diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..e348552bd9bfe410b9684a5a834dba5a58f28c3d
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,92 @@
+# GNU Makefile
+
+# Paths
+SRC_ENC = lib_enc lib_com basic_op basic_math lib_debug
+SRC_DEC = lib_dec lib_com basic_op basic_math lib_debug
+BUILD = build
+
+SRC_DIRS = $(sort -u $(SRC_ENC) $(SRC_DEC))
+
+# Name of CLI binaries
+CLI_ENC = EVS_cod
+CLI_DEC = EVS_dec
+
+# Default tool settings
+CC = gcc
+RM = rm -f
+
+ifndef VERBOSE
+QUIET_CC = @echo ' ' Compiling $<;
+QUIET_LINK= @echo ' ' Linking $@;
+QUIET = @
+endif
+
+# C compiler flags
+CFLAGS += -pedantic -Wcast-qual -Wall -W -Wextra -Wno-long-long \
+ -Wpointer-arith -Wstrict-prototypes -Wmissing-prototypes \
+ -Werror-implicit-function-declaration
+
+ifeq "$(RELEASE)" "1"
+CFLAGS += -DRELEASE
+DELIVERY = 1
+OPTIM ?= 2
+endif
+
+ifneq "$(DEBUG)" "0"
+CFLAGS += -g3
+LDFLAGS += -g3
+endif
+
+ifeq "$(WMOPS)" "1"
+CFLAGS += -DWMOPS=1
+endif
+
+OPTIM ?= 0
+CFLAGS += -O$(OPTIM)
+
+CFLAGS += $(foreach DIR,$(SRC_DIRS),-I$(DIR))
+
+# Source file search paths
+VPATH = $(SRC_DIRS)
+
+###############################################################################
+
+SRCS_ENC = $(foreach DIR,$(SRC_ENC),$(patsubst $(DIR)/%,%,$(wildcard $(DIR)/*.c)))
+SRCS_DEC = $(foreach DIR,$(SRC_DEC),$(patsubst $(DIR)/%,%,$(wildcard $(DIR)/*.c)))
+
+OBJS_ENC = $(addprefix $(BUILD)/,$(SRCS_ENC:.c=.o))
+OBJS_DEC = $(addprefix $(BUILD)/,$(SRCS_DEC:.c=.o))
+
+DEPS = $(addprefix $(BUILD)/,$(SRCS_ENC:.c=.P) $(SRCS_DEC:.c=.P))
+
+###############################################################################
+
+.PHONY: all clean clean_all
+
+all: $(CLI_ENC) $(CLI_DEC)
+
+$(BUILD):
+ $(QUIET)mkdir -p $(BUILD)
+
+$(CLI_ENC): $(OBJS_ENC)
+ $(QUIET_LINK)$(CC) $(LDFLAGS) $(OBJS_ENC) -lm -o $(CLI_ENC)
+
+$(CLI_DEC): $(OBJS_DEC)
+ $(QUIET_LINK)$(CC) $(LDFLAGS) $(OBJS_DEC) -lm -o $(CLI_DEC)
+
+clean:
+ $(QUIET)$(RM) $(OBJS_ENC) $(OBJS_DEC) $(DEPS)
+ $(QUIET)$(RM) $(DEPS:.P=.d)
+ $(QUIET)test ! -d $(BUILD) || rm -rf $(BUILD)
+
+clean_all: clean
+ $(QUIET)$(RM) $(CLI_ENC) $(CLI_DEC)
+
+$(BUILD)/%.o : %.c | $(BUILD)
+ $(QUIET_CC)$(CC) $(CFLAGS) -c -MD -o $@ $<
+ @cp $(BUILD)/$*.d $(BUILD)/$*.P; \
+ sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
+ -e '/^$$/ d' -e 's/$$/ :/' < $(BUILD)/$*.d >> $(BUILD)/$*.P; \
+ $(RM) $(BUILD)/$*.d
+
+-include $(DEPS)
diff --git a/Workspace_msvc/Workspace_msvc.sln b/Workspace_msvc/Workspace_msvc.sln
new file mode 100644
index 0000000000000000000000000000000000000000..adee19143233f0c21fa87c502971a34331556240
--- /dev/null
+++ b/Workspace_msvc/Workspace_msvc.sln
@@ -0,0 +1,39 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.26228.12
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "common", "common.vcxproj", "{39EC200D-7795-4FF8-B214-B24EDA5526AE}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "evs_dec", "evs_dec.vcxproj", "{E822DDAF-0F5F-4CD0-A694-38AE69DE74D3}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "evs_enc", "evs_enc.vcxproj", "{824DA4CF-06F0-45C9-929A-8792F0E19C3E}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib_fx", "lib_fx.vcxproj", "{52EF5F7B-DF20-4BA8-96E0-DCB4A9B3D200}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Release|Win32 = Release|Win32
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {39EC200D-7795-4FF8-B214-B24EDA5526AE}.Debug|Win32.ActiveCfg = Debug|Win32
+ {39EC200D-7795-4FF8-B214-B24EDA5526AE}.Debug|Win32.Build.0 = Debug|Win32
+ {39EC200D-7795-4FF8-B214-B24EDA5526AE}.Release|Win32.ActiveCfg = Release|Win32
+ {39EC200D-7795-4FF8-B214-B24EDA5526AE}.Release|Win32.Build.0 = Release|Win32
+ {E822DDAF-0F5F-4CD0-A694-38AE69DE74D3}.Debug|Win32.ActiveCfg = Debug|Win32
+ {E822DDAF-0F5F-4CD0-A694-38AE69DE74D3}.Debug|Win32.Build.0 = Debug|Win32
+ {E822DDAF-0F5F-4CD0-A694-38AE69DE74D3}.Release|Win32.ActiveCfg = Release|Win32
+ {E822DDAF-0F5F-4CD0-A694-38AE69DE74D3}.Release|Win32.Build.0 = Release|Win32
+ {824DA4CF-06F0-45C9-929A-8792F0E19C3E}.Debug|Win32.ActiveCfg = Debug|Win32
+ {824DA4CF-06F0-45C9-929A-8792F0E19C3E}.Debug|Win32.Build.0 = Debug|Win32
+ {824DA4CF-06F0-45C9-929A-8792F0E19C3E}.Release|Win32.ActiveCfg = Release|Win32
+ {824DA4CF-06F0-45C9-929A-8792F0E19C3E}.Release|Win32.Build.0 = Release|Win32
+ {52EF5F7B-DF20-4BA8-96E0-DCB4A9B3D200}.Debug|Win32.ActiveCfg = Debug|Win32
+ {52EF5F7B-DF20-4BA8-96E0-DCB4A9B3D200}.Debug|Win32.Build.0 = Debug|Win32
+ {52EF5F7B-DF20-4BA8-96E0-DCB4A9B3D200}.Release|Win32.ActiveCfg = Release|Win32
+ {52EF5F7B-DF20-4BA8-96E0-DCB4A9B3D200}.Release|Win32.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/Workspace_msvc/common.vcxproj b/Workspace_msvc/common.vcxproj
new file mode 100644
index 0000000000000000000000000000000000000000..946a2e096d8ec277e0b20e441e788c0dc92a6d85
--- /dev/null
+++ b/Workspace_msvc/common.vcxproj
@@ -0,0 +1,250 @@
+
+
+
+
+ Debug
+ Win32
+
+
+ Release
+ Win32
+
+
+
+ {39EC200D-7795-4FF8-B214-B24EDA5526AE}
+ common
+ 10.0
+
+
+
+ StaticLibrary
+ v142
+ false
+ MultiByte
+
+
+ StaticLibrary
+ v142
+ false
+ MultiByte
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <_ProjectFileVersion>15.0.26228.10
+
+
+ .\Debug_Common\
+ .\Debug_Common\
+
+
+ .\Release_Common\
+ .\Release_Common\
+
+
+
+ /MP %(AdditionalOptions)
+ Disabled
+ ..\lib_enc;..\lib_dec;..\lib_com;..\lib_debug;..\basic_op;..\basic_math;%(AdditionalIncludeDirectories)
+ _CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
+
+ EnableFastChecks
+ MultiThreadedDebug
+
+
+ $(IntDir)commonlib.pdb
+ Level4
+ true
+ OldStyle
+ Default
+
+
+ _DEBUG;%(PreprocessorDefinitions)
+ 0x0c0c
+
+
+ WS2_32.lib;%(AdditionalDependencies)
+ $(OutDir)$(TargetName)$(TargetExt)
+ true
+
+
+
+
+ MaxSpeed
+ OnlyExplicitInline
+ false
+ Speed
+ false
+ false
+ ..\lib_enc;..\lib_dec;..\lib_com;..\basic_op;..\basic_math;%(AdditionalIncludeDirectories)
+ _CRT_SECURE_NO_WARNINGS;RELEASE;%(PreprocessorDefinitions)
+ true
+
+ Default
+ MultiThreaded
+ true
+
+
+ $(IntDir)commonlib.pdb
+ Level4
+ true
+
+ Default
+
+
+ NDEBUG;%(PreprocessorDefinitions)
+ 0x0c0c
+
+
+ WS2_32.lib;%(AdditionalDependencies)
+ $(OutDir)$(TargetName)$(TargetExt)
+ true
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {52ef5f7b-df20-4ba8-96e0-dcb4a9b3d200}
+ false
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Workspace_msvc/evs_dec.vcxproj b/Workspace_msvc/evs_dec.vcxproj
new file mode 100644
index 0000000000000000000000000000000000000000..410ecd8d252bcc100724131045cdd890b3d04742
--- /dev/null
+++ b/Workspace_msvc/evs_dec.vcxproj
@@ -0,0 +1,294 @@
+
+
+
+
+ Debug
+ Win32
+
+
+ Release
+ Win32
+
+
+
+ {E822DDAF-0F5F-4CD0-A694-38AE69DE74D3}
+ evs_dec
+ 10.0
+
+
+
+ Application
+ v142
+ false
+ MultiByte
+
+
+ Application
+ v142
+ false
+ MultiByte
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <_ProjectFileVersion>15.0.26228.10
+
+
+ ..\
+ .\Debug_Dec\
+ false
+ false
+ EVS_dec
+
+
+ ..\
+ .\Release_Dec\
+ false
+ false
+ EVS_dec
+
+
+
+
+
+
+ .\Debug/vbr_dec.tlb
+
+
+
+ /MP %(AdditionalOptions)
+ Disabled
+ ..\lib_enc;..\lib_dec;..\lib_com;..\lib_debug;..\basic_op;..\basic_math;%(AdditionalIncludeDirectories)
+ _CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
+
+ EnableFastChecks
+ MultiThreadedDebug
+ false
+
+
+ $(IntDir)evs_dec.pdb
+ Level4
+ true
+ OldStyle
+ Default
+
+
+ _DEBUG;%(PreprocessorDefinitions)
+ 0x0c0c
+
+
+
+ ..\EVS_dec.exe
+ true
+
+ true
+ .\Debug/evs_dec.pdb
+ Console
+ false
+
+ MachineX86
+
+
+
+
+ .\Release/vbr_dec.tlb
+
+
+
+ MaxSpeed
+ OnlyExplicitInline
+ false
+ Speed
+ false
+ false
+ ..\lib_enc;..\lib_dec;..\lib_com;..\basic_op;..\basic_math;%(AdditionalIncludeDirectories)
+ _CRT_SECURE_NO_WARNINGS;RELEASE;%(PreprocessorDefinitions)
+ true
+
+ Default
+ MultiThreaded
+ true
+ false
+
+
+
+ $(IntDir)
+ $(IntDir)evs_dec.pdb
+ Level4
+ true
+
+ Default
+
+
+ NDEBUG;%(PreprocessorDefinitions)
+ 0x0c0c
+
+
+ Ws2_32.lib;%(AdditionalDependencies)
+ ..\EVS_dec.exe
+ true
+
+ false
+ .\Release/vbr_dec.pdb
+ Console
+ false
+
+ MachineX86
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {39ec200d-7795-4ff8-b214-b24eda5526ae}
+ false
+
+
+ {52ef5f7b-df20-4ba8-96e0-dcb4a9b3d200}
+ false
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Workspace_msvc/evs_enc.vcxproj b/Workspace_msvc/evs_enc.vcxproj
new file mode 100644
index 0000000000000000000000000000000000000000..7da24732f846abf975d0a69885025ca1c86e89a5
--- /dev/null
+++ b/Workspace_msvc/evs_enc.vcxproj
@@ -0,0 +1,321 @@
+
+
+
+
+ Debug
+ Win32
+
+
+ Release
+ Win32
+
+
+
+ {824DA4CF-06F0-45C9-929A-8792F0E19C3E}
+ evs_enc
+ 10.0
+
+
+
+ Application
+ v142
+ false
+ MultiByte
+
+
+ Application
+ v142
+ false
+ MultiByte
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <_ProjectFileVersion>15.0.26228.10
+
+
+ ..\
+ .\Release_Enc\
+ false
+ false
+ EVS_cod
+
+
+ ..\
+ .\Debug_Enc\
+ false
+ false
+ EVS_cod
+
+
+
+
+
+
+ .\Release/vbr_enc.tlb
+
+
+
+ MaxSpeed
+ OnlyExplicitInline
+ false
+ Speed
+ false
+ false
+ ..\lib_enc;..\lib_dec;..\lib_com;..\basic_op;..\basic_math;%(AdditionalIncludeDirectories)
+ _CRT_SECURE_NO_WARNINGS;RELEASE;%(PreprocessorDefinitions)
+ true
+
+ Default
+ MultiThreaded
+ true
+ Precise
+ false
+
+
+
+ $(IntDir)
+ $(IntDir)evs_enc.pdb
+ Level4
+ true
+
+ Default
+
+
+ NDEBUG;%(PreprocessorDefinitions)
+ 0x0c0c
+
+
+ Ws2_32.lib;%(AdditionalDependencies)
+ ..\EVS_cod.exe
+ true
+
+ false
+ .\Release/vbr_enc.pdb
+ Console
+ false
+
+ MachineX86
+
+
+
+
+
+
+
+ .\Debug/vbr_enc.tlb
+
+
+
+ /MP %(AdditionalOptions)
+ Disabled
+ ..\lib_enc;..\lib_dec;..\lib_com;..\lib_debug;..\basic_op;..\basic_math;%(AdditionalIncludeDirectories)
+ _CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
+
+ EnableFastChecks
+ MultiThreadedDebug
+ false
+
+
+ $(IntDir)evs_enc.pdb
+ true
+ Level4
+ true
+ OldStyle
+ Default
+
+
+ _DEBUG;%(PreprocessorDefinitions)
+ 0x0c0c
+
+
+
+ ..\EVS_cod.exe
+ true
+
+ false
+ true
+ .\Debug/evs_enc.pdb
+ Console
+
+ false
+
+ MachineX86
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {39ec200d-7795-4ff8-b214-b24eda5526ae}
+ false
+
+
+ {52ef5f7b-df20-4ba8-96e0-dcb4a9b3d200}
+ false
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Workspace_msvc/lib_fx.vcxproj b/Workspace_msvc/lib_fx.vcxproj
new file mode 100644
index 0000000000000000000000000000000000000000..c05eb8e87cbb298b1408362eff4ac6baf1f9ba40
--- /dev/null
+++ b/Workspace_msvc/lib_fx.vcxproj
@@ -0,0 +1,126 @@
+
+
+
+
+ Debug
+ Win32
+
+
+ Release
+ Win32
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {52EF5F7B-DF20-4BA8-96E0-DCB4A9B3D200}
+ lib_fx
+ 10.0
+
+
+
+ StaticLibrary
+ v142
+ MultiByte
+ true
+
+
+ StaticLibrary
+ v142
+ MultiByte
+
+
+
+
+
+
+
+
+
+
+
+
+ <_ProjectFileVersion>15.0.26228.10
+
+
+ .\Debug_Fx\
+ .\Debug_Fx\
+
+
+ .\Release_Fx\
+ .\Release_Fx\
+
+
+
+ /MP %(AdditionalOptions)
+ Disabled
+ ..\lib_enc;..\lib_dec;..\lib_com;..\lib_debug;..\basic_op;..\basic_math;%(AdditionalIncludeDirectories)
+ _CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
+ EnableFastChecks
+ MultiThreadedDebug
+ $(IntDir)lib_fixlib.pdb
+ Level3
+ OldStyle
+ Default
+
+
+
+
+ MaxSpeed
+ false
+ false
+ ..\lib_enc;..\lib_dec;..\lib_com;..\basic_op;..\basic_math;%(AdditionalIncludeDirectories)
+ _CRT_SECURE_NO_WARNINGS;RELEASE;%(PreprocessorDefinitions)
+ true
+ Default
+ MultiThreaded
+ true
+ $(IntDir)lib_fixlib.pdb
+ Level3
+ ProgramDatabase
+ Default
+ Speed
+
+
+
+
+
+
\ No newline at end of file
diff --git a/basic_math/log2.c b/basic_math/log2.c
new file mode 100644
index 0000000000000000000000000000000000000000..57abb3352b34e9bb9fd50235cc1a805c41e4b313
--- /dev/null
+++ b/basic_math/log2.c
@@ -0,0 +1,211 @@
+/********************************************************************************
+*
+* File : log2.c
+* Purpose : Computes log2(L_x)
+*
+********************************************************************************
+*/
+
+/*
+********************************************************************************
+* INCLUDE FILES
+********************************************************************************
+*/
+#include "stl.h"
+#include "math_op.h"
+#include
+#include "rom_basic_math.h"
+#include "options.h"
+
+#define LW_SIGN (Word32)0x80000000 /* sign bit */
+#define LW_MIN (Word32)0x80000000
+#define LW_MAX (Word32)0x7fffffff
+
+#define SW_SIGN (Word16)0x8000 /* sign bit for Word16 type */
+#define SW_MIN (Word16)0x8000 /* smallest Ram */
+#define SW_MAX (Word16)0x7fff /* largest Ram */
+
+
+/*
+********************************************************************************
+* PUBLIC PROGRAM CODE
+********************************************************************************
+*/
+
+/*************************************************************************
+ *
+ * FUNCTION: Log2_norm_lc()
+ *
+ * PURPOSE: Computes log2(L_x, exp), where L_x is positive and
+ * normalized, and exp is the normalisation exponent
+ * If L_x is negative or zero, the result is 0.
+ *
+ * DESCRIPTION:
+ * The function Log2(L_x) is approximated by a table and linear
+ * interpolation. The following steps are used to compute Log2(L_x)
+ *
+ * 1- exponent = 30-norm_exponent
+ * 2- i = bit25-b31 of L_x; 32<=i<=63 (because of normalization).
+ * 3- a = bit10-b24
+ * 4- i -=32
+ * 5- fraction = table[i]<<16 - (table[i] - table[i+1]) * a * 2
+ *
+ *************************************************************************/
+Word16 Log2_norm_lc ( /* (o) : Fractional part of Log2. (range: 0<=val<1) */
+ Word32 L_x /* (i) : input value (normalized) */
+)
+{
+ Word16 i, a;
+ Word16 y;
+
+ if (L_x <= 0)
+ L_x = L_deposit_h(0x4000);
+
+ L_x = L_shr (L_x, 9);
+ a = extract_l (L_x); /* Extract b10-b24 of fraction */
+ a = lshr(a, 1);
+
+ i = mac_r(L_x, -32*2-1, 16384); /* Extract b25-b31 minus 32 */
+
+ y = mac_r(L_table_Log2_norm_lc[i], table_diff_Log2_norm_lc[i], a); /* table[i] << 16 - diff*a*2 */
+
+ return y;
+}
+
+Word32 log10_fx(Word32 Linput)
+{
+ Word16 n1, frac, p1, p2, q1;
+ Word32 Ltemp1, Ltemp2;
+ Word32 L_tmp;
+
+ if (Linput<=0) return(LW_MIN);
+ n1=norm_l(Linput);
+ Ltemp1=(Word32)L_shl(Linput,n1);
+
+ Ltemp2=L_mult(extract_h(Ltemp1),0x40);
+ frac=extract_l(Ltemp2);
+
+ p1=log2_tab[sub(extract_h(Ltemp2),0x20)];
+ p2=log2_tab[sub(extract_h(Ltemp2),0x1F)];
+ Ltemp2=L_mult(n1,0x200);
+ n1=extract_l(Ltemp2);
+
+ Ltemp1=L_add(L_deposit_h(p1),0x8000); /* Add rounding bit */
+
+ IF(frac >= 0)
+ {
+ Ltemp1=L_sub(Ltemp1,(Word32)L_mult0(p1,frac));
+ Ltemp1=L_add(Ltemp1,(Word32)L_mult0(p2,frac));
+ }
+ ELSE
+ {
+ L_tmp = L_add(65536,frac);
+ L_tmp = L_tmp*p1;
+ Ltemp1=L_sub(Ltemp1,L_tmp);
+
+ L_tmp = L_add(65536,frac);
+ L_tmp = L_tmp*p2;
+ Ltemp1=L_add(Ltemp1,L_tmp);
+ }
+ q1=extract_h(Ltemp1);
+ Ltemp1=L_mult(q1,0x6054);
+ Ltemp1=L_msu(Ltemp1,0x6054,n1);
+ return(L_shr(Ltemp1,1));
+
+}
+
+Word32 pow_10(Word32 x , Word16 *Q)
+{
+ Word16 xl,xh, t1, t2, n;
+ Word32 Ltemp1;
+ Word32 Lacc;
+ Word32 L_tmp;
+ Word16 n1,i;
+ Word16 count = 0;
+
+ move16();;
+
+ xl=extract_l(x);
+ xh=extract_h(x);
+
+ IF(xl < 0)
+ {
+ L_tmp = L_add(65536,xl);
+ Ltemp1=(Word32) (0x6a4d*L_tmp );
+ }
+ ELSE
+ {
+ Ltemp1=L_mult0(0x6a4d,xl);
+ }
+ Ltemp1=L_add(L_shr(Ltemp1,16),L_shr(L_mult(xh,0x6a4d),1));
+
+
+ Lacc=L_sub(-1L, Ltemp1); /* Lacc=~Lacc, 1's complement */
+ t1=extract_l(L_shr(Lacc,7));
+
+ Ltemp1=L_shr(Ltemp1,7);
+ n1 = extract_h(Ltemp1);
+ n=sub(n1,14);
+ *Q = 14; move16();
+ IF(t1<0)
+ {
+ L_tmp = L_add(65536,t1);
+ t2=extract_h(L_tmp*L_tmp);
+ }
+ ELSE
+ {
+ t2=extract_h(L_mult0(t1,t1));
+ }
+
+ Lacc = L_deposit_h(0x1FEF);
+ IF(t2 < 0)
+ {
+ L_tmp = L_add(65536,t2);
+ Lacc = L_add(Lacc,(Word32)(L_tmp*0x057C));
+ }
+ ELSE
+ {
+ Lacc = L_add(Lacc,(Word32)L_mult0(t2,0x057C));
+ }
+
+ IF(t1 < 0)
+ {
+ L_tmp = L_add(65536,t1);
+ Lacc = L_sub(Lacc,(Word32)(L_tmp*0x155C));
+ }
+ ELSE
+ {
+ Lacc = L_sub(Lacc,(Word32)L_mult0(t1,0x155C));
+ }
+
+ L_tmp = Lacc;
+ FOR(i =1 ;i <= n ;i++)
+ {
+ Overflow = 0; move16();
+ L_tmp = L_shl(L_tmp,i);
+ IF(Overflow)
+ {
+ count = add(count,1);
+ }
+ }
+ *Q = sub(*Q,count); move16();
+
+ return(L_shl(Lacc,sub(n,count)));
+
+}
+
+Word16 Log2_lc( /* (o) : Fractional part of Log2. (range: 0<=val<1) */
+ Word32 L_x, /* (i) : input value */
+ Word16 *exponent /* (o) : Integer part of Log2. (range: 0<=val<=30) */
+)
+{
+ Word16 exp;
+
+ if (L_x <= 0)
+ L_x = L_deposit_l(0x1);
+
+ exp = norm_l (L_x);
+ *exponent = sub(30, exp); move16();
+
+ return Log2_norm_lc(L_shl(L_x, exp));
+}
diff --git a/basic_math/log2.h b/basic_math/log2.h
new file mode 100644
index 0000000000000000000000000000000000000000..a8ff32e657ffa5008e1dc24b51779acd94127dbc
--- /dev/null
+++ b/basic_math/log2.h
@@ -0,0 +1,40 @@
+/********************************************************************************
+*
+* File : log2.h
+* Purpose : Computes log2(L_x)
+*
+********************************************************************************
+*/
+#ifndef log2_h
+#define log2_h "$Id $"
+
+/*
+********************************************************************************
+* INCLUDE FILES
+********************************************************************************
+*/
+#include "typedef.h"
+#include "log2.h"
+
+/*
+********************************************************************************
+* DEFINITION OF DATA TYPES
+********************************************************************************
+*/
+
+/*
+********************************************************************************
+* DECLARATION OF PROTOTYPES
+********************************************************************************
+*/
+Word16 Log2_norm_lc ( /* (o) : Fractional part of Log2. (range: 0<=val<1) */
+ Word32 L_x /* (i) : input value (normalized) */
+);
+
+Word32 log10_fx(Word32 Linput);
+Word32 pow_10(Word32 x, Word16 *Q);
+Word16 Log2_lc( /* (o) : Fractional part of Log2. (range: 0<=val<1) */
+ Word32 L_x, /* (i) : input value */
+ Word16 *exponent /* (o) : Integer part of Log2. (range: 0<=val<=30) */
+);
+#endif
diff --git a/basic_math/math_32.h b/basic_math/math_32.h
new file mode 100644
index 0000000000000000000000000000000000000000..539284d5a28e25aee9cb74576ca9c14c35b7593c
--- /dev/null
+++ b/basic_math/math_32.h
@@ -0,0 +1,10 @@
+#ifndef _MATH_32_H_
+#define _MATH_32_H_
+
+#include "typedef.h"
+#include "basop32.h"
+#include "enh32.h"
+
+#define Mult_32_16(A,B) Mpy_32_16_1(A,B)
+#define Mult_32_32(A,B) Mpy_32_32(A,B)
+#endif /* #ifndef _MATH_32_H_ */
diff --git a/basic_math/math_op.c b/basic_math/math_op.c
new file mode 100644
index 0000000000000000000000000000000000000000..a5256a2af9156d59267cbf43509f2e4044f8a175
--- /dev/null
+++ b/basic_math/math_op.c
@@ -0,0 +1,359 @@
+/*___________________________________________________________________________
+ | |
+ | This file contains mathematic operations in fixed point. |
+ | |
+ | Isqrt() : inverse square root (16 bits precision). |
+ | Pow2() : 2^x (16 bits precision). |
+ | Log2() : log2 (16 bits precision). |
+ | Dot_product() : scalar product of |
+ | |
+ | In this file, the values use theses representations: |
+ | |
+ | Word32 L_32 : standard signed 32 bits format |
+ | Word16 hi, lo : L_32 = hi<<16 + lo<<1 (DPF - Double Precision Format) |
+ | Word32 frac, Word16 exp : L_32 = frac << exp-31 (normalised format) |
+ | Word16 int, frac : L_32 = int.frac (fractional format) |
+ |___________________________________________________________________________|
+*/
+
+#include "stl.h"
+#include "math_op.h"
+#include "rom_basic_math.h"
+
+#include
+#include
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : Isqrt |
+ | |
+ | Compute 1/sqrt(L_x). |
+ | if L_x is negative or zero, result is 1 (7fffffff). |
+ |---------------------------------------------------------------------------|
+ | Algorithm: |
+ | |
+ | 1- Normalization of L_x. |
+ | 2- call Isqrt_lc(L_x, exponant) |
+ | 3- L_y = L_x << exponant |
+ |___________________________________________________________________________|
+*/
+Word32 Isqrt( /* (o) Q31 : output value (range: 0<=val<1) */
+ Word32 L_x /* (i) Q0 : input value (range: 0<=val<=7fffffff) */
+)
+{
+ Word16 exp;
+ Word32 L_y;
+
+ exp = norm_l(L_x);
+ L_x = L_shl(L_x, exp); /* L_x is normalized */
+ exp = sub(31, exp);
+
+ L_x = Isqrt_lc(L_x, &exp);
+
+ L_y = L_shl(L_x, exp); /* denormalization */
+
+ return (L_y);
+}
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : Isqrt_lc |
+ | |
+ | Compute 1/sqrt(value). |
+ | if value is negative or zero, result is 1 (frac=7fffffff, exp=0). |
+ |---------------------------------------------------------------------------|
+ | Algorithm: |
+ | |
+ | The function 1/sqrt(value) is approximated by a table and linear |
+ | interpolation. |
+ | |
+ | 1- If exponant is odd then shift fraction right once. |
+ | 2- exponant = -((exponant-1)>>1) |
+ | 3- i = bit25-b30 of fraction, 16 <= i <= 63 ->because of normalization. |
+ | 4- a = bit10-b24 |
+ | 5- i -=16 |
+ | 6- fraction = table[i]<<16 - (table[i] - table[i+1]) * a * 2 |
+ |___________________________________________________________________________|
+*/
+Word32 Isqrt_lc(
+ Word32 frac, /* (i) Q31: normalized value (1.0 < frac <= 0.5) */
+ Word16 * exp /* (i/o) : exponent (value = frac x 2^exponent) */
+)
+{
+ Word16 i, a;
+ Word32 L_tmp;
+
+ IF (frac <= (Word32) 0)
+ {
+ *exp = 0; move16();
+ return 0x7fffffff; /*0x7fffffff*/
+ }
+
+ /* If exponant odd -> shift right by 10 (otherwise 9) */
+ L_tmp = L_shr(frac, shift_Isqrt_lc[s_and(*exp, 1)]);
+
+ /* 1) -16384 to shift left and change sign */
+ /* 2) 32768 to Add 1 to Exponent like it was divided by 2 */
+ /* 3) We let the mac_r add another 0.5 because it imitates */
+ /* the behavior of shr on negative number that should */
+ /* not be rounded towards negative infinity. */
+ /* It replaces: */
+ /* *exp = negate(shr(sub(*exp, 1), 1)); move16(); */
+ *exp = mac_r(32768, *exp, -16384); move16();
+
+ a = extract_l(L_tmp); /* Extract b10-b24 */
+ a = lshr(a, 1);
+
+ i = mac_r(L_tmp, -16*2-1, 16384); /* Extract b25-b31 minus 16 */
+
+ L_tmp = L_msu(L_table_isqrt[i], table_isqrt_diff[i], a);/* table[i] << 16 - diff*a*2 */
+
+ return L_tmp;
+}
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : Pow2() |
+ | |
+ | L_x = pow(2.0, exponant.fraction) (exponant = interger part) |
+ | = pow(2.0, 0.fraction) << exponant |
+ |---------------------------------------------------------------------------|
+ | Algorithm: |
+ | |
+ | The function Pow2(L_x) is approximated by a table and linear |
+ | interpolation. |
+ | |
+ | 1- i = bit10-b15 of fraction, 0 <= i <= 31 |
+ | 2- a = bit0-b9 of fraction |
+ | 3- L_x = table[i]<<16 - (table[i] - table[i+1]) * a * 2 |
+ | 4- L_x = L_x >> (30-exponant) (with rounding) |
+ |___________________________________________________________________________|
+*/
+
+Word32 Pow2( /* (o) Q0 : result (range: 0<=val<=0x7fffffff) */
+ Word16 exponant, /* (i) Q0 : Integer part. (range: 0<=val<=30) */
+ Word16 fraction /* (i) Q15 : Fractionnal part. (range: 0.0<=val<1.0) */
+)
+{
+ Word16 exp, i, a;
+ Word32 L_x;
+
+
+
+ i = mac_r(-32768, fraction, 32); /* Extract b10-b16 of fraction */
+ a = s_and(fraction, 0x3ff); /* Extract b0-b9 of fraction */
+
+ L_x = L_deposit_h(table_pow2[i]); /* table[i] << 16 */
+ L_x = L_mac(L_x, table_pow2_diff_x32[i], a);/* L_x -= diff*a*2 */
+
+ exp = sub(30, exponant);
+
+ L_x = L_shr_r(L_x, exp);
+
+
+ return L_x;
+}
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : Dot_product12() |
+ | |
+ | Compute scalar product of using accumulator. |
+ | |
+ | The result is normalized (in Q31) with exponent (0..30). |
+ |---------------------------------------------------------------------------|
+ | Algorithm: |
+ | |
+ | dot_product = sum(x[i]*y[i]) i=0..N-1 |
+ |___________________________________________________________________________|
+*/
+
+Word32 Dot_product12( /* (o) Q31: normalized result (1 < val <= -1) */
+ const Word16 x[], /* (i) 12bits: x vector */
+ const Word16 y[], /* (i) 12bits: y vector */
+ const Word16 lg, /* (i) : vector length */
+ Word16 * exp /* (o) : exponent of result (0..+30) */
+)
+{
+ Word16 i, sft;
+ Word32 L_sum;
+
+ L_sum = L_mac(1, x[0], y[0]);
+ FOR (i = 1; i < lg; i++)
+ L_sum = L_mac(L_sum, x[i], y[i]);
+
+ /* Normalize acc in Q31 */
+
+ sft = norm_l(L_sum);
+ L_sum = L_shl(L_sum, sft);
+
+ *exp = sub(30, sft); move16(); /* exponent = 0..30 */
+
+ return L_sum;
+}
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : Energy_scale() |
+ | |
+ | Compute energy of signal (scaling the input if specified) |
+ | |
+ | The result is normalized (in Q31) with exponent (0..30). |
+ |___________________________________________________________________________|
+*/
+
+Word32 Energy_scale( /* (o) : Q31: normalized result (1 < val <= -1) */
+ const Word16 x[], /* (i) : input vector x */
+ const Word16 lg, /* (i) : vector length */
+ Word16 expi, /* (i) : exponent of input */
+ Word16 *exp /* (o) : exponent of result (0..+30) */
+)
+{
+ Word16 i, sft, tmp;
+ Word32 L_sum;
+
+
+ L_sum = 0; /* just to avoid superflous compiler warning about uninitialized use of L_sum */
+
+ IF (expi == 0)
+ {
+ L_sum = L_mac(1, x[0], x[0]);
+ FOR (i = 1; i < lg; i++)
+ {
+ L_sum = L_mac(L_sum, x[i], x[i]);
+ }
+ }
+ IF (expi < 0)
+ {
+ sft = lshl(-32768 /* 0x8000 */, expi);
+ tmp = mult_r(x[0], sft);
+ L_sum = L_mac(1, tmp, tmp);
+ FOR (i = 1; i < lg; i++)
+ {
+ tmp = mult_r(x[i], sft);
+ L_sum = L_mac(L_sum, tmp, tmp);
+ }
+ }
+ IF (expi > 0)
+ {
+ tmp = shl(x[0], expi);
+ L_sum = L_mac(1, tmp, tmp);
+ FOR (i = 1; i < lg; i++)
+ {
+ tmp = shl(x[i], expi);
+ L_sum = L_mac(L_sum, tmp, tmp);
+ }
+ }
+
+ /* Normalize acc in Q31 */
+
+ sft = norm_l(L_sum);
+ L_sum = L_shl(L_sum, sft);
+
+ *exp = sub(30, sft); move16(); /* exponent = 0..30 */
+
+
+ return L_sum;
+}
+
+Word32 Sqrt_l( /* o : output value, Q31 */
+ Word32 L_x, /* i : input value, Q31 */
+ Word16 *exp /* o : right shift to be applied to result, Q1 */
+)
+{
+ /*
+ y = sqrt(x)
+
+ x = f * 2^-e, 0.5 <= f < 1 (normalization)
+
+ y = sqrt(f) * 2^(-e/2)
+
+ a) e = 2k --> y = sqrt(f) * 2^-k (k = e div 2,
+ 0.707 <= sqrt(f) < 1)
+ b) e = 2k+1 --> y = sqrt(f/2) * 2^-k (k = e div 2,
+ 0.5 <= sqrt(f/2) < 0.707)
+ */
+
+ Word16 e, i, a, tmp;
+ Word32 L_y;
+
+ if (L_x <= 0)
+ {
+ *exp = 0; move16 ();
+ return L_deposit_l(0);
+ }
+
+ e = s_and(norm_l(L_x), 0x7FFE); /* get next lower EVEN norm. exp */
+ L_x = L_shl(L_x, e); /* L_x is normalized to [0.25..1) */
+ *exp = e; move16 (); /* return 2*exponent (or Q1) */
+
+ L_x = L_shr(L_x, 9);
+ a = extract_l(L_x); /* Extract b10-b24 */
+ a = lshr(a, 1);
+
+ i = mac_r(L_x, -16*2-1, 16384); /* Extract b25-b31 minus 16 */
+
+ L_y = L_deposit_h(sqrt_table[i]); /* table[i] << 16 */
+ tmp = sub(sqrt_table[i], sqrt_table[i + 1]); /* table[i] - table[i+1]) */
+ L_y = L_msu(L_y, tmp, a); /* L_y -= tmp*a*2 */
+
+ /* L_y = L_shr (L_y, *exp); */ /* denormalization done by caller */
+
+ return (L_y);
+}
+
+/*---------------------------------------------------------------------------*
+ * L_Frac_sqrtQ31
+ *
+ * Calculate square root from fractional values (Q31 -> Q31)
+ * Uses 32 bit internal representation for precision
+ *---------------------------------------------------------------------------*/
+Word32 L_Frac_sqrtQ31( /* o : Square root if input */
+ const Word32 x /* i : Input */
+)
+{
+ Word32 log2_work;
+ Word16 log2_int, log2_frac;
+
+ test();
+ if (x > 0)
+ {
+ log2_int = norm_l(x);
+ log2_frac = Log2_norm_lc(L_shl(x, log2_int));
+
+ log2_work = L_msu((31+30)*65536L/2, 16384, log2_int);
+ log2_work = L_mac0(log2_work, log2_frac, 1);
+
+ log2_frac = L_Extract_lc(log2_work, &log2_int);
+
+ return Pow2(log2_int, log2_frac);
+ }
+ return 0;
+}
+
+/*----------------------------------------------------------------------------------*
+ * Frac_sqrt
+ *
+ * Calculate square root from fractional values (Q15 -> Q15)
+ *----------------------------------------------------------------------------------*/
+Word16 Frac_sqrt( /* o : Square root if input */
+ const Word16 x /* i : Input */
+)
+{
+ return round_fx(L_Frac_sqrtQ31(L_deposit_h(x)));
+}
+
+
+/*----------------------------------------------------------------------------------*
+ * i_mult2
+ *
+ * Faster Integer Multiplication
+ *----------------------------------------------------------------------------------*/
+
+Word16 i_mult2 (Word16 a, Word16 b)
+{
+ return extract_l(L_mult0(a, b));
+}
+
+
+
diff --git a/basic_math/math_op.h b/basic_math/math_op.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a17485f44bf97100532c04ea68506b7c370b66e
--- /dev/null
+++ b/basic_math/math_op.h
@@ -0,0 +1,48 @@
+/*--------------------------------------------------------------------------*
+ * MATH_OP.H *
+ *--------------------------------------------------------------------------*
+ * Mathematical operations *
+ *--------------------------------------------------------------------------*/
+#include "oper_32b.h"
+#include "log2.h"
+
+Word32 Isqrt( /* (o) Q31 : output value (range: 0<=val<1) */
+ Word32 L_x /* (i) Q0 : input value (range: 0<=val<=7fffffff) */
+);
+Word32 Isqrt_lc(
+ Word32 frac, /* (i/o) Q31: normalized value (1.0 < frac <= 0.5) */
+ Word16 * exp /* (i/o) : exponent (value = frac x 2^exponent) */
+);
+
+Word32 Pow2( /* (o) Q0 : result (range: 0<=val<=0x7fffffff) */
+ Word16 exponant, /* (i) Q0 : Integer part. (range: 0<=val<=30) */
+ Word16 fraction /* (i) Q15 : Fractionnal part. (range: 0.0<=val<1.0) */
+);
+Word32 Dot_product12( /* (o) Q31: normalized result (1 < val <= -1) */
+ const Word16 x[], /* (i) 12bits: x vector */
+ const Word16 y[], /* (i) 12bits: y vector */
+ const Word16 lg, /* (i) : vector length */
+ Word16 * exp /* (o) : exponent of result (0..+30) */
+);
+
+Word32 Energy_scale( /* (o) Q31: normalized result (1 < val <= -1) */
+ const Word16 x[], /* (i) 12bits: x vector */
+ const Word16 lg, /* (i) : vector length */
+ Word16 expi, /* (i) : exponent of input */
+ Word16 *exp /* (o) : exponent of result (0..+30) */
+);
+
+Word32 Sqrt_l(Word32 L_x, Word16 *exp);
+
+Word32 L_Frac_sqrtQ31( /* o : Square root if input */
+ const Word32 x /* i : Input */
+);
+
+Word16 Frac_sqrt( /* o : Square root if input */
+ const Word16 x /* i : Input */
+);
+
+Word16 i_mult2 (Word16 a, Word16 b);
+
+#include "math_32.h"
+
diff --git a/basic_math/oper_32b.c b/basic_math/oper_32b.c
new file mode 100644
index 0000000000000000000000000000000000000000..1904cdd882a56674be5451ef68035e8cf1287aac
--- /dev/null
+++ b/basic_math/oper_32b.c
@@ -0,0 +1,381 @@
+/*****************************************************************************
+ * $Id: oper_32b.c 1094 2014-02-10 17:12:11Z jdr $
+ *
+ * This file contains operations in double precision. *
+ * These operations are not standard double precision operations. *
+ * They are used where single precision is not enough but the full 32 bits *
+ * precision is not necessary. For example, the function Div_32() has a *
+ * 24 bits precision which is enough for our purposes. *
+ * *
+ * The double precision numbers use a special representation: *
+ * *
+ * L_32 = hi<<16 + lo<<1 *
+ * *
+ * L_32 is a 32 bit integer. *
+ * hi and lo are 16 bit signed integers. *
+ * As the low part also contains the sign, this allows fast multiplication. *
+ * *
+ * 0x8000 0000 <= L_32 <= 0x7fff fffe. *
+ * *
+ * We will use DPF (Double Precision Format) in this file to specify *
+ * this special format. *
+ *****************************************************************************
+*/
+
+#include "stl.h"
+#include "math_op.h"
+
+/*****************************************************************************
+ * *
+ * Function L_Extract() *
+ * *
+ * Extract from a 32 bit integer two 16 bit DPF. *
+ * *
+ * Arguments: *
+ * *
+ * L_32 : 32 bit integer. *
+ * 0x8000 0000 <= L_32 <= 0x7fff ffff. *
+ * hi : b16 to b31 of L_32 *
+ * lo : (L_32 - hi<<16)>>1 *
+ *****************************************************************************
+*/
+
+void L_Extract (Word32 L_32, Word16 *hi, Word16 *lo)
+{
+ *hi = extract_h (L_32);
+ *lo = extract_l (L_msu (L_shr (L_32, 1), *hi, 16384));
+ return;
+}
+
+/*****************************************************************************
+ * *
+ * Function L_Extract_lc() *
+ * *
+ * Extract from a 32 bit integer two 16 bit DPF. *
+ * (lo is returned, store to memory is not accounted for) *
+ * *
+ * Arguments: *
+ * *
+ * L_32 : 32 bit integer. *
+ * 0x8000 0000 <= L_32 <= 0x7fff ffff. *
+ * hi : b16 to b31 of L_32 *
+ * lo : (L_32 - hi<<16)>>1 *
+ *****************************************************************************
+*/
+
+Word16 L_Extract_lc (Word32 L_32, Word16 *hi)
+{
+ *hi = extract_h (L_32);
+
+ return lshr(extract_l(L_32), 1);
+}
+
+/*****************************************************************************
+ * *
+ * Function L_Comp() *
+ * *
+ * Compose from two 16 bit DPF a 32 bit integer. *
+ * *
+ * L_32 = hi<<16 + lo<<1 *
+ * *
+ * Arguments: *
+ * *
+ * hi msb *
+ * lo lsf (with sign) *
+ * *
+ * Return Value : *
+ * *
+ * 32 bit long signed integer (Word32) whose value falls in the *
+ * range : 0x8000 0000 <= L_32 <= 0x7fff fff0. *
+ * *
+ *****************************************************************************
+*/
+
+Word32 L_Comp (Word16 hi, Word16 lo)
+{
+ Word32 L_32;
+
+ L_32 = L_deposit_h (hi);
+ return (L_mac (L_32, lo, 1)); /* = hi<<16 + lo<<1 */
+}
+
+/*****************************************************************************
+ * Function Mpy_32() *
+ * *
+ * Multiply two 32 bit integers (DPF). The result is divided by 2**31 *
+ * *
+ * L_32 = (hi1*hi2)<<1 + ( (hi1*lo2)>>15 + (lo1*hi2)>>15 )<<1 *
+ * *
+ * This operation can also be viewed as the multiplication of two Q31 *
+ * number and the result is also in Q31. *
+ * *
+ * Arguments: *
+ * *
+ * hi1 hi part of first number *
+ * lo1 lo part of first number *
+ * hi2 hi part of second number *
+ * lo2 lo part of second number *
+ * *
+ *****************************************************************************
+*/
+
+Word32 Mpy_32 (Word16 hi1, Word16 lo1, Word16 hi2, Word16 lo2)
+{
+ Word32 L_32;
+
+ L_32 = L_mult (hi1, hi2);
+ L_32 = L_mac (L_32, mult (hi1, lo2), 1);
+ L_32 = L_mac (L_32, mult (lo1, hi2), 1);
+
+ return (L_32);
+}
+
+/*****************************************************************************
+ * Function Mac_32() *
+ * *
+ * Multiply two 32 bit integers (DPF). The result is divided by 2**31 *
+ * Adds a 32 bit integer (non DFP) *
+ * *
+ * L_32 = L_num + (hi1*hi2)<<1 + ( (hi1*lo2)>>15 + (lo1*hi2)>>15 )<<1 *
+ * *
+ * This operation can also be viewed as the multiplication of two Q31 *
+ * number and the result is also in Q31. *
+ * *
+ * Arguments: *
+ * *
+ * hi1 hi part of first number *
+ * lo1 lo part of first number *
+ * hi2 hi part of second number *
+ * lo2 lo part of second number *
+ * *
+ *****************************************************************************
+*/
+
+Word32 Mac_32 (Word32 L_num, Word16 hi1, Word16 lo1, Word16 hi2, Word16 lo2)
+{
+ Word32 L_32;
+
+ L_32 = L_mac (L_num, hi1, hi2);
+ L_32 = L_mac (L_32, mult (hi1, lo2), 1);
+ L_32 = L_mac (L_32, mult (lo1, hi2), 1);
+
+ return (L_32);
+}
+
+/*****************************************************************************
+ * Function Sqr_32() *
+ * *
+ * Square one 32 bit integer (DPF). The result is divided by 2**31 *
+ * *
+ * L_32 = (hi*hi)<<1 + ( (hi*lo)>>15 *2)<<1 *
+ * *
+ * This operation can also be viewed as the square of one Q31 *
+ * number and the result is also in Q31. *
+ * *
+ * Arguments: *
+ * *
+ * hi1 hi part of first number *
+ * lo1 lo part of first number *
+ * hi2 hi part of second number *
+ * lo2 lo part of second number *
+ * *
+ *****************************************************************************
+*/
+
+Word32 Sqr_32 (Word16 hi, Word16 lo)
+{
+ Word32 L_32;
+
+ L_32 = L_mult (hi, hi);
+ L_32 = L_mac (L_32, mult (hi, lo), 2);
+
+ return (L_32);
+}
+
+/*****************************************************************************
+ * Function Sad_32() *
+ * *
+ * Square one 32 bit integer (DPF). The result is divided by 2**31 *
+ * Adds a 32 bit integer (non DFP) *
+ * *
+ * L_32 = L_num + (hi*hi)<<1 + ( (hi*lo)>>15 *2)<<1 *
+ * *
+ * This operation can also be viewed as the square of one Q31 *
+ * number and the result is also in Q31. *
+ * *
+ * Arguments: *
+ * *
+ * hi1 hi part of first number *
+ * lo1 lo part of first number *
+ * hi2 hi part of second number *
+ * lo2 lo part of second number *
+ * *
+ *****************************************************************************
+*/
+
+Word32 Sad_32 (Word32 L_num, Word16 hi, Word16 lo)
+{
+ Word32 L_32;
+
+ L_32 = L_mac (L_num, hi, hi);
+ L_32 = L_mac (L_32, mult (hi, lo), 2);
+
+ return (L_32);
+}
+
+/*****************************************************************************
+ * Function Mpy_32_16() *
+ * *
+ * Multiply a 16 bit integer by a 32 bit (DPF). The result is divided *
+ * by 2**15 *
+ * *
+ * *
+ * L_32 = (hi1*lo2)<<1 + ((lo1*lo2)>>15)<<1 *
+ * *
+ * Arguments: *
+ * *
+ * hi hi part of 32 bit number. *
+ * lo lo part of 32 bit number. *
+ * n 16 bit number. *
+ * *
+ *****************************************************************************
+*/
+
+Word32 Mpy_32_16 (Word16 hi, Word16 lo, Word16 n)
+{
+ Word32 L_32;
+
+ L_32 = L_mult (hi, n);
+ L_32 = L_mac (L_32, mult (lo, n), 1);
+
+ return (L_32);
+}
+
+/*****************************************************************************
+ * Function Mac_32_16() *
+ * *
+ * Multiply a 16 bit integer by a 32 bit (DPF). The result is divided *
+ * by 2**15 *
+ * Adds a 32 bit integer (non DFP) *
+ * *
+ * *
+ * L_32 = L_num + (hi1*lo2)<<1 + ((lo1*lo2)>>15)<<1 *
+ * *
+ * Arguments: *
+ * *
+ * L_num 32 bit long signed integer (Word32) *
+ * hi hi part of 32 bit number. *
+ * lo lo part of 32 bit number. *
+ * n 16 bit number. *
+ * *
+ *****************************************************************************
+*/
+
+Word32 Mac_32_16 (Word32 L_num, Word16 hi, Word16 lo, Word16 n)
+{
+ Word32 L_32;
+
+ L_32 = L_mac (L_num, hi, n);
+ L_32 = L_mac (L_32, mult (lo, n), 1);
+
+ return (L_32);
+}
+
+/*****************************************************************************
+ * Function Msu_32_16() *
+ * *
+ * Substract a 32 bit integer (non DFP) *
+ * Multiply a 16 bit integer by a 32 bit (DPF). The result is divided *
+ * by 2**15 *
+ * *
+ * *
+ * L_32 = L_num - (hi1*lo2)<<1 + ((lo1*lo2)>>15)<<1 *
+ * *
+ * Arguments: *
+ * *
+ * L_num 32 bit long signed integer (Word32) *
+ * hi hi part of 32 bit number. *
+ * lo lo part of 32 bit number. *
+ * n 16 bit number. *
+ * *
+ *****************************************************************************
+*/
+
+Word32 Msu_32_16 (Word32 L_num, Word16 hi, Word16 lo, Word16 n)
+{
+ Word32 L_32;
+
+ L_32 = L_msu (L_num, hi, n);
+ L_32 = L_msu (L_32, mult (lo, n), 1);
+
+ return (L_32);
+}
+
+/*****************************************************************************
+ * *
+ * Function Name : Div_32 *
+ * *
+ * Purpose : *
+ * Fractional integer division of two 32 bit numbers. *
+ * L_num / L_denom. *
+ * L_num and L_denom must be positive and L_num < L_denom. *
+ * L_denom = denom_hi<<16 + denom_lo<<1 *
+ * denom_hi is a normalize number. *
+ * *
+ * Inputs : *
+ * *
+ * L_num *
+ * 32 bit long signed integer (Word32) whose value falls in the *
+ * range : 0x0000 0000 < L_num < L_denom *
+ * *
+ * L_denom = denom_hi<<16 + denom_lo<<1 (DPF) *
+ * *
+ * denom_hi *
+ * 16 bit positive normalized integer whose value falls in the *
+ * range : 0x4000 < hi < 0x7fff *
+ * denom_lo *
+ * 16 bit positive integer whose value falls in the *
+ * range : 0 < lo < 0x7fff *
+ * *
+ * Return Value : *
+ * *
+ * L_div *
+ * 32 bit long signed integer (Word32) whose value falls in the *
+ * range : 0x0000 0000 <= L_div <= 0x7fff ffff. *
+ * *
+ * Algorithm: *
+ * *
+ * - find = 1/L_denom. *
+ * First approximation: approx = 1 / denom_hi *
+ * 1/L_denom = approx * (2.0 - L_denom * approx ) *
+ * *
+ * - result = L_num * (1/L_denom) *
+ *****************************************************************************
+*/
+
+Word32 Div_32 (Word32 L_num, Word16 denom_hi, Word16 denom_lo)
+{
+ Word16 approx, hi, lo, n_hi, n_lo;
+ Word32 L_32;
+
+ /* First approximation: 1 / L_denom = 1/denom_hi */
+
+ approx = div_s ((Word16) 0x3fff, denom_hi);
+
+ /* 1/L_denom = approx * (2.0 - L_denom * approx) */
+
+ L_32 = Msu_32_16 ((Word32) 0x7fffffffL, denom_hi, denom_lo, approx);
+
+ lo = L_Extract_lc (L_32, &hi);
+ L_32 = Mpy_32_16 (hi, lo, approx);
+
+ /* L_num * (1/L_denom) */
+
+ lo = L_Extract_lc (L_32, &hi);
+ n_lo = L_Extract_lc (L_num, &n_hi);
+ L_32 = Mpy_32 (n_hi, n_lo, hi, lo);
+ L_32 = L_shl (L_32, 2);
+
+ return (L_32);
+}
+
diff --git a/basic_math/oper_32b.h b/basic_math/oper_32b.h
new file mode 100644
index 0000000000000000000000000000000000000000..70d1c59dbd989669878651ca1654d9311631bfdd
--- /dev/null
+++ b/basic_math/oper_32b.h
@@ -0,0 +1,18 @@
+/* Double precision operations */
+/* $Id: oper_32b.h 1094 2014-02-10 17:12:11Z jdr $ */
+#ifndef _OPER_32b_H
+#define _OPER_32b_H
+
+void L_Extract (Word32 L_32, Word16 *hi, Word16 *lo);
+Word16 L_Extract_lc (Word32 L_32, Word16 *hi);
+Word32 L_Comp (Word16 hi, Word16 lo);
+Word32 Mpy_32 (Word16 hi1, Word16 lo1, Word16 hi2, Word16 lo2);
+Word32 Mac_32 (Word32 L_num, Word16 hi1, Word16 lo1, Word16 hi2, Word16 lo2);
+Word32 Sqr_32 (Word16 hi, Word16 lo);
+Word32 Sad_32 (Word32 L_num, Word16 hi, Word16 lo);
+Word32 Mpy_32_16 (Word16 hi, Word16 lo, Word16 n);
+Word32 Mac_32_16 (Word32 L_num, Word16 hi, Word16 lo, Word16 n);
+Word32 Msu_32_16 (Word32 L_num, Word16 hi, Word16 lo, Word16 n);
+Word32 Div_32 (Word32 L_num, Word16 denom_hi, Word16 denom_lo);
+
+#endif
diff --git a/basic_math/rom_basic_math.c b/basic_math/rom_basic_math.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c81378209d0a5f2b20c04eea2460d328b4fb2ce
--- /dev/null
+++ b/basic_math/rom_basic_math.c
@@ -0,0 +1,91 @@
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Decoder static structure */
+#include "stl.h"
+
+/* math_op.c */
+const Word32 L_table_isqrt[48] =
+{
+ 2147418112L, 2083389440L, 2024669184L, 1970667520L,
+ 1920794624L, 1874460672L, 1831403520L, 1791098880L,
+ 1753415680L, 1717960704L, 1684602880L, 1653145600L,
+ 1623326720L, 1595080704L, 1568276480L, 1542782976L,
+ 1518469120L, 1495334912L, 1473183744L, 1451950080L,
+ 1431633920L, 1412169728L, 1393491968L, 1375469568L,
+ 1358168064L, 1341521920L, 1325465600L, 1309933568L,
+ 1294991360L, 1280507904L, 1266548736L, 1252982784L,
+ 1239875584L, 1227161600L, 1214775296L, 1202847744L,
+ 1191182336L, 1179910144L, 1168965632L, 1158283264L,
+ 1147863040L, 1137770496L, 1127940096L, 1118306304L,
+ 1108934656L, 1099825152L, 1090912256L, 1082261504L
+};
+
+/* table of table_isqrt[i] - table_isqrt[i+1] */
+const Word16 table_isqrt_diff[48] =
+{
+ 977, 896, 824, 761, 707, 657, 615, 575,
+ 541, 509, 480, 455, 431, 409, 389, 371,
+ 353, 338, 324, 310, 297, 285, 275, 264,
+ 254, 245, 237, 228, 221, 213, 207, 200,
+ 194, 189, 182, 178, 172, 167, 163, 159,
+ 154, 150, 147, 143, 139, 136, 132, 130
+};
+
+const Word16 shift_Isqrt_lc[] = {9,10};
+
+const Word16 table_pow2[32] =
+{
+ 16384, 16743, 17109, 17484, 17867, 18258, 18658, 19066, 19484, 19911,
+ 20347, 20792, 21247, 21713, 22188, 22674, 23170, 23678, 24196, 24726,
+ 25268, 25821, 26386, 26964, 27554, 28158, 28774, 29405, 30048, 30706,
+ 31379, 32066
+};
+
+/* table of table_pow2[i+1] - table_pow2[i] */
+const Word16 table_pow2_diff_x32[32] =
+{
+ 11488, 11712, 12000, 12256, 12512, 12800, 13056, 13376, 13664, 13952,
+ 14240, 14560, 14912, 15200, 15552, 15872, 16256, 16576, 16960, 17344,
+ 17696, 18080, 18496, 18880, 19328, 19712, 20192, 20576, 21056, 21536,
+ 21984, 22432
+};
+
+const Word16 sqrt_table[49] =
+{
+ 16384, 16888, 17378, 17854, 18318, 18770, 19212,
+ 19644, 20066, 20480, 20886, 21283, 21674, 22058,
+ 22435, 22806, 23170, 23530, 23884, 24232, 24576,
+ 24915, 25249, 25580, 25905, 26227, 26545, 26859,
+ 27170, 27477, 27780, 28081, 28378, 28672, 28963,
+ 29251, 29537, 29819, 30099, 30377, 30652, 30924,
+ 31194, 31462, 31727, 31991, 32252, 32511, 32767
+};
+
+/* log2.c */
+const Word32 L_table_Log2_norm_lc[32] =
+{
+ -32768L, 95322112L, 187793408L, 277577728L,
+ 364871680L, 449740800L, 532381696L, 612859904L,
+ 691306496L, 767787008L, 842432512L, 915308544L,
+ 986546176L, 1056210944L, 1124302848L, 1190887424L,
+ 1256095744L, 1319993344L, 1382580224L, 1443921920L,
+ 1504083968L, 1563131904L, 1621000192L, 1677885440L,
+ 1733722112L, 1788510208L, 1842380800L, 1895399424L,
+ 1947435008L, 1998618624L, 2049015808L, 2098626560L
+};
+
+const Word16 table_diff_Log2_norm_lc[32] =
+{
+ 1455, 1411, 1370, 1332, 1295, 1261, 1228, 1197,
+ 1167, 1139, 1112, 1087, 1063, 1039, 1016, 995,
+ 975, 955, 936, 918, 901, 883, 868, 852,
+ 836, 822, 809, 794, 781, 769, 757, 744
+};
+
+const Word16 log2_tab[33]={
+ 0x7800, 0x782D, 0x785A, 0x7884, 0x78AE, 0x78D6, 0x78FE, 0x7924,
+ 0x794A, 0x796E, 0x7992, 0x79B4, 0x79D6, 0x79F8, 0x7A18, 0x7A38,
+ 0x7A57, 0x7A75, 0x7A93, 0x7AB1, 0x7ACD, 0x7AE9, 0x7B05, 0x7B20,
+ 0x7B3B, 0x7B55, 0x7B6F, 0x7B88, 0x7BA1, 0x7BB9, 0x7BD1, 0x7BE9,
+ 0x7C00
+};
+
diff --git a/basic_math/rom_basic_math.h b/basic_math/rom_basic_math.h
new file mode 100644
index 0000000000000000000000000000000000000000..f39ea84755f3878bcaf317d4d9d9f704dc3dc595
--- /dev/null
+++ b/basic_math/rom_basic_math.h
@@ -0,0 +1,26 @@
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Decoder static structure */
+#include "stl.h"
+
+
+/* math_op.c */
+extern const Word32 L_table_isqrt[48];
+
+/* table of table_isqrt[i] - table_isqrt[i+1] */
+extern const Word16 table_isqrt_diff[48];
+
+extern const Word16 shift_Isqrt_lc[];
+
+extern const Word16 table_pow2[32];
+
+/* table of table_pow2[i+1] - table_pow2[i] */
+extern const Word16 table_pow2_diff_x32[32];
+
+extern const Word16 sqrt_table[49];
+
+/* log2.c */
+extern const Word32 L_table_Log2_norm_lc[32];
+
+extern const Word16 table_diff_Log2_norm_lc[32];
+
+extern const Word16 log2_tab[33];
diff --git a/basic_op/README.md b/basic_op/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..47ff87ced765c8312fd0e96da124070d0bd841d8
--- /dev/null
+++ b/basic_op/README.md
@@ -0,0 +1,101 @@
+
+ Read-me for ITU-T/UGST Basic Operator Module V.2.3
+ (30.Nov.2009)
+
+ =============================================================
+ COPYRIGHT NOTE: This source code, and all of its derivations,
+ is subject to the "ITU-T General Public License". Please have
+ it read in the distribution disk, or in the ITU-T
+ Recommendation G.191 on "SOFTWARE TOOLS FOR SPEECH AND AUDIO
+ CODING STANDARDS".
+ =============================================================
+
+# Changes v.2.2 --> v.2.3
+
+Modifications in `basop32.c` and `basop32.h`
+- Function `round()` is now named `round_fx()`, to avoid clashes with
+standard C library.
+- Function `saturate()` is made unreferencable from outside application.
+
+Added new functionalities:
+- Basic operator counter utility: `basop_cnt.c`
+- Complexity evaluation tool for floating-point: `flc.h`, `flc.c`
+
+# Changes v.2.1 --> v.2.2
+
+New functions in `count.c`:
+- `void setFrameRate(int samplingFreq, int frameLength);`
+
+ This function can overwrite the value of the frameRate variable
+ that is initialized by the `FRAME_RATE` constant.
+
+- `void WMOPS_output_avg (Word16 dtx_mode, Word32 *tot_wm, Word16 *num_frames);`
+
+ Same as `WMOPS_output` + returns the total wmops counter and the number of frames
+ to support the computation of advanced complexity results as the global average.
+
+An example of the use of `WMOPS_output_avg` is given below:
+
+In a decoder, the `spe1Id` was used for valid frames while the `spe2Id` counter was used for erased frames.
+Using the `WMOPS_output_avg` the global average complexity can be also displayed :
+
+ short spe1Id = getCounterId("Valid frames");
+ short spe2Id = getCounterId("Bad frames");
+ long tot_wm1;
+ short num_frames1;
+ long tot_wm2;
+ short num_frames2;
+
+ ...
+
+ setCounter(spe1Id);
+ fwc();
+ WMOPS_output_avg(0, &tot_wm1, &num_frames1);
+ setCounter(spe2Id);
+ fwc();
+ WMOPS_output_avg(0, &tot_wm2, &num_frames2);
+ printf("Global average %f WMOPS\n", (tot_wm1 + tot_wm2)/(float)(num_frames1 + num_frames2));
+
+ Modifications in count.c:
+ - L_mls() is weighted 5.
+ - div_l() is weighted 32.
+ - i_mult() is weighted 3.
+
+# Changes v.2.0 --> v.2.1
+
+Improved portability:
+- in header files `__inline` was changed to `static __inline`
+- `//` style comments were changed to `/* */`
+- Cygwin added in the supported compiler list (`typedef.h`)
+- Word40 definition was added for Sun and Unix (`typedef.h`)
+
+Corrections:
+- missing incrementations were added for `s_and`, `s_or` and `s_xor` (`enh1632.h`)
+
+# Original version: v.2.0
+
+The ITU-T/UGST Basic Operator module contains the following files:
+
+## C code: (`model` directory)
+
+ basop32.c: ....... 16/32 bit basic operators
+ basop32.h: ....... Prototypes for basop32.c
+ count.c: ......... Functions for WMOPS computation
+ count.h: ......... Prototypes for count.c
+ typedef.h: ....... Data type definitions
+ typedefs.h: ...... New data type definitions
+ move.h: .......... Move & miscellaneous legacy operators
+ control.c: ....... Control operator internal variable decl.
+ control.h: ....... Control operators
+ enh1632.c: ....... Enhanced 16/32 bit basic operators
+ enh1632.h: ....... Prototypes for enh1632.c
+ enh40.c: ......... 40 bit basic operators
+ enh40.h: ......... Prototypes for enh40.c
+ patch.h: ......... Backward compatibility for operator names
+ stl.h: ........... Main header file
+
+## Demos:
+
+Demo programs are not available for this module.
+
+--
diff --git a/basic_op/basop.rme b/basic_op/basop.rme
new file mode 100644
index 0000000000000000000000000000000000000000..361ebc40393e28697f5c385c722ca1b2fb36f9ce
--- /dev/null
+++ b/basic_op/basop.rme
@@ -0,0 +1,120 @@
+
+ Read-me for ITU-T/UGST Basic Operator Module V.2.3
+ (30.Nov.2009)
+
+ =============================================================
+ COPYRIGHT NOTE: This source code, and all of its derivations,
+ is subject to the "ITU-T General Public License". Please have
+ it read in the distribution disk, or in the ITU-T
+ Recommendation G.191 on "SOFTWARE TOOLS FOR SPEECH AND AUDIO
+ CODING STANDARDS".
+ =============================================================
+
+Changes v.2.2 --> v.2.3
+***********************
+
+Modifications in basop32.c and basop32.h
+ - Function round() is now named round_fx(), to avoid clashes with
+ standard C library.
+ - Function saturate() is made unreferencable from outside application.
+
+Added new functionalities:
+ - Basic operator counter utility: basop_cnt.c
+ - Complexity evaluation tool for floating-point: flc.h, flc.c
+
+Changes v.2.1 --> v.2.2
+***********************
+
+New functions in count.c:
+ - void setFrameRate(int samplingFreq, int frameLength);
+ This function can overwrite the value of the frameRate variable
+ that is initialized by the FRAME_RATE constant.
+ - void WMOPS_output_avg (Word16 dtx_mode, Word32 *tot_wm, Word16 *num_frames);
+ same as WMOPS_output + returns the total wmops counter and the number of frames
+ to support the computation of advanced complexity results as the global average.
+
+An example of the use of WMOPS_output_avg is given below:
+
+In a decoder, the spe1Id was used for valid frames while the spe2Id counter was used for erased frames.
+Using the WMOPS_output_avg the global average complexity can be also displayed :
+
+short spe1Id = getCounterId("Valid frames");
+short spe2Id = getCounterId("Bad frames");
+long tot_wm1;
+short num_frames1;
+long tot_wm2;
+short num_frames2;
+
+...
+
+setCounter(spe1Id);
+fwc();
+WMOPS_output_avg(0, &tot_wm1, &num_frames1);
+setCounter(spe2Id);
+fwc();
+WMOPS_output_avg(0, &tot_wm2, &num_frames2);
+printf("Global average %f WMOPS\n", (tot_wm1 + tot_wm2)/(float)(num_frames1 + num_frames2));
+
+Modifications in count.c:
+ - L_mls() is weighted 5.
+ - div_l() is weighted 32.
+ - i_mult() is weighted 3.
+
+Changes v.2.0 --> v.2.1
+***********************
+
+Improved portability:
+ - in header files "__inline" was changed to "static __inline"
+ - // style comments were changed to /* */
+ - Cygwin added in the supported compiler list (typedef.h)
+ - Word40 definition was added for Sun and Unix (typedef.h)
+Corrections:
+ - missing incrementations were added for s_and, s_or and s_xor (enh1632.h)
+
+
+
+Original version: v.2.0
+***********************
+
+The ITU-T/UGST Basic Operator module contails the following files:
+
+General:
+~~~~~~~~
+ basop.rme: ....... Read-me file for Basic Operator module (this file)
+
+C code: ('model' directory)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ basop32.c: ....... 16/32 bit basic operators
+ basop32.h: ....... Prototypes for basop32.c
+ count.c: ......... Functions for WMOPS computation
+ count.h: ......... Prototypes for count.c
+ typedef.h: ....... Data type definitions
+ typedefs.h: ...... New data type definitions
+ move.h: .......... Move & miscellaneous legacy operators
+ control.c: ....... Control operator internal variable decl.
+ control.h: ....... Control operators
+ enh1632.c: ....... Enhanced 16/32 bit basic operators
+ enh1632.h: ....... Prototypes for enh1632.c
+ enh40.c: ......... 40 bit basic operators
+ enh40.h: ......... Prototypes for enh40.c
+ patch.h: ......... Backward compatibility for operator names
+ stl.h: ........... Main header file
+ enh64.c: ......... 64 bit basic operators
+ enh64.h: ......... Prototypes for enh64.c
+ enh32.c: ......... Extension to enhanced 32 bit operators
+ enh32.h: ......... Prototypes for enh32.c
+ complex_basop.c: ... 32/16 complex basic operators
+ complex_basop.h: ... Prototypes for complex_basop.c
+
+Demos:
+~~~~~~
+Demo programs are not available for this module.
+
+
+Makefiles
+~~~~~~~~~
+Make files are not available for this module.
+
+
+--
+
diff --git a/basic_op/basop32.c b/basic_op/basop32.c
new file mode 100644
index 0000000000000000000000000000000000000000..b83cd21ab78eaee7c66e6c884b6d3b2deeb79cf5
--- /dev/null
+++ b/basic_op/basop32.c
@@ -0,0 +1,2429 @@
+/* v.2.3 - 30.Nov.2009
+ =============================================================================
+
+ U U GGG SSSS TTTTT
+ U U G S T
+ U U G GG SSSS T
+ U U G G S T
+ UUU GG SSS T
+
+ ========================================
+ ITU-T - USER'S GROUP ON SOFTWARE TOOLS
+ ========================================
+
+ =============================================================
+ COPYRIGHT NOTE: This source code, and all of its derivations,
+ is subject to the "ITU-T General Public License". Please have
+ it read in the distribution disk, or in the ITU-T
+ Recommendation G.191 on "SOFTWARE TOOLS FOR SPEECH AND AUDIO
+ CODING STANDARDS".
+ =============================================================
+
+MODULE: BASOP32, BASIC OPERATORS
+
+ORIGINAL BY:
+ Incorporated from anonymous contributions for
+ ETSI Standards as well as G.723.1, G.729, and G.722.1
+
+DESCRIPTION:
+ This file contains the definition of 16- and 32-bit basic
+ operators to be used in the implementation of signal
+ processing algorithms. The basic operators try to resemble
+ assembly language instructions that are commonly found in
+ digital signal processor (DSP) CPUs, thus allowing algorithm
+ C-code implementations more directly mapeable to DSP assembly
+ code.
+
+ *********************************************************
+ NOTE: so far, this module does not have a demo program!
+ *********************************************************
+
+FUNCTIONS:
+ Defined in basop32.h. Self-documentation within each function.
+
+HISTORY:
+ 26.Jan.00 v1.0 Incorporated to the STL from updated G.723.1/G.729
+ basic operator library (based on basicop2.c) and
+ G.723.1's basop.c [L_mls(), div_l(), i_mult()]
+
+ 05.Jul.00 v1.1 Added 32-bit shiftless accumulation basic
+ operators (L_msu0, L_mac0, L_mult0). Improved
+ documentation for i_mult().
+
+ 03 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ norm_s() weight reduced from 15 to 1.
+ norm_l() weight reduced from 30 to 1.
+ L_abs() weight reduced from 2 to 1.
+ L_add() weight reduced from 2 to 1.
+ L_negate() weight reduced from 2 to 1.
+ L_shl() weight reduced from 2 to 1.
+ L_shr() weight reduced from 2 to 1.
+ L_sub() weight reduced from 2 to 1.
+ mac_r() weight reduced from 2 to 1.
+ msu_r() weight reduced from 2 to 1.
+ mult_r() weight reduced from 2 to 1.
+ L_deposit_h() weight reduced from 2 to 1.
+ L_deposit_l() weight reduced from 2 to 1.
+ L_mls() weight of 5.
+ div_l() weight of 32.
+ i_mult() weight of 3.
+
+ 30 Nov 09 v2.3 round() function is now round_fx().
+ saturate() is not referencable from outside application
+ =============================================================================
+*/
+
+
+/*___________________________________________________________________________
+ | |
+ | Basic arithmetic operators. |
+ | |
+ | $Id $ |
+ | |
+ | saturate() |
+ | add() |
+ | sub() |
+ | abs_s() |
+ | divide_s() |
+ | extract_h() |
+ | extract_l() |
+ | L_abs() |
+ | L_add() |
+ | L_deposit_h() |
+ | L_deposit_l() |
+ | L_mac() |
+ | L_msu() |
+ | L_mult() |
+ | L_negate() |
+ | L_shl() |
+ | L_shr() |
+ | L_sub() |
+ | mac_r() |
+ | msu_r() |
+ | mult() |
+ | mult_r() |
+ | negate() |
+ | norm_l() |
+ | norm_s() |
+ | round_fx() |
+ | shl() |
+ | shr() |
+ |___________________________________________________________________________|
+*/
+
+
+/*___________________________________________________________________________
+ | |
+ | Include-Files |
+ |___________________________________________________________________________|
+*/
+#include
+#include
+#include "stl.h"
+
+
+#if (WMOPS)
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+extern int currCounter;
+#endif
+
+
+/*___________________________________________________________________________
+ | |
+ | Local Functions |
+ |___________________________________________________________________________|
+*/
+static Word16 saturate (Word32 L_var1);
+
+
+/*___________________________________________________________________________
+ | |
+ | Constants and Globals |
+ |___________________________________________________________________________|
+*/
+Flag Overflow = 0;
+Flag Carry = 0;
+
+
+/*___________________________________________________________________________
+ | |
+ | Functions |
+ |___________________________________________________________________________|
+*/
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : saturate |
+ | |
+ | Purpose : |
+ | |
+ | Limit the 32 bit input to the range of a 16 bit word. Must NOT be |
+ | referenced from outside applications. |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+static Word16 saturate (Word32 L_var1) {
+ Word16 var_out;
+
+ if (L_var1 > 0X00007fffL) {
+ Overflow = 1;
+ var_out = MAX_16;
+ } else if (L_var1 < (Word32) 0xffff8000L) {
+ Overflow = 1;
+ var_out = MIN_16;
+ } else {
+ var_out = extract_l (L_var1);
+#if (WMOPS)
+ multiCounter[currCounter].extract_l--;
+#endif
+ }
+
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : add |
+ | |
+ | Purpose : |
+ | |
+ | Performs the addition (var1+var2) with overflow control and saturation;|
+ | the 16 bit result is set at +32767 when overflow occurs or at -32768 |
+ | when underflow occurs. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 add (Word16 var1, Word16 var2) {
+ Word16 var_out;
+ Word32 L_sum;
+
+ L_sum = (Word32) var1 + var2;
+ var_out = saturate (L_sum);
+
+#if (WMOPS)
+ multiCounter[currCounter].add++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : sub |
+ | |
+ | Purpose : |
+ | |
+ | Performs the subtraction (var1+var2) with overflow control and satu- |
+ | ration; the 16 bit result is set at +32767 when overflow occurs or at |
+ | -32768 when underflow occurs. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 sub (Word16 var1, Word16 var2) {
+ Word16 var_out;
+ Word32 L_diff;
+
+ L_diff = (Word32) var1 - var2;
+ var_out = saturate (L_diff);
+
+#if (WMOPS)
+ multiCounter[currCounter].sub++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : abs_s |
+ | |
+ | Purpose : |
+ | |
+ | Absolute value of var1; abs_s(-32768) = 32767. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0x0000 0000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 abs_s (Word16 var1) {
+ Word16 var_out;
+
+ if (var1 == (Word16) MIN_16) {
+ var_out = MAX_16;
+ } else {
+ if (var1 < 0) {
+ var_out = -var1;
+ } else {
+ var_out = var1;
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].abs_s++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : shl |
+ | |
+ | Purpose : |
+ | |
+ | Arithmetically shift the 16 bit input var1 left var2 positions.Zero fill|
+ | the var2 LSB of the result. If var2 is negative, arithmetically shift |
+ | var1 right by -var2 with sign extension. Saturate the result in case of |
+ | underflows or overflows. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 shl (Word16 var1, Word16 var2) {
+ Word16 var_out;
+ Word32 result;
+
+ if (var2 < 0) {
+ if (var2 < -16)
+ var2 = -16;
+ var2 = -var2;
+ var_out = shr (var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].shr--;
+#endif
+ } else {
+ result = (Word32) var1 *((Word32) 1 << var2);
+
+ if ((var2 > 15 && var1 != 0) || (result != (Word32) ((Word16) result))) {
+ Overflow = 1;
+ var_out = (var1 > 0) ? MAX_16 : MIN_16;
+ } else {
+ var_out = extract_l (result);
+
+#if (WMOPS)
+ multiCounter[currCounter].extract_l--;
+#endif
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].shl++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : shr |
+ | |
+ | Purpose : |
+ | |
+ | Arithmetically shift the 16 bit input var1 right var2 positions with |
+ | sign extension. If var2 is negative, arithmetically shift var1 left by |
+ | -var2 with sign extension. Saturate the result in case of underflows or |
+ | overflows. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 shr (Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ if (var2 < 0) {
+ if (var2 < -16)
+ var2 = -16;
+ var2 = -var2;
+ var_out = shl (var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].shl--;
+#endif
+ } else {
+ if (var2 >= 15) {
+ var_out = (var1 < 0) ? -1 : 0;
+ } else {
+ if (var1 < 0) {
+ var_out = ~((~var1) >> var2);
+ } else {
+ var_out = var1 >> var2;
+ }
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].shr++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : mult |
+ | |
+ | Purpose : |
+ | |
+ | Performs the multiplication of var1 by var2 and gives a 16 bit result |
+ | which is scaled i.e.: |
+ | mult(var1,var2) = extract_l(L_shr((var1 times var2),15)) and |
+ | mult(-32768,-32768) = 32767. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 mult (Word16 var1, Word16 var2) {
+ Word16 var_out;
+ Word32 L_product;
+
+ L_product = (Word32) var1 *(Word32) var2;
+
+ L_product = (L_product & (Word32) 0xffff8000L) >> 15;
+
+ if (L_product & (Word32) 0x00010000L)
+ L_product = L_product | (Word32) 0xffff0000L;
+
+ var_out = saturate (L_product);
+
+#if (WMOPS)
+ multiCounter[currCounter].mult++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_mult |
+ | |
+ | Purpose : |
+ | |
+ | L_mult is the 32 bit result of the multiplication of var1 times var2 |
+ | with one shift left i.e.: |
+ | L_mult(var1,var2) = L_shl((var1 times var2),1) and |
+ | L_mult(-32768,-32768) = 2147483647. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_mult (Word16 var1, Word16 var2) {
+ Word32 L_var_out;
+
+ L_var_out = (Word32) var1 *(Word32) var2;
+
+ if (L_var_out != (Word32) 0x40000000L) {
+ L_var_out *= 2;
+ } else {
+ Overflow = 1;
+ L_var_out = MAX_32;
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L_mult++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : negate |
+ | |
+ | Purpose : |
+ | |
+ | Negate var1 with saturation, saturate in the case where input is -32768:|
+ | negate(var1) = sub(0,var1). |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 negate (Word16 var1) {
+ Word16 var_out;
+
+ var_out = (var1 == MIN_16) ? MAX_16 : -var1;
+
+#if (WMOPS)
+ multiCounter[currCounter].negate++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : extract_h |
+ | |
+ | Purpose : |
+ | |
+ | Return the 16 MSB of L_var1. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 |
+ | 32 bit long signed integer (Word32 ) whose value falls in the |
+ | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 extract_h (Word32 L_var1) {
+ Word16 var_out;
+
+ var_out = (Word16) (L_var1 >> 16);
+
+#if (WMOPS)
+ multiCounter[currCounter].extract_h++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : extract_l |
+ | |
+ | Purpose : |
+ | |
+ | Return the 16 LSB of L_var1. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 |
+ | 32 bit long signed integer (Word32 ) whose value falls in the |
+ | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 extract_l (Word32 L_var1) {
+ Word16 var_out;
+
+ var_out = (Word16) L_var1;
+
+#if (WMOPS)
+ multiCounter[currCounter].extract_l++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : round_fx |
+ | |
+ | Purpose : |
+ | |
+ | Round the lower 16 bits of the 32 bit input number into the MS 16 bits |
+ | with saturation. Shift the resulting bits right by 16 and return the 16 |
+ | bit number: |
+ | round_fx(L_var1) = extract_h(L_add(L_var1,32768)) |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 |
+ | 32 bit long signed integer (Word32 ) whose value falls in the |
+ | range : 0x8000 0000 <= L_var1 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 round_fx (Word32 L_var1) {
+ Word16 var_out;
+ Word32 L_rounded;
+
+ L_rounded = L_add (L_var1, (Word32) 0x00008000L);
+ var_out = extract_h (L_rounded);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].extract_h--;
+ multiCounter[currCounter].round++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_mac |
+ | |
+ | Purpose : |
+ | |
+ | Multiply var1 by var2 and shift the result left by 1. Add the 32 bit |
+ | result to L_var3 with saturation, return a 32 bit result: |
+ | L_mac(L_var3,var1,var2) = L_add(L_var3,L_mult(var1,var2)). |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var3 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_mac (Word32 L_var3, Word16 var1, Word16 var2) {
+ Word32 L_var_out;
+ Word32 L_product;
+
+ L_product = L_mult (var1, var2);
+ L_var_out = L_add (L_var3, L_product);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_mult--;
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].L_mac++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_msu |
+ | |
+ | Purpose : |
+ | |
+ | Multiply var1 by var2 and shift the result left by 1. Subtract the 32 |
+ | bit result from L_var3 with saturation, return a 32 bit result: |
+ | L_msu(L_var3,var1,var2) = L_sub(L_var3,L_mult(var1,var2)). |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var3 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_msu (Word32 L_var3, Word16 var1, Word16 var2) {
+ Word32 L_var_out;
+ Word32 L_product;
+
+ L_product = L_mult (var1, var2);
+ L_var_out = L_sub (L_var3, L_product);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_mult--;
+ multiCounter[currCounter].L_sub--;
+ multiCounter[currCounter].L_msu++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_macNs |
+ | |
+ | Purpose : |
+ | |
+ | Multiply var1 by var2 and shift the result left by 1. Add the 32 bit |
+ | result to L_var3 without saturation, return a 32 bit result. Generate |
+ | carry and overflow values : |
+ | L_macNs(L_var3,var1,var2) = L_add_c(L_var3,L_mult(var1,var2)). |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var3 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ | |
+ | Caution : |
+ | |
+ | In some cases the Carry flag has to be cleared or set before using |
+ | operators which take into account its value. |
+ |___________________________________________________________________________|
+*/
+Word32 L_macNs (Word32 L_var3, Word16 var1, Word16 var2) {
+ Word32 L_var_out;
+
+ L_var_out = L_mult (var1, var2);
+ L_var_out = L_add_c (L_var3, L_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_mult--;
+ multiCounter[currCounter].L_add_c--;
+ multiCounter[currCounter].L_macNs++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_msuNs |
+ | |
+ | Purpose : |
+ | |
+ | Multiply var1 by var2 and shift the result left by 1. Subtract the 32 |
+ | bit result from L_var3 without saturation, return a 32 bit result. Ge- |
+ | nerate carry and overflow values : |
+ | L_msuNs(L_var3,var1,var2) = L_sub_c(L_var3,L_mult(var1,var2)). |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var3 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ | |
+ | Caution : |
+ | |
+ | In some cases the Carry flag has to be cleared or set before using |
+ | operators which take into account its value. |
+ |___________________________________________________________________________|
+*/
+Word32 L_msuNs (Word32 L_var3, Word16 var1, Word16 var2) {
+ Word32 L_var_out;
+
+ L_var_out = L_mult (var1, var2);
+ L_var_out = L_sub_c (L_var3, L_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_mult--;
+ multiCounter[currCounter].L_sub_c--;
+ multiCounter[currCounter].L_msuNs++;
+
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_add |
+ | |
+ | Purpose : |
+ | |
+ | 32 bits addition of the two 32 bits variables (L_var1+L_var2) with |
+ | overflow control and saturation; the result is set at +2147483647 when |
+ | overflow occurs or at -2147483648 when underflow occurs. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | L_var2 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_add (Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+
+ L_var_out = L_var1 + L_var2;
+
+ if (((L_var1 ^ L_var2) & MIN_32) == 0) {
+ if ((L_var_out ^ L_var1) & MIN_32) {
+ L_var_out = (L_var1 < 0) ? MIN_32 : MAX_32;
+ Overflow = 1;
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L_add++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_sub |
+ | |
+ | Purpose : |
+ | |
+ | 32 bits subtraction of the two 32 bits variables (L_var1-L_var2) with |
+ | overflow control and saturation; the result is set at +2147483647 when |
+ | overflow occurs or at -2147483648 when underflow occurs. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | L_var2 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_sub (Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+
+ L_var_out = L_var1 - L_var2;
+
+ if (((L_var1 ^ L_var2) & MIN_32) != 0) {
+ if ((L_var_out ^ L_var1) & MIN_32) {
+ L_var_out = (L_var1 < 0L) ? MIN_32 : MAX_32;
+ Overflow = 1;
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L_sub++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_add_c |
+ | |
+ | Purpose : |
+ | |
+ | Performs 32 bits addition of the two 32 bits variables (L_var1+L_var2+C)|
+ | with carry. No saturation. Generate carry and Overflow values. The car- |
+ | ry and overflow values are binary variables which can be tested and as- |
+ | signed values. |
+ | |
+ | Complexity weight : 2 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | L_var2 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ | |
+ | Caution : |
+ | |
+ | In some cases the Carry flag has to be cleared or set before using |
+ | operators which take into account its value. |
+ |___________________________________________________________________________|
+*/
+Word32 L_add_c (Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+ Word32 L_test;
+ Flag carry_int = 0;
+
+ L_var_out = L_var1 + L_var2 + Carry;
+
+ L_test = L_var1 + L_var2;
+
+ if ((L_var1 > 0) && (L_var2 > 0) && (L_test < 0)) {
+ Overflow = 1;
+ carry_int = 0;
+ } else {
+ if ((L_var1 < 0) && (L_var2 < 0)) {
+ if (L_test >= 0) {
+ Overflow = 1;
+ carry_int = 1;
+ } else {
+ Overflow = 0;
+ carry_int = 1;
+ }
+ } else {
+ if (((L_var1 ^ L_var2) < 0) && (L_test >= 0)) {
+ Overflow = 0;
+ carry_int = 1;
+ } else {
+ Overflow = 0;
+ carry_int = 0;
+ }
+ }
+ }
+
+ if (Carry) {
+ if (L_test == MAX_32) {
+ Overflow = 1;
+ Carry = carry_int;
+ } else {
+ if (L_test == (Word32) 0xFFFFFFFFL) {
+ Carry = 1;
+ } else {
+ Carry = carry_int;
+ }
+ }
+ } else {
+ Carry = carry_int;
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L_add_c++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_sub_c |
+ | |
+ | Purpose : |
+ | |
+ | Performs 32 bits subtraction of the two 32 bits variables with carry |
+ | (borrow) : L_var1-L_var2-C. No saturation. Generate carry and Overflow |
+ | values. The carry and overflow values are binary variables which can |
+ | be tested and assigned values. |
+ | |
+ | Complexity weight : 2 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | L_var2 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ | |
+ | Caution : |
+ | |
+ | In some cases the Carry flag has to be cleared or set before using |
+ | operators which take into account its value. |
+ |___________________________________________________________________________|
+*/
+Word32 L_sub_c (Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+ Word32 L_test;
+ Flag carry_int = 0;
+
+ if (Carry) {
+ Carry = 0;
+ if (L_var2 != MIN_32) {
+ L_var_out = L_add_c (L_var1, -L_var2);
+#if (WMOPS)
+ multiCounter[currCounter].L_add_c--;
+#endif
+ } else {
+ L_var_out = L_var1 - L_var2;
+ if (L_var1 > 0L) {
+ Overflow = 1;
+ Carry = 0;
+ }
+ }
+ } else {
+ L_var_out = L_var1 - L_var2 - (Word32) 0X00000001L;
+ L_test = L_var1 - L_var2;
+
+ if ((L_test < 0) && (L_var1 > 0) && (L_var2 < 0)) {
+ Overflow = 1;
+ carry_int = 0;
+ } else if ((L_test > 0) && (L_var1 < 0) && (L_var2 > 0)) {
+ Overflow = 1;
+ carry_int = 1;
+ } else if ((L_test > 0) && ((L_var1 ^ L_var2) > 0)) {
+ Overflow = 0;
+ carry_int = 1;
+ }
+ if (L_test == MIN_32) {
+ Overflow = 1;
+ Carry = carry_int;
+ } else {
+ Carry = carry_int;
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L_sub_c++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_negate |
+ | |
+ | Purpose : |
+ | |
+ | Negate the 32 bit variable L_var1 with saturation; saturate in the case |
+ | where input is -2147483648 (0x8000 0000). |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_negate (Word32 L_var1) {
+ Word32 L_var_out;
+
+ L_var_out = (L_var1 == MIN_32) ? MAX_32 : -L_var1;
+
+#if (WMOPS)
+ multiCounter[currCounter].L_negate++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : mult_r |
+ | |
+ | Purpose : |
+ | |
+ | Same as mult with rounding, i.e.: |
+ | mult_r(var1,var2) = extract_l(L_shr(((var1 * var2) + 16384),15)) and |
+ | mult_r(-32768,-32768) = 32767. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0x8000 <= var_out <= 0x7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 mult_r (Word16 var1, Word16 var2) {
+ Word16 var_out;
+ Word32 L_product_arr;
+
+ L_product_arr = (Word32) var1 *(Word32) var2; /* product */
+ L_product_arr += (Word32) 0x00004000L; /* round */
+ L_product_arr &= (Word32) 0xffff8000L;
+ L_product_arr >>= 15; /* shift */
+
+ if (L_product_arr & (Word32) 0x00010000L) { /* sign extend when necessary */
+ L_product_arr |= (Word32) 0xffff0000L;
+ }
+ var_out = saturate (L_product_arr);
+
+#if (WMOPS)
+ multiCounter[currCounter].mult_r++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_shl |
+ | |
+ | Purpose : |
+ | |
+ | Arithmetically shift the 32 bit input L_var1 left var2 positions. Zero |
+ | fill the var2 LSB of the result. If var2 is negative, arithmetically |
+ | shift L_var1 right by -var2 with sign extension. Saturate the result in |
+ | case of underflows or overflows. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_shl (Word32 L_var1, Word16 var2) {
+
+ Word32 L_var_out = 0L;
+
+ if (var2 <= 0) {
+ if (var2 < -32)
+ var2 = -32;
+ var2 = -var2;
+ L_var_out = L_shr (L_var1, var2);
+#if (WMOPS)
+ multiCounter[currCounter].L_shr--;
+#endif
+ } else {
+ for (; var2 > 0; var2--) {
+ if (L_var1 > (Word32) 0X3fffffffL) {
+ Overflow = 1;
+ L_var_out = MAX_32;
+ break;
+ } else {
+ if (L_var1 < (Word32) 0xc0000000L) {
+ Overflow = 1;
+ L_var_out = MIN_32;
+ break;
+ }
+ }
+ L_var1 *= 2;
+ L_var_out = L_var1;
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L_shl++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_shr |
+ | |
+ | Purpose : |
+ | |
+ | Arithmetically shift the 32 bit input L_var1 right var2 positions with |
+ | sign extension. If var2 is negative, arithmetically shift L_var1 left |
+ | by -var2 and zero fill the -var2 LSB of the result. Saturate the result |
+ | in case of underflows or overflows. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_shr (Word32 L_var1, Word16 var2) {
+ Word32 L_var_out;
+
+ if (var2 < 0) {
+ if (var2 < -32)
+ var2 = -32;
+ var2 = -var2;
+ L_var_out = L_shl (L_var1, var2);
+#if (WMOPS)
+ multiCounter[currCounter].L_shl--;
+#endif
+ } else {
+ if (var2 >= 31) {
+ L_var_out = (L_var1 < 0L) ? -1 : 0;
+ } else {
+ if (L_var1 < 0) {
+ L_var_out = ~((~L_var1) >> var2);
+ } else {
+ L_var_out = L_var1 >> var2;
+ }
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L_shr++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : shr_r |
+ | |
+ | Purpose : |
+ | |
+ | Same as shr(var1,var2) but with rounding. Saturate the result in case of|
+ | underflows or overflows : |
+ | - If var2 is greater than zero : |
+ | if (sub(shl(shr(var1,var2),1),shr(var1,sub(var2,1)))) |
+ | is equal to zero |
+ | then |
+ | shr_r(var1,var2) = shr(var1,var2) |
+ | else |
+ | shr_r(var1,var2) = add(shr(var1,var2),1) |
+ | - If var2 is less than or equal to zero : |
+ | shr_r(var1,var2) = shr(var1,var2). |
+ | |
+ | Complexity weight : 3 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 shr_r (Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ if (var2 > 15) {
+ var_out = 0;
+ } else {
+ var_out = shr (var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].shr--;
+#endif
+
+ if (var2 > 0) {
+ if ((var1 & ((Word16) 1 << (var2 - 1))) != 0) {
+ var_out++;
+ }
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].shr_r++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : mac_r |
+ | |
+ | Purpose : |
+ | |
+ | Multiply var1 by var2 and shift the result left by 1. Add the 32 bit |
+ | result to L_var3 with saturation. Round the LS 16 bits of the result |
+ | into the MS 16 bits with saturation and shift the result right by 16. |
+ | Return a 16 bit result. |
+ | mac_r(L_var3,var1,var2) = round_fx(L_mac(L_var3,var1,var2)) |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var3 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0x0000 8000 <= L_var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 mac_r (Word32 L_var3, Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ L_var3 = L_mac (L_var3, var1, var2);
+ L_var3 = L_add (L_var3, (Word32) 0x00008000L);
+ var_out = extract_h (L_var3);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_mac--;
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].extract_h--;
+ multiCounter[currCounter].mac_r++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : msu_r |
+ | |
+ | Purpose : |
+ | |
+ | Multiply var1 by var2 and shift the result left by 1. Subtract the 32 |
+ | bit result from L_var3 with saturation. Round the LS 16 bits of the res-|
+ | ult into the MS 16 bits with saturation and shift the result right by |
+ | 16. Return a 16 bit result. |
+ | msu_r(L_var3,var1,var2) = round_fx(L_msu(L_var3,var1,var2)) |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var3 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff. |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0x0000 8000 <= L_var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word16 msu_r (Word32 L_var3, Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ L_var3 = L_msu (L_var3, var1, var2);
+ L_var3 = L_add (L_var3, (Word32) 0x00008000L);
+ var_out = extract_h (L_var3);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_msu--;
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].extract_h--;
+ multiCounter[currCounter].msu_r++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_deposit_h |
+ | |
+ | Purpose : |
+ | |
+ | Deposit the 16 bit var1 into the 16 MS bits of the 32 bit output. The |
+ | 16 LS bits of the output are zeroed. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= var_out <= 0x7fff 0000. |
+ |___________________________________________________________________________|
+*/
+Word32 L_deposit_h (Word16 var1) {
+ Word32 L_var_out;
+
+ L_var_out = (Word32) var1 << 16;
+
+#if (WMOPS)
+ multiCounter[currCounter].L_deposit_h++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_deposit_l |
+ | |
+ | Purpose : |
+ | |
+ | Deposit the 16 bit var1 into the 16 LS bits of the 32 bit output. The |
+ | 16 MS bits of the output are sign extended. |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0xFFFF 8000 <= var_out <= 0x0000 7fff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_deposit_l (Word16 var1) {
+ Word32 L_var_out;
+
+ L_var_out = (Word32) var1;
+
+#if (WMOPS)
+ multiCounter[currCounter].L_deposit_l++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_shr_r |
+ | |
+ | Purpose : |
+ | |
+ | Same as L_shr(L_var1,var2) but with rounding. Saturate the result in |
+ | case of underflows or overflows : |
+ | - If var2 is greater than zero : |
+ | if (L_sub(L_shl(L_shr(L_var1,var2),1),L_shr(L_var1,sub(var2,1))))|
+ | is equal to zero |
+ | then |
+ | L_shr_r(L_var1,var2) = L_shr(L_var1,var2) |
+ | else |
+ | L_shr_r(L_var1,var2) = L_add(L_shr(L_var1,var2),1) |
+ | - If var2 is less than or equal to zero : |
+ | L_shr_r(L_var1,var2) = L_shr(L_var1,var2). |
+ | |
+ | Complexity weight : 3 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= var1 <= 0x7fff ffff. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_shr_r (Word32 L_var1, Word16 var2) {
+ Word32 L_var_out;
+
+ if (var2 > 31) {
+ L_var_out = 0;
+ } else {
+ L_var_out = L_shr (L_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_shr--;
+#endif
+ if (var2 > 0) {
+ if ((L_var1 & ((Word32) 1 << (var2 - 1))) != 0) {
+ L_var_out++;
+ }
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L_shr_r++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_abs |
+ | |
+ | Purpose : |
+ | |
+ | Absolute value of L_var1; Saturate in case where the input is |
+ | -214783648 |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= var1 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x0000 0000 <= var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_abs (Word32 L_var1) {
+ Word32 L_var_out;
+
+ if (L_var1 == MIN_32) {
+ L_var_out = MAX_32;
+ } else {
+ if (L_var1 < 0) {
+ L_var_out = -L_var1;
+ } else {
+ L_var_out = L_var1;
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L_abs++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_sat |
+ | |
+ | Purpose : |
+ | |
+ | 32 bit L_var1 is set to 2147483647 if an overflow occured or to |
+ | -2147483648 if an underflow occured on the most recent L_add_c, |
+ | L_sub_c, L_macNs or L_msuNs operations. The carry and overflow values |
+ | are binary values which can be tested and assigned values. |
+ | |
+ | Complexity weight : 4 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= var1 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L_var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= var_out <= 0x7fff ffff. |
+ |___________________________________________________________________________|
+*/
+Word32 L_sat (Word32 L_var1) {
+ Word32 L_var_out;
+
+ L_var_out = L_var1;
+
+ if (Overflow) {
+
+ if (Carry) {
+ L_var_out = MIN_32;
+ } else {
+ L_var_out = MAX_32;
+ }
+
+ Carry = 0;
+ Overflow = 0;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L_sat++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : norm_s |
+ | |
+ | Purpose : |
+ | |
+ | Produces the number of left shift needed to normalize the 16 bit varia- |
+ | ble var1 for positive values on the interval with minimum of 16384 and |
+ | maximum of 32767, and for negative values on the interval with minimum |
+ | of -32768 and maximum of -16384; in order to normalize the result, the |
+ | following operation must be done : |
+ | norm_var1 = shl(var1,norm_s(var1)). |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0x0000 0000 <= var_out <= 0x0000 000f. |
+ |___________________________________________________________________________|
+*/
+Word16 norm_s (Word16 var1) {
+ Word16 var_out;
+
+ if (var1 == 0) {
+ var_out = 0;
+ } else {
+ if (var1 == (Word16) 0xffff) {
+ var_out = 15;
+ } else {
+ if (var1 < 0) {
+ var1 = ~var1;
+ }
+ for (var_out = 0; var1 < 0x4000; var_out++) {
+ var1 <<= 1;
+ }
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].norm_s++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : div_s |
+ | |
+ | Purpose : |
+ | |
+ | Produces a result which is the fractional integer division of var1 by |
+ | var2; var1 and var2 must be positive and var2 must be greater or equal |
+ | to var1; the result is positive (leading bit equal to 0) and truncated |
+ | to 16 bits. |
+ | If var1 = var2 then div(var1,var2) = 32767. |
+ | |
+ | Complexity weight : 18 |
+ | |
+ | Inputs : |
+ | |
+ | var1 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0x0000 0000 <= var1 <= var2 and var2 != 0. |
+ | |
+ | var2 |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : var1 <= var2 <= 0x0000 7fff and var2 != 0. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0x0000 0000 <= var_out <= 0x0000 7fff. |
+ | It's a Q15 value (point between b15 and b14). |
+ |___________________________________________________________________________|
+*/
+Word16 div_s (Word16 var1, Word16 var2) {
+ Word16 var_out = 0;
+ Word16 iteration;
+ Word32 L_num;
+ Word32 L_denom;
+
+ if ((var1 > var2) || (var1 < 0) || (var2 < 0)) {
+ printf ("Division Error var1=%d var2=%d\n", var1, var2);
+ abort (); /* exit (0); */
+ }
+ if (var2 == 0) {
+ printf ("Division by 0, Fatal error \n");
+ abort (); /* exit (0); */
+ }
+ if (var1 == 0) {
+ var_out = 0;
+ } else {
+ if (var1 == var2) {
+ var_out = MAX_16;
+ } else {
+ L_num = L_deposit_l (var1);
+ L_denom = L_deposit_l (var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_deposit_l--;
+ multiCounter[currCounter].L_deposit_l--;
+#endif
+
+ for (iteration = 0; iteration < 15; iteration++) {
+ var_out <<= 1;
+ L_num <<= 1;
+
+ if (L_num >= L_denom) {
+ L_num = L_sub (L_num, L_denom);
+ var_out = add (var_out, 1);
+#if (WMOPS)
+ multiCounter[currCounter].L_sub--;
+ multiCounter[currCounter].add--;
+#endif
+ }
+ }
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].div_s++;
+#endif
+ return (var_out);
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : norm_l |
+ | |
+ | Purpose : |
+ | |
+ | Produces the number of left shifts needed to normalize the 32 bit varia-|
+ | ble L_var1 for positive values on the interval with minimum of |
+ | 1073741824 and maximum of 2147483647, and for negative values on the in-|
+ | terval with minimum of -2147483648 and maximum of -1073741824; in order |
+ | to normalize the result, the following operation must be done : |
+ | norm_L_var1 = L_shl(L_var1,norm_l(L_var1)). |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L_var1 |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= var1 <= 0x7fff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0x0000 0000 <= var_out <= 0x0000 001f. |
+ |___________________________________________________________________________|
+*/
+Word16 norm_l (Word32 L_var1) {
+ Word16 var_out;
+
+ if (L_var1 == 0) {
+ var_out = 0;
+ } else {
+ if (L_var1 == (Word32) 0xffffffffL) {
+ var_out = 31;
+ } else {
+ if (L_var1 < 0) {
+ L_var1 = ~L_var1;
+ }
+ for (var_out = 0; L_var1 < (Word32) 0x40000000L; var_out++) {
+ L_var1 <<= 1;
+ }
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].norm_l++;
+#endif
+ return (var_out);
+}
+
+/*
+ ******************************************************************************
+ * Additional operators extracted from the G.723.1 Library
+ * Adapted for WMOPS calculations
+ ******************************************************************************
+*/
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : L_mls |
+ | |
+ | Purpose : |
+ | |
+ | Multiplies a 16 bit word v by a 32 bit word Lv and returns a 32 bit |
+ | word (multiplying 16 by 32 bit words gives 48 bit word; the function |
+ | extracts the 32 MSB and shift the result to the left by 1). |
+ | |
+ | A 32 bit word can be written as |
+ | Lv = a + b * 2^16 |
+ | where a= unsigned 16 LSBs and b= signed 16 MSBs. |
+ | The function returns v * Lv / 2^15 which is equivalent to |
+ | a*v / 2^15 + b*v*2 |
+ | |
+ | Complexity weight : 5 |
+ | |
+ | Inputs : |
+ | |
+ | Lv |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= var1 <= 0x7fff ffff. |
+ | v |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0x8000 <= var1 <= 0x7fff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 32 bit long signed integer (Word32) whose value falls in the |
+ | range : 0x8000 0000 <= var_out <= 0x7fff ffff. |
+ | |
+ |___________________________________________________________________________|
+*/
+Word32 L_mls (Word32 Lv, Word16 v) {
+ Word32 Temp;
+
+ Temp = Lv & (Word32) 0x0000ffff;
+ Temp = Temp * (Word32) v;
+ Temp = L_shr (Temp, (Word16) 15);
+ Temp = L_mac (Temp, v, extract_h (Lv));
+
+#if (WMOPS)
+ multiCounter[currCounter].L_shr--;
+ multiCounter[currCounter].L_mac--;
+ multiCounter[currCounter].extract_h--;
+ multiCounter[currCounter].L_mls++;
+#endif
+
+ return Temp;
+}
+
+
+/*__________________________________________________________________________
+| |
+| Function Name : div_l |
+| |
+| Purpose : |
+| |
+| Produces a result which is the fractional integer division of L_var1 by |
+| var2; L_var1 and var2 must be positive and var2 << 16 must be greater or|
+| equal to L_var1; the result is positive (leading bit equal to 0) and |
+| truncated to 16 bits. |
+| If L_var1 == var2 << 16 then div_l(L_var1,var2) = 32767. |
+| |
+| Complexity weight : 32 |
+| |
+| Inputs : |
+| |
+| L_var1 |
+| 32 bit long signed integer (Word32) whose value falls in the |
+| range : 0x0000 0000 <= var1 <= (var2 << 16) and var2 != 0. |
+| L_var1 must be considered as a Q.31 value |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : var1 <= (var2<< 16) <= 0x7fff0000 and var2 != 0. |
+| var2 must be considered as a Q.15 value |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| var_out |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0x0000 0000 <= var_out <= 0x0000 7fff. |
+| It's a Q15 value (point between b15 and b14). |
+|___________________________________________________________________________|
+*/
+Word16 div_l (Word32 L_num, Word16 den) {
+ Word16 var_out = (Word16) 0;
+ Word32 L_den;
+ Word16 iteration;
+
+#if (WMOPS)
+ multiCounter[currCounter].div_l++;
+#endif
+
+ if (den == (Word16) 0) {
+ printf ("Division by 0 in div_l, Fatal error \n");
+ exit (0);
+ }
+
+ if ((L_num < (Word32) 0) || (den < (Word16) 0)) {
+ printf ("Division Error in div_l, Fatal error \n");
+ exit (0);
+ }
+
+ L_den = L_deposit_h (den);
+#if (WMOPS)
+ multiCounter[currCounter].L_deposit_h--;
+#endif
+
+ if (L_num >= L_den) {
+ return MAX_16;
+ } else {
+ L_num = L_shr (L_num, (Word16) 1);
+ L_den = L_shr (L_den, (Word16) 1);
+#if (WMOPS)
+ multiCounter[currCounter].L_shr -= 2;
+#endif
+ for (iteration = (Word16) 0; iteration < (Word16) 15; iteration++) {
+ var_out = shl (var_out, (Word16) 1);
+ L_num = L_shl (L_num, (Word16) 1);
+#if (WMOPS)
+ multiCounter[currCounter].shl--;
+ multiCounter[currCounter].L_shl--;
+#endif
+ if (L_num >= L_den) {
+ L_num = L_sub (L_num, L_den);
+ var_out = add (var_out, (Word16) 1);
+#if (WMOPS)
+ multiCounter[currCounter].L_sub--;
+ multiCounter[currCounter].add--;
+#endif
+ }
+ }
+
+ return var_out;
+ }
+}
+
+
+/*__________________________________________________________________________
+| |
+| Function Name : i_mult |
+| |
+| Purpose : |
+| |
+| Integer 16-bit multiplication with overflow control. |
+| No overflow protection is performed if ORIGINAL_G7231 is defined. |
+| |
+| Complexity weight : 3 (it is performing something equivalent to |
+| extract_h( L_shl( L_mult0( v1, v2), 16)) |
+| |
+| Inputs : |
+| |
+| a |
+| 16 bit short signed integer (Word16). |
+| |
+| b |
+| 16 bit short signed integer (Word16). |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| 16 bit short signed integer (Word16). No overflow checks |
+| are performed if ORIGINAL_G7231 is defined. |
+|___________________________________________________________________________|
+*/
+Word16 i_mult (Word16 a, Word16 b) {
+#ifdef ORIGINAL_G7231
+ return a * b;
+#else
+ Word32 /*register*/ c = a * b;
+#if (WMOPS)
+ multiCounter[currCounter].i_mult++;
+#endif
+ return saturate (c);
+#endif
+}
+
+
+/*
+ ******************************************************************************
+ * The following three operators are not part of the original
+ * G.729/G.723.1 set of basic operators and implement shiftless
+ * accumulation operation.
+ ******************************************************************************
+*/
+
+/*___________________________________________________________________________
+ |
+ | Function Name : L_mult0
+ |
+ | Purpose :
+ |
+ | L_mult0 is the 32 bit result of the multiplication of var1 times var2
+ | without one left shift.
+ |
+ | Complexity weight : 1
+ |
+ | Inputs :
+ |
+ | var1 16 bit short signed integer (Word16) whose value falls in the
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff.
+ |
+ | var2 16 bit short signed integer (Word16) whose value falls in the
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff.
+ |
+ | Return Value :
+ |
+ | L_var_out
+ | 32 bit long signed integer (Word32) whose value falls in the
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ |___________________________________________________________________________
+*/
+Word32 L_mult0 (Word16 var1, Word16 var2) {
+ Word32 L_var_out;
+
+ L_var_out = (Word32) var1 *(Word32) var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].L_mult0++;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ |
+ | Function Name : L_mac0
+ |
+ | Purpose :
+ |
+ | Multiply var1 by var2 (without left shift) and add the 32 bit result to
+ | L_var3 with saturation, return a 32 bit result:
+ | L_mac0(L_var3,var1,var2) = L_add(L_var3,(L_mult0(var1,var2)).
+ |
+ | Complexity weight : 1
+ |
+ | Inputs :
+ |
+ | L_var3 32 bit long signed integer (Word32) whose value falls in the
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
+ |
+ | var1 16 bit short signed integer (Word16) whose value falls in the
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff.
+ |
+ | var2 16 bit short signed integer (Word16) whose value falls in the
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff.
+ |
+ | Return Value :
+ |
+ | L_var_out
+ | 32 bit long signed integer (Word32) whose value falls in the
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ |___________________________________________________________________________
+*/
+Word32 L_mac0 (Word32 L_var3, Word16 var1, Word16 var2) {
+ Word32 L_var_out;
+ Word32 L_product;
+
+ L_product = L_mult0 (var1, var2);
+ L_var_out = L_add (L_var3, L_product);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_mac0++;
+ multiCounter[currCounter].L_mult0--;
+ multiCounter[currCounter].L_add--;
+#endif
+ return (L_var_out);
+}
+
+
+/*___________________________________________________________________________
+ |
+ | Function Name : L_msu0
+ |
+ | Purpose :
+ |
+ | Multiply var1 by var2 (without left shift) and subtract the 32 bit
+ | result to L_var3 with saturation, return a 32 bit result:
+ | L_msu0(L_var3,var1,var2) = L_sub(L_var3,(L_mult0(var1,var2)).
+ |
+ | Complexity weight : 1
+ |
+ | Inputs :
+ |
+ | L_var3 32 bit long signed integer (Word32) whose value falls in the
+ | range : 0x8000 0000 <= L_var3 <= 0x7fff ffff.
+ |
+ | var1 16 bit short signed integer (Word16) whose value falls in the
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff.
+ |
+ | var2 16 bit short signed integer (Word16) whose value falls in the
+ | range : 0xffff 8000 <= var1 <= 0x0000 7fff.
+ |
+ | Return Value :
+ |
+ | L_var_out
+ | 32 bit long signed integer (Word32) whose value falls in the
+ | range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ |___________________________________________________________________________
+*/
+Word32 L_msu0 (Word32 L_var3, Word16 var1, Word16 var2) {
+ Word32 L_var_out;
+ Word32 L_product;
+
+ L_product = L_mult0 (var1, var2);
+ L_var_out = L_sub (L_var3, L_product);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_msu0++;
+ multiCounter[currCounter].L_mult0--;
+ multiCounter[currCounter].L_sub--;
+#endif
+ return (L_var_out);
+}
+
+
+/* end of file */
diff --git a/basic_op/basop32.h b/basic_op/basop32.h
new file mode 100644
index 0000000000000000000000000000000000000000..a9d63775bd1251c0747e150e117923c47bd42880
--- /dev/null
+++ b/basic_op/basop32.h
@@ -0,0 +1,130 @@
+/*
+ ===========================================================================
+ File: BASOP32.H v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ GLOBAL FUNCTION PROTOTYPES
+
+ History:
+ 26.Jan.00 v1.0 Incorporated to the STL from updated G.723.1/G.729
+ basic operator library (based on basic_op.h) and
+ G.723.1's basop.h.
+ 05.Jul.00 v1.1 Added 32-bit shiftless mult/mac/msub operators
+
+ 03 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ norm_s() weight reduced from 15 to 1.
+ norm_l() weight reduced from 30 to 1.
+ L_abs() weight reduced from 2 to 1.
+ L_add() weight reduced from 2 to 1.
+ L_negate() weight reduced from 2 to 1.
+ L_shl() weight reduced from 2 to 1.
+ L_shr() weight reduced from 2 to 1.
+ L_sub() weight reduced from 2 to 1.
+ mac_r() weight reduced from 2 to 1.
+ msu_r() weight reduced from 2 to 1.
+ mult_r() weight reduced from 2 to 1.
+ L_deposit_h() weight reduced from 2 to 1.
+ L_deposit_l() weight reduced from 2 to 1.
+ L_mls() weight of 5.
+ div_l() weight of 32.
+ i_mult() weight of 3.
+
+ 30 Nov 09 v2.3 round() function is now round_fx().
+ saturate() is not referencable from outside application
+ ============================================================================
+*/
+
+
+#ifndef _BASIC_OP_H
+#define _BASIC_OP_H
+
+
+/*___________________________________________________________________________
+ | |
+ | Constants and Globals |
+ | $Id $
+ |___________________________________________________________________________|
+*/
+extern Flag Overflow;
+extern Flag Carry;
+
+#define BASOP_SATURATE_WARNING_ON
+#define BASOP_SATURATE_WARNING_OFF
+#define BASOP_SATURATE_ERROR_ON
+#define BASOP_SATURATE_ERROR_OFF
+#define BASOP_CHECK()
+
+#define MAX_32 (Word32)0x7fffffffL
+#define MIN_32 (Word32)0x80000000L
+
+#define MAX_16 (Word16)0x7fff
+#define MIN_16 (Word16)0x8000
+
+/*___________________________________________________________________________
+ | |
+ | Prototypes for basic arithmetic operators |
+ |___________________________________________________________________________|
+*/
+
+Word16 add (Word16 var1, Word16 var2); /* Short add, 1 */
+Word16 sub (Word16 var1, Word16 var2); /* Short sub, 1 */
+Word16 abs_s (Word16 var1); /* Short abs, 1 */
+Word16 shl (Word16 var1, Word16 var2); /* Short shift left, 1 */
+Word16 shr (Word16 var1, Word16 var2); /* Short shift right, 1 */
+Word16 mult (Word16 var1, Word16 var2); /* Short mult, 1 */
+Word32 L_mult (Word16 var1, Word16 var2); /* Long mult, 1 */
+Word16 negate (Word16 var1); /* Short negate, 1 */
+Word16 extract_h (Word32 L_var1); /* Extract high, 1 */
+Word16 extract_l (Word32 L_var1); /* Extract low, 1 */
+Word16 round_fx (Word32 L_var1); /* Round, 1 */
+Word32 L_mac (Word32 L_var3, Word16 var1, Word16 var2); /* Mac, 1 */
+Word32 L_msu (Word32 L_var3, Word16 var1, Word16 var2); /* Msu, 1 */
+Word32 L_macNs (Word32 L_var3, Word16 var1, Word16 var2); /* Mac without sat, 1 */
+Word32 L_msuNs (Word32 L_var3, Word16 var1, Word16 var2); /* Msu without sat, 1 */
+Word32 L_add (Word32 L_var1, Word32 L_var2); /* Long add, 1 */
+Word32 L_sub (Word32 L_var1, Word32 L_var2); /* Long sub, 1 */
+Word32 L_add_c (Word32 L_var1, Word32 L_var2); /* Long add with c, 2 */
+Word32 L_sub_c (Word32 L_var1, Word32 L_var2); /* Long sub with c, 2 */
+Word32 L_negate (Word32 L_var1); /* Long negate, 1 */
+Word16 mult_r (Word16 var1, Word16 var2); /* Mult with round, 1 */
+Word32 L_shl (Word32 L_var1, Word16 var2); /* Long shift left, 1 */
+Word32 L_shr (Word32 L_var1, Word16 var2); /* Long shift right, 1 */
+Word16 shr_r (Word16 var1, Word16 var2); /* Shift right with round, 2 */
+Word16 mac_r (Word32 L_var3, Word16 var1, Word16 var2); /* Mac with rounding, 1 */
+Word16 msu_r (Word32 L_var3, Word16 var1, Word16 var2); /* Msu with rounding, 1 */
+Word32 L_deposit_h (Word16 var1); /* 16 bit var1 -> MSB, 1 */
+Word32 L_deposit_l (Word16 var1); /* 16 bit var1 -> LSB, 1 */
+
+Word32 L_shr_r (Word32 L_var1, Word16 var2); /* Long shift right with round, 3 */
+Word32 L_abs (Word32 L_var1); /* Long abs, 1 */
+Word32 L_sat (Word32 L_var1); /* Long saturation, 4 */
+Word16 norm_s (Word16 var1); /* Short norm, 1 */
+Word16 div_s (Word16 var1, Word16 var2); /* Short division, 18 */
+Word16 norm_l (Word32 L_var1); /* Long norm, 1 */
+
+
+/*
+ * Additional G.723.1 operators
+*/
+Word32 L_mls (Word32, Word16); /* Weight FFS; currently assigned 5 */
+Word16 div_l (Word32, Word16); /* Weight FFS; currently assigned 32 */
+Word16 i_mult (Word16 a, Word16 b); /* Weight FFS; currently assigned 3 */
+
+/*
+ * New shiftless operators, not used in G.729/G.723.1
+*/
+Word32 L_mult0 (Word16 v1, Word16 v2); /* 32-bit Multiply w/o shift e 1 */
+Word32 L_mac0 (Word32 L_v3, Word16 v1, Word16 v2); /* 32-bit Mac w/o shift 1 */
+Word32 L_msu0 (Word32 L_v3, Word16 v1, Word16 v2); /* 32-bit Msu w/o shift 1 */
+
+
+#endif /* ifndef _BASIC_OP_H */
+
+
+/* end of file */
diff --git a/basic_op/complex_basop.c b/basic_op/complex_basop.c
new file mode 100644
index 0000000000000000000000000000000000000000..3a65d65a6eaeac6a9ce75edbea4d3544a6a82e3a
--- /dev/null
+++ b/basic_op/complex_basop.c
@@ -0,0 +1,457 @@
+/*****************************************************************************
+
+*
+
+* Complex arithmetic operators
+
+*
+
+*****************************************************************************/
+
+
+#include "typedef.h"
+#include "basop32.h"
+
+#include "complex_basop.h"
+
+#include "stl.h"
+
+
+
+#if (WMOPS)
+
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+
+extern int currCounter;
+
+#endif /* if WMOPS */
+
+
+
+#ifdef COMPLEX_OPERATOR
+
+/* ================================ New Complex Basops ========================= */
+
+cmplx CL_shr (cmplx inp, Word32 shift_val) {
+ cmplx out;
+ out.re = L_shr (inp.re, shift_val);
+ out.im = L_shr (inp.im, shift_val);
+#if (WMOPS)
+ multiCounter[currCounter].CL_shr++;
+ multiCounter[currCounter].L_shr--;
+ multiCounter[currCounter].L_shr--;
+#endif
+ return out;
+}
+
+cmplx CL_shl (cmplx inp, Word32 shift_val) {
+ cmplx out;
+ out.re = L_shl (inp.re, shift_val);
+ out.im = L_shl (inp.im, shift_val);
+#if (WMOPS)
+ multiCounter[currCounter].CL_shl++;
+ multiCounter[currCounter].L_shl--;
+ multiCounter[currCounter].L_shl--;
+#endif
+ return out;
+}
+
+cmplx CL_add (cmplx inp1, cmplx inp2) {
+ cmplx out;
+ out.re = L_add (inp1.re, inp2.re);
+ out.im = L_add (inp1.im, inp2.im);
+#if (WMOPS)
+ multiCounter[currCounter].CL_add++;
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].L_add--;
+#endif
+ return out;
+}
+
+cmplx CL_sub (cmplx inp1, cmplx inp2) {
+ cmplx out;
+ out.re = L_sub (inp1.re, inp2.re);
+ out.im = L_sub (inp1.im, inp2.im);
+#if (WMOPS)
+ multiCounter[currCounter].CL_sub++;
+ multiCounter[currCounter].L_sub--;
+ multiCounter[currCounter].L_sub--;
+#endif
+ return out;
+}
+
+cmplx CL_scale(cmplx x, Word16 y) {
+ cmplx result;
+ result.re = Mpy_32_16_r (x.re, y);
+ result.im = Mpy_32_16_r (x.im, y);
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_r--;
+ multiCounter[currCounter].Mpy_32_16_r--;
+ multiCounter[currCounter].CL_scale++;
+#endif/* #if (WMOPS) */
+ return (result);
+}
+
+cmplx CL_dscale (cmplx x, Word16 y1, Word16 y2) {
+ cmplx result;
+ result.re = Mpy_32_16_r (x.re, y1);
+ result.im = Mpy_32_16_r (x.im, y2);
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_r--;
+ multiCounter[currCounter].Mpy_32_16_r--;
+ multiCounter[currCounter].CL_dscale++;
+#endif/* #if (WMOPS) */
+ return (result);
+}
+
+cmplx CL_msu_j (cmplx x, cmplx y) {
+ cmplx result;
+ result.re = L_add (x.re, y.im);
+ result.im = L_sub (x.im, y.re);
+#if (WMOPS)
+ multiCounter[currCounter].CL_msu_j++;
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].L_sub--;
+#endif
+ return result;
+}
+
+cmplx CL_mac_j (cmplx x, cmplx y) {
+ cmplx result;
+ result.re = L_sub (x.re, y.im );
+ result.im = L_add (x.im, y.re );
+#if (WMOPS)
+ multiCounter[currCounter].CL_mac_j++;
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].L_sub--;
+#endif
+ return result;
+}
+
+cmplx CL_move (cmplx x) {
+#if (WMOPS)
+ multiCounter[currCounter].CL_move++;
+#endif
+ return x;
+}
+
+Word32 CL_Extract_real (cmplx x) {
+#if (WMOPS)
+ multiCounter[currCounter].CL_Extract_real++;
+#endif
+ return x.re;
+}
+
+Word32 CL_Extract_imag (cmplx x) {
+#if (WMOPS)
+ multiCounter[currCounter].CL_Extract_imag++;
+#endif
+ return x.im;
+}
+
+cmplx CL_form (Word32 re, Word32 im) {
+ cmplx result;
+ result.re = re;
+ result.im = im;
+#if (WMOPS)
+ multiCounter[currCounter].CL_form++;
+#endif
+ return result;
+}
+
+cmplx CL_multr_32x16 (cmplx input, cmplx_s coeff) {
+ cmplx result;
+ result.re = W_round48_L (W_sub_nosat (W_mult_32_16 (input.re, coeff.re), W_mult_32_16 (input.im, coeff.im) ) );
+ result.im = W_round48_L (W_add_nosat (W_mult_32_16 (input.re, coeff.im), W_mult_32_16 (input.im, coeff.re) ) );
+#if (WMOPS)
+ multiCounter[currCounter].CL_multr_32x16++;
+ multiCounter[currCounter].W_mult_32_16--;
+ multiCounter[currCounter].W_mult_32_16--;
+ multiCounter[currCounter].W_mult_32_16--;
+ multiCounter[currCounter].W_mult_32_16--;
+ multiCounter[currCounter].W_sub_nosat--;
+ multiCounter[currCounter].W_add_nosat--;
+ multiCounter[currCounter].W_round48_L--;
+ multiCounter[currCounter].W_round48_L--;
+#endif
+ return result;
+}
+
+cmplx CL_negate(cmplx x) {
+ cmplx result;
+ result.re = L_negate (x.re);
+ result.im = L_negate (x.im);
+#if (WMOPS)
+ multiCounter[currCounter].CL_negate++;
+ multiCounter[currCounter].L_negate--;
+ multiCounter[currCounter].L_negate--;
+#endif
+ return result;
+}
+
+cmplx CL_conjugate (cmplx x) {
+ cmplx result;
+ result.re = x.re;
+ result.im = L_negate (x.im);
+#if (WMOPS)
+ multiCounter[currCounter].CL_conjugate++;
+ multiCounter[currCounter].L_negate--;
+#endif
+ return result;
+}
+
+
+cmplx CL_mul_j (cmplx input) {
+ cmplx temp, result;
+ temp = CL_negate (input);
+ result.re = temp.im;
+ result.im = input.re;
+#if (WMOPS)
+ multiCounter[currCounter].CL_mul_j++;
+ multiCounter[currCounter].CL_negate--;
+#endif
+ return result;
+}
+
+cmplx CL_swap_real_imag (cmplx input) {
+ cmplx result;
+ result.re = input.im;
+ result.im = input.re;
+#if (WMOPS)
+ multiCounter[currCounter].CL_swap_real_imag++;
+#endif
+ return result;
+}
+
+cmplx_s C_add (cmplx_s inp1, cmplx_s inp2) {
+ cmplx_s out;
+ out.re = add (inp1.re, inp2.re);
+ out.im = add (inp1.im, inp2.im);
+
+#if (WMOPS)
+ multiCounter[currCounter].C_add++;
+ multiCounter[currCounter].add--;
+ multiCounter[currCounter].add--;
+#endif
+ return out;
+}
+
+cmplx_s C_sub (cmplx_s inp1, cmplx_s inp2) {
+ cmplx_s out;
+ out.re = sub (inp1.re, inp2.re);
+ out.im = sub (inp1.im, inp2.im);
+
+#if (WMOPS)
+ multiCounter[currCounter].C_sub++;
+ multiCounter[currCounter].sub--;
+ multiCounter[currCounter].sub--;
+#endif
+ return out;
+}
+
+cmplx_s C_mul_j (cmplx_s input) {
+ cmplx_s result;
+ Word16 temp;
+ temp = negate(input.im);
+ result.re = temp;
+ result.im = input.re;
+
+#if (WMOPS)
+ multiCounter[currCounter].C_mul_j++;
+ multiCounter[currCounter].negate--;
+#endif
+ return result;
+}
+
+cmplx_s C_multr (cmplx_s x, cmplx_s c) {
+ cmplx_s result;
+ result.re = round_fx (W_sat_l (W_sub_nosat (W_mult_16_16 (x.re, c.re), W_mult_16_16 (x.im, c.im) ) ) );
+ result.im = round_fx (W_sat_l (W_add_nosat (W_mult_16_16 (x.im, c.re), W_mult_16_16 (x.re, c.im) ) ) );
+
+#if (WMOPS)
+ multiCounter[currCounter].C_multr++;
+ multiCounter[currCounter].W_mult_16_16--;
+ multiCounter[currCounter].W_mult_16_16--;
+ multiCounter[currCounter].W_mult_16_16--;
+ multiCounter[currCounter].W_mult_16_16--;
+ multiCounter[currCounter].W_sub_nosat--;
+ multiCounter[currCounter].W_add_nosat--;
+ multiCounter[currCounter].W_sat_l--;
+ multiCounter[currCounter].W_sat_l--;
+ multiCounter[currCounter].round--;
+ multiCounter[currCounter].round--;
+#endif
+ return result;
+}
+
+cmplx_s C_form ( Word16 re, Word16 im) {
+ cmplx_s result;
+ result.re = re;
+ result.im = im;
+#if (WMOPS)
+ multiCounter[currCounter].C_form++;
+#endif
+ return result;
+}
+
+cmplx C_scale(cmplx_s x, Word16 y) {
+ cmplx result;
+ result.re = L_mult(x.re, y);
+ result.im = L_mult(x.im, y);
+#if (WMOPS)
+ multiCounter[currCounter].L_mult--;
+ multiCounter[currCounter].L_mult--;
+ multiCounter[currCounter].C_scale++;
+#endif/* #if (WMOPS) */
+ return (result);
+}
+
+cmplx_s CL_round32_16 (cmplx x) {
+ cmplx_s result;
+ result.re = round_fx (x.re);
+ result.im = round_fx (x.im);
+
+#if (WMOPS)
+ multiCounter[currCounter].CL_round32_16++;
+ multiCounter[currCounter].round--;
+ multiCounter[currCounter].round--;
+#endif
+ return result;
+}
+
+cmplx CL_scale_32 (cmplx x, Word32 y) {
+ cmplx result;
+ result.re = Mpy_32_32_r (x.re, y);
+ result.im = Mpy_32_32_r (x.im, y);
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_32_r--;
+ multiCounter[currCounter].Mpy_32_32_r--;
+ multiCounter[currCounter].CL_scale_32++;
+#endif/* #if (WMOPS) */
+ return (result);
+}
+
+cmplx CL_dscale_32 (cmplx x, Word32 y1, Word32 y2) {
+ cmplx result;
+ result.re = Mpy_32_32_r (x.re, y1);
+ result.im = Mpy_32_32_r (x.im, y2);
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_32_r--;
+ multiCounter[currCounter].Mpy_32_32_r--;
+ multiCounter[currCounter].CL_dscale_32++;
+#endif/* #if (WMOPS) */
+ return (result);
+}
+
+cmplx CL_multr_32x32 (cmplx x, cmplx y) {
+ cmplx result;
+ result.re = W_round64_L (W_sub (W_mult_32_32 (x.re, y.re), W_mult_32_32(x.im, y.im) ) ) ;
+ result.im = W_round64_L (W_add (W_mult_32_32 (x.im, y.re), W_mult_32_32(x.re, y.im) ) ) ;
+
+#if (WMOPS)
+ multiCounter[currCounter].CL_multr_32x32++;
+ multiCounter[currCounter].W_mult_32_32--;
+ multiCounter[currCounter].W_mult_32_32--;
+ multiCounter[currCounter].W_mult_32_32--;
+ multiCounter[currCounter].W_mult_32_32--;
+ multiCounter[currCounter].W_round64_L--;
+ multiCounter[currCounter].W_round64_L--;
+ multiCounter[currCounter].W_sub--;
+ multiCounter[currCounter].W_add--;
+#endif
+ return result;
+}
+
+cmplx_s C_mac_r (cmplx x, cmplx_s y, Word16 c) {
+ cmplx_s result;
+ cmplx temp = CL_add (x, C_scale (y, c) );
+ result = CL_round32_16 (temp);
+
+#if (WMOPS)
+ multiCounter[currCounter].C_mac_r++;
+ multiCounter[currCounter].CL_add--;
+ multiCounter[currCounter].C_scale--;
+ multiCounter[currCounter].CL_round32_16--;
+#endif
+ return result;
+}
+
+cmplx_s C_msu_r (cmplx x, cmplx_s y, Word16 c) {
+ cmplx_s result;
+ cmplx temp = CL_sub (x, C_scale (y, c) );
+ result = CL_round32_16 (temp);
+
+#if (WMOPS)
+ multiCounter[currCounter].C_msu_r++;
+ multiCounter[currCounter].CL_sub--;
+ multiCounter[currCounter].C_scale--;
+ multiCounter[currCounter].CL_round32_16--;
+#endif
+ return result;
+}
+
+Word16 C_Extract_real (cmplx_s x) {
+#if (WMOPS)
+ multiCounter[currCounter].C_Extract_real++;
+#endif
+ return x.re;
+}
+
+Word16 C_Extract_imag (cmplx_s x) {
+#if (WMOPS)
+ multiCounter[currCounter].C_Extract_imag++;
+#endif
+ return x.im;
+}
+
+cmplx_s C_negate (cmplx_s x) {
+ cmplx_s result;
+ result.re = negate (x.re);
+ result.im = negate (x.im);
+#if (WMOPS)
+ multiCounter[currCounter].C_negate++;
+ multiCounter[currCounter].negate--;
+ multiCounter[currCounter].negate--;
+#endif
+ return result;
+}
+
+cmplx_s C_conjugate (cmplx_s x) {
+ cmplx_s result;
+ result.re = x.re;
+ result.im = negate (x.im);
+#if (WMOPS)
+ multiCounter[currCounter].C_conjugate++;
+ multiCounter[currCounter].negate--;
+#endif
+ return result;
+}
+
+cmplx_s C_shr (cmplx_s inp, Word16 shift_val) {
+ cmplx_s out;
+ out.re = shr (inp.re, shift_val);
+ out.im = shr (inp.im, shift_val);
+#if (WMOPS)
+ multiCounter[currCounter].C_shr++;
+ multiCounter[currCounter].shr--;
+ multiCounter[currCounter].shr--;
+#endif
+ return out;
+}
+
+cmplx_s C_shl (cmplx_s inp, Word16 shift_val) {
+ cmplx_s out;
+ out.re = shl (inp.re, shift_val);
+ out.im = shl (inp.im, shift_val);
+#if (WMOPS)
+ multiCounter[currCounter].C_shl++;
+ multiCounter[currCounter].shl--;
+ multiCounter[currCounter].shl--;
+#endif
+ return out;
+}
+
+#endif /* #ifdef COMPLEX_OPERATOR */
+
+/* end of file */
+
diff --git a/basic_op/complex_basop.h b/basic_op/complex_basop.h
new file mode 100644
index 0000000000000000000000000000000000000000..c3deb1455737a515e47b18c2c1e76c51573646ff
--- /dev/null
+++ b/basic_op/complex_basop.h
@@ -0,0 +1,77 @@
+ /*****************************************************************************
+
+ *
+
+ * Complex arithmetic operators
+
+ *
+
+ *****************************************************************************/
+#ifndef _COMPLEX_BASIC_OP_H
+#define _COMPLEX_BASIC_OP_H
+
+#include "typedef.h"
+#include "basop32.h"
+#include "stl.h"
+
+#ifdef COMPLEX_OPERATOR
+
+typedef struct
+{
+ Word32 re;
+ Word32 im;
+}cmplx;
+
+typedef struct
+{
+ Word16 re;
+ Word16 im;
+}cmplx_s;
+
+/*___________________________________________________________________________
+ | |
+ | Prototypes for complex arithmetic operators |
+ |___________________________________________________________________________|
+*/
+
+cmplx CL_shr (cmplx inp, Word32 shift_val);
+cmplx CL_shl (cmplx inp, Word32 shift_val);
+cmplx CL_add (cmplx inp1, cmplx inp2);
+cmplx CL_sub (cmplx inp1, cmplx inp2);
+cmplx CL_scale (cmplx x, Word16 y);
+cmplx CL_dscale (cmplx x, Word16 y1, Word16 y2);
+cmplx CL_msu_j (cmplx x, cmplx y);
+cmplx CL_mac_j (cmplx x, cmplx y);
+cmplx CL_move (cmplx x);
+Word32 CL_Extract_real (cmplx x);
+Word32 CL_Extract_imag (cmplx x);
+cmplx CL_form (Word32 re, Word32 im);
+cmplx CL_multr_32x16 (cmplx input, cmplx_s coeff);
+cmplx CL_negate (cmplx x);
+cmplx CL_conjugate (cmplx x);
+cmplx CL_mul_j (cmplx input);
+cmplx CL_swap_real_imag (cmplx input);
+cmplx_s C_add (cmplx_s inp1, cmplx_s inp2);
+cmplx_s C_sub (cmplx_s inp1, cmplx_s inp2);
+cmplx_s C_mul_j (cmplx_s input);
+cmplx_s C_multr (cmplx_s x, cmplx_s c);
+cmplx_s C_form (Word16 re, Word16 im );
+
+cmplx C_scale (cmplx_s x, Word16 y);
+cmplx_s CL_round32_16 (cmplx x);
+cmplx CL_scale_32 (cmplx x, Word32 y);
+cmplx CL_dscale_32 (cmplx x, Word32 y1, Word32 y2);
+cmplx CL_multr_32x32 (cmplx x, cmplx y);
+cmplx_s C_mac_r (cmplx x, cmplx_s y, Word16 c);
+cmplx_s C_msu_r (cmplx x, cmplx_s y, Word16 c);
+Word16 C_Extract_real (cmplx_s x );
+Word16 C_Extract_imag (cmplx_s x );
+cmplx_s C_negate (cmplx_s x);
+cmplx_s C_conjugate (cmplx_s x);
+cmplx_s C_shr (cmplx_s inp, Word16 shift_val);
+cmplx_s C_shl (cmplx_s inp, Word16 shift_val);
+
+#endif /* #ifdef COMPLEX_OPERATOR */
+
+#endif /* ifndef _COMPLEX_BASIC_OP_H */
+
diff --git a/basic_op/control.c b/basic_op/control.c
new file mode 100644
index 0000000000000000000000000000000000000000..2d0a46c25a507116919306e55deb85c40e3772fe
--- /dev/null
+++ b/basic_op/control.c
@@ -0,0 +1,250 @@
+/*
+ ===========================================================================
+ File: CONTROL.C v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ CONTROL FLOW OPERATOR INTERNAL VARIABLE DECLARATIONS
+
+ History:
+ 07 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ March 06 v2.1 Changed to improve portability.
+
+ ============================================================================
+*/
+
+#include "stl.h"
+
+#ifdef WMOPS
+int funcId_where_last_call_to_else_occurred;
+long funcid_total_wmops_at_last_call_to_else;
+int call_occurred = 1;
+#endif
+
+#ifdef CONTROL_CODE_OPS
+
+Flag LT_16 (Word16 var1, Word16 var2) {
+ Flag F_ret = 0;
+
+ if( var1 < var2 )
+ {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].LT_16++;
+#endif
+ return F_ret;
+}
+
+Flag GT_16 (Word16 var1, Word16 var2) {
+ Flag F_ret = 0;
+
+ if( var1 > var2 )
+ {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].GT_16++;
+#endif
+ return F_ret;
+}
+
+Flag LE_16 (Word16 var1, Word16 var2) {
+ Flag F_ret = 0;
+
+ if (var1 <= var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].LE_16++;
+#endif
+ return F_ret;
+}
+
+Flag GE_16 (Word16 var1, Word16 var2) {
+ Flag F_ret = 0;
+
+ if (var1 >= var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].GE_16++;
+#endif
+ return F_ret;
+}
+
+Flag EQ_16 (Word16 var1, Word16 var2) {
+ Flag F_ret = 0;
+
+ if (var1 == var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].EQ_16++;
+#endif
+ return F_ret;
+}
+
+Flag NE_16 (Word16 var1, Word16 var2) {
+ Flag F_ret = 0;
+
+ if (var1 != var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].NE_16++;
+#endif
+ return F_ret;
+}
+
+Flag LT_32 (Word32 L_var1, Word32 L_var2) {
+ Flag F_ret = 0;
+
+ if (L_var1 < L_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].LT_32++;
+#endif
+ return F_ret;
+}
+
+Flag GT_32 (Word32 L_var1, Word32 L_var2) {
+ Flag F_ret = 0;
+
+ if (L_var1 > L_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].GT_32++;
+#endif
+ return F_ret;
+}
+
+Flag LE_32 (Word32 L_var1, Word32 L_var2) {
+ Flag F_ret = 0;
+
+ if (L_var1 <= L_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].LE_32++;
+#endif
+ return F_ret;
+}
+
+Flag GE_32 (Word32 L_var1, Word32 L_var2) {
+ Flag F_ret = 0;
+
+ if (L_var1 >= L_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].GE_32++;
+#endif
+ return F_ret;
+}
+
+Flag EQ_32 (Word32 L_var1, Word32 L_var2) {
+ Flag F_ret = 0;
+
+ if (L_var1 == L_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].EQ_32++;
+#endif
+ return F_ret;
+}
+
+Flag NE_32 (Word32 L_var1, Word32 L_var2) {
+ Flag F_ret = 0;
+
+ if (L_var1 != L_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].NE_32++;
+#endif
+ return F_ret;
+}
+
+Flag LT_64 (Word64 L64_var1, Word64 L64_var2) {
+ Flag F_ret = 0;
+
+ if (L64_var1 < L64_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].LT_64++;
+#endif
+ return F_ret;
+}
+
+Flag GT_64 (Word64 L64_var1, Word64 L64_var2) {
+ Flag F_ret = 0;
+
+ if (L64_var1 > L64_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].GT_64++;
+#endif
+ return F_ret;
+}
+
+Flag LE_64 (Word64 L64_var1, Word64 L64_var2) {
+ Flag F_ret = 0;
+
+ if (L64_var1 <= L64_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].LE_64++;
+#endif
+ return F_ret;
+}
+Flag GE_64 (Word64 L64_var1, Word64 L64_var2) {
+ Flag F_ret = 0;
+
+ if (L64_var1 >= L64_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].GE_64++;
+#endif
+ return F_ret;
+}
+
+Flag EQ_64 (Word64 L64_var1, Word64 L64_var2) {
+ Flag F_ret = 0;
+
+ if (L64_var1 == L64_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].EQ_64++;
+#endif
+ return F_ret;
+}
+Flag NE_64 (Word64 L64_var1, Word64 L64_var2) {
+ Flag F_ret = 0;
+
+ if (L64_var1 != L64_var2) {
+ F_ret = 1;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].NE_64++;
+#endif
+ return F_ret;
+}
+
+#endif /* #ifdef CONTROL_CODE_OPS */
+
+
+/* end of file */
diff --git a/basic_op/control.h b/basic_op/control.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f406e25ba9a9158328f127e6a970c4aa226324d
--- /dev/null
+++ b/basic_op/control.h
@@ -0,0 +1,332 @@
+/*
+ ===========================================================================
+ File: CONTROL.H v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ CONTROL FLOW OPERATORS
+
+ History:
+ 07 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ March 06 v2.1 Changed to improve portability.
+
+ ============================================================================
+*/
+
+#ifndef _CONTROL_H
+#define _CONTROL_H
+
+#include "stl.h"
+
+
+/*****************************************************************************
+ *
+ * Constants and Globals
+ *
+ *****************************************************************************/
+#if (WMOPS)
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+extern int currCounter;
+
+ /* Technical note :
+ * The following 3 variables are only used for correct complexity
+ * evaluation of the following structure :
+ * IF{
+ * ...
+ * } ELSE IF {
+ * ...
+ * } ELSE IF {
+ * ...
+ * }
+ * ...
+ * } ELSE {
+ * ...
+ * }
+ */
+extern int funcId_where_last_call_to_else_occurred;
+extern long funcid_total_wmops_at_last_call_to_else;
+extern int call_occurred;
+#endif /* ifdef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Function Macros
+ *
+ *****************************************************************************/
+
+/*****************************************************************************
+ *
+ * Function Name : FOR
+ *
+ * Purpose :
+ *
+ * The macro FOR should be used instead of the 'for' C statement.
+ * The complexity is independent of the number of loop iterations that are
+ * performed.
+ *
+ * Complexity weight : 3 (regardless of number of iterations).
+ *
+ *****************************************************************************/
+#ifndef WMOPS
+#define FOR( a) for( a)
+
+#else /* ifndef WMOPS */
+#define FOR( a) if( incrFor(), 0); else for( a)
+
+static __inline void incrFor (void) {
+ multiCounter[currCounter].For++;
+}
+#endif /* ifndef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Function Name : WHILE
+ *
+ * Purpose :
+ *
+ * The macro WHILE should be used instead of the 'while' C statement.
+ * The complexity is proportional to the number of loop iterations that
+ * are performed.
+ *
+ * Complexity weight : 4 x 'number of loop iterations'.
+ *
+ *****************************************************************************/
+#ifndef WMOPS
+#define WHILE(a) while (a)
+
+#else /* ifndef WMOPS */
+#define WHILE(a) while (incrWhile(), a)
+
+static __inline void incrWhile (void) {
+ multiCounter[currCounter].While++;
+}
+#endif /* ifndef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Function Name : DO
+ *
+ * Purpose :
+ *
+ * The macro DO should be used instead of the 'do' C statement.
+ *
+ * Complexity weight : 0 (complexity counted by WHILE macro).
+ *
+ *****************************************************************************/
+#ifndef WMOPS
+#define DO do
+
+#else /* ifndef WMOPS */
+#define DO do
+
+#endif /* ifndef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Function Name : IF
+ *
+ * Purpose :
+ *
+ * The macro IF should :
+ *
+ * - not be used when :
+ * - the 'if' structure does not have any 'else if' nor 'else' statement
+ * - and it conditions only one DSP basic operations.
+ *
+ * - be used instead of the 'if' C statement in every other case :
+ * - when there is an 'else' or 'else if' statement,
+ * - or when the 'if' conditions several DSP basic operations,
+ * - or when the 'if' conditions a function call.
+ *
+ * Complexity weight : 4
+ *
+ *****************************************************************************/
+#ifndef WMOPS
+#define IF(a) if (a)
+
+#else /* ifndef WMOPS */
+#define IF(a) if (incrIf (), a)
+
+static __inline void incrIf (void) {
+ /* Technical note :
+ * If the "IF" operator comes just after an "ELSE", its counter
+ * must not be incremented.
+ */
+ if ((currCounter != funcId_where_last_call_to_else_occurred)
+ || (TotalWeightedOperation () != funcid_total_wmops_at_last_call_to_else)
+ || (call_occurred == 1))
+ multiCounter[currCounter].If++;
+
+ call_occurred = 0;
+ funcId_where_last_call_to_else_occurred = MAXCOUNTERS;
+}
+#endif /* ifndef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Function Name : ELSE
+ *
+ * Purpose :
+ *
+ * The macro ELSE should be used instead of the 'else' C statement.
+ *
+ * Complexity weight : 4
+ *
+ *****************************************************************************/
+#ifndef WMOPS
+#define ELSE else
+
+#else /* ifndef WMOPS */
+#define ELSE else if (incrElse (), 0) ; else
+
+static __inline void incrElse (void) {
+ multiCounter[currCounter].If++;
+
+ /* We keep track of the funcId of the last function which used ELSE {...} structure. */
+ funcId_where_last_call_to_else_occurred = currCounter;
+
+ /* We keep track of the number of WMOPS of this funcId when the ELSE macro was called. */
+ funcid_total_wmops_at_last_call_to_else = TotalWeightedOperation ();
+
+ /* call_occurred is set to 0, in order to count the next IF (if necessary) */
+ call_occurred = 0;
+}
+#endif /* ifndef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Function Name : SWITCH
+ *
+ * Purpose :
+ *
+ * The macro SWITCH should be used instead of the 'switch' C statement.
+ *
+ * Complexity weight : 8
+ *
+ *****************************************************************************/
+#ifndef WMOPS
+#define SWITCH(a) switch (a)
+
+#else /* ifndef WMOPS */
+#define SWITCH(a) switch (incrSwitch (), a)
+
+static __inline void incrSwitch (void) {
+ multiCounter[currCounter].Switch++;
+}
+#endif /* ifndef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Function Name : CONTINUE
+ *
+ * Purpose :
+ *
+ * The macro CONTINUE should be used instead of the 'continue' C statement.
+ *
+ * Complexity weight : 4
+ *
+ *****************************************************************************/
+#ifndef WMOPS
+#define CONTINUE continue
+
+#else /* ifndef WMOPS */
+#define CONTINUE if (incrContinue (), 0); else continue
+
+static __inline void incrContinue (void) {
+ multiCounter[currCounter].Continue++;
+}
+#endif /* ifndef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Function Name : BREAK
+ *
+ * Purpose :
+ *
+ * The macro BREAK should be used instead of the 'break' C statement.
+ *
+ * Complexity weight : 4
+ *
+ *****************************************************************************/
+#ifndef WMOPS
+#define BREAK break
+
+#else /* ifndef WMOPS */
+#define BREAK if (incrBreak (), 0); else break
+
+static __inline void incrBreak (void) {
+ multiCounter[currCounter].Break++;
+}
+#endif /* ifndef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Function Name : GOTO
+ *
+ * Purpose :
+ *
+ * The macro GOTO should be used instead of the 'goto' C statement.
+ *
+ * Complexity weight : 4
+ *
+ *****************************************************************************/
+#ifndef WMOPS
+#define GOTO goto
+
+#else /* ifndef WMOPS */
+#define GOTO if (incrGoto (), 0); else goto
+
+static __inline void incrGoto (void) {
+ multiCounter[currCounter].Goto++;
+}
+#endif /* ifndef WMOPS */
+
+
+
+/*
+ * New control code basops
+*/
+#ifdef CONTROL_CODE_OPS
+
+Flag LT_16 (Word16 var1, Word16 var2);
+Flag GT_16 (Word16 var1, Word16 var2);
+Flag LE_16 (Word16 var1, Word16 var2);
+Flag GE_16 (Word16 var1, Word16 var2);
+Flag EQ_16 (Word16 var1, Word16 var2);
+Flag NE_16 (Word16 var1, Word16 var2);
+
+Flag LT_32 (Word32 L_var1, Word32 L_var2);
+Flag GT_32 (Word32 L_var1, Word32 L_var2);
+Flag LE_32 (Word32 L_var1, Word32 L_var2);
+Flag GE_32 (Word32 L_var1, Word32 L_var2);
+Flag EQ_32 (Word32 L_var1, Word32 L_var2);
+Flag NE_32 (Word32 L_var1, Word32 L_var2);
+
+Flag LT_64 (Word64 L64_var1, Word64 L64_var2);
+Flag GT_64 (Word64 L64_var1, Word64 L64_var2);
+Flag LE_64 (Word64 L64_var1, Word64 L64_var2);
+Flag GE_64 (Word64 L64_var1, Word64 L64_var2);
+Flag EQ_64 (Word64 L64_var1, Word64 L64_var2);
+Flag NE_64 (Word64 L64_var1, Word64 L64_var2);
+
+
+#endif /* #ifdef CONTROL_CODE_OPS */
+
+#endif /* _CONTROL_H */
+
+
+/* end of file */
diff --git a/basic_op/count.c b/basic_op/count.c
new file mode 100644
index 0000000000000000000000000000000000000000..1fc839b6249b5100f4fcca179f4063bc0291cd0d
--- /dev/null
+++ b/basic_op/count.c
@@ -0,0 +1,772 @@
+/*
+ ===========================================================================
+ File: COUNT.C v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ COMPLEXITY EVALUATION FUNCTIONS
+
+ History:
+ 03 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ norm_s() weight reduced from 15 to 1.
+ norm_l() weight reduced from 30 to 1.
+ L_abs() weight reduced from 2 to 1.
+ L_add() weight reduced from 2 to 1.
+ L_negate() weight reduced from 2 to 1.
+ L_shl() weight reduced from 2 to 1.
+ L_shr() weight reduced from 2 to 1.
+ L_sub() weight reduced from 2 to 1.
+ mac_r() weight reduced from 2 to 1.
+ msu_r() weight reduced from 2 to 1.
+ mult_r() weight reduced from 2 to 1.
+ L_deposit_h() weight reduced from 2 to 1.
+ L_deposit_l() weight reduced from 2 to 1.
+ March 06 v2.1 Changed to improve portability.
+ Dec 06 v2.2 Changed to specify frame rate using setFrameRate()
+ Adding WMOPS_output_avg() for global average computation
+ L_mls() weight of 5.
+ div_l() weight of 32.
+ i_mult() weight of 3.
+ ============================================================================
+*/
+
+
+/*****************************************************************************
+ *
+ * This file contains functions for the automatic complexity calculation
+ *
+ *****************************************************************************/
+
+
+#include
+#include
+#include
+#include "stl.h"
+
+#ifdef WMOPS
+static double frameRate = FRAME_RATE; /* default value : 10 ms */
+#endif /* ifdef WMOPS */
+
+#ifdef WMOPS
+/* Global counter variable for calculation of complexity weight */
+BASIC_OP multiCounter[MAXCOUNTERS];
+int currCounter = 0; /* Zero equals global counter */
+#endif /* ifdef WMOPS */
+
+#ifdef WMOPS
+void setFrameRate (int samplingFreq, int frameLength) {
+ if (frameLength > 0) {
+ frameRate = samplingFreq / 1000000.0 / frameLength;
+ }
+ return;
+}
+
+#endif /* ifdef WMOPS */
+
+#ifdef WMOPS
+/*
+ * Below list is used for displaying the code profiling information in
+ * the file which name is defined by CODE_PROFILE_FILENAME.
+ * For further details see generic_WMOPS_output() function.
+ * Attention, the ordering in this table must be kept in synchronisation
+ * with the structure definition BASIC_OP.
+ */
+char *BasicOperationList[] = {
+ "add", "sub", "abs_s", "shl", "shr",
+ "extract_h", "extract_l", "mult", "L_mult", "negate",
+ "round", "L_mac", "L_msu", "L_macNs", "L_msuNs",
+ "L_add", "L_sub", "L_add_c", "L_sub_c", "L_negate",
+ "L_shl", "L_shr", "mult_r", "shr_r", "mac_r",
+
+ "msu_r", "L_deposit_h", "L_deposit_l", "L_shr_r", "L_abs",
+ "L_sat", "norm_s", "div_s", "norm_l", "move16",
+ "move32", "Logic16", "Logic32", "Test", "s_max",
+ "s_min", "L_max", "L_min", "L40_max", "L40_min",
+ "shl_r", "L_shl_r", "L40_shr_r", "L40_shl_r", "norm_L40",
+
+ "L40_shl", "L40_shr", "L40_negate", "L40_add", "L40_sub",
+ "L40_abs", "L40_mult", "L40_mac", "mac_r40",
+ "L40_msu", "msu_r40", "Mpy_32_16_ss", "Mpy_32_32_ss", "L_mult0",
+ "L_mac0", "L_msu0", "lshl", "lshr", "L_lshl",
+ "L_lshr", "L40_lshl", "L40_lshr", "s_and", "s_or",
+
+ "s_xor", "L_and", "L_or", "L_xor", "rotl",
+ "rotr", "L_rotl", "L_rotr", "L40_set", "L40_deposit_h",
+ "L40_deposit_l", "L40_deposit32", "Extract40_H", "Extract40_L", "L_Extract40",
+ "L40_round", "L_saturate40", "round40", "IF", "GOTO",
+ "BREAK", "SWITCH", "FOR", "WHILE", "CONTINUE",
+
+ "L_mls", "div_l", "i_mult"
+
+ /* New complex basops */
+ #ifdef COMPLEX_OPERATOR
+ , "CL_shr", "CL_shl", "CL_add"
+ , "CL_sub", "CL_scale", "CL_dscale"
+ , "CL_msu_j", "CL_mac_j", "CL_move"
+ , "CL_Extract_real", "CL_Extract_imag", "CL_form"
+ , "CL_multr_32x16", "CL_negate", "CL_conjugate"
+ , "CL_mul_j"
+ , "CL_swap_real_imag"
+ , "C_add"
+ , "C_sub"
+ , "C_mul_j"
+ , "C_multr"
+ , "C_form"
+
+ , "C_scale"
+ , "CL_round32_16", "CL_scale_32", "CL_dscale_32", "CL_multr_32x32"
+ , "C_mac_r", "C_msu_r", "C_Extract_real", "C_Extract_imag"
+ , "C_negate", "C_conjugate"
+ , "C_shr", "C_shl"
+
+#endif /* #ifdef COMPLEX_OPERATOR */
+
+ /* New 64 bit basops */
+#ifdef ENH_64_BIT_OPERATOR
+ , "move64" , "W_add_nosat" ,"W_sub_nosat"
+ , "W_shl" , "W_shr"
+ , "W_shl_nosat" , "W_shr_nosat"
+ , "W_mac_32_16" , "W_msu_32_16" , "W_mult_32_16"
+ , "W_mult0_16_16" , "W_mac0_16_16" , "W_msu0_16_16"
+ , "W_mult_16_16" , "W_mac_16_16" , "W_msu_16_16"
+ , "W_shl_sat_l" , "W_sat_l"
+ , "W_sat_m" , "W_deposit32_l" ,"W_deposit32_h"
+ , "W_extract_l" , "W_extract_h"
+ , "W_round48_L" , "W_round32_s"
+ , "W_norm"
+ , "W_add" , "W_sub" ,"W_neg" ,"W_abs"
+ , "W_mult_32_32" , "W_mult0_32_32"
+ , "W_lshl" , "W_lshr" ,"W_round64_L"
+
+#endif /* #ifdef ENH_64_BIT_OPERATOR */
+
+#ifdef ENH_32_BIT_OPERATOR
+ , "Mpy_32_16_1"
+ , "Mpy_32_16_r"
+ , "Mpy_32_32"
+ , "Mpy_32_32_r"
+ , "Madd_32_16"
+ , "Madd_32_16_r"
+ , "Msub_32_16"
+ , "Msub_32_16_r"
+ , "Madd_32_32"
+ , "Madd_32_32_r"
+ , "Msub_32_32"
+ , "Msub_32_32_r"
+#endif /* #ifdef ENH_32_BIT_OPERATOR */
+
+#ifdef ENH_U_32_BIT_OPERATOR
+ , "UL_addNs"
+ , "UL_subNs"
+ , "UL_Mpy_32_32"
+ , "Mpy_32_32_uu"
+ , "Mpy_32_16_uu"
+ , "norm_ul"
+ , "UL_deposit_l"
+#endif /* #ifdef ENH_U_32_BIT_OPERATOR */
+
+#ifdef CONTROL_CODE_OPS
+ , "LT_16"
+ , "GT_16"
+ , "LE_16"
+ , "GE_16"
+ , "EQ_16"
+ , "NE_16"
+ , "LT_32"
+ , "GT_32"
+ , "LE_32"
+ , "GE_32"
+ , "EQ_32"
+ , "NE_32"
+ , "LT_64"
+ , "GT_64"
+ , "LE_64"
+ , "GE_64"
+ , "EQ_64"
+ , "NE_64"
+#endif /* #ifdef CONTROL_CODE_OPS */
+
+};
+#endif /* ifdef WMOPS */
+
+
+#ifdef WMOPS
+const BASIC_OP op_weight = {
+ 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1,
+ 1, 1, 2, 2, 1,
+ 1, 1, 1, 2, 1,
+
+ 1, 1, 1, 2, 1,
+ 1, 1, 18, 1, 1,
+ 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1,
+ 2, 2, 2, 2, 1,
+
+ 1, 1, 1, 1, 1,
+ 1, 1, 1, 2,
+ 1, 2, 2, 2, 1,
+ 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1,
+
+ 1, 1, 1, 1, 3,
+ 3, 3, 3, 1, 1,
+ 1, 1, 1, 1, 1,
+ 1, 1, 1, 3, 2,
+ 2, 6, 3, 3, 2,
+
+ 1, 32, 1
+
+/* New complex basops */
+ #ifdef COMPLEX_OPERATOR
+ , 1, 1, 1
+ , 1, 1, 1
+ , 1, 1, 1
+ , 1, 1, 1
+ , 2, 1, 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 2
+ , 1
+
+ , 1
+ , 1, 1, 1, 2
+ , 2, 2, 1, 1
+ , 1, 1
+ , 1, 1
+
+#endif /* #ifdef COMPLEX_OPERATOR */
+
+#ifdef ENH_64_BIT_OPERATOR
+ /* Weights of new 64 bit basops */
+ , 1 , 1 ,1
+ , 1 , 1
+ , 1 , 1
+ , 1 , 1 , 1
+ , 1 , 1 , 1
+ , 1 , 1 , 1
+ , 1 , 1
+ , 1 , 1 , 1
+ , 1 , 1
+ , 1 , 1
+ , 1
+ , 1 , 1 , 1 , 1
+ , 1 , 1
+ , 1 , 1 , 1
+#endif /* #ifdef ENH_64_BIT_OPERATOR */
+
+#ifdef ENH_32_BIT_OPERATOR
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+#endif /* #ifdef ENH_32_BIT_OPERATOR */
+
+#ifdef ENH_U_32_BIT_OPERATOR
+ , 1
+ , 1
+ , 1
+ , 2
+ , 2
+ , 1
+ , 1
+#endif /* #ifdef ENH_U_32_BIT_OPERATOR */
+
+#ifdef CONTROL_CODE_OPS
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+ , 1
+#endif /* #ifdef CONTROL_CODE_OPS */
+};
+#endif /* ifdef WMOPS */
+
+
+Word32 TotalWeightedOperation (void);
+Word32 DeltaWeightedOperation (void);
+
+
+#ifdef WMOPS
+/* Counters for separating counting for different objects */
+
+
+static int maxCounter = 0;
+static char *objectName[MAXCOUNTERS + 1];
+
+static Word16 fwc_corr[MAXCOUNTERS + 1];
+static long int nbTimeObjectIsCalled[MAXCOUNTERS + 1];
+
+#define NbFuncMax 1024
+
+static Word16 funcid[MAXCOUNTERS], nbframe[MAXCOUNTERS];
+static Word32 glob_wc[MAXCOUNTERS], wc[MAXCOUNTERS][NbFuncMax];
+static float total_wmops[MAXCOUNTERS];
+
+static Word32 LastWOper[MAXCOUNTERS];
+#endif /* ifdef WMOPS */
+
+
+#ifdef WMOPS
+static char *my_strdup (const char *s) {
+ /*
+ * duplicates UNIX function strdup() which is not ANSI standard:
+ * -- malloc() memory area big enough to hold the string s
+ * -- copy string into new area
+ * -- return pointer to new area
+ *
+ * returns NULL if either s==NULL or malloc() fails
+ */
+ char *dup;
+
+ if (s == NULL)
+ return NULL;
+
+ /* allocate memory for copy of ID string (including string terminator) */
+ /* NOTE: the ID strings will never be deallocated because there is no way to "destroy" a counter that is not longer needed */
+ if ((dup = (char *) malloc (strlen (s) + 1)) == NULL)
+ return NULL;
+
+ return strcpy (dup, s);
+}
+#endif /* ifdef WMOPS */
+
+
+int getCounterId (char *objectNameArg) {
+#if WMOPS
+ if (maxCounter >= MAXCOUNTERS - 1)
+ return 0;
+ objectName[++maxCounter] = my_strdup (objectNameArg);
+ return maxCounter;
+
+#else /* ifdef WMOPS */
+ (void)objectNameArg;
+ return 0; /* Dummy */
+
+#endif /* ifdef WMOPS */
+}
+
+
+#if WMOPS
+int readCounterId () {
+ return currCounter;
+}
+#endif /* ifdef WMOPS */
+
+
+#ifdef WMOPS
+char *readCounterIdName () {
+ return objectName[currCounter];
+}
+#endif /* ifdef WMOPS */
+
+void setCounter (int counterId) {
+#if WMOPS
+ if ((counterId > maxCounter)
+ || (counterId < 0)) {
+ currCounter = 0;
+ return;
+ }
+ currCounter = counterId;
+ call_occurred = 1;
+#else
+ (void)counterId;
+#endif /* ifdef WMOPS */
+}
+
+
+void incrementNbTimeObjectIsCalled (int counterId) {
+#if WMOPS
+ if ((counterId > maxCounter)
+ || (counterId < 0)) {
+ nbTimeObjectIsCalled[0]++;
+ return;
+ }
+ nbTimeObjectIsCalled[counterId]++;
+#else
+ (void)counterId;
+#endif /* ifdef WMOPS */
+}
+
+
+#if WMOPS
+static Word32 WMOPS_frameStat (void) {
+/* calculate the WMOPS seen so far and update the global
+ per-frame maximum (glob_wc)
+ */
+ Word32 tot;
+
+ tot = TotalWeightedOperation ();
+ if (tot > glob_wc[currCounter])
+ glob_wc[currCounter] = tot;
+
+ /* check if fwc() was forgotten at end of last frame */
+ if (tot > LastWOper[currCounter]) {
+ if (!fwc_corr[currCounter]) {
+ fprintf (stderr,
+ "count: operations counted after last fwc() for '%s'; " "-> fwc() called\n",
+ objectName[currCounter] ? objectName[currCounter] : "");
+ }
+ fwc ();
+ }
+
+ return tot;
+}
+#endif /* ifdef WMOPS */
+
+
+#ifdef WMOPS
+static void WMOPS_clearMultiCounter (void) {
+ Word16 i;
+
+ Word32 *ptr = (Word32 *) & multiCounter[currCounter];
+ for (i = 0; i < (Word16)(sizeof (multiCounter[currCounter]) / sizeof (Word32)); i++) {
+ *ptr++ = 0;
+ }
+}
+#endif /* ifdef WMOPS */
+
+
+void ClearNbTimeObjectsAreCalled () {
+#if WMOPS
+ Word16 i;
+
+ for (i = 0; i < (Word16)(sizeof (multiCounter[currCounter]) / sizeof (Word32)); i++) {
+ nbTimeObjectIsCalled[i] = 0;
+ }
+#endif /* ifdef WMOPS */
+}
+
+Word32 TotalWeightedOperation () {
+#if WMOPS
+ Word16 i;
+ Word32 tot, *ptr, *ptr2;
+
+ tot = 0;
+ ptr = (Word32 *) & multiCounter[currCounter];
+ ptr2 = (Word32 *) & op_weight;
+ for (i = 0; i < (Word16)(sizeof (multiCounter[currCounter]) / sizeof (Word32)); i++) {
+ tot += ((*ptr++) * (*ptr2++));
+ }
+
+ return ((Word32) tot);
+
+#else /* ifdef WMOPS */
+ return 0; /* Dummy */
+
+#endif /* ifdef WMOPS */
+
+}
+
+Word32 DeltaWeightedOperation () {
+#if WMOPS
+ Word32 NewWOper, delta;
+
+ NewWOper = TotalWeightedOperation ();
+ delta = NewWOper - LastWOper[currCounter];
+ LastWOper[currCounter] = NewWOper;
+ return (delta);
+
+#else /* ifdef WMOPS */
+ return 0; /* Dummy */
+
+#endif /* ifdef WMOPS */
+}
+
+
+void Init_WMOPS_counter (void) {
+#if WMOPS
+ Word16 i;
+
+ /* reset function weight operation counter variable */
+
+ for (i = 0; i < NbFuncMax; i++)
+ wc[currCounter][i] = (Word32) 0;
+ glob_wc[currCounter] = 0;
+ nbframe[currCounter] = 0;
+ total_wmops[currCounter] = 0.0;
+
+ /* initially clear all counters */
+ WMOPS_clearMultiCounter ();
+ LastWOper[currCounter] = 0;
+ funcid[currCounter] = 0;
+
+ /* Following line is useful for incrIf(), see control.h */
+ call_occurred = 1;
+ funcId_where_last_call_to_else_occurred = MAXCOUNTERS;
+#endif /* ifdef WMOPS */
+}
+
+
+void Reset_WMOPS_counter (void) {
+#if WMOPS
+ Word32 tot = WMOPS_frameStat ();
+
+ /* increase the frame counter --> a frame is counted WHEN IT BEGINS */
+ nbframe[currCounter]++;
+
+ /* add wmops used in last frame to count, then reset counter (in first frame, this is a no-op */
+ total_wmops[currCounter] += (float) (tot * frameRate);
+
+ /* clear counter before new frame starts */
+ WMOPS_clearMultiCounter ();
+ LastWOper[currCounter] = 0;
+ funcid[currCounter] = 0; /* new frame, set function id to zero */
+#endif /* ifdef WMOPS */
+}
+
+
+Word32 fwc (void) {
+/* function worst case */
+#if WMOPS
+ Word32 tot;
+
+ tot = DeltaWeightedOperation ();
+ if (tot > wc[currCounter][funcid[currCounter]])
+ wc[currCounter][funcid[currCounter]] = tot;
+
+ funcid[currCounter]++;
+ return (tot);
+
+#else /* ifdef WMOPS */
+ return 0; /* Dummy */
+
+#endif /* ifdef WMOPS */
+}
+
+void WMOPS_output (Word16 dtx_mode) {
+#if WMOPS
+ Word16 i;
+ Word32 tot, tot_wm, tot_wc;
+
+ /* get operations since last reset (or init), but do not update the counters (except the glob_wc[] maximum)
+ so output CAN be called in each frame without problems. The frame counter is NOT updated! */
+ tot = WMOPS_frameStat ();
+ tot_wm = (Word32) (total_wmops[currCounter] + ((float) tot) * frameRate);
+
+ fprintf (stdout,
+ "%10s:WMOPS=%.3f", objectName[currCounter] ? objectName[currCounter] : "",
+ ((float) tot) * frameRate);
+
+ if (nbframe[currCounter] != 0) {
+ fprintf (stdout, " Average=%.3f", tot_wm / (float) nbframe[currCounter]);
+ }
+ fprintf (stdout, " WorstCase=%.3f", ((float) glob_wc[currCounter]) * frameRate);
+
+ /* Worst worst case printed only when not in DTX mode */
+ if (dtx_mode == 0) {
+ tot_wc = 0L;
+ for (i = 0; i < funcid[currCounter]; i++)
+ tot_wc += wc[currCounter][i];
+ fprintf (stdout, " WorstWC=%.3f", ((float) tot_wc) * frameRate);
+ }
+ fprintf (stdout, " (%d frames)\n", nbframe[currCounter]);
+#else
+ (void)dtx_mode;
+#endif /* ifdef WMOPS */
+}
+
+
+void WMOPS_output_avg (Word16 dtx_mode, Word32 * tot_wm, Word16 * num_frames) {
+#if WMOPS
+ Word16 i;
+ Word32 tot, tot_wc;
+
+ /* get operations since last reset (or init), but do not update the counters (except the glob_wc[] maximum)
+ so output CAN be called in each frame without problems. The frame counter is NOT updated! */
+ tot = WMOPS_frameStat ();
+ *tot_wm = (Word32) (total_wmops[currCounter] + ((float) tot) * frameRate);
+ *num_frames = nbframe[currCounter];
+
+ fprintf (stdout, "%10s:WMOPS=%.3f", objectName[currCounter] ? objectName[currCounter] : "", ((float) tot) * frameRate);
+
+ if (nbframe[currCounter] != 0) {
+ fprintf (stdout, " Average=%.3f", *tot_wm / (float) nbframe[currCounter]);
+ }
+ fprintf (stdout, " WorstCase=%.3f", ((float) glob_wc[currCounter]) * frameRate);
+
+ /* Worst worst case printed only when not in DTX mode */
+ if (dtx_mode == 0) {
+ tot_wc = 0L;
+ for (i = 0; i < funcid[currCounter]; i++)
+ tot_wc += wc[currCounter][i];
+ fprintf (stdout, " WorstWC=%.3f", ((float) tot_wc) * frameRate);
+ }
+ fprintf (stdout, " (%d frames)\n", nbframe[currCounter]);
+#else
+ (void)dtx_mode;
+ (void)tot_wm;
+ (void)num_frames;
+#endif /* ifdef WMOPS */
+}
+
+void generic_WMOPS_output (Word16 dtx_mode, char *test_file_name) {
+#if WMOPS
+ int saved_value;
+ Word16 i;
+ Word32 tot, tot_wm, tot_wc, *ptr, *ptr2;
+ Word40 grand_total;
+ FILE *WMOPS_file;
+
+ saved_value = currCounter;
+
+ /* Count the grand_total WMOPS so that % ratio per function group can be displayed. */
+ grand_total = 0;
+ for (currCounter = 0; currCounter <= maxCounter; currCounter++) {
+ tot = WMOPS_frameStat ();
+ grand_total += tot;
+ }
+
+
+ if ((WMOPS_file = fopen (WMOPS_DATA_FILENAME, "a")) != NULL) {
+
+ printf ("opened file %s in order to print WMOPS for each function group.\n", WMOPS_DATA_FILENAME);
+
+ /* Print the file header line. */
+ fprintf (WMOPS_file, "Test file name\tFunction Name \tFrame\tNb Times Called\tWMOPS\t%% versus grand total");
+
+ if (nbframe[saved_value] != 0)
+ fprintf (WMOPS_file, "\tAverage");
+
+ fprintf (WMOPS_file, "\tWorstCase");
+
+ /* Worst worst case printed only when not in DTX mode */
+ if (dtx_mode == 0)
+ fprintf (WMOPS_file, "\tWorstWC");
+
+ fprintf (WMOPS_file, "\n");
+
+ /* Print the WMOPS for each Function Group by scanning all the function groups with currCounter index. */
+ for (currCounter = 0; currCounter <= maxCounter; currCounter++) {
+
+ fprintf (WMOPS_file, "%s", test_file_name);
+ fprintf (WMOPS_file, "\t%s", objectName[currCounter] ? objectName[currCounter] : "");
+ fprintf (WMOPS_file, "\t%d", nbframe[currCounter]);
+
+ tot = WMOPS_frameStat ();
+ tot_wm = (Word32) (total_wmops[currCounter] + ((float) tot) * frameRate);
+
+ fprintf (WMOPS_file, "\t\t%ld", nbTimeObjectIsCalled[currCounter]);
+ fprintf (WMOPS_file, "\t%.6f", ((float) tot) * frameRate);
+ fprintf (WMOPS_file, "\t%.3f", ((float) tot) / grand_total * 100);
+
+ if (nbframe[currCounter] != 0)
+ fprintf (WMOPS_file, "\t%.3f", tot_wm / (float) nbframe[currCounter]);
+
+ fprintf (WMOPS_file, "\t%.3f", ((float) glob_wc[currCounter]) * frameRate);
+
+ /* Worst worst case printed only when not in DTX mode */
+ if (dtx_mode == 0) {
+ tot_wc = 0L;
+ for (i = 0; i < funcid[currCounter]; i++)
+ tot_wc += wc[currCounter][i];
+ fprintf (WMOPS_file, "\t%.3f", ((float) tot_wc) * frameRate);
+ }
+ fprintf (WMOPS_file, "\n");
+
+ }
+
+ /* Print the file Grand Total line */
+ fprintf (WMOPS_file, "%s", test_file_name);
+ fprintf (WMOPS_file, "\tGrand Total");
+ fprintf (WMOPS_file, "\t%d", nbframe[saved_value]);
+ fprintf (WMOPS_file, "\t\t%.6f", ((float) grand_total) * frameRate);
+ fprintf (WMOPS_file, "\t100.000");
+ fprintf (WMOPS_file, "\n");
+ fclose (WMOPS_file);
+
+ } else
+ printf ("Can not open file %s for WMOPS editing\n", WMOPS_DATA_FILENAME);
+
+
+ if ((WMOPS_file = fopen (WMOPS_TOTAL_FILENAME, "a")) != NULL) {
+ printf ("opened file %s in order to print application's total WMOPS.\n", WMOPS_TOTAL_FILENAME);
+ fprintf (WMOPS_file, "%s", test_file_name);
+ fprintf (WMOPS_file, "\tframe=%d", nbframe[currCounter]);
+ fprintf (WMOPS_file, "\tWMOPS=%.6f", ((float) grand_total) * frameRate);
+ fprintf (WMOPS_file, "\n");
+ fclose (WMOPS_file);
+
+ } else
+ printf ("Can not open file %s for WMOPS editing.\n", WMOPS_TOTAL_FILENAME);
+
+
+ if ((WMOPS_file = fopen (CODE_PROFILE_FILENAME, "a")) != NULL) {
+
+ printf ("opened file %s in order to print basic operation distribution statistics.\n", CODE_PROFILE_FILENAME);
+
+ /* Print the file header line. */
+ fprintf (WMOPS_file, "Test file name\tBasic Operation Name\tframe\tWMOPS\t\t%% versus grand total\n");
+
+ /* Print the WMOPS for each Basic Operation across all the defined */
+ /* Function Groups. */
+ for (i = 0; i < (Word16)(sizeof (op_weight) / sizeof (Word32)); i++) {
+ fprintf (WMOPS_file, "%-16s", test_file_name);
+ fprintf (WMOPS_file, "\t%s", BasicOperationList[i]);
+ fprintf (WMOPS_file, "\t%d", nbframe[0]);
+
+ tot = 0;
+ ptr = (Word32 *) & multiCounter[0] + i;
+ ptr2 = (Word32 *) & op_weight + i;
+ for (currCounter = 0; currCounter <= maxCounter; currCounter++) {
+ tot += ((*ptr) * (*ptr2));
+ ptr += (sizeof (op_weight) / sizeof (Word32));
+ }
+
+ fprintf (WMOPS_file, "\t%.6f", ((float) tot) * frameRate);
+ fprintf (WMOPS_file, "\t%.3f", ((float) tot) / grand_total * 100);
+ fprintf (WMOPS_file, "\n");
+ }
+
+ /* Print the file Grand Total line */
+ fprintf (WMOPS_file, "%s", test_file_name);
+ fprintf (WMOPS_file, "\tGrand Total");
+ fprintf (WMOPS_file, "\t%d", nbframe[saved_value]);
+ fprintf (WMOPS_file, "\t%.6f", ((float) grand_total) * frameRate);
+ fprintf (WMOPS_file, "\t100.000");
+ fprintf (WMOPS_file, "\n");
+ fclose (WMOPS_file);
+
+ } else
+ printf ("Can not open file %s for basic operations distribution statistic editing\n", CODE_PROFILE_FILENAME);
+
+ currCounter = saved_value;
+
+#else
+ (void)dtx_mode;
+ (void)test_file_name;
+#endif /* ifdef WMOPS */
+}
+
+
+/* end of file */
diff --git a/basic_op/count.h b/basic_op/count.h
new file mode 100644
index 0000000000000000000000000000000000000000..e173de624f8db442f68d729c1db3713e591f471b
--- /dev/null
+++ b/basic_op/count.h
@@ -0,0 +1,542 @@
+/*
+ ===========================================================================
+ File: COUNT.H v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ PROTOTYPES & DEFINITION FOR COUNTING OPERATIONS
+
+ History
+ 09.Aug.1999 V1.0.0 Input to UGST from ETSI AMR (count.h);
+
+ 26.Jan.2000 V1.1.0 Added counter entries for G.723.1's
+ L_mls(), div_l(), i_mult() [from basop32.c]
+
+ 05.Jul.2000 V1.2.0 Added counter entries for 32bit shiftless
+ operators L_mult0(), L_mac0(), L_msu0()
+
+ 03 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ March 06 v2.1 Changed to improve portability.
+ Dec 06 v2.2 Changed to specify frame rate using setFrameRate()
+ Adding WMOPS_output_avg() for global average computation
+ L_mls() weight of 5.
+ div_l() weight of 32.
+ i_mult() weight of 3.
+ ============================================================================
+*/
+
+
+/******************************************************************************
+ * Functions for counting operations.
+ *
+ * These functions make it possible to measure the wMOPS of a codec.
+ *
+ * All functions in this file, and in other *.h files, update a structure so
+ * that it will be possible to track how many calls to add(), sub(), L_mult()
+ * ... was made by the code and to estimate the wMOPS (and MIPS) for a certain
+ * part of the code.
+ *
+ * It is also possible to measure the wMOPS separatly for different parts
+ * of the codec.
+ *
+ * This is done by creating a counter group (getCounterId) for each part of
+ * the code that one wants a seperate measure for. Before a part of the code
+ * is executed a call to the "setCounter" function is needed to identify
+ * which counter group to use.
+ *
+ * Currently there is a limit of 255 different counter groups.
+ *
+ * In the end of this file, there is a piece of code illustrating how the
+ * functions can be used.
+ *
+******************************************************************************/
+
+
+#ifndef _COUNT_H
+#define _COUNT_H "$Id$"
+#if 0
+#define WMOPS 1 /* enable WMOPS profiling features */
+#undef WMOPS /* disable WMOPS profiling features */
+#endif
+#define MAXCOUNTERS (256)
+
+
+#define BASOP_sub_start(label)
+#define BASOP_sub_end()
+#define SUB_WMOPS_INIT(label) BASOP_sub_start(label)
+#define END_SUB_WMOPS BASOP_sub_end()
+#define BASOP_push_wmops(label)
+#define BASOP_pop_wmops()
+#define BASOP_end_noprint
+#define BASOP_end
+#define BASOP_init
+
+int getCounterId (char *objectName);
+/*
+ * Create a counter group, the "objectname" will be used when printing
+ * statistics for this counter group.
+ *
+ * Returns 0 if no more counter groups are available.
+ */
+
+
+int readCounterId (void);
+/*
+ * Returns the current CounterId.
+ */
+
+
+void setCounter (int counterId);
+/*
+ * Defines which counter group to use, default is zero.
+ */
+
+
+char *readCounterIdName (void);
+/*
+ * Returns the current CounterId name.
+ */
+
+
+void incrementNbTimeObjectIsCalled (int counterId);
+/*
+ * This function enables to increment by 1 a counter
+ * tracking the number of times the application enters a groups of functions.
+ * If the counterId is not refering to a defined function counter group, then it is
+ * the default function group (0) which is impacted.
+ *
+ */
+
+
+void ClearNbTimeObjectsAreCalled (void);
+/*
+ * This function enables to clear to 0 all the counters enabling to
+ * track the number of times the application enters any groups of functions.
+ */
+
+
+void Init_WMOPS_counter (void);
+/*
+ * Initiates the current counter group.
+ */
+
+
+void Reset_WMOPS_counter (void);
+/*
+ * Resets the current counter group.
+ */
+
+
+void WMOPS_output (Word16 notPrintWorstWorstCase);
+/*
+ * Prints the statistics to the screen, if the argument is non zero
+ * the statistics for worst worst case will not be printed. This is typically
+ * done for dtx frames.
+ *
+ */
+
+void WMOPS_output_avg (Word16 dtx_mode, Word32 * tot_wm, Word16 * num_frames);
+/*
+ * same as WMOPS_output + returns the total wmops counter and the number of frames
+ * to support the computation of global average.
+ *
+ */
+
+
+Word32 fwc (void);
+/*
+ * worst worst case counter.
+ *
+ * This function calculates the worst possible case that can be reached.
+ *
+ * This is done by calling this function for each subpart of the calculations
+ * for a frame. This function then stores the maximum wMOPS for each part.
+ *
+ * The WMOPS_output function add together all parts and presents the sum.
+ */
+
+void setFrameRate (int samplingFreq, int frameLength);
+/*
+ * This function can overwrite the value of the frameRate variable that is
+ * initialized by the FRAME_RATE constant.
+ */
+
+
+#define WMOPS_DATA_FILENAME "wmops_data.txt"
+/*
+ * WMOPS_DATA_FILENAME is the macro defining the name of the file
+ * where the Weighted Million of Operations per Second (wMOPS)
+ * are appended, function group by function group.
+*/
+
+
+#define CODE_PROFILE_FILENAME "code_profile.txt"
+/*
+ * CODE_PROFILE_FILENAME is the macro defining the name of the file
+ * where the Weighted Million of Operations per Second (WMOPS)
+ * are appended, basic operation by basic operation.
+*/
+
+
+#define WMOPS_TOTAL_FILENAME "wmops_total.txt"
+/*
+ * WMOPS_TOTAL_FILENAME is the macro defining the name of the file
+ * where the Weighted Million of Operations per Second (WMOPS)
+ * are printed, globally for the application.
+*/
+
+
+#define FRAME_RATE (0.0001F) /* in this version frame_rate can be overwriten online by the new setFrameRate function */
+/* FRAME_RATE of 0.000025 is corresponding to 40ms frame.*/
+/* FRAME_RATE of 0.00005 is corresponding to 20ms frame.*/
+/* FRAME_RATE of 0.0001 is corresponding to 10ms frame.*/
+/*
+ * FRAME_RATE is the macro defining the calling rate of the
+ * application to benchmark.
+*/
+
+
+/* Global counter variable for calculation of complexity weight */
+typedef struct {
+ UWord32 add; /* Complexity Weight of 1 */
+ UWord32 sub; /* Complexity Weight of 1 */
+ UWord32 abs_s; /* Complexity Weight of 1 */
+ UWord32 shl; /* Complexity Weight of 1 */
+ UWord32 shr; /* Complexity Weight of 1 */
+
+ UWord32 extract_h; /* Complexity Weight of 1 */
+ UWord32 extract_l; /* Complexity Weight of 1 */
+ UWord32 mult; /* Complexity Weight of 1 */
+ UWord32 L_mult; /* Complexity Weight of 1 */
+ UWord32 negate; /* Complexity Weight of 1 */
+
+ UWord32 round; /* Complexity Weight of 1 */
+ UWord32 L_mac; /* Complexity Weight of 1 */
+ UWord32 L_msu; /* Complexity Weight of 1 */
+ UWord32 L_macNs; /* Complexity Weight of 1 */
+ UWord32 L_msuNs; /* Complexity Weight of 1 */
+
+ UWord32 L_add; /* Complexity Weight of 1 */
+ UWord32 L_sub; /* Complexity Weight of 1 */
+ UWord32 L_add_c; /* Complexity Weight of 2 */
+ UWord32 L_sub_c; /* Complexity Weight of 2 */
+ UWord32 L_negate; /* Complexity Weight of 1 */
+
+ UWord32 L_shl; /* Complexity Weight of 1 */
+ UWord32 L_shr; /* Complexity Weight of 1 */
+ UWord32 mult_r; /* Complexity Weight of 1 */
+ UWord32 shr_r; /* Complexity Weight of 3 */
+ UWord32 mac_r; /* Complexity Weight of 1 */
+
+ UWord32 msu_r; /* Complexity Weight of 1 */
+ UWord32 L_deposit_h; /* Complexity Weight of 1 */
+ UWord32 L_deposit_l; /* Complexity Weight of 1 */
+ UWord32 L_shr_r; /* Complexity Weight of 3 */
+ UWord32 L_abs; /* Complexity Weight of 1 */
+
+ UWord32 L_sat; /* Complexity Weight of 4 */
+ UWord32 norm_s; /* Complexity Weight of 1 */
+ UWord32 div_s; /* Complexity Weight of 18 */
+ UWord32 norm_l; /* Complexity Weight of 1 */
+ UWord32 move16; /* Complexity Weight of 1 */
+
+ UWord32 move32; /* Complexity Weight of 2 */
+ UWord32 Logic16; /* Complexity Weight of 1 */
+ UWord32 Logic32; /* Complexity Weight of 2 */
+ UWord32 Test; /* Complexity Weight of 2 */
+ UWord32 s_max; /* Complexity Weight of 1 */
+
+ UWord32 s_min; /* Complexity Weight of 1 */
+ UWord32 L_max; /* Complexity Weight of 1 */
+ UWord32 L_min; /* Complexity Weight of 1 */
+ UWord32 L40_max; /* Complexity Weight of 1 */
+ UWord32 L40_min; /* Complexity Weight of 1 */
+
+ UWord32 shl_r; /* Complexity Weight of 2 */
+ UWord32 L_shl_r; /* Complexity Weight of 2 */
+ UWord32 L40_shr_r; /* Complexity Weight of 2 */
+ UWord32 L40_shl_r; /* Complexity Weight of 2 */
+ UWord32 norm_L40; /* Complexity Weight of 1 */
+
+ UWord32 L40_shl; /* Complexity Weight of 1 */
+ UWord32 L40_shr; /* Complexity Weight of 1 */
+ UWord32 L40_negate; /* Complexity Weight of 1 */
+ UWord32 L40_add; /* Complexity Weight of 1 */
+ UWord32 L40_sub; /* Complexity Weight of 1 */
+
+ UWord32 L40_abs; /* Complexity Weight of 1 */
+ UWord32 L40_mult; /* Complexity Weight of 1 */
+ UWord32 L40_mac; /* Complexity Weight of 1 */
+ UWord32 mac_r40; /* Complexity Weight of 2 */
+
+ UWord32 L40_msu; /* Complexity Weight of 1 */
+ UWord32 msu_r40; /* Complexity Weight of 2 */
+ UWord32 Mpy_32_16_ss; /* Complexity Weight of 2 */
+ UWord32 Mpy_32_32_ss; /* Complexity Weight of 2 */
+ UWord32 L_mult0; /* Complexity Weight of 1 */
+
+ UWord32 L_mac0; /* Complexity Weight of 1 */
+ UWord32 L_msu0; /* Complexity Weight of 1 */
+ UWord32 lshl; /* Complexity Weight of 1 */
+ UWord32 lshr; /* Complexity Weight of 1 */
+ UWord32 L_lshl; /* Complexity Weight of 1 */
+
+ UWord32 L_lshr; /* Complexity Weight of 1 */
+ UWord32 L40_lshl; /* Complexity Weight of 1 */
+ UWord32 L40_lshr; /* Complexity Weight of 1 */
+ UWord32 s_and; /* Complexity Weight of 1 */
+ UWord32 s_or; /* Complexity Weight of 1 */
+
+ UWord32 s_xor; /* Complexity Weight of 1 */
+ UWord32 L_and; /* Complexity Weight of 1 */
+ UWord32 L_or; /* Complexity Weight of 1 */
+ UWord32 L_xor; /* Complexity Weight of 1 */
+ UWord32 rotl; /* Complexity Weight of 3 */
+
+ UWord32 rotr; /* Complexity Weight of 3 */
+ UWord32 L_rotl; /* Complexity Weight of 3 */
+ UWord32 L_rotr; /* Complexity Weight of 3 */
+ UWord32 L40_set; /* Complexity Weight of 1 */
+ UWord32 L40_deposit_h; /* Complexity Weight of 1 */
+
+ UWord32 L40_deposit_l; /* Complexity Weight of 1 */
+ UWord32 L40_deposit32; /* Complexity Weight of 1 */
+ UWord32 Extract40_H; /* Complexity Weight of 1 */
+ UWord32 Extract40_L; /* Complexity Weight of 1 */
+ UWord32 L_Extract40; /* Complexity Weight of 1 */
+
+ UWord32 L40_round; /* Complexity Weight of 1 */
+ UWord32 L_saturate40; /* Complexity Weight of 1 */
+ UWord32 round40; /* Complexity Weight of 1 */
+ UWord32 If; /* Complexity Weight of 3 */
+ UWord32 Goto; /* Complexity Weight of 2 */
+
+ UWord32 Break; /* Complexity Weight of 2 */
+ UWord32 Switch; /* Complexity Weight of 6 */
+ UWord32 For; /* Complexity Weight of 3 */
+ UWord32 While; /* Complexity Weight of 3 */
+ UWord32 Continue; /* Complexity Weight of 2 */
+
+ UWord32 L_mls; /* Complexity Weight of 1 */
+ UWord32 div_l; /* Complexity Weight of 32 */
+ UWord32 i_mult; /* Complexity Weight of 1 */
+
+/* New complex basic operators */
+#ifdef COMPLEX_OPERATOR
+ UWord32 CL_shr; /* Complexity Weight of 1 */
+ UWord32 CL_shl; /* Complexity Weight of 1 */
+ UWord32 CL_add; /* Complexity Weight of 1 */
+ UWord32 CL_sub; /* Complexity Weight of 1 */
+ UWord32 CL_scale; /* Complexity Weight of 1 */
+ UWord32 CL_dscale; /* Complexity Weight of 1 */
+ UWord32 CL_msu_j; /* Complexity Weight of 1 */
+ UWord32 CL_mac_j; /* Complexity Weight of 1 */
+ UWord32 CL_move; /* Complexity Weight of 1 */
+ UWord32 CL_Extract_real; /* Complexity Weight of 1 */
+ UWord32 CL_Extract_imag; /* Complexity Weight of 1 */
+ UWord32 CL_form; /* Complexity Weight of 1 */
+ UWord32 CL_multr_32x16; /* Complexity Weight of 2 */
+ UWord32 CL_negate; /* Complexity Weight of 1 */
+ UWord32 CL_conjugate; /* Complexity Weight of 1 */
+ UWord32 CL_mul_j; /* Complexity Weight of 1 */
+ UWord32 CL_swap_real_imag; /* Complexity Weight of 1 */
+ UWord32 C_add; /* Complexity Weight of 1 */
+ UWord32 C_sub; /* Complexity Weight of 1 */
+ UWord32 C_mul_j; /* Complexity Weight of 1 */
+ UWord32 C_multr; /* Complexity Weight of 2 */
+ UWord32 C_form; /* Complexity Weight of 1 */
+
+ UWord32 C_scale; /* Complexity Weight of 1 */
+ UWord32 CL_round32_16; /* Complexity Weight of 1 */
+ UWord32 CL_scale_32; /* Complexity Weight of 1 */
+ UWord32 CL_dscale_32; /* Complexity Weight of 1 */
+ UWord32 CL_multr_32x32; /* Complexity Weight of 2 */
+ UWord32 C_mac_r; /* Complexity Weight of 2 */
+ UWord32 C_msu_r; /* Complexity Weight of 2 */
+ UWord32 C_Extract_real; /* Complexity Weight of 1 */
+ UWord32 C_Extract_imag; /* Complexity Weight of 1 */
+ UWord32 C_negate; /* Complexity Weight of 1 */
+ UWord32 C_conjugate; /* Complexity Weight of 1 */
+ UWord32 C_shr; /* Complexity Weight of 1 */
+ UWord32 C_shl; /* Complexity Weight of 1 */
+
+#endif /* #ifdef COMPLEX_OPERATOR */
+
+/* New 64 bit basops */
+#ifdef ENH_64_BIT_OPERATOR
+ UWord32 move64; /* Complexity Weight of 1 */
+ UWord32 W_add_nosat; /* Complexity Weight of 1 */
+ UWord32 W_sub_nosat; /* Complexity Weight of 1 */
+ UWord32 W_shl; /* Complexity Weight of 1 */
+ UWord32 W_shr; /* Complexity Weight of 1 */
+ UWord32 W_shl_nosat; /* Complexity Weight of 1 */
+ UWord32 W_shr_nosat; /* Complexity Weight of 1 */
+ UWord32 W_mac_32_16; /* Complexity Weight of 1 */
+ UWord32 W_msu_32_16; /* Complexity Weight of 1 */
+ UWord32 W_mult_32_16; /* Complexity Weight of 1 */
+ UWord32 W_mult0_16_16; /* Complexity Weight of 1 */
+ UWord32 W_mac0_16_16; /* Complexity Weight of 1 */
+ UWord32 W_msu0_16_16; /* Complexity Weight of 1 */
+ UWord32 W_mult_16_16; /* Complexity Weight of 1 */
+ UWord32 W_mac_16_16; /* Complexity Weight of 1 */
+ UWord32 W_msu_16_16; /* Complexity Weight of 1 */
+ UWord32 W_shl_sat_l; /* Complexity Weight of 1 */
+ UWord32 W_sat_l; /* Complexity Weight of 1 */
+ UWord32 W_sat_m; /* Complexity Weight of 1 */
+ UWord32 W_deposit32_l; /* Complexity Weight of 1 */
+ UWord32 W_deposit32_h; /* Complexity Weight of 1 */
+ UWord32 W_extract_l; /* Complexity Weight of 1 */
+ UWord32 W_extract_h; /* Complexity Weight of 1 */
+ UWord32 W_round48_L; /* Complexity Weight of 1 */
+ UWord32 W_round32_s; /* Complexity Weight of 1 */
+ UWord32 W_norm; /* Complexity Weight of 1 */
+
+ UWord32 W_add; /* Complexity Weight of 1 */
+ UWord32 W_sub; /* Complexity Weight of 1 */
+ UWord32 W_neg; /* Complexity Weight of 1 */
+ UWord32 W_abs; /* Complexity Weight of 1 */
+ UWord32 W_mult_32_32; /* Complexity Weight of 1 */
+ UWord32 W_mult0_32_32; /* Complexity Weight of 1 */
+ UWord32 W_lshl; /* Complexity Weight of 1 */
+ UWord32 W_lshr; /* Complexity Weight of 1 */
+ UWord32 W_round64_L; /* Complexity Weight of 1 */
+
+#endif /* #ifdef ENH_64_BIT_OPERATOR */
+
+#ifdef ENH_32_BIT_OPERATOR
+ UWord32 Mpy_32_16_1; /* Complexity Weight of 1 */
+ UWord32 Mpy_32_16_r; /* Complexity Weight of 1 */
+ UWord32 Mpy_32_32; /* Complexity Weight of 1 */
+ UWord32 Mpy_32_32_r; /* Complexity Weight of 1 */
+ UWord32 Madd_32_16; /* Complexity Weight of 1 */
+ UWord32 Madd_32_16_r; /* Complexity Weight of 1 */
+ UWord32 Msub_32_16; /* Complexity Weight of 1 */
+ UWord32 Msub_32_16_r; /* Complexity Weight of 1 */
+ UWord32 Madd_32_32; /* Complexity Weight of 1 */
+ UWord32 Madd_32_32_r; /* Complexity Weight of 1 */
+ UWord32 Msub_32_32; /* Complexity Weight of 1 */
+ UWord32 Msub_32_32_r; /* Complexity Weight of 1 */
+#endif /* #ifdef ENH_32_BIT_OPERATOR */
+
+#ifdef ENH_U_32_BIT_OPERATOR
+ UWord32 UL_addNs; /* Complexity Weight of 1 */
+ UWord32 UL_subNs; /* Complexity Weight of 1 */
+ UWord32 UL_Mpy_32_32; /* Complexity Weight of 1 */
+ UWord32 Mpy_32_32_uu; /* Complexity Weight of 2 */
+ UWord32 Mpy_32_16_uu; /* Complexity Weight of 2 */
+ UWord32 norm_ul; /* Complexity Weight of 1 */
+ UWord32 UL_deposit_l; /* Complexity Weight of 1 */
+#endif /* #ifdef ENH_U_32_BIT_OPERATOR */
+
+#ifdef CONTROL_CODE_OPS
+ UWord32 LT_16; /* Complexity Weight of 1 */
+ UWord32 GT_16; /* Complexity Weight of 1 */
+ UWord32 LE_16; /* Complexity Weight of 1 */
+ UWord32 GE_16; /* Complexity Weight of 1 */
+ UWord32 EQ_16; /* Complexity Weight of 1 */
+ UWord32 NE_16; /* Complexity Weight of 1 */
+ UWord32 LT_32; /* Complexity Weight of 1 */
+ UWord32 GT_32; /* Complexity Weight of 1 */
+ UWord32 LE_32; /* Complexity Weight of 1 */
+ UWord32 GE_32; /* Complexity Weight of 1 */
+ UWord32 EQ_32; /* Complexity Weight of 1 */
+ UWord32 NE_32; /* Complexity Weight of 1 */
+ UWord32 LT_64; /* Complexity Weight of 1 */
+ UWord32 GT_64; /* Complexity Weight of 1 */
+ UWord32 LE_64; /* Complexity Weight of 1 */
+ UWord32 GE_64; /* Complexity Weight of 1 */
+ UWord32 EQ_64; /* Complexity Weight of 1 */
+ UWord32 NE_64; /* Complexity Weight of 1 */
+
+#endif /* #ifdef CONTROL_CODE_OPS */
+} BASIC_OP;
+
+
+Word32 TotalWeightedOperation (void);
+Word32 DeltaWeightedOperation (void);
+
+
+void generic_WMOPS_output (Word16 notPrintWorstWorstCase, char *test_file_name);
+/*
+ * This function enable to append :
+ * - to WMOPS_DATA_FILENAME file, the WMOPS information related
+ * to the execution of the application, function group by function
+ * group.
+ * - to CODE_PROFILE_FILENAME file, the WMOPS information related
+ * to the execution of the application, basic operation by basic
+ * operation.
+ * - to WMOPS_TOTAL_FILENAME file, the total WMOPS information related
+ * to the execution of the application.
+ *
+ * Note that :
+ * if the files exists, the data will be written at the end of file.
+ *
+ * test_file_name : Is a character string referencing each calls to
+ * generic_WMOPS_output(). Usually, it is the name of a test
+ * sequence file.
+ *
+ * notPrintWorstWorstCase : Same usage as in WMOPS_output().
+ */
+
+
+#if 0
+/*
+ * Example of how count.h could be used.
+ *
+ * In the example below it is assumed that the init_OBJECT functions
+ * does not use any calls to counter.h or basic_op.h. If this is the case
+ * a call to the function Reset_WMOPS_counter() must be done after each call
+ * to init_OBJECT if these operations is not to be included in the statistics.
+ */
+
+int main () {
+ int spe1Id, spe2Id, cheId;
+
+ /* initiate counters and objects */
+ spe1Id = getCounterId ("Spe 5k8");
+ setCounter (spe1Id);
+ Init_WMOPS_counter ();
+ init_spe1 ( ...);
+
+ spe2Id = getCounterId ("Spe 12k2");
+ setCounter (spe2Id);
+ Init_WMOPS_counter ();
+ init_spe2 ( ...);
+
+ cheId = getCounterId ("Channel encoder");
+ setCounter (cheId);
+ Init_WMOPS_counter ();
+ init_che ( ...);
+ ... while (data) {
+ test (); /* Note this call to test(); */
+ if (useSpe1)
+ setCounter (spe1Id);
+ else
+ setCounter (spe2Id);
+ Reset_WMOPS_counter ();
+ speEncode ( ...);
+ WMOPS_output (0); /* Normal routine for displaying WMOPS info */
+
+ setCounter (cheId);
+ Reset_WMOPS_counter ();
+ preChannelInter ( ...);
+ fwc (); /* Note the call to fwc() for each part */
+ convolve ( ...);
+ fwc (); /* of the channel encoder. */
+ interleave ( ...);
+ fwc ();
+ WMOPS_output (0); /* Normal routine for displaying WMOPS info */
+ }
+}
+#endif /* #if 0 */
+
+
+#endif /* _COUNT_H */
+
+
+/* end of file */
diff --git a/basic_op/enh1632.c b/basic_op/enh1632.c
new file mode 100644
index 0000000000000000000000000000000000000000..aa3d16b2f2316d81a3923eab730bc69d53c3678e
--- /dev/null
+++ b/basic_op/enh1632.c
@@ -0,0 +1,664 @@
+/*
+ ===========================================================================
+ File: ENH1632.C v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ ENHANCED 16-BIT & 32-BIT ARITHMETIC OPERATORS
+
+ History:
+ 07 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+
+ ============================================================================
+*/
+
+
+ /*****************************************************************************
+ *
+ * Enhanced 16/32 bit operators :
+ * s_max()
+ * s_min()
+ * L_max()
+ * L_min()
+ * shl_r()
+ * L_shl_r()
+ * L_mac0()
+ * L_mult0()
+ * L_msu0()
+ * s_and()
+ * s_or()
+ * s_xor()
+ * L_and()
+ * L_or()
+ * lshl()
+ * lshr()
+ * L_lshl()
+ * L_lshr()
+ * rotr()
+ * rotl()
+ * L_rotr()
+ * L_rotl()
+ *
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ *
+ * Include-Files
+ *
+ *****************************************************************************/
+#include
+#include
+#include "stl.h"
+
+#if (WMOPS)
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+extern int currCounter;
+#endif /* ifdef WMOPS */
+
+
+
+/*****************************************************************************
+ *
+ * Constants and Globals
+ *
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ *
+ * Functions
+ *
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ *
+ * Function Name : lshl
+ *
+ * Purpose :
+ *
+ * Logically shifts left var1 by var2 positions.
+ * - If var2 is negative, var1 is shifted to the LSBits by (-var2)
+ * positions with insertion of 0 at the MSBit.
+ * - If var2 is positive, var1 is shifted to the MSBits by (var2)
+ * positions.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value falls in
+ * the range 0xffff 8000 <= var1 <= 0x0000 7fff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value:
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range 0xffff 8000 <= var_out <= 0x0000 7fff.
+ *
+ *****************************************************************************/
+Word16 lshl (Word16 var1, Word16 var2) {
+ Word16 var_out = 0;
+
+ if (var2 < 0) {
+ var2 = -var2;
+ var_out = lshr (var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].lshr--;
+#endif /* ifdef WMOPS */
+
+ } else {
+ if (var2 == 0 || var1 == 0) {
+ var_out = var1;
+ } else if (var2 >= 16) {
+ var_out = 0;
+ } else {
+ var_out = var1 << var2;
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].lshl++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+/*****************************************************************************
+ *
+ * Function Name : lshr
+ *
+ * Purpose :
+ *
+ * Logically shifts right var1 by var2 positions.
+ * - If var2 is positive, var1 is shifted to the LSBits by (var2)
+ * positions with insertion of 0 at the MSBit.
+ * - If var2 is negative, var1 is shifted to the MSBits by (-var2)
+ * positions.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value falls in
+ * the range 0xffff 8000 <= var1 <= 0x0000 7fff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value:
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range 0xffff 8000 <= var_out <= 0x0000 7fff.
+ *
+ *****************************************************************************/
+Word16 lshr (Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ if (var2 < 0) {
+ var2 = -var2;
+ var_out = lshl (var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].lshl--;
+#endif /* ifdef WMOPS */
+
+ } else {
+ if (var2 == 0 || var1 == 0) {
+ var_out = var1;
+ } else if (var2 >= 16) {
+ var_out = 0;
+ } else {
+ var_out = var1 >> 1;
+ var_out = var_out & 0x7fff;
+ var_out = var_out >> (var2 - 1);
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].lshr++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_lshl
+ *
+ * Purpose :
+ *
+ * Logically shifts left L_var1 by var2 positions.
+ * - If var2 is negative, L_var1 is shifted to the LSBits by (-var2)
+ * positions with insertion of 0 at the MSBit.
+ * - If var2 is positive, L_var1 is shifted to the MSBits by (var2)
+ * positions.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value falls in
+ * the range 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value:
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value falls in
+ * the range 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+Word32 L_lshl (Word32 L_var1, Word16 var2) {
+ Word32 L_var_out = 0;
+
+ if (var2 < 0) {
+ var2 = -var2;
+ L_var_out = L_lshr (L_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_lshr--;
+#endif /* ifdef WMOPS */
+
+ } else {
+ if (var2 == 0 || L_var1 == 0) {
+ L_var_out = L_var1;
+ } else if (var2 >= 32) {
+ L_var_out = 0;
+ } else {
+ L_var_out = L_var1 << var2;
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L_lshl++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_lshr
+ *
+ * Purpose :
+ *
+ * Logically shifts right L_var1 by var2 positions.
+ * - If var2 is positive, L_var1 is shifted to the LSBits by (var2)
+ * positions with insertion of 0 at the MSBit.
+ * - If var2 is negative, L_var1 is shifted to the MSBits by (-var2)
+ * positions.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value falls in
+ * the range 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value:
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value falls in
+ * the range 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+Word32 L_lshr (Word32 L_var1, Word16 var2) {
+ Word32 L_var_out;
+
+ if (var2 < 0) {
+ var2 = -var2;
+ L_var_out = L_lshl (L_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_lshl--;
+#endif /* ifdef WMOPS */
+
+ } else {
+ if (var2 == 0 || L_var1 == 0) {
+ L_var_out = L_var1;
+ } else if (var2 >= 32) {
+ L_var_out = 0;
+ } else {
+ L_var_out = L_var1 >> 1;
+ L_var_out = L_var_out & 0x7fffffff;
+ L_var_out = L_var_out >> (var2 - 1);
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L_lshr++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : shl_r
+ *
+ * Purpose :
+ *
+ * Identical to shl( var1, var2) but with rounding. Saturates the result
+ * in case of underflows or overflows.
+ *
+ * Complexity weight : 3
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var_out <= 0x0000 7fff.
+ *
+ *****************************************************************************/
+Word16 shl_r (Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ if (var2 >= 0) {
+ var_out = shl (var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].shl--;
+#endif /* ifdef WMOPS */
+
+ } else {
+ var2 = -var2;
+ var_out = shr_r (var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].shr_r--;
+#endif /* ifdef WMOPS */
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].shl_r++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_shl_r
+ *
+ * Purpose :
+ *
+ * Same as L_shl( var1, var2) but with rounding. Saturates the result in
+ * case of underflows or overflows.
+ *
+ * Complexity weight : 3
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value falls in
+ * the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value falls in
+ * the range : 0x8000 0000 <= var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+Word32 L_shl_r (Word32 L_var1, Word16 var2) {
+ Word32 var_out;
+
+ if (var2 >= 0) {
+ var_out = L_shl (L_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_shl--;
+#endif /* ifdef WMOPS */
+
+ } else {
+ var2 = -var2;
+ var_out = L_shr_r (L_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_shr_r--;
+#endif /* ifdef WMOPS */
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L_shl_r++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : rotr
+ *
+ * Purpose :
+ *
+ * Performs a 16-bit logical rotation of var1 by 1 bit to the LSBits. The
+ * MSBit is set to var2 bit 0. The LSBit of var1 is kept in *var3 bit 0.
+ *
+ * Complexity weight : 3
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value must be 0
+ * or 1.
+ *
+ * Outputs :
+ *
+ * *var3 Points on a 16 bit short signed integer (Word16) whose
+ * value will be 0 or 1.
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var_out <= 0x0000 7fff.
+ *
+ *****************************************************************************/
+Word16 rotr (Word16 var1, Word16 var2, Word16 * var3) {
+ Word16 var_out;
+
+ *var3 = s_and (var1, 0x1);
+ var_out = s_or (lshr (var1, 1), lshl (var2, 15));
+
+#if (WMOPS)
+ multiCounter[currCounter].s_and--;
+ multiCounter[currCounter].lshl--;
+ multiCounter[currCounter].lshr--;
+ multiCounter[currCounter].s_or--;
+ multiCounter[currCounter].rotr++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : rotl
+ *
+ * Purpose :
+ *
+ * Performs a 16-bit logical rotation of var1 by 1 bit to the MSBits. The
+ * LSBit is set to var2 bit 0. The MSBit of var1 is kept in *var3 bit 0.
+ *
+ * Complexity weight : 3
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var1 <= 0x0000 7fff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value must be 0
+ * or 1.
+ *
+ * Outputs :
+ *
+ * *var3 Points on a 16 bit short signed integer (Word16) whose
+ * value will be 0 or 1.
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var_out <= 0x0000 7fff.
+ *
+ *****************************************************************************/
+Word16 rotl (Word16 var1, Word16 var2, Word16 * var3) {
+ Word16 var_out;
+
+ *var3 = lshr (var1, 15);
+
+ var_out = s_or (lshl (var1, 1), s_and (var2, 0x1));
+
+#if (WMOPS)
+ multiCounter[currCounter].lshr--;
+ multiCounter[currCounter].s_and--;
+ multiCounter[currCounter].lshl--;
+ multiCounter[currCounter].s_or--;
+ multiCounter[currCounter].rotl++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_rotr
+ *
+ * Purpose :
+ *
+ * Performs a 32-bit logical rotation of L_var1 by 1 bit to the LSBits. The
+ * MSBit is set to var2 bit 0. The LSBit of L_var1 is kept in *var3 bit 0.
+ *
+ * Complexity weight : 3
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value falls in
+ * the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value must be 0
+ * or 1.
+ *
+ * Outputs :
+ *
+ * *var3 Points on a 16 bit short signed integer (Word16) whose
+ * value will be 0 or 1.
+ *
+ * Return Value :
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value falls in
+ * the range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+Word32 L_rotr (Word32 L_var1, Word16 var2, Word16 * var3) {
+ Word32 L_var_out;
+
+ *var3 = s_and (extract_l (L_var1), 0x1);
+
+ L_var_out = L_or (L_lshr (L_var1, 1), L_lshl (L_deposit_l (var2), 31));
+
+#if (WMOPS)
+ multiCounter[currCounter].extract_l--;
+ multiCounter[currCounter].s_and--;
+ multiCounter[currCounter].L_deposit_l--;
+ multiCounter[currCounter].L_lshl--;
+ multiCounter[currCounter].L_lshr--;
+ multiCounter[currCounter].L_or--;
+ multiCounter[currCounter].L_rotr++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_rotl
+ *
+ * Purpose :
+ *
+ * Performs a 32-bit logical rotation of L_var1 by 1 bit to the MSBits. The
+ * LSBit is set to var2 bit 0. The MSBit of L_var1 is kept in *var3 bit 0.
+ *
+ * Complexity weight : 3
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value falls in
+ * the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value must be 0
+ * or 1.
+ *
+ * Outputs :
+ *
+ * *var3 Points on a 16 bit short signed integer (Word16) whose
+ * value will be 0 or 1.
+ *
+ * Return Value :
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value falls in
+ * the range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+Word32 L_rotl (Word32 L_var1, Word16 var2, Word16 * var3) {
+ Word32 L_var_out;
+
+ *var3 = extract_l (L_lshr (L_var1, 31));
+
+ L_var_out = L_or (L_lshl (L_var1, 1), L_deposit_l (s_and (var2, 0x1)));
+
+#if (WMOPS)
+ multiCounter[currCounter].L_lshr--;
+ multiCounter[currCounter].extract_l--;
+ multiCounter[currCounter].s_and--;
+ multiCounter[currCounter].L_deposit_l--;
+ multiCounter[currCounter].L_lshl--;
+ multiCounter[currCounter].L_or--;
+ multiCounter[currCounter].L_rotl++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* end of file */
diff --git a/basic_op/enh1632.h b/basic_op/enh1632.h
new file mode 100644
index 0000000000000000000000000000000000000000..1aee12b6430079becbe4f3602d738708c7d951bf
--- /dev/null
+++ b/basic_op/enh1632.h
@@ -0,0 +1,545 @@
+/*
+ ===========================================================================
+ File: ENH1632.H v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ ENHANCED 16-BIT & 32-BIT ARITHMETIC OPERATORS
+
+ History:
+ 07 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ March 06 v2.1 Changed to improve portability.
+ Some counters incrementations were missing (s_and,
+ s_or, s_xor).
+ 30 Nov 09 v2.3 saturate() removed
+
+ ============================================================================
+*/
+
+
+#ifndef _ENH1632_H
+#define _ENH1632_H
+
+
+/*****************************************************************************
+ *
+ * Constants and Globals
+ *
+ *****************************************************************************/
+
+
+#include "stl.h"
+
+
+#if (WMOPS)
+#include "count.h"
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+extern int currCounter;
+#endif /* ifdef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Prototypes for enhanced 16/32 bit arithmetic operators
+ *
+ *****************************************************************************/
+Word16 shl_r (Word16 var1, Word16 var2);
+Word32 L_shl_r (Word32 L_var1, Word16 var2);
+
+
+Word16 lshl (Word16 var1, Word16 var2);
+Word16 lshr (Word16 var1, Word16 var2);
+Word32 L_lshl (Word32 L_var1, Word16 var2);
+Word32 L_lshr (Word32 L_var1, Word16 var2);
+
+Word16 rotr (Word16 var1, Word16 var2, Word16 * var3);
+Word16 rotl (Word16 var1, Word16 var2, Word16 * var3);
+Word32 L_rotr (Word32 var1, Word16 var2, Word16 * var3);
+Word32 L_rotl (Word32 var1, Word16 var2, Word16 * var3);
+
+
+
+/*****************************************************************************
+ *
+ * Functions
+ *
+ *****************************************************************************/
+
+/*****************************************************************************
+ *
+ * Function Name : s_max
+ *
+ * Purpose :
+ *
+ * Compares var1 and var2 and returns the maximum value.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0x8000 <= var1 <= 0x7fff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0x8000 <= var2 <= 0x7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0x8000 <= L_var_out <= 0x7fff.
+ *
+ *****************************************************************************/
+static __inline Word16 s_max (Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ if (var1 >= var2)
+ var_out = var1;
+ else
+ var_out = var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].s_max++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : s_min
+ *
+ * Purpose :
+ *
+ * Compares var1 and var2 and returns the minimum value.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0x8000 <= var1 <= 0x7fff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0x8000 <= var2 <= 0x7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0x8000 <= var_out <= 0x7fff.
+ *
+ *****************************************************************************/
+static __inline Word16 s_min (Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ if (var1 <= var2)
+ var_out = var1;
+ else
+ var_out = var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].s_min++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_max
+ *
+ * Purpose :
+ *
+ * Compares L_var1 and L_var2 and returns the maximum value.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value falls in the
+ * range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * L_var2 32 bit long signed integer (Word32) whose value falls in the
+ * range : 0x8000 0000 <= L_var2 <= 0x7fff ffff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value falls in the
+ * range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+static __inline Word32 L_max (Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+
+ if (L_var1 >= L_var2)
+ L_var_out = L_var1;
+ else
+ L_var_out = L_var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].L_max++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_min
+ *
+ * Purpose :
+ *
+ * Compares L_var1 and L_var2 and returns the minimum value.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value falls in the
+ * range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * L_var2 32 bit long signed integer (Word32) whose value falls in the
+ * range : 0x8000 0000 <= L_var2 <= 0x7fff ffff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value falls in the
+ * range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+static __inline Word32 L_min (Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+
+ if (L_var1 <= L_var2)
+ L_var_out = L_var1;
+ else
+ L_var_out = L_var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].L_min++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+
+
+
+
+
+
+
+
+/*****************************************************************************
+ *
+ * Function Name : s_and
+ *
+ * Purpose :
+ *
+ * Performs logical AND of the two 16 bit input variables.
+ * var_out = var1 & var2
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value
+ * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value
+ * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value
+ * falls in the range 0xffff 8000 <= var_out <= 0x0000 7fff.
+ *
+ *****************************************************************************/
+static __inline Word16 s_and (Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ var_out = var1 & var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].s_and++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_and
+ *
+ * Purpose :
+ *
+ * Performs logical AND of the two 32 bit input variables.
+ * L_var_out = L_var1 & L_var2
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value
+ * falls in the range 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * L_var2 32 bit long signed integer (Word32) whose value
+ * falls in the range 0x8000 0000 <= L_var2 <= 0x7fff ffff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value
+ * falls in the range 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+static __inline Word32 L_and (Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+
+ L_var_out = L_var1 & L_var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].L_and++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : s_or
+ *
+ * Purpose :
+ *
+ * Performs logical OR of the two 16 bit input variables.
+ * var_out = var1 | var2
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value
+ * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value
+ * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value
+ * falls in the range 0xffff 8000 <= var_out <= 0x0000 7fff.
+ *
+ *****************************************************************************/
+static __inline Word16 s_or (Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ var_out = var1 | var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].s_or++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_or
+ *
+ * Purpose :
+ *
+ * Performs logical OR of the two 32 bit input variables.
+ * L_var_out = L_var1 | L_var2
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value
+ * falls in the range 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * L_var2 32 bit long signed integer (Word32) whose value
+ * falls in the range 0x8000 0000 <= L_var2 <= 0x7fff ffff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value
+ * falls in the range 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+static __inline Word32 L_or (Word32 L_var1, Word32 L_var2) {
+
+ Word32 L_var_out;
+
+ L_var_out = L_var1 | L_var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].L_or++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : s_xor
+ *
+ * Purpose :
+ *
+ * Performs logical XOR of the two 16 bit input variables.
+ * var_out = var1 ^ var2
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value
+ * falls in the range 0xffff 8000 <= var1 <= 0x0000 7fff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value
+ * falls in the range 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value
+ * falls in the range 0xffff 8000 <= var_out <= 0x0000 7fff.
+ *
+ *****************************************************************************/
+static __inline Word16 s_xor (Word16 var1, Word16 var2) {
+ Word16 var_out;
+
+ var_out = var1 ^ var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].s_xor++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_xor
+ *
+ * Purpose :
+ *
+ * Performs logical OR of the two 32 bit input variables.
+ * L_var_out = L_var1 ^ L_var2
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value
+ * falls in the range 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * L_var2 32 bit long signed integer (Word32) whose value
+ * falls in the range 0x8000 0000 <= L_var2 <= 0x7fff ffff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value
+ * falls in the range 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+static __inline Word32 L_xor (Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+
+ L_var_out = L_var1 ^ L_var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].L_xor++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif /*_ENH1632_H*/
+
+/* end of file */
diff --git a/basic_op/enh32.c b/basic_op/enh32.c
new file mode 100644
index 0000000000000000000000000000000000000000..1f8a6f83cc5c53183b6207ed753c1f7779b8a131
--- /dev/null
+++ b/basic_op/enh32.c
@@ -0,0 +1,215 @@
+/*****************************************************************************
+ *
+ * Enhanced 32 bit operators :
+ *
+ * Mpy_32_16_1()
+ * Mpy_32_16_r()
+ * Mpy_32_32()
+ * Mpy_32_32_r()
+ * Madd_32_16()
+ * Msub_32_16()
+ * Madd_32_32()
+ * Msub_32_32()
+ *
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ *
+ * Include-Files
+ *
+ *****************************************************************************/
+#include
+#include
+#include "enh32.h"
+
+#if (WMOPS)
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+extern int currCounter;
+#endif /* if WMOPS */
+
+#ifdef ENH_32_BIT_OPERATOR
+/*****************************************************************************
+ *
+ * Local Functions
+ *
+ *****************************************************************************/
+
+/*****************************************************************************
+ *
+ * Constants and Globals
+ *
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ *
+ * Functions
+ *
+ *****************************************************************************/
+
+Word32 Mpy_32_16_1 (Word32 L_var1, Word16 var2) {
+ Word32 L_var_out = W_sat_m (W_mult_32_16 (L_var1, var2) );
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_1++;
+ multiCounter[currCounter].W_mult_32_16--;
+ multiCounter[currCounter].W_sat_m--;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Mpy_32_16_r (Word32 L_var1, Word16 var2) {
+ Word32 L_var_out = W_round48_L (W_mult_32_16 (L_var1, var2 ) );
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_r++;
+ multiCounter[currCounter].W_mult_32_16--;
+ multiCounter[currCounter].W_round48_L--;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Mpy_32_32 (Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+ Word64 L64_var1;
+
+ L64_var1 = ((Word64)L_var1 * L_var2);
+ L64_var1 = W_shl (L64_var1, 1);
+ L_var_out = W_extract_h (L64_var1 );
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_32++;
+ multiCounter[currCounter].W_shl--;
+ multiCounter[currCounter].W_extract_h--;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Mpy_32_32_r (Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+ Word64 L64_var1;
+
+ L64_var1 = ((Word64) L_var1 * L_var2);
+ L64_var1 = W_shr (L64_var1, 15);
+ L_var_out = W_round48_L (L64_var1 );
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_32_r++;
+ multiCounter[currCounter].W_shr--;
+ multiCounter[currCounter].W_round48_L--;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Madd_32_16 (Word32 L_var3, Word32 L_var1, Word16 var2) {
+ Word32 L_var_out;
+
+ L_var_out = Mpy_32_16_1 (L_var1, var2);
+ L_var_out = L_add (L_var3, L_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_1--;
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].Madd_32_16++;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Madd_32_16_r (Word32 L_var3, Word32 L_var1, Word16 var2) {
+ Word32 L_var_out;
+
+ L_var_out = Mpy_32_16_r (L_var1, var2);
+ L_var_out = L_add (L_var3, L_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_r--;
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].Madd_32_16_r++;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Msub_32_16 (Word32 L_var3, Word32 L_var1, Word16 var2) {
+ Word32 L_var_out;
+
+ L_var_out = Mpy_32_16_1 (L_var1, var2);
+ L_var_out = L_sub(L_var3, L_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_1--;
+ multiCounter[currCounter].L_sub--;
+ multiCounter[currCounter].Msub_32_16++;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Msub_32_16_r (Word32 L_var3, Word32 L_var1, Word16 var2) {
+ Word32 L_var_out;
+
+ L_var_out = Mpy_32_16_r (L_var1, var2);
+ L_var_out = L_sub (L_var3, L_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_r--;
+ multiCounter[currCounter].L_sub--;
+ multiCounter[currCounter].Msub_32_16_r++;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Madd_32_32 (Word32 L_var3, Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+
+ L_var_out = Mpy_32_32 (L_var1, L_var2);
+ L_var_out = L_add (L_var3, L_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_32--;
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].Madd_32_32++;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Madd_32_32_r (Word32 L_var3, Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+
+ L_var_out = Mpy_32_32_r (L_var1, L_var2);
+ L_var_out = L_add (L_var3, L_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_32_r--;
+ multiCounter[currCounter].L_add--;
+ multiCounter[currCounter].Madd_32_32_r++;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Msub_32_32 (Word32 L_var3, Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+
+ L_var_out = Mpy_32_32 (L_var1, L_var2);
+ L_var_out = L_sub (L_var3, L_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_32--;
+ multiCounter[currCounter].L_sub--;
+ multiCounter[currCounter].Msub_32_32++;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+Word32 Msub_32_32_r (Word32 L_var3, Word32 L_var1, Word32 L_var2) {
+ Word32 L_var_out;
+
+ L_var_out = Mpy_32_32_r (L_var1, L_var2);
+ L_var_out = L_sub (L_var3, L_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_32_r--;
+ multiCounter[currCounter].L_sub--;
+ multiCounter[currCounter].Msub_32_32_r++;
+#endif /* if WMOPS */
+ return L_var_out;
+}
+
+#endif /* #ifdef ENH_32_BIT_OPERATOR */
+
+/* end of file */
diff --git a/basic_op/enh32.h b/basic_op/enh32.h
new file mode 100644
index 0000000000000000000000000000000000000000..a6e220c9512838e797b6add6dbe4d44e3c029d69
--- /dev/null
+++ b/basic_op/enh32.h
@@ -0,0 +1,38 @@
+
+#ifndef _ENH32_H
+#define _ENH32_H
+
+#include "stl.h"
+
+#ifndef Word64
+#define Word64 long long int
+#endif
+
+ /*****************************************************************************
+ *
+ * Prototypes for enhanced 32 bit arithmetic operators
+ *
+ *****************************************************************************/
+#ifdef ENH_32_BIT_OPERATOR
+
+Word32 Mpy_32_16_1 (Word32 L_var1, Word16 var2);
+Word32 Mpy_32_16_r (Word32 L_var1, Word16 var2);
+Word32 Mpy_32_32 (Word32 L_var1, Word32 L_var2);
+Word32 Mpy_32_32_r (Word32 L_var1, Word32 L_var2);
+Word32 Madd_32_16 (Word32 L_var3, Word32 L_var1, Word16 var2);
+Word32 Madd_32_16_r (Word32 L_var3, Word32 L_var1, Word16 var2);
+Word32 Msub_32_16 (Word32 L_var3, Word32 L_var1, Word16 var2);
+Word32 Msub_32_16_r (Word32 L_var3, Word32 L_var1, Word16 var2);
+Word32 Madd_32_32 (Word32 L_var3, Word32 L_var1, Word32 L_var2);
+Word32 Madd_32_32_r (Word32 L_var3, Word32 L_var1, Word32 L_var2);
+Word32 Msub_32_32 (Word32 L_var3, Word32 L_var1, Word32 L_var2);
+Word32 Msub_32_32_r (Word32 L_var3, Word32 L_var1, Word32 L_var2);
+
+#endif /* #ifdef ENH_32_BIT_OPERATOR */
+
+#endif /*_ENH32_H*/
+
+
+/* end of file */
+
+
diff --git a/basic_op/enh40.c b/basic_op/enh40.c
new file mode 100644
index 0000000000000000000000000000000000000000..a72a243b25fb9f356eb2328aeeaa9cca5d6ae1a9
--- /dev/null
+++ b/basic_op/enh40.c
@@ -0,0 +1,1045 @@
+/*
+ ===========================================================================
+ File: ENH40.C v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ 40-BIT ARITHMETIC OPERATORS
+
+ History:
+ 07 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+
+ ============================================================================
+*/
+
+
+/*****************************************************************************
+ *
+ * Enhanced 40 bit operators :
+ *
+ * L40_add()
+ * L40_sub()
+ * L40_abs()
+ * L40_negate()
+ * L40_max()
+ * L40_min()
+ * L40_shr()
+ * L40_shr_r()
+ * L40_shl()
+ * L40_shl_r()
+ * norm_L40()
+ * L40_mult()
+ * L40_mac()
+ * L40_msu()
+ * mac_r40()
+ * msu_r40()
+ * Mpy_32_16_ss()
+ * Mpy_32_32_ss()
+ * L40_lshl()
+ * L40_lshr()
+ * L40_round()
+ * L_saturate40()
+ * L40_set()
+ * Extract40_H()
+ * Extract40_L()
+ * L_Extract40()
+ * L40_deposit_h()
+ * L40_deposit_l()
+ * L40_deposit32()
+ *
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ *
+ * Include-Files
+ *
+ *****************************************************************************/
+#include
+#include
+#include "stl.h"
+
+#if (WMOPS)
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+extern int currCounter;
+#endif /* ifdef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Local Functions
+ *
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ *
+ * Constants and Globals
+ *
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ *
+ * Functions
+ *
+ *****************************************************************************/
+
+/*****************************************************************************
+ *
+ * Function Name : L40_shl
+ *
+ * Purpose :
+ *
+ * Arithmetically shifts left L40_var1 by var2 positions.
+ * - If var2 is negative, L40_var1 is shifted to the LSBits by (-var2)
+ * positions with extension of the sign bit.
+ * - If var2 is positive, L40_var1 is shifted to the MSBits by (var2)
+ * positions.
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var2 <= MAX_16.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_shl (Word40 L40_var1, Word16 var2) {
+
+ Word40 L40_var_out;
+ Word40 L40_constant = L40_set (0xc000000000);
+
+ if (var2 < 0) {
+ var2 = -var2;
+ L40_var_out = L40_shr (L40_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_shr--;
+#endif /* ifdef WMOPS */
+ }
+
+ else {
+ L40_var_out = L40_var1;
+
+ for (; var2 > 0; var2--) {
+ if (L40_var_out > 0x003fffffffff) {
+ L40_var_out = L40_OVERFLOW_OCCURED (L40_var_out);
+ break;
+ }
+
+ else if (L40_var_out < L40_constant) {
+ L40_var_out = L40_UNDERFLOW_OCCURED (L40_var_out);
+ break;
+ }
+
+ else {
+ L40_var_out = L40_var_out << 1;
+ }
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_set--;
+ multiCounter[currCounter].L40_shl++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_shr
+ *
+ * Purpose :
+ *
+ * Arithmetically shifts right L40_var1 by var2 positions.
+ * - If var2 is positive, L40_var1 is shifted to the LSBits by (var2)
+ * positions with extension of the sign bit.
+ * - If var2 is negative, L40_var1 is shifted to the MSBits by (-var2)
+ * positions.
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var2 <= MAX_16.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_shr (Word40 L40_var1, Word16 var2) {
+ Word40 L40_var_out;
+
+ if (var2 < 0) {
+ var2 = -var2;
+ L40_var_out = L40_shl (L40_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_shl--;
+#endif /* ifdef WMOPS */
+
+ } else {
+ L40_var_out = L40_var1 >> var2;
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_shr++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_negate
+ *
+ * Purpose :
+ *
+ * Negates L40_var1.
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_negate (Word40 L40_var1) {
+ Word40 L40_var_out;
+
+ L40_var_out = L40_add (~L40_var1, 0x01);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_add--;
+ multiCounter[currCounter].L40_negate++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_add
+ *
+ * Purpose :
+ *
+ * Adds L40_var1 and L40_var2 and returns the 40-bit result.
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * L40_var2 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var2 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_add (Word40 L40_var1, Word40 L40_var2) {
+ Word40 L40_var_out;
+
+ L40_var_out = L40_var1 + L40_var2;
+
+ if ((((L40_var1 & 0x8000000000) >> 39) != 0)
+ && (((L40_var2 & 0x8000000000) >> 39) != 0)
+ && (((L40_var_out & 0x8000000000) >> 39) == 0)) {
+ L40_var_out = L40_UNDERFLOW_OCCURED (L40_var_out);
+
+ } else if ((((L40_var1 & 0x8000000000) >> 39) == 0)
+ && (((L40_var2 & 0x8000000000) >> 39) == 0)
+ && (((L40_var_out & 0x8000000000) >> 39) != 0)) {
+ L40_var_out = L40_OVERFLOW_OCCURED (L40_var_out);
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L40_add++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_sub
+ *
+ * Purpose :
+ *
+ * Subtracts L40_var2 from L40_var1.
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * L40_var2 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var2 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_sub (Word40 L40_var1, Word40 L40_var2) {
+ Word40 L40_var_out;
+
+ L40_var_out = L40_var1 - L40_var2;
+
+ if ((((L40_var1 & 0x8000000000) >> 39) != 0)
+ && (((L40_var2 & 0x8000000000) >> 39) == 0)
+ && (((L40_var_out & 0x8000000000) >> 39) == 0)) {
+ L40_var_out = L40_UNDERFLOW_OCCURED (L40_var_out);
+
+ } else if ((((L40_var1 & 0x8000000000) >> 39) == 0)
+ && (((L40_var2 & 0x8000000000) >> 39) != 0)
+ && (((L40_var_out & 0x8000000000) >> 39) != 0)) {
+ L40_var_out = L40_OVERFLOW_OCCURED (L40_var_out);
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L40_sub++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_abs
+ *
+ * Purpose :
+ *
+ * Returns the absolute value of L40_var1.
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : 0x00 0000 0000 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_abs (Word40 L40_var1) {
+ Word40 L40_var_out;
+
+ if (L40_var1 < 0) {
+ L40_var_out = L40_negate (L40_var1);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_negate--;
+#endif /* ifdef WMOPS */
+
+ } else {
+ L40_var_out = L40_var1;
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_abs++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_max
+ *
+ * Purpose :
+ *
+ * Compares L40_var1 and L40_var2 and returns the maximum value.
+ *
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * L40_var2 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var2 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_max (Word40 L40_var1, Word40 L40_var2) {
+ Word40 L40_var_out;
+
+ if (L40_var1 < L40_var2)
+ L40_var_out = L40_var2;
+ else
+ L40_var_out = L40_var1;
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_max++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_min
+ *
+ * Purpose :
+ *
+ * Compares L40_var1 and L40_var2 and returns the minimum value.
+ *
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * L40_var2 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var2 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_min (Word40 L40_var1, Word40 L40_var2) {
+ Word40 L40_var_out;
+
+ if (L40_var1 < L40_var2)
+ L40_var_out = L40_var1;
+ else
+ L40_var_out = L40_var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_min++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_saturate40
+ *
+ * Purpose :
+ *
+ * If L40_var1 is greater than MAX_32, returns MAX_32.
+ * If L40_var1 is lower than MIN_32, returns MIN_32.
+ * If not, returns L_Extract40( L40_var1).
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L_var_out 32 bit long signed integer (Word32) whose value falls in
+ * the range : 0x8000 0000 <= L_var_out <= 0x7fff ffff.
+ *
+ *****************************************************************************/
+Word32 L_saturate40 (Word40 L40_var1) {
+ Word32 L_var_out;
+
+ Word40 UNDER_L40_var2 = (Word40) ~ ((((Word40) 1) << 31) - (Word40) 1);
+ Word40 OVER_L40_var2 = (Word40) ((((Word40) 1) << 31) - (Word40) 1);
+
+ if (L40_var1 < UNDER_L40_var2) {
+ L40_var1 = UNDER_L40_var2;
+ Overflow = 1;
+ }
+
+ if (L40_var1 > OVER_L40_var2) {
+ L40_var1 = OVER_L40_var2;
+ Overflow = 1;
+ }
+
+ L_var_out = L_Extract40 (L40_var1);
+
+#if (WMOPS)
+ multiCounter[currCounter].L_Extract40--;
+ multiCounter[currCounter].L_saturate40++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : Mpy_32_16_ss
+ *
+ * Purpose :
+ *
+ * Multiplies the 2 signed values L_var1 and var2 with saturation control
+ * on 48-bit. The operation is performed in fractional mode :
+ * - L_var1 is supposed to be in 1Q31 format.
+ * - var2 is supposed to be in 1Q15 format.
+ * - The result is produced in 1Q47 format : L_varout_h points to the
+ * 32 MSBits while varout_l points to the 16 LSBits.
+ *
+ * Complexity weight : 2
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value falls in
+ * the range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * *L_varout_h 32 bit long signed integer (Word32) whose value falls in
+ * the range : 0x8000 0000 <= L_varout_h <= 0x7fff ffff.
+ *
+ * *varout_l 16 bit short unsigned integer (UWord16) whose value falls in
+ * the range : 0x0000 0000 <= varout_l <= 0x0000 ffff.
+ *
+ * Return Value :
+ *
+ * none
+ *
+ *****************************************************************************/
+void Mpy_32_16_ss (Word32 L_var1, Word16 var2, Word32 * L_varout_h, UWord16 * varout_l) {
+ Word16 var1_h;
+ UWord16 uvar1_l;
+ Word40 L40_var1;
+
+ if ((L_var1 == (Word32) 0x80000000)
+ && (var2 == (Word16) 0x8000)) {
+ *L_varout_h = 0x7fffffff;
+ *varout_l = (UWord16) 0xffff;
+
+ } else {
+ uvar1_l = extract_l (L_var1);
+ var1_h = extract_h (L_var1);
+
+ /* Below line can not overflow, so we can use << instead of L40_shl. */
+ L40_var1 = ((Word40) ((Word32) var2 * (Word32) uvar1_l)) << 1;
+
+ *varout_l = Extract40_L (L40_var1);
+
+ L40_var1 = L40_shr (L40_var1, 16);
+ L40_var1 = L40_mac (L40_var1, var2, var1_h);
+
+ *L_varout_h = L_Extract40 (L40_var1);
+
+#if(WMOPS)
+ multiCounter[currCounter].extract_l--;
+ multiCounter[currCounter].extract_h--;
+ multiCounter[currCounter].Extract40_L--;
+ multiCounter[currCounter].L40_shr--;
+ multiCounter[currCounter].L40_mac--;
+ multiCounter[currCounter].L_Extract40--;
+#endif /* ifdef WMOPS */
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_ss++;
+#endif /* ifdef WMOPS */
+
+ return;
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : Mpy_32_32_ss
+ *
+ * Purpose :
+ *
+ * Multiplies the 2 signed values L_var1 and L_var2 with saturation control
+ * on 64-bit. The operation is performed in fractional mode :
+ * - L_var1 and L_var2 are supposed to be in 1Q31 format.
+ * - The result is produced in 1Q63 format : L_varout_h points to the
+ * 32 MSBits while L_varout_l points to the 32 LSBits.
+ *
+ * Complexity weight : 4
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value falls in the
+ * range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * L_var2 32 bit long signed integer (Word32) whose value falls in the
+ * range : 0x8000 0000 <= L_var2 <= 0x7fff ffff.
+ *
+ * Outputs :
+ *
+ * *L_varout_h 32 bit long signed integer (Word32) whose value falls in
+ * the range : 0x8000 0000 <= L_varout_h <= 0x7fff ffff.
+ *
+ * *L_varout_l 32 bit short unsigned integer (UWord32) whose value falls in
+ * the range : 0x0000 0000 <= L_varout_l <= 0xffff ffff.
+ *
+ *
+ * Return Value :
+ *
+ * none
+ *
+ *****************************************************************************/
+void Mpy_32_32_ss (Word32 L_var1, Word32 L_var2, Word32 * L_varout_h, UWord32 * L_varout_l) {
+ UWord16 uvar1_l, uvar2_l;
+ Word16 var1_h, var2_h;
+ Word40 L40_var1;
+
+ if ((L_var1 == (Word32) 0x80000000)
+ && (L_var2 == (Word32) 0x80000000)) {
+ *L_varout_h = 0x7fffffff;
+ *L_varout_l = (UWord32) 0xffffffff;
+
+ } else {
+
+ uvar1_l = extract_l (L_var1);
+ var1_h = extract_h (L_var1);
+ uvar2_l = extract_l (L_var2);
+ var2_h = extract_h (L_var2);
+
+ /* Below line can not overflow, so we can use << instead of L40_shl. */
+ L40_var1 = ((Word40) ((UWord32) uvar2_l * (UWord32) uvar1_l)) << 1;
+
+ *L_varout_l = 0x0000ffff & L_Extract40 (L40_var1);
+
+ L40_var1 = L40_shr (L40_var1, 16);
+ L40_var1 = L40_add (L40_var1, ((Word40) ((Word32) var2_h * (Word32) uvar1_l)) << 1);
+ L40_var1 = L40_add (L40_var1, ((Word40) ((Word32) var1_h * (Word32) uvar2_l)) << 1);
+ *L_varout_l |= (L_Extract40 (L40_var1)) << 16;
+
+ L40_var1 = L40_shr (L40_var1, 16);
+ L40_var1 = L40_mac (L40_var1, var1_h, var2_h);
+
+ *L_varout_h = L_Extract40 (L40_var1);
+
+#if (WMOPS)
+ multiCounter[currCounter].extract_l -= 2;
+ multiCounter[currCounter].extract_h -= 2;
+ multiCounter[currCounter].L_Extract40 -= 3;
+ multiCounter[currCounter].L40_shr -= 2;
+ multiCounter[currCounter].L40_add -= 2;
+ multiCounter[currCounter].L40_mac--;
+#endif /* ifdef WMOPS */
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_32_ss++;
+#endif /* ifdef WMOPS */
+
+ return;
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_lshl
+ *
+ * Purpose :
+ *
+ * Logically shifts left L40_var1 by var2 positions.
+ * - If var2 is negative, L40_var1 is shifted to the LSBits by (-var2)
+ * positions with insertion of 0 at the MSBit.
+ * - If var2 is positive, L40_var1 is shifted to the MSBits by (var2)
+ * positions.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var2 <= MAX_16.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_lshl (Word40 L40_var1, Word16 var2) {
+ Word40 L40_var_out;
+
+ if (var2 <= 0) {
+ var2 = -var2;
+ L40_var_out = L40_lshr (L40_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_lshr--;
+#endif /* ifdef WMOPS */
+
+ } else {
+ if (var2 >= 40)
+ L40_var_out = 0x0000000000;
+ else
+ L40_var_out = L40_var1 << var2;
+
+ L40_var_out = L40_set (L40_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_set--;
+#endif /* ifdef WMOPS */
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_lshl++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_lshr
+ *
+ * Purpose :
+ *
+ * Logically shifts right L40_var1 by var2 positions.
+ * - If var2 is positive, L40_var1 is shifted to the LSBits by (var2)
+ * positions with insertion of 0 at the MSBit.
+ * - If var2 is negative, L40_var1 is shifted to the MSBits by (-var2)
+ * positions.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var2 <= MAX_16.
+*
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_lshr (Word40 L40_var1, Word16 var2) {
+ Word40 L40_var_out;
+
+ if (var2 < 0) {
+ var2 = -var2;
+ L40_var_out = L40_lshl (L40_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_lshl--;
+#endif /* ifdef WMOPS */
+ } else {
+ if (var2 >= 40)
+ L40_var_out = 0x0000000000;
+ else
+ L40_var_out = (L40_var1 & 0xffffffffff) >> var2;
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_lshr++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : norm_L40
+ *
+ * Purpose :
+ *
+ * Produces the number of left shifts needed to normalize in 32 bit format
+ * the 40 bit variable L40_var1. This returned value can be used to scale
+ * L_40_var1 into the following intervals :
+ * - [(MAX_32+1)/2 .. MAX_32 ] for positive values.
+ * - [ MIN_32 .. (MIN_32/2)+1 ] for negative values.
+ * - [ 0 .. 0 ] for null values.
+ * In order to normalize the result, the following operation must be done :
+ * normelized_L40_var1 = L40_shl( L40_var1, norm_L40( L40_var1))
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range : -8 <= var_out <= 31.
+ *
+ *****************************************************************************/
+Word16 norm_L40 (Word40 L40_var1) {
+ Word16 var_out;
+
+ var_out = 0;
+
+ if (L40_var1 != 0) {
+ while ((L40_var1 > (Word32) 0x80000000L)
+ && (L40_var1 < (Word32) 0x7fffffffL)) {
+
+ L40_var1 = L40_shl (L40_var1, 1);
+ var_out++;
+
+#ifdef WMOPS
+ multiCounter[currCounter].L40_shl--;
+#endif /* ifdef WMOPS */
+ }
+
+ while ((L40_var1 < (Word32) 0x80000000L)
+ || (L40_var1 > (Word32) 0x7fffffffL)) {
+
+ L40_var1 = L40_shl (L40_var1, -1);
+ var_out--;
+
+#ifdef WMOPS
+ multiCounter[currCounter].L40_shl--;
+#endif /* ifdef WMOPS */
+ }
+ }
+#ifdef WMOPS
+ multiCounter[currCounter].norm_L40++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+
+
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_shr_r
+ *
+ * Purpose :
+ *
+ * Arithmetically shifts right L40_var1 by var2 positions and rounds the
+ * result. It is equivalent to L40_shr( L40_var1, var2) except that if the
+ * last bit shifted out to the LSBit is 1, then the shifted result is
+ * incremented by 1.
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 3
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_shr_r (Word40 L40_var1, Word16 var2) {
+ Word40 L40_var_out;
+
+ if (var2 > 39) {
+ L40_var_out = 0;
+
+ } else {
+ L40_var_out = L40_shr (L40_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_shr--;
+#endif /* ifdef WMOPS */
+
+ if (var2 > 0) {
+ if ((L40_var1 & ((Word40) 1 << (var2 - 1))) != 0) {
+ /* below line can not generate overflows on 40-bit */
+ L40_var_out++;
+ }
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_shr_r++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_shl_r
+ *
+ * Purpose :
+ *
+ * Arithmetically shifts left L40_var1 by var2 positions and rounds the
+ * result. It is equivalent to L40_shl( L40_var1, var2) except if var2 is
+ * negative. In that case, it does the same as
+ * L40_shr_r( L40_var1, (-var2)).
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 3
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : 0xffff 8000 <= var2 <= 0x0000 7fff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+Word40 L40_shl_r (Word40 L40_var1, Word16 var2) {
+ Word40 L40_var_out;
+
+ if (var2 >= 0) {
+ L40_var_out = L40_shl (L40_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_shl--;
+#endif /* ifdef WMOPS */
+
+ } else {
+ var2 = -var2;
+ L40_var_out = L40_shr_r (L40_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_shr_r--;
+#endif /* ifdef WMOPS */
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L40_shl_r++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/* end of file */
diff --git a/basic_op/enh40.h b/basic_op/enh40.h
new file mode 100644
index 0000000000000000000000000000000000000000..69ab7fc58a837548055b4fabae01236c8bc605b9
--- /dev/null
+++ b/basic_op/enh40.h
@@ -0,0 +1,839 @@
+/*
+ ===========================================================================
+ File: ENH40.H v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ 40-BIT ARITHMETIC OPERATORS
+
+ History:
+ 07 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ March 06 v2.1 Changed to improve portability.
+
+ ============================================================================
+*/
+
+
+#ifndef _ENH40_H
+#define _ENH40_H
+
+
+#include "stl.h"
+
+
+#ifdef WMOPS
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+extern int currCounter;
+#endif /* ifdef WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Constants and Globals
+ *
+ *****************************************************************************/
+#ifdef _MSC_VER
+#define MAX_40 (0x0000007fffffffff)
+#define MIN_40 (0xffffff8000000000)
+#endif /* ifdef _MSC_VER */
+
+
+
+/*****************************************************************************
+ *
+ * Macros for 40 bit arithmetic overflow management :
+ * Upon 40-bit overflow beyond MAX_40 or underflow beyond MIN_40,
+ * the application will exit.
+ *
+ *****************************************************************************/
+#define L40_OVERFLOW_OCCURED( L40_var1) (Overflow = 1, exit(1), L40_var1)
+#define L40_UNDERFLOW_OCCURED( L40_var1) (Overflow = 1, exit(2), L40_var1)
+
+
+
+ /*****************************************************************************
+ *
+ * Prototypes for enhanced 40 bit arithmetic operators
+ *
+ *****************************************************************************/
+Word40 L40_shr (Word40 L40_var1, Word16 var2);
+Word40 L40_shr_r (Word40 L40_var1, Word16 var2);
+Word40 L40_shl (Word40 L40_var1, Word16 var2);
+Word40 L40_shl_r (Word40 L40_var1, Word16 var2);
+
+static __inline Word40 L40_mult (Word16 var1, Word16 var2);
+
+static __inline Word40 L40_mac (Word40 L40_var1, Word16 var1, Word16 var2);
+static __inline Word16 mac_r40 (Word40 L40_var1, Word16 var1, Word16 var2);
+
+static __inline Word40 L40_msu (Word40 L40_var1, Word16 var1, Word16 var2);
+static __inline Word16 msu_r40 (Word40 L40_var1, Word16 var1, Word16 var2);
+
+
+void Mpy_32_16_ss (Word32 L_var1, Word16 var2, Word32 * L_varout_h, UWord16 * varout_l);
+void Mpy_32_32_ss (Word32 L_var1, Word32 L_var2, Word32 * L_varout_h, UWord32 * L_varout_l);
+
+
+Word40 L40_lshl (Word40 L40_var1, Word16 var2);
+Word40 L40_lshr (Word40 L40_var1, Word16 var2);
+
+static __inline Word40 L40_set (Word40 L40_var1);
+static __inline UWord16 Extract40_H (Word40 L40_var1);
+static __inline UWord16 Extract40_L (Word40 L40_var1);
+static __inline UWord32 L_Extract40 (Word40 L40_var1);
+
+static __inline Word40 L40_deposit_h (Word16 var1);
+static __inline Word40 L40_deposit_l (Word16 var1);
+static __inline Word40 L40_deposit32 (Word32 L_var1);
+
+static __inline Word40 L40_round (Word40 L40_var1);
+static __inline Word16 round40 (Word40 L40_var1);
+
+
+Word40 L40_add (Word40 L40_var1, Word40 L40_var2);
+Word40 L40_sub (Word40 L40_var1, Word40 L40_var2);
+Word40 L40_abs (Word40 L40_var1);
+Word40 L40_negate (Word40 L40_var1);
+Word40 L40_max (Word40 L40_var1, Word40 L40_var2);
+Word40 L40_min (Word40 L40_var1, Word40 L40_var2);
+Word32 L_saturate40 (Word40 L40_var1);
+Word16 norm_L40 (Word40 L40_var1);
+
+
+/*****************************************************************************
+ *
+ * Functions
+ *
+ *****************************************************************************/
+
+/*****************************************************************************
+ *
+ * Function Name : L40_set
+ *
+ * Purpose :
+ *
+ * Assigns a 40 constant to a Word40 with adequate initialization depending
+ * on underlying architecture constraints (for example to keep consistency
+ * of sign bits). Current implementation only validated on MSVC++6.0.
+ *
+ * Complexity weight : 3
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+/*#ifdef _MSC_VER*/
+static __inline Word40 L40_set (Word40 L40_var1) {
+ Word40 L40_var_out;
+
+ L40_var_out = L40_var1 & 0x000000ffffffffff;
+
+ if (L40_var1 & 0x8000000000)
+ L40_var_out = L40_var_out | 0xffffff0000000000;
+
+#ifdef WMOPS
+ multiCounter[currCounter].L40_set++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+/* #endif */ /* ifdef _MSC_VER */
+
+
+/*****************************************************************************
+ *
+ * Function Name : Extract40_H
+ *
+ * Purpose :
+ *
+ * Returns the bits [31-16] of L40_var1.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short unsigned integer (UWord16) whose value falls in
+ * the range : MIN_U_16 <= var_out <= MAX_U_16.
+ *
+ *****************************************************************************/
+static __inline UWord16 Extract40_H (Word40 L40_var1) {
+ UWord16 var_out;
+
+ var_out = (UWord16) (L40_var1 >> 16);
+
+#if (WMOPS)
+ multiCounter[currCounter].Extract40_H++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : Extract40_L
+ *
+ * Purpose :
+ *
+ * Returns the bits [15-0] of L40_var1.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short unsigned integer (UWord16) whose value falls in
+ * the range : MIN_U_16 <= var_out <= MAX_U_16.
+ *
+ *****************************************************************************/
+static __inline UWord16 Extract40_L (Word40 L40_var1) {
+ UWord16 var_out;
+
+ var_out = (UWord16) (L40_var1);
+
+#if (WMOPS)
+ multiCounter[currCounter].Extract40_L++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L_Extract40
+ *
+ * Purpose :
+ *
+ * Returns the bits [31-0] of L40_var1.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L_var_out 32 bit long unsigned integer (UWord32) whose value falls in
+ * range : MIN_U_32 <= L_var_out <= MAX_U_32.
+ *
+ *****************************************************************************/
+static __inline UWord32 L_Extract40 (Word40 L40_var1) {
+ UWord32 L_var_out;
+
+ L_var_out = (UWord32) L40_var1;
+
+#if (WMOPS)
+ multiCounter[currCounter].L_Extract40++;
+#endif /* ifdef WMOPS */
+
+ return (L_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_deposit_h
+ *
+ * Purpose :
+ *
+ * Deposits var1 in the bits [31-16] in a 40-bit number. The 16 LSBits of
+ * the output are zeroed and the 8 MSBits sign extend var1 sign bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var1 <= MAX_16.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+static __inline Word40 L40_deposit_h (Word16 var1) {
+ Word40 L40_var_out;
+
+ L40_var_out = ((Word40) var1) << 16;
+
+ if (var1 & 0x8000) {
+ L40_var_out = L40_set (L40_var_out | 0xff00000000);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_set--;
+#endif /* ifdef WMOPS */
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L40_deposit_h++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_deposit_l
+ *
+ * Purpose :
+ *
+ * Deposits var1 in the bits [15-0] in a 40-bit number. The 24 MSBits sign
+ * extend var1 sign bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var1 <= MAX_16.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+static __inline Word40 L40_deposit_l (Word16 var1) {
+ Word40 L40_var_out;
+
+ L40_var_out = var1;
+
+ if (var1 & 0x8000) {
+ L40_var_out = L40_set (L40_var_out | 0xffffff0000);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_set--;
+#endif /* ifdef WMOPS */
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L40_deposit_l++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_deposit32
+ *
+ * Purpose :
+ *
+ * Deposits L_var1 in the bits [31-0] in a 40-bit number. The 8 MSBits sign
+ * extend L_var1 sign bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L_var1 32 bit long signed integer (Word32) whose value falls in the
+ * range : 0x8000 0000 <= L_var1 <= 0x7fff ffff.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+static __inline Word40 L40_deposit32 (Word32 L_var1) {
+ Word40 L40_var_out;
+
+ L40_var_out = (Word40) L_var1;
+
+ if (L_var1 & 0x80000000) {
+ L40_var_out = L40_set (L40_var_out | 0xff00000000);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_set--;
+#endif /* ifdef WMOPS */
+ }
+#if (WMOPS)
+ multiCounter[currCounter].L40_deposit32++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+
+
+
+
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_round
+ *
+ * Purpose :
+ *
+ * Rounds the lower 16 bits of the 40 bit input number. Returns the 40 bit
+ * result with bits 15-0 cleared.
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+static __inline Word40 L40_round (Word40 L40_var1) {
+ Word40 L40_var_out;
+ Word40 L40_constant = L40_set (0xffffff0000);
+
+ L40_var_out = L40_add (0x8000, L40_var1);
+ L40_var_out = L40_var_out & L40_constant;
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_set--;
+ multiCounter[currCounter].L40_add--;
+ multiCounter[currCounter].L40_round++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : round40
+ *
+ * Purpose :
+ *
+ * Rounds the lower 16 bits of the 40 bit input number. Saturates the 40
+ * bit result to 32-bit and returns the resulting higher 16-bit.
+ * round40( L40_var1) = extract_h( L_saturate40( L40_round( L40_var1)))
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range 0xffff 8000 <= var_out <= 0x0000 7fff.
+ *
+ *****************************************************************************/
+static __inline Word16 round40 (Word40 L40_var1) {
+ Word16 var_out;
+
+ var_out = extract_h (L_saturate40 (L40_round (L40_var1)));
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_round--;
+ multiCounter[currCounter].L_saturate40--;
+ multiCounter[currCounter].extract_h--;
+ multiCounter[currCounter].round40++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_mult
+ *
+ * Purpose :
+ *
+ * Multiplies var1 by var2 and shifts the result left by 1. Returns the
+ * full precision result on 40-bit.
+ * L40_mult( var1, var2) = shiftleft(( var1 times var2), 1)
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * var1 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var1 <= MAX_16.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var2 <= MAX_16.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+static __inline Word40 L40_mult (Word16 var1, Word16 var2) {
+ Word32 L_var_out;
+ Word40 L40_var_out;
+
+ L_var_out = (Word32) var1 *(Word32) var2;
+ L40_var_out = (Word40) L_var_out;
+
+ /* Below line can not overflow, so we can use << instead of L40_shl. */
+ L40_var_out = L40_var_out << 1;
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_mult++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_mac
+ *
+ * Purpose :
+ *
+ * Multiplies var2 by var3. Shifts left the 40-bit result by 1 and adds
+ * the result to L40_var1. Returns a 40 bit result.
+ * L40_mac( L40_var1, var2, var3)
+ * = L40_add( L40_var1, L40_mult( var2, var3))
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var2 <= MAX_16.
+ *
+ * var3 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var3 <= MAX_16.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+static __inline Word40 L40_mac (Word40 L40_var1, Word16 var2, Word16 var3) {
+ Word40 L40_var_out;
+
+ L40_var_out = L40_mult (var2, var3);
+ L40_var_out = L40_add (L40_var1, L40_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_mult--;
+ multiCounter[currCounter].L40_add--;
+ multiCounter[currCounter].L40_mac++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+
+
+
+
+/*****************************************************************************
+ *
+ * Function Name : mac_r40
+ *
+ * Purpose :
+ *
+ * Multiplies var2 by var3. Shifts left the 40-bit result by 1 and adds
+ * the result to L40_var1. Rounds the lower 16 bits of the 40 bit result.
+ * Saturates the 40 bit result to 32-bit and returns the resulting higher
+ * 16-bit.
+ * mac_r40( L40_var1, var2, var3)
+ * = round40( L40_mac( L40_var1, var2, var3))
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 2
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var2 <= MAX_16.
+ *
+ * var3 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var3 <= MAX_16.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var_out <= MAX_16.
+ *
+ *****************************************************************************/
+static __inline Word16 mac_r40 (Word40 L40_var1, Word16 var2, Word16 var3) {
+ Word40 L40_var_out;
+ Word16 var_out;
+
+ L40_var_out = L40_mac (L40_var1, var2, var3);
+ var_out = round40 (L40_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_mac--;
+ multiCounter[currCounter].round40--;
+ multiCounter[currCounter].mac_r40++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+
+
+
+
+/*****************************************************************************
+ *
+ * Function Name : L40_msu
+ *
+ * Purpose :
+ *
+ * Multiplies var2 by var3. Shifts left the 40-bit result by 1 and
+ * subtracts the result from L40_var1. Returns a 40 bit result.
+ * L40_msu( L40_var1, var2, var3)
+ * = L40_sub( L40_var1, L40_mult( var2, var3))
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 1
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var2 <= MAX_16.
+ *
+ * var3 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var3 <= MAX_16.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * L40_var_out 40 bit long signed integer (Word40) whose value falls in
+ * the range : MIN_40 <= L40_var_out <= MAX_40.
+ *
+ *****************************************************************************/
+static __inline Word40 L40_msu (Word40 L40_var1, Word16 var2, Word16 var3) {
+ Word40 L40_var_out;
+
+ L40_var_out = L40_mult (var2, var3);
+ L40_var_out = L40_sub (L40_var1, L40_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_mult--;
+ multiCounter[currCounter].L40_sub--;
+ multiCounter[currCounter].L40_msu++;
+#endif /* ifdef WMOPS */
+
+ return (L40_var_out);
+}
+
+
+
+
+
+
+/*****************************************************************************
+ *
+ * Function Name : msu_r40
+ *
+ * Purpose :
+ *
+ * Multiplies var2 by var3. Shifts left the 40-bit result by 1 and
+ * subtracts the result from L40_var1. Rounds the lower 16 bits of the
+ * 40 bit result. Saturates the 40 bit result to 32-bit and returns the
+ * resulting higher 16-bit.
+ * msu_r40( L40_var1, var2, var3)
+ * = round40( L40_msu( L40_var1, var2, var3))
+ * Calls the macro L40_UNDERFLOW_OCCURED() in case of underflow on 40-bit.
+ * Calls the macro L40_OVERFLOW_OCCURED() in case of overflow on 40-bit.
+ *
+ * Complexity weight : 2
+ *
+ * Inputs :
+ *
+ * L40_var1 40 bit long signed integer (Word40) whose value falls in the
+ * range : MIN_40 <= L40_var1 <= MAX_40.
+ *
+ * var2 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var2 <= MAX_16.
+ *
+ * var3 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var3 <= MAX_16.
+ *
+ * Outputs :
+ *
+ * none
+ *
+ * Return Value :
+ *
+ * var_out 16 bit short signed integer (Word16) whose value falls in
+ * the range : MIN_16 <= var_out <= MAX_16.
+ *
+ *****************************************************************************/
+static __inline Word16 msu_r40 (Word40 L40_var1, Word16 var2, Word16 var3) {
+ Word40 L40_var_out;
+ Word16 var_out;
+
+ L40_var_out = L40_msu (L40_var1, var2, var3);
+ var_out = round40 (L40_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].L40_msu--;
+ multiCounter[currCounter].round40--;
+ multiCounter[currCounter].msu_r40++;
+#endif /* ifdef WMOPS */
+
+ return (var_out);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif /*_ENH40_H*/
+
+
+/* end of file */
diff --git a/basic_op/enh64.c b/basic_op/enh64.c
new file mode 100644
index 0000000000000000000000000000000000000000..4a365ee2c119d12f4e7515e4b0f2ddb0a51096ea
--- /dev/null
+++ b/basic_op/enh64.c
@@ -0,0 +1,1665 @@
+/*****************************************************************************
+*
+* Enhanced 64 bit operators :
+*
+* W_mac_32_16()
+* W_mac0_16_16()
+* W_msu0_16_16()
+*
+*****************************************************************************/
+
+
+/*****************************************************************************
+*
+* Include-Files
+*
+*****************************************************************************/
+#include
+#include
+#include "enh64.h"
+
+#if (WMOPS)
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+extern int currCounter;
+#endif /* if WMOPS */
+
+
+/*****************************************************************************
+*
+* Local Functions
+*
+*****************************************************************************/
+
+/*****************************************************************************
+*
+* Constants and Globals
+*
+*****************************************************************************/
+
+
+/*****************************************************************************
+*
+* Functions
+*
+*****************************************************************************/
+
+#ifdef ENH_64_BIT_OPERATOR
+
+
+/*___________________________________________________________________________
+| |
+| Function Name : W_add_nosat |
+| |
+| Purpose : |
+| |
+| 64 bits addition of the two 64 bits variables (L64_var1+L64_var2) |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| L64_var2 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|___________________________________________________________________________|
+*/
+Word64 W_add_nosat (Word64 L64_var1, Word64 L64_var2) {
+ Word64 L64_var_out;
+
+ L64_var_out = L64_var1 + L64_var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].W_add_nosat++;
+#endif
+
+ return L64_var_out;
+}
+
+
+/*___________________________________________________________________________
+| |
+| Function Name : W_sub_nosat |
+| |
+| Purpose : |
+| |
+| 64 bits subtraction of the two 64 bits variables (L64_var1-L64_var2) |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| L64_var2 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|___________________________________________________________________________|
+*/
+Word64 W_sub_nosat (Word64 L64_var1, Word64 L64_var2) {
+ Word64 L64_var_out;
+
+ L64_var_out = L64_var1 - L64_var2;
+
+#if (WMOPS)
+ multiCounter[currCounter].W_sub_nosat++;
+#endif
+
+ return L64_var_out;
+}
+
+
+/*___________________________________________________________________________
+| |
+| Function Name : W_shl |
+| |
+| Purpose : |
+| |
+| Arithmetically shift the 64 bit input L64_var1 left var2 positions. Zero|
+| fill the var2 LSB of the result. If var2 is negative, arithmetically |
+| shift L64_var1 right by -var2 with sign extension. Saturate the result |
+| in case of underflows or overflows. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long signed integer (Word64) whose value falls in the|
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|___________________________________________________________________________|
+*/
+Word64 W_shl (Word64 L64_var1, Word16 var2) {
+
+ Word64 L64_var_out = 0LL;
+
+ if (var2 <= 0) {
+ if (var2 < -64)
+ var2 = -64;
+ var2 = -var2;
+ L64_var_out = L64_var1 >> var2;
+ }
+ else {
+ for (; var2 > 0; var2--) {
+ if (L64_var1 > (Word64) 0X3fffffffffffffffLL) {
+ Overflow = 1;
+ L64_var_out = (Word64) 0X7fffffffffffffffLL;
+ break;
+ }
+ else {
+ if (L64_var1 < (Word64) 0xc000000000000000LL) {
+ Overflow = 1;
+ L64_var_out = (Word64)0x8000000000000000LL;
+ break;
+ }
+ }
+ L64_var1 *= 2;
+ L64_var_out = L64_var1;
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].W_shl++;
+#endif
+
+/* BASOP_CHECK();*/
+
+ return (L64_var_out);
+}
+
+
+/*___________________________________________________________________________
+| |
+| Function Name : W_shr |
+| |
+| Purpose : |
+| |
+| Arithmetically shift the 64 bit input L64_var1 right var2 positions. |
+| Zero fill the var2 LSB of the result. If var2 is negative, |
+| arithmetically shift L64_var1 left by -var2 with sign extension. |
+| Saturate the result in case of underflows or overflows. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long signed integer (Word64) whose value falls in the|
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|___________________________________________________________________________|
+*/
+Word64 W_shr (Word64 L64_var1, Word16 var2) {
+ Word64 L64_var_out;
+
+ if (var2 < 0) {
+ var2 = -var2;
+ L64_var_out = W_shl (L64_var1, var2);
+
+#if (WMOPS)
+ multiCounter[currCounter].W_shl--;
+#endif /* if WMOPS */
+
+ } else {
+ L64_var_out = L64_var1 >> var2;
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].W_shr++;
+#endif /* if WMOPS */
+
+ return (L64_var_out);
+}
+
+
+/*___________________________________________________________________________
+| |
+| Function Name : W_shl_nosat |
+| |
+| Purpose : |
+| |
+| Arithmetically shifts left the 64-bit variable W_var1 by var2 positions. |
+| if var2 is negative, W_var1 is shifted to the least significant bits by |
+| (�var2) positions with extension of the sign bit . |
+| if var2 is positive, W_var1 is shifted to the most significant bits by |
+| (var2) positions without saturation control on 64 bits. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long signed integer (Word64) whose value falls in the|
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|___________________________________________________________________________|
+*/
+Word64 W_shl_nosat (Word64 L64_var1, Word16 var2) {
+
+ Word64 L64_var_out = 0LL;
+
+ if (var2 <= 0) {
+ var2 = -var2;
+ L64_var_out = L64_var1 >> var2;
+ }
+ else {
+ L64_var_out = L64_var1 << var2;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].W_shl_nosat++;
+#endif
+
+/* BASOP_CHECK();*/
+
+ return (L64_var_out);
+}
+
+
+/*___________________________________________________________________________
+| |
+| Function Name : W_shr_nosat |
+| |
+| Purpose : |
+| |
+| Arithmetically shifts right the 64-bit variable W_var1 by var2 positions. |
+| if var2 is negative, W_var1 is shifted to the most significant bits by |
+| (�var2) positions without saturation control on 64 bits. |
+| if var2 is positive, W_var1 is shifted to the least significant bits by |
+| (var2) positions with extension of the sign bit . |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long signed integer (Word64) whose value falls in the|
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|___________________________________________________________________________|
+*/
+Word64 W_shr_nosat (Word64 L64_var1, Word16 var2) {
+ Word64 L64_var_out;
+
+ if (var2 < 0) {
+ var2 = -var2;
+ L64_var_out = L64_var1 << var2;
+
+ } else {
+ L64_var_out = L64_var1 >> var2;
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].W_shr_nosat++;
+#endif /* if WMOPS */
+
+ return (L64_var_out);
+}
+
+
+/*_________________________________________________________________________________________________
+| |
+| Function Name : W_mac_32_16 |
+| |
+| Purpose : |
+| |
+| Multiply L_var2 by var3 and shift the result left by 1. Add the 64 bit |
+| result to L64_var1, return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| L_var2 |
+| 32 bit signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var2 <= 0x7fff ffff |
+| |
+| var3 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var3 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_mac_32_16 (Word64 L64_var1, Word32 L_var2, Word16 var3) {
+ Word64 L64_var_out = ((Word64) L_var2*var3) << 1;
+ L64_var_out += L64_var1;
+#if (WMOPS)
+ multiCounter[currCounter].W_mac_32_16++;
+#endif /* if WMOPS */
+ return L64_var_out;
+}
+
+
+/*_________________________________________________________________________________________________
+| |
+| Function Name : W_msu_32_16 |
+| |
+| Purpose : |
+| |
+| Multiply L_var2 by var3 and shift the result left by 1. Subtract the 64 bit |
+| result from L64_var1, return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| L_var2 |
+| 32 bit signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var2 <= 0x7fff ffff |
+| |
+| var3 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var3 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_msu_32_16(Word64 L64_var1, Word32 L_var2, Word16 var3) {
+ Word64 L64_var_out = ((Word64 )L_var2*var3) << 1;
+ L64_var_out = L64_var1 - L64_var_out;
+#if (WMOPS)
+ multiCounter[currCounter].W_msu_32_16++;
+#endif /* if WMOPS */
+ return L64_var_out;
+}
+
+
+/*_________________________________________________________________________________________________
+| |
+| Function Name : W_mult_32_16 |
+| |
+| Purpose : |
+| |
+| Multiply L_var1 by var2 and shift the result left by 1. Return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L_var1 |
+| 32 bit signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var2 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_mult_32_16(Word32 L_var1, Word16 var2) {
+ Word64 L64_var_out = ((Word64 )L_var1*var2) << 1;
+#if (WMOPS)
+ multiCounter[currCounter].W_mult_32_16++;
+#endif /* if WMOPS */
+ return L64_var_out;
+}
+
+/*________________________________________________________________________________________________
+| |
+| Function Name : W_mult0_16_16 |
+| |
+| Purpose : |
+| |
+| Multiply var1 by var2 and return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| var1 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_acc <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_mult0_16_16(Word16 var1, Word16 var2) {
+ Word64 L64_var_out = (Word64 )var1*var2;
+#if (WMOPS)
+ multiCounter[currCounter].W_mult0_16_16++;
+#endif /* if WMOPS */
+ return L64_var_out;
+}
+
+/*________________________________________________________________________________________________
+| |
+| Function Name : W_mac0_16_16 |
+| |
+| Purpose : |
+| |
+| Multiply var2 by var3 and add the 64 bit result to L64_var1, return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var2 <= 0x0000 7fff. |
+| |
+| var3 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var3 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_mac0_16_16(Word64 L64_var1, Word16 var2, Word16 var3) {
+ Word64 L64_var_out = (Word64 )var2*var3;
+ L64_var_out += L64_var1;
+#if (WMOPS)
+ multiCounter[currCounter].W_mac0_16_16++;
+#endif /* if WMOPS */
+ return L64_var_out;
+}
+
+
+/*________________________________________________________________________________________________
+| |
+| Function Name : W_msu0_16_16 |
+| |
+| Purpose : |
+| |
+| Multiply var2 by var3 and subtract the 64 bit result from L64_var1, return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var2 <= 0x0000 7fff. |
+| |
+| var3 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var3 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_msu0_16_16 (Word64 L64_var1, Word16 var2, Word16 var3) {
+ Word64 L64_var_out = (Word64) var2*var3;
+ L64_var_out = L64_var1 - L64_var_out;
+#if (WMOPS)
+ multiCounter[currCounter].W_msu0_16_16++;
+#endif /* if WMOPS */
+ return L64_var_out;
+}
+
+
+
+/*_____________________________________________________________________________________
+| |
+| Function Name : W_sat_l |
+| |
+| Purpose : |
+| |
+| Saturate the lower 32 bits of the 64 bit input number L64_var into 32 bits. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L_var_out |
+| 32 bit signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var_out <= 0x7fff 0000. |
+|_____________________________________________________________________________________|
+*/
+Word32 W_sat_l (Word64 L64_var) {
+ Word32 L_var_out;
+
+ if (L64_var > 0x7FFFFFFF) {
+ L_var_out = 0x7FFFFFFF;
+ }
+ else if (L64_var < (int)0x80000000) {
+ L_var_out = 0x80000000;
+ }
+ else {
+ L_var_out = (Word32)L64_var;
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].W_sat_l++;
+#endif /* if WMOPS */
+
+ return L_var_out;
+}
+
+
+
+/*___________________________________________________________________________________
+| |
+| Function Name : W_sat_m |
+| |
+| Purpose : |
+| |
+| Truncates the lower 16 bits of the 64 bit input L64_var |
+| and saturates the number into 32 bits. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L_var_out |
+| 32 bit signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var_out <= 0x7fff 0000. |
+|_____________________________________________________________________________________|
+*/
+Word32 W_sat_m (Word64 L64_var) {
+ Word32 L_var_out;
+
+ L64_var = L64_var >> 16;
+ L_var_out = W_sat_l (L64_var);
+
+#if (WMOPS)
+ multiCounter[currCounter].W_sat_l--;
+ multiCounter[currCounter].W_sat_m++;
+#endif /* if WMOPS */
+
+ return L_var_out;
+}
+
+
+/*__________________________________________________________________________________
+| |
+| Function Name : W_deposit32_l |
+| |
+| Purpose : |
+| |
+| Deposit the 32 bit L_var1 into the 32 LS bits of the 64 bit output. The |
+| 32 MS bits of the output are sign extended. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L_var1 |
+| 32 bit long signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= var_out <= 0x7fff 0000. | |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|__________________________________________________________________________________|
+*/
+Word64 W_deposit32_l (Word32 L_var1) {
+ Word64 L64_var_out;
+
+ L64_var_out = (Word64) L_var1;
+
+#if (WMOPS)
+ multiCounter[currCounter].W_deposit32_l++;
+#endif
+
+ return (L64_var_out);
+}
+
+
+/*__________________________________________________________________________________
+| |
+| Function Name : W_deposit32_h |
+| |
+| Purpose : |
+| |
+| Deposit the 32 bit L_var1 into the 32 MS bits of the 64 bit output. The |
+| 32 LS bits of the output are zeroed. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L_var1 |
+| 32 bit long signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= var_out <= 0x7fff 0000. | |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|__________________________________________________________________________________|
+*/
+Word64 W_deposit32_h (Word32 L_var1) {
+ Word64 L64_var_out;
+
+ L64_var_out = (Word64) L_var1 << 32;
+
+#if (WMOPS)
+ multiCounter[currCounter].W_deposit32_h++;
+#endif
+
+ return (L64_var_out);
+}
+
+
+/*__________________________________________________________________________________
+| |
+| Function Name : W_extract_l |
+| |
+| Purpose : |
+| |
+| Return the 32 LSB of L64_var1. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L_var_out |
+| 32 bit long signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var_out <= 0x7fff 0000. |
+|__________________________________________________________________________________|
+*/
+Word32 W_extract_l (Word64 L64_var1) {
+ Word32 L_var_out;
+
+ L_var_out = (Word32) L64_var1;
+
+#if (WMOPS)
+ multiCounter[currCounter].W_extract_l++;
+#endif /* if WMOPS */
+
+ return (L_var_out);
+}
+
+
+
+/*__________________________________________________________________________________
+| |
+| Function Name : W_extract_h |
+| |
+| Purpose : |
+| |
+| Return the 32 MSB of L64_var1. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L_var_out |
+| 32 bit long signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var_out <= 0x7fff 0000. |
+|__________________________________________________________________________________|
+*/
+Word32 W_extract_h (Word64 L64_var1) {
+ Word32 L_var_out;
+
+ L_var_out = (Word32) (L64_var1 >> 32);
+
+#if (WMOPS)
+ multiCounter[currCounter].W_extract_h++;
+#endif /* if WMOPS */
+
+ return (L_var_out);
+}
+
+
+
+/*________________________________________________________________________________________________
+| |
+| Function Name : W_mult_16_16 |
+| |
+| Purpose : |
+| |
+| Multiply var1 by var2 and shift the result left by 1. Return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| var1 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_acc <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_mult_16_16 (Word16 var1, Word16 var2) {
+ Word64 L64_var_out = ((Word64) var1*var2) << 1;
+#if (WMOPS)
+ multiCounter[currCounter].W_mult_16_16++;
+#endif /* if WMOPS */
+ return L64_var_out;
+}
+/*________________________________________________________________________________________________
+| |
+| Function Name : W_mac_16_16 |
+| |
+| Purpose : |
+| |
+| Multiply var1 by var2 and shift the result left by 1 and add the 64 bit result to L64_acc, |
+| return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_acc |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_acc <= 0x7fffffff ffffffffLL. |
+| |
+| var1 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var2 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_mac_16_16 (Word64 L64_acc, Word16 var1, Word16 var2) {
+ Word64 L64_var_out = ((Word64) var1*var2) << 1;
+ L64_acc = L64_acc + L64_var_out;
+
+#if (WMOPS)
+ multiCounter[currCounter].W_mac_16_16++;
+#endif /* if WMOPS */
+ return L64_acc;
+}
+
+
+
+/*________________________________________________________________________________________________
+| |
+| Function Name : W_msu_16_16 |
+| |
+| Purpose : |
+| |
+| Multiply var2 by var3 and shift the result left by1 and subtract the 64 bit result |
+| from L64_var1, return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var2 <= 0x0000 7fff. |
+| |
+| var3 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var3 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_msu_16_16 (Word64 L64_var1, Word16 var2, Word16 var3) {
+ Word64 L64_var_out = ((Word64)var2*var3) << 1;
+ L64_var_out = L64_var1 - L64_var_out;
+#if (WMOPS)
+ multiCounter[currCounter].W_msu_16_16++;
+#endif /* if WMOPS */
+ return L64_var_out;
+}
+
+
+/*___________________________________________________________________________
+| |
+| Function Name : W_shl_sat_l |
+| |
+| Purpose : |
+| |
+| Arithmetically shift the 64 bit input L64_var left by n positions with |
+| lower 32 bit saturation and return the 32 LSB of 64 bit result |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var |
+| 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var <= 0x7fffffff ffffffffLL. |
+| |
+| n |
+| 32 bit signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= n <= 0x7fff 0000. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L_result |
+| 32 bit long signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_result <= 0x7fff 0000. |
+|___________________________________________________________________________|
+*/
+Word32 W_shl_sat_l (Word64 L64_var, Word32 n) {
+ Word32 L_result;
+ Word64 d_var_64;
+
+ d_var_64 = W_shl (L64_var, n);
+ L_result = W_sat_l (d_var_64);
+
+#if (WMOPS)
+ multiCounter[currCounter].W_shl_sat_l++;
+ multiCounter[currCounter].W_shl--;
+ multiCounter[currCounter].W_sat_l--;
+#endif /* if WMOPS */
+
+ return L_result;
+}
+
+
+/*__________________________________________________________________________________
+| |
+| Function Name : W_round48_L |
+| |
+| Purpose : |
+| |
+| Round asymmetrically lower 16 bits, and |
+| saturate the 17.47-bit values to 1.31-bit values |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L_var_out |
+| 32 bit long signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+|__________________________________________________________________________________|
+*/
+Word32 W_round48_L (Word64 L64_var1) {
+ Word64 L64_var_out;
+ Word32 L_result;
+
+ Word64 L64_var2 = 0x80000000;
+ Word64 L64_MIN = 0x8000000000000000LL;
+ Word64 L64_MAX = 0x7FFFFFFFFFFFFFFFLL;
+
+ L64_var1 = W_shl (L64_var1, 16);
+
+ L64_var_out = L64_var1 + L64_var2;
+
+ if ( ( (L64_var1 ^ L64_var2) & L64_MIN) == 0) {
+ if ( (L64_var_out ^ L64_var1) & L64_MIN) {
+ L64_var_out = (L64_var1 < 0) ? L64_MIN : L64_MAX;
+ Overflow = 1;
+ }
+ }
+ L_result = W_extract_h (L64_var_out);
+#if (WMOPS)
+ multiCounter[currCounter].W_round48_L++;
+ multiCounter[currCounter].W_extract_h--;
+ multiCounter[currCounter].W_shl--;
+#endif /* if WMOPS */
+
+ return (L_result);
+}
+
+/*__________________________________________________________________________________
+| |
+| Function Name : W_round32_s |
+| |
+| Purpose : |
+| |
+| Round asymmetrically lower 32 bits, and |
+| saturate the 17.47-bit values to 1.15-bit values |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| var_out |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var_out <= 0x0000 7fff. |
+|__________________________________________________________________________________|
+*/
+Word16 W_round32_s (Word64 L64_var1) {
+ Word64 L64_var_out;
+ Word32 L_var;
+ Word16 var_out;
+
+
+ Word64 L64_var2 = 0x800000000000LL;
+ Word64 L64_MIN = 0x8000000000000000LL;
+ Word64 L64_MAX = 0x7FFFFFFFFFFFFFFFLL;
+
+ L64_var1 = W_shl (L64_var1, 16);
+ L64_var_out = L64_var1 + L64_var2;
+
+ if (((L64_var1 ^ L64_var2) & L64_MIN) == 0) {
+ if ((L64_var_out ^ L64_var1) & L64_MIN) {
+ L64_var_out = (L64_var1 < 0) ? L64_MIN : L64_MAX;
+ Overflow = 1;
+ }
+ }
+ L_var = W_extract_h (L64_var_out);
+ var_out = extract_h (L_var);
+#if (WMOPS)
+ multiCounter[currCounter].W_round32_s ++;
+ multiCounter[currCounter].W_extract_h--;
+ multiCounter[currCounter].extract_h--;
+ multiCounter[currCounter].W_shl--;
+#endif /* if WMOPS */
+
+ return (var_out);
+}
+/*___________________________________________________________________________
+| |
+| Function Name : W_norm |
+| |
+| Purpose : |
+| |
+| Produces the number of left shifts needed to normalize the 64 bit varia-|
+| ble L64_var1.
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| var_out |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0x0000 0000 <= var_out <= 0x0000 003f. |
+|___________________________________________________________________________|
+*/
+Word16 W_norm (Word64 L64_var1) {
+ Word16 var_out;
+ if (L64_var1 == 0) {
+ var_out = 0;
+ }
+ else {
+ if (L64_var1 == (Word64) 0xffffffffffffffffLL) {
+ var_out = 63;
+ }
+ else {
+ if (L64_var1 < 0) {
+ L64_var1 = ~L64_var1;
+ }
+ for (var_out = 0; L64_var1 < (Word64) 0x4000000000000000LL; var_out++) {
+ L64_var1 <<= 1;
+ }
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].W_norm ++;
+#endif /* if WMOPS */
+ return (var_out);
+}
+
+
+
+/*______________________________________________________________________________
+| |
+| Function Name : W_add |
+| |
+| Purpose : |
+| |
+| 64 bits addition of the two 64 bits variables (L64_var1+L64_var2) with |
+| overflow control and saturation; the result is set at 0x7fffffffffffffffLL |
+| when overflow occurs or at 0x8000000000000000LL when underflow occurs. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| L64_var2 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|_______________________________________________________________________________|
+*/
+Word64 W_add (Word64 L64_var1, Word64 L64_var2) {
+ Word64 L64_var_out;
+
+ L64_var_out = L64_var1 + L64_var2;
+
+ if (((L64_var1 ^ L64_var2) & MIN_64) == 0) {
+ if ((L64_var_out ^ L64_var1) & MIN_64) {
+ L64_var_out = (L64_var1 < 0) ? MIN_64 : MAX_64;
+ Overflow = 1;
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].W_add++;
+#endif
+ return L64_var_out;
+}
+
+/*______________________________________________________________________________
+| |
+| Function Name : W_sub |
+| |
+| Purpose : |
+| |
+| 64 bits subtraction of the two 64 bits variables (L64_var1-L64_var2) with |
+| overflow control and saturation; the result is set at 0x7fffffffffffffffLL |
+| when overflow occurs or at 0x8000000000000000LL when underflow occurs. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| L64_var2 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|_______________________________________________________________________________|
+*/
+Word64 W_sub (Word64 L64_var1, Word64 L64_var2) {
+ Word64 L64_var_out;
+
+ L64_var_out = L64_var1 - L64_var2;
+
+ if (((L64_var1 ^ L64_var2) & MIN_64) != 0) {
+ if ((L64_var_out ^ L64_var1) & MIN_64) {
+ L64_var_out = (L64_var1 < 0) ? MIN_64 : MAX_64;
+ Overflow = 1;
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].W_add++;
+#endif
+ return L64_var_out;
+}
+
+
+/*______________________________________________________________________________
+| |
+| Function Name : W_neg |
+| |
+| Purpose : |
+| |
+| Negate the 64 bit variable L64_var1 with overflow control and saturation; |
+| Saturate and set overflow in the case where input is 0x8000000000000000LL. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+|_______________________________________________________________________________|
+*/
+Word64 W_neg (Word64 L64_var1) {
+ Word64 L64_var_out;
+
+ if (L64_var1 == MIN_64) {
+ L64_var_out = MAX_64;
+ Overflow = 1;
+ }
+ else {
+ L64_var_out = -L64_var1;
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].W_neg++;
+#endif
+
+ return (L64_var_out);
+
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : W_abs |
+ | |
+ | Purpose : |
+ | |
+ | Absolute value of L64_var1; Saturate in case where the input is |
+ | 0x8000000000000000LL |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | L64_var1 64 bit long signed integer (Word64) whose value falls in the |
+ | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | L64_var_out |
+ | 64 bit long signed integer (Word64) whose value falls in the |
+ | range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+ |___________________________________________________________________________|
+*/
+Word64 W_abs (Word64 L64_var1) {
+ Word64 L64_var_out;
+
+ if (L64_var1 == MIN_64) {
+ L64_var_out = MAX_64;
+ Overflow = 1;
+ }
+ else {
+ if (L64_var1 < 0) {
+ L64_var_out = -L64_var1;
+ }
+ else {
+ L64_var_out = L64_var1;
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].W_abs++;
+#endif
+
+ return (L64_var_out);
+}
+
+/*_________________________________________________________________________________________________
+| |
+| Function Name : W_mult_32_32 |
+| |
+| Purpose : |
+| |
+| Multiply L_var1 by L_var2 and shift the result left by 1.Saturate and set overflow in case |
+| where both inputs are 0x80000000 . Return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L_var1 |
+| 32 bit signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
+| |
+| L_var2 |
+| 32 bit signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_mult_32_32(Word32 L_var1, Word32 L_var2) {
+ Word64 L64_var_out;
+
+ if ((L_var1 == MIN_32) && (L_var2 == MIN_32)) {
+ L64_var_out = MAX_64;
+ Overflow = 1;
+ }
+ else {
+ L64_var_out = ((Word64 )L_var1*L_var2) << 1;
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].W_mult_32_32++;
+#endif /* if WMOPS */
+ return L64_var_out;
+}
+
+/*_________________________________________________________________________________________________
+| |
+| Function Name : W_mult0_32_32 |
+| |
+| Purpose : |
+| |
+| Multiply L_var1 by L_var2. Return a 64 bit result. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L_var1 |
+| 32 bit signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
+| |
+| L_var2 |
+| 32 bit signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var1 <= 0x7fff ffff |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long long signed integer (Word64) whose value falls in the |
+| range : 0x80000000 00000000LL <= L64_var_out <= 0x7fffffff ffffffffLL. |
+|_________________________________________________________________________________________________|
+*/
+Word64 W_mult0_32_32 (Word32 L_var1, Word32 L_var2) {
+ Word64 L64_var_out;
+
+ L64_var_out = (Word64) L_var1*L_var2;
+
+
+#if (WMOPS)
+ multiCounter[currCounter].W_mult0_32_32++;
+#endif /* if WMOPS */
+ return L64_var_out;
+}
+
+
+/*_____________________________________________________________________________
+| |
+| Function Name : W_lshl |
+| |
+| Purpose : |
+| |
+| Logically shift the 64 bit unsigned input L64_var1 left by var2 positions. |
+| Zero fill the var2 LSB of the result. If var2 is negative, logically shift |
+| L64_var1 right by -var2 with zero fill in the MSB. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long unsigned signed integer (UWord64) whose value falls |
+| in the range : 0LL <= L64_var1 <= 0xffffffff ffffffffLL. |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long unsigned signed integer (UWord64) whose value falls |
+| in the range : 0LL <= L64_var1 <= 0xffffffff ffffffffLL. |
+|______________________________________________________________________________|
+*/
+UWord64 W_lshl (UWord64 L64_var1, Word16 var2) {
+
+ UWord64 L64_var_out = 0LL;
+
+ if (var2 < 0) {
+ L64_var_out = L64_var1 >> (-var2);
+ }
+ else {
+ L64_var_out = L64_var1 << var2 ;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].W_lshl++;
+#endif
+
+ return (L64_var_out);
+}
+
+/*_____________________________________________________________________________
+| |
+| Function Name : W_lshr |
+| |
+| Purpose : |
+| |
+| Logically shift the 64 bit unsigned input L64_var1 right by var2 positions.|
+| Zero fill the var2 MSB of the result. If var2 is negative, logically shift |
+| L64_var1 left by -var2 with zero fill in the LSB. |
+| |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 64 bit long unsigned signed integer (UWord64) whose value falls |
+| in the range : 0LL <= L64_var1 <= 0xffffffff ffffffffLL. |
+| |
+| var2 |
+| 16 bit short signed integer (Word16) whose value falls in the |
+| range : 0xffff 8000 <= var1 <= 0x0000 7fff. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L64_var_out |
+| 64 bit long unsigned signed integer (UWord64) whose value falls |
+| in the range : 0LL <= L64_var1 <= 0xffffffff ffffffffLL. |
+|______________________________________________________________________________|
+*/
+UWord64 W_lshr (UWord64 L64_var1, Word16 var2) {
+
+ UWord64 L64_var_out = 0LL;
+
+ if (var2 < 0) {
+ L64_var_out = L64_var1 << (-var2);
+ }
+ else {
+ L64_var_out = L64_var1 >> var2 ;
+ }
+#if (WMOPS)
+ multiCounter[currCounter].W_lshr++;
+#endif
+
+ return (L64_var_out);
+}
+
+
+/*__________________________________________________________________________________
+| |
+| Function Name : W_round64_L |
+| |
+| Purpose : |
+| |
+| Round asymmetrically lower 32 bits, and |
+| saturate the 1.63-bit values to 1.31-bit values |
+| Complexity weight : 1 |
+| |
+| Inputs : |
+| |
+| L64_var1 |
+| 64 bit long long signed integer (Word64) whose value falls in |
+| range : 0x80000000 00000000LL <= L64_var1 <= 0x7fffffff ffffffffLL. |
+| |
+| Outputs : |
+| |
+| none |
+| |
+| Return Value : |
+| |
+| L_var_out |
+| 32 bit long signed integer (Word32) whose value falls in the |
+| range : 0x8000 0000 <= L_var_out <= 0x7fff ffff. |
+|__________________________________________________________________________________|
+*/
+Word32 W_round64_L (Word64 L64_var1) {
+ Word64 L64_var_out;
+ Word32 L_result;
+
+
+ Word64 L64_tmp = 0x80000000;
+ L64_var_out = W_add (L64_var1, L64_tmp);
+ L_result = W_extract_h (L64_var_out);
+
+#if (WMOPS)
+ multiCounter[currCounter].W_round64_L++;
+ multiCounter[currCounter].W_extract_h--;
+ multiCounter[currCounter].W_add--;
+#endif /* if WMOPS */
+
+ return (L_result);
+}
+
+#endif /* #ifdef ENH_64_BIT_OPERATOR */
+
+/* end of file */
diff --git a/basic_op/enh64.h b/basic_op/enh64.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac15ffdcd98da585c2aa55d3e933056ebcf436f2
--- /dev/null
+++ b/basic_op/enh64.h
@@ -0,0 +1,73 @@
+
+#ifndef _ENH64_H
+#define _ENH64_H
+
+#include "stl.h"
+
+#ifndef Word64
+#define Word64 long long int
+#endif
+
+#ifndef UWord64
+#define UWord64 unsigned long long int
+#endif
+
+#define MAX_64 (Word64)0x7fffffffffffffffLL
+#define MIN_64 (Word64)0x8000000000000000LL
+
+ /*****************************************************************************
+ *
+ * Prototypes for enhanced 64 bit arithmetic operators
+ *
+ *****************************************************************************/
+#ifdef ENH_64_BIT_OPERATOR
+Word64 W_add_nosat (Word64 L64_var1, Word64 L64_var2);
+Word64 W_sub_nosat (Word64 L64_var1, Word64 L64_var2);
+Word64 W_shl (Word64 L64_var1, Word16 var2);
+Word64 W_shr (Word64 L64_var1, Word16 var2);
+Word64 W_shl_nosat (Word64 L64_var1, Word16 var2);
+Word64 W_shr_nosat (Word64 L64_var1, Word16 var2);
+Word64 W_mult_32_16 (Word32 L_var1, Word16 var2);
+Word64 W_mac_32_16 (Word64 L64_acc, Word32 L_var1, Word16 var2);
+Word64 W_msu_32_16 (Word64 L64_acc, Word32 L_var1, Word16 var2);
+Word64 W_mult0_16_16 (Word16 var1, Word16 var2);
+Word64 W_mac0_16_16 (Word64 L64_acc, Word16 var1, Word16 var2);
+Word64 W_msu0_16_16 (Word64 L64_acc, Word16 var1, Word16 var2);
+Word64 W_mult_16_16 (Word16 var1, Word16 var2);
+Word64 W_mac_16_16 (Word64 L64_acc, Word16 var1, Word16 var2);
+Word64 W_msu_16_16 (Word64 L64_acc, Word16 var1, Word16 var2);
+
+Word64 W_deposit32_l (Word32 L_var1);
+Word64 W_deposit32_h (Word32 L_var1);
+
+Word32 W_sat_l (Word64 L64_var);
+Word32 W_sat_m (Word64 L64_var);
+Word32 W_shl_sat_l (Word64 L64_var, Word32 n);
+
+Word32 W_extract_l (Word64 L64_var1);
+Word32 W_extract_h (Word64 L64_var1);
+
+Word32 W_round48_L (Word64 L64_var1);
+Word16 W_round32_s (Word64 L64_var1);
+
+Word16 W_norm (Word64 L_var1);
+
+
+Word64 W_add (Word64 L64_var1, Word64 L64_var2);
+Word64 W_sub (Word64 L64_var1, Word64 L64_var2);
+Word64 W_neg (Word64 L64_var1);
+Word64 W_abs (Word64 L64_var1);
+Word64 W_mult_32_32 (Word32 L_var1, Word32 L_var2);
+Word64 W_mult0_32_32 (Word32 L_var1, Word32 L_var2);
+UWord64 W_lshl (UWord64 L64_var1, Word16 var2);
+UWord64 W_lshr (UWord64 L64_var1, Word16 var2);
+Word32 W_round64_L (Word64 L64_var1) ;
+
+#endif /* #ifdef ENH_64_BIT_OPERATOR */
+
+#endif /*_ENH64_H*/
+
+
+/* end of file */
+
+
diff --git a/basic_op/enhUL32.c b/basic_op/enhUL32.c
new file mode 100644
index 0000000000000000000000000000000000000000..9f82d044348b8cefcfdfb443e182457a16e9655c
--- /dev/null
+++ b/basic_op/enhUL32.c
@@ -0,0 +1,409 @@
+/*
+ ============================================================================
+ File: ENHUL32.C v.1.0 - 01.July.2018
+ ============================================================================
+
+ ENHANCED UNSIGNED 32-BIT ARITHMETIC OPERATORS
+ History:
+ v.0.5 - 21.March.2014
+
+ ============================================================================
+*/
+
+ /*****************************************************************************
+ *
+ * Enhanced Unsigned 32 bit operators :
+ * see complete list in .h file
+ *
+ *****************************************************************************/
+
+/*****************************************************************************
+ *
+ * Include-Files
+ *
+ *****************************************************************************/
+#include
+#include
+#include "stl.h"
+#include "enhUL32.h"
+
+#if (WMOPS)
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+extern int currCounter;
+#endif /* if WMOPS */
+
+
+/*****************************************************************************
+ *
+ * Constants and Globals
+ *
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ *
+ * Functions
+ *
+ *****************************************************************************/
+#ifdef ENH_U_32_BIT_OPERATOR
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : UL_deposit_l |
+ | |
+ | Purpose : |
+ | |
+ | Deposit the 16 bit var1 into the 16 LS bits of the 32 bit output. The |
+ | 16 MS bits of the output are not sign extended. |
+ |___________________________________________________________________________|
+*/
+
+UWord32 UL_deposit_l (UWord16 uvar) {
+ UWord32 UL_result;
+ UL_result = (UWord32) uvar; /* no sign extension*/
+#if (WMOPS)
+ multiCounter[currCounter].UL_deposit_l++;
+#endif
+ return (UL_result);
+}
+
+/*_____________________________________________________________________________
+ | |
+ | Function Name : norm_ul |
+ | |
+ | Purpose : |
+ | |
+ | Produces the number of left shifts needed to normalize the 32 bit varia- |
+ | ble UL_var1 for positive values on the interval with minimum of |
+ | 0 and maximum of 0xffffffff, ; in order to normalize the |
+ | result, the following operation must be done : |
+ | |
+ | norm_UL_var1 = UL_lshl(UL_var1, norm_ul(UL_var1)). |
+ | |
+ | Complexity weight : 1 |
+ | |
+ | Inputs : |
+ | |
+ | UL_var1 |
+ | 32 bit long unsigned integer (UWord32) whose value falls in the |
+ | range : 0x0000 0000 <= var1 <= 0xffff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | |
+ | var_out |
+ | 16 bit short signed integer (Word16) whose value falls in the |
+ | range : 0x0000 0000 <= var_out <= 0x0000 001f. (0..31d) |
+ |_____________________________________________________________________________|
+*/
+Word16 norm_ul (UWord32 UL_var1) {
+ Word16 var_out;
+
+ if (UL_var1 == 0) {
+ var_out = 0;
+ }
+ else {
+ /* simply test shift up until highest bit is set */
+ for (var_out = 0; UL_var1 < (UWord32) 0x80000000U; var_out++) {
+ UL_var1 <<= 1;
+ }
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].norm_ul++;
+#endif
+
+ return (var_out);
+}
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : UL_addNs |
+ | |
+ | Purpose : |
+ | |
+ | 32 bits addition of the two unsigned 32 bits variables |
+ | (L_var1+L_var2) with overflow control, but without saturation |
+ | |
+ | Outputs : |
+ | |
+ | *wrap = 1 if wrap occured, otherwize 0 |
+ | |
+ | Return Value : |
+ | |
+ | UL_var3 = modulo(UL_var1+UL_var2,32) |
+ |___________________________________________________________________________|
+*/
+
+UWord32 UL_addNs (UWord32 UL_var1, UWord32 UL_var2, UWord16 * wrap) {
+ UWord32 UL_var3;
+
+ /* STL Overflow flag is not updated */
+ UL_var3 = UL_var1 + UL_var2; /* 32-bit wrap may occur, like in C */
+
+ if (((UWord64) UL_var1 + (UWord64) UL_var2) > 0xFFFFFFFFU) {
+ *wrap = 1; /* wrapped output */
+ }
+ else {
+ *wrap = 0;
+ }
+
+#if WMOPS
+ multiCounter[currCounter].UL_addNs++;
+#endif
+
+ return UL_var3;
+}
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : UL_subNs |
+ | |
+ | Purpose : |
+ | |
+ | 32 bits subtraction of the two unsigned 32 bits variables |
+ | (L_var1-L_var2) with overflow control, but without saturation |
+ | |
+ | Outputs : |
+ | |
+ | *sgn = 1 if wrap (to "negative" occured, otherwise 0) |
+ | |
+ | Return Value : |
+ | |
+ | UL_var3 = modulo(UL_var1-UL_var2,32) |
+ |___________________________________________________________________________|
+*/
+
+UWord32 UL_subNs (UWord32 UL_var1, UWord32 UL_var2, UWord16 * sgn) {
+ UWord32 UL_var3;
+
+ UL_var3 = UL_var1 - UL_var2; /*wrap may occur, like in C */
+ if (UL_var1 >= UL_var2) {
+ *sgn = 0;
+ }
+ else {
+ *sgn = 1; /* "negative", wrapped output */
+ }
+
+#if WMOPS
+ multiCounter[currCounter].UL_subNs++;
+#endif
+ return UL_var3;
+}
+
+/*________________________________________________________________________________
+ | |
+ | Function Name : Mpy_32_16_uu |
+ | |
+ | Purpose : |
+ | |
+ | Multiplies the 2 unsigned values UL_var1 and uvar2. |
+ | The operation is performed in fractional mode : |
+ | - UL_var1 is supposed to be in Q32 format. |
+ | - var2 is supposed to be in Q16 format. |
+ | - The result is produced in Q48 format : UL_varout_h points to the |
+ | 32 MSBits while varout_l points to the 16 LSBits. |
+ | |
+ | Complexity weight : 2 |
+ | |
+ | Inputs : |
+ | |
+ | UL_var1 32 bit long unsigned integer (UWord32) whose value falls in |
+ | the range : 0x0000 0000 <= L_var1 <= 0xffff ffff. |
+ | |
+ | var2 16 bit short unsigned integer (UWord16) whose value falls in |
+ | the range : 0x0000 <= var2 <= 0x0000 ffff. |
+ | |
+ | Outputs : |
+ | |
+ | *UL_varout_h 32 bit long unsigned integer (UWord32) whose value falls in |
+ | the range : 0x0000 0000 <= UL_varout_h <= 0xffff ffff. |
+ | |
+ | *varout_l 16 bit short unsigned integer (UWord16) whose value falls in |
+ | the range : 0x0000 0000 <= varout_l <= 0x0000 ffff. |
+ | |
+ | Return Value : |
+ | |
+ | none |
+ |________________________________________________________________________________|
+*/
+void Mpy_32_16_uu (UWord32 UL_var1, UWord16 uvar2, UWord32 *UL_varout_h, UWord16 *varout_l) {
+ UWord64 UL64_var1;
+
+ /* 4294967295 * 65535 < 281474976710655 */
+ /* (uint64(2)^16-1 )*(uint64(2)^32-1) < (uint64(2)^(16+32)-1) */
+ UL64_var1 = ((UWord64) UL_var1)*((UWord64) uvar2);
+ *varout_l = (UWord16) UL64_var1;
+ *UL_varout_h = (UWord32) (UL64_var1>>16);
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_uu++;
+#endif /* if WMOPS */
+
+ return;
+}
+
+/*__________________________________________________________________________________
+ | |
+ | Function Name : Mpy_32_32_uu |
+ | |
+ | Purpose : |
+ | |
+ | Multiplies the 2 unsigned values UL_var1 and UL_var2. |
+ | The operation is performed in fractional mode : |
+ | - UL_var1 and UL_var2 are supposed to be in Q32 format. |
+ | - The result is produced in Q64 format : UL_varout_h points to the |
+ | 32 MSBits while UL_varout_l points to the 32 LSBits. |
+ | |
+ | Complexity weight : 4 |
+ | |
+ | Inputs : |
+ | |
+ | UL_var1 32 bit long unsigned integer (UWord32) whose value falls in the |
+ | range : 0x0000 0000 <= L_var1 <= 0xffff ffff. |
+ | |
+ | UL_var2 32 bit long unsigned integer (UWord32) whose value falls in the |
+ | range : 0x0000 0000 <= L_var2 <= 0xffff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | *UL_varout_h 32 bit long signed integer (Word32) whose value falls in |
+ | the range : 0x0000 0000 <= UL_varout_h <= 0xffff ffff. |
+ | |
+ | *UL_varout_l 32 bit short unsigned integer (UWord32) whose value falls in |
+ | the range : 0x0000 0000 <= UL_varout_l <= 0xffff ffff. |
+ | |
+ | Return Value : |
+ | |
+ | none |
+ |__________________________________________________________________________________|
+ */
+void Mpy_32_32_uu (UWord32 UL_var1, UWord32 UL_var2, UWord32 *UL_varout_h, UWord32 *UL_varout_l) {
+ UWord64 UL64_var1;
+ /* (uint64(2)^32-1 )*(uint64(2)^32-1) < (uint64(2)^(32+32)-1) */
+ UL64_var1 = ((UWord64) UL_var1)*((UWord64) UL_var2);
+ *UL_varout_h = (UWord32)(UL64_var1>>32);
+ *UL_varout_l = (UWord32)(UL64_var1);
+
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_32_uu++;
+#endif /* if WMOPS */
+
+ return;
+}
+
+/*_____________________________________________________________________________________
+ | |
+ | Function Name : UL_Mpy_32_32 |
+ | |
+ | Purpose : |
+ | |
+ | Multiplies the 2 unsigned values UL_var1 and UL_var2 |
+ | and returns the lower 32 bits, without saturation control. |
+ | |
+ | - UL_var1 and UL_var2 are supposed to be in Q32 format. |
+ | - The result is produced in Q64 format, the 32 LSBits. |
+ | |
+ | operates like a regular 32-by-32 bit unsigned int multiplication in ANSI-C. |
+ | UWord32) = (unsigned int)*(unsigned int); |
+ | |
+ | |
+ | Complexity weight : 2 |
+ | |
+ | Inputs : |
+ | |
+ | UL_var1 32 bit long unsigned integer (UWord32) whose value falls in the |
+ | range : 0x0000 0000 <= UL_var1 <= 0xffff ffff. |
+ | |
+ | UL_var2 32 bit long unsigned integer (UWord32) whose value falls in the |
+ | range : 0x0000 0000 <= UL_var2 <= 0xffff ffff. |
+ | |
+ | Outputs : |
+ | |
+ | none |
+ | |
+ | Return Value : |
+ | *UL_varout_l 32 bit short unsigned integer (UWord32) whose value falls in |
+ | the range : 0x0000 0000 <= UL_varout_l <= 0xffff ffff. |
+ | |
+ |_____________________________________________________________________________________|
+*/
+UWord32 UL_Mpy_32_32 (UWord32 UL_var1, UWord32 UL_var2) {
+ UWord32 UL_varout_l;
+
+#define MASK32 0xFFFFFFFFU
+ /* MASK32 may be needed in case Hardware is using larger than 32 bits for UWord32 type */
+ UL_varout_l = (UL_var1&MASK32)*(UL_var2&MASK32);
+ UL_varout_l = UL_varout_l&MASK32;
+#undef MASK32
+
+#if (WMOPS)
+ multiCounter[currCounter].UL_Mpy_32_32++;
+#endif /* if WMOPS */
+
+ return UL_varout_l;
+}
+
+
+#ifdef STL_TYPECASTS
+/* (Reuse of existing signed STL "L" operators) with
+ typecasting to make the resulting "UL" code a lot cleaner and more readable. */
+
+UWord32 UL_lshl( UWord32 UL_var1, Word16 var2) {
+ return( (UWord32)L_lshl( (Word32) UL_var1, var2));
+}
+
+UWord32 UL_lshr( UWord32 UL_var1, Word16 var2) {
+ return( (UWord32)L_lshr( (Word32) UL_var1, var2) );
+}
+
+UWord32 UL_and(UWord32 UL_var1, UWord32 UL_var2 )
+{
+ return (UWord32) L_and((Word32)UL_var1,(Word32) UL_var2);
+}
+
+UWord32 UL_or(UWord32 UL_var1, UWord32 UL_var2 )
+{
+ return (UWord32) L_or((Word32)UL_var1,(Word32) UL_var2);
+}
+
+UWord32 UL_xor(UWord32 UL_var1, UWord32 UL_var2 )
+{
+ return (UWord32) L_xor((Word32)UL_var1,(Word32) UL_var2);
+}
+
+UWord32 UL_deposit_h(UWord16 uvar1)
+{
+ return (UWord32) L_deposit_h((Word32)uvar1);
+}
+
+UWord16 u_extract_h(UWord32 UL_var1)
+{
+ return (UWord16) extract_h((Word32)UL_var1);
+}
+
+UWord16 u_extract_l(UWord32 UL_var1)
+{
+ return (UWord32)extract_l((Word32)UL_var1);
+}
+
+/* enable convenient reuse of Non-saturating UL_subNs , UL_addNs while "D"iscarding the sgn/wrap output flags */
+UWord32 UL_subNsD(UWord32 UL_var1, UWord32 UL_var2 )
+{
+ UWord16 dummy_sign;
+ return UL_subNs(UL_var1,UL_var2,&dummy_sign );
+}
+
+UWord32 UL_addNsD(UWord32 UL_var1, UWord32 UL_var2 )
+{
+ UWord16 dummy_wrap;
+ return UL_addNs(UL_var1,UL_var2,&dummy_wrap );
+}
+#endif
+
+#endif /* ENH_U_32_BIT_OPERATOR */
+
+/* end of file */
diff --git a/basic_op/enhUL32.h b/basic_op/enhUL32.h
new file mode 100644
index 0000000000000000000000000000000000000000..a89b2489b20ef5b55ec2fb1d1de3bc15e3b48834
--- /dev/null
+++ b/basic_op/enhUL32.h
@@ -0,0 +1,76 @@
+/*
+ ============================================================================
+ File: ENHUL32.H v.1.0 - 01.July.2018
+ ============================================================================
+
+
+ ============================================================================
+*/
+
+#ifndef _ENHUL32_H
+#define _ENHUL32_H
+
+/*****************************************************************************
+ *
+ * Constants and Globals
+ *
+ *****************************************************************************/
+#define STL_TYPECASTS /* logical shift and bitwise manipulation functions */
+ /* algorithmically exact to existing signed L_lshr and L_lshr */
+
+#include "stl.h"
+
+#ifndef UWord64
+#define UWord64 unsigned long long /* for local use inside UL_Mpy_32_* */
+#endif
+
+#if (WMOPS)
+#include "count.h"
+extern BASIC_OP multiCounter[MAXCOUNTERS]; /* existing signed counters are reused for unsigedn operators */
+extern int currCounter;
+#endif /* if WMOPS */
+
+/*****************************************************************************
+ *
+ * Prototypes for enhanced unsigned 32 bit arithmetic operators
+ *
+ *****************************************************************************/
+#ifdef ENH_U_32_BIT_OPERATOR
+UWord32 UL_addNs (UWord32 a, UWord32 b, UWord16* wrap);
+UWord32 UL_subNs (UWord32 a, UWord32 b, UWord16* sgn);
+
+UWord32 UL_Mpy_32_32 (UWord32 a, UWord32 b);
+void Mpy_32_32_uu (UWord32 a, UWord32 b, UWord32 *c_h, UWord32 *c_l); /* does not saturate */
+void Mpy_32_16_uu (UWord32 a, UWord16 b, UWord32 *c_h, UWord16 *c_l); /* does not saturate */
+
+Word16 norm_ul (UWord32 UL_var1);
+UWord32 UL_deposit_l (UWord16); /* deposit low without sign extension */
+#endif /* ENH_U_32_BIT_OPERATOR */
+
+/*****************************************************************************
+ *
+ * Inline Functions
+ *
+ *****************************************************************************/
+
+#ifdef STL_TYPECASTS
+/* (Reuse of existing signed STL "L" operators) with
+ typecasting to make the resulting "UL" code a lot cleaner and more readable. */
+UWord32 UL_lshl( UWord32 UL_var1, Word16 var2);
+UWord32 UL_lshr( UWord32 UL_var1, Word16 var2);
+UWord32 UL_and(UWord32 UL_var1, UWord32 UL_var2 );
+UWord32 UL_or(UWord32 UL_var1, UWord32 UL_var2 );
+UWord32 UL_xor(UWord32 UL_var1, UWord32 UL_var2 );
+UWord32 UL_deposit_h(UWord16 uvar1);
+UWord16 u_extract_h(UWord32 UL_var1);
+UWord16 u_extract_l(UWord32 UL_var1);
+
+/* enable convenient reuse of Non-saturating UL_subNs , UL_addNs
+ while "D"iscarding the sgn/wrap output flags */
+UWord32 UL_subNsD(UWord32 UL_var1, UWord32 UL_var2 );
+UWord32 UL_addNsD(UWord32 UL_var1, UWord32 UL_var2 );
+#endif
+
+#endif /*_ENHUL32_H*/
+
+/* end of file */
diff --git a/basic_op/move.h b/basic_op/move.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a02bd99c9e0d4eb41c0d6e4a2e8239678ce6953
--- /dev/null
+++ b/basic_op/move.h
@@ -0,0 +1,95 @@
+/*
+ ===========================================================================
+ File: MOVE.H v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ MOVE & MISC LEGACY OPERATORS
+
+ History:
+ 07 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ March 06 v2.1 Changed to improve portability.
+
+ ============================================================================
+*/
+
+
+#ifndef _MOVE_H
+#define _MOVE_H
+
+
+#include "stl.h"
+
+#if (WMOPS)
+extern BASIC_OP multiCounter[MAXCOUNTERS];
+extern int currCounter;
+#endif /* ifdef WMOPS */
+
+
+static __inline void move16 (void) {
+#if WMOPS
+ multiCounter[currCounter].move16++;
+#endif /* ifdef WMOPS */
+}
+
+
+
+
+
+
+static __inline void move32 (void) {
+#if WMOPS
+ multiCounter[currCounter].move32++;
+#endif /* ifdef WMOPS */
+}
+
+
+#ifdef ENH_64_BIT_OPERATOR
+static __inline void move64 (void) {
+#if WMOPS
+ multiCounter[currCounter].move64++;
+#endif /* if WMOPS */
+}
+#endif /* #ifdef ENH_64_BIT_OPERATOR */
+
+
+
+
+static __inline void test (void) {
+#if WMOPS
+ multiCounter[currCounter].Test++;
+#endif /* ifdef WMOPS */
+}
+
+
+static __inline void logic16 (void) {
+#if WMOPS
+ multiCounter[currCounter].Logic16++;
+#endif /* ifdef WMOPS */
+}
+
+
+static __inline void logic32 (void) {
+#if WMOPS
+ multiCounter[currCounter].Logic32++;
+#endif /* ifdef WMOPS */
+}
+
+
+/*-------- legacy ----------*/
+#define data_move () move16 ()
+#define L_data_move () move32 ()
+#define data_move_external () move16 ()
+#define compare_zero () test ()
+/*-------- end legacy ----------*/
+
+
+#endif /* _MOVE_H */
+
+
+/* end of file */
diff --git a/basic_op/patch.h b/basic_op/patch.h
new file mode 100644
index 0000000000000000000000000000000000000000..c843cb78bf069494e8ee897309c869ec8e70d077
--- /dev/null
+++ b/basic_op/patch.h
@@ -0,0 +1,51 @@
+/*
+ ===========================================================================
+ File: PATCH.H v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ OPERATOR NAME PATCHING
+
+ History:
+ 07 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+
+ ============================================================================
+*/
+
+
+#ifndef _PATCH_H
+#define _PATCH_H
+
+
+#if 1
+/*****************************************************************************
+ * start of Patch1 :
+ * It is enabled.
+ *
+ * This patch enables to keep compatibility with old ITU DSP operator names
+ * following naming conventions as proposed to ITU-T Standard Tool Library
+ * definition group in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ * TD 11 document.
+ *
+ *****************************************************************************/
+#define shift_r( var1, var2) shl_r( var1, var2)
+#define L_shift_r( L_var1, var2) L_shl_r( L_var1, var2)
+
+
+#endif /* end of Patch1 */
+
+
+
+
+
+
+
+
+
+
+#endif /* end of _PATCH_H */
diff --git a/basic_op/stl.h b/basic_op/stl.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ba4c3ff353b059179c8da826aea3b76f209d000
--- /dev/null
+++ b/basic_op/stl.h
@@ -0,0 +1,69 @@
+/*
+ ===========================================================================
+ File: STL.H v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ MAIN HEADER FILE
+
+ History:
+ 07 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ March 06 v2.1 Changed to improve portability.
+
+ ============================================================================
+*/
+
+
+#ifndef _STL_H
+#define _STL_H
+
+
+#include /* for size_t */
+
+#define ENH_U_32_BIT_OPERATOR
+#define COMPLEX_OPERATOR
+#define CONTROL_CODE_OPS
+#define ENH_32_BIT_OPERATOR
+
+#include "patch.h"
+/* both ALLOW_40bits and ALLOW_ENH_UL32 shall be enabled for the EVS codec. */
+#define ALLOW_40bits /* allow 32x16 and 32x32 multiplications */
+#define ALLOW_ENH_UL32 /* allow enhanced unsigned 32bit operators */
+#include "typedef.h"
+#include "basop32.h"
+#include "count.h"
+#include "move.h"
+#include "control.h"
+#include "enh1632.h"
+#include "oper_32b.h"
+#include "math_op.h"
+#include "log2.h"
+
+#include "enh40.h"
+
+
+#ifdef ENH_64_BIT_OPERATOR
+#include "enh64.h"
+#endif
+
+#ifdef ENH_32_BIT_OPERATOR
+#include "enh32.h"
+#endif
+
+#ifdef COMPLEX_OPERATOR
+#include "complex_basop.h"
+#endif
+
+#ifdef ENH_U_32_BIT_OPERATOR
+#include "enhUL32.h"
+#endif
+
+#endif /* ifndef _STL_H */
+
+
+/* end of file */
diff --git a/basic_op/typedef.h b/basic_op/typedef.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd031a3a6e3a7964d9ddacfb6291779c2147b394
--- /dev/null
+++ b/basic_op/typedef.h
@@ -0,0 +1,102 @@
+/*
+ ===========================================================================
+ File: TYPEDEF.H v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ TYPE DEFINITION PROTOTYPES
+
+ History:
+ 26.Jan.00 v1.0 Incorporated to the STL from updated G.723.1/G.729
+ basic operator library (based on basic_op.h)
+
+ 03 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+ March 06 v2.1 Changed to improve portability.
+
+ ============================================================================
+*/
+
+
+/*_____________________
+ | |
+ | Basic types. |
+ |_____________________|
+*/
+
+
+#ifndef _TYPEDEF_H
+#define _TYPEDEF_H "$Id $"
+
+#define ORIGINAL_TYPEDEF_H /* Define to get "original" version of typedef.h (this file). */
+#undef ORIGINAL_TYPEDEF_H /* Undefine to get the "new" version of typedef.h (see typedefs.h). */
+
+
+#ifdef ORIGINAL_TYPEDEF_H
+/*
+ * This is the original code from the file typedef.h
+ */
+
+#if defined(__BORLANDC__) || defined(__WATCOMC__) || defined(_MSC_VER) || defined(__ZTC__)
+typedef signed char Word8;
+typedef short Word16;
+typedef long Word32;
+typedef __int64 Word40;
+typedef unsigned short UWord16;
+typedef unsigned long UWord32;
+typedef int Flag;
+
+#elif defined(__CYGWIN__)
+typedef signed char Word8;
+typedef short Word16;
+typedef long Word32;
+typedef long long Word40;
+typedef unsigned short UWord16;
+typedef unsigned long UWord32;
+typedef int Flag;
+
+#elif defined(__sun)
+typedef signed char Word8;
+typedef short Word16;
+typedef long Word32;
+/*#error "The 40-bit operations have not been tested on __sun : need to define Word40"*/
+typedef long long Word40;
+typedef unsigned short UWord16;
+typedef unsigned long UWord32;
+typedef int Flag;
+
+#elif defined(__unix__) || defined(__unix) || defined(__APPLE__)
+typedef signed char Word8;
+typedef short Word16;
+typedef int Word32;
+/*#error "The 40-bit operations have not been tested on unix : need to define Word40"*/
+typedef long long Word40;
+typedef unsigned short UWord16;
+typedef unsigned int UWord32;
+typedef int Flag;
+#endif
+
+
+#else /* ifdef ORIGINAL_TYPEDEF_H */ /* not original typedef.h */
+
+
+
+
+/*
+ * Use (improved) type definition file typdefs.h and add a "Flag" type.
+ */
+#include "typedefs.h"
+typedef int Flag;
+
+
+#endif /* ifdef ORIGINAL_TYPEDEF_H */
+
+
+#endif /* ifndef _TYPEDEF_H */
+
+
+/* end of file */
diff --git a/basic_op/typedefs.h b/basic_op/typedefs.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0e7645a706bbbc90c4bc34adcf8d58db0035f26
--- /dev/null
+++ b/basic_op/typedefs.h
@@ -0,0 +1,218 @@
+/*
+ ===========================================================================
+ File: TYPEDEFS.H v.2.3 - 30.Nov.2009
+ ===========================================================================
+
+ ITU-T STL BASIC OPERATORS
+
+ NEW TYPE DEFINITION PROTOTYPES
+
+ History:
+ 03 Nov 04 v2.0 Incorporation of new 32-bit / 40-bit / control
+ operators for the ITU-T Standard Tool Library as
+ described in Geneva, 20-30 January 2004 WP 3/16 Q10/16
+ TD 11 document and subsequent discussions on the
+ wp3audio@yahoogroups.com email reflector.
+
+ Editor comment :
+ This file is not yet used or validated since
+ ORIGINAL_TYPEDEF_H compilation flag is defined in
+ typedef.h. This file is incorporated for future
+ reference / usage.
+
+ ============================================================================
+*/
+
+
+/******************************************************************************
+ *
+ * File : typedefs.h
+ * Description : Definition of platform independent data
+ * types and constants
+ *
+ *
+ * The following platform independent data types and corresponding
+ * preprocessor (#define) constants are defined:
+ *
+ * defined type meaning corresponding constants
+ * ----------------------------------------------------------
+ * Char character (none)
+ * Bool boolean true, false
+ * Word8 8-bit signed minWord8, maxWord8
+ * UWord8 8-bit unsigned minUWord8, maxUWord8
+ * Word16 16-bit signed minWord16, maxWord16
+ * UWord16 16-bit unsigned minUWord16, maxUWord16
+ * Word32 32-bit signed minWord32, maxWord32
+ * UWord32 32-bit unsigned minUWord32, maxUWord32
+ * Float floating point minFloat, maxFloat
+ *
+ *
+ * The following compile switches are #defined:
+ *
+ * PLATFORM string indicating platform progam is compiled on
+ * possible values: "OSF", "PC", "SUN"
+ *
+ * OSF only defined if the current platform is an Alpha
+ * PC only defined if the current platform is a PC
+ * SUN only defined if the current platform is a Sun
+ *
+ * LSBFIRST is defined if the byte order on this platform is
+ * "least significant byte first" -> defined on DEC Alpha
+ * and PC, undefined on Sun
+ *
+ *****************************************************************************/
+
+
+#ifndef _TYPEDEFS_H
+#define _TYPEDEFS_H "$Id $"
+
+/*****************************************************************************
+ * INCLUDE FILES
+ *****************************************************************************/
+#include
+#include
+
+#define ENH_64_BIT_OPERATOR
+
+/*****************************************************************************
+ * DEFINITION OF CONSTANTS
+ *****************************************************************************/
+/*
+ ********* define char type
+ */
+typedef char Char;
+
+typedef unsigned short int UNS_Word16; /* 16 bit "register" (sw*) */
+#ifdef UNS_Word16
+#pragma message ("UNS_Word16 is defined but not officially part of STL2009@")
+#endif
+
+/*
+ ********* define 8 bit signed/unsigned types & constants
+ */
+#if SCHAR_MAX == 127
+typedef signed char Word8;
+#define minWord8 SCHAR_MIN
+#define maxWord8 SCHAR_MAX
+
+typedef unsigned char UWord8;
+#define minUWord8 0
+#define maxUWord8 UCHAR_MAX
+#else
+#error cannot find 8-bit type
+#endif
+
+
+/*
+ ********* define 16 bit signed/unsigned types & constants
+ */
+#if INT_MAX == 32767
+typedef int Word16;
+#define minWord16 INT_MIN
+#define maxWord16 INT_MAX
+typedef unsigned int UWord16;
+#define minUWord16 0
+#define maxUWord16 UINT_MAX
+#elif SHRT_MAX == 32767
+typedef short Word16;
+#define minWord16 SHRT_MIN
+#define maxWord16 SHRT_MAX
+typedef unsigned short UWord16;
+#define minUWord16 0
+#define maxUWord16 USHRT_MAX
+#else
+#error cannot find 16-bit type
+#endif
+
+/* Definition of Word64 */
+#ifdef ENH_64_BIT_OPERATOR
+#define Word64 long long int
+#endif /* #ifdef ENH_64_BIT_OPERATOR */
+
+/* Definition of Word40 was missing 10/06/2013 */
+#define Word40 long long
+
+/*
+ ********* define 32 bit signed/unsigned types & constants
+ */
+#if INT_MAX == 2147483647
+typedef int Word32;
+#define minWord32 INT_MIN
+#define maxWord32 INT_MAX
+typedef unsigned int UWord32;
+#define minUWord32 0
+#define maxUWord32 UINT_MAX
+#elif LONG_MAX == 2147483647
+typedef long Word32;
+#define minWord32 LONG_MIN
+#define maxWord32 LONG_MAX
+typedef unsigned long UWord32;
+#define minUWord32 0
+#define maxUWord32 ULONG_MAX
+#else
+#error cannot find 32-bit type
+#endif
+
+/*
+ ********* define floating point type & constants
+ */
+/* use "if 0" below if Float should be double;
+ use "if 1" below if Float should be float
+ */
+#if 0
+typedef float Float;
+#define maxFloat FLT_MAX
+#define minFloat FLT_MIN
+#else
+typedef double Float;
+#define maxFloat DBL_MAX
+#define minFloat DBL_MIN
+#endif
+
+/*
+ ********* define complex type
+ */
+typedef struct {
+ Float r; /* real part */
+ Float i; /* imaginary part */
+} CPX;
+
+/*
+ ********* define boolean type
+ */
+typedef int Bool;
+#define false 0
+#define true 1
+
+/*
+ ********* Check current platform
+ */
+#if defined (__MSDOS__)
+#define PC
+#define PLATFORM "PC"
+#define LSBFIRST
+#elif defined (__osf__)
+#define OSF
+#define PLATFORM "OSF"
+#define LSBFIRST
+#elif defined (__sun__) || defined (__sun)
+#define SUN
+#define PLATFORM "SUN"
+#undef LSBFIRST
+#elif defined (linux) && defined (i386)
+#define PC
+#define PLATFORM "PC"
+#define LSBFIRST
+#else
+/*#error "can't determine architecture; adapt typedefs.h to your platform"*/
+/* for MSVC 2008 10/06/2013 */
+#define PC
+#define PLATFORM "PC"
+#define LSBFIRST
+#endif
+
+
+#endif /* ifndef _TYPEDEFS_H */
+
+
+/* end of file */
diff --git a/lib_com/ACcontextMapping.c b/lib_com/ACcontextMapping.c
new file mode 100644
index 0000000000000000000000000000000000000000..154618f6a3a5a8743ad987ee0226ffcf5ade3c22
--- /dev/null
+++ b/lib_com/ACcontextMapping.c
@@ -0,0 +1,81 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include
+#include
+#include
+#include "options.h"
+#include "basop_util.h"
+#include "cnst_fx.h"
+#include "prot_fx.h"
+#include "rom_com_fx.h"
+#include "stl.h"
+
+/* Returns: index of next coefficient */
+Word16 get_next_coeff_mapped(
+ Word16 ii[2], /* i/o: coefficient indexes */
+ Word16 *pp, /* o : peak(1)/hole(0) indicator */
+ Word16 *idx, /* o : index in unmapped domain */
+ CONTEXT_HM_CONFIG *hm_cfg /* i : HM configuration */
+)
+{
+ Word16 p;
+
+ p = s_and(sub(ii[1], hm_cfg->numPeakIndices), sub(hm_cfg->indexBuffer[ii[1]], hm_cfg->indexBuffer[ii[0]]));
+ if (p > 0)
+ {
+ p = 0;
+ move16();
+ }
+ if (p < 0)
+ {
+ p = 1;
+ move16();
+ }
+ *pp = p;
+ move16();
+ *idx = ii[p];
+ move16();
+ ii[p] = add(ii[p], 1);
+ move16();
+ return hm_cfg->indexBuffer[*idx];
+}
+
+/* Returns: index of next coefficient */
+Word16 get_next_coeff_unmapped(
+ Word16 ii[2], /* i/o: coefficient indexes */
+ Word16 *pp, /* o : peak(1)/hole(0) indicator */
+ Word16 *idx, /* o : index in unmapped domain */
+ CONTEXT_HM_CONFIG *hm_cfg /* i : HM configuration */
+)
+{
+ (void)pp;
+ (void)hm_cfg;
+
+ *idx = ii[0];
+ move16();
+ ii[0] = add(ii[0], 1);
+ move16();
+ return *idx;
+}
+
+Word16 update_mixed_context(Word16 ctx, Word16 a)
+{
+ Word32 t32;
+ Word16 t=0; /* initialize just to avoid compiler warning */
+
+ t32 = L_mac0(1-13, s_and(a, ~1), add(shr(a, 2), 1));
+ if (t32 <= 0)
+ {
+ t = extract_l(t32);
+ }
+ a = shr(a, 3);
+ if (t32 > 0)
+ {
+ t = s_min(a, 2);
+ }
+ return add(shl(s_and(ctx, 0xf), 4), add(t, 13));
+}
+
diff --git a/lib_com/ari.c b/lib_com/ari.c
new file mode 100644
index 0000000000000000000000000000000000000000..edf6e473c1c234b4c281e5e68a8d4850e785f8aa
--- /dev/null
+++ b/lib_com/ari.c
@@ -0,0 +1,57 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "assert.h"
+#include "prot_fx.h"
+#include "basop_mpy.h"
+#include "cnst_fx.h"
+#include "stl.h"
+
+/**
+ * \brief 31x16 Bit multiply (x*y)
+ *
+ * \param[i] xh high part, bit [30..15]
+ * \param[i] xl low part, 15 LSBits
+ * \param[i] y
+ *
+ * \return x*y
+ */
+Word32 L_multi31x16_X2(Word16 xh, Word16 xl, Word16 y)
+{
+ Word32 z;
+
+ z = L_shl(L_mult0(xh,y),15);
+ z = L_mac0(z,xl,y);
+
+ return z;
+}
+
+/*---------------------------------------------------------------
+ Ari 14 bits common routines
+ -------------------------------------------------------------*/
+
+/**
+ * \brief Integer Multiply
+ *
+ * \param[i] r
+ * \param[i] c
+ *
+ * \return r*c
+ */
+Word32 mul_sbc_14bits(Word32 r, Word16 c)
+{
+ Word32 ret;
+
+
+ /*
+ temp = (((int32) r)*((int32) c))>>stat_bitsnew;
+ */
+ assert(stat_bitsnew == 14);
+ ret = Mpy_32_16_1(L_shl(r,15-stat_bitsnew), c);
+
+ /*assert( (((int) r)*((int) c))>>stat_bitsnew == ret);*/
+
+ return (ret);
+}
diff --git a/lib_com/ari_hm.c b/lib_com/ari_hm.c
new file mode 100644
index 0000000000000000000000000000000000000000..80f2d70c6e5c064a5f978777fddb94442720eeae
--- /dev/null
+++ b/lib_com/ari_hm.c
@@ -0,0 +1,292 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+
+#include
+#include
+#include
+#include
+#include "stl.h"
+#include "cnst_fx.h"
+#include "basop_util.h"
+#include "rom_com_fx.h"
+#include "prot_fx.h"
+
+void UnmapIndex(
+ Word16 PeriodicityIndex,
+ Word16 Bandwidth,
+ Word16 LtpPitchLag,
+ Word8 SmallerLags,
+ Word16 *FractionalResolution,
+ Word32 *Lag)
+{
+ Word16 LtpPitchIndex, Multiplier;
+ Word16 Lag16;
+
+ test();
+ IF ((LtpPitchLag > 0) && (s_and(PeriodicityIndex, kLtpHmFlag) != 0))
+ {
+ LtpPitchIndex = shr(PeriodicityIndex, 9);
+ Multiplier = s_and(PeriodicityIndex, 0xff);
+
+ assert(0 <= LtpPitchIndex && LtpPitchIndex <= 16);
+ assert(1 <= Multiplier && Multiplier <= (1 << NumRatioBits[Bandwidth][LtpPitchIndex]));
+
+ *FractionalResolution = kLtpHmFractionalResolution;
+ move16();
+ *Lag = L_shr(L_mult0(LtpPitchLag, Ratios[Bandwidth][LtpPitchIndex][Multiplier-1]), 8);
+ move32();
+ }
+ ELSE
+ {
+ IF (LT_16(PeriodicityIndex, 16))
+ {
+ *FractionalResolution = 3;
+ move16();
+ Lag16 = add(PeriodicityIndex, GET_ADJ2(0, 6, 3));
+ }
+ ELSE IF (LT_16(PeriodicityIndex, 80))
+ {
+ *FractionalResolution = 4;
+ move16();
+ Lag16 = add(PeriodicityIndex, GET_ADJ2(16, 8, 4));
+ }
+ ELSE IF (LT_16(PeriodicityIndex, 208))
+ {
+ *FractionalResolution = 3;
+ move16();
+ Lag16 = add(PeriodicityIndex, GET_ADJ2(80, 12, 3));
+ }
+ ELSE {
+ test();
+ IF (LT_16(PeriodicityIndex, 224)||SmallerLags!=0)
+ {
+ *FractionalResolution = 1;
+ move16();
+ Lag16 = add(PeriodicityIndex, GET_ADJ2(208, 28, 1));
+ }
+ ELSE {
+ *FractionalResolution = 0;
+ move16();
+ Lag16 = add(PeriodicityIndex, GET_ADJ2(224, 188, 0));
+ }
+ }
+ *Lag = L_deposit_l(Lag16);
+ }
+}
+
+
+void ConfigureContextHm(
+ Word16 NumCoeffs, /* (I) Number of coefficients */
+ Word16 TargetBits, /* (I) Target bit budget (excl. Done flag) */
+ Word16 PeriodicityIndex, /* (I) Pitch related index */
+ Word16 LtpPitchLag, /* (I) TCX-LTP pitch in F.D. */
+ CONTEXT_HM_CONFIG *hm_cfg /* (O) Context-based harmonic model configuration */
+)
+{
+ Word8 Bandwidth, SmallerLags;
+ Word32 i, Limit, Lag;
+ Word16 j, Index, FractionalResolution;
+ Word16 *tmp;
+
+
+ Bandwidth = 0;
+ move16();
+ if (GE_16(NumCoeffs, 256))
+ {
+ Bandwidth = 1;
+ move16();
+ }
+
+ SmallerLags = 0;
+ move16();
+ test();
+ if ((LE_16(TargetBits, kSmallerLagsTargetBitsThreshold))||(Bandwidth==0))
+ {
+ SmallerLags = 1;
+ move16();
+ }
+
+ UnmapIndex(PeriodicityIndex,
+ Bandwidth,
+ LtpPitchLag,
+ SmallerLags,
+ &FractionalResolution, &Lag);
+
+ /* Set up and fill peakIndices */
+ hm_cfg->peakIndices = hm_cfg->indexBuffer;
+ tmp = hm_cfg->peakIndices;
+ Limit = L_shl(L_deposit_l(sub(NumCoeffs, 1)), FractionalResolution);
+ IF (LT_32(Lag, Limit))
+ {
+ FOR (i=Lag; inumPeakIndices = (Word16)(tmp - hm_cfg->indexBuffer);
+
+ /* Set up and fill holeIndices */
+ hm_cfg->holeIndices = hm_cfg->indexBuffer + hm_cfg->numPeakIndices;
+ tmp = hm_cfg->holeIndices;
+ Index = 0;
+ move16();
+ IF (hm_cfg->numPeakIndices > 0)
+ {
+ FOR (j=0; jnumPeakIndices; j+=3)
+ {
+ FOR (; IndexpeakIndices[j]; ++Index)
+ {
+ *tmp++ = Index;
+ move16();
+ }
+ Index = add(Index, 3); /* Skip the peak */
+ }
+ }
+ IF (LT_16(Index, NumCoeffs))
+ {
+ FOR (; IndexnumHoleIndices = (Word16)(tmp - hm_cfg->holeIndices);
+ *tmp++ = NumCoeffs;
+ move16(); /* Add extremal element signaling the end of the buffer */
+
+}
+
+Word16 CountIndexBits(
+ Word16 Bandwidth,
+ Word16 PeriodicityIndex)
+{
+ Word16 result;
+ Word16 PeriodicityIndexS;
+
+ result = 8;
+ move16();
+ PeriodicityIndexS = shr(PeriodicityIndex, 9);
+
+ if (s_and(PeriodicityIndex, kLtpHmFlag) != 0)
+ {
+ result = NumRatioBits[Bandwidth][PeriodicityIndexS];
+ move16();
+ }
+
+ return result;
+}
+
+
+
+int tcx_hm_render(
+ Word32 lag, /* i: pitch lag Q0 */
+ Word16 fract_res, /* i: fractional resolution of the lag Q0 */
+ Word16 p[] /* o: harmonic model Q13 */
+)
+{
+ Word16 k, tmp, height;
+ Word16 PeakDeviation;
+ Word32 f0, tmp32;
+
+ /* Set up overall shape */
+ f0 = L_shl(lag, sub(15, fract_res)); /* Q31 */
+
+ tmp32 = Mpy_32_16_1(f0, -26474);
+ tmp32 = L_shr_r(BASOP_Util_InvLog2(L_shl(tmp32, 7)), 2);
+ tmp32 = L_sub(603979776L, tmp32);
+ tmp32 = L_add(L_add(tmp32, tmp32), Mpy_32_16_1(tmp32, 26214));
+ height = round_fx(tmp32); /* Q13 */
+
+ tmp32 = Mpy_32_16_1(f0, -18910);
+ tmp32 = L_shr_r(BASOP_Util_InvLog2(L_shl(tmp32, 7)), 2);
+ tmp32 = L_sub(1395864371L, tmp32);
+ PeakDeviation = round_fx(tmp32); /* Q14 */
+
+ IF( GT_16(13915,PeakDeviation))
+ {
+ /* A bit error was encountered */
+ return 1;
+ }
+ ELSE
+ {
+ tmp = div_s(13915, PeakDeviation);
+ tmp = mult_r(tmp, tmp); /* Q15 */
+ }
+
+ tmp = div_s(13915, PeakDeviation);
+ tmp = mult_r(tmp, tmp); /* Q15 */
+
+ /* Render the prototype peak */
+ p[kTcxHmParabolaHalfWidth] = height;
+ move16();
+
+ FOR (k=1; k<=kTcxHmParabolaHalfWidth; ++k)
+ {
+ p[kTcxHmParabolaHalfWidth+k] = round_fx(Mpy_32_16_1(BASOP_Util_InvLog2(L_shl(L_mult0(i_mult2(negate(k),k), tmp),10)), height));
+ }
+ /* Mirror */
+ FOR (k=-kTcxHmParabolaHalfWidth; k<0; ++k)
+ {
+ p[kTcxHmParabolaHalfWidth+k] = p[kTcxHmParabolaHalfWidth-k];
+ move16();
+ }
+
+ return 0;
+}
+
+void tcx_hm_modify_envelope(
+ Word16 gain, /* i: HM gain Q11 */
+ Word32 lag, /* i: pitch lag Q0 */
+ Word16 fract_res, /* i: fractional resolution of the lag Q0 */
+ Word16 p[], /* i: harmonic model Q13 */
+ Word32 env[], /* i/o: envelope Q16 */
+ Word16 L_frame /* i: number of spectral lines Q0 */
+)
+{
+ Word16 k, h, x, l1,l2, L_frame_m1, L_frame_for_loop;
+ Word16 inv_shape[2*kTcxHmParabolaHalfWidth+1];
+
+ IF ( gain == 0 )
+ {
+ return;
+ }
+
+ FOR (k=0; k<2*kTcxHmParabolaHalfWidth+1; ++k)
+ {
+ /* Q24 = Q11 * Q13; 512 = 1.0 in Q24 format */
+ inv_shape[k] = div_s(512, add(512, mult_r(gain, p[k])));
+ move16();
+ }
+
+ h = 1;
+ move16();
+ k = extract_l(L_shr(lag,fract_res));
+
+ L_frame_m1 = sub(L_frame,1);
+ L_frame_for_loop = add(L_frame,kTcxHmParabolaHalfWidth - 1);
+
+ WHILE ( LE_16(k,L_frame_for_loop))
+ {
+ l1 = s_max(0, sub(k,kTcxHmParabolaHalfWidth));
+ l2 = s_min(add(k,kTcxHmParabolaHalfWidth), L_frame_m1);
+ FOR (x=l1; x<=l2; ++x)
+ {
+ env[x] = Mpy_32_16_1(env[x], inv_shape[x-k+kTcxHmParabolaHalfWidth]);
+ move32();
+ }
+
+ h = add(h,1);
+ k = extract_l(L_shr(imult3216(lag,h),fract_res));
+ }
+
+}
+
+
diff --git a/lib_com/arith_coder.c b/lib_com/arith_coder.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c4739da2df8628997f6dbcbe92eeec2c2dae82a
--- /dev/null
+++ b/lib_com/arith_coder.c
@@ -0,0 +1,471 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include
+#include
+#include
+
+#include "prot_fx.h"
+#include "basop_util.h"
+#include "options.h"
+#include "cnst_fx.h"
+#include "stl.h"
+
+/* Fixed point implementation of exp(negate()) */
+Word32 expfp( /* o: Q31 */
+ Word16 x, /* i: mantissa Q-e */
+ Word16 x_e) /* i: exponent Q0 */
+{
+ Word16 xi, xf, tmp;
+ Word16 b0, b1, b2, b3;
+ Word32 y, L_tmp;
+
+
+ assert(x > 0);
+
+ L_tmp = L_shl(L_deposit_h(x), x_e);
+
+ /* split into integer and fractional parts */
+ xi = round_fx(L_tmp);
+ xf = extract_l(L_tmp);
+
+ BASOP_SATURATE_WARNING_OFF;
+ xf = negate(xf);
+ BASOP_SATURATE_WARNING_ON;
+
+ /* Fractional part */
+ /* y = 65536
+ + xf
+ + ((xf*xf) / (2*65536))
+ + ((((((xf*xf) / (2*65536))*xf) / 65536)*65536/3) / 65536)
+ + ((((((((xf*xf) / (2*65536))*xf) / 65536)*65536/3) / 65536)*xf) / (4*65536)); */
+ y = L_mac0(65536, xf, 1);
+ tmp = shr(mult(xf, xf), 2);
+ y = L_mac0(y, tmp, 1);
+ tmp = shr(mult(shr(mult(tmp, xf), 1), 65536/3), 1);
+ y = L_mac0(y, tmp, 1);
+ tmp = shr(mult(tmp, xf), 3);
+ y = L_mac0(y, tmp, 1);
+
+ /* Integer part */
+ b0 = s_and(xi, 1);
+ b1 = s_and(xi, 2);
+ b2 = s_and(xi, 4);
+ b3 = s_and(xi, 8);
+
+ if (b0 != 0) y = Mpy_32_16_1(y, 24109); /* exp(-1) in -1Q16 */
+ if (b1 != 0) y = Mpy_32_16_1(y, 17739); /* exp(-2) in -2Q17 */
+ if (b2 != 0) y = Mpy_32_16_1(y, 19205); /* exp(-4) in -5Q20 */
+ if (b3 != 0) y = Mpy_32_16_1(y, 22513); /* exp(-8) in -11Q26 */
+
+ /* scaling: -1*b0 - 2*b1 -5*b2 -11*b3 */
+ y = L_shr(y, add(add(xi, shr(xi, 2)), shr(b3, 3)));
+
+ /* zero for xi >= 16 */
+ if (shr(xi, 4) > 0)
+ {
+ y = L_deposit_l(0);
+ }
+
+
+ return L_shl(y, 15);
+}
+
+/* Fixed point implementation of pow(), where base is fixed point (16/16) and exponent a small *odd* integer
+ *
+ * Returns: *pout1 = ( (base/65536)^(2*exp - 1) ) * 65536
+ * *pout2 = ( (base/65536)^(2*exp + 1) ) * 65536
+ *
+ * NOTE: This function must be in sync with ari_decode_14bits_pow() */
+void powfp_odd2(Word16 base, /* Q15 */
+ Word16 exp, /* Q0 */
+ Word16 *pout1, /* Q15 */
+ Word16 *pout2) /* Q15 */
+{
+ /* this version is in sync with ari_enc_14bits_pow()
+ * that is, we have to start multiplication from the largest power-of-two, in order to
+ * get the rounding errors to appear at the same places */
+ Word16 pows[12]; /* powers of two exponents*/
+ Word16 exp2;
+ Word16 out, out2;
+ Word16 k, h, maxk;
+
+ assert(exp >= 0);
+
+ out = base;
+ move16();
+ out2 = 0x7FFF;
+ move16();
+ IF (exp != 0)
+ {
+ exp2 = sub(exp, 1);
+ maxk = sub(15, norm_s(exp));
+ assert(maxk < 12);
+
+ pows[0] = base;
+ move16();
+ FOR (k = 0; k < maxk; k++)
+ {
+ pows[k+1] = mult_r(pows[k], pows[k]);
+ move16();
+ }
+ k = sub(k, 1);
+ h = shl(1, k); /* highest bit of exp2 */
+ out2 = base;
+ move16();
+ out = mult_r(out, pows[k+1]); /* we already know that "exp" has the highest bit set to one since we calculated .. */
+ /* .. the effective length of "exp" earlier on, thus we omit the branch for out2 */
+ if (s_and(exp2, h) != 0)
+ {
+ out2 = mult_r(out2, pows[k+1]);
+ }
+
+ h = shr(h, 1);
+ FOR (k = sub(k, 1); k >= 0; k--)
+ {
+ if (s_and(exp, h) != 0)
+ {
+ out = mult_r(out, pows[k+1]);
+ }
+
+ if (s_and(exp2, h) != 0)
+ {
+ out2 = mult_r(out2, pows[k+1]);
+ }
+
+ h = shr(h, 1);
+ }
+ }
+
+ *pout1 = out2;
+ move16();
+ *pout2 = out;
+ move16();
+
+}
+
+/*------------------------------------------------------------------------
+ * Function: tcx_arith_scale_envelope
+ *
+ * For optimal performance of the arithmetic coder, the envelope shape must
+ * be scaled such that the expected bit-consumption of a signal that
+ * follows the scaled shape coincides with the target bitrate.
+ * This function calculates a first-guess scaling and then uses the bi-section
+ * search to find the optimal scaling.
+ *
+ * We assume that lines follow the Laplacian distribution, whereby the expected
+ * bit-consumption would be log2(2*e*s[k]), where s[k] is the envelope value
+ * for the line in question. However, this theoretical formula assumes that
+ * all lines are encoded with magnitude+sign. Since the sign is unnecessary
+ * for 0-values, that estimate of bit-consumption is biased when s[k] is small.
+ * Analytical solution of the expectation for small s[k] is difficult, whereby
+ * we use the approximation log2(2*e*s[k] + 0.15 + 0.035 / s[k]) which is accurate
+ * on the range 0.08 to 1.0.
+ *
+ * NOTE: This function must be bit-exact on all platforms such that encoder
+ * and decoder remain synchronized.
+ *-------------------------------------------------------------------------*/
+void tcx_arith_scale_envelope(
+ Word16 L_spec_core, /* i: number of lines to scale Q0 */
+ Word16 L_frame, /* i: number of lines Q0 */
+ Word32 env[], /* i: unscaled envelope Q16 */
+ Word16 target_bits, /* i: number of available bits Q0 */
+ Word16 low_complexity, /* i: low-complexity flag Q0 */
+ Word16 s_env[], /* o: scaled envelope Q15-e */
+ Word16 *s_env_e /* o: scaled envelope exponent Q0 */
+)
+{
+ Word32 ienv[N_MAX_ARI];
+ Word16 scale, iscale, iscale_e, a_e, b, b_e;
+ Word16 lob, hib, adjust;
+ Word16 k, iter, max_iter, lob_bits, hib_bits;
+ Word16 statesi, bits;
+ Word32 mean, a, s, L_tmp;
+ Word16 mean_e, tmp, tmp2;
+
+
+
+ lob_bits = 0;
+ move16();
+ hib_bits = 0;
+ move16();
+
+ /* Boosting to account for expected spectrum truncation (kMax) */
+ /* target_bits = (int)(target_bits * (1.2f - 0.00045f * target_bits + 0.00000025f * target_bits * target_bits)); */
+ L_tmp = L_shr(Mpy_32_16_1(L_mult0(target_bits, target_bits), 17180), 6); /* Q15; 17180 -> 0.00000025f (Q36) */
+ L_tmp = L_sub(L_tmp, L_shr(L_mult0(target_bits, 30199), 11)); /* Q15; 30199 -> 0.00045f (Q26) */
+ L_tmp = L_add(L_tmp, 39322); /* Q15; 39322 -> 1.2f (Q15) */
+ L_tmp = Mpy_32_16_1(L_tmp, target_bits); /* Q0 */
+ assert(L_tmp < 32768);
+ target_bits = extract_l(L_tmp);
+
+ /* Calculate inverse envelope and find initial scale guess based on mean */
+ mean = L_deposit_l(0);
+ FOR (k = 0; k < L_frame; k++)
+ {
+ /* ienv[k] = 1.0f / env[k];
+ mean += ienv[k]; */
+
+ tmp = norm_l(env[k]);
+ tmp2 = sub(15, tmp);
+ tmp = Inv16(round_fx(L_shl(env[k], tmp)), &tmp2);
+ ienv[k] = L_shl(L_deposit_h(tmp), sub(tmp2, 15)); /* Q16 */ move32();
+ mean = L_add(mean, ienv[k]);
+ }
+ tmp = norm_s(L_frame);
+ tmp = shl(div_s(8192, shl(L_frame, tmp)), sub(tmp, 7));
+ mean = L_shr(Mpy_32_16_1(mean, tmp), 6); /* Q16 */
+
+ /* Rate dependent compensation to get closer to the target on average */
+ /* mean = (float)pow(mean, (float)L_frame / (float)target_bits * 0.357f); */
+ tmp = BASOP_Util_Divide1616_Scale(L_frame, target_bits, &tmp2);
+ tmp = mult_r(tmp, 11698/*0.357f Q15*/);
+ mean = BASOP_Util_fPow(mean, 15, L_deposit_h(tmp), tmp2, &mean_e);
+
+ /* Find first-guess scaling coefficient "scale" such that if "mean" is the
+ * mean of the envelope, then the mean bit-consumption is approximately
+ *
+ * log2(2*e*mean*scale + 0.15 + 0.035/(mean*scale)) * L_frame = target_bits
+ */
+ /* a = 2*2.71828183f*mean*mean; */
+ tmp = round_fx(mean);
+ a = L_mult(mult_r(tmp, 22268/*2.71828183f Q13*/), tmp);
+ a_e = add(shl(mean_e, 1), 3);
+
+ /* b = (0.15f - (float)pow(2.0f, target_bits/(float)L_frame)) * mean; */
+ tmp = BASOP_Util_Divide1616_Scale(target_bits, L_frame, &tmp2);
+ tmp = round_fx(BASOP_util_Pow2(L_deposit_h(tmp), tmp2, &tmp2));
+ b_e = BASOP_Util_Add_MantExp(4915/*0.15f Q15*/, 0, negate(tmp), tmp2, &b);
+ b = mult_r(b, round_fx(mean));
+ b_e = add(b_e, mean_e);
+
+ /* scale = (-b + (float)sqrt(b*b - 4.0f*a*0.035f)) / (2.0f * a); */
+ tmp = round_fx(BASOP_Util_Add_Mant32Exp(L_mult(b, b), shl(b_e, 1), Mpy_32_16_1(a, -4588/*-4.0f*0.035f Q15*/), a_e, &tmp2));
+
+ IF( tmp <= 0 )
+ {
+ tmp = 0;
+ set16_fx(s_env, 0, L_frame);
+ }
+ ELSE
+ {
+ tmp = Sqrt16(tmp, &tmp2);
+ }
+
+ tmp2 = BASOP_Util_Add_MantExp(negate(b), b_e, tmp, tmp2, &scale);
+ scale = BASOP_Util_Divide1616_Scale(scale, round_fx(a), &tmp);
+ scale = shl(scale, sub(sub(add(tmp, tmp2), a_e), 1)); /* Q15 */
+
+ /* iscale = 1.0f / scale; */
+ iscale_e = 0;
+ move16();
+ iscale = Inv16(s_max(1, scale), &iscale_e);
+
+ lob = 0;
+ move16();
+ hib = 0;
+ move16();
+
+ max_iter = 2;
+ move16();
+ if(low_complexity)
+ {
+ max_iter = 1;
+ move16();
+ }
+
+ FOR (iter = 0; iter < max_iter; iter++)
+ {
+ statesi = 0x7FFF;
+ move16();
+ bits = 0;
+ move16();
+
+ FOR (k = 0; k < L_frame; k++)
+ {
+ s = Mpy_32_16_1(ienv[k], scale); /* Q16 */
+
+ IF (LE_32(s, 5243l/*0.08f Q16*/))
+ {
+ /* If s = 0.08, the expected bit-consumption is log2(1.0224). Below 0.08, the bit-consumption
+ estimate function becomes inaccurate, so use log2(1.0224) for all values below 0.08. */
+ /* round(state * 1.0224 * 32768) */
+ statesi = mult_r(statesi, 16751/*1.0224 Q14*/);
+ tmp = norm_s(statesi);
+ statesi = shl(statesi, tmp);
+ bits = add(bits, sub(1, tmp));
+ }
+ ELSE IF (LE_32(s, 16711680l/*255.0 Q16*/))
+ {
+ /* a = 5.436564f * s + 0.15f + 0.035f * env[k] * iscale; */
+ L_tmp = L_shl(Mpy_32_16_1(s, 22268/*5.436564f Q12*/), 3);
+ L_tmp = L_add(L_tmp, 9830l/*0.15f Q16*/);
+ L_tmp = L_add(L_tmp, L_shl(Mpy_32_16_1(env[k], mult_r(1147/*0.035f Q15*/, iscale)), iscale_e));
+
+ tmp = norm_l(L_tmp);
+ statesi = mult_r(statesi, round_fx(L_shl(L_tmp, tmp)));
+ bits = add(bits, sub(15, tmp));
+
+ tmp = norm_s(statesi);
+ statesi = shl(statesi, tmp);
+ bits = sub(bits, tmp);
+ }
+ ELSE
+ {
+ /* for large envelope values, s > 255, bit consumption is approx log2(2*e*s)
+ * further, we use round(log2(x)) = floor(log2(x)+0.5) = floor(log2(x*sqrt(2))) */
+ /* a = 5.436564f * s; */
+ L_tmp = Mpy_32_16_1(s, 31492/*5.436564f * 1.4142f Q12*/); /* Q13 */
+ bits = add(bits, sub(17, norm_l(L_tmp)));
+ }
+ }
+
+ IF (LE_16(bits, target_bits)) /* Bits leftover => scale is too small */
+ {
+ lob = scale;
+ move16();
+ lob_bits = bits;
+ move16();
+
+ IF (hib > 0) /* Bisection search */
+ {
+ adjust = div_s(sub(hib_bits, target_bits), sub(hib_bits, lob_bits));
+ scale = add(mult_r(sub(lob, hib), adjust), hib);
+ }
+ ELSE /* Initial scale adaptation */
+ {
+ /* adjust = 1.05f * target_bits / (float)bits;
+ scale *= adjust; */
+ adjust = mult_r(17203/*1.05f Q14*/, target_bits);
+ adjust = BASOP_Util_Divide1616_Scale(adjust, bits, &tmp);
+ scale = shl(mult_r(scale, adjust), add(1, tmp));
+ }
+ }
+ ELSE /* Ran out of bits => scale is too large */
+ {
+ hib = scale;
+ move16();
+ hib_bits = bits;
+ move16();
+
+ IF (lob > 0) /* Bisection search */
+ {
+ adjust = div_s(sub(hib_bits, target_bits), sub(hib_bits, lob_bits));
+ scale = add(mult_r(sub(lob, hib), adjust), hib);
+ }
+ ELSE { /* Initial scale adaptation */
+ test();
+ IF( target_bits <= 0 || bits <= 0 ) /* safety check in case of bit errors */
+ {
+ adjust = 0;
+ move16();
+ set16_fx( s_env, 0, L_frame );
+ }
+ ELSE
+ {
+ adjust = div_s(mult_r(31130/*0.95f Q15*/, target_bits), bits);
+ }
+ scale = mult_r(scale, adjust);
+ }
+ }
+ iscale_e = 0;
+ move16();
+
+ IF( scale == 0 ) /* safety check in case of bit errors */
+ {
+ iscale = 0;
+ move16();
+ set16_fx( s_env, 0, L_frame );
+ }
+ ELSE
+ {
+ iscale = Inv16(scale, &iscale_e);
+ }
+ }
+ L_frame = L_spec_core;
+ move16();
+
+ tmp = getScaleFactor32(env, L_frame);
+ *s_env_e = sub(add(15, iscale_e), tmp);
+ move16();
+ BASOP_SATURATE_WARNING_OFF;
+ a = L_shl(1265000, sub(15, *s_env_e));
+ BASOP_SATURATE_WARNING_ON;
+
+ FOR (k = 0; k < L_frame; k++)
+ {
+ L_tmp = Mpy_32_16_1(L_shl(env[k], tmp), iscale);
+ L_tmp = L_min(L_tmp, a);
+ s_env[k] = round_fx(L_tmp);
+ }
+
+}
+
+/*------------------------------------------------------------------------
+ * Function: tcx_arith_render_envelope
+ *
+ * Calculate the envelope of the spectrum based on the LPC shape. The
+ * envelope is used in a perceptual domain, whereby the LPC shape has to
+ * be multiplied by the perceptual model.
+ * Operations that are performed on the spectrum, which change the magnitude
+ * expectation of lines, such as low-frequency emphasis, are included in the
+ * envelope shape.
+ * NOTE: This function must be bit-exact on all platforms such that encoder
+ * and decoder remain synchronized.
+ *-------------------------------------------------------------------------*/
+void tcx_arith_render_envelope(
+ const Word16 A_ind[], /* i: LPC coefficients of signal envelope */
+ Word16 L_frame, /* i: number of spectral lines */
+ Word16 L_spec,
+ Word16 preemph_fac, /* i: pre-emphasis factor */
+ Word16 gamma_w, /* i: A_ind -> weighted envelope factor */
+ Word16 gamma_uw, /* i: A_ind -> non-weighted envelope factor */
+ Word32 env[] /* o: shaped signal envelope */
+)
+{
+ Word16 k;
+ Word16 tmpA[M+2];
+ Word16 signal_env[FDNS_NPTS], signal_env_e[FDNS_NPTS];
+ Word16 gainlpc[FDNS_NPTS], gainlpc_e[FDNS_NPTS];
+
+
+
+ /* Compute perceptual LPC envelope, transform it into freq.-domain gains */
+ weight_a_fx( A_ind, tmpA, gamma_w, M );
+ lpc2mdct( tmpA, M, NULL, NULL, gainlpc, gainlpc_e );
+
+ /* Add pre-emphasis tilt to LPC envelope, transform LPC into MDCT gains */
+ E_LPC_a_weight_inv(A_ind, signal_env, gamma_uw, M);
+ E_LPC_a_add_tilt(signal_env, tmpA, preemph_fac, M);
+ lpc2mdct(tmpA, M+1, signal_env, signal_env_e, NULL, NULL);
+
+ /* Compute weighted signal envelope in perceptual domain */
+ FOR (k = 0; k < FDNS_NPTS; k++)
+ {
+ signal_env[k] = mult_r(signal_env[k], gainlpc[k]);
+ move16();
+ signal_env_e[k] = add(signal_env_e[k], gainlpc_e[k]);
+ move16();
+ }
+
+ /* Adaptive low frequency emphasis */
+ set32_fx(env, 0x10000, L_frame);
+
+ AdaptLowFreqDeemph(env, 15,
+ 1,
+ gainlpc, gainlpc_e,
+ L_frame, NULL);
+
+ /* Scale from FDNS_NPTS to L_frame and multiply LFE gains */
+ mdct_noiseShaping_interp(env, L_frame, signal_env, signal_env_e);
+
+ FOR (k=L_frame; k
+#include
+
+#include "stl.h"
+
+#define DOT12_SUBDIV_LD 2 /* log2(number of dot product sub divisions) */
+
+#define HP20_COEF_SCALE 2
+#define INV_BANDS10 3277 /* 1/10 in Q15 */
+#define INV_BANDS9 3641 /* 1/9 in Q15 */
+
+extern const Word32 SqrtTable[32];
+extern const Word16 SqrtDiffTable[32];
+
+extern const Word32 ISqrtTable[32];
+extern const Word16 ISqrtDiffTable[32];
+
+extern const Word32 InvTable[32];
+extern const Word16 InvDiffTable[32];
+
+
+Word32 BASOP_Util_Log2(Word32 x)
+{
+ Word32 exp;
+ Word16 exp_e;
+ Word16 nIn;
+ Word16 accuSqr;
+ Word32 accuRes;
+
+
+
+ assert(x >= 0);
+
+ if (x == 0)
+ {
+
+ return ((Word32)MIN_32);
+ }
+
+ /* normalize input, calculate integer part */
+ exp_e = norm_l(x);
+ x = L_shl(x,exp_e);
+ exp = L_deposit_l(exp_e);
+
+ /* calculate (1-normalized_input) */
+ nIn = extract_h(L_sub(MAX_32,x));
+
+ /* approximate ln() for fractional part (nIn *c0 + nIn^2*c1 + nIn^3*c2 + ... + nIn^8 *c7) */
+
+ /* iteration 1, no need for accumulation */
+ accuRes = L_mult(nIn,ldCoeff[0]); /* nIn^i * coeff[0] */
+ accuSqr = mult(nIn,nIn); /* nIn^2, nIn^3 .... */
+
+ /* iteration 2 */
+ accuRes = L_mac(accuRes,accuSqr,ldCoeff[1]); /* nIn^i * coeff[1] */
+ accuSqr = mult(accuSqr,nIn); /* nIn^2, nIn^3 .... */
+
+ /* iteration 3 */
+ accuRes = L_mac(accuRes,accuSqr,ldCoeff[2]); /* nIn^i * coeff[2] */
+ accuSqr = mult(accuSqr,nIn); /* nIn^2, nIn^3 .... */
+
+ /* iteration 4 */
+ accuRes = L_mac(accuRes,accuSqr,ldCoeff[3]); /* nIn^i * coeff[3] */
+ accuSqr = mult(accuSqr,nIn); /* nIn^2, nIn^3 .... */
+
+ /* iteration 5 */
+ accuRes = L_mac(accuRes,accuSqr,ldCoeff[4]); /* nIn^i * coeff[4] */
+ accuSqr = mult(accuSqr,nIn); /* nIn^2, nIn^3 .... */
+
+ /* iteration 6 */
+ accuRes = L_mac(accuRes,accuSqr,ldCoeff[5]); /* nIn^i * coeff[5] */
+ accuSqr = mult(accuSqr,nIn); /* nIn^2, nIn^3 .... */
+
+ /* iteration 7, no need to calculate accuSqr any more */
+ accuRes = L_mac(accuRes,accuSqr,ldCoeff[6]); /* nIn^i * coeff[6] */
+
+ /* ld(fractional part) = ln(fractional part)/ln(2), 1/ln(2) = (1 + 0.44269504) */
+ accuRes = L_mac0(L_shr(accuRes,1),extract_h(accuRes),14506);
+
+ accuRes = L_shr(accuRes,LD_DATA_SCALE-1); /* fractional part/LD_DATA_SCALE */
+ exp = L_shl(exp,(31-LD_DATA_SCALE)); /* integer part/LD_DATA_SCALE */
+ accuRes = L_sub(accuRes,exp); /* result = integer part + fractional part */
+
+
+ return (accuRes);
+}
+
+Word32 BASOP_Util_InvLog2(Word32 x)
+{
+ Word16 frac;
+ Word16 exp;
+ Word32 retVal;
+ UWord32 index3;
+ UWord32 index2;
+ UWord32 index1;
+ UWord32 lookup3f;
+ UWord32 lookup12;
+ UWord32 lookup;
+
+
+
+ if ( x < -1040187392l/*-31.0/64.0 Q31*/ )
+ {
+
+ return 0;
+ }
+ test();
+ if ( (GE_32(x,1040187392l/*31.0/64.0 Q31*/))||(x==0))
+ {
+
+ return 0x7FFFFFFF;
+ }
+
+ frac = extract_l(L_and(x,0x3FF));
+
+ index3 = L_and(L_shr(x,10),0x1F);
+ index2 = L_and(L_shr(x,15),0x1F);
+ index1 = L_and(L_shr(x,20),0x1F);
+
+ exp = extract_l(L_shr(x,25));
+ if ( x > 0 )
+ {
+ exp = sub(31,exp);
+ }
+ if ( x < 0 )
+ {
+ exp = negate(exp);
+ }
+
+ lookup3f = L_add(exp2x_tab_long[index3],L_shr(Mpy_32_16_1(0x0016302F,frac),1));
+ lookup12 = Mpy_32_32(exp2_tab_long[index1],exp2w_tab_long[index2]);
+ lookup = Mpy_32_32(lookup12, lookup3f);
+
+ retVal = L_shr(lookup,sub(exp,3));
+
+
+ return retVal;
+}
+
+
+Word16 BASOP_Util_Add_MantExp /*!< Exponent of result */
+(Word16 a_m, /*!< Mantissa of 1st operand a */
+ Word16 a_e, /*!< Exponent of 1st operand a */
+ Word16 b_m, /*!< Mantissa of 2nd operand b */
+ Word16 b_e, /*!< Exponent of 2nd operand b */
+ Word16 *ptrSum_m) /*!< Mantissa of result */
+{
+ Word32 L_lm, L_hm;
+ Word16 shift;
+
+
+
+ /* Compare exponents: the difference is limited to +/- 15
+ The Word16 mantissa of the operand with higher exponent is moved into the low
+ part of a Word32 and shifted left by the exponent difference. Then, the
+ unshifted mantissa of the operand with the lower exponent is added to the lower
+ 16 bits. The addition result is normalized and the upper Word16 of the result represents
+ the mantissa to return. The returned exponent takes into account all shift operations
+ including the final 16-bit extraction.
+ Note: The resulting mantissa may be inaccurate in the case, where the mantissa of the operand
+ with higher exponent is not really left-aligned, while the mantissa of the operand with
+ lower exponent is so. If in such a case, the difference in exponents is more than 15,
+ an inaccuracy is introduced.
+ Example:
+ A: a_e = 20, a_m = 0x0001
+ B: b_e = 0, b_m = 0x4000
+ correct: A+B=1*2^20+1*2^14=0x0010.0000+0x0000.4000=0x0010.4000=0x4100*2^6
+ previously: A+B=1*2^20+1*2^14=0x0001+0x0000=0x0001*2^20
+ this version: A+B=1*2^20+1*2^14=0x0000.8000+0x0000.4000=0x6000*2^6
+ */
+
+ shift = sub(a_e, b_e);
+ if (shift >= 0)
+ shift = s_min( 15,shift);
+
+ if (shift < 0)
+ shift = s_max(-15,shift);
+ a_e = s_max(a_e,b_e);
+ L_hm = L_deposit_l(a_m); /* mantissa belonging to higher exponent */
+ L_lm = L_deposit_l(a_m); /* mantissa belonging to lower exponent */
+ if (shift >= 0)
+ L_lm = L_deposit_l(b_m);
+ if (shift < 0)
+ L_hm = L_deposit_l(b_m);
+
+ if (shift > 0)
+ shift = negate(shift);
+
+ L_hm = L_shr(L_hm,shift); /* shift left due to negative shift parameter */
+ a_e = add(a_e, shift);
+ L_hm = L_add(L_hm, L_lm);
+ shift = norm_l(L_hm);
+ L_hm = L_shl(L_hm,shift);
+ *ptrSum_m = extract_h(L_hm);
+ move16();
+
+ a_e = sub(a_e,shift);
+ if (L_hm)
+ a_e = add(a_e,16);
+ return (a_e);
+}
+
+
+void BASOP_Util_Divide_MantExp (Word16 a_m, /*!< Mantissa of dividend a */
+ Word16 a_e, /*!< Exponent of dividend a */
+ Word16 b_m, /*!< Mantissa of divisor b */
+ Word16 b_e, /*!< Exponent of divisor b */
+ Word16 *ptrResult_m, /*!< Mantissa of quotient a/b */
+ Word16 *ptrResult_e /*!< Exponent of quotient a/b */
+ )
+{
+ Word16 index, frac;
+ Word16 preShift, postShift;
+ Word16 m;
+ Word32 m32;
+
+
+
+ assert(b_m != 0);
+
+ /* normalize b */
+ preShift = norm_s(b_m);
+ m = shl(b_m, preShift);
+
+ /* make b positive */
+ BASOP_SATURATE_WARNING_OFF;
+ if (m < 0) m = negate(m);
+ BASOP_SATURATE_WARNING_ON;
+
+ /* get table index (upper 6 bits minus 16) */
+ /* index = (m >> 9) - 32; */
+ index = mac_r(-32768 - (32 << 16), m, 1 << 6);
+
+ /* get fractional part for interpolation (lower 9 bits) */
+ frac = shl(s_and(m, 0x1FF), 1); /* Q10 */
+
+ /* interpolate 1/b */
+ m = msu_r(InvTable[index], InvDiffTable[index], frac);
+
+ /* restore sign */
+ if (b_m < 0) m = negate(m);
+
+ /* multiply with a */
+ m32 = L_mult(a_m, m);
+
+ /* normalize result */
+ postShift = norm_l(m32);
+ m = round_fx(L_shl(m32, postShift));
+
+ /* exponent */
+ *ptrResult_e = sub(add(add(a_e, sub(1, b_e)), preShift), postShift);
+ move16();
+
+ *ptrResult_m = m;
+ move16();
+
+}
+
+
+/* local function for Sqrt16 and Sqrt16norm */
+static Word16 Sqrt16_common(Word16 m,
+ Word16 e)
+{
+ Word16 index, frac;
+
+ assert((m >= 0x4000) || (m == 0));
+
+ /* get table index (upper 6 bits minus 32) */
+ /* index = (m >> 9) - 32; */
+ index = mac_r(-32768 - (32 << 16), m, 1 << 6);
+
+ /* get fractional part for interpolation (lower 9 bits) */
+ frac = s_and(m, 0x1FF); /* Q9 */
+
+ /* interpolate */
+ if (m != 0)
+ {
+ BASOP_SATURATE_WARNING_OFF;
+ m = mac_r(SqrtTable[index], SqrtDiffTable[index], frac);
+ BASOP_SATURATE_WARNING_ON;
+ }
+
+ /* handle odd exponents */
+ if (s_and(e, 1) != 0) m = mult_r(m, 0x5a82);
+
+ return m;
+}
+
+/* local function for Sqrt32 and Sqrt32norm */
+static Word32 Sqrt32_common(Word32 m,
+ Word16 e)
+{
+ Word16 m16, index, frac;
+
+ assert((m >= 0x40000000) || (m == 0));
+
+ m16 = round_fx(m);
+
+ /* get table index (upper 6 bits minus 32) */
+ /* index = (m16 >> 9) - 32; */
+ index = mac_r(-32768 - (32 << 16), m16, 1 << 6);
+
+ /* get fractional part for interpolation (lower 9 bits) */
+ frac = s_and(m16, 0x1FF); /* Q9 */
+
+ /* interpolate */
+ if (m != 0)
+ {
+ BASOP_SATURATE_WARNING_OFF;
+ m = L_mac(SqrtTable[index], SqrtDiffTable[index], frac);
+ BASOP_SATURATE_WARNING_ON;
+ }
+
+ /* handle odd exponents */
+ if (s_and(e, 1) != 0) m = Mpy_32_16_1(m, 0x5a82);
+
+ return m;
+}
+
+/* local function for ISqrt16 and ISqrt16norm */
+static Word16 ISqrt16_common(Word16 m,
+ Word16 e)
+{
+ Word16 index, frac;
+
+ assert(m >= 0x4000);
+
+ /* get table index (upper 6 bits minus 32) */
+ /* index = (m >> 9) - 32; */
+ index = mac_r(-32768 - (32 << 16), m, 1 << 6);
+
+ /* get fractional part for interpolation (lower 9 bits) */
+ frac = s_and(m, 0x1FF); /* Q9 */
+
+ /* interpolate */
+ m = msu_r(ISqrtTable[index], ISqrtDiffTable[index], frac);
+
+ /* handle even exponents */
+ if (s_and(e, 1) == 0) m = mult_r(m, 0x5a82);
+
+ return m;
+}
+
+/* local function for ISqrt32 and ISqrt32norm */
+static Word32 ISqrt32_common(Word32 m,
+ Word16 e)
+{
+ Word16 m16, index, frac;
+
+ assert(m >= 0x40000000);
+
+ m16 = round_fx(m);
+
+ /* get table index (upper 6 bits minus 32) */
+ /* index = (m16 >> 25) - 32; */
+ index = mac_r(-32768 - (32 << 16), m16, 1 << 6);
+
+ /* get fractional part for interpolation (lower 9 bits) */
+ frac = s_and(m16, 0x1FF); /* Q9 */
+
+ /* interpolate */
+ m = L_msu(ISqrtTable[index], ISqrtDiffTable[index], frac);
+
+ /* handle even exponents */
+ if (s_and(e, 1) == 0) m = Mpy_32_16_1(m, 0x5a82);
+
+ return m;
+}
+
+
+Word16 Sqrt16( /*!< output mantissa */
+ Word16 mantissa, /*!< input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+)
+{
+ Word16 preShift, e;
+
+ assert(mantissa >= 0);
+
+ /* normalize */
+ preShift = norm_s(mantissa);
+
+ e = sub(*exponent, preShift);
+ mantissa = shl(mantissa, preShift);
+
+ /* calc mantissa */
+ mantissa = Sqrt16_common(mantissa, e);
+
+ /* e = (e + 1) >> 1 */
+ *exponent = mult_r(e, 1 << 14);
+ move16();
+
+ return mantissa;
+}
+
+Word16 Sqrt16norm( /*!< output mantissa */
+ Word16 mantissa, /*!< normalized input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+)
+{
+
+ assert((mantissa >= 0x4000) || (mantissa == 0));
+
+ /* calc mantissa */
+ mantissa = Sqrt16_common(mantissa, *exponent);
+
+ /* e = (e + 1) >> 1 */
+ *exponent = mult_r(*exponent, 1 << 14);
+ move16();
+
+ return mantissa;
+}
+
+
+Word16 ISqrt16( /*!< output mantissa */
+ Word16 mantissa, /*!< input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+)
+{
+ Word16 preShift, e;
+
+ assert(mantissa > 0);
+
+ /* normalize */
+ preShift = norm_s(mantissa);
+
+ e = sub(*exponent, preShift);
+ mantissa = shl(mantissa, preShift);
+
+ /* calc mantissa */
+ mantissa = ISqrt16_common(mantissa, e);
+
+ /* e = (2 - e) >> 1 */
+ *exponent = msu_r(1L << 15, e, 1 << 14);
+ move16();
+
+ return mantissa;
+}
+
+
+Word32 Sqrt32( /*!< output mantissa */
+ Word32 mantissa, /*!< input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+)
+{
+ Word16 preShift, e;
+
+ assert(mantissa >= 0);
+
+ /* normalize */
+ preShift = norm_l(mantissa);
+
+ e = sub(*exponent, preShift);
+ mantissa = L_shl(mantissa, preShift);
+
+ /* calc mantissa */
+ mantissa = Sqrt32_common(mantissa, e);
+
+ /* e = (e + 1) >> 1 */
+ *exponent = mult_r(e, 1 << 14);
+ move16();
+
+ return mantissa;
+}
+
+
+Word32 ISqrt32( /*!< output mantissa */
+ Word32 mantissa, /*!< input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+)
+{
+ Word16 preShift, e;
+
+ assert(mantissa > 0);
+
+ /* normalize */
+ preShift = norm_l(mantissa);
+
+ e = sub(*exponent, preShift);
+ mantissa = L_shl(mantissa, preShift);
+
+ /* calc mantissa */
+ mantissa = ISqrt32_common(mantissa, e);
+
+ /* e = (2 - e) >> 1 */
+ *exponent = msu_r(1L << 15, e, 1 << 14);
+ move16();
+
+ return mantissa;
+}
+
+Word32 ISqrt32norm( /*!< output mantissa */
+ Word32 mantissa, /*!< normalized input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+)
+{
+
+ assert(mantissa >= 0x40000000);
+
+ /* calc mantissa */
+ mantissa = ISqrt32_common(mantissa, *exponent);
+
+ /* e = (2 - e) >> 1 */
+ *exponent = msu_r(1L << 15, *exponent, 1 << 14);
+ move16();
+
+ return mantissa;
+}
+
+
+Word16 Inv16( /*!< output mantissa */
+ Word16 mantissa, /*!< input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+)
+{
+ Word16 index, frac;
+ Word16 preShift;
+ Word16 m, e;
+
+
+
+ assert(mantissa != 0);
+
+ /* absolute */
+ BASOP_SATURATE_WARNING_OFF;
+ m = abs_s(mantissa);
+ BASOP_SATURATE_WARNING_ON;
+
+ /* normalize */
+ preShift = norm_s(m);
+
+ e = sub(*exponent, preShift);
+ m = shl(m, preShift);
+
+ /* get table index (upper 6 bits minus 32) */
+ /* index = (m >> 9) - 32; */
+ index = mac_r(-32768 - (32 << 16), m, 1 << 6);
+
+ /* get fractional part for interpolation (lower 9 bits) */
+ frac = shl(s_and(m, 0x1FF), 1); /* Q10 */
+
+ /* interpolate */
+ m = msu_r(InvTable[index], InvDiffTable[index], frac);
+
+ /* restore sign */
+ if (mantissa < 0) m = negate(m);
+
+ /* e = 1 - e */
+ *exponent = sub(1, e);
+ move16();
+
+ return m;
+}
+
+
+void BASOP_Util_Sqrt_InvSqrt_MantExp (Word16 mantissa, /*!< mantissa */
+ Word16 exponent, /*!< expoinent */
+ Word16 *sqrt_mant, /*!< Pointer to sqrt mantissa */
+ Word16 *sqrt_exp, /*!< Pointer to sqrt exponent */
+ Word16 *isqrt_mant, /*!< Pointer to 1/sqrt mantissa */
+ Word16 *isqrt_exp /*!< Pointer to 1/sqrt exponent */
+ )
+{
+ Word16 index, frac;
+ Word16 preShift;
+ Word16 m, mi, e_odd;
+
+
+
+ assert(mantissa > 0);
+
+ /* normalize */
+ preShift = norm_s(mantissa);
+
+ exponent = sub(exponent, preShift);
+ mantissa = shl(mantissa, preShift);
+
+ /* get table index (upper 6 bits minus 32) */
+ /* index = (m >> 9) - 32; */
+ index = mac_r(-32768 - (32 << 16), mantissa, 1 << 6);
+
+ /* get fractional part for interpolation (lower 9 bits) */
+ frac = s_and(mantissa, 0x1FF); /* Q9 */
+
+ /* interpolate */
+ BASOP_SATURATE_WARNING_OFF;
+ m = mac_r(SqrtTable[index], SqrtDiffTable[index], frac);
+ mi = msu_r(ISqrtTable[index], ISqrtDiffTable[index], frac);
+ BASOP_SATURATE_WARNING_ON;
+
+ /* handle even/odd exponents */
+ e_odd = s_and(exponent, 1);
+ if (e_odd != 0) m = mult_r(m, 0x5a82);
+ if (e_odd == 0) mi = mult_r(mi, 0x5a82);
+
+ /* e = (e + 1) >> 1 */
+ *sqrt_exp = mult_r(exponent, 1 << 14);
+ move16();
+
+ /* e = (2 - e) >> 1 */
+ *isqrt_exp = msu_r(1L << 15, exponent, 1 << 14);
+ move16();
+
+ /* Write result */
+ *sqrt_mant = m;
+ move16();
+ *isqrt_mant = mi;
+ move16();
+
+}
+
+/********************************************************************/
+/*!
+ \brief Calculates the scalefactor needed to normalize input array
+
+ The scalefactor needed to normalize the Word16 input array is returned
+ If the input array contains only '0', a scalefactor 0 is returned
+ Scaling factor is determined wrt a normalized target x: 16384 <= x <= 32767 for positive x
+ and -32768 <= x <= -16384 for negative x
+*/
+
+Word16 getScaleFactor16( /* o: measured headroom in range [0..15], 0 if all x[i] == 0 */
+ const Word16 *x, /* i: array containing 16-bit data */
+ const Word16 len_x) /* i: length of the array to scan */
+{
+ Word16 i, i_min, i_max;
+ Word16 x_min, x_max;
+
+
+
+ x_max = 0;
+ move16();
+ x_min = 0;
+ move16();
+ FOR (i = 0; i < len_x; i++)
+ {
+ if (x[i] >= 0)
+ x_max = s_max(x_max,x[i]);
+ if (x[i] < 0)
+ x_min = s_min(x_min,x[i]);
+ }
+
+ i_max = 0x10;
+ move16();
+ i_min = 0x10;
+ move16();
+
+ if (x_max != 0)
+ i_max = norm_s(x_max);
+
+ if (x_min != 0)
+ i_min = norm_s(x_min);
+
+ i = s_and(s_min(i_max, i_min),0xF);
+
+
+ return i;
+}
+
+
+/********************************************************************/
+/*!
+ \brief Calculates the scalefactor needed to normalize input array
+
+ The scalefactor needed to normalize the Word32 input array is returned
+ If the input array contains only '0', a scalefactor 0 is returned
+ Scaling factor is determined wrt a normalized target x: 1073741824 <= x <= 2147483647 for positive x
+ and -2147483648 <= x <= -1073741824 for negative x
+*/
+
+Word16 getScaleFactor32( /* o: measured headroom in range [0..31], 0 if all x[i] == 0 */
+ const Word32 *x, /* i: array containing 32-bit data */
+ const Word16 len_x) /* i: length of the array to scan */
+{
+ Word16 i, i_min, i_max;
+ Word32 x_min, x_max;
+
+
+
+ x_max = 0; move32();
+ x_min = 0; move32();
+ FOR (i = 0; i < len_x; i++)
+ {
+ if (x[i] >= 0)
+ x_max = L_max(x_max,x[i]);
+ if (x[i] < 0)
+ x_min = L_min(x_min,x[i]);
+ }
+
+ i_max = 0x20;
+ move16();
+ i_min = 0x20;
+ move16();
+
+ if (x_max != 0)
+ i_max = norm_l(x_max);
+
+ if (x_min != 0)
+ i_min = norm_l(x_min);
+
+ i = s_and(s_min(i_max, i_min),0x1F);
+
+
+ return i;
+}
+
+Word16 normalize16(Word16 mantissa, Word16 *pexponent)
+{
+ Word16 tmp;
+
+ tmp = norm_s(mantissa);
+ mantissa = shl(mantissa, tmp);
+ move16();
+ *pexponent = sub(*pexponent, tmp);
+
+
+ return mantissa;
+}
+Word16 divide3216(Word32 x, Word16 y)
+{
+ Word16 z;
+
+
+ z = 0;
+ move16();
+ if (0 == y)
+ {
+ return 0x7fff;
+ }
+
+ IF (x != 0)
+ {
+ Word16 den, sign;
+ Word32 num;
+ num = L_abs(x);
+ den = abs_s(y);
+
+ sign = s_and(s_xor(extract_h(x),y),-32768 /* 0x8000 */);
+
+ z = div_l(num,den);
+ if (0 != sign)
+ {
+ z = negate(z);
+ }
+ }
+
+
+ return z;
+}
+
+Word16 divide1616(Word16 x, Word16 y)
+{
+ Word16 z, num, den, sign;
+
+
+ num = abs_s(x);
+ den = abs_s(y);
+
+ sign = s_and(s_xor(x,y),-32768 /* 0x8000 */);
+
+ move16();
+ z = 0x7fff;
+ if ( LT_16(num, den))
+ z = div_s(num,den);
+
+ if (0 != sign)
+ {
+ z = negate(z);
+ }
+
+
+ return z;
+}
+
+Word16 divide3232(Word32 L_num, Word32 L_denom)
+{
+ Word16 z;
+ Word32 sign;
+
+
+ sign = L_and(L_xor(L_num,L_denom),0x80000000);
+
+ L_num = L_abs(L_num);
+ L_denom = L_abs(L_denom);
+
+ /* limit the range of denominator to Word16 */
+ z = s_min(norm_l(L_num),norm_l(L_denom));
+ L_num = L_shl(L_num,z);
+ L_denom = L_shl(L_denom,z);
+
+ /* round_fx instead of extract_h improves spectral distortion in E_UTIL_lev_dur (schur version). */
+ z = div_l(L_num,round_fx(L_denom));
+ if (0 != sign)
+ {
+ z = negate(z);
+ }
+
+
+ return z;
+}
+
+Word16 BASOP_Util_Divide3232_uu_1616_Scale(Word32 x, Word32 y, Word16 *s)
+{
+ Word16 z;
+ Word16 sx;
+ Word16 sy;
+ Word16 x16;
+ Word16 y16;
+
+
+
+ assert(x >= 0);
+ assert(y > 0);
+
+ if ( x == 0 )
+ {
+ *s = 0;
+ move16();
+
+
+ return (0);
+ }
+
+ sx = norm_l(x);
+ sy = norm_l(y);
+
+ x16 = extract_h(L_shl(x,sx));
+ y16 = extract_h(L_shl(y,sy));
+
+ if(GT_16(x16,y16))
+ {
+ sx = sub(sx,1);
+ }
+
+ if(LT_16(y16,x16))
+ {
+ x16 = mult_r(x16,0x4000);
+ }
+
+
+ z = div_s(x16,y16);
+ move16();
+ *s = sub(sy,sx);
+
+
+ return (z);
+}
+
+Word16 BASOP_Util_Divide3232_Scale(Word32 x, Word32 y, Word16 *s)
+{
+ Word16 z;
+ Word16 sy;
+
+
+
+ sy = norm_l(y);
+ if (sy > 0)
+ {
+ sy = sub(sy,1);
+ }
+ y = L_shl(y,sy);
+
+ z = BASOP_Util_Divide3216_Scale(x, extract_h(y), s);
+ move16();
+ *s = add(*s,sy);
+
+
+ return (z);
+}
+
+Word16 BASOP_Util_Divide3216_Scale( /* o: result of division x/y, not normalized */
+ Word32 x, /* i: numerator, signed */
+ Word16 y, /* i: denominator, signed */
+ Word16 *s) /* o: scaling, 0, if x==0 */
+{
+ Word16 z;
+ Word16 sx;
+ Word16 sy;
+ Word16 sign;
+
+
+
+ /*assert (x > (Word32)0);
+ assert (y >= (Word16)0);*/
+
+ /* check, if numerator equals zero, return zero then */
+ IF ( x == (Word32)0 )
+ {
+ move16();
+ *s = 0;
+
+
+ return ((Word16)0);
+ }
+
+ sign = s_xor(extract_h(x),y); /* just to exor the sign bits */
+ BASOP_SATURATE_WARNING_OFF
+ x = L_abs(x);
+ y = abs_s(y);
+ BASOP_SATURATE_WARNING_ON
+ sx = sub(norm_l(x),1);
+ x = L_shl(x,sx);
+ sy = norm_s(y);
+ y = shl(y,sy);
+ *s = sub(sy,sx);
+ move16();
+
+ z = div_s(round_fx(x),y);
+
+ if ( sign < 0 ) /* if sign bits differ, negate the result */
+ {
+ z = negate(z);
+ }
+
+
+ return z;
+}
+
+Word16 BASOP_Util_Divide1616_Scale(Word16 x, Word16 y, Word16 *s)
+{
+ Word16 z;
+ Word16 sx;
+ Word16 sy;
+ Word16 sign;
+
+
+
+ /* assert (x >= (Word16)0); */
+ assert (y != (Word16)0);
+
+ sign = 0;
+ move16();
+
+ IF ( x < 0 )
+ {
+ x = negate(x);
+ sign = s_xor(sign,1);
+ }
+
+ IF ( y < 0 )
+ {
+ y = negate(y);
+ sign= s_xor(sign,1);
+ }
+
+ IF ( x == (Word16)0 )
+ {
+ move16();
+ *s = 0;
+
+
+ return ((Word16)0);
+ }
+
+ sx = norm_s(x);
+ x = shl(x,sx);
+ x = shr(x,1);
+ move16();
+ *s = sub(1,sx);
+
+ sy = norm_s(y);
+ y = shl(y,sy);
+ move16();
+ *s = add(*s,sy);
+
+ z = div_s(x,y);
+
+ if ( sign != 0 )
+ {
+ z = negate(z);
+ }
+
+
+ return z;
+}
+
+void copyWord8(const Word8 *src, Word8 *dst, const Word32 n)
+{
+ Word32 i;
+
+
+ FOR (i=0; i= 0)
+ {
+ /* Yes */
+ temp = temp2;
+ move16();
+ }
+ return temp;
+}
+Word16 findIndexOfMinWord32(Word32 *x, const Word16 len)
+{
+ Word16 i, indx;
+
+
+ indx = 0;
+ move16();
+ FOR (i = 1; i < len; i++)
+ {
+ if (LT_32(x[i],x[indx]))
+ {
+ indx = i;
+ move16();
+ }
+ }
+
+
+ return indx;
+}
+
+
+Word16 imult1616(Word16 x, Word16 y)
+{
+ assert((int)x * (int)y < 32768 && (int)x * (int)y >= -32768);
+ return extract_l(L_mult0(x, y));
+}
+
+Word32 imult3216(Word32 x, Word16 y)
+{
+ Word32 mh;
+ UWord16 ml;
+
+ Mpy_32_16_ss(x, y, &mh, &ml);
+
+ mh = L_shl(mh, 15);
+ ml = lshr(ml, 1);
+
+ return L_or(mh, L_deposit_l(ml));
+}
+
+
+Word16 idiv1616U(Word16 x, Word16 y)
+{
+ Word16 sx, sy;
+
+ /* make y > x to meet the requirements for div_s parameters */
+ sx = norm_s(x);
+ sy = norm_s(y);
+ x = shl(x, sx);
+ y = shl(y, sy);
+
+ if (x >= y)
+ {
+ x = shr(x,1);
+ sx = sub(sx,1);
+ }
+
+ /* divide and shift */
+ y = shr(div_s(x, y), sub(15, sub(sy,sx)));
+
+ return y;
+}
+
+
+Word16 idiv1616(Word16 x, Word16 y)
+{
+ Word16 s, num, den, sign;
+
+
+ num = abs_s(x);
+ den = abs_s(y);
+
+ sign = s_and(s_xor(x,y),-32768 /* 0x8000 */);
+
+ /* make num > den */
+ s = add(sub(norm_s(den), norm_s(num)), 1);
+ s = s_max(s, 0);
+
+ den = shl(den, s);
+
+ /* divide and shift */
+ y = shr(div_s(num, den), sub(15, s));
+
+ if (0 != sign)
+ {
+ y = negate(y);
+ }
+
+
+ return y;
+}
+
+Word32 norm_llQ31( /* o : normalized result Q31 */
+ Word32 L_c, /* i : upper bits of accu Q-1 */
+ Word32 L_sum, /* i : lower bits of accu, unsigned Q31 */
+ Word16 * exp /* o : exponent of result in [-32,31] Q0 */
+)
+{
+ Word16 i;
+ Word32 L_tmp;
+
+ /* Move MSBit of L_sum into L_c */
+ Carry = 0;
+ L_tmp = L_add_c(L_sum, L_sum); /* L_tmp = L_sum << 1 */
+ L_c = L_add_c(L_c,L_c);
+ L_add(0,0);
+ test();
+ IF ((L_c != (Word32) 0L) && (L_c != (Word32) 0xFFFFFFFFL))
+ {
+ i = norm_l(L_c);
+ L_c = L_shl(L_c,i);
+ i = sub(31,i); /* positive exponent */
+ L_sum = L_lshr(L_tmp, 1); /* L_sum with MSBit=0 */
+ L_sum = L_lshr(L_sum, i);
+ L_sum = L_add(L_c,L_sum);
+ }
+ ELSE
+ {
+ i = -32;
+ move16(); /* default exponent, if total sum=0 */
+ IF (L_sum)
+ {
+ i = norm_l(L_sum);
+ L_sum = L_shl(L_sum,i);
+ i = negate(i); /* negative or zero exponent */
+ }
+ }
+ *exp = i;
+ move16();
+ return L_sum;
+}
+
+Word32 w_norm_llQ31( Word64 L_sum, Word16 * exp );
+Word32 w_norm_llQ31( /* o : normalized result Q31 */
+ Word64 L_sum, /* i : upper and lower bits of accu, unsigned Q31 */
+ Word16 * exp /* o : exponent of result in [-32,31] Q0 */
+)
+{
+ Word32 L_tmp;
+ Word16 exp_val;
+ Word64 L64_inp64 = L_sum; move64();
+
+ L64_inp64 = W_shl( L64_inp64, 1);
+ exp_val = W_norm( L64_inp64 );
+ L64_inp64 = W_shl( L64_inp64, exp_val );
+ exp_val = sub( 31, exp_val );
+ if(EQ_64(L_sum , 0))
+ {
+ exp_val = -32; move16();
+ }
+ *exp = exp_val; move16();
+
+ L_tmp = W_extract_h( L64_inp64 );
+ return L_tmp;
+}
+
+Word32 Dot_product16HQ( /* o : normalized result Q31 */
+ const Word32 L_off, /* i : initial sum value Qn */
+ const Word16 x[], /* i : x vector Qn */
+ const Word16 y[], /* i : y vector Qn */
+ const Word16 lg, /* i : vector length, range [0..7FFF] Q0 */
+ Word16 * exp /* o : exponent of result in [-32,31] Q0 */
+)
+{
+ Word16 i;
+ Word32 L_sum;
+ Word64 L_sum64;
+
+ L_sum64 = W_deposit32_l( L_off );
+
+ FOR (i=0; i < lg; i++)
+ {
+ L_sum64 = W_mac_16_16(L_sum64,x[i], y[i]);
+ }
+
+ L_sum = w_norm_llQ31(L_sum64,exp);
+ return L_sum;
+}
+
+Word32 Norm32Norm(const Word32 *x, const Word16 headroom, const Word16 length, Word16 *result_e)
+{
+ Word32 L_tmp, L_tmp2;
+ Word16 i, shift, tmp;
+
+ move16();
+ shift = headroom;
+
+ L_tmp = L_deposit_l(0);
+
+ FOR (i=0; i= 0) shift = sub(shift,1);
+ if (L_tmp2 >= 0) L_tmp = L_shr(L_tmp, 2);
+
+ tmp = round_fx(L_shl(x[i], shift));
+ L_tmp = L_mac0(L_tmp, tmp, tmp); /* exponent = (1-shift*2) , Q(30+shift*2) */
+ }
+
+ move16();
+ *result_e = sub(1, shl(shift,1));
+
+ return L_tmp;
+}
+
+Word32 Dot_productSq16HQ( /* o : normalized result Q31 */
+ const Word32 L_off, /* i : initial sum value Qn */
+ const Word16 x[], /* i : x vector Qn */
+ const Word16 lg, /* i : vector length, range [0..7FFF] Q0 */
+ Word16 * exp /* o : exponent of result in [-32,31] Q0 */
+)
+{
+ Word16 i;
+ Word32 L_sum;
+ Word64 L_sum64;
+
+ L_sum64 = W_deposit32_l( L_off );
+
+ FOR (i=0; i < lg; i++)
+ {
+ L_sum64 = W_mac_16_16(L_sum64, x[i], x[i]);
+ }
+ L_sum = w_norm_llQ31(L_sum64,exp);
+
+ return L_sum;
+}
+
+Word32 dotp_s_fx(const Word16 *x, const Word16 *y, const Word16 n, Word16 s)
+{
+ Word16 i;
+ Word16 n2;
+ Word32 L_tmp;
+ Word32 L_sum;
+
+
+ L_sum = 0;
+ move32();
+
+ n2 = shr(n,1);
+
+ s = sub(s,1);
+
+ FOR (i=0; i < n2; i++)
+ {
+ L_tmp = L_mult0(x[2*i], y[2*i]);
+ L_tmp = L_mac0(L_tmp, x[2*i+1], y[2*i+1]);
+ L_sum = L_add(L_sum, L_shr(L_tmp, s));
+ }
+
+ IF ( s_and(n,1) )
+ {
+ L_tmp = L_mult0(x[n-1], y[n-1]);
+ L_sum = L_add(L_sum, L_shr(L_tmp, s));
+ }
+
+
+ return L_sum;
+}
+
+Word32 BASOP_util_Pow2(
+ const Word32 exp_m, const Word16 exp_e,
+ Word16 *result_e
+)
+{
+ static const Word16 pow2Coeff[8] =
+ {
+ 22713/*0.693147180559945309417232121458177 Q15*/, /* ln(2)^1 /1! */
+ 7872/*0.240226506959100712333551263163332 Q15*/, /* ln(2)^2 /2! */
+ 1819/*0.0555041086648215799531422637686218 Q15*/, /* ln(2)^3 /3! */
+ 315/*0.00961812910762847716197907157365887 Q15*/, /* ln(2)^4 /4! */
+ 44/*0.00133335581464284434234122219879962 Q15*/, /* ln(2)^5 /5! */
+ 5/*1.54035303933816099544370973327423e-4 Q15*/, /* ln(2)^6 /6! */
+ 0/*1.52527338040598402800254390120096e-5 Q15*/, /* ln(2)^7 /7! */
+ 0/*1.32154867901443094884037582282884e-6 Q15*/ /* ln(2)^8 /8! */
+ };
+
+ Word32 frac_part, tmp_frac, result_m;
+ Word16 int_part;
+
+ int_part = 0; /* to avoid compilation warnings */
+ frac_part = 0; /* to avoid compilation warnings */
+
+ IF (exp_e > 0)
+ {
+ /* "+ 1" compensates L_shr(,1) of the polynomial evaluation at the loop end. */
+
+ int_part = add(1,extract_l(L_shr(exp_m, sub(31, exp_e))));
+ frac_part = L_lshl(exp_m, exp_e);
+ frac_part = L_and(0x7FFFFFFF, frac_part);
+ }
+ if (exp_e <= 0)
+ frac_part = L_shl(exp_m, exp_e);
+ if (exp_e <= 0)
+ {
+ int_part = 1;
+ move16();
+ }
+
+ /* Best accuracy is around 0, so try to get there with the fractional part. */
+ IF( (tmp_frac = L_sub(frac_part,1073741824l/*0.5 Q31*/)) >= 0)
+ {
+ int_part = add(int_part, 1);
+ frac_part = L_sub(tmp_frac,1073741824l/*0.5 Q31*/);
+ }
+ ELSE IF( (tmp_frac = L_add(frac_part,1073741824l/*0.5 Q31*/)) < 0)
+ {
+ int_part = sub(int_part, 1);
+ frac_part = L_add(tmp_frac,1073741824l/*0.5 Q31*/);
+ }
+
+ /* Evaluate taylor polynomial which approximates 2^x */
+ {
+ Word32 p;
+ Word16 i;
+
+
+ /* First taylor series coefficient a_0 = 1.0, scaled by 0.5 due to L_shr(,1). */
+ result_m = L_add(1073741824l/*1.0/2.0 Q31*/,L_shr(Mpy_32_16_1(frac_part, pow2Coeff[0]), 1));
+ p = Mpy_32_32(frac_part, frac_part);
+ FOR (i = 1; i < 7; i++)
+ {
+ /* next taylor series term: a_i * x^i, x=0 */
+ result_m = L_add(result_m, L_shr(Mpy_32_16_1(p, pow2Coeff[i]), 1));
+ p = Mpy_32_32(p, frac_part);
+ }
+ result_m = L_add(result_m, L_shr(Mpy_32_16_1(p, pow2Coeff[i]), 1));
+ }
+ *result_e = int_part;
+ move16();
+ return result_m;
+}
+Word16 findIndexOfMaxWord32(Word32 *x, const Word16 len)
+{
+ Word16 i, indx;
+
+
+ indx = 0;
+ move16();
+ FOR (i = 1; i < len; i++)
+ {
+ if (GT_32(x[i],x[indx]))
+ {
+ indx = i;
+ move16();
+ }
+ }
+
+
+ return indx;
+}
+
+
+Word16 getNormReciprocalWord16(Word16 x)
+{
+
+ assert(x < (Word16)(sizeof(BASOP_util_normReciprocal)/sizeof(BASOP_util_normReciprocal[0])));
+
+ return extract_h(BASOP_util_normReciprocal[x]);
+}
+Word16 getNormReciprocalWord16Scale(Word16 x, Word16 s)
+{
+
+ assert(x < (Word16)(sizeof(BASOP_util_normReciprocal)/sizeof(BASOP_util_normReciprocal[0])));
+
+ return round_fx(L_shl(BASOP_util_normReciprocal[x],s));
+}
+
+Word32 BASOP_Util_fPow(
+ Word32 base_m, Word16 base_e,
+ Word32 exp_m, Word16 exp_e,
+ Word16 *result_e
+)
+{
+
+ Word16 ans_lg2_e, base_lg2_e;
+ Word32 base_lg2_m, ans_lg2_m, result_m;
+ Word16 shift;
+
+
+ test();
+ IF ((base_m == 0) && (exp_m != 0))
+ {
+ *result_e = 0;
+ move16();
+ return 0;
+ }
+ /* Calc log2 of base */
+ shift = norm_l(base_m);
+ base_m = L_shl(base_m, shift);
+ base_e = sub(base_e, shift);
+ base_lg2_m = BASOP_Util_Log2(base_m);
+
+ /* shift: max left shift such that neither base_e or base_lg2_m saturate. */
+ shift = sub(s_min(norm_s(base_e), WORD16_BITS-1-LD_DATA_SCALE), 1);
+ /* Compensate shift into exponent of result. */
+ base_lg2_e = sub(WORD16_BITS-1, shift);
+ base_lg2_m = L_add(L_shr(base_lg2_m, sub(WORD16_BITS-1-LD_DATA_SCALE, shift)), L_deposit_h(shl(base_e, shift)));
+
+ /* Prepare exp */
+ shift = norm_l(exp_m);
+ exp_m = L_shl(exp_m, shift);
+ exp_e = sub(exp_e, shift);
+
+ /* Calc base pow exp */
+ ans_lg2_m = Mpy_32_32(base_lg2_m, exp_m);
+ ans_lg2_e = add(exp_e, base_lg2_e);
+
+ /* Calc antilog */
+ result_m = BASOP_util_Pow2(ans_lg2_m, ans_lg2_e, result_e);
+
+ return result_m;
+}
+
+
+/*___________________________________________________________________________
+ | |
+ | Function Name : Dot_product12_offs() |
+ | |
+ | Compute scalar product of using accumulator. |
+ | The parameter 'L_off' is added to the accumulation result. |
+ | The result is normalized (in Q31) with exponent (0..30). |
+ | Notes: |
+ | o data in x[],y[] must provide enough headroom for accumulation |
+ | o L_off must correspond in format with product of x,y |
+ | Example: 0.01f for Q9 x Q9: 0x0000147B in Q19 |
+ | means: L_off = FL2WORD32_SCALE(0.01,31-19) |
+ |---------------------------------------------------------------------------|
+ | Algorithm: |
+ | |
+ | dot_product = L_off + sum(x[i]*y[i]) i=0..N-1 |
+ |___________________________________________________________________________|
+*/
+Word32 Dot_product12_offs( /* (o) Q31: normalized result (1 < val <= -1) */
+ const Word16 x[], /* (i) 12bits: x vector */
+ const Word16 y[], /* (i) 12bits: y vector */
+ const Word16 lg, /* (i) : vector length in range [1..256] */
+ Word16 * exp, /* (o) : exponent of result (0..+30) */
+ Word32 L_off /* (i) initial summation offset / 2 */
+)
+{
+ Word16 i, sft;
+ Word32 L_sum;
+
+ Word64 L_sum64;
+
+ L_sum64 = W_deposit32_l( L_off );
+ FOR (i = 0; i < lg; i++)
+ {
+ L_sum64 = W_mac0_16_16(L_sum64, x[i], y[i]);
+ }
+ L_sum = W_sat_l( L_sum64 );
+
+ /* Normalize acc in Q31 */
+
+ sft = norm_l(L_sum);
+ if (exp != NULL)
+ {
+ L_sum = L_shl(L_sum, sft);
+ }
+
+ /* exponent = 0..30, when L_sum != 0 */
+ if (L_sum != 0)
+ {
+ sft = sub(31,sft);
+ }
+
+ if (exp != NULL)
+ {
+ *exp = sft;
+ move16();
+ }
+
+ return L_sum;
+}
+
+Word32 Dot_product15_offs( /* (o) Q31: normalized result (1 < val <= -1) */
+ const Word16 x[], /* (i) 15bits: x vector */
+ const Word16 y[], /* (i) 15bits: y vector */
+ const Word16 lg, /* (i) : vector length in range [1..256] */
+ Word16 *exp, /* (o) : exponent of result (0..+30) */
+ Word32 L_off /* (i) initial summation offset */
+)
+{
+ Word16 i, sft, fac, ld;
+ Word32 L_sum;
+
+ ld = sub(14,norm_s(lg));
+ fac = shr(-32768,ld);
+ L_sum = L_shr(L_off,ld);
+
+ FOR (i = 0; i < lg; i++)
+ {
+ L_sum = L_add(L_sum, Mpy_32_16_1(L_msu(0, y[i],fac),x[i]));
+ }
+
+ /* Avoid returning 0 */
+ if (L_sum == 0)
+ {
+ L_sum = L_add(L_sum, 1);
+ }
+
+ /* Normalize acc in Q31 */
+ sft = norm_l(L_sum);
+ L_sum = L_shl(L_sum, sft);
+
+ /* exponent = 0..30, when L_sum != 0 */
+ if (L_sum != 0)
+ {
+ sft = add(ld, sub(30,sft));
+ }
+
+ *exp = sft;
+ move16();
+
+ return L_sum;
+}
+
+
+/*
+
+ precondition: headroom in Y is sufficient for n accumulations
+*/
+Word32 BASOP_Util_Add_Mant32Exp /*!< o: normalized result mantissa */
+(Word32 a_m, /*!< i: Mantissa of 1st operand a */
+ Word16 a_e, /*!< i: Exponent of 1st operand a */
+ Word32 b_m, /*!< i: Mantissa of 2nd operand b */
+ Word16 b_e, /*!< i: Exponent of 2nd operand b */
+ Word16 *ptr_e) /*!< o: exponent of result */
+{
+ Word32 L_tmp;
+ Word16 shift;
+
+
+
+ /* Compare exponents: the difference is limited to +/- 30
+ The Word32 mantissa of the operand with lower exponent is shifted right by the exponent difference.
+ Then, the unshifted mantissa of the operand with the higher exponent is added. The addition result
+ is normalized and the result represents the mantissa to return. The returned exponent takes into
+ account all shift operations.
+ */
+
+ if (!a_m)
+ {
+ a_e = b_e;
+ move16();
+ }
+
+ if (!b_m)
+ {
+ b_e = a_e;
+ move16();
+ }
+
+ shift = sub(a_e, b_e);
+ shift = s_max(-31,shift);
+ shift = s_min(31, shift);
+ if (shift < 0)
+ {
+ /* exponent of b is greater than exponent of a, shr a_m */
+ a_m = L_shl(a_m,shift);
+ }
+ if (shift > 0)
+ {
+ /* exponent of a is greater than exponent of b */
+ b_m = L_shr(b_m,shift);
+ }
+ a_e = add(s_max(a_e,b_e),1);
+ L_tmp = L_add(L_shr(a_m,1),L_shr(b_m,1));
+ shift = norm_l(L_tmp);
+ if (shift)
+ L_tmp = L_shl(L_tmp,shift);
+ if (L_tmp == 0)
+ {
+ a_e = 0;
+ move16();
+ }
+ if (L_tmp != 0)
+ a_e = sub(a_e,shift);
+ *ptr_e = a_e;
+
+ return (L_tmp);
+}
+
+
+Word16 BASOP_Util_Cmp_Mant32Exp /*!< o: flag: result of comparison */
+/* 0, if a == b */
+/* 1, if a > b */
+/* -1, if a < b */
+(Word32 a_m, /*!< i: Mantissa of 1st operand a */
+ Word16 a_e, /*!< i: Exponent of 1st operand a */
+ Word32 b_m, /*!< i: Mantissa of 2nd operand b */
+ Word16 b_e) /*!< i: Exponent of 2nd operand b */
+
+{
+ Word32 diff_m;
+ Word16 diff_e, shift, result;
+
+
+
+ /*
+ This function compares two input parameters, both represented by a 32-bit mantissa and a 16-bit exponent.
+ If both values are identical, 0 is returned.
+ If a is greater b, 1 is returned.
+ If a is less than b, -1 is returned.
+ */
+
+ /* Check, if both mantissa and exponents are identical, when normalized: return 0 */
+ shift = norm_l(a_m);
+ if (shift)
+ a_m = L_shl(a_m, shift);
+ if (shift)
+ a_e = sub(a_e, shift);
+
+ shift = norm_l(b_m);
+ if (shift)
+ b_m = L_shl(b_m, shift);
+ if (shift)
+ b_e = sub(b_e, shift);
+
+ /* align exponent, if any mantissa is zero */
+ if (!a_m)
+ {
+ a_e = b_e;
+ move16();
+ }
+ if (!b_m)
+ {
+ b_e = a_e;
+ move16();
+ }
+
+ BASOP_SATURATE_WARNING_OFF
+ diff_m = L_sub(a_m,b_m);
+ BASOP_SATURATE_WARNING_ON
+ diff_e = sub(a_e,b_e);
+
+ test();
+ IF(diff_m == 0 && diff_e == 0)
+ {
+ return 0;
+ }
+
+ /* Check sign, exponent and mantissa to identify, whether a is greater b or not */
+ result = sub(0,1);
+
+ IF (a_m >= 0)
+ {
+ /* a is positive */
+ if (b_m < 0)
+ {
+ result = 1;
+ move16();
+ }
+
+ test();
+ test();
+ test();
+ if ((b_m >= 0) && ((diff_e > 0) || (diff_e == 0 && diff_m > 0)))
+ {
+ result = 1;
+ move16();
+ }
+ }
+ ELSE
+ {
+ /* a is negative */
+ test();
+ test();
+ test();
+ if ((b_m < 0) && ((diff_e < 0) || (diff_e == 0 && diff_m > 0)))
+ {
+ result = 1;
+ move16();
+ }
+ }
+ return result;
+}
+
+/*
+
+ headroom is introduced into acc
+*/
+
+
+
+void bufferCopyFx(
+ Word16* src, /*old_exc, exc_buf, st->old_exc_len);*/
+ tmp_16 = sub(sub(Qf_src,Qf_dest),sub(Q_src,Q_dest));
+ IF (tmp_16>0) /*if value will be shifted right, do a multiplication with rounding ->preserves more accuracy*/
+ {
+ tmp_16 = shl(1,sub(15,tmp_16));
+ FOR (i = 0 ; i < length ; i++)
+ {
+ *(dest+i) = mult_r(*(src+i),tmp_16);
+ move16();
+ }
+ }
+ ELSE IF (tmp_16 <0)/*leftshift - no accuracy preservation needed*/
+ {
+ FOR (i = 0 ; i < length ; i++)
+ {
+ *(dest+i) = shr(*(src+i),tmp_16);
+ move16();
+ }
+ }
+ ELSE /*no shift, simply copy*/
+ {
+ FOR (i = 0 ; i < length ; i++)
+ {
+ *(dest+i) = *(src+i);
+ move16();
+ }
+ }
+}
+
+Word32 dotWord32_16_Mant32Exp(const Word32 *bufX32,/* i: 32-bit buffer with unknown headroom */
+ Word16 bufX32_exp, /* i: exponent of buffer bufX32 */
+ const Word16 *bufY16,/* i: 16-bit buffer quite right-aligned */
+ Word16 bufY16_exp, /* i: exponent of buffer bufY16 */
+ Word16 len, /* i: buffer len to process */
+ Word16 *exp) /* o: result exponent */
+{
+ Word32 L_sum;
+ Word16 shift, shift1, i;
+
+
+
+ shift = getScaleFactor32(bufX32, len); /* current available headroom */
+ shift = sub(shift, sub(14,norm_s(len))); /* reduced required headroom */
+ L_sum = 0; /* Clear accu */
+ move32();
+ FOR(i=0; i < len; i++)
+ {
+ L_sum = L_mac0(L_sum, round_fx(L_shl(bufX32[i], shift)), bufY16[i]);
+ }
+ shift1 = norm_l(L_sum);
+ L_sum = L_shl(L_sum, shift1); /* return value */
+
+ shift = sub(add(bufX32_exp, bufY16_exp), add(shift, shift1));
+ shift = add(shift, 1); /* compensate for factor of 2 introduced by L_mac0 */
+ /* In case of NULL result, we want to have a 0 exponent too */
+ if (L_sum == 0)
+ shift = 0;
+ *exp = shift;
+ move16();
+
+
+ return L_sum;
+
+}
+
+Word16 BASOP_Util_lin2dB(Word32 x, Word16 x_e, Word16 fEnergy)
+{
+ assert(x >= 0);
+
+ /* log2 */
+ x = L_shr(BASOP_Util_Log2(x), 25-16); /* Q16 */
+
+ /* add exponent */
+ x = L_msu(x, x_e, -32768 /* 0x8000 */);
+
+ /* convert log2 to 20*log10 */
+ x = Mpy_32_16_1(x, 24660/*6.0206f Q12*/); /* Q13 */
+
+ /* if energy divide by 2 (->10*log10) */
+ if (fEnergy != 0) x = L_shr(x, 1);
+
+ /* return dB as 7Q8 */
+ return round_fx(L_shl(x, 8-13+16)); /* Q8 */
+}
+
+/* --- fixp_atan() ---- */
+#define Q_ATANINP (25) /* Input in q25, Output in q14 */
+#define Q_ATANOUT (14)
+#define ATI_SF ((32-1)-Q_ATANINP) /* 6 */
+#define ATO_SF ((16-1)-Q_ATANOUT) /* 1 ] -pi/2 .. pi/2 [ */
+/* --- fixp_atan2() --- */
+#define Q_ATAN2OUT (13)
+#define AT2O_SF ((16-1)-Q_ATAN2OUT) /* 2 ] -pi .. pi ] */
+
+
+Word16 BASOP_util_atan2( /* o: atan2(y,x) [-pi,pi] Q13 */
+ Word32 y, /* i: */
+ Word32 x, /* i: */
+ Word16 e /* i: exponent difference (exp_y - exp_x) */
+)
+{
+ Word16 q;
+ Word32 at;
+ Word16 ret = -32768/*-1.0f Q15*/;
+ Word16 sf,sfo,stf;
+ Word32 L_sign;
+
+ if(L_or(y,x) == 0)
+ {
+ return 0;
+ }
+
+ IF(x == 0)
+ {
+ ret = 12868/*+EVS_PI/2 Q13*/;
+ move16();
+ if ( y < 0 )
+ {
+ ret = negate(ret);
+ }
+
+ return ret;
+ }
+
+ /* --- division */
+ L_sign = L_and(L_xor(x,y), 0x80000000 );
+
+ q = 32767/*1.0f Q15*/; /* y/x = neg/zero = -Inf */
+ sf = 0;
+ BASOP_SATURATE_WARNING_OFF
+ q = BASOP_Util_Divide3232_uu_1616_Scale(L_abs(y),L_abs(x), &sf);
+ BASOP_SATURATE_WARNING_ON
+
+ BASOP_SATURATE_WARNING_OFF
+ if(L_sign < 0)
+ q = negate(q);
+ BASOP_SATURATE_WARNING_ON
+
+ sfo = add(sf,e);
+
+ /* --- atan() */
+ IF ( GT_16(sfo,ATI_SF))
+ {
+ /* --- could not calc fixp_atan() here bec of input data out of range
+ ==> therefore give back boundary values */
+
+ sfo = s_min(sfo, MAXSFTAB);
+
+ /*q = FL2WORD16( 0.0f ); move16();*/
+
+ if( q > 0 )
+ {
+ move16();
+ q = +f_atan_expand_range[sfo-ATI_SF-1];
+ }
+ if( q < 0 )
+ {
+ move16();
+ q = -f_atan_expand_range[sfo-ATI_SF-1];
+ }
+ }
+ ELSE
+ {
+ /* --- calc of fixp_atan() is possible; input data within range
+ ==> set q on fixed scale level as desired from fixp_atan() */
+ stf = sub(sfo, ATI_SF);
+
+ at = L_deposit_h(q);
+ if (stf < 0) at = L_shl(at,stf);
+
+ q = BASOP_util_atan(at); /* ATO_SF*/
+ }
+
+
+ /* --- atan2() */
+
+ ret = shr(q,(AT2O_SF - ATO_SF)); /* now AT2O_SF for atan2 */
+ IF ( x < 0 )
+ {
+ if ( y >= 0 )
+ {
+ ret = add(ret, 25736/*EVS_PI Q13*/);
+ }
+ if(y < 0)
+ {
+ ret = sub(ret, 25736/* EVS_PI Q13*/);
+ }
+ }
+
+ return ret;
+}
+
+/* SNR of fixp_atan() = 56 dB*/
+#define ONEBY3P56 0x26800000 /* 1.0/3.56 in q31*/
+#define P281 0x00026000 /* 0.281 in q19*/
+#define ONEP571 0x6487 /* 1.571 in q14*/
+
+Word16 BASOP_util_atan( /* o: atan(x) [-pi/2;pi/2] 1Q14 */
+ Word32 x /* i: input data (-64;64) 6Q25 */
+)
+{
+ Word16 sign, result, exp;
+ Word16 res_e;
+ Word16 tmp, xx;
+
+
+
+ sign = 0;
+ move16();
+ if (x < 0)
+ {
+ sign = 1;
+ move16();
+ }
+ x = L_abs(x);
+
+ /* calc of arctan */
+ IF(LT_32(x, 1509950l/*0.045f/64.0f Q31*/))
+ {
+ result = round_fx(L_shl(x,5)); /*Q14*/
+ /*BASOP_util_atan_16(0.0444059968): max error 0.0000567511, mean 0.000017, abs mean 0.000017*/
+ }
+ ELSE
+ IF(LT_32(x,( L_shl(1,Q_ATANINP)-8482560l/*0.00395 Q31*/)))
+ {
+ xx =round_fx(L_shl(x,6));
+ tmp = mult_r(xx, xx); /* q15 * q15 - (16-1) = q15*/
+ tmp = mult_r(tmp, 0x1340); /* 15 * (ONEBY3P56) q14 - (16-1) = q14*/
+ tmp = add(tmp, 0x4000); /*L_shl(1,14) = 524288*/ /* q14 + q14 = q14 */
+ res_e=Q_ATANOUT-15+14-16+1;
+ move16();
+ if(GT_16(xx,tmp))
+ {
+ res_e = add(res_e,1);
+ }
+ if(GT_16(xx,tmp))
+ {
+ xx = shr(xx,1);
+ }
+ result = div_s(xx, tmp);
+ result = msu_r(0, result, shl(-32768,res_e));
+ /*BASOP_util_atan_16(0.7471138239): max error 0.0020029545, mean 0.000715, abs mean 0.000715*/
+ }
+ ELSE IF( LT_32(x,42949673l/*1.28/64.0 Q31*/))
+ {
+ Word16 delta_fix;
+ Word32 PI_BY_4 = 1686629684l/*3.1415926/4.0 Q31*//2; /* pi/4 in q30 */
+
+ delta_fix = round_fx(L_shl(L_sub(x,33554432l/*1.0/64.0 Q31*/), 5)); /* q30 */
+ result = round_fx(L_sub(L_add(PI_BY_4, L_msu(0,delta_fix,-16384)),(L_mult0(delta_fix, delta_fix))));
+ /* BASOP_Util_fPow(0.7472000122): max error 0.0020237688, mean 0.000026, abs mean 0.000520 */
+ }
+ ELSE
+ {
+ exp = sub(norm_l(x),1);
+ xx = round_fx(L_shl(x,exp));
+ /* q25+exp * q25+exp - (16-1) = q19+2*exp*/
+ tmp = mac_r(L_shl(P281,shl(exp,1)),xx, xx); /* q19+2*exp + q19+2*exp = q19+2*exp*/
+ res_e = norm_s(tmp);
+ result = div_s(xx, shl(tmp,res_e));
+ result = shl(result, add(add(Q_ATANOUT-Q_ATANINP/*-exp*/+19/*+2*exp*/-16+1, res_e ),exp));
+ result = sub(ONEP571,result); /* q14 + q14 = q14*/
+ /*BASOP_Util_fPow(1.2799999714): max error 0.0020168927, mean 0.000066, abs mean 0.000072*/
+ }
+
+ if (sign)
+ {
+ result = negate(result);
+ }
+
+ return(result);
+}
+
+/* compare two positive normalized 16 bit mantissa/exponent values */
+/* return value: positive if first value greater, negative if second value greater, zero if equal */
+Word16 compMantExp16Unorm(Word16 m1, Word16 e1, Word16 m2, Word16 e2)
+{
+ Word16 tmp;
+
+ assert((m1 >= 0x4000) && (m2 >= 0x4000)); /* comparisons below work only for normalized mantissas */
+
+ tmp = sub(e1, e2);
+ if (tmp == 0) tmp = sub(m1, m2);
+
+ return tmp;
+}
+
+cmplx CL_scale_t(cmplx x, Word16 y)
+{
+ cmplx result;
+ result.re = Mpy_32_16_1(x.re, y);
+ result.im = Mpy_32_16_1(x.im, y);
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_1--;
+ multiCounter[currCounter].Mpy_32_16_1--;
+ multiCounter[currCounter].CL_scale++;
+#endif
+ return (result);
+}
+
+cmplx CL_dscale_t(cmplx x, Word16 y1, Word16 y2)
+{
+ cmplx result;
+ result.re = Mpy_32_16_1(x.re, y1);
+ result.im = Mpy_32_16_1(x.im, y2);
+#if (WMOPS)
+ multiCounter[currCounter].Mpy_32_16_1--;
+ multiCounter[currCounter].Mpy_32_16_1--;
+ multiCounter[currCounter].CL_dscale++;
+#endif/* #if (WMOPS) */
+ return (result);
+}
+
+cmplx CL_mult_32x16(cmplx input, cmplx_s coeff)
+{
+ cmplx result;
+ result.re = L_sub(Mpy_32_16_1(input.re,coeff.re), Mpy_32_16_1(input.im, coeff.im));
+ result.im = L_add(Mpy_32_16_1(input.re,coeff.im), Mpy_32_16_1(input.im, coeff.re));
+#if (WMOPS)
+ multiCounter[currCounter].CL_multr_32x16++;
+ multiCounter[currCounter].Mpy_32_16_1--;
+ multiCounter[currCounter].Mpy_32_16_1--;
+ multiCounter[currCounter].Mpy_32_16_1--;
+ multiCounter[currCounter].Mpy_32_16_1--;
+ multiCounter[currCounter].L_sub--;
+ multiCounter[currCounter].L_add--;
+#endif
+ return result;
+}
diff --git a/lib_com/basop_util.h b/lib_com/basop_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..b52e70cd68699682f9ef7c605005b27d136aa921
--- /dev/null
+++ b/lib_com/basop_util.h
@@ -0,0 +1,816 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#ifndef __BASOP_UTIL_H__
+#define __BASOP_UTIL_H__
+
+#include "stl.h"
+#include "typedef.h"
+#include "basop32.h"
+#include "basop_mpy.h"
+
+
+#define _LONG long
+#define _SHORT short
+#ifdef _WIN32
+#define _INT64 __int64
+#else
+#define _INT64 long long
+#endif
+
+#define WORD32_BITS 32
+#define MAXVAL_WORD32 ((signed)0x7FFFFFFF)
+#define MINVAL_WORD32 ((signed)0x80000000)
+#define WORD32_FIX_SCALE ((_INT64)(1)<<(WORD32_BITS-1))
+
+#define WORD16_BITS 16
+#define MAXVAL_WORD16 (((signed)0x7FFFFFFF)>>16)
+#define MINVAL_WORD16 (((signed)0x80000000)>>16)
+#define WORD16_FIX_SCALE ((_INT64)(1)<<(WORD16_BITS-1))
+
+/*!
+ \def Macro converts a Word32 fixed point to Word16 fixed point <1 with saturation
+*/
+#define WORD322WORD16(val) \
+ ( ( ((((val) >> (WORD32_BITS-WORD16_BITS-1)) + 1) > (((_LONG)1< 0) ) ? \
+ (Word16)(_SHORT)(((_LONG)1<<(WORD16_BITS-1))-1):(Word16)(_SHORT)((((val) >> (WORD32_BITS-WORD16_BITS-1)) + 1) >> 1) )
+
+
+/* Word16 Packed Type */
+typedef struct
+{
+ struct
+ {
+ Word16 re;
+ Word16 im;
+ } v;
+} PWord16;
+
+#define cast16 move16
+
+
+#define LD_DATA_SCALE (6)
+#define LD_DATA_SHIFT_I5 (7)
+
+#define modDiv2(x) sub(x,shl(shr(x,1),1))
+#define modDiv8(x) L_sub(x,L_shl(L_shr(x,3),3))
+
+static __inline Word16 limitScale16( Word16 s)
+{
+ /* It is assumed, that s is calculated just before, therefore we can switch upon sign */
+ if (s >= 0)
+ s = s_min(s,WORD16_BITS-1);
+ if (s < 0)
+ s = s_max(s,1-WORD16_BITS);
+ return (s);
+}
+
+static __inline Word16 limitScale32( Word16 s)
+{
+ /* It is assumed, that s is calculated just before, therefore we can switch upon sign */
+ if (s >= 0)
+ s = s_min(s, WORD32_BITS-1);
+ if (s < 0)
+ s = s_max(s, 1-WORD32_BITS);
+ return (s);
+}
+
+/*!**********************************************************************
+ \brief Add two values given by mantissa and exponent.
+
+ Mantissas are in 16-bit-fractional format with values between 0 and 1.
+ The base for exponents is 2. Example: \f$ a = a\_m * 2^{a\_e} \f$
+
+************************************************************************/
+Word16 BASOP_Util_Add_MantExp /*!< Exponent of result */
+(Word16 a_m, /*!< Mantissa of 1st operand a */
+ Word16 a_e, /*!< Exponent of 1st operand a */
+ Word16 b_m, /*!< Mantissa of 2nd operand b */
+ Word16 b_e, /*!< Exponent of 2nd operand b */
+ Word16 *ptrSum_m); /*!< Mantissa of result */
+
+/************************************************************************/
+/*!
+ \brief Divide two values given by mantissa and exponent.
+
+ Mantissas are in 16-bit-fractional format with values between 0 and 1.
+ The base for exponents is 2. Example: \f$ a = a\_m * 2^{a\_e} \f$
+
+ For performance reasons, the division is based on a table lookup
+ which limits accuracy.
+*/
+void BASOP_Util_Divide_MantExp (Word16 a_m, /*!< Mantissa of dividend a */
+ Word16 a_e, /*!< Exponent of dividend a */
+ Word16 b_m, /*!< Mantissa of divisor b */
+ Word16 b_e, /*!< Exponent of divisor b */
+ Word16 *ptrResult_m, /*!< Mantissa of quotient a/b */
+ Word16 *ptrResult_e /*!< Exponent of quotient a/b */
+ );
+
+/************************************************************************/
+/*!
+ \brief Calculate the squareroot of a number given by mantissa and exponent
+
+ Mantissa is in 16/32-bit-fractional format with values between 0 and 1.
+ For *norm versions mantissa has to be between 0.5 and 1.
+ The base for the exponent is 2. Example: \f$ a = a\_m * 2^{a\_e} \f$
+ The exponent is addressed via pointers and will be overwritten with the result.
+*/
+Word16 Sqrt16( /*!< output mantissa */
+ Word16 mantissa, /*!< input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+);
+
+Word16 Sqrt16norm( /*!< output mantissa */
+ Word16 mantissa, /*!< normalized input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+);
+
+Word32 Sqrt32( /*!< output mantissa */
+ Word32 mantissa, /*!< input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+);
+
+
+/* deprecated, use Sqrt16! */
+void BASOP_Util_Sqrt_MantExp (Word16 *mantissa, /*!< Pointer to mantissa */
+ Word16 *exponent /*!< Pointer to exponent */
+ );
+
+/* deprecated, use Sqrt16norm! */
+void BASOP_Util_Sqrt_MantExpNorm (Word16 *mantissa, /*!< Pointer to normalized mantissa */
+ Word16 *exponent /*!< Pointer to exponent */
+ );
+
+/****************************************************************************/
+/*!
+ \brief Calculate the inverse of the squareroot of a number given by mantissa and exponent
+
+ Mantissa is in 16/32-bit-fractional format with values between 0 and 1.
+ For *norm versions mantissa has to be between 0.5 and 1.
+ The base for the exponent is 2. Example: \f$ a = a\_m * 2^{a\_e} \f$
+ The exponent is addressed via pointers and will be overwritten with the result.
+*/
+Word16 ISqrt16( /*!< output mantissa */
+ Word16 mantissa, /*!< input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+);
+
+Word32 ISqrt32( /*!< output mantissa */
+ Word32 mantissa, /*!< input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+);
+
+Word32 ISqrt32norm( /*!< output mantissa */
+ Word32 mantissa, /*!< normalized input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+);
+
+/* deprecated, use ISqrt16! */
+void BASOP_Util_InvSqrt_MantExp (Word16 *mantissa, /*!< Pointer to mantissa */
+ Word16 *exponent /*!< Pointer to exponent */
+ );
+
+/*****************************************************************************/
+/*!
+ \brief Calculate the inverse of a number given by mantissa and exponent
+
+ Mantissa is in 16-bit-fractional format with values between 0 and 1.
+ The base for the exponent is 2. Example: \f$ a = a\_m * 2^{a\_e} \f$
+ The operand is addressed via pointers and will be overwritten with the result.
+
+ The function uses a table lookup and a newton iteration.
+*/
+Word16 Inv16( /*!< output mantissa */
+ Word16 mantissa, /*!< input mantissa */
+ Word16 *exponent /*!< pointer to exponent */
+);
+/******************************************************************************/
+/*!
+ \brief Calculate the squareroot and inverse of squareroot of a number given by mantissa and exponent
+
+ Mantissa is in 16-bit-fractional format with values between 0 and 1.
+ The base for the exponent is 2. Example: \f$ a = a\_m * 2^{a\_e} \f$
+*/
+void BASOP_Util_Sqrt_InvSqrt_MantExp (Word16 mantissa, /*!< mantissa */
+ Word16 exponent, /*!< expoinent */
+ Word16 *sqrt_mant, /*!< Pointer to sqrt mantissa */
+ Word16 *sqrt_exp, /*!< Pointer to sqrt exponent */
+ Word16 *isqrt_mant, /*!< Pointer to 1/sqrt mantissa */
+ Word16 *isqrt_exp /*!< Pointer to 1/sqrt exponent */
+ );
+
+/********************************************************************/
+/*!
+ \brief Calculates the scalefactor needed to normalize input array
+
+ The scalefactor needed to normalize the Word16 input array is returned
+ If the input array contains only '0', a scalefactor 0 is returned
+ Scaling factor is determined wrt a normalized target x: 16384 <= x <= 32767 for positive x
+ and -32768 <= x <= -16384 for negative x
+*/
+
+Word16 getScaleFactor16( /* o: measured headroom in range [0..15], 0 if all x[i] == 0 */
+ const Word16 *x, /* i: array containing 16-bit data */
+ const Word16 len_x); /* i: length of the array to scan */
+
+/********************************************************************/
+/*!
+ \brief Calculates the scalefactor needed to normalize input array
+
+ The scalefactor needed to normalize the Word32 input array is returned
+ If the input array contains only '0', a scalefactor 0 is returned
+ Scaling factor is determined wrt a normalized target x: 1073741824 <= x <= 2147483647 for positive x
+ and -2147483648 <= x <= -1073741824 for negative x
+*/
+
+Word16 getScaleFactor32( /* o: measured headroom in range [0..31], 0 if all x[i] == 0 */
+ const Word32 *x, /* i: array containing 32-bit data */
+ const Word16 len_x); /* i: length of the array to scan */
+
+/**
+ * \brief normalize mantissa and update the exponent accordingly.
+ * \param mantissa the mantissa to be normalized
+ * \param pexponent pointer to the exponent.
+ * \return the normalized mantissa.
+ */
+Word16 normalize16(Word16 mantissa, Word16 *pexponent);
+/****************************************************************************/
+/*!
+ \brief Does fractional integer division of Word32 arg1 by Word16 arg2
+
+ both input arguments may be positive or negative
+ the result is truncated to Word16
+
+ \return fractional integer Word16 result of arg1/arg2
+*/
+Word16 divide3216( Word32 x, /*!< Numerator*/
+ Word16 y); /*!< Denominator*/
+
+
+/****************************************************************************/
+/*!
+ \brief Does fractional integer division of Word16 arg1 by Word16 arg2
+
+ both input arguments may be positive or negative
+ the result is truncated to Word16
+
+ \return fractional integer Word16 result of arg1/arg2
+*/
+Word16 divide1616( Word16 x, /*!< Numerator*/
+ Word16 y); /*!< Denominator*/
+
+
+/****************************************************************************/
+/*!
+ \brief Does fractional integer division of Word32 arg1 by Word32 arg2
+
+ this function makes both the numerator and the denominator positive integers,
+ and scales up both values to avoid losing the accuracy of the outcome
+ too much
+
+ WARNING: it should be arg1 < arg2 because of the maximum degree of scaling for the mantissa!
+
+ \return fractional Word16 integer z = arg1(32bits)/arg2(32bits)
+*/
+Word16 divide3232( Word32 x, /*!< Numerator*/
+ Word32 y); /*!< Denominator*/
+
+
+/****************************************************************************/
+/*!
+ \brief Does fractional integer division of UWord32 arg1 by UWord32 arg2
+
+ This function ensures both the numerator and the denominator are positive integers,
+ and scales up both values to avoid losing the accuracy of the outcome
+ too much.
+
+ CAUTION: Arg 3 is a Word16 pointer which will point to the scalefactor difference
+ s_diff = sub(s2,s1), where s1 and s2 are the scalefactors of the arguments, which
+ were shifted in order to e.g. preserve accuracy.
+ I.e. the result has to be scaled due to shifting it
+ s_diff to the right to obtain the real result of the division.
+
+ \return fractional Word16 integer z = arg1(32bits)/arg2(32bits)
+*/
+Word16 BASOP_Util_Divide3232_uu_1616_Scale( Word32 x, /*!< i : Numerator*/
+ Word32 y, /*!< i : Denominator*/
+ Word16 *s); /*!< o : Additional scalefactor difference*/
+
+
+/****************************************************************************/
+/*!
+ \brief Does fractional integer division of Word32 arg1 by Word32 arg2
+
+ This function scales up both values to avoid losing the accuracy of the outcome
+ too much.
+
+ CAUTION: Arg 3 is a Word16 pointer which will point to the scalefactor difference
+ s_diff = sub(s2,s1), where s1 and s2 are the scalefactors of the arguments, which
+ were shifted in order to e.g. preserve accuracy.
+ I.e. the result has to be scaled due to shifting it
+ s_diff to the right to obtain the real result of the division.
+
+ \return fractional Word16 integer z = arg1(32bits)/arg2(32bits)
+*/
+Word16 BASOP_Util_Divide3232_Scale( Word32 x, /*!< i : Numerator*/
+ Word32 y, /*!< i : Denominator*/
+ Word16 *s); /*!< o : Additional scalefactor difference*/
+
+
+/****************************************************************************/
+/*!
+ \brief Does fractional integer division of Word32 arg1 by Word16 arg2
+
+
+ \return fractional Word16 integer z = arg1(32bits)/arg2(16bits) , z not normalized
+*/
+Word16 BASOP_Util_Divide3216_Scale( Word32 x, /*!< i : Numerator */
+ Word16 y, /*!< i : Denominator*/
+ Word16 *s); /*!< o : Additional scalefactor difference*/
+
+
+/****************************************************************************/
+/*!
+ \brief Does fractional division of Word16 arg1 by Word16 arg2
+
+
+ \return fractional Q15 Word16 z = arg1(Q15)/arg2(Q15) with scaling s
+*/
+Word16 BASOP_Util_Divide1616_Scale( Word16 x, /*!< i : Numerator*/
+ Word16 y, /*!< i : Denominator*/
+ Word16 *s); /*!< o : Additional scalefactor difference*/
+
+/************************************************************************/
+/*!
+ \brief Binary logarithm with 7 iterations
+
+ \param x
+
+ \return log2(x)/64
+ */
+/************************************************************************/
+Word32 BASOP_Util_Log2(Word32 x);
+
+
+/************************************************************************/
+/*!
+ \brief Binary power
+
+ Date: 06-JULY-2012 Arthur Tritthart, IIS Fraunhofer Erlangen
+
+ Version with 3 table lookup and 1 linear interpolations
+
+ Algorithm: compute power of 2, argument x is in Q7.25 format
+ result = 2^(x/64)
+ We split exponent (x/64) into 5 components:
+ integer part: represented by b31..b25 (exp)
+ fractional part 1: represented by b24..b20 (lookup1)
+ fractional part 2: represented by b19..b15 (lookup2)
+ fractional part 3: represented by b14..b10 (lookup3)
+ fractional part 4: represented by b09..b00 (frac)
+ => result = (lookup1*lookup2*(lookup3+C1*frac)<<3)>>exp
+
+ Due to the fact, that all lookup values contain a factor 0.5
+ the result has to be shifted by 3 to the right also.
+ Table exp2_tab_long contains the log2 for 0 to 1.0 in steps
+ of 1/32, table exp2w_tab_long the log2 for 0 to 1/32 in steps
+ of 1/1024, table exp2x_tab_long the log2 for 0 to 1/1024 in
+ steps of 1/32768. Since the 2-logarithm of very very small
+ negative value is rather linear, we can use interpolation.
+
+ Limitations:
+
+ For x <= 0, the result is fractional positive
+ For x > 0, the result is integer in range 1...7FFF.FFFF
+ For x < -31/64, we have to clear the result
+ For x = 0, the result is ~1.0 (0x7FFF.FFFF)
+ For x >= 31/64, the result is 0x7FFF.FFFF
+
+ \param x
+
+ \return pow(2,(x/64))
+ */
+/************************************************************************/
+Word32 BASOP_Util_InvLog2(Word32 x);
+
+Word16 BASOP_util_norm_s_bands2shift (Word16 x);
+
+/***********************************************************************/
+/*!
+ \brief Calculate the headroom of the complex data in a 2 dimensional array
+
+ \return number of headroom bits
+ */
+Word16 BASOP_util_norm_l_dim2_cplx (const Word32 * const *re, /*!< Real part of 32 Bit input */
+ const Word32 * const *im, /*!< Imag part if 32 Bit input */
+ Word16 startBand, /*!< start band of cplx data */
+ Word16 stopBand, /*!< stop band of cplx data */
+ Word16 startSlot, /*!< start slot of cplx data */
+ Word16 stopSlot /*!< stop slot of cplx data */
+ );
+/****************************************************************************/
+/*!
+ \brief Does a data copy of Word8 *arg1 to Word8 *arg2 with Word16 arg3 number of moves
+*/
+void copyWord8( const Word8 *src, /*!< i : Source address */
+ Word8 *dst, /*!< i : Destination address */
+ const Word32 n); /*!< i : Number of elements to copy */
+
+
+/****************************************************************************/
+/*!
+ \brief Sets Word8 array arg1[] to zero for a length of Word16 arg2 elements
+*/
+void set_zero_Word8( Word8 X[], /*!< i : Address of array */
+ Word32 n); /*!< i : Number of elements to set to zero */
+
+/****************************************************************************/
+/*!
+ \brief Does a multiplication of Word32 * Word16 input values
+
+ \return z32 = x32 * y16
+*/
+Word32 L_mult0_3216( Word32 x, /*!< : Multiplier */
+ Word16 y); /*!< : Multiplicand */
+
+/* Calculate sin/cos. Angle in 2Q13 format, result has exponent = 1 */
+Word16 getCosWord16(Word16 theta);
+Word32 getCosWord32(Word32 theta);
+/**
+ * \brief calculate cosine of angle. Tuned for ISF domain.
+ * \param theta Angle normalized to radix 2, theta = (angle in radians)*2.0/pi
+ * \return result with exponent 0.
+ */
+Word16 getCosWord16R2(Word16 theta);
+
+/****************************************************************************/
+/*!
+ \brief square root abacus algorithm
+
+ \return integer sqrt(x)
+ */
+Word16 getSqrtWord32(Word32 x);
+
+/****************************************************************************/
+/*!
+ \brief finds index of min Word16 in array
+
+ \return index of min Word16
+ */
+Word16 findIndexOfMinWord16(Word16 *x, const Word16 len);
+
+/****************************************************************************/
+/*!
+ \brief finds index of min Word32 in array
+
+ \return index of min Word32
+ */
+Word16 findIndexOfMinWord32(Word32 *x, const Word16 len);
+
+/****************************************************************************/
+/*!
+ \brief finds index of max Word16 in array
+
+ \return index of max Word16
+ */
+Word16 findIndexOfMaxWord16(Word16 *x, const Word16 len);
+
+/****************************************************************************/
+/*!
+ \brief finds index of max Word32 in array
+
+ \return index of max Word32
+ */
+Word16 findIndexOfMaxWord32(Word32 *x, const Word16 len);
+
+/****************************************************************************/
+/*!
+ \brief 16x16->16 integer multiplication without overflow control
+
+ \return 16x16->16 integer
+ */
+Word16 imult1616(Word16 x, Word16 y);
+
+/****************************************************************************/
+/*!
+ \brief 32x16->32 integer multiplication with overflow control
+
+ \return 32x16->32 integer
+ */
+Word32 imult3216(Word32 x, Word16 y);
+
+/****************************************************************************/
+/*!
+ \brief 16/16->16 unsigned integer division
+
+ x and y have to be positive, x has to be < 16384
+
+ \return 16/16->16 integer
+ */
+
+Word16 idiv1616U(Word16 x, Word16 y);
+
+/****************************************************************************/
+/*!
+ \brief 16/16->16 signed integer division
+
+ x and y have to be positive, x has to be < 16384
+
+ \return 16/16->16 integer
+ */
+
+Word16 idiv1616(Word16 x, Word16 y);
+
+/*------------------------------------------------------------------*
+ * Dot_product16HQ:
+ *
+ * \brief Compute scalar product of using 64-bit accumulator.
+ *
+ * Performs normalization of the result, returns the exponent
+ * Note: In contrast to dotWord32, no headroom is required for data
+ * in x[] and y[], means, they may have any format Qn
+ *------------------------------------------------------------------*/
+Word32 Dot_product16HQ( /* using 64-bit accumulator.
+ *
+ * Performs normalization of the result, returns the exponent
+ * Note: In contrast to dotWord32, no headroom is required for data
+ * in x[], means, they may have any format Qn
+ *------------------------------------------------------------------*/
+Word32 Dot_productSq16HQ( /* using 64-bit accumulator.
+ *
+ * Performs no normalization of the result
+ *------------------------------------------------------------------*/
+Word32 dotp_s_fx( /* using accumulator. |
+ | The parameter 'L_off' is added to the accumulation result. |
+ | The result is normalized (in Q31) with exponent (0..30). |
+ | Notes: |
+ | o data in x[],y[] must provide enough headroom for accumulation |
+ | o L_off must correspond in format with product of x,y |
+ | Example: 0.01f for Q9 x Q9: 0x0000147B in Q19 |
+ | means: L_off = FL2WORD32_SCALE(0.01f,31-19) |
+ |---------------------------------------------------------------------------|
+ | Algorithm: |
+ | |
+ | dot_product = L_off + sum(x[i]*y[i]) i=0..N-1 |
+ |___________________________________________________________________________|
+*/
+
+Word32 Dot_product12_offs( /* (o) Q31: normalized result (1 < val <= -1) */
+ const Word16 x[], /* (i) 12bits: x vector */
+ const Word16 y[], /* (i) 12bits: y vector */
+ const Word16 lg, /* (i) : vector length in range [1..256] */
+ Word16 * exp, /* (o) : exponent of result (0..+30) */
+ Word32 L_off /* (i) initial summation offset /2 */
+);
+
+Word32 Dot_product15_offs( /* (o) Q31: normalized result (1 < val <= -1) */
+ const Word16 x[], /* (i) 15bits: x vector */
+ const Word16 y[], /* (i) 15bits: y vector */
+ const Word16 lg, /* (i) : vector length in range [1..256] */
+ Word16 *exp, /* (o) : exponent of result (0..+30) */
+ Word32 L_off /* (i) initial summation offset */
+);
+
+/*!**********************************************************************
+ \brief Add two values given by mantissa and exponent.
+
+ Mantissas are in 32-bit-fractional format with values between 0 and 1.
+ The base for exponents is 2. Example: \f$ a = a\_m * 2^{a\_e} \f$
+
+************************************************************************/
+Word32 BASOP_Util_Add_Mant32Exp /*!< o: normalized result mantissa */
+(Word32 a_m, /*!< i: Mantissa of 1st operand a */
+ Word16 a_e, /*!< i: Exponent of 1st operand a */
+ Word32 b_m, /*!< i: Mantissa of 2nd operand b */
+ Word16 b_e, /*!< i: Exponent of 2nd operand b */
+ Word16 *ptr_e); /*!< o: exponent of result */
+/*!**********************************************************************
+ \brief Returns the comparison result of two normalized values given by mantissa and exponent.
+ return value: -1: a < b, 0: a == b, 1; a > b
+
+ Mantissas are in 32-bit-fractional format with values between 0 and 1.
+ The base for exponents is 2. Example: \f$ a = a\_m * 2^{a\_e} \f$
+
+************************************************************************/
+Word16 BASOP_Util_Cmp_Mant32Exp /*!< o: flag: result of comparison */
+(Word32 a_m, /*!< i: Mantissa of 1st operand a */
+ Word16 a_e, /*!< i: Exponent of 1st operand a */
+ Word32 b_m, /*!< i: Mantissa of 2nd operand b */
+ Word16 b_e); /*!< i: Exponent of 2nd operand b */
+
+/********************************************************************
+ * bufferCopyFx
+ *
+ * \brief copies buffer while preserving Format of destination buffer
+*********************************************************************
+*/
+void bufferCopyFx(
+ Word16* src, /*
+ The base for exponent x_e is 2.
+
+************************************************************************/
+Word16 BASOP_Util_lin2dB( /*!< o: dB value (7Q8) */
+ Word32 x, /*!< i: mantissa */
+ Word16 x_e, /*!< i: exponent */
+ Word16 fEnergy); /*!< i: flag indicating if x is energy */
+
+/*!**********************************************************************
+ \brief Calculates atan(x).
+************************************************************************/
+Word16 BASOP_util_atan( /*!< o: atan(x) [-pi/2;pi/2] 1Q14 */
+ Word32 x /*!< i: input data (-64;64) 6Q25 */
+);
+
+/*!**********************************************************************
+ \brief Calculates atan2(y,x).
+************************************************************************/
+Word16 BASOP_util_atan2( /*!< o: atan2(y,x) [-pi,pi] Q13 */
+ Word32 y, /*!< i: */
+ Word32 x, /*!< i: */
+ Word16 e /*!< i: exponent difference (exp_y - exp_x) */
+);
+/*!**********************************************************************
+ \brief norm_llQ31 returns Word32 with scalingfactor, with 2 32bit accus as input
+
+************************************************************************/
+Word32 norm_llQ31( /* o : normalized result Q31 */
+ Word32 L_c, /* i : upper bits of accu Q-1 */
+ Word32 L_sum, /* i : lower bits of accu, unsigned Q31 */
+ Word16 * exp /* o : exponent of result in [-32,31] Q0 */
+);
+
+/* compare two positive normalized 16 bit mantissa/exponent values */
+/* return value: positive if first value greater, negative if second value greater, zero if equal */
+Word16 compMantExp16Unorm(Word16 m1, Word16 e1, Word16 m2, Word16 e2);
+
+
+cmplx CL_scale_t(cmplx x, Word16 y);
+cmplx CL_dscale_t(cmplx x, Word16 y1, Word16 y2);
+cmplx CL_mult_32x16(cmplx input, cmplx_s coeff);
+
+#endif /* __BASOP_UTIL_H__ */
diff --git a/lib_com/bitalloc_fx.c b/lib_com/bitalloc_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..e875265f99d80e8261c59748cd0ff56ee64349c2
--- /dev/null
+++ b/lib_com/bitalloc_fx.c
@@ -0,0 +1,1029 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h" /* required for wmc_tool */
+
+void bitalloc_fx (
+ Word16 *y, /* i : reordered norm of sub-vectors Q0 */
+ Word16 *idx, /* i : reordered sub-vector indices Q0 */
+ Word16 sum, /* i : number of available bits Q0 */
+ Word16 N, /* i : number of norms Q0 */
+ Word16 K, /* i : maximum number of bits per dimension Q0 */
+ Word16 *r, /* o : bit-allacation vector Q0 */
+ const Word16 *sfmsize, /* i : band length Q0 */
+ const Word16 hqswb_clas /* i : signal classification flag Q0 */
+)
+{
+ Word16 i, j, k, n, m, v, im;
+ Word16 diff, temp;
+ Word16 fac;
+ Word16 ii;
+ Word16 SFM_thr = SFM_G1G2;
+ move16();
+
+ N = sub(N, 1);
+
+ if ( EQ_16(hqswb_clas, HQ_HARMONIC))
+ {
+ SFM_thr = 22;
+ move16();
+ }
+
+ fac = 3;
+ move16();
+ K = sub(K,2);
+ im = 1;
+ move16();
+ diff = sum;
+ move16();
+ n = shr(sum,3);
+ FOR ( i=0; i 0)
+ {
+ n = add(n,Nb[i]);
+ Rsubband_w32_fx[i] = Mult_32_16(Rsubband_w32_fx[i], tmp);
+ move32();/*exp1 - 15*/
+ Rsubband_w32_fx[i] = L_shl(Rsubband_w32_fx[i], sub(30, exp1));/*Q15*/
+
+ t_fx = L_add(t_fx, Rsubband_w32_fx[i]);/*Q0*/
+ }
+ ELSE
+ {
+ Rsubband_w32_fx[i] = L_deposit_l(0);
+ }
+ }
+ }
+ ELSE
+ {
+ /* Initial bits distribution */
+ L_tmp1 = 0;
+ move16();
+ m_fx = 0;
+ move16();
+ FOR ( i = 0; i < N ; i++)
+ {
+ L_tmp1 = L_mac0(L_tmp1, Nb[i], y[i]);
+ }
+ L_tmp1 = L_msu0(L_tmp1, fac, B);
+
+
+ t_fx = L_deposit_l(0);
+ n = 0;
+ move16();
+ tmp = add(band_end_HQ[N-1], shl(band_end_HQ[N-1], 1));
+ exp1 = norm_s(tmp);
+ tmp = div_s(16384, shl(tmp, exp1));/*15 + 14 - exp1*/
+ exp2 = norm_s(tmp);
+ tmp = shl(tmp, exp2);
+ exp1 = add(29, sub(exp2, exp1));
+ FOR ( i = 0; i < N; i++)
+ {
+ L_tmp2 = L_sub(L_mult0(y[i], band_end_HQ[N-1]), L_tmp1);
+ Rsubband_w32_fx[i] = L_mult0(extract_l(L_tmp2), Nb[i]);
+ move32();/*Q0*/
+ IF (Rsubband_w32_fx[i] > 0)
+ {
+ n = add(n,Nb[i]);
+ L_tmp3 = Mult_32_16(Rsubband_w32_fx[i], tmp); /*exp1 - 15*/
+ Rsubband_w32_fx[i] = L_shl(L_tmp3, sub(30, exp1)); /*Q15*/ move32();
+
+ t_fx = L_add(t_fx, Rsubband_w32_fx[i]);/*Q0*/
+ }
+ ELSE
+ {
+ Rsubband_w32_fx[i] = L_deposit_l(0);
+ }
+ }
+ }
+
+ /* Distribute the remaining bits to subbands with non-zero bits */
+ B_fx = L_shl(B, 15);
+ WHILE (NE_32(L_shr(L_add(t_fx, 16384), 15) , B))
+ {
+ L_tmp1 = L_sub(t_fx, B_fx);
+ exp1 = sub(norm_l(L_tmp1), 1);
+ exp2 = norm_s(n);
+ tmp = div_s(extract_h(L_shl(L_tmp1, exp1)), shl(n, exp2));/*15 + 15 + exp1 - 16 - exp2*/
+ m_fx = shl(tmp, sub(exp2, exp1));/*Q14*/
+
+ t_fx = L_deposit_l(0);
+ n = 0;
+ move16();
+ FOR ( i = 0; i < N; i++)
+ {
+ IF (Rsubband_w32_fx[i] > 0)
+ {
+ Rsubband_w32_fx[i] = L_msu(Rsubband_w32_fx[i], m_fx, Nb[i]);
+ move32();
+
+ IF (Rsubband_w32_fx[i] > 0)
+ {
+ n = add(n,Nb[i]);
+
+ t_fx = L_add(t_fx, Rsubband_w32_fx[i]);
+ }
+ ELSE
+ {
+ Rsubband_w32_fx[i] = L_deposit_l(0);
+ }
+ }
+ }
+ }
+ Bits = B;
+ move16();
+
+ /* Impose bit-constraints to subbands with less than minimum bits*/
+ t_fx = L_deposit_l(0);
+ n = 0;
+ move16();
+ FOR ( i = 0; i < N; i++)
+ {
+ IF (Rsubband_w32_fx[i] > 0)
+ {
+ test();
+ IF ((LT_32(Rsubband_w32_fx[i] , L_shl(add(bs, LNb[i]), 15)))&&(EQ_16(low_rate,1)))
+ {
+ Rsubband_w32_fx[i] = L_deposit_l(0);
+ }
+ ELSE IF ( LE_32(Rsubband_w32_fx[i] , L_shl(Nb[i], 15)))
+ {
+ B = sub(B,Nb[i]);
+ Rsubband_w32_fx[i] = L_shl(Nb[i], 15);
+ move32();
+ }
+ ELSE
+ {
+ n = add(n,Nb[i]);
+ t_fx = L_add(t_fx, Rsubband_w32_fx[i]);
+ }
+ }
+ }
+
+ /* Distribute the remaining bits to subbands with more than 1-bit per sample */
+ WHILE (NE_32(L_shr(L_add(t_fx, 16384), 15) ,B))
+ {
+ L_tmp1 = L_sub(t_fx, L_shl(B, 15));
+ L_tmp2 = L_abs(L_tmp1);
+
+ if (n>0)
+ {
+ exp1 = sub(norm_l(L_tmp2), 1);
+ exp2 = norm_s(n);
+ tmp = div_s(extract_h(L_shl(L_tmp2, exp1)), shl(n, exp2));/*15 + 15 + exp1 - 16 - exp2*/
+ m_fx = shl(tmp, sub(exp2, exp1));/*Q14*/
+ if (L_tmp1 < 0)
+ {
+ m_fx = negate(m_fx);
+ }
+
+ t_fx = L_deposit_l(0);
+ n = 0;
+ move16();
+ FOR( i = 0; i < N; i++)
+ {
+ IF (GT_32(Rsubband_w32_fx[i] , L_shl(Nb[i], 15)))
+ {
+ Rsubband_w32_fx[i] = L_msu(Rsubband_w32_fx[i], m_fx, Nb[i]);
+ move32();
+ IF (GT_32(Rsubband_w32_fx[i] ,L_shl(Nb[i], 15)))
+ {
+ n = add(n,Nb[i]);
+
+ t_fx = L_add(t_fx, Rsubband_w32_fx[i]);
+ }
+ ELSE
+ {
+ B = sub(B,Nb[i]);
+
+ Rsubband_w32_fx[i] = L_shl(Nb[i], 15);
+ move32();
+ }
+ }
+ }
+ }
+ /*In case no subband has enough bits more than 1-bit per sample, take bits off the higher subbands */
+ IF (t_fx == 0)
+ {
+ FOR ( i = N-1; i >= 0; i--)
+ {
+ IF (Rsubband_w32_fx[i] > 0)
+ {
+ B = add( B, Nb[i] );
+ Rsubband_w32_fx[i] = L_deposit_l(0);
+ IF ( B >= 0)
+ {
+ BREAK;
+ }
+ }
+ }
+ BREAK;
+ }
+ }
+
+ /* fine redistribution of over-allocated or under-allocated bits */
+ tmp = 0;
+ move16();
+ FOR ( i = 0; i < N; i++)
+ {
+ Rsubband_fx[i] = extract_l(L_shr(Rsubband_w32_fx[i], 12));
+ tmp = add(tmp, Rsubband_fx[i]);
+ }
+
+ B = Bits;
+ B_w16_fx = shl(B, 3);
+ IF (GT_16(tmp ,B_w16_fx))
+ {
+ tmp = sub(tmp, B_w16_fx);
+ FOR ( i = 0; i < N; i++)
+ {
+ IF (GE_16(Rsubband_fx[i], add(shl(Nb[i], 3), tmp)))
+ {
+ Rsubband_fx[i] = sub(Rsubband_fx[i], tmp);
+ move16();
+ BREAK;
+ }
+ }
+ }
+ ELSE
+ {
+ tmp = sub(tmp, B_w16_fx);
+ FOR ( i = 0; i < N; i++)
+ {
+ IF (Rsubband_fx[i] > 0)
+ {
+ Rsubband_fx[i] = sub(Rsubband_fx[i], tmp);
+ move16();
+ BREAK;
+ }
+ }
+ }
+
+ /* Calcuate total used bits and initialize R to be used for Noise Filling */
+ tmp = 0;
+ move16();
+ FOR ( i = 0; i < N; i++)
+ {
+ tmp = add(tmp, Rsubband_fx[i]);
+ R[i] = shr(Rsubband_fx[i], 3);
+ move16();
+ }
+ return shr(tmp, 3);
+}
+/*-------------------------------------------------------------------*
+ * Bit_group()
+ *
+ * bit allocation in group
+ *-------------------------------------------------------------------*/
+static
+void Bit_group_fx (
+ Word16 *y, /* i : norm of sub-band Q0*/
+ Word16 start_band, /* i : start band indices Q0*/
+ Word16 end_band, /* i : end band indices Q0*/
+ Word16 Bits, /* i : number of allocation bits in group Q0*/
+ Word16 thr, /* i : smallest bit number for allocation in group Q0*/
+ Word32 *Rsubband_fx, /* o : bit allocation of sub-band Q21*/
+ Word16 *fac_fx /* i : weight factor for norm of sub-band Q13*/
+)
+{
+ Word16 i, j, k, m, y_index[16], index[16], bit_band, band_num, norm_sum;
+ Word16 tmp,exp;
+ Word16 factor_fx;
+ Word32 R_temp_fx[16], R_sum_fx = 0, R_sum_org_fx = 0, Bits_avg_fx = 0;
+ Word32 L_tmp;
+
+ /* initialization for bit allocation in one group*/
+ tmp = 6554;
+ move16(); /*Q15 1/5 */
+ if(EQ_16(thr,5))
+ {
+ tmp = 6554;
+ move16(); /*Q15 1/5 */
+ }
+ if(EQ_16(thr,6))
+ {
+ tmp = 5462;
+ move16();/*Q15 1/6 */
+ }
+ if(EQ_16(thr,7))
+ {
+ tmp = 4682;
+ move16();/*Q15 1/7 */
+ }
+ bit_band = mult(tmp, Bits); /*0+15-15=0, Q0 */
+ band_num = sub(end_band,start_band);
+
+ FOR( i = 0; i < band_num; i++ )
+ {
+ y_index[i] = y[add(i,start_band)];
+ move16();
+ index[i] = i;
+ move16();
+ }
+
+ /* Rearrange norm vector in decreasing order */
+ reordvct_fx(y_index, band_num, index);
+ /* norm vector modification */
+
+ factor_fx = div_s(1, band_num);/*Q15 */
+ IF ( GT_16(thr,5))
+ {
+ FOR ( i = 0; i < band_num; i++ )
+ {
+ L_tmp = L_mult(i,factor_fx);/*Q16 */
+ tmp = extract_h(L_shl(L_tmp, 13)); /*Q13 */
+ tmp = sub(fac_fx[1],tmp);/*Q13 */
+ L_tmp = L_mult(y_index[i],tmp);/*Q14 */
+ y_index[i] = extract_h(L_shl(L_tmp, 2));/*Q0 */
+ }
+ }
+ ELSE
+ {
+ FOR ( i = 0; i < band_num; i++ )
+ {
+ L_tmp = L_mult(i,factor_fx);/*Q16 */
+ tmp = extract_h(L_shl(L_tmp, 13)); /*Q13 */
+ tmp = sub(fac_fx[0],tmp);/*Q13 */
+ L_tmp = L_mult(y_index[i],tmp);/*Q14 */
+ y_index[i] = extract_h(L_shl(L_tmp, 2));/*Q0 */
+ }
+ }
+
+ /* bit allocation based on modified norm */
+ L_tmp = L_mult(band_num,24576);/*Q16 */
+ tmp = extract_h(L_shl(L_tmp,7));/*Q7 */
+ IF ( GE_16(shl(bit_band,7),tmp))
+ {
+ FOR ( j = 0; j < band_num; j++)
+ {
+ if ( y_index[j] < 0 )
+ {
+ y_index[j] = 0;
+ move16();
+ }
+ R_temp_fx[j] = 2097152;
+ move16();/*Q21 = 1 move16(); */
+ }
+
+ i = sub(band_num,1);
+ norm_sum = 0;/*Q0 */
+ FOR (k = 0; k <= i; k++)
+ {
+ norm_sum = add(norm_sum,y_index[k]);
+ }
+
+ FOR (j = 0; j < band_num; j++)
+ {
+ IF(norm_sum == 0)
+ {
+ FOR (k = 0; k <= i; k++)
+ {
+ R_temp_fx[k] = L_deposit_h(0);/*Q21 */
+ }
+ }
+ ELSE
+ {
+ exp = norm_s(norm_sum);
+ tmp = shl(norm_sum, exp);/*Q(exp) */
+ tmp = div_s(16384,tmp); /*Q(15+14-exp) */
+ Bits_avg_fx = L_mult(tmp, Bits);/*Q(30-exp) */
+
+ FOR (k = 0; k <= i; k++)
+ {
+ L_tmp = L_shl(L_deposit_l(y_index[k]),24);
+ L_tmp = Mult_32_32(Bits_avg_fx,L_tmp);/*Q(23-exp) */
+
+ R_temp_fx[k] = L_shl(L_tmp,sub(exp,2));
+ move32();/*Q21 */
+ }
+ }
+
+ L_tmp = L_shl(L_deposit_l(thr),21);/*Q21 */
+ IF ( LT_32(R_temp_fx[i],L_tmp))
+ {
+ R_temp_fx[i] = L_deposit_h(0);
+ norm_sum = sub(norm_sum,y_index[i]);
+ i--;
+ }
+ ELSE
+ {
+ BREAK;
+ }
+ }
+ }
+ ELSE
+ {
+ FOR ( j = 0; j < bit_band; j++ )
+ {
+ if ( y_index[j] < 0 )
+ {
+ y_index[j] = 0;
+ move16();
+ }
+ R_temp_fx[j] = 2097152;
+ move32();/*Q21 = 1 */
+ }
+
+ FOR ( j = bit_band; j < band_num; j++ )
+ {
+ R_temp_fx[j] = L_deposit_l(0);
+ }
+
+ norm_sum = 0;
+ FOR (k = 0; k < bit_band; k++)
+ {
+ norm_sum = add(norm_sum,y_index[k]);
+ }
+
+ i = bit_band;
+ FOR (j = 0; j < bit_band; j++)
+ {
+ IF(norm_sum == 0)
+ {
+ FOR (k = 0; k < i; k++)
+ {
+ R_temp_fx[k] = L_deposit_l(0); /*Q21 */
+ }
+ }
+ ELSE
+ {
+ exp = norm_s(norm_sum);
+ tmp = shl(norm_sum, exp);/*Q(exp) */
+ tmp = div_s(16384,tmp); /*Q(15+14-exp) */
+ Bits_avg_fx = L_mult(tmp, Bits);/*Q(30-exp) */
+ FOR (k = 0; k < i; k++)
+ {
+ L_tmp = L_shl(L_deposit_l(y_index[k]),24);
+ L_tmp = Mult_32_32(Bits_avg_fx,L_tmp);/*Q(23-exp) */
+
+ R_temp_fx[k] = L_shl(L_tmp,sub(exp,2));
+ move32();/*Q21 */
+ }
+ }
+ R_sum_fx = 0;
+ L_tmp = L_shl(L_deposit_l(thr),21);/*Q21 */
+ FOR (k = 0; k < i; k++)
+ {
+ IF (LT_32(R_temp_fx[k],L_tmp))
+ {
+ FOR(m = k; m < i; m++)
+ {
+ norm_sum = sub(norm_sum,y_index[m]);
+ R_temp_fx[m] = L_deposit_l(0); /*Q21 */
+ }
+ i = k;
+ BREAK;
+ }
+ ELSE
+ {
+ R_sum_fx = L_add(R_sum_fx,R_temp_fx[k]);
+ }
+ }
+ IF (EQ_32(R_sum_fx,R_sum_org_fx))
+ {
+ BREAK;
+ }
+
+ R_sum_org_fx = R_sum_fx;
+ }
+ }
+
+ /* index comeback */
+ FOR ( k = 0 ; k < band_num; k++ )
+ {
+ j = index[k];
+ move16();
+ Rsubband_fx[add(j,start_band)] = R_temp_fx[k];
+ move32();
+ }
+
+ return;
+
+}
+
+/*-------------------------------------------------------------------*
+ * BitAllocWB()
+ *
+ * WB bit allocation
+ *-------------------------------------------------------------------*/
+
+Word16 BitAllocWB_fx( /* o : t Q0*/
+ Word16 *y, /* i : norm of sub-vectors Q0*/
+ Word16 B, /* i : number of available bits Q0*/
+ Word16 N, /* i : number of sub-vectors Q0*/
+ Word16 *R, /* o : bit-allocation indicator Q0*/
+ Word16 *Rsubband_fx /* o : sub-band bit-allocation vector Q3*/
+)
+{
+ Word16 t_fx;
+ Word16 i, j, k, B1, B2, B3, B_saved;
+ Word16 Rsum_fx, Rsum_sub_fx[3];
+ Word32 Ravg_sub_32_fx[3], R_diff_32_fx[2];
+ Word16 factor_fx[2];/*Q13 */
+ Word16 BANDS;
+ Word16 tmp,exp;
+ Word16 Rsum_sub_fx_tmp=0; /* initialize just to avoid compiler warning */
+ Word32 L_tmp,L_tmp1;
+ Word32 Rsubband_buf[NB_SFM];
+
+ BANDS = N;
+ move16();
+ if( GT_16(BANDS,SFM_N))
+ {
+ BANDS = SFM_N;
+ move16();
+ }
+ /* Init Rsubband to non-zero values for bands to be allocated bits */
+ FOR (k = 0; k < BANDS; k++)
+ {
+ Rsubband_buf[k] = 2097152;
+ move32();/*Q21 */
+ }
+ /* Calculate the norm sum and average of sub-band */
+ Rsum_sub_fx[0] = 0;
+ move16();
+ FOR ( j = 0; j < SFM_G1; j++ )
+ {
+ if ( y[j] > 0 )
+ {
+ Rsum_sub_fx_tmp = add(Rsum_sub_fx[0],y[j]); /*Q0 */
+ }
+ if (y[j] > 0)
+ {
+ Rsum_sub_fx[0] = Rsum_sub_fx_tmp;
+ move16(); /*Q0 */
+ }
+ }
+ Ravg_sub_32_fx[0] = L_mult(Rsum_sub_fx[0], 2048);
+ move32();/*Q16 0+15+1 //q15 1/16 =2048 */
+
+ Rsum_sub_fx[1] = 0;
+ move16();
+ FOR ( j = SFM_G1; j < SFM_G1G2; j++ )
+ {
+ if ( y[j] > 0 )
+ {
+ Rsum_sub_fx_tmp = add(Rsum_sub_fx[1],y[j]); /*Q0 */
+ }
+ if ( y[j] > 0 )
+ {
+ Rsum_sub_fx[1] = Rsum_sub_fx_tmp;
+ move16();/*Q0 */
+ }
+ }
+ Ravg_sub_32_fx[1] = L_mult(Rsum_sub_fx[1], 4096); /*16 0+15+1 //q15 1/8 =4096 */
+
+ Rsum_sub_fx[2] = 0;
+ move16();
+ FOR ( j = SFM_G1G2; j < BANDS; j++ )
+ {
+ if ( y[j] > 0 )
+ {
+ Rsum_sub_fx_tmp = add(Rsum_sub_fx[2],y[j]); /*Q0 */
+ }
+ if ( y[j] > 0 )
+ {
+ Rsum_sub_fx[2] = Rsum_sub_fx_tmp;
+ move16();/*Q0 */
+ }
+ }
+ tmp = div_s(1, BANDS-SFM_G1G2); /*Q15 */
+ Ravg_sub_32_fx[2] = L_mult(Rsum_sub_fx[2], tmp);
+ move32();/*Q16 */
+
+ /* Bit allocation for every group */
+ tmp = add(Rsum_sub_fx[0],Rsum_sub_fx[1]);
+ Rsum_fx = add(tmp,Rsum_sub_fx[2]);/*Q0 */
+
+ factor_fx[0] = 16384;/*Q13 move16(); */
+ factor_fx[1] = 24576;/*Q13 move16(); */
+ {
+ R_diff_32_fx[0] = L_sub(Ravg_sub_32_fx[0], Ravg_sub_32_fx[1]);
+ move32();/*Q16 */
+ R_diff_32_fx[1] = L_sub(Ravg_sub_32_fx[1], Ravg_sub_32_fx[2]);
+ move32();/*Q16 */
+
+ test();
+ IF ( LT_32(R_diff_32_fx[0],393216)&<_32(R_diff_32_fx[1],245760))
+ {
+ IF(Rsum_fx == 0)
+ {
+ B1 = 0;
+ move16();
+ B2 = 0;
+ move16();
+ B3 = 0;
+ move16();
+ }
+ ELSE
+ {
+ exp = norm_s(Rsum_fx);
+ tmp = shl(Rsum_fx,exp);/*Q(exp) */
+ tmp = div_s(16384,tmp);/*Q(15+14-exp) */
+ L_tmp1 = L_mult(B,Rsum_sub_fx[0]);/*Q1 */
+ L_tmp = Mult_32_16(L_tmp1,tmp);/*Q(15-exp) */
+ B1 = extract_h(L_shl(L_tmp,add(exp,1)));/*Q0 */
+ test();
+ if(GT_32(L_tmp1,L_mult(B1,Rsum_fx))&&GE_32(L_tmp1,L_mult(add(B1,1),Rsum_fx)))
+ {
+ B1 = add(B1,1);
+ }
+ L_tmp1 = L_mult(B,Rsum_sub_fx[1]);/*Q1 */
+ L_tmp = Mult_32_16(L_tmp1,tmp);/*Q(15-exp) */
+ B2 = extract_h(L_shl(L_tmp,add(exp,1)));/*Q0 */
+ test();
+ if(GT_32(L_tmp1,L_mult(B2,Rsum_fx))&&GE_32(L_tmp1,L_mult(add(B2,1),Rsum_fx)))
+ {
+ B2 = add(B2,1);
+ }
+ L_tmp1 = L_mult(B,Rsum_sub_fx[2]);/*Q1 */
+ L_tmp = Mult_32_16(L_tmp1,tmp);/*Q(15-exp) */
+ B3 = extract_h(L_shl(L_tmp,add(exp,1)));/*Q0 */
+ test();
+ if(GT_32(L_tmp1,L_mult(B3,Rsum_fx))&&GE_32(L_tmp1,L_mult(add(B3,1),Rsum_fx)))
+ {
+ B3 = add(B3,1);
+ }
+ }
+ IF ( GT_32(Ravg_sub_32_fx[2],786432))
+ {
+ B_saved = 0;
+ move16();
+ IF ( GT_16(B1,288))
+ {
+ B_saved = sub(B1,288);
+ B1 = 288;
+ move16();
+ }
+
+ IF ( GT_16(B2,256))
+ {
+ tmp = sub(B2,256);
+ B_saved = add(B_saved,tmp);
+ B2 = 256;
+ move16();
+ }
+
+ IF ( GT_16(B3,96))
+ {
+ tmp = sub(B3,96);
+ B_saved = add(B_saved,tmp);
+ B3 = 96;
+ move16();
+ }
+
+ IF ( B_saved > 0 )
+ {
+ IF ( EQ_16(B1,288))
+ {
+ tmp = shr(B_saved,1);
+ B2 = add(B2,tmp);
+ tmp = sub(B,B1);
+ B3 = sub(tmp,B2);
+ }
+ ELSE
+ {
+ tmp = shr(B_saved,1);
+ B1 = add(B1,tmp);
+ IF ( EQ_16(B2,256))
+ {
+ tmp = sub(B,B1);
+ B3 = sub(tmp,B2);
+ }
+ ELSE
+ {
+ tmp = sub(B,B1);
+ B2 = sub(tmp,B3);
+ }
+ }
+ }
+ }
+
+ factor_fx[0] = 16384;
+ move16();/*Q13 */
+ factor_fx[1] = 12288;
+ move16();/*Q13 */
+ }
+ ELSE
+ {
+ IF(Rsum_fx == 0)
+ {
+ B1 = 0;
+ move16();
+ B2 = 0;
+ move16();
+ B3 = B;
+ move16();
+ }
+ ELSE
+ {
+ exp = norm_s(Rsum_fx);
+ tmp = shl(Rsum_fx,exp);/*Q(exp) */
+ tmp = div_s(16384,tmp);/*Q(15+14-exp) */
+ L_tmp1 = L_mult(B,Rsum_sub_fx[0]);/*Q1 */
+ L_tmp = Mult_32_16(L_tmp1,tmp);/*Q(15-exp) */
+ B1 = extract_h(L_shl(L_tmp,add(exp,1)));/*Q0 */
+ test();
+ if(GT_32(L_tmp1,L_mult(B1,Rsum_fx))&&GE_32(L_tmp1,L_mult(add(B1,1),Rsum_fx)))
+ {
+ B1 = add(B1,1);
+ }
+ L_tmp1 = Mult_32_16(1975684956,shl(B,5));/*Q(31+5-15=21) */
+ L_tmp1 = Mult_32_16(L_tmp1,shl(Rsum_sub_fx[1],7));/*Q(21+7-15=13) */
+ L_tmp = Mult_32_16(L_tmp1,tmp);/*Q(27-exp) */
+ B2 = extract_h(L_shl(L_tmp,sub(exp,11)));/*Q0 */
+ test();
+ if(GT_32(L_tmp1,L_shl(L_mult(B2,Rsum_fx),12))&&GE_32(L_add(L_tmp1,2),L_shl(L_mult(add(B2,1),Rsum_fx),12)))
+ {
+ B2 = add(B2,1);
+ }
+ tmp = sub(B,B1);
+ B3 = sub(tmp,B2);
+ }
+ }
+ }
+
+ IF ( LT_16(Rsum_sub_fx[2],3))
+ {
+ B2 = add(B2,B3);
+ B3 = 0;
+ move16();
+ }
+
+ /* Bit allocation in group */
+ Bit_group_fx( y, 0, SFM_G1, B1, 5, Rsubband_buf, factor_fx);
+ Bit_group_fx( y, SFM_G1, SFM_G1G2, B2, 6, Rsubband_buf, factor_fx);
+ Bit_group_fx( y, SFM_G1G2, BANDS, B3, 7, Rsubband_buf, factor_fx);
+ FOR (i = 0; i < BANDS; i++)
+ {
+ Rsubband_fx[i] = extract_l(L_shr(Rsubband_buf[i], 18));
+ }
+
+ /* Calcuate total used bits and initialize R to be used for Noise Filling */
+ L_tmp = L_deposit_l(0);
+ FOR( i = 0; i < N; i++)
+ {
+ L_tmp = L_add(L_tmp,Rsubband_buf[i]);/*Q21 */
+ R[i] = extract_h(L_shr(Rsubband_buf[i],5));/*Q0 */
+ }
+ t_fx = extract_h(L_shr(L_tmp, 5)); /*Q0 */
+
+ return (Word16)t_fx;
+
+}
diff --git a/lib_com/bitallocsum_fx.c b/lib_com/bitallocsum_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..cb8cf09a15ef902c3f9f7e38a78cbd7d3a36f164
--- /dev/null
+++ b/lib_com/bitallocsum_fx.c
@@ -0,0 +1,63 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h" /* Common constants */
+
+/*--------------------------------------------------------------------------
+ * bitallocsum_fx()
+ *
+ * Calculate the total number of bits allocated over frame
+ *--------------------------------------------------------------------------*/
+void bitallocsum_fx(
+ Word16 *R, /* i : bit-allocation vector Q0 */
+ const Word16 nb_sfm, /* i : number of sub-vectors Q0 */
+ Word16 *sum, /* o : total number of bits allocated Q0 */
+ Word16 *Rsubband, /* o : rate per subband Q3 */
+ const Word16 v, /* i : bit rate Q0 */
+ const Word16 length, /* i : length of spectrum (32 or 48 kHz samplerate) Q0 */
+ const Word16 *sfmsize /* i : band length Q0 */
+)
+{
+ Word16 i;
+ Word16 total, tmp;
+ Word16 diff;
+
+ total = (Word16)0;
+ move16();
+ FOR (i = 0; i < nb_sfm; i++)
+ {
+ tmp = extract_l(L_mult0(R[i], sfmsize[i]));
+ Rsubband[i] = shl(tmp, 3);
+ move16();
+ total = add(total, tmp);
+ }
+ *sum = total;
+
+ IF ( LE_16(length, L_FRAME32k))
+ {
+ diff = sub(v, *sum);
+ i = (Word16)0;
+ move16();
+ WHILE ( diff > 0 )
+ {
+ IF ( R[i] > 0 )
+ {
+ Rsubband[i] = add(Rsubband[i], 8);
+ move16();
+ diff = sub(diff, 1);
+ *sum = add(*sum, 1);
+ }
+ i = add(i, 1);
+ if ( GE_16(i, nb_sfm))
+ {
+ i = (Word16)0;
+ move16();
+ }
+ }
+ }
+ return;
+}
diff --git a/lib_com/bits_alloc.c b/lib_com/bits_alloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..69b71c6b49ee344f997da4b8af16d08268461463
--- /dev/null
+++ b/lib_com/bits_alloc.c
@@ -0,0 +1,384 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include
+#include "options.h"
+#include "prot_fx.h"
+#include "basop_util.h"
+#include "stl.h"
+#include "options.h"
+#include "rom_com_fx.h"
+
+
+/*
+ * function BITS_ALLOC_init_config_acelp()
+ *
+ * description: initial configuration for ACELP
+ *
+ * return: void
+ */
+void BITS_ALLOC_init_config_acelp(
+ const Word32 bit_rate,
+ const Word8 narrowBand,
+ const Word16 nb_subfr,
+ ACELP_config *pConfigAcelp /*o: configuration structure of ACELP*/
+)
+{
+ Word8 rate_mode_index;
+
+
+ move16();
+ move16();
+ move16();
+ rate_mode_index=(bit_rate > ACELP_9k60);
+
+ pConfigAcelp->mode_index=rate_mode_index;
+
+
+ /*LPC: midLpc should be swithced off?*/
+ pConfigAcelp->midLpc_enable = 1;
+ move16();
+
+ /*ACELP ICB config*/
+ test();
+ IF( (rate_mode_index==0) || narrowBand != 0 )
+ {
+ move16();
+ move16();
+ move16();
+ move16();
+ move16();
+ move16();
+ pConfigAcelp->pre_emphasis = 1;
+ pConfigAcelp->formant_enh = 1;
+ pConfigAcelp->formant_enh_num = FORMANT_SHARPENING_G1;
+ pConfigAcelp->formant_enh_den = FORMANT_SHARPENING_G2;
+ pConfigAcelp->formant_tilt = 0;
+ pConfigAcelp->voice_tilt = 0;
+ }
+ ELSE
+ {
+ move16();
+ move16();
+ move16();
+ move16();
+ move16();
+ move16();
+ pConfigAcelp->pre_emphasis = 0;
+ pConfigAcelp->formant_enh = 1;
+ pConfigAcelp->formant_enh_num = FORMANT_SHARPENING_G1;
+ pConfigAcelp->formant_enh_den = FORMANT_SHARPENING_G2;
+ pConfigAcelp->formant_tilt = 1;
+ pConfigAcelp->voice_tilt = 1;
+ }
+
+ /*Wide band @ 16kHz*/
+ IF ( EQ_16(nb_subfr,NB_SUBFR16k))
+ {
+ move16();
+ move16();
+ move16();
+ move16();
+ move16();
+ move16();
+ pConfigAcelp->pre_emphasis = 1;
+ pConfigAcelp->formant_enh = 1;
+ pConfigAcelp->formant_enh_num = FORMANT_SHARPENING_G1_16k;
+ pConfigAcelp->formant_enh_den = FORMANT_SHARPENING_G2_16k;
+ pConfigAcelp->formant_tilt = 0;
+ pConfigAcelp->voice_tilt = 2;
+ }
+
+}
+
+
+/*
+ * function BITS_ALLOC_config_acelp()
+ *
+ * description: configure all acelp modes and allocate the bits
+ *
+ * return: bit demand
+ */
+Word16 BITS_ALLOC_config_acelp(
+ const Word16 bits_frame, /*i: remaining bit budget for the frame*/
+ const Word16 coder_type, /*i: acelp coder type*/
+ ACELP_config *pConfigAcelp, /*i/o: configuration structure of ACELP*/
+ const Word16 narrowBand,
+ const Word16 nb_subfr
+)
+{
+ Word16 mode_index;
+ Word16 band_index;
+ Word16 i;
+ Word16 remaining_bits, bits;
+
+
+
+ move16();
+ move16();
+ move16();
+ mode_index = pConfigAcelp->mode_index;
+ band_index = (narrowBand==0);
+ bits=0;
+
+ IF ( band_index==0 )
+ {
+ move16();
+ pConfigAcelp->formant_enh = 1;
+ if(EQ_16(coder_type,INACTIVE))
+ {
+ move16();
+ pConfigAcelp->formant_enh = 0;
+ }
+ }
+
+ IF ( s_and((Word16)EQ_16(band_index,1),(Word16)EQ_16(nb_subfr,4)))
+ {
+ IF(EQ_16(coder_type,INACTIVE))
+ {
+ pConfigAcelp->pre_emphasis = 0;
+ move16();
+ pConfigAcelp->formant_enh = 0;
+ move16();
+ pConfigAcelp->formant_enh_num = FORMANT_SHARPENING_G1_16k;
+ move16();
+ pConfigAcelp->voice_tilt = 1;
+ move16();
+ pConfigAcelp->formant_tilt = 1;
+ move16();
+ }
+ ELSE
+ {
+ pConfigAcelp->pre_emphasis = 1;
+ move16();
+ pConfigAcelp->formant_enh = 1;
+ move16();
+ pConfigAcelp->formant_enh_num = FORMANT_SHARPENING_G1;
+ move16();
+ pConfigAcelp->voice_tilt = 0;
+ move16();
+ pConfigAcelp->formant_tilt = 0;
+ move16();
+ }
+ }
+ IF (EQ_16(coder_type,UNVOICED))
+ {
+ IF(EQ_16(ACELP_GAINS_MODE[mode_index][band_index][coder_type], 6))
+ {
+ pConfigAcelp->pitch_sharpening = 0;
+ move16();
+ pConfigAcelp->phase_scrambling = 1;
+ move16();
+ }
+ ELSE
+ {
+ pConfigAcelp->pitch_sharpening = 0;
+ move16();
+ pConfigAcelp->phase_scrambling = 0;
+ move16();
+ }
+ }
+ ELSE
+ {
+ pConfigAcelp->pitch_sharpening = 1;
+ move16();
+ pConfigAcelp->phase_scrambling = 0;
+ move16();
+ }
+
+ IF(GT_16(coder_type,ACELP_MODE_MAX)) /* keep pitch sharpening for RF_ALLPRED mode */
+ {
+ pConfigAcelp->pitch_sharpening = 0;
+ pConfigAcelp->phase_scrambling = 0;
+ }
+
+ /*Allocate bits and different modes*/
+ move16();
+ pConfigAcelp->bpf_mode=ACELP_BPF_MODE[mode_index][band_index][coder_type];
+ bits = add(bits, ACELP_BPF_BITS[pConfigAcelp->bpf_mode]);
+
+ move16();
+ move16();
+ pConfigAcelp->nrg_mode=ACELP_NRG_MODE[mode_index][band_index][coder_type];
+ pConfigAcelp->nrg_bits=ACELP_NRG_BITS[pConfigAcelp->nrg_mode];
+ bits = add(bits, pConfigAcelp->nrg_bits);
+
+ move16();
+ pConfigAcelp->ltp_mode=ACELP_LTP_MODE[mode_index][band_index][coder_type];
+
+ move16();
+ pConfigAcelp->ltp_bits=0;
+
+ move16();
+ pConfigAcelp->ltf_mode=ACELP_LTF_MODE[mode_index][band_index][coder_type];
+
+ move16();
+ pConfigAcelp->ltf_bits=ACELP_LTF_BITS[pConfigAcelp->ltf_mode];
+ if ( s_and((Word16)EQ_16(nb_subfr,5),(Word16)EQ_16(pConfigAcelp->ltf_bits,4)))
+ {
+ pConfigAcelp->ltf_bits = add(pConfigAcelp->ltf_bits,1);
+ }
+ bits = add(bits,pConfigAcelp->ltf_bits);
+
+
+ FOR ( i=0; igains_mode[i] = ACELP_GAINS_MODE[mode_index][band_index][coder_type];
+ move16();
+
+ /* skip subframe 1, 3 gain encoding, and use from subframe 0, and 3, respectively */
+ test();
+ test();
+ IF(GE_16(coder_type,ACELP_MODE_MAX)&&(EQ_16(i,1)||EQ_16(i,3)))
+ {
+ pConfigAcelp->gains_mode[i] = 0;
+ }
+
+ bits = add(bits, ACELP_GAINS_BITS[pConfigAcelp->gains_mode[i]]);
+
+ move16();
+ bits = add(bits, ACELP_LTP_BITS_SFR[pConfigAcelp->ltp_mode][i]);
+ pConfigAcelp->ltp_bits= add( pConfigAcelp->ltp_bits,ACELP_LTP_BITS_SFR[pConfigAcelp->ltp_mode][i]);
+ }
+
+ /*Innovation*/
+
+ if ( LT_16(bits_frame,bits))
+ {
+ printf("Warning: bits per frame too low\n");
+ return -1;
+ }
+
+ IF( EQ_16(coder_type,RF_ALLPRED))
+ {
+ set16_fx(pConfigAcelp->fixed_cdk_index, -1, nb_subfr);
+ }
+ ELSE IF ( EQ_16(coder_type,RF_GENPRED))
+ {
+ pConfigAcelp->fixed_cdk_index[0] = 0; /* 7 bits */
+ pConfigAcelp->fixed_cdk_index[1] = -1;
+ pConfigAcelp->fixed_cdk_index[2] = 0; /* 7 bits */
+ pConfigAcelp->fixed_cdk_index[3] = -1;
+ pConfigAcelp->fixed_cdk_index[4] = -1;
+ bits = add(bits,14);
+ }
+ ELSE IF( EQ_16(coder_type,RF_NOPRED))
+ {
+ set16_fx(pConfigAcelp->fixed_cdk_index, 0, nb_subfr);
+ bits = add(bits,28);
+ }
+ ELSE
+ {
+ bits = add(bits, BITS_ALLOC_adjust_acelp_fixed_cdk(sub(bits_frame,bits), pConfigAcelp->fixed_cdk_index, nb_subfr ));
+ }
+
+ remaining_bits = sub(bits_frame, bits);
+
+ /*Sanity check*/
+ if (remaining_bits<0)
+ {
+ move16();
+ bits = -1;
+ }
+
+
+ return(bits);
+}
+
+
+static
+Word16 BITS_ALLOC_adjust_generic(
+ const Word16 bits_frame, /*i: bit budget*/
+ Word16 *fixed_cdk_index,
+ const Word16 nb_subfr,
+ const Word16 *pulseconfigbits,
+ const Word16 pulseconfig_size
+)
+{
+ Word16 bits_subframe2, inb_subfr;
+ Word16 sfr, k, bitsused, bits_currsubframe;
+
+ bits_subframe2 = bits_frame;
+ move16();
+ inb_subfr = 8192/*1.0f/NB_SUBFR Q15*/;
+ move16();
+ if ( EQ_16(nb_subfr,NB_SUBFR16k))
+ {
+ inb_subfr = 6554/*1.0f/NB_SUBFR16k Q15*/;
+ move16();
+ }
+
+ IF ( LT_16(bits_subframe2, i_mult2(pulseconfigbits[0], nb_subfr))) /* not in final code - not instrumented */
+ {
+ return add(bits_frame,1); /* Not enough bits for lowest mode. -> trigger alarm*/
+ }
+
+ /* search cdk-index for first subframe */
+ FOR (k=0; k bits_subframe2)
+ {
+ k = sub(k,1); /* previous mode did not exceed bit-budget */
+ BREAK;
+ }
+ }
+
+ if (i_mult2(pulseconfigbits[k], nb_subfr) > bits_subframe2)
+ {
+ k = sub(k,1); /* previous mode did not exceed bit-budget */
+ }
+
+ move16();
+ fixed_cdk_index[0] = k;
+ bitsused = i_mult2(pulseconfigbits[k], nb_subfr);
+
+ FOR (sfr=1; sfr < nb_subfr; sfr++)
+ {
+ /*bits_currsubframe = (int)(((float)sfr+1.0f)*bits_subframe) - bitsused;*/
+ bits_currsubframe = sub(add(i_mult2(sfr, bits_subframe2), bits_subframe2), bitsused);
+
+ /* try increasing mode while below threshold */
+ WHILE ( (LT_16(k, pulseconfig_size-1))&&(LE_16(i_mult2(pulseconfigbits[add(k,1)],nb_subfr),bits_currsubframe)))
+ {
+ test();
+ k = add(k,1);
+ }
+
+ /* try decreasing mode until below threshold */
+ WHILE (i_mult2(pulseconfigbits[k], nb_subfr) > bits_currsubframe)
+ {
+ k = sub(k,1);
+
+ IF (k == 0)
+ {
+ BREAK;
+ }
+ }
+
+ /* store mode */
+ move16();
+ fixed_cdk_index[sfr] = k;
+ bitsused = add(bitsused, i_mult2(pulseconfigbits[k], nb_subfr));
+ }
+
+ return mult_r(bitsused, inb_subfr);
+}
+
+Word16 BITS_ALLOC_adjust_acelp_fixed_cdk(
+ const Word16 bits_frame, /*i: bit budget*/
+ Word16 *fixed_cdk_index,
+ const Word16 nb_subfr
+)
+{
+ Word16 bitsused;
+
+
+ bitsused = BITS_ALLOC_adjust_generic(bits_frame, fixed_cdk_index, nb_subfr, ACELP_CDK_BITS, ACELP_FIXED_CDK_NB);
+
+
+ return bitsused;
+}
+
diff --git a/lib_com/bitstream_fx.c b/lib_com/bitstream_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..c734eb4ceac70c80e02ddcbe1a558e8068dc2fdb
--- /dev/null
+++ b/lib_com/bitstream_fx.c
@@ -0,0 +1,2589 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include
+#include "stl.h"
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "options.h"
+#include "basop_util.h"
+#include "rom_com_fx.h"
+#include "mime.h"
+#ifdef DEBUGGING
+ /*-------------------------------------------------------------------*
+ * Global variables
+ *--------------------------------------------------------------------*/
+
+int16_t FEC_seed = 12558; /* Seed for random FEC generator */
+float FEC_random = 0; /* FEC rate in percent (for simulation of FEC) */
+FILE* FEC_pattern = NULL; /* FEC pattern file (for simulation of FEC) */
+/*-------------------------------------------------------------------*
+ * file_read_FECpattern()
+ *
+ * Simulate packet losses by reading FEC pattern from external file
+ *-------------------------------------------------------------------*/
+
+static int16_t file_read_FECpattern(void)
+{
+ int16_t bfi = 0;
+
+ /* FEC pattern file provided */
+ if (FEC_pattern != NULL)
+ {
+ int16_t tmp = 0;
+ if (fread(&tmp, sizeof(int16_t), 1, FEC_pattern) != 1)
+ {
+ if (feof(FEC_pattern) != 0)
+ {
+ tmp = 0;
+ fseek(FEC_pattern, 0L, SEEK_SET);
+ }
+ else
+ {
+ fprintf(stderr, "\nError reading the FEC pattern file !");
+ exit(-1);
+ }
+ }
+
+ if (tmp == 2609 || tmp == 1 || tmp == SYNC_BAD_FRAME)
+ {
+ bfi = 1;
+ }
+ else
+ {
+ bfi = 0;
+ }
+ }
+
+ /* random FEC simulation requested */
+ else if (FEC_random > 0)
+ {
+ float ftmp = (float)/*own_random*/Random(&FEC_seed) + 32768.0f;
+ if (ftmp <= FEC_random / 100.0f * 65535.0f)
+ {
+ bfi = 1;
+ }
+ else
+ {
+ bfi = 0;
+ }
+ }
+
+ return bfi;
+}
+#endif
+/*-------------------------------------------------------------------*
+* pack_bit()
+*
+* insert a bit into packed octet
+*-------------------------------------------------------------------*/
+static void pack_bit(
+ const Word16 bit, /* i: bit to be packed */
+ UWord8 **pt, /* i/o: pointer to octet array into which bit will be placed */
+ UWord8 *omask /* i/o: output mask to indicate where in the octet the bit is to be written */
+)
+{
+ if (*omask == 0x80)
+ {
+ **pt = 0;
+ }
+ if (bit != 0)
+ {
+ **pt = **pt | *omask;
+ }
+ *omask >>= 1;
+ if (*omask == 0)
+ {
+ *omask = 0x80;
+ (*pt)++;
+ }
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+* unpack_bit()
+*
+* unpack a bit from packed octet
+*-------------------------------------------------------------------*/
+static Word16 unpack_bit(
+ UWord8 **pt, /* i/o: pointer to octet array from which bit will be read */
+ UWord8 *mask /* i/o: mask to indicate the bit in the octet */
+)
+{
+ Word16 bit;
+
+ bit = (**pt & *mask) != 0;
+ *mask >>= 1;
+ if (*mask == 0)
+ {
+ *mask = 0x80;
+ (*pt)++;
+ }
+ return bit;
+}
+
+/*-------------------------------------------------------------------*
+* rate2AMRWB_IOmode()
+*
+* lookup AMRWB IO mode
+*-------------------------------------------------------------------*/
+static Word16 rate2AMRWB_IOmode(
+ Word32 rate /* i: bit rate */
+)
+{
+ switch ( rate )
+ {
+ /* EVS AMR-WB IO modes */
+ case SID_1k75 :
+ return AMRWB_IO_SID;
+ case ACELP_6k60 :
+ return AMRWB_IO_6600;
+ case ACELP_8k85 :
+ return AMRWB_IO_8850;
+ case ACELP_12k65 :
+ return AMRWB_IO_1265;
+ case ACELP_14k25 :
+ return AMRWB_IO_1425;
+ case ACELP_15k85 :
+ return AMRWB_IO_1585;
+ case ACELP_18k25 :
+ return AMRWB_IO_1825;
+ case ACELP_19k85 :
+ return AMRWB_IO_1985;
+ case ACELP_23k05 :
+ return AMRWB_IO_2305;
+ case ACELP_23k85 :
+ return AMRWB_IO_2385;
+ default:
+ return -1;
+ }
+}
+
+/*-------------------------------------------------------------------*
+* rate2EVSmode()
+*
+* lookup EVS mode
+*-------------------------------------------------------------------*/
+static Word16 rate2EVSmode(
+ Word32 rate /* i: bit rate */
+)
+{
+ switch ( rate )
+ {
+ /* EVS Primary modes */
+ case FRAME_NO_DATA :
+ return NO_DATA_TYPE;
+ case SID_2k40 :
+ return PRIMARY_SID;
+ case PPP_NELP_2k80 :
+ return PRIMARY_2800;
+ case ACELP_7k20 :
+ return PRIMARY_7200;
+ case ACELP_8k00 :
+ return PRIMARY_8000;
+ case ACELP_9k60 :
+ return PRIMARY_9600;
+ case ACELP_13k20 :
+ return PRIMARY_13200;
+ case ACELP_16k40 :
+ return PRIMARY_16400;
+ case ACELP_24k40 :
+ return PRIMARY_24400;
+ case ACELP_32k :
+ return PRIMARY_32000;
+ case ACELP_48k :
+ return PRIMARY_48000;
+ case ACELP_64k :
+ return PRIMARY_64000;
+ case HQ_96k :
+ return PRIMARY_96000;
+ case HQ_128k :
+ return PRIMARY_128000;
+ default :
+ return rate2AMRWB_IOmode(rate);
+ }
+}
+
+/*-------------------------------------------------------------------*
+ * push_indice_fx( )
+ *
+ * Push a new indice into the buffer
+ *-------------------------------------------------------------------*/
+
+void push_indice_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 id, /* i : ID of the indice */
+ UWord16 value, /* i : value of the quantized indice */
+ Word16 nb_bits /* i : number of bits used to quantize the indice */
+)
+{
+ Word16 i;
+
+
+ IF ( EQ_16(st_fx->last_ind_fx, id))
+ {
+ /* indice with the same name as the previous one */
+ i = st_fx->next_ind_fx;
+ }
+ ELSE
+ {
+ /* new indice - find an empty slot in the list */
+ i = id;
+ move16();
+ WHILE (NE_16(st_fx->ind_list_fx[i].nb_bits, -1))
+ {
+ i = add(i, 1);
+ }
+ }
+
+ /* store the values in the list */
+ st_fx->ind_list_fx[i].value = value;
+ move16();
+ st_fx->ind_list_fx[i].nb_bits = nb_bits;
+ move16();
+
+ /* updates */
+ st_fx->next_ind_fx = add(i, 1);
+ st_fx->last_ind_fx = id;
+ move16();
+ st_fx->nb_bits_tot_fx = add(st_fx->nb_bits_tot_fx, nb_bits);
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * push_next_indice_fx() *
+ * Push a new indice into the buffer at the next position
+ *-------------------------------------------------------------------*/
+
+void push_next_indice_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ UWord16 value, /* i : value of the quantized indice */
+ Word16 nb_bits /* i : number of bits used to quantize the indice */
+)
+{
+
+ /* store the values in the list */
+ st_fx->ind_list_fx[st_fx->next_ind_fx].value = value;
+ move16();
+ st_fx->ind_list_fx[st_fx->next_ind_fx].nb_bits = nb_bits;
+ move16();
+ st_fx->next_ind_fx = add(st_fx->next_ind_fx, 1);
+
+
+ /* update the total number of bits already written */
+ st_fx->nb_bits_tot_fx = add(st_fx->nb_bits_tot_fx, nb_bits);
+
+ return;
+}
+
+
+/*-------------------------------------------------------------------*
+ * push_next_bits_fx()
+ * Push a bit buffer into the buffer at the next position
+ *-------------------------------------------------------------------*/
+
+void push_next_bits_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 bits[], /* i : bit buffer to pack, sequence of single bits */
+ Word16 nb_bits /* i : number of bits to pack */
+)
+{
+ UWord16 code;
+ Word16 i, nb_bits_m15;
+ Indice_fx *ptr;
+
+ ptr = &st_fx->ind_list_fx[st_fx->next_ind_fx];
+ nb_bits_m15 = sub(nb_bits, 15);
+ i = 0;
+ move16();
+ IF (nb_bits_m15 > 0)
+ {
+ FOR (; ivalue = code;
+ move16();
+ ptr->nb_bits = 16;
+ move16();
+ ++ptr;
+ }
+ }
+ IF (LT_16(i, nb_bits))
+ {
+ FOR (; ivalue = bits[i];
+ move16();
+ ptr->nb_bits = 1;
+ move16();
+ ++ptr;
+ }
+ }
+ st_fx->next_ind_fx = (Word16)(ptr - st_fx->ind_list_fx);
+ st_fx->nb_bits_tot_fx = add(st_fx->nb_bits_tot_fx, nb_bits);
+}
+
+/*-------------------------------------------------------------------*
+ * get_next_indice_fx( )
+ *
+ * Get the next indice from the buffer
+ *-------------------------------------------------------------------*/
+
+UWord16 get_next_indice_fx( /* o : value of the indice */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 nb_bits /* i : number of bits that were used to quantize the indice */
+)
+{
+ UWord16 value;
+ Word16 i;
+
+ assert(nb_bits <= 16);
+ value = 0;
+ move16();
+
+ /* detect corrupted bitstream */
+ IF( GT_16(add(st_fx->next_bit_pos_fx,nb_bits),st_fx->total_num_bits))
+ {
+ st_fx->BER_detect = 1;
+ move16();
+ return(0);
+ }
+
+ FOR (i = 0; i < nb_bits; i++)
+ {
+ value = lshl(value, 1);
+ value = add(value, st_fx->bit_stream_fx[st_fx->next_bit_pos_fx+i]);
+ }
+
+ /* update the position in the bitstream */
+ st_fx->next_bit_pos_fx = add(st_fx->next_bit_pos_fx, nb_bits);
+ return value;
+}
+
+/*-------------------------------------------------------------------*
+ * get_next_indice_1_fx( )
+ *
+ * Get the next 1-bit indice from the buffer
+ *-------------------------------------------------------------------*/
+
+UWord16 get_next_indice_1_fx( /* o : value of the indice */
+ Decoder_State_fx *st_fx /* i/o: decoder state structure */
+)
+{
+ /* detect corrupted bitstream */
+ test();
+ test();
+ test();
+ IF( ( GT_16(add(st_fx->next_bit_pos_fx,1),st_fx->total_num_bits)&&EQ_16(st_fx->codec_mode,MODE1))||
+ ( GT_16(add(st_fx->next_bit_pos_fx,1),add(st_fx->total_num_bits,2*8)) && EQ_16(st_fx->codec_mode,MODE2)) /* add two zero bytes for arithmetic coder flush */
+ )
+ {
+ st_fx->BER_detect = 1;
+ move16();
+ return(0);
+ }
+
+ return st_fx->bit_stream_fx[st_fx->next_bit_pos_fx++];
+}
+
+/*-------------------------------------------------------------------*
+ * get_next_indice_tmp()
+ *
+ * update the total number of bits and the position in the bitstream
+ *-------------------------------------------------------------------*/
+
+void get_next_indice_tmp_fx(
+ Decoder_State_fx *st_fx, /* o : decoder state structure */
+ Word16 nb_bits /* i : number of bits that were used to quantize the indice */
+)
+{
+ /* update the position in the bitstream */
+ st_fx->next_bit_pos_fx = add(st_fx->next_bit_pos_fx, nb_bits);
+}
+
+/*-------------------------------------------------------------------*
+ * get_indice_fx( )
+ *
+ * Get indice at specific position in the buffer
+ *-------------------------------------------------------------------*/
+
+UWord16 get_indice_fx( /* o : value of the indice */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 pos, /* i : absolute position in the bitstream (update after the read) */
+ Word16 nb_bits /* i : number of bits that were used to quantize the indice */
+)
+{
+ UWord16 value;
+ Word16 i;
+
+ assert(nb_bits <= 16);
+
+ /* detect corrupted bitstream */
+ IF( GT_16(add(pos,nb_bits),st_fx->total_num_bits))
+ {
+ st_fx->BER_detect = 1;
+ move16();
+ return(0);
+ }
+
+ value = 0;
+ move16();
+ FOR (i = 0; i < nb_bits; i++)
+ {
+ value = lshl(value, 1);
+ value = add(value, st_fx->bit_stream_fx[pos+i]);
+ }
+
+ return value;
+}
+
+/*-------------------------------------------------------------------*
+ * get_indice_1_fx( )
+ *
+ * Get a 1-bit indice at specific position in the buffer
+ *-------------------------------------------------------------------*/
+
+UWord16 get_indice_1_fx( /* o : value of the indice */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 pos /* i : absolute position in the bitstream (update after the read) */
+)
+{
+ /* detect corrupted bitstream */
+ IF( GT_16(add(pos,1),st_fx->total_num_bits))
+ {
+ st_fx->BER_detect = 1;
+ move16();
+ return(0);
+ }
+
+ return st_fx->bit_stream_fx[pos];
+}
+
+/*-------------------------------------------------------------------*
+ * reset_indices_enc_fx()
+ *
+ * Reset the buffer of indices
+ *-------------------------------------------------------------------*/
+
+void reset_indices_enc_fx(
+ Encoder_State_fx *st_fx
+)
+{
+ Word16 i;
+
+ st_fx->nb_bits_tot_fx = 0;
+ move16();
+ st_fx->next_ind_fx = 0;
+ move16();
+ st_fx->last_ind_fx = -1;
+ move16();
+
+ FOR (i=0; iind_list_fx[i].nb_bits = -1;
+ move16();
+ }
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * reset_indices_dec_fx()
+ *
+ * Reset the buffer of decoder indices
+ *-------------------------------------------------------------------*/
+
+void reset_indices_dec_fx(
+ Decoder_State_fx *st_fx
+)
+{
+ st_fx->next_bit_pos_fx = 0;
+ move16();
+
+ return;
+}
+
+
+/*-------------------------------------------------------------------*
+ * write_indices_fx()
+ *
+ * Write the buffer of indices to a file
+ *-------------------------------------------------------------------*/
+
+void write_indices_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ FILE *file /* i : output bitstream file */
+ , UWord8 *pFrame, /* i: byte array with bit packet and byte aligned coded speech data */
+ Word16 pFrame_size /* i: size of the binary encoded access unit [bits] */
+)
+{
+ Word16 i, k;
+ Word16 stream[2+MAX_BITS_PER_FRAME], *pt_stream;
+ Word32 mask;
+ UWord8 header;
+
+ if( st_fx->bitstreamformat == G192 )
+ {
+ /*-----------------------------------------------------------------*
+ * Encode Sync Header and Frame Length
+ *-----------------------------------------------------------------*/
+ pt_stream = stream;
+ for (i=0; i<(2 + MAX_BITS_PER_FRAME); ++i)
+ {
+ stream[i] = 0;
+ }
+ *pt_stream++ = (Word16)SYNC_GOOD_FRAME;
+ *pt_stream++ = st_fx->nb_bits_tot_fx;
+
+ /*----------------------------------------------------------------*
+ * Bitstream packing (conversion of individual indices into a serial stream)
+ * Writing the serial stream into file
+ *----------------------------------------------------------------*/
+
+ for (i=0; iind_list_fx[i].nb_bits != -1)
+ {
+ /* mask from MSB to LSB */
+ mask = 1 << (st_fx->ind_list_fx[i].nb_bits - 1);
+
+ /* write bit by bit */
+ for (k=0; k < st_fx->ind_list_fx[i].nb_bits; k++)
+ {
+ if ( st_fx->ind_list_fx[i].value & mask )
+ {
+ *pt_stream++ = G192_BIN1;
+ }
+ else
+ {
+ *pt_stream++ = G192_BIN0;
+ }
+
+ mask >>= 1;
+ }
+ }
+ }
+
+ }
+ else
+ {
+ /* Create and write ToC header */
+ /* qbit always set to 1 on encoder side for AMRWBIO , no qbit in use for EVS, but set to 0(bad) */
+ header = (UWord8)(st_fx->Opt_AMR_WB_fx << 5 | st_fx->Opt_AMR_WB_fx << 4 | rate2EVSmode(st_fx->nb_bits_tot_fx * 50));
+ fwrite( &header, sizeof(UWord8), 1, file );
+ /* Write speech bits */
+ fwrite( pFrame, sizeof(UWord8), (pFrame_size + 7)>>3, file );
+ }
+
+ /* Clearing of indices */
+ FOR (i=0; iind_list_fx[i].nb_bits = -1;
+ move16();
+ }
+
+
+ if( st_fx->bitstreamformat == G192 )
+ {
+ /* write the serial stream into file */
+ fwrite( stream, sizeof(unsigned short), 2+stream[1], file );
+ }
+ /* reset index pointers */
+ st_fx->nb_bits_tot_fx = 0;
+ st_fx->next_ind_fx = 0;
+ st_fx->last_ind_fx = -1;
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * indices_to_serial()
+ *
+ * pack indices into serialized payload format
+ *-------------------------------------------------------------------*/
+
+void indices_to_serial(
+ const Encoder_State_fx *st_fx, /* i: encoder state structure */
+ UWord8 *pFrame, /* o: byte array with bit packet and byte aligned coded speech data */
+ Word16 *pFrame_size /* o: size of the binary encoded access unit [bits] */
+)
+{
+ Word16 i, k, j;
+ Word16 cmi = 0, core_mode=0;
+ Word32 mask;
+ Word16 amrwb_bits[(ACELP_23k85 / 50)];
+ UWord8 omask= 0x80;
+ UWord8 *pt_pFrame=pFrame;
+
+ if ( st_fx->Opt_AMR_WB_fx )
+ {
+ cmi = rate2EVSmode(st_fx->total_brate_fx);
+ core_mode = rate2EVSmode(st_fx->nb_bits_tot_fx * 50);
+
+ j=0;
+ for (i=0; iind_list_fx[i].nb_bits != -1)
+ {
+ /* mask from MSB to LSB */
+ mask = 1 << (st_fx->ind_list_fx[i].nb_bits - 1);
+
+ /* temporarily save bit */
+ for (k=0; k < st_fx->ind_list_fx[i].nb_bits; k++)
+ {
+ amrwb_bits[j++] = (st_fx->ind_list_fx[i].value & mask) > 0;
+ mask >>= 1;
+ }
+ }
+ }
+ }
+
+ *pFrame_size = st_fx->nb_bits_tot_fx;
+
+ /*----------------------------------------------------------------*
+ * Bitstream packing (conversion of individual indices into a serial stream)
+ *----------------------------------------------------------------*/
+ j=0;
+ for (i=0; iind_list_fx[i].nb_bits != -1)
+ {
+ /* mask from MSB to LSB */
+ mask = 1 << (st_fx->ind_list_fx[i].nb_bits - 1);
+
+ /* write bit by bit */
+ for (k=0; k < st_fx->ind_list_fx[i].nb_bits; k++)
+ {
+ if (st_fx->Opt_AMR_WB_fx )
+ {
+ pack_bit(amrwb_bits[sort_ptr[core_mode][j++]], &pt_pFrame, &omask);
+ }
+ else
+ {
+ pack_bit(st_fx->ind_list_fx[i].value & mask, &pt_pFrame, &omask);
+ j++;
+ }
+ mask >>= 1;
+ }
+ }
+ }
+
+ if ( st_fx->Opt_AMR_WB_fx && core_mode == AMRWB_IO_SID) /* SID UPD frame always written now .... */
+ {
+ /* insert STI bit and CMI */
+ pack_bit(1, &pt_pFrame, &omask);
+ for (mask=0x08; mask>0; mask >>= 1)
+ {
+ pack_bit(cmi & mask, &pt_pFrame, &omask);
+ }
+ }
+}
+
+
+/*-------------------------------------------------------------------*
+ * indices_to_serial_generic()
+ *
+ * pack indices into serialized payload format
+ *-------------------------------------------------------------------*/
+
+void indices_to_serial_generic(
+ const Indice_fx *ind_list, /* i: indices list */
+ const Word16 num_indices, /* i: number of indices to write */
+ UWord8 *pFrame, /* o: byte array with bit packet and byte aligned coded speech data */
+ Word16 *pFrame_size /* i/o: number of bits in the binary encoded access unit [bits] */
+)
+{
+ Word16 i, k, j;
+ Word32 mask;
+ UWord8 omask;
+ UWord8 *pt_pFrame = pFrame;
+ Word16 nb_bits_tot;
+
+ nb_bits_tot = 0;
+ move16();
+ omask = (0x80 >> (*pFrame_size & 0x7));
+ pt_pFrame += shr(*pFrame_size, 3);
+
+ /*----------------------------------------------------------------*
+ * Bitstream packing (conversion of individual indices into a serial stream)
+ *----------------------------------------------------------------*/
+ j=0;
+ move16();
+ for (i=0; i>= 1;
+ }
+ nb_bits_tot = add(nb_bits_tot, ind_list[i].nb_bits);
+ }
+ }
+
+ *pFrame_size = add(*pFrame_size, nb_bits_tot);
+
+ return;
+}
+
+
+static void decoder_selectCodec(
+ Decoder_State_fx *st, /* i/o: decoder state structure */
+ const Word32 total_brate, /* i : total bitrate */
+ const Word16 bit0
+)
+{
+ test();
+ test();
+ test();
+ test();
+ test();
+ test();
+ test();
+ test();
+ test();
+ /* check if we are in AMR-WB IO mode */
+ IF( EQ_32(total_brate, SID_1k75)||
+ EQ_32(total_brate, ACELP_6k60) || EQ_32(total_brate, ACELP_8k85) || EQ_32(total_brate, ACELP_12k65) ||
+ EQ_32(total_brate, ACELP_14k25) || EQ_32(total_brate, ACELP_15k85) || EQ_32(total_brate, ACELP_18k25) ||
+ EQ_32(total_brate, ACELP_19k85) || EQ_32(total_brate, ACELP_23k05) || EQ_32(total_brate, ACELP_23k85) )
+ {
+ st->Opt_AMR_WB_fx = 1;
+ move16();
+ }
+ ELSE IF ( NE_32(total_brate, FRAME_NO_DATA))
+ {
+ st->Opt_AMR_WB_fx = 0;
+ move16();
+ }
+
+ /* select MODE1 or MODE2 */
+ IF (st->Opt_AMR_WB_fx)
+ {
+ st->codec_mode = MODE1;
+ move16();/**/
+ }
+ ELSE
+ {
+ SWITCH ( total_brate )
+ {
+ case 0:
+ st->codec_mode = st->last_codec_mode;
+ move16();
+ BREAK;
+ case 2400:
+ st->codec_mode = st->last_codec_mode;
+ move16();
+ BREAK;
+ case 2800:
+ st->codec_mode = MODE1;
+ move16();
+ BREAK;
+ case 7200:
+ st->codec_mode = MODE1;
+ move16();
+ BREAK;
+ case 8000:
+ st->codec_mode = MODE1;
+ move16();
+ BREAK;
+ case 9600:
+ st->codec_mode = MODE2;
+ move16();
+ BREAK;
+ case 13200:
+ st->codec_mode = MODE1;
+ move16();
+ BREAK;
+ case 16400:
+ st->codec_mode = MODE2;
+ move16();
+ BREAK;
+ case 24400:
+ st->codec_mode = MODE2;
+ move16();
+ BREAK;
+ case 32000:
+ st->codec_mode = MODE1;
+ move16();
+ BREAK;
+ case 48000:
+ st->codec_mode = MODE2;
+ move16();
+ BREAK;
+ case 64000:
+ st->codec_mode = MODE1;
+ move16();
+ BREAK;
+ case 96000:
+ st->codec_mode = MODE2;
+ move16();
+ BREAK;
+ case 128000:
+ st->codec_mode = MODE2;
+ move16();
+ BREAK;
+ default :
+ /* validate that total_brate (derived from RTP packet or a file header) is one of the defined bit rates */
+ st->codec_mode = st->last_codec_mode;
+ st->bfi_fx = 1;
+ move16();
+ move16();
+ BREAK;
+ }
+ }
+
+ IF ( st->ini_frame_fx == 0 )
+ {
+ IF(EQ_16(st->codec_mode,-1))
+ {
+ st->codec_mode = MODE1;
+ move16();
+ }
+ st->last_codec_mode = st->codec_mode;
+ move16();
+ }
+
+ /* set SID/CNG type */
+ IF ( EQ_32(total_brate,SID_2k40))
+ {
+ IF ( bit0 == G192_BIN0 )
+ {
+ st->cng_type_fx = LP_CNG;
+ move16();
+
+ /* force MODE1 when selecting LP_CNG */
+ st->codec_mode = MODE1;
+ move16();
+ }
+ ELSE
+ {
+ st->cng_type_fx = FD_CNG;
+ test();
+ if ( EQ_16(st->last_codec_mode, MODE2)&&EQ_32(st->last_total_brate_fx,13200))
+ {
+ st->codec_mode = MODE1;
+ move16();
+ }
+ }
+ st->last_cng_type_fx = st->cng_type_fx; /* CNG type switching at the first correctly received SID frame */
+ }
+
+
+ return;
+}
+
+
+
+
+void dec_prm_core(Decoder_State_fx *st)
+{
+ Word16 n, frame_size_index, num_bits;
+ UWord16 lsb;
+ Word32 L_tmp;
+
+ frame_size_index = -1;
+ move16();
+ st->core_fx = -1;
+ move16();
+
+ IF (EQ_32(st->total_brate_fx, FRAME_NO_DATA))
+ {
+ st->m_frame_type = ZERO_FRAME;
+ move16();
+ }
+ ELSE IF (EQ_32(st->total_brate_fx, SID_2k40))
+ {
+ st->m_frame_type = SID_FRAME;
+ move16();
+ }
+ ELSE
+ {
+ st->m_frame_type = ACTIVE_FRAME;
+ move16();
+ Mpy_32_16_ss(st->total_brate_fx, 5243, &L_tmp, &lsb); /* 5243 is 1/50 in Q18. (0+18-15=3) */
+ num_bits = extract_l(L_shr(L_tmp, 3)); /* Q0 */
+ assert(num_bits == st->total_brate_fx/50);
+ FOR (n=0; nbwidth_fx = get_next_indice_fx(st, FrameSizeConfig[frame_size_index].bandwidth_bits);
+
+ st->bwidth_fx = add(st->bwidth_fx, FrameSizeConfig[frame_size_index].bandwidth_min);
+
+ if (GT_16(st->bwidth_fx, FB))
+ {
+ st->bwidth_fx = FB;
+ move16();
+ st->BER_detect = 1;
+ move16();
+ }
+
+ if (GT_16(st->bwidth_fx, SWB)&<_32(st->total_brate_fx,ACELP_16k40))
+ {
+ st->bwidth_fx = SWB;
+ move16();
+ st->BER_detect = 1;
+ move16();
+ }
+
+ /* Skip reserved bit */
+ get_next_indice_tmp_fx(st, FrameSizeConfig[frame_size_index].reserved_bits);
+
+ IF (get_next_indice_1_fx(st) != 0) /* TCX */
+ {
+ st->core_fx = TCX_20_CORE;
+ move16();
+ if (get_next_indice_1_fx(st) != 0)
+ {
+ st->core_fx = HQ_CORE;
+ move16();
+ }
+ }
+ ELSE /* ACELP */
+ {
+ st->core_fx = ACELP_CORE;
+ move16();
+ }
+ }
+}
+
+/*-----------------------------------------------------------------*
+ * decision_matrix_core_dec()
+ *
+ * Read core mode signalling bits from the bitstream
+ * Set st->core, and st->bwidth if signalled together with the core.
+ *-----------------------------------------------------------------*/
+
+void decision_matrix_core_dec(
+ Decoder_State_fx *st /* i/o: decoder state structure */
+)
+{
+ Word16 start_idx;
+ Word32 ind;
+ Word16 nBits;
+
+ assert(st->bfi_fx != 1);
+
+ st->core_fx = -1;
+ move16();
+ st->bwidth_fx = -1;
+ move16();
+
+ test();
+ IF ( EQ_32(st->total_brate_fx, FRAME_NO_DATA)||EQ_32(st->total_brate_fx,SID_2k40))
+ {
+ st->core_fx = ACELP_CORE;
+ move16();
+ }
+ /* SC-VBR */
+ ELSE IF ( st->total_brate_fx == PPP_NELP_2k80 )
+ {
+ st->core_fx = ACELP_CORE;
+ move16();
+ return;
+ }
+
+ /*---------------------------------------------------------------------*
+ * ACELP/HQ core selection
+ *---------------------------------------------------------------------*/
+
+ test();
+ IF ( LT_32(st->total_brate_fx, ACELP_24k40))
+ {
+ st->core_fx = ACELP_CORE;
+ move16();
+ }
+ ELSE IF ( GE_32(st->total_brate_fx, ACELP_24k40)&&LE_32(st->total_brate_fx,ACELP_64k))
+ {
+ /* read the ACELP/HQ core selection bit */
+ st->core_fx = imult1616(get_next_indice_fx( st, 1 ), HQ_CORE);
+ }
+ ELSE
+ {
+ st->core_fx = HQ_CORE;
+ move16();
+ }
+
+ /*-----------------------------------------------------------------*
+ * Read ACELP signalling bits from the bitstream
+ *-----------------------------------------------------------------*/
+
+ IF ( EQ_16(st->core_fx, ACELP_CORE))
+ {
+ /* find the section in the ACELP signalling table corresponding to bitrate */
+ start_idx = 0;
+ move16();
+ WHILE ( NE_32(acelp_sig_tbl[start_idx], st->total_brate_fx))
+ {
+ start_idx = add(start_idx, 1);
+ }
+
+ /* skip the bitrate */
+ start_idx = add(start_idx, 1);
+
+ /* retrieve the number of bits */
+ nBits = extract_l(acelp_sig_tbl[start_idx]);
+ start_idx = add(start_idx, 1);
+
+ /* retrieve the signalling indice */
+ ind = acelp_sig_tbl[add(start_idx, get_next_indice_fx( st, nBits ))];
+ st->bwidth_fx = extract_l(L_and(L_shr(ind, 3), 0x7));
+
+ /* convert signalling indice into signalling information */
+ if ( EQ_32(L_and(ind, 0x7), LR_MDCT))
+ {
+ st->core_fx = HQ_CORE;
+ move16();
+ }
+ }
+
+ /*-----------------------------------------------------------------*
+ * Read HQ signalling bits from the bitstream
+ * Set HQ core type
+ *-----------------------------------------------------------------*/
+
+ IF ( EQ_16(st->core_fx, HQ_CORE))
+ {
+ /* read the HQ/TCX core switching flag */
+ if ( get_next_indice_fx( st, 1 ) != 0 )
+ {
+ st->core_fx = TCX_20_CORE;
+ move16();
+ }
+
+ /* For TCX: read/set band-width (needed for different I/O sampling rate support) */
+ test();
+ IF( EQ_16(st->core_fx, TCX_20_CORE)&>_32(st->total_brate_fx,ACELP_16k40))
+ {
+ ind = get_next_indice_fx( st, 2 );
+
+ IF( ind == 0 )
+ {
+ st->bwidth_fx = NB;
+ move16();
+ }
+ ELSE IF( EQ_32(ind, 1))
+ {
+ st->bwidth_fx = WB;
+ move16();
+ }
+ ELSE IF( EQ_32(ind, 2))
+ {
+ st->bwidth_fx = SWB;
+ move16();
+ }
+ ELSE
+ {
+ st->bwidth_fx = FB;
+ move16();
+ }
+ }
+ }
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * mdct_switching_dec()
+ *
+ * Set up MDCT core switching if indicated in the bit stream
+ *-------------------------------------------------------------------*/
+
+static void mdct_switching_dec(
+ Decoder_State_fx *st /* i/o: decoder state structure */
+)
+{
+ IF (st->Opt_AMR_WB_fx != 0)
+ {
+ return;
+ }
+
+ test();
+ test();
+ IF (EQ_32(st->total_brate_fx, ACELP_13k20)||EQ_32(st->total_brate_fx,ACELP_32k))
+ {
+ st->mdct_sw_enable = MODE1;
+ move16();
+ }
+ ELSE IF (LE_32(ACELP_16k40, st->total_brate_fx)&&LE_32(st->total_brate_fx,ACELP_24k40))
+ {
+ st->mdct_sw_enable = MODE2;
+ move16();
+ }
+
+ test();
+ test();
+ IF ( EQ_16(st->codec_mode, MODE1)&&EQ_16(st->mdct_sw_enable,MODE1))
+ {
+ /* Read ahead core mode signaling */
+ Word16 next_bit_pos_save;
+ Word16 core_save;
+ Word16 bwidth_save;
+
+ next_bit_pos_save = st->next_bit_pos_fx;
+ move16();
+ core_save = st->core_fx;
+ move16();
+ bwidth_save = st->bwidth_fx;
+ move16();
+
+ decision_matrix_core_dec(st); /* sets st->core */
+
+ IF (EQ_16(st->core_fx, TCX_20_CORE))
+ {
+ /* Trigger TCX */
+ st->codec_mode = MODE2;
+ move16();
+ st->mdct_sw = MODE1;
+ move16();
+ }
+ ELSE
+ {
+ /* Rewind bitstream */
+ st->next_bit_pos_fx = next_bit_pos_save;
+ move16();
+ IF (st->bfi_fx != 0)
+ {
+ st->core_fx = core_save;
+ move16();
+ st->bwidth_fx = bwidth_save;
+ move16();
+ }
+ }
+ }
+ ELSE IF (EQ_16(st->codec_mode, MODE2)&&EQ_16(st->mdct_sw_enable,MODE2))
+ {
+ /* Read ahead core mode signaling */
+ Word16 next_bit_pos_save;
+ Word16 core_save;
+ Word16 bwidth_save;
+
+ next_bit_pos_save = st->next_bit_pos_fx;
+ move16();
+ core_save = st->core_fx;
+ move16();
+ bwidth_save = st->bwidth_fx;
+ move16();
+
+ dec_prm_core(st); /* sets st->core */
+
+ IF (EQ_16(st->core_fx, HQ_CORE))
+ {
+ /* Trigger HQ_CORE */
+ st->codec_mode = MODE1;
+ move16();
+ st->mdct_sw = MODE2;
+ move16();
+ }
+ ELSE
+ {
+ /* Rewind bitstream */
+ st->next_bit_pos_fx = next_bit_pos_save;
+ move16();
+ IF (st->bfi_fx != 0)
+ {
+ st->core_fx = core_save;
+ move16();
+ }
+ /* always reset bwidth, to not interfere with BER logic */
+ st->bwidth_fx = bwidth_save;
+ move16();
+ }
+ }
+}
+
+/*-------------------------------------------------------------------*
+ * BRATE2IDX_fx()
+ *
+ * Convert Bitrate to Index Value
+ *-------------------------------------------------------------------*/
+
+Word16 BRATE2IDX_fx(Word32 brate)
+{
+ Word32 L_temp;
+ Word32 L_idx;
+#define START 9
+ extern const Word16 bit_rates_div50[];
+
+ /* This is a Fast Bit Rate Value to Index Value Binary Search */
+ L_temp = L_msu0(brate, bit_rates_div50[START], 50);
+ L_temp = L_min(6, L_max(-6, L_temp));
+ L_idx = L_add(L_temp, START);
+ L_temp = L_msu0(brate, bit_rates_div50[L_idx], 50);
+ L_temp = L_min(3, L_max(-3, L_temp));
+ L_idx = L_add(L_temp, L_idx);
+ L_temp = L_msu0(brate, bit_rates_div50[L_idx], 50);
+ L_temp = L_min(1, L_max(-2, L_temp));
+ L_idx = L_add(L_temp, L_idx);
+ L_temp = L_msu0(brate, bit_rates_div50[L_idx], 50);
+ if (L_temp != 0) L_idx = L_add(L_idx, 1);
+ return (Word16)L_idx;
+}
+
+
+/*-------------------------------------------------------------------*
+ * BRATE2IDX16k_fx()
+ *
+ * Convert Bitrate to Index Value
+ *-------------------------------------------------------------------*/
+
+Word16 BRATE2IDX16k_fx(Word32 brate)
+{
+ Word32 L_temp, L_idx;
+#define START_16K 5
+ extern const Word16 bit_rates_16k_div50[];
+
+ if(EQ_32(brate,ACELP_16k40))
+ {
+ brate=ACELP_14k80;
+ }
+
+ /* This is a Fast Bit Rate Value to Index Value Binary Search */
+ L_temp = L_msu0(brate, bit_rates_16k_div50[START_16K], 50);
+ L_temp = L_min(3, L_max(-3, L_temp));
+ L_idx = L_add(L_temp, START_16K);
+ L_temp = L_msu0(brate, bit_rates_16k_div50[L_idx], 50);
+ L_temp = L_min(2, L_max(-2, L_temp));
+ L_idx = L_add(L_temp, L_idx);
+ L_temp = L_msu0(brate, bit_rates_16k_div50[L_idx], 50);
+ L_temp = L_min(1, L_max(-1, L_temp));
+ L_idx = L_add(L_temp, L_idx);
+
+ return (Word16)L_idx;
+}
+
+/*-------------------------------------------------------------------*
+ * BIT_ALLOC_IDX_fx()
+ *-------------------------------------------------------------------*/
+
+Word32 BIT_ALLOC_IDX_fx(Word32 brate, Word16 ctype, Word16 sfrm, Word16 tc)
+{
+ Word32 L_temp;
+ Word16 temp;
+ if (ctype == INACTIVE) /* no sub(ctype, INACTIVE) because it is '0' */
+ ctype = GENERIC;
+ move16();
+ L_temp = L_mac0(-1l*256, 1*256, ctype);
+
+ temp = BRATE2IDX_fx(brate);
+ L_temp = L_mac0(L_temp, 4*256, temp);
+ if (tc >= 0)
+ L_temp = L_mac0(L_temp, (10-4)*256, temp);
+ /* So either 'temp' x 4 when 'tc < 0', 'temp' x 10 otherwise */
+
+ L_temp = L_mac0(L_temp, 1*256, s_max(0, tc));
+
+ L_temp = L_mac0(L_temp, s_max(0, sfrm), 1);
+ if (sfrm < 0)
+ L_temp = L_shr(L_temp, 2);
+ L_temp = L_shr(L_temp, 6);
+
+ return L_temp;
+}
+
+/*-------------------------------------------------------------------*
+ * BIT_ALLOC_IDX_16KHZ_fx()
+ *-------------------------------------------------------------------*/
+
+Word32 BIT_ALLOC_IDX_16KHZ_fx(Word32 brate, Word16 ctype, Word16 sfrm, Word16 tc)
+{
+ Word32 L_temp;
+ Word16 temp;
+ /* 'ctype' =
+ TRANSITION => 2
+ GENERIC => 1
+ ALL Other => 0
+ */
+ L_temp = L_and(shr(0x0240l, shl(ctype, 1)), 3);
+
+ temp = BRATE2IDX16k_fx(brate);
+ L_temp = L_mac0(L_temp, 3, temp);
+ if (tc >= 0)
+ L_temp = L_mac0(L_temp, (7-3), temp);
+ /* So either 'temp' x 3 when 'tc < 0', 'temp' x 7 otherwise */
+
+ L_temp = L_mac0(L_temp, 1, s_max(0, tc));
+
+ IF (sfrm >= 0)
+ {
+ /* Mult by 5 */
+ L_temp = L_add(L_temp, L_shl(L_temp, 2));
+ L_temp = L_mac0(L_temp, shr(sfrm, 6), 1);
+ }
+
+ return L_temp;
+}
+
+
+/*-------------------------------------------------------------------*
+ * read_indices_fx()
+ *
+ * Read indices from an ITU-T G.192 bitstream to the buffer
+ * Simulate packet losses by inserting frame erasures
+ *-------------------------------------------------------------------*/
+
+Word16 read_indices_fx( /* o : 1 = reading OK, 0 = problem */
+ Decoder_State_fx *st, /* i/o: decoder state structure */
+ FILE *file, /* i : bitstream file */
+ Word16 rew_flag /* i : rewind flag (rewind file after reading)*/
+)
+{
+ Word16 k;
+ UWord16 utmp, stream[2+MAX_BITS_PER_FRAME], *pt_stream, *bit_stream_ptr;
+ Word16 num_bits;
+ Word32 total_brate;
+ Word32 L_tmp;
+ Word16 curr_ft_good_sp, curr_ft_bad_sp;
+ Word16 g192_sid_first,sid_upd_bad, sid_update;
+ Word16 speech_bad, speech_lost;
+ Word16 num_bits_read;
+
+ st->bfi_fx = 0;
+ st->BER_detect = 0;
+ st->mdct_sw_enable = 0;
+ st->mdct_sw = 0;
+ reset_indices_dec_fx( st );
+
+ /* read the Sync Header field from the bitstream */
+ /* in case rew_flag is set, read until first good frame is encountered */
+ do
+ {
+ /* read the Sync header */
+ if ( fread( &utmp, sizeof(unsigned short), 1, file ) != 1 )
+ {
+ if( ferror( file ) )
+ {
+ /* error during reading */
+ fprintf(stderr, "\nError reading the bitstream !");
+ exit(-1);
+ }
+ else
+ {
+ /* end of file reached */
+ return 0;
+ }
+ }
+
+ /* set the BFI indicator according the value of Sync Header */
+ if ( EQ_16(utmp, SYNC_BAD_FRAME))
+ {
+ st->bfi_fx = 1;
+ }
+
+
+ else
+ {
+ st->bfi_fx = 0;
+ }
+
+ /* read the Frame Length field from the bitstream */
+ if ( fread( &num_bits, sizeof(unsigned short), 1, file ) != 1 )
+ {
+ if( ferror( file ) )
+ {
+ /* error during reading */
+ fprintf(stderr, "\nError reading the bitstream !");
+ exit(-1);
+ }
+ else
+ {
+ /* end of file reached */
+ return 0;
+ }
+ }
+ /* convert the frame length to total bitrate */
+ total_brate = (long)(num_bits* 50);
+
+ /* read ITU-T G.192 serial stream of indices from file to the local buffer */
+ /* Validate that the G.192 length is within the defined bit rate range
+ to not allow writing past the end of the "stream" buffer */
+ if( num_bits > MAX_BITS_PER_FRAME )
+ {
+ fprintf(stderr, "\nError, too large G.192 frame (size(%d))! Exiting ! \n", num_bits);
+ exit(-1);
+ }
+
+ /* verify that a valid num bits value is present in the G.192 file */
+ /* only AMRWB or EVS bit rates or 0(NO DATA) are allowed in G.192 file frame reading */
+ if( rate2EVSmode(total_brate) < 0 ) /* negative value means that a valid rate was not found */
+ {
+ fprintf(stderr, "\nError, illegal bit rate (%d) in the G.192 frame ! Exiting ! \n", total_brate);
+ exit(-1);
+ }
+ pt_stream = stream;
+
+ num_bits_read = (Word16) fread( pt_stream, sizeof(unsigned short), num_bits, file );
+
+ if( num_bits_read != num_bits )
+ {
+ fprintf(stderr, "\nError, invalid number of bits read ! Exiting ! \n");
+ exit(-1);
+ }
+
+ }
+ while ( rew_flag && (st->bfi_fx || LT_32(total_brate,2800)));
+
+ /* G.192 RX DTX handler*/
+ if( !rew_flag )
+ {
+ /* handle SID_FIRST, SID_BAD, SPEECH_LOST, NO_DATA as properly as possible for the ITU-T G.192 format */
+
+ /* (total_brate, bfi , st_CNG) = rx_handler(received frame type, [previous frame type], past CNG state, past core) */
+ curr_ft_good_sp = 0;
+ curr_ft_bad_sp = 0;
+
+ if( total_brate > SID_2k40 )
+ {
+ if( st->bfi_fx == 0 )
+ {
+ curr_ft_good_sp = 1;
+ }
+ else
+ {
+ curr_ft_bad_sp = 1;
+ }
+ }
+ sid_update = 0;
+ sid_upd_bad = 0;
+
+ if( total_brate == SID_1k75 || total_brate == SID_2k40 )
+ {
+ if( st->bfi_fx == 0 )
+ {
+ sid_update = 1;
+ }
+ else
+ {
+ sid_upd_bad = 1; /* may happen in CS , corrupt but detected sid frame */
+ }
+ }
+
+ /* all zero indeces/bits iSP AMRWB SID_update results in a valid LP filter with extremely high LP-filter-gain */
+ /* all zero indeces/bits may be a result of CS bit errors and/or erroneously injected by gateways or by a bad dejitter handlers */
+ if (total_brate == SID_1k75 && sid_update == 1)
+ {
+ /* valid sid_update received, check for very risky but formally valid content */
+ Word16 sum = 0;
+ for (k = 0; k < num_bits; ++k)
+ {
+ sum += (pt_stream[k] == G192_BIN1);/* check of 35 zeroes, 35 ones */
+ }
+ if( sum == 0 )
+ { /* all zeros */
+ sid_upd_bad = 1; /* initial signal as corrupt (BER likley) */
+ }
+ }
+
+ /* AMRWB 26.173 G.192 file reader (read_serial) does not declare/use SID_BAD ft,
+ it declares every bad synch marked frame initially as a lost_speech frame,
+ and then the RXDTX handler CNG state decides the decoding mode CNG/SPEECH.
+ While In the AMRWB ETSI/3GPP format eid a CRC error in a detected SID_UPDATE frame triggers SID_UPD_BAD.
+
+ Here we inhibit use of the SID-length info, even though it is available in the G.192 file format after STL/EID-XOR .
+ */
+ if ( sid_upd_bad )
+ {
+ sid_upd_bad = 0;
+ total_brate = FRAME_NO_DATA ; /* treat SID_BAD as a stolen signaling frame --> SPEECH LOST */
+
+ }
+
+ g192_sid_first = 0;
+ if( st->core_fx == AMR_WB_CORE && st->prev_ft_speech_fx && total_brate == FRAME_NO_DATA && st->bfi_fx == 0 )
+ {
+ g192_sid_first = 1; /* SID_FIRST detected for previous AMRWB/AMRWBIO active frames only */
+ /*
+ It is not possible to perfectly simulate rate switching conditions EVS->AMRWBIO where:
+ the very first SID_FIRST detection is based on a past EVS active frame
+ and a good length 0 "SID_FIRST"(NO_DATA) frame is sent in AMRWBIO,
+ , due to the one frame state memory in the AMRWB legacy G.192 SID_FIRST encoding
+ */
+ }
+
+ speech_bad = 0;
+ if( total_brate > SID_2k40 && st->bfi_fx != 0 ) /* CS-type of CRC failure frame */
+ {
+ speech_bad = 1; /* initial assumption, CNG_state decides what to do */
+ }
+
+ speech_lost = 0;
+ if( total_brate == 0 && st->bfi_fx != 0 ) /* unsent NO_DATA or stolen NO_DATA/signaling frame */
+ {
+ speech_lost = 1; /* initial assumption, CNG_state decides what to do */
+ }
+
+ /* Do not allow decoder to enter CNG-synthesis for any instantly received GOOD+LENGTH==0 frame
+ as this frame was never transmitted, one can not know it is good and has a a length of zero ) */
+
+ if( st->CNG_fx != 0 )
+ {
+ /* We were in CNG synthesis */
+ if( curr_ft_good_sp != 0 )
+ {
+ /* only a good speech frame makes you leave CNG synthesis */
+ st->CNG_fx = 0;
+ }
+ }
+ else
+ {
+ /* We were in SPEECH synthesis */
+ /* only a received SID frame can make the decoder enter into CNG synthsis */
+ if( g192_sid_first || sid_update || sid_upd_bad )
+ {
+ st->CNG_fx = 1;
+ }
+ }
+
+ /* handle the g.192 _simulated_ untransmitted frame, setting for decoder SPEECH synthesis */
+ if ( (st->CNG_fx==0) && (total_brate==0 && st->bfi_fx == 0 ) )
+ {
+ st->bfi_fx = 1;
+ move16(); /* SPEECH PLC code will now become active as in a real system */
+ /* total_brate= 0 */
+ }
+
+ /* handle bad speech frame(and bad sid frame) in the decoders CNG synthesis settings pair (total_brate, bfi) */
+ if( ((st->CNG_fx != 0) && ( (speech_bad != 0) || (speech_lost != 0) )) || /* SP_BAD or SPEECH_LOST) --> stay in CNG */
+ ( sid_upd_bad != 0 )) /* SID_UPD_BAD --> start CNG */
+ {
+ st->bfi_fx = 0;
+ total_brate = 0;
+ }
+ /* update for next frame's G.192 file format's SID_FIRST detection (primarily for AMRWBIO) */
+ st->prev_ft_speech_fx = ((curr_ft_good_sp != 0) || (curr_ft_bad_sp != 0));
+
+ /* st->total brate= total_brate ; updated in a good frame below */
+ } /* rew_flag */
+#ifdef DEBUGGING
+ st->bfi_fx |= file_read_FECpattern();
+#endif
+ /* get total bit-rate */
+ if ( st->bfi_fx == 0 && !rew_flag )
+ {
+ /* select MODE1 or MODE2 */
+ decoder_selectCodec( st, total_brate, *pt_stream );
+ }
+
+ Mpy_32_16_ss(total_brate, 5243, &L_tmp, &utmp); /* 5243 is 1/50 in Q18. (0+18-15=3) */
+ st->total_num_bits = extract_l(L_shr(L_tmp, 3)); /* Q0 */
+
+ /* in case rew_flag is set, rewind the file and return */
+ /* (used in io_enc() to print out info about technologies and to initialize the codec) */
+ if ( rew_flag )
+ {
+ rewind( file );
+ st->total_brate_fx = total_brate;
+ move16();
+ return 1;
+ }
+
+ /* GOOD frame */
+ if ( st->bfi_fx == 0 )
+ {
+ /* GOOD frame - convert ITU-T G.192 words to short values */
+ bit_stream_ptr = st->bit_stream_fx;
+
+ for( k = 0; k< num_bits; ++k)
+ {
+ *bit_stream_ptr++ = (*pt_stream++ == G192_BIN1 );
+ }
+
+ /*add two zero bytes for arithmetic coder flush*/
+ for(k=0; k< 2*8; ++k)
+ {
+ *bit_stream_ptr++ = 0;
+ }
+ /*a change of the total bitrate should not be
+ known to the decoder, if the received frame was lost*/
+ st->total_brate_fx = total_brate ;
+
+ mdct_switching_dec(st);
+ }
+
+ return 1;
+}
+
+
+/*-------------------------------------------------------------------*
+ * read_indices_mime_handle_dtx()
+ *
+ * Handle DTX for MIME and RTP_DUMP decoding.
+ * Returns the actual total_brate.
+ *-------------------------------------------------------------------*/
+
+static Word32 read_indices_mime_handle_dtx(
+ Decoder_State_fx *st,
+ Word16 isAMRWB_IOmode,
+ Word16 core_mode,
+ Word32 total_brate,
+ Word16 sti,
+ Word16 speech_lost,
+ Word16 no_data
+)
+{
+ Word16 curr_ft_good_sp = 0;
+ Word16 speech_bad = 0;
+ Word16 sid_upd_bad = 0, sid_update = 0;
+ Word16 amrwb_sid_first = 0; /* derived from sti SID_FIRST indicator in AMRWB payload */
+
+ /* keep st->CNG , st_bfi and total_brate updated for proper synthesis in DTX and FER */
+ if( GT_32(total_brate, SID_2k40) )
+ {
+ if( st->bfi_fx != 1 ) /* so far derived from q bit in AMRWB/AMRWBIO cases */
+ {
+ curr_ft_good_sp = 1;
+ }
+ }
+
+ /* handle q_bit and lost_sp clash , assume worst case */
+ if( speech_lost != 0 ) /* overrides a good q_bit */
+ {
+ curr_ft_good_sp = 0;
+ st->bfi_fx = 1; /* override qbit */
+ }
+
+ /* now_bfi_fx has been set based on q_bit and ToC fields */
+
+
+ /* SID_UPDATE check */
+ if( total_brate == SID_1k75 || total_brate == SID_2k40 )
+ {
+ if( st->bfi_fx == 0 )
+ {
+ /* typically from q bit */
+ sid_update = 1;
+ }
+ else
+ {
+ sid_upd_bad = 1; /* may happen in saving from e.g. a CS-connection */
+ }
+ }
+
+ if( isAMRWB_IOmode && total_brate == 0 && sti == 0 )
+ {
+ if( st->bfi_fx )
+ {
+ sid_upd_bad = 1; /* corrupt sid_first, signaled as bad sid */
+ }
+ else
+ {
+ amrwb_sid_first = 1; /* 1-sti */
+ }
+ }
+
+ if ( sid_upd_bad != 0 && (
+ (isAMRWB_IOmode != 0 && st->Opt_AMR_WB_fx==0 ) || /* switch to AMRWBIO */
+ (isAMRWB_IOmode != 1 && st->Opt_AMR_WB_fx==1) /* switch from AMRWBIO */
+ ) )
+ {
+ /* do not allow a normal start of CNG synthesis if this SID(with BER or FER) is a switch to/from AMRWBIO */
+ sid_upd_bad = 0; /* revert this detection due to AMRWBIO/EVS mode switch */
+ total_brate = 0;
+ no_data = 1;
+ assert( st->bfi_fx==1); /* bfi stays 1 */
+ }
+
+ if( GT_32(total_brate, SID_2k40) && st->bfi_fx == 1 ) /* typically from q bit */
+ {
+ speech_bad = 1; /* initial assumption, CNG synt state decides what to actually do */
+ }
+ /* all frame types decoded */
+
+ /* update CNG synthesis state */
+ /* Decoder can only enter CNG-synthesis for CNG frame types (sid_upd, sid_bad, sid_first) */
+ if( st->CNG_fx != 0 )
+ {
+ /* We were in CNG synthesis */
+ if( curr_ft_good_sp != 0 )
+ {
+ /* only a good speech frame makes decoder leave CNG synthesis */
+ st->CNG_fx = 0;
+ }
+ }
+ else
+ {
+ /* We were in SPEECH synthesis */
+ /* only a received SID frame can make the decoder enter into CNG synthesis */
+ if( amrwb_sid_first || sid_update || sid_upd_bad )
+ {
+ st->CNG_fx = 1;
+ }
+ }
+
+ /* Now modify bfi flag for the decoder's SPEECH/CNG synthesis logic */
+ /* in SPEECH synthesis, make sure to activate speech plc for a received no_data frame,
+ no_data frames may be injected by the network or by the dejitter buffer */
+ /* modify bfi_flag to stay/move into the correct decoder PLC section */
+ if ( (st->CNG_fx == 0) && ( no_data != 0 ) )
+ {
+ /* treat no_data received in speech synthesis as SP_LOST frames, SPEECH PLC code will now become active */
+ st->bfi_fx = 1;
+ /* total_brate= 0; always zero for no_data */
+ }
+
+ /* in CNG */
+ /* handle bad speech frame(and bad sid frame) in the decoders CNG synthesis settings pair (total_brate, bfi) */
+ if( ( st->CNG_fx != 0 && ( speech_bad || speech_lost || no_data )) || /* SP_BAD or SPEECH_LOST) --> stay in CNG */
+ sid_upd_bad ) /* SID_UPD_BAD --> start/stay CNG */
+ {
+ st->bfi_fx = 0; /* mark as good to not start speech PLC */
+ total_brate = 0; /* this zeroing needed for speech_bad, sid_bad frames */
+ }
+
+
+ /* now bfi, total_brate are set by RX-DTX handler::
+ bfi==0, total_brate!=0 cng or speech pending bitrate
+ bfi==0, total_brate==0 cng will continue or start(sid_first, sid_bad)
+ bfi==1, total_brate!=0 speech plc
+ bfi==1, total_brate==0 , speech plc
+ */
+
+
+ /* handle available AMRWB/AMRWBIO MIME header ToC rate-info at startup */
+ if( ( st->bfi_fx == 1 && st->ini_frame_fx == 0) &&
+ ( (st->amrwb_rfc4867_flag != 0) || (st->amrwb_rfc4867_flag == 0 && isAMRWB_IOmode != 0 )) ) /*AMRWB ToC */
+ {
+ Word32 init_rate;
+
+ init_rate = total_brate; /* default , may have been modified from original ToC value */
+ if (speech_lost !=0 || no_data != 0 )
+ {
+ init_rate = ACELP_12k65; /* make sure the decoder starts up in a selected AMRWB mode */
+ }
+ else if( speech_bad !=0 )
+ {
+ init_rate = AMRWB_IOmode2rate[core_mode]; /* read from from ToC */
+ }
+ st->total_brate_fx = init_rate; /* not updated on bfi as decoderSelectCodec is not called below */
+ st->core_brate_fx = init_rate;
+ }
+
+ return total_brate;
+}
+
+
+/*-------------------------------------------------------------------*
+ * read_indices_mime_handle_sti_and_all_zero_bits()
+ *
+ * Handle STI and frames with all zero bits for MIME and RTP_DUMP decoding.
+ *-------------------------------------------------------------------*/
+
+static void read_indices_mime_handle_sti_and_all_zero_bits(
+ Decoder_State_fx *st,
+ Word32 *total_brate,
+ Word16 sti
+)
+{
+ Word16 k;
+
+ if( sti == 0 )
+ {
+ *total_brate = 0; /* signal received SID_FIRST as a good frame with no bits */
+ for(k=0; k<35; k++)
+ {
+ st->bfi_fx |= st->bit_stream_fx[k] ; /* partity check of 35 zeroes, any single 1 gives BFI */
+ }
+ }
+ /* all zero bit SID_update results in a valid LP filter with extremely high LP-filter-gain */
+ /* all zero bits signal may be a result of CS bit errors or erronesouly injected by gateways or bad dejitter handlers */
+ if (sti == 1)
+ { /*sid_update received */
+ Word16 sum = 0;
+ for (k = 0; k < 35; k++)
+ {
+ sum += st->bit_stream_fx[k]; /* check of 35 zeroes */
+ }
+
+ if ( sum == 0 )
+ {
+ st->bfi_fx = 1; /* eventually becomes SID_UPD_BAD */
+ }
+ }
+}
+
+
+/*------------------------------------------------------------------------------------------*
+* read_indices_mime()
+*
+* Read indices from MIME formatted bitstream to the buffer
+* The magic word and number of channnels should be consumed before calling this function
+*-------------------------------------------------------------------------------------------*/
+
+Word16 read_indices_mime( /* o : 1 = reading OK, 0 = problem */
+ Decoder_State_fx *st, /* i/o: decoder state structure */
+ FILE *file, /* i : bitstream file */
+ Word16 rew_flag /* i : rewind flag (rewind file after reading) */
+)
+{
+ Word16 k, isAMRWB_IOmode, cmi, core_mode = -1, qbit,sti;
+ UWord8 header;
+ UWord8 pFrame[(MAX_BITS_PER_FRAME + 7) >> 3];
+ UWord8 mask= 0x80, *pt_pFrame=pFrame;
+ UWord16 *bit_stream_ptr;
+ Word16 num_bits;
+ Word32 total_brate;
+ UWord16 utmp;
+ Word32 L_tmp;
+ Word16 speech_lost = 0, no_data = 0;
+ Word16 num_bytes_read;
+
+ st->BER_detect = 0;
+ st->bfi_fx = 0;
+ st->mdct_sw_enable = 0;
+ st->mdct_sw = 0;
+ reset_indices_dec_fx( st );
+
+ /* read the FT Header field from the bitstream */
+ if ( fread( &header, sizeof(UWord8), 1, file ) != 1 )
+ {
+ if( ferror( file ) )
+ {
+ /* error during reading */
+ fprintf(stderr, "\nError reading the bitstream !");
+ exit(-1);
+ }
+ else
+ {
+ /* end of file reached */
+ return 0;
+ }
+ }
+
+ /* init local RXDTX flags */
+ sti = -1;
+
+ if( st->amrwb_rfc4867_flag != 0 )
+ {
+ /* RFC 4867
+ 5.3 ....
+ Each stored speech frame starts with a one-octet frame header with
+ the following format:
+ 0 1 2 3 4 5 6 7
+ +-+-+-+-+-+-+-+-+
+ |P| FT |Q|P|P|
+ +-+-+-+-+-+-+-+-+
+ The FT field and the Q bit are defined in the same way as in
+ Section 4.3.2. The P bits are padding and MUST be set to 0, and MUST be ignored. */
+
+ isAMRWB_IOmode = 1;
+ qbit = (header>>2)&0x01 ; /* b2 bit (b7 is the F bit ) */
+ st->bfi_fx = !qbit;
+ core_mode = ((header>>3) & 0x0F); /* b6..b3 */
+ total_brate = AMRWB_IOmode2rate[core_mode]; /* get the frame length from the header */
+ }
+ else
+ {
+ /*0 1 2 3 4 5 6 7 MS-bit ---> LS-bit
+ +-+-+-+-+-+-+-+-+
+ |H|F|E|x| brate |
+ +-+-+-+-+-+-+-+-+
+ where :
+ "E|x| brate " is the 6 bit "FT" -field
+ x is unused if E=0, (should be 0 )
+ x is the q-bit if E=1, q==1(good), Q==0(bad, maybe bit errors in payload )
+ H,F always 0 in RTP format.
+ */
+ isAMRWB_IOmode = (header & 0x20) > 0; /* get EVS mode-from header */ /* b2 */
+ core_mode = (header & 0x0F); /* b4,b5,b6,b7 */
+
+ if( isAMRWB_IOmode )
+ {
+ qbit = (header & 0x10) > 0; /* get Q bit, valid for IO rates */ /* b3 */
+ total_brate = AMRWB_IOmode2rate[core_mode];
+ }
+ else
+ {
+ qbit = 1; /* assume good q_bit for the unused EVS-mode bit, complete ToC validity checked later */
+ total_brate = PRIMARYmode2rate[ core_mode ];
+ }
+ st->bfi_fx = !qbit;
+ }
+
+
+
+
+ /* set up RX-DTX-handler input */
+ if( core_mode == 14 )
+ {
+ /* SP_LOST */
+ speech_lost=1;
+ }
+ if ( core_mode == 15)
+ {
+ /* NO_DATA unsent CNG frame OR any frame marked or injected as no_data by e.g a signaling layer or dejitter buffer */
+ no_data=1;
+ }
+
+ Mpy_32_16_ss(total_brate, 5243, &L_tmp, &utmp); /* 5243 is 1/50 in Q18. (0+18-15=3) */
+ num_bits = extract_l(L_shr(L_tmp, 3)); /* Q0 */
+ st->total_num_bits = num_bits;
+
+ if( total_brate < 0 )
+ {
+ /* validate that total_brate (derived from RTP packet or a file header) is one of the defined bit rates */
+ fprintf(stderr, "\n Error. Illegal total bit rate (= %d) in MIME ToC header \n", total_brate );
+ /* num_bits = -1; not needed as BASOP multiplication preserves sign */
+ }
+
+ /* Check correctness of ToC headers */
+ if( st->amrwb_rfc4867_flag == 0 )
+ {
+ /* EVS ToC header (FT field(b2-b7), H bit (b0), F bit (b1) , (EVS-modebit(b2)=0 unused(Qbit)(b3)==0) */
+ if ( (isAMRWB_IOmode == 0) && ((num_bits < 0) || ((header & 0x80) > 0) || ((header & 0x40) > 0) || (header & 0x30) != 0x00 ) )
+ {
+ /* incorrect FT header */
+ fprintf(stderr, "\nError in EVS FT ToC header(%02x) ! ",header);
+ exit(-1);
+ }
+ else if( (isAMRWB_IOmode != 0) && ( (num_bits < 0) || ((header & 0x80) > 0) || ((header & 0x40) > 0) ) ) /* AMRWBIO */
+ {
+ /* incorrect IO FT header */
+ fprintf(stderr, "\nError in EVS(AMRWBIO) FT ToC header(%02x) ! ",header);
+ exit(-1);
+ }
+ }
+ else
+ {
+ /* legacy AMRWB ToC, is only using Padding bits which MUST be ignored */
+ if ( num_bits < 0 )
+ {
+ /* incorrect FT header */
+ fprintf(stderr, "\nError in AMRWB RFC4867 Toc(FT) header(%02x) !", header);
+ exit(-1);
+ }
+ }
+
+ /* read serial stream of indices from file to the local buffer */
+ num_bytes_read = (Word16) fread( pFrame, sizeof(UWord8), (num_bits + 7)>>3, file );
+ if( num_bytes_read != (num_bits + 7)>>3 )
+ {
+ fprintf(stderr, "\nError, invalid number of bytes read ! Exiting ! \n");
+ exit(-1);
+ }
+
+ /* in case rew_flag is set, rewind the file and return */
+ /* (used in io_dec() to attempt print out info about technologies and to initialize the codec ) */
+ if ( rew_flag )
+ {
+ st->total_brate_fx = total_brate; /* used for the codec banner output */
+ if( st->bfi_fx == 0 && speech_lost == 0 && no_data == 0 )
+ {
+ decoder_selectCodec( st, total_brate, unpack_bit(&pt_pFrame,&mask) ? G192_BIN1 : G192_BIN0);
+ }
+ return 1;
+ }
+
+
+
+ /* unpack speech data */
+ bit_stream_ptr = st->bit_stream_fx;
+ for (k=0; kbit_stream_fx[sort_ptr[core_mode][k]] = unpack_bit(&pt_pFrame,&mask);
+ bit_stream_ptr++;
+ }
+ else
+ {
+ *bit_stream_ptr++ = unpack_bit(&pt_pFrame,&mask);
+ }
+ }
+
+ /* unpack auxiliary bits */
+ /* Note: the cmi bits are unpacked for demo purposes; */
+ if (isAMRWB_IOmode && total_brate == SID_1k75)
+ {
+ sti = unpack_bit(&pt_pFrame,&mask);
+ cmi = unpack_bit(&pt_pFrame,&mask) << 3;
+ cmi |= unpack_bit(&pt_pFrame,&mask) << 2;
+ cmi |= unpack_bit(&pt_pFrame,&mask) << 1;
+ cmi |= unpack_bit(&pt_pFrame,&mask);
+
+ read_indices_mime_handle_sti_and_all_zero_bits( st, &total_brate, sti );
+ }
+
+ /*add two zero bytes for arithmetic coder flush*/
+ for(k=0; k< 2*8; ++k)
+ {
+ *bit_stream_ptr++ = 0;
+ }
+
+ /* MIME RX_DTX handler */
+ if( !rew_flag )
+ {
+ total_brate = read_indices_mime_handle_dtx( st, isAMRWB_IOmode, core_mode, total_brate, sti, speech_lost, no_data );
+ }
+
+ if( st->bfi_fx == 0 )
+ {
+ /* select MODE1 or MODE2 in MIME */
+ decoder_selectCodec( st, total_brate, *st->bit_stream_fx ? G192_BIN1 : G192_BIN0);
+
+ /* a change of the total bitrate should not be known to the decoder, if the received frame was truly lost */
+ st->total_brate_fx = total_brate;
+ mdct_switching_dec(st);
+ }
+ /* else{ bfi stay in past synthesis mode(SP,CNG) } */
+
+ return 1;
+}
+
+/*-------------------------------------------------------------------*
+* berCheck()
+*
+* Check for bit errors in channel aware signalling.
+*-------------------------------------------------------------------*/
+
+static void berCheck(
+ Decoder_State_fx *st, /* i/o: decoder state structure */
+ Word16 *coder_type /* i/o: coder type */
+)
+{
+ /* In case of RF flag = 1, and valid RF packet with primary and partial copy */
+ if ( ( EQ_16( st->bwidth_fx, NB)||EQ_16(st->bwidth_fx,FB))
+ || (GE_16(*coder_type,TRANSITION) )
+ )
+ {
+ if( EQ_16( st->use_partial_copy, 1 ))
+ {
+ st->use_partial_copy = 0;
+ move16();
+ }
+
+ st->bfi_fx = 1;
+ move16();
+ st->bwidth_fx = st->last_bwidth_fx;
+ move16();
+ st->BER_detect = 1;
+ move16();
+ *coder_type = GENERIC;
+ move16();
+ }
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+* getPartialCopyInfo()
+*
+* Check if the frame includes a partial copy for channel aware processing.
+*-------------------------------------------------------------------*/
+
+void getPartialCopyInfo(
+ Decoder_State_fx *st, /* i/o: decoder state structure */
+ Word16 *coder_type,
+ Word16 *sharpFlag
+)
+{
+ Word16 nBits;
+ Word16 ind;
+ /* check the rf flag in the packet */
+ get_rfFlag( st, &(st->rf_flag), &nBits , &ind);
+
+ /* get rf frame type info */
+ get_rfFrameType( st, &(st->rf_frame_type) );
+
+ /* Get the FEC offset info */
+ get_rf_fec_offset( st, &(st->rf_fec_offset) );
+
+ /* reset number of target bits in case of rate switching */
+ st->rf_target_bits = 0;
+
+ /* Get the number of bits used for RF*/
+ IF( EQ_16(st->rf_flag,1))
+ {
+ *coder_type = s_and(ind,0x7);
+ st->bwidth_fx = s_and(shr(ind,3), 0x7);
+ *sharpFlag = s_and(shr(ind,6), 0x1);
+ st->codec_mode = MODE2;
+ move16();
+ get_rfTargetBits( st->rf_frame_type, &(st->rf_target_bits) );
+
+ IF( EQ_16(st->bfi_fx,FRAMEMODE_FUTURE))
+ {
+ st->use_partial_copy = 1;
+ /* now set the frame mode to normal mode */
+ test();
+ IF(GE_16(st->rf_frame_type,RF_TCXFD)&&LE_16(st->rf_frame_type,RF_TCXTD2))
+ {
+ st->bfi_fx = 1;
+ st->core_fx = 1;
+ }
+ ELSE
+ {
+ st->bfi_fx = FRAMEMODE_NORMAL;
+ st->core_fx = 0;
+ }
+ }
+
+ /* check for bit errors */
+ berCheck( st, coder_type );
+
+ get_next_indice_tmp_fx(st, nBits);
+
+ }
+}
+
+/*-------------------------------------------------------------------*
+* get_rfFlag()
+*
+* Check if rf flag is present in the bitstream
+*-------------------------------------------------------------------*/
+
+void get_rfFlag(
+ Decoder_State_fx *st, /* i: decoder state structure */
+ Word16 *rf_flag, /* o : check for the RF flag */
+ Word16 *nBits,
+ Word16 *ind
+)
+{
+ Word16 start_idx, nBits_tmp;
+ Word16 ind_tmp;
+
+ /* Init */
+ *rf_flag = 0;
+
+ /* check for rf_flag in the packet and extract the rf_frame_type and rf_fec_offset */
+ test();
+ test();
+ IF( EQ_32(st->total_brate_fx,ACELP_13k20)&&(EQ_16(st->bfi_fx,FRAMEMODE_NORMAL)||EQ_16(st->bfi_fx,FRAMEMODE_FUTURE)))
+ {
+ /* find the section in the ACELP signalling table corresponding to bitrate */
+ start_idx = 0;
+ WHILE ( NE_32(acelp_sig_tbl[start_idx], st->total_brate_fx))
+ {
+ start_idx++;
+ assert((start_idx < MAX_ACELP_SIG) && "ERROR: start_idx larger than acelp_sig_tbl[].\n");
+ }
+
+ /* skip the bitrate */
+ start_idx = add(start_idx,1);
+
+ /* retrieve the number of bits */
+ nBits_tmp = (Word16) acelp_sig_tbl[start_idx++];
+
+ /* retrieve the signalling indice */
+ ind_tmp = (Word16) acelp_sig_tbl[start_idx + get_indice_fx( st, 0, nBits_tmp )];
+
+ /* convert signalling indice into RF flag. */
+ *rf_flag = s_and(shr(ind_tmp, 7), 0x1);
+
+ if( ind )
+ {
+ *ind = ind_tmp;
+ }
+
+ if( nBits )
+ {
+ *nBits = nBits_tmp;
+ }
+ }
+}
+
+/*-------------------------------------------------------------------*
+* get_rfFrameType()
+*
+* Extract the rf frame type
+*-------------------------------------------------------------------*/
+
+void get_rfFrameType(
+ Decoder_State_fx *st, /* i : decoder state structure */
+ Word16 *rf_frame_type /* o : RF frame type */
+)
+{
+ Word16 num_bits = 0;
+
+ IF( EQ_16(st->rf_flag, 1))
+ {
+ /*num_bits = st->total_brate_fx/50;*/
+ if( EQ_32(st->total_brate_fx, ACELP_13k20))
+ {
+ num_bits = 264;
+ move16(); /* @13.2kbps */
+ }
+ else
+ {
+ UWord16 lsb;
+ Word32 L_tmp;
+ Mpy_32_16_ss(st->total_brate_fx, 5243, &L_tmp, &lsb); /* 5243 is 1/50 in Q18. (0+18-15=3) */
+ num_bits = extract_l(L_shr(L_tmp, 3)); /* Q0 */
+ }
+
+ /* the last three bits in a packet is the RF frame type */
+ *rf_frame_type = get_indice_fx( st, num_bits - 3, 3 );
+ }
+ ELSE
+ {
+ *rf_frame_type = 0;
+ }
+}
+
+/*-------------------------------------------------------------------*
+* get_rf_fec_offset()
+*
+* Extract the FEC offset
+*-------------------------------------------------------------------*/
+
+void get_rf_fec_offset(
+ Decoder_State_fx *st, /* i : decoder state structure */
+ Word16 *rf_fec_offset /* o : RF fec offset */
+)
+{
+ Word16 num_bits, tmp;
+
+ IF( EQ_16(st->rf_flag,1))
+ {
+ /*num_bits = st->total_brate_fx/50;*/
+ if( EQ_32(st->total_brate_fx, ACELP_13k20))
+ {
+ num_bits = 264;
+ move16(); /* @13.2kbps */
+ }
+ else
+ {
+ UWord16 lsb;
+ Word32 L_tmp;
+ Mpy_32_16_ss(st->total_brate_fx, 5243, &L_tmp, &lsb); /* 5243 is 1/50 in Q18. (0+18-15=3) */
+ num_bits = extract_l(L_shr(L_tmp, 3)); /* Q0 */
+ }
+
+ /* the two bits before the rf frame type contain the fec offset */
+ tmp = get_indice_fx( st, num_bits - 5, 2 );
+
+ if( tmp == 0 )
+ {
+ *rf_fec_offset = 2;
+ move16();
+ }
+ else
+ {
+ *rf_fec_offset = add(shl(tmp, 1), 1);
+ }
+ }
+ ELSE
+ {
+ *rf_fec_offset = 0;
+ move16();
+ }
+}
+
+/*-------------------------------------------------------------------*
+* get_rfTargetBits()
+*
+* Return the number of RF target bits
+*-------------------------------------------------------------------*/
+
+void get_rfTargetBits(
+ Word16 rf_frame_type, /* i : RF frame type */
+ Word16 *rf_target_bits /* o : Number of RF target bits */
+)
+{
+
+ /* Number of RF bits for different RF coder types */
+
+ SWITCH (rf_frame_type)
+ {
+ case RF_NO_DATA:
+ *rf_target_bits = 5;
+ BREAK;
+ case RF_TCXFD:
+ *rf_target_bits = 27;
+ BREAK;
+ case RF_TCXTD1:
+ *rf_target_bits = 16;
+ BREAK;
+ case RF_TCXTD2:
+ *rf_target_bits = 16;
+ BREAK;
+ case RF_ALLPRED:
+ /* Es_pred bits 3 bits, LTF: 1, pitch: 8,5,5,5, FCB: 0, gain: 7,0,7,0, Diff GFr: 4*/
+ *rf_target_bits = 63;
+ BREAK;
+ case RF_NOPRED:
+ /* Es_pred bits 3 bits, LTF: 0, pitch: 0, FCB: 7,7,7,7, gain: 6,0,6,0, Diff GFr: 2*/
+ *rf_target_bits = 66;
+ BREAK;
+ case RF_GENPRED:
+ /* Es_pred bits 3 bits, LTF: 1, pitch: 8,0,8,0, FCB: 6,7,5,5, gain: 5,0,5,0, Diff GFr: 0*/
+ *rf_target_bits = 70;
+ BREAK;
+ case RF_NELP:
+ /* gain: 19, Diff GFr: 5 */
+ *rf_target_bits = 45;
+ BREAK;
+ }
+}
+
+
+/*-------------------------------------------------------------------*
+ * get_NextCoderType_fx()
+ *
+ * Extract the coder type of next frame
+ *-------------------------------------------------------------------*/
+
+void get_NextCoderType_fx(
+ UWord8 *bitsteam, /* i : bitstream */
+ Word16 *next_coder_type /* o : next coder type */
+)
+{
+ Word16 k;
+ Word16 start_idx;
+ Word16 nBits_tmp;
+ Word8 bit_stream[ACELP_13k20/50];
+ UWord16 tmp;
+
+
+ FOR( k = 0; k < ACELP_13k20/50; k++ )
+ {
+ bit_stream[k] = (bitsteam[k / 8] >> (7 - (k % 8))) & 0x1;
+ }
+ start_idx = 0;
+ WHILE ( NE_32(acelp_sig_tbl[start_idx], ACELP_13k20))
+ {
+ start_idx = add(start_idx,1);
+ assert((start_idx < MAX_ACELP_SIG) && "ERROR: start_idx larger than acelp_sig_tbl[].\n");
+ }
+
+ /* skip the bitrate */
+ start_idx = add(start_idx,1);
+
+ tmp = 0;
+ move16();
+ nBits_tmp = (Word16) acelp_sig_tbl[start_idx++];
+ FOR (k = 0; k < nBits_tmp; k++)
+ {
+ tmp = lshl(tmp, 1);
+ tmp = add(tmp, bit_stream[k]);
+ }
+ /* retrieve the signalling indice */
+ *next_coder_type = s_and((Word16)acelp_sig_tbl[start_idx + tmp],0x7);
+}
+
+/*-------------------------------------------------------------------*
+ * read_indices_from_djb_fx()
+ *
+ * Read indices from the de-jitter buffer payload (works also for AMR-WB IO mode)
+ *-------------------------------------------------------------------*/
+
+void read_indices_from_djb_fx(
+ Decoder_State_fx *st, /* i/o: decoder state structure */
+ UWord8 *pt_stream, /* i : bitstream file */
+ Word16 num_bits, /* i : input frame length in bits */
+ Word16 isAMRWB_IOmode,
+ Word16 core_mode,
+ Word16 qbit,
+ Word16 partialframe, /* i : partial frame information */
+ Word16 next_coder_type /* i : next coder type information */
+)
+{
+ Word16 k;
+ UWord8 mask = 0x80;
+ Word16 no_data = 0;
+ Word16 sti = -1;
+ UWord16 *bit_stream_ptr;
+ Word32 total_brate;
+ Word16 speech_lost = 0;
+
+ st->bfi_fx = 0;
+ st->BER_detect = 0;
+ st->mdct_sw_enable = 0;
+ st->mdct_sw = 0;
+ reset_indices_dec_fx(st);
+
+ st->bfi_fx = !qbit;
+ total_brate = (Word32)(num_bits) * 50;
+ st->total_num_bits = num_bits;
+
+ if( num_bits == 0 ) /* guess type of missing frame for SP_LOST and NO_DATA */
+ {
+ speech_lost = st->CNG_fx == 0;
+ no_data = st->CNG_fx != 0;
+ }
+
+ if( partialframe || st->prev_use_partial_copy)
+ {
+ st->next_coder_type = next_coder_type;
+ }
+ else
+ {
+ st->next_coder_type = INACTIVE;
+ }
+
+ if (partialframe == 1)
+ {
+ st->bfi_fx = 2;
+ }
+
+ /* unpack speech data */
+ bit_stream_ptr = st->bit_stream_fx;
+ /* convert bitstream from compact bytes to short values and store it in decoder state */
+ for( k = 0; k < num_bits; k++ )
+ {
+ if( st->bitstreamformat == VOIP_RTPDUMP && isAMRWB_IOmode )
+ {
+ st->bit_stream_fx[sort_ptr[core_mode][k]] = unpack_bit(&pt_stream, &mask);
+ bit_stream_ptr++;
+ }
+ else
+ {
+ *bit_stream_ptr++ = unpack_bit(&pt_stream, &mask);
+ }
+ }
+
+ /* unpack auxiliary bits */
+ if( isAMRWB_IOmode && total_brate == SID_1k75 )
+ {
+ if( st->bitstreamformat == VOIP_RTPDUMP )
+ {
+ /* A.2.2.1.3: AMR-WB SID_1k75 frame is followed by STI bit and CMI bits */
+ sti = unpack_bit(&pt_stream, &mask);
+ }
+ else
+ {
+ /* VOIP_G192_RTP does not contain STI and CMI */
+ sti = 1;
+ }
+ read_indices_mime_handle_sti_and_all_zero_bits(st, &total_brate, sti);
+
+ }
+
+ /* add two zero bytes for arithmetic coder flush */
+ for( k=0; k < 8*2; ++k )
+ {
+ *bit_stream_ptr++ = 0;
+ }
+
+ total_brate = read_indices_mime_handle_dtx(st, isAMRWB_IOmode, core_mode, total_brate, sti, speech_lost, no_data);
+ /* st->CNG_fx set inside */
+
+ if ( st->bfi_fx != 1 )
+ {
+ /* select Mode 1 or Mode 2 */
+ decoder_selectCodec( st, total_brate, *st->bit_stream_fx ? G192_BIN1 : G192_BIN0);
+
+ /* a change of the total bitrate should not be known to the decoder, if the received frame was truly lost */
+ st->total_brate_fx = total_brate;
+
+ mdct_switching_dec(st);
+ }
+}
+
+
+
+/*-------------------------------------------------------------------*
+ * get_indice_preview()
+ *
+ * Indices preview to parse for the presence of partial copy
+ *-------------------------------------------------------------------*/
+static UWord16 get_indice_preview(
+ UWord8 *bitstream,
+ Word16 bitstreamSize,
+ Word16 pos,
+ Word16 nb_bits
+)
+{
+ UWord16 value;
+ Word16 i;
+ UWord16 bitstreamShort[MAX_BITS_PER_FRAME+16];
+ UWord16 *bitstreamShortPtr;
+
+ /* convert bitstream from compact bytes to short values */
+ bitstreamShortPtr = bitstreamShort;
+ FOR( i = 0; i < bitstreamSize; i++ )
+ {
+ *bitstreamShortPtr++ = (bitstream[i / 8] >> (7 - (i % 8))) & 0x1;
+ }
+
+ assert(nb_bits <= 16);
+ value = 0;
+ FOR (i = 0; i < nb_bits; i++)
+ {
+ value = shl(value,1);
+ value = add(value,bitstreamShort[pos+i]);
+ }
+ return value;
+}
+
+/*-------------------------------------------------------------------*
+ * evs_dec_previewFrame()
+ *
+ * Signalling index preview
+ *-------------------------------------------------------------------*/
+void evs_dec_previewFrame(
+ UWord8 *bitstream,
+ Word16 bitstreamSize,
+ Word16 *partialCopyFrameType,
+ Word16 *partialCopyOffset
+)
+{
+ Word32 total_brate;
+ Word16 start_idx, nBits;
+ Word32 ind;
+ Word16 rf_flag;
+
+ rf_flag = 0;
+ *partialCopyFrameType = 0;
+ *partialCopyOffset = 0;
+ total_brate = bitstreamSize * 50;
+
+ IF( EQ_32(total_brate,ACELP_13k20))
+ {
+ /* find the section in the ACELP signalling table corresponding to bitrate */
+ start_idx = 0;
+ WHILE ( NE_32(acelp_sig_tbl[start_idx], total_brate))
+ {
+ start_idx = add(start_idx,1);
+ assert((start_idx < MAX_ACELP_SIG) && "ERROR: start_idx larger than acelp_sig_tbl[].\n");
+ }
+
+ /* skip the bitrate */
+ start_idx = add(start_idx,1);
+ /* retrieve the number of bits */
+ nBits = (Word16) acelp_sig_tbl[start_idx++];
+
+ /* retrieve the signalling indice */
+ ind = acelp_sig_tbl[start_idx + get_indice_preview( bitstream, bitstreamSize, 0, nBits )];
+
+ /* convert signalling indice into RF flag. */
+ rf_flag = s_and(extract_l(L_shr(ind, 7)), 0x1);
+ assert(rf_flag == ((ind >> 7) & 0x1));
+ IF(rf_flag != 0)
+ {
+ /* read the fec offset at which the partial copy is received */
+ ind = get_indice_preview( bitstream, bitstreamSize, (bitstreamSize-5), 2 );
+ IF(ind== 0) *partialCopyOffset = 2;
+ ELSE IF(EQ_32(ind,1))*partialCopyOffset=3;
+ ELSE IF(EQ_32(ind,2))*partialCopyOffset=5;
+ ELSE IF(EQ_32(ind,3))*partialCopyOffset=7;
+
+ /* the last three bits in a packet is the RF frame type */
+ *partialCopyFrameType = get_indice_preview( bitstream, bitstreamSize, bitstreamSize - 3, 3 );
+ }
+ }
+}
+
+
diff --git a/lib_com/cb_shape_fx.c b/lib_com/cb_shape_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..b4751363bffdcb913b704c639b727b6a9dedbc8d
--- /dev/null
+++ b/lib_com/cb_shape_fx.c
@@ -0,0 +1,134 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "rom_com_fx.h" /* */
+
+#include "stl.h"
+
+/*
+ * E_GAIN_f_pitch_sharpening
+ *
+ * Parameters:
+ * x I/O: impulse response (or algebraic code)
+ * pit_lag I: pitch lag
+ *
+ * Function:
+ * Performs Pitch sharpening routine for one subframe.
+ * pitch sharpening factor is 0.85
+ *
+ * Returns:
+ * void
+ */
+static void E_GAIN_f_pitch_sharpening(Word16 *x, Word16 pit_lag, Word16 L_subfr)
+{
+ Word16 i, tmp;
+
+ FOR (i = pit_lag; i < L_subfr; i++)
+ {
+ /*x[i] += x[i - pit_lag] * F_PIT_SHARP;*/
+ tmp = mult_r(x[i - pit_lag], 27853/*F_PIT_SHARP Q15*/);
+ x[i] = add(x[i],tmp);
+ move16();
+ }
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * cb_shape()
+ *
+ * pre-emphasis, pitch sharpening and formant sharpening of the algebraic codebook
+ *-------------------------------------------------------------------*/
+
+void cb_shape_fx(
+ const Word16 preemphFlag, /* i : flag for pre-emphasis */
+ const Word16 pitchFlag, /* i : flag for pitch sharpening */
+ const Word16 scramblingFlag, /* i : flag for phase scrambling */
+ const Word16 sharpFlag, /* i : flag for formant sharpening */
+ const Word16 formantTiltFlag, /* i : flag for formant tilt */
+ const Word16 g1, /* i : formant sharpening numerator weighting */
+ const Word16 g2, /* i : formant sharpening denominator weighting */
+ const Word16 *p_Aq, /* i : LP filter coefficients */
+ Word16 *code, /* i/o: signal to shape */
+ const Word16 tilt_code, /* i : tilt of code */
+ const Word16 pt_pitch, /* i : pointer to current subframe fractional pitch */
+ const Word16 shift
+)
+{
+ Word16 tmp, buff[L_SUBFR+M], A_num[M+1], A_den[M+1];
+ Word16 i;
+ Word32 L_tmp;
+ Word16 tilt, mu;
+ tmp = 0;
+ move16();
+
+ /* Pre-emphasis */
+ IF( preemphFlag )
+ {
+ preemph_copy_fx(code, code, tilt_code, L_SUBFR, &tmp);
+ }
+
+ /* pitch sharpening */
+ IF( pitchFlag )
+ {
+ E_GAIN_f_pitch_sharpening( code, pt_pitch, L_SUBFR );
+ }
+
+ /* phase scrambling filter */
+ IF( scramblingFlag )
+ {
+ buff[0] = code[0];
+ move16();
+ FOR (i = 1; i < L_SUBFR; i++)
+ {
+ buff[i]=code[i];
+ move16();
+ /*code[i] = 0.7f*buff[i] + buff[i-1] - 0.7f*code[i-1]; */
+ L_tmp = L_mult(22938, buff[i]);
+ tmp = mac_r(L_tmp,-22938, code[i-1]);
+ code[i] = add(tmp,buff[i-1]);
+ move16();
+ }
+ }
+
+ test();
+ IF ( sharpFlag || formantTiltFlag )
+ {
+ weight_a_fx( p_Aq, A_num, g1, M );
+ weight_a_fx( p_Aq, A_den, g2, M );
+ set16_fx(buff, 0, M+L_SUBFR);
+ IF( formantTiltFlag )
+ {
+ Copy(A_num, buff+M, M+1);
+
+ E_UTIL_synthesis(1, A_den, buff+M, buff+M, L_SUBFR, buff, 0, M);
+
+ /*Compute tilt of formant enhancement*/
+ tilt = extract_l(L_shr(get_gain(buff+M+1, buff+M, L_SUBFR-1),1));
+
+ /*Combine tilt of code and fe*/
+ tmp = 0;
+ move16();
+ /*mu = 0.5f*tilt_code-0.25f*tilt;*/
+ mu = sub(shr(tilt_code,1),shr(tilt,2));
+ preemph_copy_fx(code, code, mu, L_SUBFR, &tmp);
+ }
+ ELSE
+ {
+ Copy( code, buff, L_SUBFR );
+
+ Overflow = 0;
+ move16();
+ Residu3_lc_fx(A_num, M, buff, code, L_SUBFR, shift);
+ {
+ syn_filt_s_lc_fx(shift, A_den, code, code, L_SUBFR);
+ }
+ }
+ }
+
+ return;
+}
+
diff --git a/lib_com/cldfb.c b/lib_com/cldfb.c
new file mode 100644
index 0000000000000000000000000000000000000000..a05236eb85670703cc1da268d1b371d434289ba3
--- /dev/null
+++ b/lib_com/cldfb.c
@@ -0,0 +1,1661 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+/*!
+ \file
+ \brief Complex cldfb analysis/synthesis, $Revision: 1214 $
+ This module contains the cldfb filterbank for analysis [ cplxAnalysisCldfbFiltering() ] and
+ synthesis [ cplxSynthesisCldfbFiltering() ]. It is a polyphase implementation of a complex
+ exponential modulated filter bank. The analysis part usually runs at half the sample rate
+ than the synthesis part. (So called "dual-rate" mode.)
+
+ \anchor PolyphaseFiltering About polyphase filtering
+ The polyphase implementation of a filterbank requires filtering at the input and output.
+ This is implemented as part of cplxAnalysisCldfbFiltering() and cplxSynthesisCldfbFiltering().
+
+*/
+
+#include "stl.h"
+#include "cnst_fx.h"
+#include "stat_com.h"
+#include "rom_com_fx.h"
+#include "basop_util.h"
+#include "prot_fx.h"
+#include
+
+#define STATE_BUFFER_SIZE ( 9+16 )
+
+#define CLDFB_NO_POLY ( 5 )
+#define SYN_FILTER_HEADROOM ( 1 )
+
+#define CLDFB_LDCLDFB_PFT_SCALE ( 0 )
+#define CLDFB_CLDFB80_O24_PFT_SCALE ( 1 )
+#define CLDFB_CLDFB80_O5_PFT_SCALE ( 1 )
+#define CLDFB_CLDFB80_PFT_SCALE ( 1 )
+
+
+
+#define SYN_FILTER_HEADROOM_1MS ( 2 )
+#define SYN_FILTER_HEADROOM_2MS ( 2 )
+#define SYN_FILTER_HEADROOM_2_5MS ( 2 )
+#define SYN_FILTER_HEADROOM_8MS ( 1 )
+
+#define N8 ( 4 )
+#define N10 ( 5 )
+#define N16 ( 8 )
+#define N20 ( 10 )
+#define N30 ( 15 )
+#define N32 ( 16 )
+#define N40 ( 20 )
+#define N60 ( 30 )
+
+static void
+cldfb_init_proto_and_twiddles(HANDLE_CLDFB_FILTER_BANK hs);
+
+#define cplxMpyS(yr,yi,xr,xi,cr,ci,syr,syi,sxr,sxi,CL_x,CL_z,C_c) CL_x = CL_form( *xr, *xi ); \
+ C_c = C_form( *cr, *ci ); \
+ CL_z = CL_mult_32x16( CL_x, C_c ); \
+ *yr = CL_Extract_real( CL_z ); \
+ *yi = CL_Extract_imag( CL_z ); \
+ yr+=syr, yi+=syi, xr+=sxr, xi+=sxi, cr++, ci++
+
+#define cplxMpy(ryr,ryi,iyr,iyi,rxr,rxi,ixr,ixi,cr,ci,g,sx,sr,CL_x,CL_ry,CL_iy,C_c) CL_x = CL_form( *rxr, *rxi ); \
+ C_c = C_form( *cr, *ci ); \
+ CL_ry = CL_mult_32x16( CL_x, C_c ); \
+ CL_x = CL_form( *ixr, *ixi ); \
+ CL_iy = CL_mult_32x16( CL_x, C_c ); \
+ CL_ry = CL_scale_t( CL_ry, g ); \
+ CL_iy = CL_scale_t( CL_iy, g ); \
+ ryr = CL_Extract_real( CL_ry ); \
+ ryi = CL_Extract_imag( CL_ry ); \
+ iyr = CL_Extract_real( CL_iy ); \
+ iyi = CL_Extract_imag( CL_iy ); \
+ rxr+=sx, rxi+=sx, ixr+=sx, ixi+=sx, cr+=sr, ci+=sr
+
+#define add1(y1,y2,y3,y4,rr12,ri12,ir12,ii12,s) *y1 = round_fx(L_shl(L_negate(L_add(rr12,ii12)),s)); \
+ *y2 = round_fx(L_shl(L_negate(L_add(ri12,ir12)),s)); \
+ *y3 = round_fx(L_shl(L_sub(rr12,ii12),s)); \
+ *y4 = round_fx(L_shl(L_sub(ir12,ri12),s)); \
+ y1+=2, y2-=2, y3-=2, y4+=2
+
+
+#define add2(y1,y2,y3,y4,rr12,ri12,ir12,ii12,s) *y1 = round_fx(L_shl(L_add(ri12,ir12),s)); \
+ *y2 = round_fx(L_shl(L_add(rr12,ii12),s)); \
+ *y3 = round_fx(L_shl(L_sub(ir12,ri12),s)); \
+ *y4 = round_fx(L_shl(L_sub(rr12,ii12),s)); \
+ y1+=2, y2-=2, y3-=2, y4+=2
+
+#define ptrUpdate16(y11,y12,y13,y14,r11,x11,x12,x13,x14,r12,y21,y22,y23,y24,r21,x21,x22,x23,x24,r22) \
+ y11 += 2*N8, y12 -= 2*N8, y13 -= 2*N8, y14 += 2*N8, r11 -= 1*N8; \
+ x11 -= 2*N8, x12 -= 2*N8, x13 -= 2*N8, x14 -= 2*N8, r12 -= 1*N8; \
+ y21 += 2*N8, y22 -= 2*N8, y23 -= 2*N8, y24 += 2*N8, r21 += 1*N8; \
+ x21 += 2*N8, x22 += 2*N8, x23 += 2*N8, x24 += 2*N8, r22 += 1*N8
+
+#define ptrUpdate20(y11,y12,y13,y14,r11,x11,x12,x13,x14,r12,y21,y22,y23,y24,r21,x21,x22,x23,x24,r22) \
+ y11 += 2*N10, y12 -= 2*N10, y13 -= 2*N10, y14 += 2*N10, r11 -= 1*N10; \
+ x11 -= 2*N10, x12 -= 2*N10, x13 -= 2*N10, x14 -= 2*N10, r12 -= 1*N10; \
+ y21 += 2*N10, y22 -= 2*N10, y23 -= 2*N10, y24 += 2*N10, r21 += 1*N10; \
+ x21 += 2*N10, x22 += 2*N10, x23 += 2*N10, x24 += 2*N10, r22 += 1*N10
+
+
+
+
+static void cplxMultAdd10_1(Word16 *rY1, Word16 *rY2, Word16 *rY3, Word16 *rY4,
+ Word32 *rXR, Word32 *rXI, Word32 *iXR, Word32 *iXI,
+ const Word16 *cr, const Word16 *ci, Word16 gv, Word16 s,
+ Word16 sx, Word16 sr)
+{
+ Word32 rr12, ri12, ir12, ii12;
+ cmplx CL_x,CL_ry, CL_iy;
+ cmplx_s C_c;
+
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr,CL_x,CL_ry, CL_iy,C_c);
+ add1(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr,CL_x,CL_ry, CL_iy,C_c);
+ add1(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+
+}
+
+static void cplxMultAdd10_2(Word16 *rY1, Word16 *rY2, Word16 *rY3, Word16 *rY4,
+ Word32 *rXR, Word32 *rXI, Word32 *iXR, Word32 *iXI,
+ const Word16 *cr, const Word16 *ci, Word16 gv, Word16 s,
+ Word16 sx, Word16 sr)
+{
+ Word32 rr12, ri12, ir12, ii12;
+ cmplx CL_x,CL_ry, CL_iy;
+ cmplx_s C_c;
+
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add2(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add2(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add2(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+
+}
+
+
+static void cplxMultAdd20_1(Word16 *rY1, Word16 *rY2, Word16 *rY3, Word16 *rY4,
+ Word32 *rXR, Word32 *rXI, Word32 *iXR, Word32 *iXI,
+ const Word16 *cr, const Word16 *ci, Word16 gv, Word16 s,
+ Word16 sx, Word16 sr)
+{
+ Word32 rr12, ri12, ir12, ii12;
+ cmplx CL_x,CL_ry, CL_iy;
+ cmplx_s C_c;
+
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add1(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add1(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add1(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add1(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add1(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+
+
+}
+
+static void cplxMultAdd20_2(Word16 *rY1, Word16 *rY2, Word16 *rY3, Word16 *rY4,
+ Word32 *rXR, Word32 *rXI, Word32 *iXR, Word32 *iXI,
+ const Word16 *cr, const Word16 *ci, Word16 gv, Word16 s,
+ Word16 sx, Word16 sr)
+{
+ Word32 rr12, ri12, ir12, ii12;
+ cmplx CL_x,CL_ry, CL_iy;
+ cmplx_s C_c;
+
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add2(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add2(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add2(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add2(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+ cplxMpy(rr12, ri12, ir12, ii12, rXR, rXI, iXR, iXI, cr, ci, gv, sx, sr, CL_x, CL_ry, CL_iy, C_c);
+ add2(rY1, rY2, rY3, rY4, rr12, ri12, ir12, ii12, s);
+
+}
+
+/* calcModulation
+
+ Parameters:
+ *rYR O: pointer to real output samples (DST)
+ *rYI O: pointer to imaginary output samples (DST)
+ *rXR I: pointer to real input samples (DST)
+ *rXI I: pointer to imaginary input samples (DST)
+ srYR I: offset for update of pointer to real output samples (DST)
+ srYI I: offset for update of pointer to imaginary output samples (DST)
+ srXR I: offset for update of pointer to real input samples (DST)
+ srXI I: offset for update of pointer to imaginary input samples (DST)
+ *iYR O: pointer to real output samples (DCT)
+ *iYI O: pointer to imaginary output samples (DCT)
+ *iXR I: pointer to real input samples (DCT)
+ *iXI I: pointer to imaginary input samples (DCT)
+ siYR I: offset for update of pointer to real output samples (DCT)
+ siYI I: offset for update of pointer to imaginary output samples (DCT)
+ siXR I: offset for update of pointer to real input samples (DCT)
+ siXI I: offset for update of pointer to imaginary input samples (DCT)
+ m I: processed cldfb bands
+
+ Function:
+ The function applies for each cldfb length a unrolled complex modulation
+
+ Returns:
+ void
+*/
+static void calcModulation( Word32 *rYR,
+ Word32 *rYI,
+ Word32 *rXR,
+ Word32 *rXI,
+ Word16 srYR,
+ Word16 srYI,
+ Word16 srXR,
+ Word16 srXI,
+ Word32 *iYR,
+ Word32 *iYI,
+ Word32 *iXR,
+ Word32 *iXI,
+ Word16 siYR,
+ Word16 siYI,
+ Word16 siXR,
+ Word16 siXI,
+ const Word16 *rRotVctr,
+ const Word16 *iRotVctr,
+ Word16 m
+ )
+{
+ cmplx CL_x,CL_z;
+ cmplx_s C_c;
+ int i;
+ int lc = m >> 1;
+
+ const Word16 *cr = rRotVctr;
+ const Word16 *ci = iRotVctr;
+
+ for(i=0;ino_channels;
+ move16();
+ L2 = shl(m,1);
+ m2 = shr(m,1);
+ M4 = shr(m,2);
+ M4 = sub(m2,M4);
+
+ L3 = sub(L2,m2);
+ L4 = add(L2,m2);
+
+ M0M2 = sub(0,m2);
+ M2M1 = sub(m2,1);
+ L3M1 = sub(L3,1);
+ L4M1 = sub(L4,1);
+
+ rBuffer = &pWorkBuffer[0];
+ iBuffer = &pWorkBuffer[m];
+
+ rRotVctr = cldfbBank->rRotVctr;
+ iRotVctr = cldfbBank->iRotVctr;
+
+ pStates = cldfbBank->FilterStates;
+ pStates1 = &pStates[L3M1];
+ pStates2 = &pStates[L3];
+ pStates3 = &pStates[m2];
+ pStates4 = &pStates[M2M1];
+ pStates5 = &pStates[L4M1];
+ pStates6 = &pStates[M0M2];
+
+ p_stride = CLDFB_NO_POLY;
+ pFilter = &cldfbBank->p_filter[p_stride - CLDFB_NO_POLY];
+ pFilter1 = &pFilter[p_stride*L3M1];
+ pFilter2 = &pFilter[p_stride*L3];
+ pFilter3 = &pFilter[p_stride*m2];
+ pFilter4 = &pFilter[p_stride*M2M1];
+ pFilter5 = &pFilter[p_stride*L4M1];
+ pFilter6 = &pFilter[p_stride*M0M2];
+
+ nSamples = i_mult(nTimeSlots, cldfbBank->no_channels);
+ nSamplesUpd = i_mult(cldfbBank->no_col, cldfbBank->no_channels);
+ offset = sub(sub(cldfbBank->p_filter_length, cldfbBank->no_channels),cldfbBank->zeros);
+
+ /* Determine states scale */
+ scale = -15;
+ move16();
+ k = 0;
+ move16();
+ FOR (i=0; ino_channels)
+ {
+ cldfbBank->FilterStates_e[k] = cldfbBank->FilterStates_e[k+cldfbBank->no_col];
+ move16();
+ assert((size_t)k < sizeof(cldfbBank->FilterStates_e)/sizeof(cldfbBank->FilterStates_e[0]));
+ scale = s_max(scale, cldfbBank->FilterStates_e[k]);
+ k = add(k,1);
+ }
+ FOR (i=0; ino_channels)
+ {
+ cldfbBank->FilterStates_e[k] = timeIn_e;
+ move16();
+ assert((size_t)k < sizeof(cldfbBank->FilterStates_e)/sizeof(cldfbBank->FilterStates_e[0]));
+ scale = s_max(scale, cldfbBank->FilterStates_e[k]);
+ k = add(k,1);
+ }
+ i = s_max(scale, timeIn_e);
+ scale = sub(cldfbBank->FilterStates_eg, i);
+ cldfbBank->FilterStates_eg = i;
+ move16();
+
+ /* if nTimeSlots==0, make sure we have a value. */
+ scaleFactor->lb_scale = add(cldfbBank->anaScalefactor, add(cldfbBank->FilterStates_eg, 5));
+ move16();
+
+ /* move and scale filter states */
+ FOR (i=0; iFilterStates_eg);
+ FOR (i=0; ilb_scale = add(cldfbBank->anaScalefactor, add(cldfbBank->FilterStates_eg, scale));
+ move16();
+
+ /* FFT of DCT IV */
+ BASOP_cfft((cmplx *)iBuffer, m2, &scale, workBuffer);
+
+ /* post modulation of DST IV and DCT IV */
+ calcModulation(&rAnalysis[k][m-1], &rAnalysis[k][0], &rBuffer[0], &rBuffer[1],-2, 2, 2, 2,
+ &iAnalysis[k][0], &iAnalysis[k][m-1], &iBuffer[0], &iBuffer[1], 2,-2, 2, 2,
+ rRotVctr, iRotVctr, m);
+
+
+ /* update states pointer */
+ pStates1 = &pStates1[cldfbBank->no_channels];
+ pStates2 = &pStates2[cldfbBank->no_channels];
+ pStates3 = &pStates3[cldfbBank->no_channels];
+ pStates5 = &pStates5[cldfbBank->no_channels];
+ pStates4 = &pStates4[cldfbBank->no_channels];
+ pStates6 = &pStates6[cldfbBank->no_channels];
+ }
+
+}
+
+
+/* cldfbSynthesisFiltering
+
+ Parameters:
+ cldfbBank I/O: handle to analysis CLDFB filter struct
+ **rAnalysis I: matrix holding the real part of the subband samples
+ **iAnalysis I: matrix holding the imaginary part of the subband samples
+ *scaleFactor I: pointer to cldfb scalefactor struct
+ ov_len I: determines overlapping area in time slots (obsolete)
+ *timeOut O: pointer to time domain data
+ stride I: stride for time domain data
+ *pWorkBuffer I: pointer to scratch buffer, needed for buffer of size 2*cldfbbands*Word32 + 2*cldfbbands*Word16
+
+ Function:
+ Performs inverse complex-valued subband filtering of the subband samples in rAnalysis and iAnalysis
+ and stores the time domain data in timeOut
+
+ Returns:
+ void
+*/
+void
+cldfbSynthesisFiltering( HANDLE_CLDFB_FILTER_BANK cldfbBank,
+ Word32 **rAnalysis,
+ Word32 **iAnalysis,
+ const CLDFB_SCALE_FACTOR *scaleFactor,
+ Word16 *timeOut,
+ const Word16 timeOut_e,
+ const Word16 nTimeSlots,
+ Word32 *pWorkBuffer
+ )
+{
+ Word16 i;
+ Word16 k;
+ Word16 L2;
+ Word16 m;
+ Word16 m2;
+ Word16 Lz;
+ Word16 Mz;
+ Word32 acc;
+ Word16 offset1;
+ Word16 offset2;
+ Word16 channels0;
+ Word16 channels1;
+ Word16 channels2;
+ Word16 channels3;
+ Word16 channels4;
+ Word16 statesSizeM1;
+ Word16 statesSizeM2;
+ Word16 stride;
+
+ Word16 scale, scaleMod;
+ Word16 outScale;
+ Word16 scaleLB;
+ Word16 scaleHB;
+
+ Word32 *rAnalysisS;
+ Word32 *iAnalysisS;
+
+ Word32 *rBuffer;
+ Word32 *iBuffer;
+ Word16 *nBuffer;
+
+ Word16 *pStates;
+ Word16 *pStatesI;
+ Word16 *pStatesR;
+
+ const Word16 *pFilterS;
+ const Word16 *pFilterM;
+
+ const Word16 *rRotVctr;
+ const Word16 *iRotVctr;
+ Word32 workBuffer[2*BASOP_CFFT_MAX_LENGTH];
+
+ m = cldfbBank->no_channels;
+ move16();
+ L2 = shl(m,1);
+ m2 = shr(m,1);
+ Lz = s_min(cldfbBank->lsb, sub(m,cldfbBank->bandsToZero));
+ Mz = s_min(cldfbBank->usb, sub(m,cldfbBank->bandsToZero));
+ stride = 1; /* constant */
+
+ channels0 = sub(m,cldfbBank->zeros);
+ channels1 = sub(m,1);
+ channels2 = shl(m,1);
+ channels3 = add(m,channels2);
+ channels4 = shl(channels2,1);
+
+ statesSizeM1 = sub(shl(cldfbBank->p_filter_length,1),m);
+ statesSizeM2 = sub(statesSizeM1,m);
+
+ offset1 = sub(channels1,cldfbBank->zeros);
+ offset2 = add(offset1,cldfbBank->no_channels);
+
+ rBuffer = &pWorkBuffer[0];
+ iBuffer = &pWorkBuffer[m];
+ nBuffer = (Word16*)(&pWorkBuffer[L2]);
+
+ rAnalysisS = &pWorkBuffer[3*m];
+ iAnalysisS = &pWorkBuffer[4*m];
+
+ rRotVctr = cldfbBank->rRotVctr;
+ iRotVctr = cldfbBank->iRotVctr;
+
+ scale = scaleFactor->lb_scale;
+ move16();
+ if ( NE_16(Lz, Mz))
+ {
+ scale = s_max(scale, scaleFactor->hb_scale);
+ }
+ scaleLB = limitScale32(sub(scale, scaleFactor->lb_scale));
+ scaleHB = limitScale32(sub(scale, scaleFactor->hb_scale));
+
+ outScale = cldfbBank->synFilterHeadroom;
+ move16();
+
+ scaleMod = sub(add(scale, cldfbBank->outScalefactor), outScale);
+
+ /* Increase CLDFB synthesis states for low level signals */
+ IF ( LT_16(scale, 8))
+ {
+ scaleMod = add(scaleMod, 2);
+ outScale = sub(outScale, 2);
+ }
+ scaleMod = sub(scaleMod, timeOut_e);
+ scale = add(outScale, timeOut_e);
+ IF ( NE_16(scale, cldfbBank->FilterStates_eg))
+ {
+ Scale_sig(cldfbBank->FilterStates, statesSizeM2, sub(cldfbBank->FilterStates_eg, scale));
+ cldfbBank->FilterStates_eg = scale;
+ move16();
+ }
+
+ FOR (k=0; k < nTimeSlots; k++)
+ {
+ {
+ FOR (i=0; i < Lz; i+=2)
+ {
+ rAnalysisS[i] = L_shr(rAnalysis[k][i],scaleLB);
+ move32();
+ iAnalysisS[i] = L_negate(L_shr(iAnalysis[k][i],scaleLB));
+ move32();
+ }
+
+ IF ( LT_16(i,Mz))
+ {
+ FOR ( ; i < Mz; i+=2)
+ {
+ rAnalysisS[i] = L_shr(rAnalysis[k][i],scaleHB);
+ move32();
+ iAnalysisS[i] = L_negate(L_shr(iAnalysis[k][i],scaleHB));
+ move32();
+ }
+ }
+
+ IF ( LT_16(i,m))
+ {
+ FOR ( ; i < m; i+=2)
+ {
+ rAnalysisS[i] = L_deposit_l(0);
+ iAnalysisS[i] = L_deposit_l(0);
+ }
+ }
+
+ FOR (i=1; i < Lz; i+=2)
+ {
+ rAnalysisS[i] = L_shr(rAnalysis[k][i],scaleLB);
+ move32();
+ iAnalysisS[i] = L_shr(iAnalysis[k][i],scaleLB);
+ move32();
+ }
+
+ IF ( LT_16(i,Mz))
+ {
+ FOR ( ; i < Mz; i+=2)
+ {
+ rAnalysisS[i] = L_shr(rAnalysis[k][i],scaleHB);
+ move32();
+ iAnalysisS[i] = L_shr(iAnalysis[k][i],scaleHB);
+ move32();
+ }
+ }
+
+ IF ( LT_16(i,m))
+ {
+ FOR ( ; i < m; i+=2)
+ {
+ rAnalysisS[i] = L_deposit_l(0);
+ iAnalysisS[i] = L_deposit_l(0);
+ }
+ }
+ }
+
+ /* pre modulation */
+ calcModulation(&rBuffer[0], &rBuffer[1], &rAnalysisS[0], &rAnalysisS[m-1], 2, 2, 2,-2,
+ &iBuffer[0], &iBuffer[1], &iAnalysisS[0], &iAnalysisS[m-1], 2, 2, 2,-2,
+ rRotVctr, iRotVctr, m);
+
+
+ /* FFT of DST IV */
+ scale = 0;
+ move16();
+ BASOP_cfft((cmplx *)rBuffer, m2, &scale, workBuffer);
+
+ /* FFT of DCT IV */
+ scale = scaleMod;
+ move16();
+ BASOP_cfft((cmplx *)iBuffer, m2, &scale, workBuffer);
+
+ /* post modulation and folding */
+ calcModulationAndFolding(nBuffer, rBuffer, iBuffer, rRotVctr, iRotVctr, cldfbBank->synGain, scale, m, m2);
+
+ /* prototype filter */
+ pStates = &cldfbBank->FilterStates[k*L2];
+ pFilterS = &cldfbBank->p_filter[0];
+ pFilterM = &cldfbBank->p_filter[shr(cldfbBank->p_filter_length,1)];
+
+ FOR (i=0; i < channels0; i++)
+ {
+ pStatesI = &pStates[i];
+ pStatesR = &pStates[i+channels3];
+
+ acc = L_mult( *pStatesI, *pFilterS++);
+ acc = L_mac(acc, *pStatesR, *pFilterM++);
+ pStatesR += channels4;
+ pStatesI += channels4;
+
+ acc = L_mac(acc, *pStatesI, *pFilterS++);
+ acc = L_mac(acc, *pStatesR, *pFilterM++);
+ pStatesR += channels4;
+ pStatesI += channels4;
+
+ acc = L_mac(acc, *pStatesI, *pFilterS++);
+ acc = L_mac(acc, *pStatesR, *pFilterM++);
+ pStatesR += channels4;
+ pStatesI += channels4;
+
+ acc = L_mac(acc, *pStatesI, *pFilterS++);
+ acc = L_mac(acc, *pStatesR, *pFilterM++);
+ pStatesI += channels4;
+
+ acc = L_mac(acc, *pStatesI, *pFilterS++);
+ acc = L_mac(acc, nBuffer[channels1-i], *pFilterM++);
+
+ BASOP_SATURATE_WARNING_OFF
+ timeOut[(offset1-i)*stride] = round_fx(L_shl(acc,outScale));
+ BASOP_SATURATE_WARNING_ON
+ }
+
+ FOR ( ; ino_channels; i++)
+ {
+ pStatesI = &pStates[i+channels2];
+ pStatesR = &pStates[i+channels2+channels3];
+
+ acc = L_mult( *pStatesI, *pFilterS++);
+ acc = L_mac(acc, *pStatesR, *pFilterM++);
+ pStatesR += channels4;
+ pStatesI += channels4;
+
+ acc = L_mac(acc, *pStatesI, *pFilterS++);
+ acc = L_mac(acc, *pStatesR, *pFilterM++);
+ pStatesR += channels4;
+ pStatesI += channels4;
+
+ acc = L_mac(acc, *pStatesI, *pFilterS++);
+ acc = L_mac(acc, *pStatesR, *pFilterM++);
+ pStatesR += channels4;
+ pStatesI += channels4;
+
+ acc = L_mac(acc, *pStatesI, *pFilterS++);
+ acc = L_mac(acc, *pStatesR, *pFilterM++);
+
+ acc = L_mac(acc, nBuffer[channels1+m-i], *pFilterS++);
+ pFilterM++;
+
+ BASOP_SATURATE_WARNING_OFF
+ timeOut[(offset2-i)*stride] = round_fx(L_shl(acc,outScale));
+ BASOP_SATURATE_WARNING_ON
+ }
+
+ FOR (i=0; ino_channels; i++)
+ {
+ pStates[statesSizeM1+i] = nBuffer[channels1-i];
+ move16();
+ pStates[statesSizeM2+i] = nBuffer[channels1+m-i];
+ move16();
+ }
+
+ timeOut = &timeOut[m*stride];
+ }
+
+ /* move filter states */
+ Copy(&cldfbBank->FilterStates[i_mult(nTimeSlots,L2)], cldfbBank->FilterStates, statesSizeM2);
+ set16_fx(&cldfbBank->FilterStates[statesSizeM2],0,L2);
+
+}
+
+
+/*-------------------------------------------------------------------*
+ * configureClfdb()
+ *
+ * configures a CLDFB handle
+ *--------------------------------------------------------------------*/
+
+void configureCldfb ( HANDLE_CLDFB_FILTER_BANK h_cldfb, /*!< Returns handle */
+ const Word16 no_channels, /*!< Number of channels (bands) */
+ const Word16 frameSize /*!< FrameSize */
+ )
+{
+
+ h_cldfb->no_channels = no_channels;
+ move16();
+ assert(h_cldfb->no_channels >= 10);
+ h_cldfb->no_col = div_l(frameSize,shr(h_cldfb->no_channels,1));
+
+ /* was cldfbInitFilterBank()*/
+ h_cldfb->anaScalefactor = 0;
+ move16();
+ h_cldfb->synScalefactor = 0;
+ move16();
+ h_cldfb->bandsToZero = 0;
+ move16();
+ h_cldfb->filtermode = 0;
+ move16();
+ h_cldfb->memory = 0;
+ move16();
+ h_cldfb->memory_length = 0;
+ move16();
+
+ h_cldfb->p_filter_length = i_mult(10,h_cldfb->no_channels);
+ move16();
+
+ h_cldfb->flags = s_or(h_cldfb->flags,CLDFB_FLAG_2_5MS_SETUP);
+ h_cldfb->filterScale = CLDFB_CLDFB80_PFT_SCALE;
+ move16();
+
+ h_cldfb->zeros = 0;
+ move16();
+ h_cldfb->synFilterHeadroom = SYN_FILTER_HEADROOM_2_5MS;
+ move16();
+
+ cldfb_init_proto_and_twiddles (h_cldfb);
+
+ h_cldfb->lsb = no_channels;
+ move16();
+ h_cldfb->usb = s_min(no_channels, h_cldfb->no_channels); /* Does this make any sense? in the previous implemenatation lsb, usb and no_channels are all maxCldfbBands */ move16();
+
+ h_cldfb->FilterStates = (void*)h_cldfb->FilterStates;
+ h_cldfb->outScalefactor = h_cldfb->synScalefactor;
+ move16();
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * openClfdb()
+ *
+ * open and configures a CLDFB handle
+ *--------------------------------------------------------------------*/
+void openCldfb ( HANDLE_CLDFB_FILTER_BANK *h_cldfb, /*!< Returns handle */
+ const Word16 type, /*!< analysis or synthesis */
+ const Word16 maxCldfbBands, /*!< number of cldfb bands */
+ const Word16 frameSize /*!< FrameSize */
+ )
+{
+ HANDLE_CLDFB_FILTER_BANK hs;
+
+ hs = (HANDLE_CLDFB_FILTER_BANK) calloc(1, sizeof (struct CLDFB_FILTER_BANK));
+
+
+ hs->type = type;
+ move16();
+
+ IF (type == CLDFB_ANALYSIS)
+ {
+ hs->FilterStates = (Word16 *) calloc(STATE_BUFFER_SIZE*maxCldfbBands, sizeof (Word16));
+ }
+ ELSE
+ {
+ hs->FilterStates = (Word16 *) calloc( 2 * STATE_BUFFER_SIZE * maxCldfbBands, sizeof (Word16));
+ }
+ hs->flags &= ~CLDFB_FLAG_KEEP_STATES;
+
+ configureCldfb (hs, maxCldfbBands, frameSize );
+
+ hs->memory = NULL;
+ hs->memory_length = 0;
+ move16();
+
+ IF( hs->type == CLDFB_ANALYSIS)
+ {
+ test();
+ IF ( (s_and(hs->flags,CLDFB_FLAG_KEEP_STATES) == 0) && (hs->FilterStates != 0) )
+ {
+ set16_fx(hs->FilterStates, 0, i_mult(STATE_BUFFER_SIZE,hs->no_channels));
+ set16_fx(hs->FilterStates_e, 0, sizeof(hs->FilterStates_e)/sizeof(hs->FilterStates_e[0]));
+
+ hs->FilterStates_eg = 0;
+ move16();
+ }
+ }
+ ELSE IF (hs->type == CLDFB_SYNTHESIS )
+ {
+ IF ( hs->FilterStates != 0 )
+ {
+ IF ( s_and(hs->flags,CLDFB_FLAG_KEEP_STATES) == 0 )
+ {
+ set16_fx(hs->FilterStates, 0, i_mult( shl(STATE_BUFFER_SIZE,1), hs->no_channels));
+ }
+ }
+ hs->FilterStates_eg = 0;
+ move16();
+ }
+
+ if (h_cldfb != NULL)
+ {
+ *h_cldfb = hs;
+ }
+
+ return;
+}
+
+
+/*-------------------------------------------------------------------*
+* resampleCldfb()
+*
+* Change sample rate of filter bank
+*--------------------------------------------------------------------*/
+void resampleCldfb (HANDLE_CLDFB_FILTER_BANK hs,
+ const Word16 newCldfbBands,
+ const Word16 frameSize,
+ const Word8 firstFrame
+ )
+
+{
+ Word16 timeOffset;
+ Word16 timeOffsetOld;
+ Word16 noChannelsOld;
+
+ noChannelsOld = hs->no_channels;
+ move16();
+ timeOffsetOld = sub(sub(hs->p_filter_length,hs->no_channels),hs->zeros);
+
+ /* change all CLDFB bank parameters that depend on the no of channels */
+ hs->flags = s_or(hs->flags,CLDFB_FLAG_KEEP_STATES);
+ move16();
+
+ /* new settings */
+ configureCldfb (hs, newCldfbBands, frameSize);
+
+ /* resample cldfb state buffer */
+ timeOffset = sub(sub(hs->p_filter_length,hs->no_channels),hs->zeros);
+
+ IF( firstFrame == 0 )
+ {
+ /*low complexity-resampling only stored previous samples that are needed for next frame modulation */
+ lerp(hs->FilterStates+(noChannelsOld*hs->no_col), hs->FilterStates+(noChannelsOld*hs->no_col), timeOffset, timeOffsetOld);
+ Copy(hs->FilterStates+(noChannelsOld*hs->no_col), hs->FilterStates+frameSize, timeOffset);
+ }
+
+ return;
+}
+
+/*
+ AnalysisPostSpectrumScaling_Fx
+
+ Parameters:
+ cldfbBank I: CLDFB handle
+ **rSubband32 I: matrix holding real part of the CLDFB subsamples
+ **iSubband32 I: matrix holding imaginary part of the CLDFB subsamples
+ **rSubband16 O: matrix holding real part of the CLDFB subsamples
+ **iSubband16 O: matrix holding imaginary part of the CLDFB subsamples
+ *cldfbScale O: cldfb lowband scalefactor
+
+ Function:
+ performs dynamic spectrum scaling for all subband
+
+ Returns:
+ headroom
+*/
+Word16
+AnalysisPostSpectrumScaling_Fx (HANDLE_CLDFB_FILTER_BANK cldfbBank, /*!< Handle of cldfbBank */
+ Word32 **rSubband32, /*!< Real bands */
+ Word32 **iSubband32, /*!< Imaginary bands */
+ Word16 **rSubband16, /*!< Real bands */
+ Word16 **iSubband16, /*!< Imaginary bands */
+ Word16 *cldfbScale /*!< CLDFB lowband scalefactor */
+ )
+{
+ Word16 i;
+ Word16 j;
+ Word16 headRoom;
+
+
+
+ headRoom = BASOP_util_norm_l_dim2_cplx (
+ (const Word32 * const*) rSubband32,
+ (const Word32 * const*) iSubband32,
+ 0,
+ cldfbBank->no_channels,
+ 0,
+ cldfbBank->no_col
+ );
+
+ FOR (i=0; i < cldfbBank->no_col; i++)
+ {
+ FOR (j=0; j < cldfbBank->no_channels; j++)
+ {
+ rSubband16[i][j] = round_fx(L_shl(rSubband32[i][j], headRoom));
+ iSubband16[i][j] = round_fx(L_shl(iSubband32[i][j], headRoom));
+ }
+ }
+
+ *cldfbScale = add(*cldfbScale,headRoom);
+ move16();
+
+
+ return headRoom;
+}
+
+
+/*-------------------------------------------------------------------*
+* analysisCLDFBEncoder()
+*
+* Encoder CLDFB analysis + energy stage
+*--------------------------------------------------------------------*/
+
+void analysisCldfbEncoder_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 *timeIn,
+ Word32 realBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX],
+ Word32 imagBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX],
+ Word16 realBuffer16[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX],
+ Word16 imagBuffer16[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX],
+ Word32 enerBuffSum[CLDFB_NO_CHANNELS_MAX],
+ Word16 *enerBuffSum_exp,
+ CLDFB_SCALE_FACTOR * scale
+)
+{
+ Word16 i;
+ CLDFB_SCALE_FACTOR enerScale;
+ Word32 *ppBuf_Real[CLDFB_NO_COL_MAX];
+ Word32 *ppBuf_Imag[CLDFB_NO_COL_MAX];
+ Word16 *ppBuf_Real16[CLDFB_NO_COL_MAX];
+ Word16 *ppBuf_Imag16[CLDFB_NO_COL_MAX];
+ Word32 workBuffer[256];
+ Word16 num_slots = 1;
+
+ FOR (i=0; icldfbAna_Fx,
+ ppBuf_Real,
+ ppBuf_Imag,
+ scale,
+ timeIn,
+ 0,
+ CLDFB_NO_COL_MAX,
+ workBuffer
+ );
+
+ enerScale.lb_scale = negate(scale->lb_scale);
+ enerScale.lb_scale16 = negate(scale->lb_scale);
+
+ /* get 16bit respresentation */
+ AnalysisPostSpectrumScaling_Fx (
+ st_fx->cldfbAna_Fx,
+ ppBuf_Real,
+ ppBuf_Imag,
+ ppBuf_Real16,
+ ppBuf_Imag16,
+ &enerScale.lb_scale16
+ );
+
+ /* get the energy */
+ GetEnergyCldfb( &st_fx->energyCoreLookahead_Fx,
+ &st_fx->sf_energyCoreLookahead_Fx,
+ num_slots,
+ ppBuf_Real16,
+ ppBuf_Imag16,
+ enerScale.lb_scale16,
+ st_fx->cldfbAna_Fx->no_channels,
+ st_fx->cldfbAna_Fx->no_col,
+ &st_fx->currEnergyHF_fx,
+ &st_fx->currEnergyHF_e_fx,
+ enerBuffSum,
+ enerBuffSum_exp,
+ &st_fx->tecEnc
+ );
+
+ return;
+}
+
+void
+GetEnergyCldfb( Word32 *energyLookahead, /*!< o: Q(*sf_energyLookahead) | pointer to the result in the core look-ahead slot */
+ Word16 *sf_energyLookahead, /*!< o: pointer to the scalefactor of the result in the core look-ahead slot */
+ const Word16 numLookahead, /*!< i: Q0 the number of look-ahead time-slots */
+ Word16 **realValues, /*!< i: Q(sf_Values) | the real part of the CLDFB subsamples */
+ Word16 **imagValues, /*!< i: Q(sf_Values) | the imaginary part of the CLDFB subsamples */
+ Word16 sf_Values, /*!< i: scalefactor of the CLDFB subcamples - apply as a negated Exponent */
+ Word16 numberBands, /*!< i: Q0 | number of CLDFB bands */
+ Word16 numberCols, /*!< i: Q0 | number of CLDFB subsamples */
+ Word32 *energyHF, /*!< o: Q31 | pointer to HF energy */
+ Word16 *energyHF_Exp, /*!< o: pointer to exponent of HF energy */
+ Word32 *energyValuesSum, /*!< o: Q(2*sf_Values-4) | pointer to sum array of energy values, not initialized*/
+ Word16 *energyValuesSum_Exp,/*!< o: pointer to exponents of energyValuesSum, not initialized */
+ HANDLE_TEC_ENC_FX hTecEnc
+ )
+{
+ Word16 j;
+ Word16 k;
+ Word16 s;
+ Word16 sm;
+ Word32 nrg;
+ Word16 numberColsL;
+ Word16 numberBandsM;
+ Word16 numberBandsM20;
+ Word32 energyValues[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX];
+ Word16 energyValuesSumE[CLDFB_NO_CHANNELS_MAX];
+ Word16 freqTable[2] = {20, 40};
+
+
+ FOR (k=0; kloBuffer,
+ hTecEnc->hiTempEnv,
+ ScaleX2
+ );
+ }
+
+ FOR (j=0; j< numberBands; j++)
+ {
+ energyValuesSum[j] = L_deposit_l(0);
+ energyValuesSumE[j] = 31;
+ move16();
+ FOR (k=0; k value 0x40000000, scale 44 */
+ *energyLookahead = L_add(L_shr(nrg, sub(s, sm)),
+ L_shr(0x40000000, s_max(-31, s_min(31, sub(44, sm)))));
+ move32();
+ BASOP_SATURATE_WARNING_ON
+ *sf_energyLookahead = sm;
+ move16();
+
+ return;
+ }
+
+
+
+ *energyHF = 0x40000000;
+ move32();
+ *energyHF_Exp = 17;
+ move16();
+
+
+}
+
+
+Word16
+CLDFB_getNumChannels(Word32 sampleRate)
+{
+
+ Word16 nChannels = 0;
+
+
+ SWITCH (sampleRate)
+ {
+ case 48000:
+ move16();
+ nChannels = 60;
+ BREAK;
+ case 32000:
+ move16();
+ nChannels = 40;
+ BREAK;
+ case 25600:
+ move16();
+ nChannels = 32;
+ BREAK;
+ case 16000:
+ move16();
+ nChannels = 20;
+ BREAK;
+ case 12800:
+ move16();
+ nChannels = 16;
+ BREAK;
+ case 8000:
+ move16();
+ nChannels = 10;
+ BREAK;
+ }
+
+ return (nChannels);
+}
+
+/*-------------------------------------------------------------------*
+* cldfb_get_memory_length()
+*
+* Return length of filter state for recovery
+*--------------------------------------------------------------------*/
+static Word16
+cldfb_get_memory_length (HANDLE_CLDFB_FILTER_BANK hs)
+{
+ IF (EQ_16(hs->type,CLDFB_ANALYSIS))
+ {
+ return (i_mult(hs->no_channels,STATE_BUFFER_SIZE));
+ }
+ ELSE
+ {
+ return (i_mult(hs->no_channels,(9*2)) );
+ }
+}
+
+/*-------------------------------------------------------------------*
+* GetEnergyCldfb()
+*
+* Remove handle
+*--------------------------------------------------------------------*/
+void
+deleteCldfb (HANDLE_CLDFB_FILTER_BANK * h_cldfb) /* i: cldfb handle */
+{
+ IF ( *h_cldfb != NULL )
+ {
+ IF ( (*h_cldfb)->FilterStates != NULL )
+ {
+ free((*h_cldfb)->FilterStates);
+ }
+ free(*h_cldfb);
+ }
+ *h_cldfb = NULL;
+}
+
+
+/*-------------------------------------------------------------------*
+* cldfb_init_proto_and_twiddles()
+*
+* Initializes rom pointer
+*--------------------------------------------------------------------*/
+static void
+cldfb_init_proto_and_twiddles(HANDLE_CLDFB_FILTER_BANK hs) /* i: cldfb handle */
+{
+
+ /*find appropriate set of rotVecs*/
+ SWITCH(hs->no_channels)
+ {
+ case 10:
+
+ hs->rRotVctr = rRotVectr_10;
+ hs->iRotVctr = iRotVectr_10;
+ hs->synGain = cldfb_synGain[0];
+ move16();
+ hs->p_filter = cldfb_protoFilter_2_5ms[0];
+ hs->scale = cldfb_scale_2_5ms[0];
+ move16();
+ IF (hs->type == CLDFB_SYNTHESIS )
+ {
+ hs->synScalefactor = add(cldfb_synScale[0],hs->filterScale);
+ move16();
+ }
+ ELSE
+ {
+ hs->anaScalefactor = add(cldfb_anaScale[0],hs->filterScale);
+ move16();
+ }
+ break;
+
+ case 16:
+ hs->rRotVctr = rRotVectr_16;
+ hs->iRotVctr = iRotVectr_16;
+ hs->synGain = cldfb_synGain[1];
+ move16();
+ hs->p_filter = cldfb_protoFilter_2_5ms[1];
+ hs->scale = cldfb_scale_2_5ms[1];
+ move16();
+ {
+ hs->anaScalefactor = add(cldfb_anaScale[1],hs->filterScale);
+ move16();
+ }
+ break;
+
+ case 20:
+ hs->rRotVctr = rRotVectr_20;
+ hs->iRotVctr = iRotVectr_20;
+ hs->synGain = cldfb_synGain[2];
+ move16();
+ hs->p_filter = cldfb_protoFilter_2_5ms[2];
+ hs->scale = cldfb_scale_2_5ms[2];
+ move16();
+ IF (hs->type == CLDFB_SYNTHESIS )
+ {
+ hs->synScalefactor = add(cldfb_synScale[2],hs->filterScale);
+ move16();
+ }
+ ELSE
+ {
+ hs->anaScalefactor = add(cldfb_anaScale[2],hs->filterScale);
+ move16();
+ }
+ break;
+
+ case 32:
+ hs->rRotVctr = rRotVectr_32;
+ hs->iRotVctr = iRotVectr_32;
+ hs->synGain = cldfb_synGain[3];
+ move16();
+ hs->p_filter = cldfb_protoFilter_2_5ms[3];
+ hs->scale = cldfb_scale_2_5ms[3];
+ move16();
+ {
+ hs->anaScalefactor = add(cldfb_anaScale[3],hs->filterScale);
+ move16();
+ }
+ break;
+
+ case 40:
+ hs->rRotVctr = rRotVectr_40;
+ hs->iRotVctr = iRotVectr_40;
+ hs->synGain = cldfb_synGain[4];
+ move16();
+ hs->p_filter = cldfb_protoFilter_2_5ms[4];
+ hs->scale = cldfb_scale_2_5ms[4];
+ move16();
+ IF (hs->type == CLDFB_SYNTHESIS )
+ {
+ hs->synScalefactor = add(cldfb_synScale[4],hs->filterScale);
+ move16();
+ }
+ ELSE
+ {
+ hs->anaScalefactor = add(cldfb_anaScale[4],hs->filterScale);
+ move16();
+ }
+ break;
+
+ case 60:
+ hs->rRotVctr = rRotVectr_60;
+ hs->iRotVctr = iRotVectr_60;
+ hs->synGain = cldfb_synGain[5];
+ move16();
+ hs->p_filter = cldfb_protoFilter_2_5ms[5];
+ hs->scale = cldfb_scale_2_5ms[5];
+ move16();
+ IF (hs->type == CLDFB_SYNTHESIS )
+ {
+ hs->synScalefactor = add(cldfb_synScale[5],hs->filterScale);
+ move16();
+ }
+ ELSE
+ {
+ hs->anaScalefactor = add(cldfb_anaScale[5],hs->filterScale);
+ move16();
+ }
+ break;
+
+ }
+}
+
+
+#define CLDFB_MEM_EXPONENTS (CLDFB_NO_COL_MAX+9)
+
+/*-------------------------------------------------------------------*
+* cldfb_save_memory()
+*
+* Save the memory of filter; to be restored with cldfb_restore_memory()
+*--------------------------------------------------------------------*/
+void
+cldfb_save_memory (HANDLE_CLDFB_FILTER_BANK hs) /* i: cldfb handle */
+{
+
+ hs->memory_length = cldfb_get_memory_length(hs);
+ hs->memory = (Word16 *) calloc( hs->memory_length + CLDFB_MEM_EXPONENTS + 1, sizeof (Word16));
+
+
+ /* save the memory */
+ Copy (hs->FilterStates, hs->memory, hs->memory_length);
+ Copy (hs->FilterStates_e, hs->memory+hs->memory_length, CLDFB_MEM_EXPONENTS);
+ hs->memory[hs->memory_length+CLDFB_MEM_EXPONENTS] = hs->FilterStates_eg;
+ move16();
+
+ return;
+}
+
+
+/*-------------------------------------------------------------------*
+* cldfb_restore_memory()
+*
+* Restores the memory of filter; memory to be save by cldfb_save_memory()
+*--------------------------------------------------------------------*/
+void
+cldfb_restore_memory (HANDLE_CLDFB_FILTER_BANK hs) /* i/o: cldfb handle */
+
+{
+ Word16 size;
+
+
+ size = cldfb_get_memory_length(hs);
+
+ /* read the memory */
+ Copy (hs->memory, hs->FilterStates, hs->memory_length);
+ Copy (hs->memory+hs->memory_length, hs->FilterStates_e, CLDFB_MEM_EXPONENTS);
+ hs->FilterStates_eg = hs->memory[hs->memory_length+CLDFB_MEM_EXPONENTS];
+ move16();
+
+ /* adjust sample rate if it was changed in the meanwhile */
+ IF (NE_16 (hs->memory_length,size))
+ {
+ lerp(hs->FilterStates, hs->FilterStates, size, hs->memory_length);
+ }
+
+ hs->memory_length = 0;
+ free(hs->memory);
+ hs->memory = NULL;
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+* cldfb_reset_memory()
+*
+* Resets the memory of filter.
+*--------------------------------------------------------------------*/
+void
+cldfb_reset_memory (HANDLE_CLDFB_FILTER_BANK hs) /* i/o: cldfb handle */
+{
+ Word16 length;
+
+ length = cldfb_get_memory_length(hs);
+ /* erase the memory */
+ set16_fx (hs->FilterStates, 0, length);
+ set16_fx (hs->FilterStates_e, 0, sizeof(hs->FilterStates_e)/sizeof(hs->FilterStates_e[0]));
+ hs->FilterStates_eg = 0;
+ move16();
+}
+
diff --git a/lib_com/cng_exc_fx.c b/lib_com/cng_exc_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..b0249f69ef874f5474c4b54106511726ab22b2e5
--- /dev/null
+++ b/lib_com/cng_exc_fx.c
@@ -0,0 +1,890 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+#include "rom_com_fx.h"
+
+/*---------------------------------------------------------------------*
+ * Local constants
+ *---------------------------------------------------------------------*/
+#define A2 6554
+#define OmA2 (32768-A2)
+#define GAIN_VAR 11811 /* in Q31 divided by 2 (Q30) */
+
+/*-------------------------------------------------------*
+ * CNG_exc()
+ *
+ * Comfort noise generation routine
+ *-------------------------------------------------------*/
+
+void CNG_exc_fx(
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 L_frame, /* i : length of the frame */
+ Word32 *Enew, /* i/o: decoded SID energy Q6 */
+ Word16 *seed, /* i/o: random generator seed */
+ Word16 exc[], /* o : current non-enhanced excitation Q_new */
+ Word16 exc2[], /* o : current enhanced excitation Q_new */
+ Word32 *lp_ener, /* i/o: LP filtered E */
+ const Word32 last_core_brate, /* i : previous frame core bitrate */
+ Word16 *first_CNG, /* i/o: first CNG frame flag for energy init. */
+ Word16 *cng_ener_seed, /* i/o: random generator seed for CNG energy */
+ Word16 bwe_exc[], /* o : excitation for SWB TBE */
+ const Word16 allow_cn_step, /* i : allow CN step */
+ Word16 *last_allow_cn_step, /* i/o: last allow step */
+ const Word16 OldQ_exc, /* i : Old excitation scaling */
+ const Word16 Q_exc /* i : excitation scaling */
+ , const Word16 num_ho /* i : number of selected hangover frames */
+ ,Word32 q_env[]
+ ,Word32 *lp_env
+ ,Word32 *old_env
+ ,Word16 *exc_mem
+ ,Word16 *exc_mem1
+ ,Word16 *sid_bw
+ ,Word16 *cng_ener_seed1
+ ,Word16 exc3[]
+ ,Word16 Opt_AMR_WB
+)
+{
+ Word16 i, tmp, tmp2, exp, exp2, Q_ener;
+ Word32 L_tmp_ener, L_tmp;
+ Word16 i_subfr;
+ Word16 pit_max;
+ Word16 ftmp,j;
+ Word16 *ptR,*ptI;
+ Word16 fft_io[L_FRAME16k];
+ Word32 itmp[129];
+ Word32 env[NUM_ENV_CNG];
+ Word32 enr1;
+ Word32 denv[NUM_ENV_CNG];
+ Word16 fra;
+ Word16 temp_lo_fx, temp_hi_fx;
+ Word16 exp_pow;
+ Word32 L_tmp2;
+ Word16 *pt_fft_io;
+
+ /*------------------------------------------------------------------*
+ * Initializations
+ *------------------------------------------------------------------*/
+
+ pit_max = PIT16k_MAX;
+ move16();
+ if( EQ_16(L_frame,L_FRAME))
+ {
+ pit_max = PIT_MAX;
+ move16();
+ }
+
+ /*---------------------------------------------------------------------*
+ * Initialization of CNG energy for the first CNG frame
+ *---------------------------------------------------------------------*/
+
+ IF(*first_CNG == 0 )
+ {
+ IF(EQ_32(core_brate,FRAME_NO_DATA))
+ {
+ /* needed only in decoder when the very first SID frame was erased and this frame is FRAME_NO_DATA frame */
+ /*fenew = dotp( fexc, fexc, pit_max )/pit_max;*/
+ L_tmp_ener = Calc_Energy_Autoscaled(exc-pit_max, OldQ_exc, pit_max, &Q_ener);
+ L_tmp_ener = Mult_32_16(L_tmp_ener, 9079); /* divide by PIT_MAX (in Q15 + Q6 to get output in Q6)*/
+ L_tmp_ener = L_shr(L_tmp_ener, Q_ener); /* -> If we want ener in Q6 */
+
+ if(EQ_16(L_frame, L_FRAME16k))
+ {
+ L_tmp_ener = Mult_32_16(L_tmp_ener, 26214); /* Compensate for 16kHz */
+ }
+ *Enew = L_tmp_ener;
+ move32();
+ }
+
+ *lp_ener = *Enew;
+ move32();
+ }
+
+ /*---------------------------------------------------------------------*
+ * Update CNG energy
+ *---------------------------------------------------------------------*/
+ test();
+ test();
+ IF( NE_32(last_core_brate,SID_1k75)&&NE_32(last_core_brate,FRAME_NO_DATA)&&NE_32(last_core_brate,SID_2k40))
+ {
+ /* Partially reset CNG energy after active speech period */
+ test();
+ IF ( allow_cn_step == 0 && *last_allow_cn_step == 0 )
+ {
+ test();
+ IF( LT_16(num_ho,3)||LT_32(Mult_32_16(*Enew,21845/*1/1.5f, Q15*/),*lp_ener))
+ {
+ /**lp_ener = 0.8f * *lp_ener + 0.2f * *Enew;*/
+ L_tmp_ener = Mult_32_16(*lp_ener, 26214);
+ L_tmp_ener = Madd_32_16(L_tmp_ener, *Enew, 6554);
+
+ }
+ ELSE
+ {
+ /**lp_ener = 0.95f * *lp_ener + 0.05f * *Enew;*/
+ L_tmp_ener = Mult_32_16(*lp_ener, 31130);
+ L_tmp_ener = Madd_32_16(L_tmp_ener, *Enew, 1638);
+ }
+ }
+ ELSE
+ {
+ L_tmp_ener = *Enew;
+ move32();
+ *last_allow_cn_step = 0;
+ move16();
+ }
+ }
+ ELSE
+ {
+ /* normal CNG update */
+ IF ( *last_allow_cn_step == 0 )
+ {
+ /**lp_ener = (float)(A2 * *Enew + (1-A2) * *lp_ener);*/
+ L_tmp_ener = Mult_32_16(*Enew, A2);
+ L_tmp_ener = Madd_32_16(L_tmp_ener, *lp_ener, OmA2);
+ }
+ ELSE
+ {
+ test();
+ if ( EQ_32(core_brate,SID_1k75)||EQ_32(core_brate,SID_2k40))
+ {
+ *last_allow_cn_step = 0;
+ move16();
+ }
+
+ L_tmp_ener = *Enew;
+ move32();
+
+ }
+ }
+ *lp_ener = L_max(L_tmp_ener,1);
+ move32(); /*To avoid / per 0*/
+
+ if ( EQ_16(allow_cn_step,1))
+ {
+ *last_allow_cn_step = 1;
+ move16();
+ }
+
+ /*---------------------------------------------------------------------*
+ * Generate white noise vector
+ *---------------------------------------------------------------------*/
+
+ /*for ( i=0; i Q_exc +16 */
+ exc2[i_subfr+i] = round_fx(L_shl(L_tmp, exp));
+ }
+ }
+ IF ( NE_16(Opt_AMR_WB,1))
+ {
+ Copy( exc2, exc3, L_FRAME16k);
+
+ /* enr1 = (float)log10( *Enew*L_frame + 0.1f ) / (float)log10( 2.0f ); */
+ exp = norm_l(*Enew);
+ L_tmp = L_shl(*Enew,exp); /* Q(exp+6) */
+ L_tmp = Mult_32_16(L_tmp,shl(L_frame,5)); /* Q(exp+6+5-15=exp-4) */
+ L_tmp = L_shr(L_tmp,sub(exp,10)); /* Q6 */
+
+ exp = norm_l(L_tmp);
+ fra = Log2_norm_lc(L_shl(L_tmp,exp));
+ exp = sub(sub(30,exp),6);
+ L_tmp = L_Comp(exp,fra);
+ /* enr1 = round_fx(L_shl(L_tmp,8)); */ /*Q8 */
+ enr1 = L_shr(L_tmp,10);/* Q6 */
+
+
+ IF ( EQ_32(core_brate,SID_2k40))
+ {
+ IF ( *sid_bw == 0 )
+ {
+ FOR ( i=0; iHQ switching gap in ms */
+#define HQ_DELAY_COMP NS2SA(8000, DELAY_CLDFB_NS)
+#define HQ_DELTA_MAX 6 /* maximum multiplication factor (==48kHz/8kHz) for core switching modules */
+
+#define N_ZERO_MDCT_NS 5625000L /* Number of zeros in ms for MDCT */
+#define NL_BUFF_OFFSET 12
+
+#define N_WS2N_FRAMES 40 /* number of frames for attenuation during the band-width switching */
+#define N_NS2W_FRAMES 20 /* number of frames for attenuation during the band-width switching */
+
+/*----------------------------------------------------------------------------------*
+ * Coder types (only for ACELP core when not running in AMR-WB IO mode)
+ *----------------------------------------------------------------------------------*/
+
+#define INACTIVE 0 /* inactive */
+#define UNVOICED 1 /* unvoiced */
+#define VOICED 2 /* purely voiced */
+#define GENERIC 3 /* generic */
+#define TRANSITION 4 /* transition */
+#define AUDIO 5 /* audio (GSC) */
+#define LR_MDCT 6 /* low-rate MDCT core */
+
+
+/*--------------------------------------------------*
+ * Partial copy frame types (only for ACELP core )
+ *--------------------------------------------------*/
+
+/* TCX partial copy frame types */
+#define RF_NO_DATA 0
+#define RF_TCXFD 1
+#define RF_TCXTD1 2
+#define RF_TCXTD2 3
+/* ACELP partial copy frame types */
+#define RF_ALLPRED ACELP_MODE_MAX
+#define RF_NOPRED ACELP_MODE_MAX + 1
+#define RF_GENPRED ACELP_MODE_MAX + 2
+#define RF_NELP ACELP_MODE_MAX + 3
+
+
+/*--------------------------------------------------------------*
+ * MODE2 Frame length constants
+ *---------------------------------------------------------------*/
+
+#define L_FRAME_MAX 960 /* Max 20ms frame size @48kHz */
+#define L_FRAME_PLUS 1200 /* Max frame size (long TCX frame) */
+#define L_MDCT_OVLP_MAX NS2SA(48000,ACELP_LOOK_NS) /* = Max mdct overlap */
+#define N_TCX10_MAX 480 /* Max size of TCX10 MDCT size */
+#define BITS_TEC 1 /* number of bits for TEC */
+#define BITS_TFA 1 /* number of bits for TTF */
+#define N_TEC_TFA_SUBFR 16 /* number of subframes of TEC/TFA */
+#define L_TEC_TFA_SUBFR16k (L_FRAME16k/N_TEC_TFA_SUBFR) /* TEC/TFA subframe size @ 16kHz*/
+#define MAX_TEC_SMOOTHING_DEG 6 /* max degree of smoothing for TEC */
+#define N_MAX 1200 /* Max size of MDCT spectrum = 25ms @ 48kHz */
+#define N_MAX_TCX 1000 /* Max size of MDCT spectrum = 25ms @ 48kHz */
+#define IGF_START_MN 164 /* MDCT lines not used by IGF*/
+#define IGF_START_MX 800 /* max. MDCT lines used by IGF*/
+
+#define L_FRAME_12k8 256 /* Frame size at 12k8Hz: 20ms = 256 samples */
+#define L_FRAME_16k 320 /* Frame size at 16kHz: 20ms = 320 samples */
+#define L_NEXT_MAX_12k8 112 /* maximum encoder lookahead at 12k8Hz */
+#define L_PAST_MAX_12k8 144 /* maximum encoder past samples at 12k8Hz */
+#define L_DIV 256 /* 20ms frame size (ACELP or short TCX frame) */
+#define L_DIV_MAX 320
+#define NB_DIV 2 /* number of division (frame) per 20ms frame */
+#define NB_SUBFR 4 /* number of 5ms subframe per 20ms frame */
+
+#define L_NEXT_MAX_16k 140 /* maximum encoder lookahead at 16kHz */
+#define L_NEXT_MAX_32k 280 /* maximum encoder lookahead at 32kHz */
+#define L_PAST_MAX_32k 360 /* maximum encoder past samples at 32kHz */
+
+#define MIDLSF_NBITS 5
+#define ENDLSF_NBITS 31
+
+/*----------------------------------------------------------------------------------*
+ * ACELP core constants
+ *----------------------------------------------------------------------------------*/
+
+#define SAFETY_NET 0
+#define MOVING_AVERAGE 1
+#define AUTO_REGRESSIVE 2
+
+#define ACELP_MODE_MAX 4
+
+#define RF_MODE_MAX 4
+
+#define M 16 /* order of the LP filter @ 12.8kHz */
+#define L_FRAME 256 /* frame size at 12.8kHz */
+#define NB_SUBFR 4 /* number of subframes per frame */
+#define L_SUBFR (L_FRAME/NB_SUBFR) /* subframe size */
+#define L_SUBFR_Q6 ((L_FRAME/NB_SUBFR)*64) /* subframe size */
+#define L_SUBFR_Q16 ((L_FRAME/NB_SUBFR)*65536) /* subframe size */
+
+#define L_INP_MEM (L_LOOK_16k + ((L_LP_16k - (NS2SA(INT_FS_16k, ACELP_LOOK_NS) + L_SUBFR16k/2)) - 3*L_SUBFR16k/2)) /* length of memory of input signal, given by the Look-Ahead + the past memory (max needed for the LP window at 16 kHz) */
+#define L_INP_12k8 (L_INP_MEM + L_FRAME) /* length of input signal buffer @12.8kHz */
+#define L_INP (L_INP_MEM + L_FRAME32k) /* length of input signal buffer */
+
+#define L_EXC_MEM L_FRAME16k /*(PIT16k_MAX + L_INTERPOL)*/ /* length of memory of excitation signal */
+#define L_EXC_MEM_12k8 (PIT_MAX + L_INTERPOL) /* length of memory of excitation signal @12.8kHz */
+#define L_EXC_MEM_DEC (3*L_FRAME16k/2) /*Half-frame needed for MODE2 PLC in case of TCX->ACELP*/
+#define L_EXC (L_EXC_MEM + L_FRAME16k + 1) /* length of excitation signal buffer */
+#define L_EXC_DEC (L_EXC_MEM_DEC + L_FRAME16k + 1 + L_SUBFR) /* length of decoder excitation signal buffer @16kHz*/
+#define L_SYN_MEM NS2SA(48000,DELAY_CLDFB_NS) /* synthesis memory length, 1.25ms @ 48kHz */
+#define L_SYN (L_SYN_MEM + L_FRAME16k) /* length of synthesis signal buffer */
+#define L_WSP_MEM (PIT_MAX + L_INTERPOL) /* length of memory for weighted input signal */
+#define L_WSP (L_WSP_MEM + L_FRAME + L_LOOK_12k8) /* length of weighted input signal buffer */
+
+#define OLD_SYNTH_SIZE_DEC (2*L_FRAME_MAX) /* decoder past synthesis; needed for LTP, PLC and rate switching*/
+#define OLD_SYNTH_INTERNAL_DEC (2*L_FRAME32k) /* decoder past synthesis @ internal sampling rate; needed for LTP, PLC and rate switching*/
+#define OLD_SYNTH_SIZE_ENC L_FRAME32k+L_FRAME32k/4 /* Frame size in samples at 25.6 kHz */
+#define OLD_EXC_SIZE_DEC (3*L_FRAME_MAX/2+2*L_FIR_FER2) /*old excitation needed for decoder for PLC*/
+
+#define TILT_CODE 9830 /* ACELP code preemphasis factor ~=0.3f (0Q15) (=0.299987792968750) */
+
+#define L_SUBFR16k (L_FRAME16k/NB_SUBFR) /* subframe size at 16kHz */
+#define L_HALFR16k (2*L_SUBFR16k) /* half-frame size at 16kHz */
+
+#define L_INTERPOL2 16 /* Length of filter for interpolation */
+#define L_INTERPOL (L_INTERPOL2+1) /* Length of filter for interpolation */
+#define TILT_FAC_FX 22282 /* tilt factor (denominator) fixed-point*/
+#define M16k 20 /* order of the LP filter @ 16kHz */
+#define PIT_SHARP_fx 27853 /* pitch sharpening factor */
+#define F_PIT_SHARP 0.85F /* pitch sharpening factor */
+#define PIT_UP_SAMP 4
+#define UP_SAMP 4 /* upsampling factor for 1/4 interpolation filter */
+#define PIT_L_INTERPOL2 16
+#define PIT_FIR_SIZE2 (PIT_UP_SAMP*PIT_L_INTERPOL2+1)
+#define PIT_UP_SAMP6 6
+#define PIT_L_INTERPOL6_2 17
+#define PIT_FIR_SIZE6_2 (PIT_UP_SAMP6*PIT_L_INTERPOL6_2+1)
+#define E_MIN_FX 1 /* QSCALE (Q7)*/
+#define STEP_DELTA_FX 11
+#define FORMANT_SHARPENING_NOISE_THRESHOLD_FX 5376 /* 21 (!8)lp_noise level above which formant sharpening is deactivated - at this level most of 20 dB SNR office noisy speech still uses sharpening */
+#define LP_NOISE_THRESH 167772160l/*20.f Q23*/
+#define LFAC 160 /* FAC maximum frame length */
+
+#define L_FILT_UP8k 24 /* Resampling - delay of filter for 8 kHz output signals (at 12.8 kHz sampling rate) */
+#define LEN_WIN_SSS 120
+#define L_FILT 12 /* Delay of the low-pass filter in the BPF */
+#define L_FILT8k 16 /* Resampling - delay of filter for 8 kHz input signals (at 8kHz sampling rate) */
+#define L_FILT16k 15 /* Resampling - delay of filter for 16 kHz input signals (at 16kHz sampling rate) */
+#define L_FILT32k 30 /* Resampling - delay of filter for 32 kHz input signals (at 32kHz sampling rate) */
+#define L_FILT48k 45 /* Resampling - delay of filter for 48 kHz input signals (at 48kHz sampling rate) */
+#define L_FILT_UP16k 12 /* Resampling - delay of filter for 16 kHz output signals (at 12.8 kHz sampling rate) */
+#define L_FILT_UP32k 12 /* Resampling - delay of filter for 32 kHz output signals (at 12.8 kHz sampling rate) */
+#define L_FILT_UP48k 12 /* Resampling - delay of filter for 48 kHz output signals (at 12.8 kHz sampling rate) */
+#define L_FILT_MAX L_FILT48k /* Resampling - maximum length of all filters - for memories */
+#define RS_INV_FAC 0x8000 /* Resampling - flag needed in rom_com and modif_fs to allow pre-scaled and non pre-scaled filters */
+
+#define CLDFB_NO_CHANNELS_MAX 60 /* CLDFB resampling - max number of CLDFB channels */
+#define CLDFB_NO_COL_MAX 16 /* CLDFB resampling - max number of CLDFB col. */
+#define CLDFB_NO_COL_MAX_SWITCH 6 /* CLDFB resampling - max number of CLDFB col. for switching */
+#define CLDFB_NO_COL_MAX_SWITCH_BFI 8 /* CLDFB resampling - max number of CLDFB col. for switching */
+
+#define CLDFB_ANALYSIS 0
+#define CLDFB_SYNTHESIS 1
+
+#define L_FFT 256 /* Spectral analysis - length of the FFT */
+#define LOG2_L_FFT 8 /* Spectral analysis - log2 of L_FFT */
+
+
+#define BIN (INT_FS_FX/L_FFT)/* Spectral analysis - Width of one frequency bin in Hz */
+#define NB_BANDS 20 /* Spectral analysis - number of frequency bands */
+#define VOIC_BINS 74 /* Spectral analysis - max number of frequency bins considered as voiced (related to VOIC_BAND and L_FFT) */
+#define VOIC_BAND 17 /* Spectral analysis - number of critical bands considered as voiced (related to VOIC_BINS) */
+#define VOIC_BINS_8k 115 /* Spectral analysis - max number of frequency bins considered as voiced in NB (related to VOIC_BAND_8k and L_FFT) */
+#define VOIC_BAND_8k 17 /* Spectral analysis - number of critical bands considered as voiced in NB (related to VOIC_BINS_8k) */
+#define N_SPEC (L_FFT/2) /* number of spectral bins */
+
+#define M_GAMMA_FX 32440 /* Q15 - forgetting factor of active speech decision predictor */
+#define M_ALPHA_FX 29491 /* Q15 - forgetting factor of LT correlation map */
+#define ONE_MINUS_M_ALPHA 3277 /* Q15 - one minus forgetting factor of LT correlation map */
+#define THR_CORR_INIT_FX (56<<9 ) /* Q9 - starting threshold of multi-harm. correlation */
+#define THR_NCHAR_WB_FX 2048 /* Q11 threshold for noise character (WB) */
+#define THR_NCHAR_NB_FX 2048 /* Q11 threshold for noise character (NB) */
+
+#define L_LP 320 /* LP analysis - LP window size */
+#define L_LP_16k 400 /* LP analysis @16kHz - LP window size for 16kHz */
+#define L_LP_AMR_WB 384 /* LP analysis - windows size (only for AMR-WB IO mode) */
+#define GRID100_POINTS 100 /* LP analysis - number of points to evaluate Chebyshev polynomials */
+#define GRID80_POINTS 80 /* LP analysis - number of points to evaluate Chebyshev polynomials used in the LP coefs. conversion */
+
+#define GRID50_POINTS 51 /* LP analysis - half-number of points to evaluate Chebyshev polynomials used in the LP coefs. conversion */
+#define GRID40_POINTS 41 /* LP analysis - half-number of points to evaluate Chebyshev polynomials used in the LP coefs. conversion */
+
+#define PIT_MIN 34 /* OL pitch analysis - Minimum pitch lag */
+#define PIT_MAX 231 /* OL pitch analysis - Maximum pitch lag */
+#define PIT_MIN_EXTEND 20 /* OL pitch analysis - Minimum pitch lag of extended range */
+#define PIT_MIN_DOUBLEEXTEND 17 /* OL pitch analysis - Minimum pitch lag of double-extended range */
+#define OPL_DECIM 2 /* OL pitch analysis - decimation factor */
+#define L_INTERPOL1 4 /* OL pitch analysis - interval to compute normalized correlation */
+#define FIR_SIZE1 (UP_SAMP*L_INTERPOL1+1) /* OL pitch analysis - total length of the 1/4 interpolation filter */
+
+#define PIT_MIN_SHORTER 29 /* OL pitch analysis - minimum for wider pitch, MODE2 specific constant */
+
+#define PIT_MIN_12k8 29 /* Minimum pitch lag with resolution 1/4 */
+#define PIT_FR2_12k8 121 /* Minimum pitch lag with resolution 1/2 */
+#define PIT_FR1_12k8 154 /* Minimum pitch lag with resolution 1 */
+#define PIT_MAX_12k8 231 /* Maximum pitch lag */
+#define PIT_FR1_8b_12k8 82 /* Minimum pitch lag with resolution 1 for low bit-rate pitch delay codings*/
+#define PIT_MIN_16k 36
+#define PIT_FR2_16k 36
+#define PIT_FR1_16k 165
+#define PIT_FR1_8b_16k 165
+#define PIT_MIN_25k6 58
+#define PIT_FR2_25k6 58
+#define PIT_FR1_25k6 164
+#define PIT_MAX_25k6 463
+#define PIT_FR1_8b_25k6 164
+#define PIT_MIN_32k 72
+#define PIT_FR2_32k 72
+#define PIT_FR1_32k 75
+#define PIT_MAX_32k 577
+#define PIT_FR1_8b_32k 75
+#define PIT_MAX_MAX PIT_MAX_32k
+#define PIT_MAX_16k 289
+
+#define PIT_FR1_8b 92 /* Pitch encoding - Minimum pitch lag with resolution 1 */
+#define PIT_FR2_9b 128 /* Pitch encoding - Minimum pitch lag with resolution 1/2 */
+#define PIT_FR1_9b 160 /* Pitch encoding - Minimum pitch lag with resolution 1 */
+#define PIT_FR1_EXTEND_8b 64 /* Pitch encoding - Minimum pitch lag with resolution 1 of extended range */
+#define PIT_FR2_EXTEND_9b 116 /* Pitch encoding - Minimum pitch lag with resolution 1/2 of extended range */
+#define PIT_FR1_EXTEND_9b 128 /* Pitch encoding - Minimum pitch lag with resolution 1 of extended range */
+#define PIT_FR1_DOUBLEEXTEND_8b 58 /* Pitch encoding - Minimum pitch lag with resolution 1 of double-extended range */
+#define PIT_FR2_DOUBLEEXTEND_9b 112 /* Pitch encoding - Minimum pitch lag with resolution 1/2 of double-extended range */
+#define PIT_FR1_DOUBLEEXTEND_9b 124 /* Pitch encoding - Minimum pitch lag with resolution 1 of double-extended range */
+
+#define LOW_PASS 0 /* LP filtering - flag for low-pass filtering of the excitation */
+#define FULL_BAND 1 /* LP filtering - flag for no low-pass filtering of the excitation */
+#define NORMAL_OPERATION 2 /* LP filtering - flag for selecting the best of the two above */
+
+#define NB_TRACK_FCB_2T 2 /* Algebraic codebook - number of tracks in algebraic fixed codebook search with 2 tracks */
+#define NB_POS_FCB_2T 32 /* Algebraic codebook - number of positions in algebraic fixed codebook search with 2 tracks */
+#define NB_TRACK_FCB_4T 4 /* Algebraic codebook - number of tracks in algebraic fixed codebook search with 4 tracks */
+#define NB_POS_FCB_4T 16 /* Algebraic codebook - number of positions in algebraic fixed codebook search with 4 tracks */
+#define NB_PULSE_MAX 36
+#define NPMAXPT ((NB_PULSE_MAX+NB_TRACK_FCB_4T-1)/NB_TRACK_FCB_4T)
+
+#define GAIN_PRED_ORDER 4 /* Gain quantization - prediction order for gain quantizer (only for AMR-WB IO mode) */
+#define MEAN_ENER 30 /* Gain quantization - average innovation energy */
+
+#define DTX_HIST_SIZE 8 /* CNG & DTX - number of last signal frames used for CNG averaging */
+#define CNG_ISF_FACT_FX 29491 /* Q15(0.9), CNG & DTX - CNG spectral envelope smoothing factor*/
+#define STEP_AMR_WB_SID_FX 10752 /* Q12 */
+#define HO_HIST_SIZE 8 /* CNG & DTX - maximal number of hangover frames used for averaging */
+
+#define NUM_ENV_CNG 20
+#define BUF_L_NRG_FX 22938 /* Q15(0.7), CNG & DTX - lower threshold offset for hangover updates */
+#define ONE_OVER_BUF_H_NRG_FX 31814 /* Q15(1/1.03), CNG & DTX - inverse of higher threshold offset for hangover updates */
+#define HO_ATT_FAC_FX 3277 /* Q15(0.1), CNG & DTX - Hangover frame attenuation rate factor */
+
+#define BUF_DEC_RATE 25 /* CNG & DTX - buffer size decrease rate for active frames */
+#define STEP_SID_FX 21504 /* Q12 */
+#define ISTEP_SID_FX 6242 /* Inverse of CNG & DTX - CNG energy quantization step in Q15(1/5.25 in Q15)*/
+#define ISTEP_AMR_WB_SID_FX 12483 /* Q15(1/2.625) Inverse of CNG & DTX - CNG energy quantization step */
+
+#define MIN_ACT_CNG_UPD 20 /* DTX - Minimum number of consecutive active frames for CNG mode update */
+#define FIXED_SID_RATE 8 /* DTX SID rate */
+
+#define TOTALNOISE_HIST_SIZE 4
+
+/************************************************************************/
+
+/************************************************************************/
+#define SUBFFT_QIN 10
+#define DATAFFT_Q 5
+#define SUBFFT_QOUT SUBFFT_QIN-DATAFFT_Q
+#define SPECAMP_Q SUBFFT_QIN
+
+#define CLDFBVAD_NB_ID 1
+#define CLDFBVAD_WB_ID 2
+#define CLDFBVAD_SWB_ID 3
+#define CLDFBVAD_FB_ID 4
+#define SP_CENTER_NUM 4
+#define TONA_NUM 3
+#define PRE_SNR_NUM 32
+#define PRE_FLAG_NUM 64
+#define POWER_NUM 56
+#define PRE_SPEC_DIF_NUM 56
+#define CLDFBVAD_VAD_ON 1
+#define COM_VAD_ON 2
+
+#define MAX_SUBBAND_NUM 12 /* max number of sub-band divided non-uniformly*/
+#define BG_ENG_NUM MAX_SUBBAND_NUM /* number of energy of sub-band divided non-uniformly*/
+#define MIN_AMP_ID 5
+#define MAX_AMP_ID 64
+#define SPEC_AMP_NUM (MAX_AMP_ID-MIN_AMP_ID+1)
+#define STABLE_NUM 4 /* number of time-domain stable rate*/
+#define SFM_NUM 3 /* number of spectral flatness */
+
+
+
+#define MAX_CORR_SHIFT_FX 16384 /* corrshift limit, 0.5 in Q15 */
+
+
+#define START_NG 5 /* Stationary noise UV modification */
+#define FULL_NG 10 /* Stationary noise UV modification */
+#define ISP_SMOOTHING_QUANT_A1_FX 29491 /* 0.9f in Q15 */ /* Stationary noise UV modification */
+
+#define KP559016994_FX 18318 /* EDCT & EMDCT constants */
+#define KP951056516_FX 31164 /* EDCT & EMDCT constants */
+#define KP587785252_FX 19261 /* EDCT & EMDCT constants */
+#define KP866025403_FX 28378 /* EDCT & EMDCT constants */
+#define KP250000000_FX 8192 /* EDCT & EMDCT constants */
+
+#define FEC_BITS_CLS 2 /* FEC - number of bits for clas information */
+#define FEC_BITS_ENR 5 /* FEC - number of bits for energy information */
+#define FEC_ENR_STEP (96.0f/(1< 1! For dividing spectrum into multiple ranges, define NOISE_FILL_RANGES > 1. For each region one noise filling level will be transmited */
+#define NBITS_NOISE_FILL_LEVEL 3 /* Number of bits used for coding noise filling level for each range */
+#define MIN_NOISE_FILLING_HOLE 8
+#define HOLE_SIZE_FROM_LTP(gain) (add(4, extract_h(L_shr(L_mult0(gain, 0x6666), 10)))) /* 0x6666 -> 2.0*(4.0/0.625) (4Q11) */
+#define FDNS_NPTS 64
+#define AVG_TCX20_LSF_BITS 40
+#define AVG_TCX10_LSF_BITS 59
+#define LTPSIZE 3
+#define TCXLTP_DELAY_NS 250000
+#define TCXLTP_MAX_DELAY NS2SA(48000,TCXLTP_DELAY_NS)
+#define TCXLTP_LTP_ORDER 24
+#define TCX_RES_Q_BITS_GAIN 3
+
+#define LPC_SHAPED_ARI_MAX_RATE ACELP_9k60
+
+#define N_MAX_ARI 800
+
+#define SPEC_EXP_DEC 20 /* initial decoder spectrum exponent */
+
+/*----------------------------------------------------------------------------------*
+ * TNS constants
+ *----------------------------------------------------------------------------------*/
+
+#define R1_48 690
+#define R2_48 420
+#define R1_16 230
+#define R2_16 140
+#define R1_25 368
+#define R2_25 224
+
+#define TNS_MAX_NUM_OF_FILTERS 2 /* TNS maximum number of filters */
+#define TNS_MAX_FILTER_ORDER 8 /* TNS maximum filter order */
+#define ITF_MAX_FILTER_ORDER 16 /* ITF maximum filter order */
+#define NPRM_TNS (2+TNS_MAX_NUM_OF_FILTERS*(3+TNS_MAX_FILTER_ORDER)) /* TNS total number of quantized parameters */
+#define NPRM_RESQ 100 /* Maximum number of parameter for residual Q in TCX */
+#define NPRM_CTX_HM 3 /* Number of Parameters for Context HM : flag+index */
+#define NPRM_DIV (2+NPRM_TNS+N_MAX/2+NPRM_RESQ+NPRM_CTX_HM) /* Total number of quantized parameter in 1 division */
+#define DEC_NPRM_DIV NPRM_DIV /* Total number of quantized parameter in 1 division (decoder side) */
+#define NPRM_LPC_NEW 2*(4+2*NB_SPHERE) /* LPC total number of quantized parameters */
+
+#define BITBUFSIZE (128000/50)
+
+#define TNS_COEF_RES 4 /* Bit resolution of the coefficients. */
+#define INDEX_SHIFT (1 << (TNS_COEF_RES-1)) /* For shifting the index so that index 0 points to 0. */
+
+/*----------------------------------------------------------------------------------*
+ * LSF quantization constants
+ *----------------------------------------------------------------------------------*/
+
+#define GENERIC_MA_LIMIT 9600
+
+#define SPC_FX 770 /* q15 */
+#define SPC_PLUS_FX 771
+
+#define LSF_GAP_FX 128 /*50.0f x 2.56*/
+#define MODE1_LSF_GAP_FX 179 /* MODE1_LSF_GAP*2.56 */ /* Minimum LSF separation for end-frame ISFs */
+#define FREQ_MAX 16384 /*6400Hz in 14Q1*1.28 */
+#define FREQ_DIV 800 /*400.0f in 14Q1 */
+
+#define LSF_BITS_CNG 29
+
+#define ISF_GAP_FX 128 /* Minimum ISF separation for end-frame ISFs (only in AMR-WB IO mode) */
+#define LSF_GAP_MID_FX 205 /* 80.0 * 2.56 */ /* Minimum LSF separation for mid-frame LSFs */
+#define PREFERSFNET_FX 1638 /* 0.05 in Q16*/
+#define SFNETLOWLIMIT_WB 3670016 /* 2.56x2.56*Q4 LSF quantizer - new sampling rate dependent thresholds used in LSF codebook decision logic, WB case */
+#define SFNETLOWLIMIT_NB 3984589 /* 2.56x2.56*Q4 LSF quantizer - new sampling rate dependent thresholds used in LSF codebook decision logic, NB case */
+#define LSFMBEST 2 /* number of survivors from one stage to another */
+#define STREAKLEN 3 /* Allow this many predictive frames, before starting limiting, For voiced +3 frames allowed */
+#define STREAKMULT_FX 26214 /* Exponential limiting multiplier */
+
+#define LSFMBEST_MAX 16
+
+#define TCXLPC_NUMSTAGES 3
+#define TCXLPC_NUMBITS 13
+#define TCXLPC_IND_NUMSTAGES 1
+#define TCXLPC_IND_NUMBITS 2
+#define TCXLPC_LSF_GAP 204 /* 80 in 14Q1*1.28 */
+#define kMaxC 8
+
+#define MAX_VQ_STAGES 4 /* Maximum number of LSF VQ (3 trained and 1 LVQ) stages allowed */
+#define MAX_VQ_STAGES_USED 9 /*this is the maximum number of stages currently used and changing this will affect the memory allocated MAX_VQ_STAGES is also used as offset for addressing some arrays, so this should NOT be changed*/
+
+#define LEN_INDICE 15
+#define LATTICE_DIM 8
+#define NO_LEADERS 49
+#define MAX_NO_BR_LVQ 28
+#define MAX_NO_SCALES 3
+#define MAX_NO_VALS 4
+#define CNG_LVQ_MODES 16
+#define MAX_NO_MODES 128
+#define START_CNG 112
+#define MAX_NO_MODES_p 145
+#define NO_CODING_MODES 6
+#define LVQ_COD_MODES 18
+/* BC-TCQ */
+#define N_STAGE_VQ 8
+#define N_DIM 2
+#define NUM_SUBSET 8
+#define OP_LOOP_THR_HVO 1550146 /* 80% : Open-loop Threshold 2.56*2.56/16 */
+#define NUM_STATE 16 /* BC-TCQ - Number of state of the Trellis */
+#define N_STAGE 16 /* BC-TCQ - Smaple number in a frame */
+
+#define SIZE_BK1 256
+#define SIZE_BK2 256
+#define SIZE_BK21 64
+#define SIZE_BK22 128
+#define SIZE_BK23 128
+#define SIZE_BK24 32
+#define SIZE_BK25 32
+#define SIZE_BK21_36b 128
+#define SIZE_BK22_36b 128
+#define SIZE_BK23_36b 64
+
+#define NB_QUA_GAIN5B 32 /* Number of quantization level */
+#define NB_QUA_GAIN6B 64 /* Number of quantization level */
+#define NB_QUA_GAIN7B 128 /* Number of quantization level */
+
+/*----------------------------------------------------------------------------------*
+ * Transient detection
+ *----------------------------------------------------------------------------------*/
+
+#define NSUBBLOCKS 8 /* Number of subblocks per frame, one transient per a sub-block can be found */
+#define MAX_TD_DELAY 2*NSUBBLOCKS /* Maximum allowed delay (in number of subblocks) of the transient detection, affects required memory */
+
+#define NO_TCX 0
+#define TCX_20 1
+#define TCX_10 2
+#define TCX_5 3
+
+#define TRANSITION_OVERLAP (-2)
+#define RECTANGULAR_OVERLAP (-1)
+#define FULL_OVERLAP 0
+#define NOT_SUPPORTED 1
+#define MIN_OVERLAP 2
+#define HALF_OVERLAP 3
+
+/*----------------------------------------------------------------------------------*
+ * FEC constants
+ *----------------------------------------------------------------------------------*/
+
+#define UNVOICED_CLAS 0 /* Unvoiced, silence, noise, voiced offset */
+#define UNVOICED_TRANSITION 1 /* Transition from unvoiced to voiced components - possible onset, but too small */
+#define VOICED_TRANSITION 2 /* Transition from voiced - still voiced, but with very weak voiced characteristics */
+#define VOICED_CLAS 3 /* Voiced frame, previous frame was also voiced or ONSET */
+#define ONSET 4 /* Voiced onset sufficiently well built to follow with a voiced concealment */
+#define SIN_ONSET 5 /* Artificial harmonic+noise onset (used only in decoder) */
+#define INACTIVE_CLAS 6 /* Inactive frame (used only in decoder) */
+#define AUDIO_CLAS 7 /* Audio frame (used only in AMR-WB IO mode) */
+
+#define BETA_FEC_FX 24576 /* FEC - weighting factor for LSF estimation in FER */
+#define STAB_FAC_LIMIT_FX 8192 /* FEC - limit at which safety net is forced for next frame */
+
+#define MODE1_L_FIR_FER 5 /* FEC - impulse response length for low- and high-pass filters in FEC */
+#define L_FIR_FER 3 /* FEC - impulse response length for low- & high-pass filters in FER concealment*/
+#define L_FIR_FER2 11 /* FEC - new filter tuning: 11*/
+#define MAX_UPD_CNT 5 /* FEC - maximum number of frames since last pitch update */
+
+/* attenuation strategy in case of FER */
+#define _ALPHA_S_FX 19661
+#define _ALPHA_V_FX 32767
+#define _ALPHA_VT_FX 13107
+#define _ALPHA_UT_FX 26214
+#define _ALPHA_U_FX 13107
+#define _ALPHA_U_FX_X_2 26214
+#define _ALPHA_UU_FX 32767
+
+#define PLC_MIN_CNG_LEV 328/*0.01f Q15*/
+#define PLC_MIN_STAT_BUFF_SIZE 50 /* buffer size for minimum statistics */
+#define G_LPC_RECOVERY_BITS 1
+
+/*----------------------------------------------------------------------------------*
+ * Transition mode (TC) constants
+ *----------------------------------------------------------------------------------*/
+/* Conversion of tc_subfr to index */
+#define TC_SUBFR2IDX_16KHZ_fx(x) mac_r(1024L, (x), 512) /* -1 => 0, 0 => 0, 64 => 1, 128 => 2, 192 => 3, 256 => 4 */
+
+#define TC_SUBFR2IDX_fx(x) add(s_min(3, s_max(0, sub((x), 1))), TC_SUBFR2IDX_16KHZ_fx(x))
+
+#define L_IMPULSE 17 /* TC - length of one prototype impulse */
+#define L_IMPULSE2 8 /* TC - half-length of one prototype impulse == floor(L_IMPULSE/2) */
+#define NUM_IMPULSE 8 /* TC - number of prototype impulses */
+#define N_GAIN_CODE_TC 8 /* TC - number of levels for gain_code quantization for subrames without glot. impulse(s) - */
+#define N_GAIN_TC 8 /* TC - number of levels for gain_trans quantization */
+/* TC - attention: DO NOT CHANGE the following constants - needed for correct bit-allocations */
+#define TC_0_0 1 /* TC - subframe ID for TC: first glottal impulse in the 1st subframe, second in the 1st subframe */
+#define TC_0_64 2 /* TC - subframe ID for TC: first glottal impulse in the 1st subframe, second in the 2nd subframe */
+#define TC_0_128 3 /* TC - subframe ID for TC: first glottal impulse in the 1st subframe, second in the 3rd subframe */
+#define TC_0_192 4 /* TC - subframe ID for TC: first glottal impulse in the 1st subframe, second in the 4th subframe */
+
+/*----------------------------------------------------------------------------------*
+ * AVQ constants
+ *----------------------------------------------------------------------------------*/
+
+#define NB_LDQ3 9 /* RE8 constants */
+#define NB_LDQ4 27
+#define NB_SPHERE 32
+#define NB_LEADER 36
+
+#define NSV_MAX 34 /* maximal number of sub-vectors used by the AVQ */
+
+/*----------------------------------------------------------------------------------*
+ * Arithmetic coder
+ *----------------------------------------------------------------------------------*/
+#define A_THRES_SHIFT 2
+#define A_THRES (1<0 */
+#define GAMMA3_MINUS_FX 29491 /* NB post-filter - tilt weighting factor when k1<0 */
+#define GAMMA3_PLUS_WB_FX 21299 /* WB post-filter */
+#define GAMMA3_MINUS_WB_FX 27853 /* WB post-filter */
+#define AGC_FAC_WB_FX 27853 /* WB post-filter - gain adjustment factor */
+#define AGC_FAC1_WB_FX (Word16)(32768L-AGC_FAC_WB_FX) /* WB post-filter - gain adjustment factor complement */
+
+/* SWB TBE, FX only constants */
+#define NOISE_QFAC 6
+#define NOISE_QADJ (15-NOISE_QFAC)
+
+/*----------------------------------------------------------------------------------*
+ * SWB BWE constants
+ *----------------------------------------------------------------------------------*/
+
+#define INV_L_SUBFR16k_FX 410 /*Q15 */
+#define SWB_L_SUBFR 160
+#define FB_L_SUBFR 240
+#define SWB_FENV 14
+#define WB_FENV 2
+#define FB_GAIN_QLOW_FX 0
+#define FB_GAIN_QDELTA_FX 512 /*Q14 */
+
+#define NUM_BITS_FB_FRAMEGAIN 4 /* Number of bits for framegain for FB */
+#define FB_BAND_BEGIN 620
+#define FB_BAND_END 800
+#define FB_BAND_WIDTH 180
+#define N_CAND 2
+#define N_CB11 32 /* 5bits */
+#define N_CB1ST 128 /* 7bits */
+#define N_CB2ND 64 /* 6bits */
+#define N_CB3RD 32 /* 5bits */
+#define N_CB4TH 64 /* 6bits */
+#define DIM1ST 3
+#define DIM2ND 4
+#define DIM3RD 3
+#define DIM4TH 4
+#define DIM11 (DIM1ST+DIM2ND)
+#define DIM12 (DIM3RD+DIM4TH)
+#define N_CAND_TR 3
+#define N_CB_TR1 128
+#define N_CB_TR2 64
+#define DIM_TR1 2
+#define DIM_TR2 2
+#define SWB_FENV_TRANS 4
+#define SWB_TENV 4
+#define NUM_SHARP 9
+#define SHARP_WIDTH 32
+
+#define HARMONIC 3
+#define NORMAL 2
+#define TRANSIENT 1
+#define NOISE 0
+
+/*----------------------------------------------------------------------------------*
+ * HR SWB BWE constants
+ *----------------------------------------------------------------------------------*/
+
+#define NSV_OVERLAP 2 /* number of sub-bands overlaping with lower-band (0-8kHz) */ /* note that NSV_MAX >= END_FREQ_BWE_FULL/(8*50) + NSV_OVERLAP ! */
+#define N_BANDS_BWE_HR 4 /* number of frequency bands in non-transient frame */
+#define N_BANDS_TRANS_BWE_HR 2 /* number of frequency bands in transient frame */
+#define END_FREQ_BWE 14400 /* maximum frequency coded by AVQ */
+#define END_FREQ_BWE_FULL 16000 /* maximum frequency coded by HR SWB BWE */
+#define END_FREQ_BWE_FULL_FB 20000 /* maximum frequency coded by HR FB BWE */
+
+#define NBITS_GLOB_GAIN_BWE_HR 5 /* number of bits of the global gain quantizer */
+#define MIN_GLOB_GAIN_BWE_HR 3 /* minimum value of the global gain quantizer */
+#define MAX_GLOB_GAIN_BWE_HR 500 /* maximum value of the global gain quantizer */
+
+#define NBITS_ENVELOPE_BWE_HR1 6 /* number of bits for envelope VQ - first two subbands in non-transient frame */
+#define NBITS_ENVELOPE_BWE_HR2 5 /* number of bits for envelope VQ - second two subbands in non-transient frame */
+#define NBITS_ENVELOPE_BWE_HR_TR 4 /* number of bits for envelope VQ - two subbands in transient frame */
+#define NUM_ENVLOPE_CODE_HR1 64 /* dimension of envelope VQ - first two subbands in non-transient frame */
+#define NUM_ENVLOPE_CODE_HR2 32 /* dimension of envelope VQ - second two subbands in non-transient frame */
+#define NUM_ENVLOPE_CODE_HR_TR 16 /* dimension of envelope VQ - two subbands in transient frame */
+#define NUM_ENVLOPE_CODE_HR_TR2 8 /* dimension of envelope VQ - two subbands in transient frame */
+
+#define NUM_NONTRANS_START_FREQ_COEF (L_FRAME32k/2 - NSV_OVERLAP*WIDTH_BAND) /* start frequency coefficient (==7.6kHz) in non-transient frame */
+#define NUM_NONTRANS_END_FREQ_COEF (L_FRAME32k*END_FREQ_BWE/END_FREQ_BWE_FULL) /* end frequency coefficient (==14.4kHz) in non-transient frame */
+#define NUM_TRANS_START_FREQ_COEF (NUM_NONTRANS_START_FREQ_COEF/NUM_TIME_SWITCHING_BLOCKS) /* start frequency coefficient (==7.6kHz) in transient frame */
+#define NUM_TRANS_END_FREQ_COEF (NUM_NONTRANS_END_FREQ_COEF/NUM_TIME_SWITCHING_BLOCKS) /* end frequency coefficient (==14.4kHz) in transient frame */
+#define NUM_TRANS_END_FREQ_COEF_EFF 140
+#define WIDTH_NONTRANS_FREQ_COEF ((NUM_NONTRANS_END_FREQ_COEF - NUM_NONTRANS_START_FREQ_COEF)/N_BANDS_BWE_HR) /* number of coefficients per band in non-transient frame */
+#define WIDTH_TRANS_FREQ_COEF ((NUM_TRANS_END_FREQ_COEF - NUM_TRANS_START_FREQ_COEF)/N_BANDS_TRANS_BWE_HR) /* number of coefficients per band in transient frame */
+
+#define NBITS_THRESH_BWE_HR 400 /* BWE HR number of bits threshold */
+
+#define NBITS_HF_GAIN_BWE_HR 2 /* number of bits for HF (noncoded) energy estimation */
+#define BWE_HR_TRANS_EN_LIMIT1_FX_Q16 6554
+#define BWE_HR_TRANS_EN_LIMIT2_FX_Q16 19661
+#define BWE_HR_TRANS_EN_LIMIT3_FX_Q16 32767
+#define BWE_HR_NONTRANS_EN_LIMIT1_FX_Q15 16384 /* 0.5 */
+#define BWE_HR_NONTRANS_EN_LIMIT2_FX_Q14 19661 /* 1.2 */
+#define BWE_HR_NONTRANS_EN_LIMIT2_FX_Q15 16384
+#define BWE_HR_NONTRANS_EN_LIMIT3_FX_Q15 26214 /* 0.8 */
+
+/*----------------------------------------------------------------------------------*
+ * FD CNG
+ *----------------------------------------------------------------------------------*/
+#define DELTA 1e-20f
+#define DELTA_MANTISSA_W16 0x5e73
+#define DELTA_MANTISSA_W32 0x5e728433
+#define DELTA_EXPONENT (-66)
+
+#define CLDFB_SCALING 24576/*1.5 Q14*/ /* Q 2.14 */
+
+#define FFTLEN 640
+#define FFTLEN2 (FFTLEN/2)
+#define CORECLDFBLEN 20
+#define TOTCLDFBLEN 40
+#define FFTCLDFBLEN (FFTLEN2+TOTCLDFBLEN-CORECLDFBLEN)
+#define PERIODOGLEN (FFTLEN2-2)
+#define NPART 24
+#define NPARTCLDFB 10
+#define NPART_SHAPING 62
+
+#define MSSUBFRLEN 12
+#define MSNUMSUBFR 6
+#define MSBUFLEN 5
+
+#define NOISE_HEADROOM 5 /* headroom of noise in generate_masking_noise */
+
+#define MSALPHACORALPHA 22938/*0.7f Q15*/
+#define MSALPHACORALPHA2 9830/*0.3f Q15*/
+#define MSALPHACORMAX 9830/*0.3f Q15*/
+#define MSALPHAMAX 31457/*0.96f Q15*/
+#define MSALPHAHATMIN 107374184l/*0.05f Q31*/
+#define MSQEQINVMAX 6554/*1.f/5.f Q15*/
+#define MSAV 17367/*2.12f Q13*/
+#define MSAV_EXP 2
+#define MSBETAMAX 1717986944l/*0.8f Q31*/
+#define MSBETAMAX_SQRT 1920767767l/*0.894427191 Q31*/ /* sqrt(MSBETAMAX) */
+#define MSSNREXP -10240/*-0.02f/0.064f Q15*/
+
+#define NB_LAST_BAND_SCALE 26214/*0.8f Q15*/
+#define SWB_13k2_LAST_BAND_SCALE 26214/*0.8f Q15*/
+
+#define M_MAX 32
+#define NSTAGES_MAX 9
+#define MBEST_MAX 8
+#define N_GAIN_MIN 4
+#define N_GAIN_MAX 17
+
+#define numSlots_inv_EXP (-3)
+#define PREEMPH_COMPENSATION_EXP 4
+
+#define CLDFBscalingFactor_EXP (-15)
+#define CLDFBinvScalingFactor_EXP ( 16)
+
+#define CNG_NORM_RECIPROCAL_RANGE_SHIFT 2
+#define CNG_RAND_GAUSS_SHIFT 2
+
+#define CNA_MAX_BRATE 13200
+
+/*----------------------------------------------------------------------------------*
+ * Bass post-filter constants
+ *----------------------------------------------------------------------------------*/
+
+#define NBPSF_PIT_MAX (PIT16k_MAX+1) /* maximum pitch value for bass post-filter */
+#define L_TRACK_HIST 10
+
+/*----------------------------------------------------------------------------------*
+ * NB post-filter constants
+ *----------------------------------------------------------------------------------*/
+
+#define LONG_H_ST 20 /* NB post-filter - impulse response length */
+#define GAMMA1_PST12K_FX 24576 /* denominator weighting factor 12K (0.75 in Q15) */
+#define GAMMA2_PST12K_FX 22938 /* numerator weighting factor 12K (0.7 in Q15) */
+#define POST_G1_FX GAMMA1_PST12K_FX /* 12 kbps default */
+#define POST_G2_FX GAMMA2_PST12K_FX /* 12 kbps default */
+#define GAMMA1_PST12K_MIN_FX 21299 /* 0.65 in Q15 */
+#define GAMMA2_PST12K_MIN_FX 18022 /* 0.55 in Q15 */
+#define GAMMA1_PST12K_NOIS_FX 4915 /* 0.15 in Q15 */
+#define GAMMA2_PST12K_NOIS_FX 3277 /* 0.10 in Q15 */
+#define F_UP_PST 8 /* NB post-filter - resolution for fractionnal delay */
+#define LH2_S 4 /* NB post-filter - length of INT16 interp. subfilters */
+#define LH2_L 16 /* NB post-filter - length of long interp. subfilters */
+#define LH_UP_S (LH2_S/2)
+#define LH_UP_L (LH2_L/2)
+#define LH2_L_P1 (LH2_L + 1)
+#define DECMEM_RES2 (PIT16k_MAX + 2 + LH_UP_L)
+#define SIZ_RES2 (DECMEM_RES2 + L_SUBFR)
+#define SIZ_Y_UP ((F_UP_PST-1) * (L_SUBFR+1))
+#define SIZ_TAB_HUP_L ((F_UP_PST-1) * LH2_L)
+#define SIZ_TAB_HUP_S ((F_UP_PST-1) * LH2_S)
+#define BG1_FX -328 /* -0.01 in Q15 */
+#define BG2_FX -1638 /* -0.05 in Q15 */
+#define CG1_FX 29491 /* 0.9 in Q15 */
+#define CG2_FX 47514L /* 1.45 in Q15 */
+#define C_LP_NOISE_FX 819 /* 0.1/4.0 in Q15 */
+#define CK_LP_NOISE_FX 6291456L /* 15.0 * 0.1/4 in Q8 * 65536 */
+#define LP_NOISE_THR_FX 6400 /* 25.0 in Q8 */
+
+/*----------------------------------------------------------------------------------*
+ * Stability estimation
+ *----------------------------------------------------------------------------------*/
+
+#define NB_BFI_THR 2 /* threshold for counter of last bad frames */
+#define MAX_LT 40
+
+#define TH_0_MIN_FX 5120 /* 2.5f in Q11 */
+#define TH_1_MIN_FX 3840 /* 1.875f in Q11 */
+#define TH_2_MIN_FX 3200 /* 1.5625f in Q11 */
+#define TH_3_MIN_FX 2688 /* 1.3125f in Q11 */
+
+/*----------------------------------------------------------------------------------*
+ * Speech/music classifier constants
+ *----------------------------------------------------------------------------------*/
+
+#define N_FEATURES 12 /* number of features */
+#define N_MIXTURES 6 /* number of mixtures */
+#define M_LSP_SPMUS 6 /* number of LSPs used in speech/music classifier */
+#define NB_BANDS_SPMUS 15
+#define START_BAND_SPMUS 2
+#define N_OLD_BIN_E 42
+
+#define LOWEST_FBIN 3 /* lowest frequency bin for feature vector preparation */
+#define HIGHEST_FBIN 70 /* highest frequency bin for feature vector preparation */
+#define HANG_LEN_INIT 8 /* number of frames for hang-over (causes delay of decision) */
+#define HANG_LEN 8
+#define BUF_LEN 60
+#define L_OVR 8
+
+#define N_FEATURES_2 3 /* number of features */
+
+/*----------------------------------------------------------------------------------*
+ * LD music post-filter constants
+ *----------------------------------------------------------------------------------*/
+
+#define TH_0_MIN2_FX 3840 /* Q11 -> 1.875 */
+#define TH_1_MIN2_FX 2560 /* Q11 -> 1.25 */
+#define TH_2_MIN2_FX 1920 /* Q11 -> 0.9375 */
+#define TH_3_MIN2_FX 1280 /* Q11 -> 0.625 */
+
+#define DCT_L_POST 640
+#define OFFSET2 192
+
+#define VOIC_BINS_HR 640
+#define BIN_16kdct (6400/DCT_L_POST)
+#define NB_LIMIT_BAND 16
+#define MBANDS_GN_LD 20 /* number of bands for gain coding in the postfilter */
+
+/*----------------------------------------------------------------------------------*
+ * AC mode (GSC) constants
+ *----------------------------------------------------------------------------------*/
+
+#define NOISE_LEVEL_SP0 8
+#define NOISE_LEVEL_SP1a 9
+#define NOISE_LEVEL_SP1 10
+#define NOISE_LEVEL_SP2 12
+#define NOISE_LEVEL_SP3 14
+
+#define MAX_DYNAMIC 82
+#define MIN_DYNAMIC 50
+#define DYNAMIC_RANGE (MAX_DYNAMIC-MIN_DYNAMIC)
+#define MAX_GSC_NF_BITS 3
+#define GSC_NF_STEPS (1 << MAX_GSC_NF_BITS)
+
+#define CRIT_NOIS_BAND 23
+
+#define SSF 32 /* Sub-subframe length for energy estimation in UC decision */
+#define NB_SSF (L_FRAME / SSF) /* number of sub-subframes per frame */
+
+
+#define MBANDS_GN 16 /* Number of band for gain coding in GSC */
+#define BAND1k2 3
+
+#define MBANDS_LOC (MBANDS_GN-1)
+#define SWNB_SUBFR 1
+
+#define VAR_COR_LEN 10
+
+#define CFREQ_BITRATE ACELP_11k60
+
+#define LT_UV_THR 100
+#define LT_UV_THRMID 70
+
+#define PIT_EXC_L_SUBFR L_FRAME
+#define LOCAL_CT VOICED
+
+#define Q_PVQ_OUT 10
+
+/*----------------------------------------------------------------------------------*
+ * Core Switching constants
+ *----------------------------------------------------------------------------------*/
+
+#define SWITCH_MAX_GAP 360 /* 6.25 + 1.25 of filter mem max */
+
+/*----------------------------------------------------------------------------------*
+ * HQ core constants
+ *----------------------------------------------------------------------------------*/
+
+#define HQ_NORMAL 0
+#define HQ_TRANSIENT 1
+#define HQ_HARMONIC 2
+#define HQ_HVQ 3
+#define HQ_GEN_SWB 4
+#define HQ_GEN_FB 5
+
+#define PREECHO_SMOOTH_LEN 20
+
+#define MAX16B 32767
+#define MIN16B (-32768)
+
+#define ALDO_WINDOW 4
+#define WINDECAY48 1230
+#define WINDECAY48_256 656
+#define WINDECAY16 410
+#define N16_CORE_SW 90
+#define N_ZERO_8 45
+
+#define SWITCH_OVERLAP_8k 15
+#define SWITCH_GAP_LENGTH_8k 50
+
+#define MAX_SEGMENT_LENGTH 480
+#define NUM_TIME_SWITCHING_BLOCKS 4
+#define NUM_MAP_BANDS 20
+#define NUM_MAP_BANDS_HQ_24k4 17
+#define NUM_MAP_BANDS_HQ_32k 18
+#define FREQ_LENGTH 800
+
+#define STOP_BAND 800
+
+#define SFM_G1 16
+#define SFM_G1G2 24
+#define SFM_N_NB 18
+#define SFM_N_WB 26
+#define SFM_N_STA_8k 27
+#define SFM_N_STA_10k 30
+#define SFM_N_ENV_STAB SFM_N_STA_8k /* Number of bands for env_stab stability measure */
+#define SFM_N_ENV_STAB_WB SFM_N_WB /* Number of bands for env_stab stability measure used in HQPLC decision for WB signals */
+#define SFM_N_HARMONIC 39
+#define SFM_N 36
+
+#define L_HQ_WB_BWE 20 /* == band_end_wb[SFM_N_WB-1] - (band_start_wb[SFM_N_WB-1]+12) */
+#define N_INTL_GRP_16 2 /* Number of interleaving band groups at 16kHz samplerate */
+#define N_INTL_GRP_32 2 /* Number of interleaving band groups at 32kHz samplerate */
+#define N_INTL_GRP_48 3 /* Number of interleaving band groups at 48kHz samplerate */
+#define SFM_N_SWB 39
+#define SFM_N_HARM 31
+#define SFM_N_HARM_FB 33
+#define NB_SFM 44
+#define NB_SFM_MAX 58
+#define WID_G1 8
+#define WID_G2 16
+#define WID_G3 24
+#define WID_GX 32
+#define NUMC_N 544
+#define HQ_MAX_BAND_LEN 96 /* Largest bandwidth in HQ mode (band_len_harm[32]) */
+#define HVQ_PVQ_BUF_LEN (HVQ_PVQ_COEFS*(MAX_PVQ_BANDS-1) + HQ_MAX_BAND_LEN) /* 24*7+96 = 216 */
+
+#define QBIT_MAX2 9
+
+#define FLAGN_BITS 1
+#define GAIN0_BITS 5
+#define GAINI_BITS 5
+
+#define FLAGS_BITS 2
+#define FLAGS_BITS_FB 3
+#define NORM0_BITS 5
+#define NORMI_BITS 5
+#define NUMNRMIBITS_SWB_STA_8k 5*(SFM_N_STA_8k-1)
+#define NUMNRMIBITS_SWB_STA_10k 5*(SFM_N_STA_10k-1)
+#define NUMNRMIBITS_SWB_HARMONIC 185
+#define NUMNRMIBITS_SWB 190
+#define NUMNRMIBITS 215
+#define NUMNRMIBITS_WB 125
+
+#define NOHUFCODE 0
+#define HUFCODE 1
+#define HUFF_THR 10
+#define NOSUPERPOSITION 40
+
+#define MAXVALUEOFFIRSTGAIN_FX 20480 /*2.5f in Q13 */
+#define MINVALUEOFFIRSTGAIN_FX -20480
+#define NOOFGAINBITS1 6
+
+#define AUDIODELAYBITS 6
+#define DELTAOFFIRSTGAIN_FX 2601 /*Q15 */
+
+#define MAX_D1M_16k ((L_FRAME16k>>1) - NS2SA(16000,SWITCH_GAP_LENGTH_NS) - 16)
+#define MAX_D1M_12k8 ((L_FRAME16k>>1) - NS2SA(16000,SWITCH_GAP_LENGTH_NS) - 20)
+
+#define MAX_P_ATT 40 /* Maximum number of pulses for gain attenuation factor */
+#define NB_G 4 /* Number of band groups */
+#define MAX_GAIN_BITS 5 /* Maximum number of gain bits */
+
+#define ENV_ADJ_START 6 /* Number of consecutive bands for which the attenuation is maximum */
+#define ENV_ADJ_INCL 5 /* Inclination for mapping between attenuation region width and attenuation limit */
+
+#define L_STAB_TBL 10 /* Number of elements in stability transition table */
+#define LUMPED_ENV_SMOOTH_FAC_FX ((Word16)10089) /* Q19 (no typo error), 0.1/sqrt(27) */
+#define CMPLMNT_ENV_SMOOTH_FAC_FX ((Word16)29491) /* Q15 0.9 */
+#define M_STAB_TBL_FX ((Word16)21068) /* Q13, 2.571756 */
+#define HALF_D_STAB_TBL_FX ((Word16) 422) /* Q13 0.1013138/2.0 */
+#define D_STAB_TBL_FX ((Word16) 845) /* Q13 0.1013138 */
+#define NUM_ENV_STAB_PLC_STATES 2 /* Number of states of markov model */
+#define INV_NUM_ENV_STAB_PLC_STATES 16384 /* Q15 */
+#define INV_STAB_TRANS_FX 16497 /* Q14. Equal to 1.0f/(1-2*stab_trans_fx[L_STAB_TBL-1]) */
+
+#define ATT_LIM_HANGOVER 150 /* Number of hangover frames for disabling stability dependent attenuation */
+
+#define START_EXC 60
+#define L_HARMONIC_EXC 202
+
+#define HQ_GENERIC_OFFSET 2
+#define HQ_GENERIC_END_FREQ 560
+
+#define HQ_GENERIC_FOFFSET_24K4 80
+#define HQ_GENERIC_FOFFSET_32K 144
+#define HQ_GENERIC_SWB_NBITS 31
+#define HQ_GENERIC_SWB_NBITS2 30
+#define HQ_GENERIC_FB_NBITS 5
+
+#define HQ_GENERIC_ST_FREQ 224
+#define HQ_GENERIC_LOW0 80
+#define HQ_GENERIC_HIGH0 240
+#define HQ_GENERIC_HIGH1 368
+#define HQ_GENERIC_HIGH2 496
+#define HQ_GENERIC_LEN0 128
+#define HQ_GENERIC_NVQIDX 6
+
+#define HQ_GENERIC_EXC0 0
+#define HQ_GENERIC_EXC1 1
+#define HQ_GENERIC_SP_EXC 2
+
+
+#define DIM_FB 3
+#define HQ_FB_FENV SWB_FENV + DIM_FB
+#define N_CB_FB 32
+
+#define HVQ_THRES_BIN_24k 224
+#define HVQ_THRES_SFM_24k 22
+#define HVQ_THRES_BIN_32k 320
+#define HVQ_THRES_SFM_32k 25
+#define HVQ_MIN_PEAKS 2
+#define HVQ_MAX_PEAKS_32k 23
+#define HVQ_MAX_PEAKS_24k 17
+#define HVQ_MAX_PEAKS_24k_CLAS 20 /* Limit for HVQ mode */
+#define HVQ_MAX_PEAKS HVQ_MAX_PEAKS_32k + 1
+#define HVQ_NUM_SFM_24k (SFM_N_HARMONIC - 1 - HVQ_THRES_SFM_24k)
+#define HVQ_NUM_SFM_32k (SFM_N_HARMONIC - 1 - HVQ_THRES_SFM_32k)
+
+#define HVQ_MAX_RATE 32000
+
+
+
+#define NUMNRMIBITS_SWB_HVQ_24k 35
+#define NUMNRMIBITS_SWB_HVQ_32k 25
+
+#define MAX_PVQ_BANDS 8
+#define HVQ_MAX_PVQ_WORDS ((HVQ_MAX_RATE/50)/16 + MAX_PVQ_BANDS)
+#define HVQ_MAX_POS_WORDS 40
+#define HVQ_PVQ_COEFS 24
+#define HVQ_BAND_MIN_PULSES 2
+#define HVQ_BAND_MAX_BITS_24k 80
+#define HVQ_BAND_MAX_BITS_32k 95
+#define HVQ_NEW_BAND_BIT_THR 30
+
+#define HVQ_NF_GROUPS 2
+#define HVQ_NF_WEIGHT1_FX 31385 /* Q15 0.9578 - HVQ Classifier - Noise floor estimate weight 1 */
+#define HVQ_NF_WEIGHT1B 1383 /* Q15, 1 - HVQ_NF_WEIGHT1_FX */
+#define HVQ_NF_WEIGHT2_FX 21207 /* Q15 0.6472 - HVQ Classifier - Noise floor estimate weight 2 */
+#define HVQ_NF_WEIGHT2B 11561 /* Q15 1 - HVQ_NF_WEIGHT2_FX */
+#define HVQ_PE_WEIGHT1_FX 13840 /* Q15 0.42237 - HVQ Classifier - Peak envelope estimate weight 1 */
+#define HVQ_PE_WEIGHT1B 18928 /* Q15, 1 - HVQ_PE_WEIGHT1_FX */
+#define HVQ_PE_WEIGHT2_FX 26308 /* Q15 0.80285 - HVQ Classifier - Peak envelope estimate weight 2 */
+#define HVQ_PE_WEIGHT2B 6460 /* Q15, 1 - HVQ_PE_WEIGHT2_FX */
+#define HVQ_SHARP_THRES_FX 576 /*9 in Q6 */
+
+#define HVQ_PA_FAC_FX 23170 /* Q15 0.7071 - HVQ Classifier peak allocation factor */
+#define HVQ_PA_PEAKS_SHARP1 9 /* HVQ Classifier - Maximum number of peaks for band with high sharpness */
+#define HVQ_PA_PEAKS_SHARP2 3 /* HVQ Classifier - Maximum number of peaks for band with medium sharpness */
+#define HVQ_PA_PEAKS_SHARP3 2 /* HVQ Classifier - Maximum number of peaks for band with low sharpness */
+#define HVQ_PA_SHARP_THRES2_FX 1024 /* Q6 16.0 - HVQ Classifier - Sharpness threshold for band with medium sharpness */
+#define HVQ_PA_SHARP_THRES3_FX 768 /* Q6 12.0 - HVQ Classifier - Sharpness threshold for band with low sharpness */
+
+#define HVQ_BW 32 /* HVQ Classifier subband bandwidth */
+#define HVQ_NSUB_32k 10
+#define HVQ_NSUB_24k 7 /* HVQ Classifier number of subbands */
+
+#define HVQ_BWE_NOISE_BANDS 2 /* Number of BWE noise bands */
+#define HVQ_BWE_WEIGHT1_FX ((Word16)31130) /* 0.95 in Q15 */
+#define HVQ_BWE_WEIGHT2_FX ((Word16)6554) /* 0.2 in Q15 */
+#define HVQ_NFPE_FACTOR_CUBE_FX ((Word16)16777) /* 6.4^3 in Q6 */
+#define HVQ_LB_NFPE_FACTOR_CUBE_FX ((Word16)16777) /* 3.2^3 in Q9 */
+
+#define HVQ_VQ_DIM 5 /* HVQ peak VQ dimension */
+#define HVQ_PVQ_GAIN_BITS 5 /* Number of bits to encode PVQ gains in HVQ */
+#define HVQ_NUM_CLASS 4 /* Number of codebook classes */
+#define HVQ_CB_SIZE 256
+
+#define NUM_PG_HUFFLEN 9 /* Number of Huffman codewords for peak gains */
+#define MAX_PG_HUFFLEN 12 /* Length of the longest codeword for peak gain Huffman coding */
+
+#define HVQ_CP_HUFF_OFFSET 3 /* HVQ Code Pos - Delta offset */
+#define HVQ_CP_HUFF_MAX 51 /* HVQ Code Pos - Maximum delta for huffman coding */
+#define HVQ_CP_HUFF_MAX_CODE 13 /* HVQ Code Pos - Size of largest code word */
+#define HVQ_CP_HUFF_NUM_LEN 11 /* HVQ Code Pos - Number of different huffman lengths */
+#define HVQ_CP_L2_MAX 64 /* HVQ Code Pos - Layer 2 maximum size */
+#define HVQ_CP_L1_LEN 5 /* HVQ Code Pos - Layer 1 block size */
+#define HVQ_CP_MAP_LEN 8 /* HVQ Code Pos - Mapping table size */
+#define HVQ_CP_MAP_IDX_LEN 3 /* HVQ Code Pos - Mapping index size */
+#define HVQ_CP_DELTA 0 /* HVQ Code Pos - Use Delta coding */
+#define HVQ_CP_SPARSE 1 /* HVQ Code Pos - Use Sparse coding */
+
+#define MAX_SPLITS 10 /* Maximum number of PVQ band splits */
+
+#define QUANTAQ3OFFSET 1
+enum QuantaMode { NEAREST = 0, CONS };
+#define PYR_OFFSET 1
+#define RCF_INIT_SHIFT 14
+
+#define THR_ADD_SPLIT 7 /* Threshold for using additional split */
+#define PVQ_MAX_BAND_SIZE 64 /* Maxiumum supported band size for PVQ search */
+#define MIN_BAND_SIZE 1 /* Minimum supported band size for PVQ search */
+#define RC_BITS_RESERVED 1
+#define MAX_PVQ_BITS_PER_COEFFICIENT 80 /* Maximum bits per coefficient allocated per PVQ band. Q3. */
+
+/* index_pvq constants */
+#define KMAX_FX 512
+
+#define KMAX_NON_DIRECT_FX 96 /* max K for non-direct indexing recursion rows is 1+KMAX_NON_DIRECT +1 */
+#define ODD_DIV_SIZE_FX 48 /* ind0=1/1 ind1 =1/3 ... ind47=1/95 */
+
+
+/* TCQ */
+#define TCQ_MAX_BAND_SIZE 120 /* Maxiumum supported band size for TCQ+USQ search */
+#define STATES 8
+#define MAX_AR_FREQ 16383
+#define AR_BITS 16
+#define STATES_LSB 4
+#define TCQ_LSB_SIZE 24
+#define TCQ_AMP 10
+
+#define AR_TOP ( ( 1 << AR_BITS ) - 1 )
+#define AR_FIRST ( AR_TOP / 4 + 1 )
+#define AR_HALF ( 2 * AR_FIRST )
+#define AR_THIRD ( 3 * AR_FIRST )
+
+#define MAX_SIZEBUF_PBITSTREAM 1024
+
+/*----------------------------------------------------------------------------------*
+ * SWB BWE for LR MDCT core
+ *----------------------------------------------------------------------------------*/
+/* Q value */
+#define SWB_BWE_LR_Qs 12 /* Q value of spectra (Word32) */
+#define SWB_BWE_LR_Qbe 14 /* Q value of band_energy (Word32) */
+#define SWB_BWE_LR_QRk 16 /* Q value of Rk, Rcalc (Word32) */
+#define SWB_BWE_LR_QsEn 4 /* Q value of smoothed sqrt band energy */
+
+#define G1_RANGE 4
+#define G1G2_RANGE 15
+#define GRP_SB 4 /*Maximum subband groups*/
+#define THR1 4 /* Bit allocation threshold value */
+#define THR2 5 /* Bit allocation threshold value */
+#define THR3 6 /* Bit allocation threshold value */
+
+#define NB_SWB_SUBBANDS 4 /* maximum number of subbands in normal2 subband coding */
+
+#define SWB_SB_LEN0_12KBPS 55/* length of subband number X in lowest bit rate operation */
+#define SWB_SB_LEN1_12KBPS 68
+#define SWB_SB_LEN2_12KBPS 84
+#define SWB_SB_LEN3_12KBPS 105
+
+#define SWB_HIGHBAND_12KBPS (SWB_SB_LEN0_12KBPS+SWB_SB_LEN1_12KBPS+SWB_SB_LEN2_12KBPS+SWB_SB_LEN3_12KBPS)
+#define SWB_LOWBAND_12KBPS (HQ_GENERIC_END_FREQ - SWB_HIGHBAND_12KBPS)
+#define SWB_HIGHBAND_MAX SWB_HIGHBAND_12KBPS
+#define SWB_LOWBAND_MAX SWB_LOWBAND_12KBPS
+
+#define SWB_SB_OFF0_12KBPS 0 /* subband offsets are based on the subband lengths */
+#define SWB_SB_OFF1_12KBPS (SWB_SB_OFF0_12KBPS + SWB_SB_LEN0_12KBPS)
+#define SWB_SB_OFF2_12KBPS (SWB_SB_OFF1_12KBPS + SWB_SB_LEN1_12KBPS)
+#define SWB_SB_OFF3_12KBPS (SWB_SB_OFF2_12KBPS + SWB_SB_LEN2_12KBPS)
+#define SWB_SB_OFF4_12KBPS (SWB_SB_OFF3_12KBPS + SWB_SB_LEN3_12KBPS)
+
+/* 16.4 kbps */
+#define SWB_SB_LEN0_16KBPS 59/* length of subband number X in lowest bit rate operation */
+#define SWB_SB_LEN1_16KBPS 74
+#define SWB_SB_LEN2_16KBPS 92
+#define SWB_SB_LEN3_16KBPS 115
+
+#define SWB_HIGHBAND_16KBPS (SWB_SB_LEN0_16KBPS+SWB_SB_LEN1_16KBPS+SWB_SB_LEN2_16KBPS+SWB_SB_LEN3_16KBPS)
+#define SWB_LOWBAND_16KBPS (HQ_GENERIC_END_FREQ - SWB_HIGHBAND_16KBPS)
+
+#define SWB_SB_OFF0_16KBPS 0 /* subband offsets are based on the subband lengths */
+#define SWB_SB_OFF1_16KBPS (SWB_SB_OFF0_16KBPS + SWB_SB_LEN0_16KBPS)
+#define SWB_SB_OFF2_16KBPS (SWB_SB_OFF1_16KBPS + SWB_SB_LEN1_16KBPS)
+#define SWB_SB_OFF3_16KBPS (SWB_SB_OFF2_16KBPS + SWB_SB_LEN2_16KBPS)
+#define SWB_SB_OFF4_16KBPS (SWB_SB_OFF3_16KBPS + SWB_SB_LEN3_16KBPS)
+
+/* SpectrumSmoothing */
+#define L_SB 12 /* subband length for SpectrumSmoothing */
+
+/* SpectrumSmoothing for NSS */
+#define L_SB_NSS 8
+#define L_SB_NSS_HALF (L_SB_NSS/2)
+#define NUM_SUBBAND_SMOOTH_MAX (L_FRAME32k/L_SB_NSS+1)
+#define MA_LEN 7
+
+/* Harmonic mode */
+#define NB_SWB_SUBBANDS_HAR_SEARCH_SB 2 /* search number of subbands in harmonic subband coding */
+#define NB_SWB_SUBBANDS_HAR 4 /* maximum number of subbands in harmonic subband coding */
+
+
+#define N_NBIGGEST_PULSEARCH 18
+#define N_NBIGGEST_SEARCH_LRG_B 32
+
+
+/* 13.2 kbps */
+#define SWB_SB_BW_LEN0_12KBPS_HAR 56 /* Group 1 length for BWE */
+#define SWB_SB_BW_LEN1_12KBPS_HAR 100 /* Group 2 Length for BWE */
+#define SWB_SB_BW_LEN2_12KBPS_HAR SWB_SB_BW_LEN1_12KBPS_HAR
+#define SWB_SB_BW_LEN3_12KBPS_HAR SWB_SB_BW_LEN0_12KBPS_HAR
+
+/* 16.4 kbps */
+#define SWB_SB_BW_LEN0_16KBPS_HAR 60 /* Group 1 length for BWE */
+#define SWB_SB_BW_LEN1_16KBPS_HAR 110 /* Group 2 Length for BWE */
+#define SWB_SB_BW_LEN2_16KBPS_HAR SWB_SB_BW_LEN1_16KBPS_HAR
+#define SWB_SB_BW_LEN3_16KBPS_HAR SWB_SB_BW_LEN0_16KBPS_HAR
+
+#define SWB_SB_OFF0_SUB5_12KBPS_HAR 0 /* subband offsets are based on the subband lengths */
+#define SWB_SB_OFF1_SUB5_12KBPS_HAR (SWB_SB_OFF0_SUB5_12KBPS_HAR + SWB_SB_BW_LEN0_12KBPS_HAR)
+#define SWB_SB_OFF2_SUB5_12KBPS_HAR (SWB_SB_OFF1_SUB5_12KBPS_HAR + SWB_SB_BW_LEN1_12KBPS_HAR)
+#define SWB_SB_OFF3_SUB5_12KBPS_HAR (SWB_SB_OFF2_SUB5_12KBPS_HAR + SWB_SB_BW_LEN2_12KBPS_HAR)
+
+#define SWB_SB_OFF0_SUB5_16KBPS_HAR 0 /* subband offsets are based on the subband lengths */
+#define SWB_SB_OFF1_SUB5_16KBPS_HAR (SWB_SB_OFF0_SUB5_16KBPS_HAR + SWB_SB_BW_LEN0_16KBPS_HAR)
+#define SWB_SB_OFF2_SUB5_16KBPS_HAR (SWB_SB_OFF1_SUB5_16KBPS_HAR + SWB_SB_BW_LEN1_16KBPS_HAR)
+#define SWB_SB_OFF3_SUB5_16KBPS_HAR (SWB_SB_OFF2_SUB5_16KBPS_HAR + SWB_SB_BW_LEN2_16KBPS_HAR)
+
+#define LR_BLK_LEN 16
+#define LR_HLF_PK_BLK_LEN 8
+#define LR_LOWBAND_DIF_PK_LEN 10
+#define SWB_HAR_RAN1 80
+#define SWB_HAR_RAN2 140
+#define SWB_HAR_RAN3 200
+#define SPT_SHORTEN_SBNUM 4
+
+/*----------------------------------------------------------------------------------*
+ * FEC for HQ core
+ *----------------------------------------------------------------------------------*/
+
+#define MAX_PGF 7
+#define MAX_ROW 2
+
+#define MINIMUM_RATE_TO_ENCODE_VOICING_FLAG 45000
+#define FRAMECTTOSTART_MDCT 3
+
+/*----------------------------------------------------------------------------------*
+ * Channel-aware mode (FEC)
+ *----------------------------------------------------------------------------------*/
+
+#define FEC_OFFSET 3
+#define MAX_RF_FEC_OFFSET 9
+
+/*----------------------------------------------------------------------------------*
+ * HQ FEC
+ *----------------------------------------------------------------------------------*/
+
+#define MAXDELAY_FEC 224
+
+#define PH_ECU_ALDO_OLP2_NS (ACELP_LOOK_NS/2) /* half the aldo window overlap */
+#define PH_ECU_LOOKAHEAD_NS (11*ACELP_LOOK_NS/(7*2)) /* Number of nanoseconds look-ahead ahead from the end of the past synthesized frame */
+#define PH_ECU_MEM_NS ((Lprot48k/48 - 20)*1000000-PH_ECU_LOOKAHEAD_NS) /* Number of nanoseconds memory for Phase ECU before the old_synthFB_fx pointer */
+#define POST_HQ_DELAY_NS DELAY_BWE_TOTAL_NS /* delay of post processing after core HQ coding */
+#define MAX_PLOCS Lprot48k/4+1 /* maximum number of spectral peaks to be searched */
+#define Lprot32k 1024 /* HQ phase ECU prototype frame length */
+#define Lprot32k_2 Lprot32k/2
+#define Quot_Lpr_Ltr 4
+#define Lgw_max 9 /* maximum number frequency group widths */
+#define BETA_MUTE_FAC_INI 16384 /* Q15, initial noise attenuation factor */
+#define Ltrana32k (Lprot32k/Quot_Lpr_Ltr) /* transient analysis frame length */
+#define Ltrana16k Ltrana32k/2
+#define pfind_sens 0.9f /* peakfinder sensitivity - tuning parameter */
+#define Lprot_hamm_len2_48k NS2SA(48000,6000000L)
+#define Lprot_hamm_len2_32k NS2SA(32000,6000000L)
+#define Lprot_hamm_len2_16k NS2SA(16000,6000000L)
+#define Lprot48k Lprot32k * 3/2 /* HQ phase ECU prototype frame length */
+#define Lprot48k_2 Lprot48k/2
+#define Ltrana48k (Lprot48k/Quot_Lpr_Ltr) /* transient analysis frame length */
+#define PH_ECU_SPEC_SIZE Lprot48k
+#define T_SIN_PI_2 PH_ECU_SPEC_SIZE/4
+#define RANDOM_START 1
+#define HQ_FEC_SIGN_SFM 16
+#define HQ_FEC_SIGN_THRES 6
+#define HQ_FEC_SIGN_THRES_TRANS 3
+#define HQ_FEC_BAND_SIZE 4
+
+/*--------------------------------------------------------------*
+ * Tonal MDCT PLC constants
+ *---------------------------------------------------------------*/
+#define SPEC_EXP_DEC 20
+
+#define MAX_NUMBER_OF_IDX 30
+#define GROUP_LENGTH 7
+#define MAX_PEAKS_FROM_PITCH 10
+#define LAST_HARMONIC_POS_TO_CHECK 128 /* 128 because we check harmonics only up to 3.2 kHz */
+#define FILTLEN 15
+#define ALLOWED_SIDE_LOBE_FLUCTUATION 24576/*3.0f Q13*/ /* 4.8 dB */
+#define ALLOWED_SIDE_LOBE_FLUCTUATION_EXP 2
+#define LEVEL_ABOVE_ENVELOPE 7.59f /* 8.8 dB */
+#define UNREACHABLE_THRESHOLD 16384/*16.0f Q10*/ /* 12 dB Increase of LEVEL_ABOVE_ENVELOPE so that the threshold is not reached */
+#define SMALL_THRESHOLD 1126/*1.10f Q10*/ /* 0.41 dB Increase of LEVEL_ABOVE_ENVELOPE for the peak detection at a definitive peak in the estimated spectrum */
+#define BIG_THRESHOLD 1536/*1.5f Q10*/ /* 1.76 dB Increase of LEVEL_ABOVE_ENVELOPE for the peak detection at a probable peak in the estimated spectrum */
+
+#define kSmallerLagsTargetBitsThreshold 150
+
+#define kLtpHmGainThr 0x3AE1 /* 0.46f */
+#define kCtxHmOlRSThr 0x5333 /* 2.6f (2Q13) */
+
+#define kTcxHmSnrOffsetGc 8/*0.03125f Q8*/
+#define kTcxHmSnrOffsetVc 0
+
+#define kTcxHmNumGainBits 2 /* Number of bits for the gain index */
+#define kTcxHmParabolaHalfWidth 4 /* Parabola half width */
+#define kLtpHmGainThr 0x3AE1 /* 0.46f */ /* Use the LTP pitch lag in the harmonic model? */
+
+#define kSmallerLagsTargetBitsThreshold 150
+
+#define TCX_LPC_OFFSET_SNR
+
+#define kTcxSnrOffsetGc 0x08 /* 0.03125f (7Q8) */
+#define kTcxSnrOffsetVc 0x20 /* 0.125f (7Q8) */
+
+#define LOWRATE_TCXLPC_MAX_BR ACELP_9k60
+
+/*--------------------------------------------------------------*
+ * Waveform-adjustment MDCT PLC
+ *---------------------------------------------------------------*/
+
+#define DEC_STATE_LEN 10
+#define MAX_POST_LEN 3
+#define TCX_TONALITY_INIT_CNT 7
+
+#define TCX_NONTONAL 0
+#define TCX_TONAL 1
+
+/*---------------------------------------------------------------*
+ * IGF *
+ *---------------------------------------------------------------*/
+#define IGF_MAX_TILES 5
+#define IGF_MAX_GRANULE_LEN 1200
+#define IGF_TRANS_FAK 2
+#define IGF_MAX_SFB 23
+#define IGF_NOF_GRIDS 3
+#define IGF_MAX_SUBFRAMES 2
+
+#define IGF_MODE_WB 1
+#define IGF_MODE_SWB 2
+#define IGF_MODE_FB 3
+
+
+#define IGF_BITRATE_WB_9600 0
+#define IGF_BITRATE_RF_WB_13200 1
+#define IGF_BITRATE_SWB_9600 2
+#define IGF_BITRATE_SWB_13200 3
+#define IGF_BITRATE_RF_SWB_13200 4
+#define IGF_BITRATE_SWB_16400 5
+#define IGF_BITRATE_SWB_24400 6
+#define IGF_BITRATE_SWB_32000 7
+#define IGF_BITRATE_SWB_48000 8
+#define IGF_BITRATE_FB_16400 9
+#define IGF_BITRATE_FB_24400 10
+#define IGF_BITRATE_FB_32000 11
+#define IGF_BITRATE_FB_48000 12
+#define IGF_BITRATE_FB_96000 13
+#define IGF_BITRATE_FB_128000 14
+#define IGF_BITRATE_UNKNOWN 15
+
+
+#define IGF_WHITENING_OFF 0
+#define IGF_WHITENING_MID 1
+#define IGF_WHITENING_STRONG 2
+
+#define IGF_GRID_LB_NORM 0
+#define IGF_GRID_LB_TRAN 1
+#define IGF_GRID_LB_SHORT 2
+
+/* constants for IGFSCFDecoder and IGFSCFEncoder */
+#define IGF_CTX_OFFSET 3 /* offset added to make the context values nonnegative, for array indexing */
+#define IGF_CTX_COUNT (2 * IGF_CTX_OFFSET + 1) /* number of contexts for the AC statistical model */
+#define IGF_MIN_ENC_SEPARATE -12 /* minimum residual value coded separately, without escape coding */
+#define IGF_MAX_ENC_SEPARATE +12 /* maximum residual value coded separately, without escape coding */
+#define IGF_SYMBOLS_IN_TABLE (1 + (IGF_MAX_ENC_SEPARATE - IGF_MIN_ENC_SEPARATE + 1) + 1) /* alphabet size */
+
+/*----------------------------------------------------------------------------------*
+ * SC-VBR
+ *----------------------------------------------------------------------------------*/
+
+#define UVG1_CBSIZE 32 /* NELP unvoiced gain-1 codebook size */
+#define UVG2_CBSIZE 64 /* NELP unvoiced gain-2 codebook size */
+
+/* PPP constants */
+
+#define NUM_ERB_WB 24 /* Number of ERB bands in wideband */
+#define NUM_ERB_NB 22 /* Number of ERB bands in narrowband */
+
+#define MAXLAG 180
+
+#define PPP_LAG_THRLD_Q6 180*64
+#define PPP_LAG_THRLD 180
+#define SNR_THLD_FX_Q8 17152 /* Threshold is upscaled to Q8 to compared with st->vadsnr*/
+
+#define MAXLAG_WI (PPP_LAG_THRLD/2 + 12) /* Maximum lag used in waveform interpolation */
+#define MAX_LAG_PIT (PPP_LAG_THRLD + 21)
+
+#define WI_FX_phase_fx 512
+
+#define VBR_ADR_MAX_TARGET_x10_Q1 123 /* VBR_ADR_MAX_TARGET(6.15f)*10 in Q1 */
+
+#define Q_SCALE 7
+
+#define CONST_1_16_Q14 19005 /* 1.16*16384 */
+#define CONST_1_37_Q14 22446 /* 1.37*16384 */
+#define SCALE_DOWN_ERAS_Q15 26214 /* 0.8*32768 */
+#define SHAPE1_COEF_QF 15 /* shape1 num and den coeffcient Q format */
+#define SHAPE2_COEF_QF 15 /* shape2 num and den coeffcient Q format */
+#define SHAPE3_COEF_QF 15 /* shape3 num and den coeffcient Q format */
+#define BP1_COEF_WB_QF 14 /* wb num and den coeffcient Q format */
+#define BP1_COEF_NB_QF_ORDER7 13 /* nb num and den coeffcient Q format */
+
+/*----------------------------------------------------------------------------------*
+ * JBM
+ *----------------------------------------------------------------------------------*/
+
+#define MAX_JBM_SLOTS 100 /* every primary copy and partial copy stored in JBM needs one slot */
+#define MAX_AU_SIZE (128000/50/8) /* max frame size in bytes */
+
+#define ACTIVE 4
+#define BACKGROUND 1
+#define LOST 14
+#define SIZE_UNDERFLOW_ARRAY 10000
+#define TIME_WARP_SPACING 4
+#define FLAG_DECREASING_BUFFER_DEPTH 1
+#define TIME_WARP_SPACING_EXPAND 1
+#define PREALLOCATE_OUTPUT_SIZE 1000
+
+#define TSM_LOST 1
+#define TSM_AUDIO 2
+#define TSM_ONSET 3
+#define TSM_UNVOICED 4
+#define TSM_VOICED 5
+#define TSM_TRANSITION 6
+#define TSM_GENERIC 7
+#define TSM_BACKGROUND 8
+
+/*------------------------------------------------------------------------------------*
+FEC_clas_estim constants
+*-------------------------------------------------------------------------------------*/
+#define Q_MAX 12
+#define LG10 24660 /* 10*log10(2) in Q13 */
+#define L_Q_MEM 5
+
+#define GE_SHIFT 6
+#define LSF_1_OVER_256SQ 5000
+#define LSF_1_OVER_256SQSQ 763
+
+#define G_CODE_MIN_TC_Q15 655 /*0.02 Q15*/
+#define G_CODE_MAX_TC_Q0 5
+
+#define G_PITCH_MIN_Q14 0 /* SQ of gains: pitch gain lower limit (0.0 in Q13) */
+#define G_PITCH_MAX_MINUS_MIN_Q13 9994 /* SQ of gains: pitch gain upper limit (1.22-0 in Q13) */
+
+/* higher ACELP constants */
+#define G_AVQ_MIN_32kbps_Q15 2621 /* lower limit for gain Q in higher-rate ACELP contribtuion @32kbps (0.08 in Q15) */
+#define G_AVQ_MIN_Q15 26214 /* lower limit for gain Q in higher-rate ACELP contribtuion (0.8 in Q15) */
+#define G_AVQ_MAX_Q0 96 /* upper limit for gain Q in higher-rate ACELP contribtuion */
+
+#define LG10_G_AVQ_MIN_32kbps_Q14 (-17972) /* log10(0.08) lower limit for gain Q in higher-rate ACELP contribtuion @32kbps (0.08 in Q15) */
+#define LG10_G_AVQ_MIN_Q14 (-1588) /* log10(0.8) lower limit for gain Q in higher-rate ACELP contribtuion (0.8 in Q15) */
+#define LG10_G_AVQ_MAX_Q13 16239 /* log10(96) upper limit for gain Q in higher-rate ACELP contribtuion */
+#define LG10_G_CODE_MIN_TC192_Q14 (-3635) /* log10(0.6) */
+#define LG10_G_CODE_MAX_TC192_Q13 13212 /* log10(41) */
+#define LG10_G_CODE_MAX_Q13 5726 /* log10(5) SQ of gains: code gain upper limit */
+#define LG10_G_CODE_MIN_Q14 (-27836) /* log10(0.02) SQ of gains: code gain lower limit */
+#define LG10_G_CODE_MIN_TC_Q14 LG10_G_CODE_MIN_Q14 /* log10(0.02) Q15*/
+#define LG10_G_CODE_MAX_TC_Q13 LG10_G_CODE_MAX_Q13
+
+
+/* AVQ (RE8) related consatnts */
+#define QR 32768
+#define Q_AVQ_OUT 6 /* AVQ_output scaling currently Q9, but may change */
+#define Q_AVQ_OUT_DEC 10
+
+
+#define PIT_DECODE_2XL_SUBFR (2*L_SUBFR)
+#define PIT_FR1_8b_MINUS_PIT_MIN_X2 ((PIT_FR1_8b-PIT_MIN)*2)
+#define PIT_FR1_8b_MINUS_PIT_FR1_8b_MINUS_PIT_MIN_X2 (PIT_FR1_8b-PIT_FR1_8b_MINUS_PIT_MIN_X2)
+#define PIT_FR2_9b_MINUS_PIT_MIN_X4 ((PIT_FR2_9b-PIT_MIN)*4)
+#define PIT_FR1_EXT8b_MINUS_PIT_MIN_EXT_X2 ((PIT_FR1_EXTEND_8b-PIT_MIN_EXTEND)*2)
+#define PIT_FR2_EXT9b_MINUS_PIT_MIN_EXT_X4 ((PIT_FR2_EXTEND_9b-PIT_MIN_EXTEND)*4)
+#define PIT_FR1_EXT9b_MINUS_PIT_FR2_EXT9b_X2 ((PIT_FR1_EXTEND_9b-PIT_FR2_EXTEND_9b)*2)
+#define PIT_FR1_DEXT8b_MINUS_PIT_MIN_DEXT_X2 ((PIT_FR1_DOUBLEEXTEND_8b-PIT_MIN_DOUBLEEXTEND)*2 )
+#define PIT_FR2_DEXT9b_MINUS_PIT_MIN_DEXT_X4 ((PIT_FR2_DOUBLEEXTEND_9b-PIT_MIN_DOUBLEEXTEND)*4 )
+
+#define PIT_DECODE_1 ((PIT_FR2_9b-PIT_MIN)*4 + (PIT_FR1_9b-PIT_FR2_9b)*2)
+#define PIT_DECODE_2 ((PIT_FR2_9b-PIT_MIN)*4)
+#define PIT_DECODE_3 (PIT_FR1_9b - ((PIT_FR2_9b-PIT_MIN)*4) - ((PIT_FR1_9b-PIT_FR2_9b)*2))
+#define PIT_DECODE_7 (PIT_FR1_EXTEND_9b - (PIT_FR2_EXT9b_MINUS_PIT_MIN_EXT_X4) - (PIT_FR1_EXT9b_MINUS_PIT_FR2_EXT9b_X2))
+#define PIT_DECODE_8 (PIT_FR1_DOUBLEEXTEND_8b - ((PIT_FR1_DOUBLEEXTEND_8b-PIT_MIN_DOUBLEEXTEND)*2))
+#define PIT_DECODE_9 (( (PIT_FR2_DOUBLEEXTEND_9b-PIT_MIN_DOUBLEEXTEND)*4 + (PIT_FR1_DOUBLEEXTEND_9b-PIT_FR2_DOUBLEEXTEND_9b)*2))
+#define PIT_DECODE_10 (PIT_FR1_DOUBLEEXTEND_9b - ((PIT_FR2_DOUBLEEXTEND_9b-PIT_MIN_DOUBLEEXTEND)*4) - ((PIT_FR1_DOUBLEEXTEND_9b-PIT_FR2_DOUBLEEXTEND_9b)*2))
+
+#define BIN4_FX 800
+#define TH_COR_FX 19661 /* Q15 Minimum correlation for per bin processing */
+#define TH_D_FX 800 /* 50 (Q4) Difference limit between nearest harmonic and a frequency bin */
+#define TH_PIT_FX 128 /* (Fs / (2.0f * TH_D)) Maximum pitch for per bin processing */
+
+#define GUESS_TBL_SZ 256
+#define INT_FS_FX 12800 /* internal sampling frequency */
+#define INT_FS_16k_FX 16000 /* CELP core internal sampling frequency @16kHz */
+
+#define WB_LIMIT_LSF_FX 16256
+#define Fs_2 16384 /* lsf max value (Use in reorder_fx.c) */
+#define Fs_2_16k 20480 /* lsf max value (Use in reorder_fx.c) */
+
+#define LG10 24660 /* 10*log10(2) in Q13 */
+#define LG10_s3_0 16440 /* 10*log10(2)/1.55 = 1.00343331 in Q14 */
+
+#define MU_MA_FX 10923 /* original prediction factor for the AMR WB tables (Q15) */
+
+#define E_MIN_FXQ15 115 /* Q15*/
+
+#define MAX_DYNAMIC_FX (82*128)
+#define MIN_DYNAMIC_FX (50*128)
+#define DYNAMIC_RANGE_FX (MAX_DYNAMIC_FX-MIN_DYNAMIC_FX)
+#define MAX_GSC_NF_BITS 3
+#define GSC_NF_STEPS (1 << MAX_GSC_NF_BITS)
+#define GSF_NF_DELTA_FX (DYNAMIC_RANGE_FX/GSC_NF_STEPS)
+
+/*----------------------------------------------------------------------------------*
+ * DTC/iDCT constants
+ *----------------------------------------------------------------------------------*/
+
+/* DCT related */
+#define KP559016994_16FX 1200479845 /* EDCT & EMDCT constants */
+#define KP951056516_16FX 2042378325 /* EDCT & EMDCT constants */
+#define KP587785252_16FX 1262259213 /* EDCT & EMDCT constants */
+
+/*----------------------------------------------------------------------------------*
+ * AVQ constants
+ *----------------------------------------------------------------------------------*/
+
+#define MIN_GLOB_GAIN_BWE_HR_FX 24576 /* Q13 */
+#define MAX_GLOB_GAIN_BWE_HR_FX 32000 /* Q6 */
+
+#define LG10_MIN_GLOB_GAIN_BWE_HR_Q14 7817
+#define LG10_MAX_GLOB_GAIN_BWE_HR_Q13 22110
+
+
+/*----------------------------------------------------------------------------------*
+ * LD music post-filter constants
+ *----------------------------------------------------------------------------------*/
+
+#define BIN_16kdct_fx (6400/DCT_L_POST)
+#define E_MIN_Q15 14680 /* 0.0035 -> Q22 */
+
+#define QSCALE 7
+#define MODE2_E_MIN 4/*0.03f Q0*/ /* 0.03f in QSCALE */
+#define MODE2_E_MIN_Q15 983/*0.03f Q15*/ /* 0.03f in Q15*/
+
+/* long term pst parameters : */
+#define L2_LH2_L 4 /* log2(LH2_L) */
+#define MIN_GPLT_FX 21845 /* LT gain minimum 1/1.5 (Q15) */
+
+#define AGC_FAC_FX 32358 /* gain adjustment factor 0.9875 (Q15) */
+#define AGC_FAC1_FX (Word16)(32768L - AGC_FAC_FX)
+
+#define DOWNMIX_12k8_FX 1850
+
+/*----------------------------------------------------------------------------------*
+ * HQ Constants
+ *----------------------------------------------------------------------------------*/
+
+#define INV2POWHALF 23170 /* Q15, sqrt(2)/2 */
+#define EPSILLON_FX (Word16) 1
+#define MAX_SFM_LEN_FX 96
+#define MAX_P_ATT_FX (Word16) 40 /* Maximum number of pulses for gain attenuation factor */
+#define MAX_PHG_FX (Word16) 10 /* Q0, Maximum number of pulses for which to apply pulse height dependent gain */
+#define PHG_START_FX (Word16) 3277 /* Q15, 0.1f */
+#define PHG_DELTA_FX (Word16) 2621 /* Q15, ((PHG_END-PHG_START)/MAX_PHG) */
+#define ENV_ADJ_START_FX (Word16) 6 /* Q0, Number of consecutive bands for which the attenuation is maximum */
+#define ENV_ADJ_INV_INCL_FX (Word16) 6554 /* Q15, 1/5.0f, Inverse inclination for mapping between attenuation region width and attenuation limit */
+
+#define INV_HVQ_THRES_BIN_24k 9362 /* 1/224 in Q21 */
+#define INV_HVQ_THRES_BIN_32k 6554 /* 1/320 in Q21 */
+#define INV_BANDS_PER_SUBFRAMES 14564 /* 1/9 in Q17 */
+#define NUM_SUBFRAMES 4
+#define BANDS_PER_SUBFRAMES 9
+#define ENERGY_TH_NUM_SUBFRAMES 1638400L /* 400 in Q12 */
+#define INV_SFM_N_ENV_STAB 19418 /* 1/27 in Q19 */
+#define ENERGY_TH_FX 819200L /* 100 in Q13 */
+#define ENERGY_LT_BETA_FX 30474 /* 0.93 in Q15 - Smoothing factor for long-term energy measure */
+#define ENERGY_LT_BETA_1_FX 2294 /* 0.07 i Q15 - (1 - ENERGY_LT_BETA_FX) */
+#define INV_DELTA_TH 13107 /* 1/5 in Q16 - Inverse Delta energy threshold for transient detection for envelope stability */
+
+#define ONE_OVER_HVQ_BAND_MAX_BITS_24k_FX ((Word16) 410) /* Q15, 1/80 = 0.0125 */
+#define ONE_OVER_HVQ_BAND_MAX_BITS_32k_FX ((Word16) 345) /* Q15, 1/95 = 0.010526315 */
+
+#define INV_PREECHO_SMOOTH_LENP1_FX 1560 /*(32768 / (PREECHO_SMOOTH_LEN + 1.0));*/
+
+#define INV_HVQ_BW 1024 /* Q15 1/32 */
+
+#define ACELP_48k_BITS 960 /* Q0 - ACELP_48k / 50 */
+
+
+/*--------------------------------------
+ * FEC_HQ_phase_ecu
+ *-------------------------------------*/
+
+#define OFF_FRAMES_LIMIT 30 /* Hard limit the variable "time_offs" to 30 */
+
+/*----------------------------------------------------------------------------------*
+ * FEC for HQ core
+ *----------------------------------------------------------------------------------*/
+
+
+#define MAX_SB_NB 3
+
+
+#define NELP_LP_ORDER 8
+#define NUM_NELP_GAINS 10
+
+#define N_LEAD_NB 70 /* (N_LEAD_MDCT*(L_FRAME8k/20)) */
+#define N_ZERO_NB 45 /* (N_ZERO_MDCT*(L_FRAME8k/20)) */
+#define N_LEAD_O_NB 90 /* (20.f-N_LEAD_MDCT)*(L_FRAME8k/20) */
+#define N_ZERO_O_NB 35 /* (10.f-N_ZERO_MDCT)*(L_FRAME8k/20) */
+#define N_Z_L_NB 115 /* (N_Z_L_MDCT*(float)(L/20)) = N_ZERO_NB + N_LEAD_NB*/
+#define N_Z_L_O_NB 205 /* (N_Z_L_O_MDCT*(float)(L/20)) = N_ZERO_NB + N_LEAD_NB + N_LEAD_O_NB */
+
+#define ED_THRES_12P_fx 66
+#define ED_THRES_50P_fx 326
+#define ED_THRES_90P_fx 1091
+
+/*----------------------------------------------------------------------------------*
+ * ISF quantizer constants
+ *----------------------------------------------------------------------------------*/
+
+/*qlpc_avq, lsf_msvq_ma*/
+#define W_MODE0 0x1333 /*60.0f/FREQ_DIV in 0Q15*/
+#define W_MODE1 0x14CD /*65.0f/FREQ_DIV in 0Q15*/
+#define W_MODE2 0x147B /*64.0f/FREQ_DIV in 0Q15*/
+#define W_MODE_ELSE 0x1429 /*60.0f/FREQ_DIV in 0Q15*/
+
+
+enum TRACKPOS
+{
+ TRACKPOS_FIXED_FIRST =0, /* Fill tracks from left */
+ TRACKPOS_FIXED_EVEN =1, /* Even tracks */
+ TRACKPOS_FIXED_FIRST_TWO =2, /* One track of 32 */
+ TRACKPOS_FIXED_TWO =3, /* Two tracks of 32 instead of four of 16 */
+ TRACKPOS_FREE_ONE =4, /* One freely moving track with extra pulse */
+ TRACKPOS_FREE_THREE =5 /* Three freely moving tracks with single extra pulses */
+};
+
+#define ALP_E 2
+
+/* Lag window strengths */
+enum
+{
+ LAGW_WEAK, /* weak lag window */
+ LAGW_MEDIUM, /* medium strength lag window */
+ LAGW_STRONG, /* strong lag window */
+
+ NUM_LAGW_STRENGTHS
+};
+
+/* qmc_cng_common.h */
+/* codec side */
+#define SCALE_TABLE_SHIFT_FACTOR (31-23)
+
+/* parameter_bitmapping.h */
+#define NPARAMS_MAX 10
+
+/*tns_tables.h*/
+
+#define TRUE 1
+#define FALSE 0
+
+#define PRED_GAIN_E 8
+
+/* Flags for CLDFB intialization */
+/* Flag indicating that the states should be kept. */
+#define CLDFB_FLAG_KEEP_STATES 8
+/* Flag indicating 2.5 ms setup */
+#define CLDFB_FLAG_2_5MS_SETUP 128
+
+
+/* bits_alloc.h */
+#define RATE_MODE_MAX 2 /*Number of rate mode*/
+#define BANDWIDTH_MODE_MAX 2 /*Number of different bandwidth modes (NB/WB-FB)*/
+
+
+typedef enum SIGNAL_CLASSIFER_MODE
+{
+ CLASSIFIER_ACELP,
+ CLASSIFIER_TCX
+} SIGNAL_CLASSIFIER_MODE;
+
+
+#define NRG_CHANGE_E 8
+#define AVG_FLAT_E 8
+
+#define FRAME_SIZE_NB 13
+
+/* RTP Payload Header Info */
+#define ACTIVE_FRAME 0xFF
+#define SID_FRAME 0xFA
+#define ZERO_FRAME 0xF0
+
+
+/************************************************************************/
+
+/************************************************************************/
+#define UNKNOWN_NOISE 0
+#define SILENCE 1
+
+#define CNT0P1 1717986918 /* 0.1*2^34 */
+#define CNT0P001 1099511627 /* 0.001*2^40 */
+#define CNT0P0001 1759218604 /* 0.0001*2^44 */
+
+#define CNT0P05 1717986918 /* 0.05*2^35 */
+
+#define CNT1DIV28 1227133513 /* (1/28)*2^35 */
+#define CNT1DIV14 1227133513 /* (1/14)*2^34 */
+#define CNT1DIV8 1073741824 /* (1/8)*2^33 */
+
+#define SP_CENTER_Q 10
+#define ITD_STABLE_RATE_Q 15
+#define SPEC_AMP_Q 14
+#define SFM_Q 15
+#define TONA_Q 14
+#define lt_bg_highf_eng_Q 16
+
+/************************************************************************/
+/* TEC/TFA */
+/************************************************************************/
+#define DELAY_TEMP_ENV_BUFF_TEC 9
+#define EXT_DELAY_HI_TEMP_ENV 2
+
+
+/************************************************************************/
+/* CLDFB */
+/************************************************************************/
+
+#define SCALE_MODULATION ( 1 )
+
+#define SCALE_GAIN_ANA_10 ( 4 )
+#define SCALE_GAIN_ANA_16 ( 3 )
+#define SCALE_GAIN_ANA_20 ( 3 )
+#define SCALE_GAIN_ANA_32 ( 2 )
+#define SCALE_GAIN_ANA_40 ( 2 )
+#define SCALE_GAIN_ANA_60 ( 1 )
+
+#define SCALE_GAIN_SYN (-6 )
+
+#define SCALE_CLDFB_ANA_10 ( SCALE_MODULATION + SCALE_GAIN_ANA_10 )
+#define SCALE_CLDFB_ANA_16 ( SCALE_MODULATION + SCALE_GAIN_ANA_16 )
+#define SCALE_CLDFB_ANA_20 ( SCALE_MODULATION + SCALE_GAIN_ANA_20 )
+#define SCALE_CLDFB_ANA_32 ( SCALE_MODULATION + SCALE_GAIN_ANA_32 )
+#define SCALE_CLDFB_ANA_40 ( SCALE_MODULATION + SCALE_GAIN_ANA_40 )
+#define SCALE_CLDFB_ANA_60 ( SCALE_MODULATION + SCALE_GAIN_ANA_60 )
+
+#define SCALE_CLDFB_SYN_10 ( SCALE_MODULATION + SCALE_GAIN_SYN )
+#define SCALE_CLDFB_SYN_16 ( SCALE_MODULATION + SCALE_GAIN_SYN )
+#define SCALE_CLDFB_SYN_20 ( SCALE_MODULATION + SCALE_GAIN_SYN )
+#define SCALE_CLDFB_SYN_32 ( SCALE_MODULATION + SCALE_GAIN_SYN )
+#define SCALE_CLDFB_SYN_40 ( SCALE_MODULATION + SCALE_GAIN_SYN )
+#define SCALE_CLDFB_SYN_60 ( SCALE_MODULATION + SCALE_GAIN_SYN )
+
+/************************************************************************/
+/* FFT */
+/************************************************************************/
+
+#define SCALEFACTORN2 ( 3)
+#define SCALEFACTOR2 ( 2)
+#define SCALEFACTOR3 ( 3)
+#define SCALEFACTOR4 ( 3)
+#define SCALEFACTOR5 ( 4)
+#define SCALEFACTOR8 ( 4)
+#define SCALEFACTOR10 ( 5)
+#define SCALEFACTOR12 ( 5)
+#define SCALEFACTOR15 ( 5)
+#define SCALEFACTOR16 ( 5)
+#define SCALEFACTOR20 ( 5)
+#define SCALEFACTOR24 ( 6)
+#define SCALEFACTOR30 ( 6)
+#define SCALEFACTOR30_1 ( 5)
+#define SCALEFACTOR30_2 ( 1)
+#define SCALEFACTOR32 ( 6)
+#define SCALEFACTOR32_1 ( 5)
+#define SCALEFACTOR32_2 ( 1)
+#define SCALEFACTOR40 ( 7)
+#define SCALEFACTOR60 ( 7)
+#define SCALEFACTOR64 ( 7)
+#define SCALEFACTOR80 ( 8)
+#define SCALEFACTOR100 (10)
+#define SCALEFACTOR120 ( 8)
+#define SCALEFACTOR128 ( 8)
+#define SCALEFACTOR160 ( 8)
+#define SCALEFACTOR192 (10)
+#define SCALEFACTOR200 (10)
+#define SCALEFACTOR240 ( 9)
+#define SCALEFACTOR256 ( 9)
+#define SCALEFACTOR320 (10)
+#define SCALEFACTOR400 (10)
+#define SCALEFACTOR480 (11)
+#define SCALEFACTOR600 (10)
+
+#define BASOP_CFFT_MAX_LENGTH 600
+
+enum
+{
+ PRIMARY_2800,
+ PRIMARY_7200,
+ PRIMARY_8000,
+ PRIMARY_9600,
+ PRIMARY_13200,
+ PRIMARY_16400,
+ PRIMARY_24400,
+ PRIMARY_32000,
+ PRIMARY_48000,
+ PRIMARY_64000,
+ PRIMARY_96000,
+ PRIMARY_128000,
+ PRIMARY_SID,
+ PRIMARY_FUT1,
+ SPEECH_LOST,
+ NO_DATA_TYPE
+};
+
+enum
+{
+ AMRWB_IO_6600,
+ AMRWB_IO_8850,
+ AMRWB_IO_1265,
+ AMRWB_IO_1425,
+ AMRWB_IO_1585,
+ AMRWB_IO_1825,
+ AMRWB_IO_1985,
+ AMRWB_IO_2305,
+ AMRWB_IO_2385,
+ AMRWB_IO_SID
+ /*, AMRWB_IO_FUT1,
+ AMRWB_IO_FUT2,
+ AMRWB_IO_FUT3,
+ AMRWB_IO_FUT4,
+ SPEECH_LOST,
+ NO_DATA_TYPE */
+};
+
+enum
+{
+ G192,
+ MIME
+ , VOIP_G192_RTP
+ , VOIP_RTPDUMP
+};
+
+#endif /* CNST_FX_H */
diff --git a/lib_com/codec_tcx_common.c b/lib_com/codec_tcx_common.c
new file mode 100644
index 0000000000000000000000000000000000000000..5f5f1db1bf0cca57579ef9bf3200e8d9890a4a7b
--- /dev/null
+++ b/lib_com/codec_tcx_common.c
@@ -0,0 +1,288 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "prot_fx.h"
+#include "options.h"
+
+#include "stl.h"
+#include "prot_fx.h"
+#include "basop_util.h"
+#include "rom_basop_util.h"
+#define inv_int InvIntTable
+
+
+
+Word16 tcxGetNoiseFillingTilt(Word16 A[], Word16 lpcorder, Word16 L_frame, Word16 mode, Word16 *noiseTiltFactor)
+{
+ Word16 firstLine;
+ Word32 tmp;
+ Word16 As[M+1];
+
+
+ IF (mode != 0)
+ {
+ firstLine = idiv1616U(L_frame, 6);
+ *noiseTiltFactor = 18432/*0.5625f Q15*/;
+ move16();
+ }
+ ELSE
+ {
+ firstLine = shr(L_frame, 3);
+
+ Copy_Scale_sig( A, As, lpcorder+1, sub(norm_s(A[0]),2) );
+ tmp = get_gain(As+1, As, lpcorder);
+ BASOP_SATURATE_WARNING_OFF;
+ *noiseTiltFactor = add(round_fx(L_shl(tmp, 15)), 3072/*0.09375f Q15*/);
+ move16();
+ BASOP_SATURATE_WARNING_ON;
+ }
+
+
+ return firstLine;
+}
+
+
+void tcxFormantEnhancement(
+ Word16 xn_buf[],
+ Word16 gainlpc[], Word16 gainlpc_e[],
+ Word32 spectrum[], Word16 *spectrum_e,
+ Word16 L_frame,
+ Word16 L_frameTCX
+)
+{
+ Word16 i, j, k, l, n;
+ Word16 fac, fac0, fac1, fac_e, d, tmp;
+ Word16 xn_buf_e, xn_one, m, e;
+
+
+ k = shr(L_frame, 6); /* FDNS_NPTS = 64 */
+ l = 0;
+ move16();
+
+ /* get exponent */
+ xn_buf_e = 0;
+ move16();
+ FOR (i = 0; i < FDNS_NPTS; i++)
+ {
+ xn_buf_e = s_max(xn_buf_e, gainlpc_e[i]);
+ }
+ xn_buf_e = shr(add(xn_buf_e, 1), 1); /* max exponent after sqrt */
+ xn_one = shr(0x4000, sub(xn_buf_e, 1)); /* 1.0 scaled to xn_buf_e */
+
+ /* Formant enhancement via square root of the LPC gains */
+ e = gainlpc_e[0];
+ move16();
+ m = Sqrt16(gainlpc[0], &e);
+ xn_buf[0] = shl(m, sub(e, xn_buf_e));
+ move16();
+
+ e = gainlpc_e[1];
+ move16();
+ m = Sqrt16(gainlpc[1], &e);
+ xn_buf[1] = shl(m, sub(e, xn_buf_e));
+ move16();
+
+ fac0 = s_min(xn_buf[0], xn_buf[1]);
+ fac_e = xn_buf_e;
+ move16();
+ fac0 = Inv16(fac0, &fac_e);
+
+ FOR (i = 1; i < FDNS_NPTS-1; i++)
+ {
+ e = gainlpc_e[i+1];
+ move16();
+ m = Sqrt16(gainlpc[i+1], &e);
+ xn_buf[i+1] = shl(m, sub(e, xn_buf_e));
+ move16();
+
+ test();
+ IF ((LE_16(xn_buf[i-1], xn_buf[i]))&&(LE_16(xn_buf[i+1],xn_buf[i])))
+ {
+ m = s_max(xn_buf[i-1], xn_buf[i+1]);
+ e = xn_buf_e;
+ move16();
+ m = Inv16(m, &e);
+
+ fac1 = m;
+ move16();
+ tmp = sub(e, fac_e);
+
+ if (tmp > 0) fac0 = shr(fac0, tmp);
+ if (tmp < 0) fac1 = shl(fac1, tmp);
+
+ if (tmp > 0)
+ {
+ fac_e = e;
+ move16();
+ }
+
+ d = sub(fac1, fac0);
+ n = sub(i, l);
+ assert(n <= 64);
+
+ xn_buf[l] = xn_one;
+ move16();
+ FOR (j = 1; j < n; j++)
+ {
+ fac = add(fac0, mult(d, extract_l(L_mult0(j, inv_int[n]))));
+ BASOP_SATURATE_WARNING_OFF;
+ xn_buf[l+j] = s_min(xn_one, shl(mult(xn_buf[l+j], fac), fac_e));
+ move16();
+ BASOP_SATURATE_WARNING_ON;
+ }
+
+ l = i;
+ move16();
+
+ fac0 = m;
+ move16();
+ fac_e = e;
+ move16();
+ }
+ }
+ /* i = FDNS_NPTS - 1; Completing changes to gains */
+ m = s_min(xn_buf[i-1], xn_buf[i]);
+ e = xn_buf_e;
+ move16();
+ m = Inv16(m, &e);
+
+ fac1 = m;
+ move16();
+ tmp = sub(e, fac_e);
+
+ if (tmp > 0) fac0 = shr(fac0, tmp);
+ if (tmp < 0) fac1 = shl(fac1, tmp);
+
+ if (tmp > 0)
+ {
+ fac_e = e;
+ move16();
+ }
+
+ d = sub(fac1, fac0);
+ n = sub(i, l);
+ assert(n <= 64);
+
+ xn_buf[l] = xn_one;
+ move16();
+ FOR (j = 1; j < n; j++)
+ {
+ fac = add(fac0, mult(d, extract_l(L_mult0(j, inv_int[n]))));
+ BASOP_SATURATE_WARNING_OFF;
+ xn_buf[l+j] = s_min(xn_one, shl(mult(xn_buf[l+j], fac), fac_e));
+ move16();
+ BASOP_SATURATE_WARNING_ON;
+ }
+
+ xn_buf[i] = xn_one;
+ move16();
+
+ /* Application of changed gains onto decoded MDCT lines */
+ FOR (i = 0; i < L_frame; i += k)
+ {
+ FOR (l = 0; l < k; l++)
+ {
+ *spectrum = Mpy_32_16_1(*spectrum, *xn_buf);
+ move32();
+ spectrum++;
+ }
+ xn_buf++;
+ }
+
+ tmp = sub(L_frameTCX, L_frame);
+ FOR (i = 0; i < tmp; i++)
+ {
+ spectrum[i] = L_shr(spectrum[i], xn_buf_e);
+ move32();
+ }
+ *spectrum_e = add(*spectrum_e, xn_buf_e);
+ move16();
+
+}
+
+void tcxInvertWindowGrouping(TCX_config *tcx_cfg,
+ Word32 xn_buf[],
+ Word32 spectrum[],
+ Word16 L_frame,
+ Word8 fUseTns,
+ Word16 last_core,
+ Word16 index,
+ Word16 frame_cnt,
+ Word16 bfi)
+{
+ Word16 i, L_win, L_spec;
+ Word32 *p;
+
+
+ L_win = shr(L_frame, 1);
+ L_spec = tcx_cfg->tnsConfig[0][0].iFilterBorders[0];
+ move16();
+
+ test();
+ test();
+ if ((frame_cnt != 0) && (bfi == 0) && (last_core != ACELP_CORE)) /* fix sub-window overlap */
+ {
+ tcx_cfg->tcx_last_overlap_mode = tcx_cfg->tcx_curr_overlap_mode;
+ move16();
+ }
+ test();
+ test();
+ test();
+ test();
+ test();
+ test();
+ test();
+ IF (((bfi==0) &&((tcx_cfg->tcx_last_overlap_mode != FULL_OVERLAP) ||
+ ((tcx_cfg->tcx_curr_overlap_mode == FULL_OVERLAP) && (frame_cnt == 0) && (index == 0))))
+ ||
+ ((bfi!=0) &&((tcx_cfg->tcx_last_overlap_mode != FULL_OVERLAP) &&
+ !(tcx_cfg->tcx_curr_overlap_mode == FULL_OVERLAP))))
+ {
+ /* ungroup sub-windows: deinterleave MDCT bins into separate windows */
+ p = xn_buf;
+ FOR (i = 1; i < L_win; i += 2)
+ {
+ *p++ = spectrum[i];
+ move32();
+ }
+
+ p = spectrum;
+ FOR (i = 0; i < L_frame; i += 2)
+ {
+ *p++ = spectrum[i];
+ move32();
+ }
+
+ p = spectrum + L_frame - 1;
+ FOR (i = sub(L_frame, 1); i > L_win; i -= 2)
+ {
+ *p-- = spectrum[i];
+ move32();
+ }
+ Copy32(xn_buf, spectrum + L_win, shr(L_win, 1));
+
+ test();
+ test();
+ IF ((tcx_cfg->fIsTNSAllowed != 0) && (bfi == 0) && (fUseTns != 0))
+ {
+ /* rearrange LF sub-window lines prior to TNS synthesis filtering */
+ IF (LT_16(L_spec, L_frame))
+ {
+ Copy32(spectrum+8, spectrum+16, sub(shr(L_spec,1),8));
+ Copy32(spectrum+L_frame/2, spectrum+8, 8);
+ Copy32(spectrum+L_frame/2+8, spectrum+L_spec/2+8, sub(shr(L_spec,1),8));
+ }
+ ELSE
+ {
+ Copy32(spectrum+L_win, xn_buf, 8);
+ Copy32(spectrum+8, spectrum+16, sub(L_win, 8));
+ Copy32(xn_buf, spectrum+8, 8);
+ }
+ }
+ }
+
+}
+
+
diff --git a/lib_com/core_com_config_fx.c b/lib_com/core_com_config_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..a287157d950b9c214353b44f8c238d36ffc30b73
--- /dev/null
+++ b/lib_com/core_com_config_fx.c
@@ -0,0 +1,471 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include
+#include
+#include
+
+#include "options.h"
+#include "stl.h"
+#include "basop_util.h"
+#include "prot_fx.h"
+#include "rom_com_fx.h"
+
+
+Word8 getTcxonly(const Word32 bitrate)
+{
+
+ Word8 tcxonly;
+
+ tcxonly = 0;
+ move16();
+ if( GT_32(bitrate,32000))
+ {
+ tcxonly = 1;
+ move16();
+ }
+
+ return tcxonly;
+}
+
+Word8 getCtxHm(const Word32 bitrate, const Word16 rf_flag)
+{
+
+ Word8 ctx_hm;
+
+ ctx_hm = 0;
+ move16();
+ test();
+ if( (bitrate > LPC_SHAPED_ARI_MAX_RATE) && (bitrate <= 64000) && !rf_flag)
+ {
+
+ ctx_hm = 1;
+ move16();
+ }
+
+
+ return ctx_hm;
+}
+
+
+Word8 getResq(const Word32 bitrate)
+{
+
+ Word8 resq;
+
+ resq = 0;
+ move16();
+ if (LE_32(bitrate,64000))
+ {
+ resq = 1;
+ move16();
+ }
+
+ return resq;
+}
+
+
+Word8 getTnsAllowed(const Word32 bitrate
+ ,const Word16 igf
+ )
+{
+ Word8 tnsAllowed;
+
+ tnsAllowed = 0;
+ move16();
+ IF ( igf != 0 )
+ {
+ if( GT_32(bitrate, HQ_16k40))
+ {
+ tnsAllowed = 1;
+ move16();
+ }
+ }
+ ELSE
+ {
+ if( GT_32(bitrate, HQ_32k))
+ {
+ tnsAllowed = 1;
+ move16();
+ }
+ }
+
+ return tnsAllowed;
+}
+
+
+Word8 getRestrictedMode(const Word32 bitrate, const Word16 Opt_AMR_WB)
+{
+
+ Word8 restrictedMode;
+
+ restrictedMode = 3;
+ move16();
+
+ test();
+ IF ( (Opt_AMR_WB == 0) && (GT_32(bitrate,32000)))
+ {
+ restrictedMode = 6;
+ move16();
+ }
+ ELSE IF( Opt_AMR_WB )
+ {
+ restrictedMode = 1;
+ move16();
+ }
+
+ return restrictedMode;
+}
+
+
+Word16 sr2fscale(const Word32 sr)
+{
+ Word16 fscale;
+
+ SWITCH(sr)
+ {
+ case 8000:
+ fscale = (FSCALE_DENOM*8000)/12800;
+ move16();
+ BREAK;
+
+ case 12800:
+ fscale = FSCALE_DENOM;
+ move16();
+ BREAK;
+
+ case 16000:
+ fscale = (FSCALE_DENOM*16000)/12800;
+ move16();
+ BREAK;
+
+ case 25600:
+ fscale = (FSCALE_DENOM*25600)/12800;
+ move16();
+ BREAK;
+
+ case 32000:
+ fscale = (FSCALE_DENOM*32000)/12800;
+ move16();
+ BREAK;
+
+ case 48000:
+ fscale = (FSCALE_DENOM*48000)/12800;
+ move16();
+ BREAK;
+
+ default:
+ assert(0);
+ fscale = 0; /* just to avoid compiler warning */
+ BREAK;
+ }
+ return fscale;
+}
+
+Word32 getCoreSamplerateMode2(const Word32 bitrate, const Word16 bandwidth, const Word16 rf_mode)
+{
+
+ Word32 sr_core;
+ sr_core = -1; /* to suppress MSVC warning */ move32();
+
+ test();
+ test();
+ test();
+ test();
+ test();
+ test();
+ test();
+ test();
+
+ IF( EQ_32( bandwidth,NB))
+ {
+ sr_core = 12800;
+ move32();
+ }
+
+ ELSE IF ( L_and(EQ_32(bandwidth,WB),LT_32(bitrate,13200))||
+ L_and(EQ_32(bandwidth,SWB), LE_32(bitrate,13200)) || EQ_16(rf_mode,1) )
+
+ {
+ sr_core = 12800;
+ move32();
+ }
+ ELSE IF (EQ_32(bandwidth,WB)||((LE_32(bitrate,32000))&&((EQ_32(bandwidth,SWB))||(EQ_32(bandwidth,FB)))))
+ {
+ sr_core = 16000;
+ move32();
+ }
+ ELSE IF ( ((EQ_32(bandwidth,SWB))||(EQ_32(bandwidth,FB)))&&(LE_32(bitrate,64000)))
+ {
+ sr_core = 25600;
+ move32();
+ }
+ ELSE IF (EQ_32(bandwidth,SWB)||EQ_32(bandwidth,FB))
+ {
+ sr_core = 32000;
+ move32();
+ }
+ ELSE
+ {
+ assert(0);
+ }
+
+ return sr_core;
+}
+
+Word16 getTcxBandwidth(const Word16 bandwidth)
+{
+
+ Word16 tcxBandwidth;
+
+ tcxBandwidth = 16384/*0.5f Q15*/;
+ move16();
+ if(EQ_16(bandwidth, NB))
+ {
+ tcxBandwidth = 10240/*0.3125f Q15*/;
+ move16();
+
+ }
+
+ return tcxBandwidth;
+}
+
+
+Word8 getIgfPresent(
+ const Word32 bitrate,
+ const Word16 bandwidth
+ ,const Word16 rf_mode
+)
+{
+ Word8 igfPresent;
+
+ igfPresent = 0;
+ move16();
+
+ test();
+ test();
+ if( (EQ_16(bandwidth, SWB))&&(GE_32(bitrate,ACELP_9k60))&&(LT_32(bitrate,HQ_64k)))
+ {
+ igfPresent = 1;
+ move16();
+ }
+
+ test();
+ if( EQ_16(bandwidth, FB)&&(GE_32(bitrate,ACELP_16k40)))
+ {
+ igfPresent = 1;
+ move16();
+ }
+
+ test();
+ if( (EQ_16(bandwidth, WB))&&(EQ_32(bitrate,ACELP_9k60)))
+ {
+ igfPresent = 1;
+ move16();
+ }
+
+ test();
+ test();
+ test();
+ if( ((EQ_16(bandwidth, WB))||(EQ_16(bandwidth,SWB)))&&(EQ_16(rf_mode,1))&&(EQ_32(bitrate,ACELP_13k20)))
+ {
+ igfPresent = 1;
+ move16();
+ }
+
+ return igfPresent;
+}
+
+
+Word8 getCnaPresent(
+ const Word32 bitrate,
+ const Word16 bandwidth
+)
+{
+ Word8 flag_cna = 0;
+
+ flag_cna = 0;
+ move16();
+ test();
+ if( EQ_16(bandwidth, NB)&&(LE_32(bitrate,ACELP_13k20)))
+ {
+ flag_cna = 1;
+ move16();
+ }
+
+ test();
+ if( (EQ_16(bandwidth, WB))&&(LE_32(bitrate,ACELP_13k20)))
+ {
+ flag_cna = 1;
+ move16();
+ }
+
+ test();
+ if( (EQ_16(bandwidth, SWB))&&(LE_32(bitrate,ACELP_13k20)))
+ {
+ flag_cna = 1;
+ move16();
+ }
+
+ return flag_cna;
+}
+
+Word8 getTcxLtp(const Word32 sr_core)
+{
+
+ Word8 tcxltp = 0;
+
+ tcxltp = 0;
+ move16();
+ test();
+ if ( (LE_32(sr_core, 25600)))
+ {
+ tcxltp = 1;
+ move16();
+ }
+
+ return tcxltp;
+}
+
+
+Word16 initPitchLagParameters(
+ const Word32 sr_core,
+ Word16 *pit_min,
+ Word16 *pit_fr1,
+ Word16 *pit_fr1b,
+ Word16 *pit_fr2,
+ Word16 *pit_max
+)
+{
+
+ Word16 pit_res_max;
+
+ IF (EQ_32(sr_core, 12800))
+ {
+
+ *pit_min = PIT_MIN_12k8;
+ move16();
+ *pit_max = PIT_MAX_12k8;
+ move16();
+ *pit_fr2 = PIT_FR2_12k8;
+ move16();
+ *pit_fr1 = PIT_FR1_12k8;
+ move16();
+ *pit_fr1b = PIT_FR1_8b_12k8;
+ move16();
+ pit_res_max = 4;
+ move16();
+
+ }
+ ELSE IF (EQ_32(sr_core, 16000))
+ {
+
+ *pit_min = PIT_MIN_16k;
+ move16();
+ *pit_max = PIT_MAX_16k;
+ move16();
+ *pit_fr2 = PIT_FR2_16k;
+ move16();
+ *pit_fr1 = PIT_FR1_16k;
+ move16();
+ *pit_fr1b = PIT_FR1_8b_16k;
+ move16();
+ pit_res_max = 6;
+ move16();
+
+ }
+ ELSE IF (EQ_32(sr_core, 25600))
+ {
+
+ *pit_min = PIT_MIN_25k6;
+ move16();
+ *pit_max = PIT_MAX_25k6;
+ move16();
+ *pit_fr2 = PIT_FR2_25k6;
+ move16();
+ *pit_fr1 = PIT_FR1_25k6;
+ move16();
+ *pit_fr1b = PIT_FR1_8b_25k6;
+ move16();
+ pit_res_max = 4;
+ move16();
+ }
+ ELSE /* sr_core==32000 */
+ {
+
+ *pit_min = PIT_MIN_32k;
+ move16();
+ *pit_max = PIT_MAX_32k;
+ move16();
+ *pit_fr2 = PIT_FR2_32k;
+ move16();
+ *pit_fr1 = PIT_FR1_32k;
+ move16();
+ *pit_fr1b = PIT_FR1_8b_32k;
+ move16();
+ pit_res_max = 6;
+ move16();
+
+ }
+
+ return pit_res_max;
+}
+
+Word16 getNumTcxCodedLines(const Word16 bwidth)
+{
+
+ Word16 tcx_coded_lines;
+
+ tcx_coded_lines = 0;
+ move16();
+
+ if(EQ_16(bwidth, NB))
+ {
+ tcx_coded_lines = 160;
+ move16();
+ }
+
+ if(EQ_16(bwidth, WB))
+ {
+ tcx_coded_lines = 320;
+ move16();
+ }
+
+ if(EQ_16(bwidth, SWB))
+ {
+ tcx_coded_lines = 640;
+ move16();
+ }
+
+ if(EQ_16(bwidth, FB))
+ {
+ tcx_coded_lines = 960;
+ move16();
+ }
+
+ return tcx_coded_lines;
+}
+
+Word16 getTcxLpcShapedAri(
+ const Word32 total_brate,
+ const Word16 bwidth
+ ,const Word16 rf_mode
+)
+{
+ Word16 tcx_lpc_shaped_ari = 0;
+ move16();
+
+ (void) bwidth;
+
+ test();
+ if( (LE_32(total_brate, LPC_SHAPED_ARI_MAX_RATE))||rf_mode)
+ {
+ tcx_lpc_shaped_ari = 1;
+ move16();
+ }
+
+
+ return tcx_lpc_shaped_ari;
+}
diff --git a/lib_com/deemph_fx.c b/lib_com/deemph_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..56e32fc65a8d80c444eb10c01f518613cdf4da19
--- /dev/null
+++ b/lib_com/deemph_fx.c
@@ -0,0 +1,136 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+#include "basop_util.h"
+
+/*========================================================================*/
+/* FUNCTION : deemph_fx() */
+/*------------------------------------------------------------------------*/
+/* PURPOSE : Deemphasis: filtering through 1/(1-mu z^-1) */
+/*------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) mu : deemphasis factor Q15 */
+/* _ (Word16) L : vector size */
+/*------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ (Word16*) signal : signal Q_syn2-1 */
+/* _ (Word16*) mem : memory (y[-1]) Q_syn2-1 */
+/*------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*========================================================================*/
+void deemph_fx(
+ Word16 *signal, /* i/o: signal Qx */
+ const Word16 mu, /* i : deemphasis factor Q15 */
+ const Word16 L, /* i : vector size Q0 */
+ Word16 *mem /* i/o: memory (y[-1]) Qx */
+)
+{
+ Word16 i;
+ Word32 L_tmp;
+
+ L_tmp = L_deposit_h(signal[0]);
+ L_tmp = L_mac(L_tmp, *mem, mu);
+ signal[0] = round_fx(L_tmp);
+
+ FOR (i = 1; i < L; i++)
+ {
+ L_tmp = L_deposit_h(signal[i]);
+ L_tmp = L_mac(L_tmp, signal[i - 1], mu);
+ signal[i] = round_fx(L_tmp);
+ }
+
+ *mem = signal[L - 1];
+ move16();
+}
+
+/*-------------------------------------------------------------------*
+ * Deeemph2 :
+ *
+ * Deemphasis: filtering through 1/(1-mu z^-1)
+ * Output divided by 2
+ *-------------------------------------------------------------------*/
+void Deemph2(
+ Word16 x[], /* i/o: input signal overwritten by the output Qx/Qx-1 */
+ const Word16 mu, /* i : deemphasis factor Q15 */
+ const Word16 L, /* i : vector size Q0 */
+ Word16 *mem /* i/o: memory (y[-1]) Qx-1 */
+)
+{
+ Word16 i;
+ Word32 L_tmp;
+
+ /* saturation can occur in L_mac() */
+
+ L_tmp = L_mult(x[0], 16384);
+ x[0] = mac_r(L_tmp, *mem, mu);
+ move16();
+
+ FOR (i = 1; i < L; i++)
+ {
+ L_tmp = L_mult(x[i], 16384);
+ x[i] = mac_r(L_tmp, x[i - 1], mu);
+ move16();
+ }
+
+ *mem = x[L - 1];
+ move16();
+}
+
+
+/*
+ * E_UTIL_deemph2
+ *
+ * Parameters:
+ * shift I: scale output
+ * x I/O: signal Qx/Qx-shift
+ * mu I: deemphasis factor Qx
+ * L I: vector size
+ * mem I/O: memory (signal[-1]) Qx
+ *
+ * Function:
+ * Filtering through 1/(1-mu z^-1)
+ * Signal is divided by 2.
+ *
+ * Returns:
+ * void
+ */
+void E_UTIL_deemph2(Word16 shift, Word16 *x, const Word16 mu, const Word16 L, Word16 *mem)
+{
+ Word16 i;
+ Word32 L_tmp;
+
+ /* signal[0] = signal[0] + mu * (*mem); */
+ L_tmp = L_deposit_h(*mem);
+ IF(shift >= 0)
+ {
+ shift = shr(-32768, shift);
+ FOR (i = 0; i < L; i++)
+ {
+ L_tmp = L_msu(Mpy_32_16_1(L_tmp, mu), x[i],shift);
+ x[i] = round_fx(L_tmp);
+ }
+
+ }
+ ELSE
+ {
+ FOR (i = 0; i < L; i++)
+ {
+ L_tmp = L_msu(Mpy_32_16_1(L_tmp, mu), shr(x[i],shift),-32768);
+ x[i] = round_fx(L_tmp);
+ }
+ }
+
+ *mem = x[L - 1];
+ move16();
+
+ return;
+}
diff --git a/lib_com/delay_comp.c b/lib_com/delay_comp.c
new file mode 100644
index 0000000000000000000000000000000000000000..f67b752c4c5ab1af305a634f92673fbdab2754ed
--- /dev/null
+++ b/lib_com/delay_comp.c
@@ -0,0 +1,43 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "stl.h"
+#include "prot_fx.h"
+
+
+/*--------------------------------------------------------------------------
+* get_delay_fx()
+*
+* Function returns various types of delays in the codec in ms.
+*--------------------------------------------------------------------------*/
+
+Word32 get_delay_fx( /* o : delay value in ms */
+ const Word16 what_delay, /* i : what delay? (ENC or DEC) */
+ const Word32 io_fs /* i : input/output sampling frequency */
+)
+{
+ Word32 delay = 0;
+
+ IF( EQ_16(what_delay,ENC))
+ {
+ delay = (DELAY_FIR_RESAMPL_NS + ACELP_LOOK_NS);
+ move32();
+ }
+ ELSE
+ {
+ IF( EQ_32(io_fs,8000))
+ {
+ delay = DELAY_CLDFB_NS;
+ move32();
+ }
+ ELSE
+ {
+ delay = DELAY_BWE_TOTAL_NS;
+ move32();
+ }
+ }
+
+ return delay;
+}
diff --git a/lib_com/disclaimer.c b/lib_com/disclaimer.c
new file mode 100644
index 0000000000000000000000000000000000000000..52f2fc2e5de1bafbac79d0d6d8d326828bd03b6a
--- /dev/null
+++ b/lib_com/disclaimer.c
@@ -0,0 +1,19 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "disclaimer.h"
+#include "options.h"
+#include "stl.h"
+
+/* WMC_TOOL_SKIP_FILE */
+
+int print_disclaimer(FILE *fPtr)
+{
+
+ fprintf(fPtr, "\n===========================================================================\n");
+ fprintf(fPtr, " EVS Codec 3GPP TS26.452 August 12, 2021. \n");
+ fprintf(fPtr, " Version 16.3.0\n");
+ fprintf(fPtr, "===========================================================================\n\n\n");
+ return 0;
+}
diff --git a/lib_com/disclaimer.h b/lib_com/disclaimer.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb41b938d9d33006c6e8180b4b06672167f4ad54
--- /dev/null
+++ b/lib_com/disclaimer.h
@@ -0,0 +1,15 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#ifndef __INCLUDED_DISCLAIMER_H
+#define __INCLUDED_DISCLAIMER_H
+
+#include
+
+int print_disclaimer(FILE *fPtr);
+
+
+
+
+#endif /* __INCLUDED_DISCLAIMER_H */
diff --git a/lib_com/dlpc_bfi.c b/lib_com/dlpc_bfi.c
new file mode 100644
index 0000000000000000000000000000000000000000..4271e1cec393eef5c8b89098018a11d09f4dba97
--- /dev/null
+++ b/lib_com/dlpc_bfi.c
@@ -0,0 +1,55 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+
+/* Header files */
+#include
+#include
+#include
+#include "prot_fx.h"
+#include "stl.h"
+#include "prot_fx.h"
+
+void dlpc_bfi(
+ const Word16 L_frame,
+ Word16 *lsf_q, /* o : quantized LSFs */
+ const Word16 *lsfold, /* i : past quantized LSF */
+ const Word16 last_good, /* i : last good received frame */
+ const Word16 nbLostCmpt, /* i : counter of consecutive bad frames */
+ Word16 mem_MA[], /* i/o: quantizer memory for MA model */
+ Word16 mem_AR[], /* i/o: quantizer memory for AR model */
+ Word16 *stab_fac, /* i : LSF stability factor */
+ Word16 *lsf_adaptive_mean,/* i : LSF adaptive mean, updated when BFI==0 */
+ Word16 numlpc, /* i : Number of division per superframe */
+ Word16 lsf_cng[],
+ Word8 plcBackgroundNoiseUpdated,
+ Word16 *lsf_q_cng, /* o : quantized LSFs */
+ Word16 *old_lsf_q_cng, /* o : old quantized LSFs for background noise */
+ const Word16* lsfBase, /* i : base for differential LSF coding */
+ Word8 tcxonly
+)
+{
+
+ lsf_dec_bfi(
+ MODE2,
+ &lsf_q[0], lsfold, lsf_adaptive_mean, lsfBase, mem_MA, mem_AR, *stab_fac,
+ 0, L_frame, last_good, nbLostCmpt,
+ plcBackgroundNoiseUpdated, lsf_q_cng, lsf_cng, old_lsf_q_cng, 0, 0, tcxonly
+ ,0
+
+ );
+ IF ( EQ_16(numlpc,2))
+ {
+ /* Decode the second LPC */
+ lsf_dec_bfi(
+ MODE2,
+ &lsf_q[M], &lsf_q[0], lsf_adaptive_mean, lsfBase, mem_MA, mem_AR, *stab_fac,
+ 0, L_frame, last_good, nbLostCmpt+1,
+ plcBackgroundNoiseUpdated, lsf_q_cng, lsf_cng, old_lsf_q_cng, 0, 0, tcxonly
+ ,0
+ );
+ }
+ /**/ /*No local variabvles defined*/
+}
+
diff --git a/lib_com/edct_fx.c b/lib_com/edct_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..f45a54fa36dff4b351bc343a59ebb81a9f0637d4
--- /dev/null
+++ b/lib_com/edct_fx.c
@@ -0,0 +1,424 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+
+
+#include "math_32.h"
+
+static Word16 const * get_edct_table(Word16 length, Word16 *q)
+{
+ Word16 const * edct_table = NULL;
+ SWITCH (length)
+ {
+ case 1200:
+ edct_table = edct_table_600_fx;
+ move16();
+ *q = add(*q, 2);
+ BREAK;
+ case 960 :
+ edct_table = edct_table_480_fx;
+ move16();
+ BREAK;
+ case 640 :
+ edct_table = edct_table_320_fx;
+ move16();
+ BREAK;
+ case 320 :
+ edct_table = edct_table_160_fx;
+ move16();
+ BREAK;
+ case 256 :
+ edct_table = edct_table_128_fx;
+ move16();
+ BREAK;
+ case 240 :
+ edct_table = edct_table_120_fx;
+ move16();
+ BREAK;
+ case 200 :
+ edct_table = edct_table_100_fx;
+ move16();
+ BREAK;
+ case 160 :
+ edct_table = edct_table_80_fx ;
+ move16();
+ BREAK;
+ case 40 :
+ edct_table = edct_table_20_fx ;
+ move16();
+ BREAK;
+ case 800 :
+ edct_table = edct_table_400_fx;
+ move16();
+ *q = add(*q, 2);
+ BREAK;
+ case 512 :
+ edct_table = edct_table_256_fx;
+ move16();
+ BREAK;
+ case 480 :
+ edct_table = edct_table_240_fx;
+ move16();
+ BREAK;
+ case 400 :
+ edct_table = edct_table_200_fx;
+ move16();
+ BREAK;
+ case 128 :
+ edct_table = edct_table_64_fx ;
+ move16();
+ BREAK;
+ case 80 :
+ edct_table = edct_table_40_fx ;
+ move16();
+ BREAK;
+ default:
+ BREAK;
+ }
+ return edct_table;
+}
+
+/*-------------------------------------------------------------------------*
+ * FUNCTION : edct_fx()
+ *
+ * PURPOSE : DCT transform
+ *
+ * INPUT ARGUMENTS :
+ * _ (Word16) length : length
+ * _ (Word16*) x : input signal Qx
+ * _ (Word16*) edct_table_128_fx : edct table Q16
+ *
+ * OUTPUT ARGUMENTS :
+ * _ (Word16[]) y : output transform Qx
+ *-------------------------------------------------------------------------*/
+void edct_fx(
+ const Word32 *x, /* i : input signal Qq */
+ Word32 *y, /* o : output transform Qq */
+ Word16 length, /* i : length */
+ Word16 *q /* i : Q value of input signal */
+)
+{
+ Word16 i;
+ Word32 re;
+ Word32 im;
+ const Word16 *edct_table = 0; /*Q16 */
+ Word32 complex_buf[2*(L_FRAME48k/2+240)];
+ Word32 L_tmp;
+ Word16 tmp;
+ Word16 len1;
+
+ edct_table = get_edct_table(length, q);
+ len1 = shr(length, 1);
+ /* Twiddling and Pre-rotate */
+ FOR (i = 0; i < len1; i++)
+ {
+ L_tmp = Mult_32_16(x[2*i], edct_table[i]); /*Q(q+1) */
+ complex_buf[2*i] = Madd_32_16(L_tmp, x[length-1-2*i], edct_table[len1-1-i]); /*Q(q+1) */ move32();
+
+ L_tmp = Mult_32_16(x[length-1-2*i], edct_table[i]); /*Q(q+1) */
+
+ complex_buf[2*i+1] = Msub_32_16(L_tmp, x[2*i], edct_table[len1-1-i]); /*Q(q+1) */ move32();
+ }
+
+ *q = sub(15, *q);
+ BASOP_cfft((cmplx *)complex_buf, len1, q, y);
+
+ tmp = div_s(1, length); /*Q15 */
+ tmp = round_fx(L_shl(L_mult(tmp, 19302), 2)); /*Q15 */
+ FOR (i = 0; i < len1; i++)
+ {
+ re = Msub_32_16(complex_buf[2*i], complex_buf[2*i+1], tmp);
+ im = Madd_32_16(complex_buf[2*i+1], complex_buf[2*i], tmp);
+ y[2 * i] = L_add(Mult_32_16(re, edct_table[i]), Mult_32_16(im, edct_table[len1 - 1 - i]));
+ move32();
+ y[length - 1 - 2 * i] = L_sub(Mult_32_16(re, edct_table[len1 - 1 - i]), Mult_32_16(im, edct_table[i]));
+ move32();
+ } /*Q(q-2) */
+
+ *q = sub(15+2, *q);
+ return;
+}
+
+/*-------------------------------------------------------------------------*
+ * FUNCTION : edst_fx()
+ *
+ * PURPOSE : DST_IV transform
+ *
+ * INPUT ARGUMENTS :
+ * _ (Word16) length : length
+ * _ (Word16*) x : input signal Qx
+ * _ (Word16*) edct_table_128_fx : edct table Q16
+ *
+ * OUTPUT ARGUMENTS :
+ * _ (Word16[]) y : output transform Qx
+ *-------------------------------------------------------------------------*/
+void edst_fx(
+ const Word32 *x, /* i : input signal Qq */
+ Word32 *y, /* o : output transform Qq */
+ Word16 length, /* i : length */
+ Word16 *q /* i : Q value of input signal */
+)
+{
+ Word16 i;
+ Word32 re;
+ Word32 im;
+ const Word16 *edct_table = 0; /*Q16 */
+ Word32 complex_buf[2*(L_FRAME48k/2+240)];
+ Word32 L_tmp;
+ Word16 tmp;
+ Word16 len1;
+
+ edct_table = get_edct_table(length, q);
+ len1 = shr(length, 1);
+ /* Twiddling and Pre-rotate */
+ FOR (i = 0; i < len1; i++)
+ {
+ L_tmp = Mult_32_16(x[length-1-2*i], edct_table[i]);
+ complex_buf[2*i] = Madd_32_16(L_tmp, x[2*i], edct_table[len1-1-i]);
+ move32();
+
+ L_tmp = Mult_32_16(x[2*i], edct_table[i]);
+ complex_buf[2*i+1] = Msub_32_16(L_tmp, x[length-1-2*i], edct_table[len1-1-i]);
+ move32();
+ }
+
+ *q = sub(15, *q);
+ BASOP_cfft((cmplx *)complex_buf, len1, q, y);
+
+ tmp = div_s(1, length); /*Q15 */
+ tmp = round_fx(L_shl(L_mult(tmp, 19302), 2)); /*Q15 */
+ FOR (i = 0; i < len1; i++)
+ {
+ re = Msub_32_16(complex_buf[2*i], complex_buf[2*i+1], tmp);
+ im = Madd_32_16(complex_buf[2*i+1], complex_buf[2*i], tmp);
+ y[2 * i] = L_add(Mult_32_16(re, edct_table[i]), Mult_32_16(im, edct_table[len1 - 1 - i]));
+ move32();
+ y[length - 1 - 2 * i] = L_sub(Mult_32_16(im, edct_table[i]), Mult_32_16(re, edct_table[len1 - 1 - i]));
+ move32();
+ } /*Q(q) */
+
+ *q = sub(15+2, *q);
+
+ return;
+}
+
+/*========================================================================*/
+/* FUNCTION : edct_fx() */
+/*------------------------------------------------------------------------*/
+/* PURPOSE : DCT transform */
+/*------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) length : length */
+/* _ (Word16*) x : input signal Qx */
+/* _ (Word16*) edct_table_128_fx : edct table Q15 */
+/*------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/*------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16[]) y : output transform Qx */
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*========================================================================*/
+void edct_16fx(
+ const Word16 *x, /* i : input signal Qx */
+ Word16 *y, /* o : output transform Qx */
+ Word16 length, /* i : length */
+ Word16 bh /* bit-headroom */
+)
+{
+ Word16 i;
+ Word16 re[L_FRAME48k/2];
+ Word16 im[L_FRAME48k/2];
+ const Word16 *edct_table = 0;
+ Word16 re2[L_FRAME48k/2];
+ Word16 im2[L_FRAME48k/2];
+
+ Word32 L_tmp, Lacc, Lmax;
+ Word16 tmp, fact;
+ Word16 Q_edct;
+ Word16 Len2, i2;
+ const Word16 *px, *pt;
+ Word16 *py;
+
+ /*COMPLETE: some eDCT sub function are missing */
+
+ IF (EQ_16(length,L_FRAME32k))
+ {
+ edct_table = &edct_table_320_16fx[0];
+ move16();
+ }
+ ELSE IF (EQ_16(length,L_FRAME))
+ {
+ edct_table = &edct_table_128_16fx[0];
+ move16();
+ }
+ ELSE IF (EQ_16(length,L_FRAME16k))
+ {
+ edct_table = &edct_table_160_16fx[0];
+ move16();
+ }
+ ELSE
+ {
+ }
+
+ /* Twiddling and Pre-rotate */
+ Lmax = L_deposit_l(0);
+ Len2 = shr(length,1);
+ px = x + length - 1;
+ pt = edct_table + Len2 - 1;
+ FOR (i = 0; i < Len2; i++)
+ {
+ i2 = shl(i,1);
+ L_tmp = L_mult(x[i2],edct_table[i]);/*Q(Qx+16) */
+
+ Lacc = L_mac(L_tmp,*px,*pt);/*Q(Qx+16) */
+
+ Lmax = L_max(Lmax, Lacc);
+
+ L_tmp = L_mult(*px,edct_table[i]);/*Q(Qx+16) */
+ Lacc = L_msu(L_tmp,x[i2],*pt);/*Q(Qx+16) */
+ Lmax = L_max(Lmax, Lacc);
+
+ px -= 2;
+ pt--;
+ }
+
+ tmp = 31;
+ if( Lmax != 0 )
+ {
+ tmp = norm_l(Lmax);
+ }
+ Q_edct = sub(tmp,bh); /*creating a bit-headroom */
+
+ px = x + length - 1;
+ pt = edct_table + Len2 - 1;
+ FOR (i = 0; i < Len2; i++)
+ {
+ i2 = shl(i,1);
+
+ L_tmp = L_mult(x[i2],edct_table[i]);/*Q(Qx+16) */
+ Lacc = L_mac(L_tmp,*px,*pt);/*Q(Qx+16) */
+ re2[i] = round_fx(L_shl(Lacc, Q_edct)); /* Q(Qx+Q_edct) */
+
+ L_tmp = L_mult(*px,edct_table[i]);/*Q(Qx+16) */
+ Lacc = L_msu(L_tmp,x[i2],*pt);/*Q(Qx+16) */
+ im2[i] = round_fx(L_shl(Lacc, Q_edct)); /* Q(Qx+Q_edct) */
+
+ px -= 2;
+ pt--;
+ }
+ IF (EQ_16(length,L_FRAME32k))
+ {
+ DoRTFT320_16fx(re2, im2);
+ }
+ ELSE IF (EQ_16(length,L_FRAME ))
+ {
+ DoRTFT128_16fx(re2, im2);
+ }
+ ELSE IF (EQ_16(length,L_FRAME16k))
+ {
+ DoRTFT160_16fx(re2, im2);
+ }
+ ELSE
+ {
+ }
+ tmp = div_s(1,length); /*Q15 */
+ L_tmp = L_mult(tmp,19302); /*Q29, (3*PI/4) in Q13 */
+ fact = round_fx(L_shl(L_tmp,2)); /*Q15 */
+ FOR (i = 0; i < length/2; i++)
+ {
+ tmp = mult_r(im2[i],fact); /*Q(Qx+Q_edct) */
+ re[i] = sub(re2[i],tmp); /*Q(Qx+Q_edct) */ move16();
+
+ tmp = mult_r(re2[i],fact); /*Q(Qx+Q_edct) */
+ im[i] = add(im2[i],tmp); /*Q(Qx+Q_edct) */ move16();
+ }
+
+ /* Post-rotate and obtain the output data */
+ py = y + length - 1;
+ pt = edct_table + Len2 - 1;
+ FOR (i = 0; i < Len2; i++)
+ {
+ i2 = shl(i,1);
+
+ L_tmp = L_mult(re[i],edct_table[i]);/*Q(Qx+Q_edct+16) */
+ Lacc = L_mac(L_tmp,im[i],*pt);/*Q(Qx+Q_edct+16) */
+ y[i2] = round_fx(L_shr(Lacc,Q_edct)); /* Q(Qx) */
+
+ L_tmp = L_mult(re[i],edct_table[length/2-1-i]);/*Q(Qx+Q_edct+16) */
+ Lacc = L_msu(L_tmp,im[i],edct_table[i]);/*Q(Qx+Q_edct+16) */
+ *py = round_fx(L_shr(Lacc,Q_edct)); /* Q(Qx) */
+
+ py -= 2;
+ pt--;
+ }
+ return;
+}
+
+
+/*-----------------------------------------------------------------*
+ * iedct_short_fx()
+ *
+ * Inverse EDCT for short frames
+ *-----------------------------------------------------------------*/
+
+void iedct_short_fx(
+ const Word32 *in, /* i : input vector */
+ Word16 *Q, /* i/o: Q value of input */
+ Word32 *out, /* o : output vector */
+ const Word16 segment_length /* i : length */
+)
+{
+ Word32 alias[MAX_SEGMENT_LENGTH];
+ Word16 seg_len_div2, seg_len_div4, seg_len_3mul_div4;
+ Word16 i;
+ Word16 qtmp, tmp;
+
+ qtmp = *Q;
+ move16();
+ tmp = 0;
+ move16();
+ seg_len_div2 = shr(segment_length, 1);
+ seg_len_div4 = shr(segment_length, 2);
+ seg_len_3mul_div4 = add(seg_len_div2, seg_len_div4);
+
+ edct_fx(in, alias, seg_len_div2, Q);
+ FOR (i = 0; i < seg_len_div2; i++)
+ {
+ IF (alias[i] != 0)
+ {
+ tmp = 1;
+ move16();
+ BREAK;
+ }
+ }
+ if (tmp == 0)
+ {
+ *Q = qtmp;
+ move16();
+ }
+ FOR (i = 0; i < seg_len_div4; i++)
+ {
+ out[i] = alias[seg_len_div4 + i];
+ move32();
+ out[seg_len_div4 + i] = L_negate(alias[seg_len_div2 - 1 - i]);
+ move32();
+ out[seg_len_div2 + i] = L_negate(alias[seg_len_div4 - 1 - i]);
+ move32();
+ out[seg_len_3mul_div4 + i] = L_negate(alias[i]);
+ move32();
+ }
+
+ return;
+}
diff --git a/lib_com/enhancer_fx.c b/lib_com/enhancer_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..81b8097abbcce4af3a8ecde7192d01fbc61f2b30
--- /dev/null
+++ b/lib_com/enhancer_fx.c
@@ -0,0 +1,679 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "stl.h"
+#include "basop_util.h"
+
+/*---------------------------------------------------------------------*
+ * Local constants
+ *---------------------------------------------------------------------*/
+#define pitch_0_9 14746 /* 0.9 in Q14 */
+#define pitch_0_6 9830 /* 0.6 in Q14 */
+#define SIZE 64
+#define SIZE2 32
+#define NUM_STAGES 5
+
+/*---------------------------------------------------------------------*
+ * Local functions
+ *---------------------------------------------------------------------*/
+static void phase_dispersion_fx(Word32 gain_code,Word16 gain_pit,Word16 code[],Word16 mode,struct dispMem_fx *dm_fx);
+static void agc2_fx(const Word16 *sig_in,Word16 *sig_out,const Word16 l_trm);
+
+/*======================================================================================*/
+/* FUNCTION : enhancer_fx() */
+/*--------------------------------------------------------------------------------------*/
+/* PURPOSE : Enhancement of the excitation signal before synthesis */
+/*--------------------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word32) core_brate : decoder bitrate */
+/* _ (Word16) Opt_AMR_WB : flag indicating AMR-WB IO mode */
+/* _ (Word16) coder_type : coder type */
+/* _ (Word16) i_subfr : subframe number */
+/* _ (Word16) voice_fac : subframe voicing estimation (Q15) */
+/* _ (Word16) stab_fac : LP filter stablility measure (Q15) */
+/* _ (Word32) norm_gain_code : normalised innovative cb. gain (Q16) */
+/* _ (Word16) gain_inov : gain of the unscaled innovation (Q12) */
+/* _ (Word16) gain_pit_fx : Pitch gain (Q14) */
+/* _ (Word16) Q_exc : Q of the excitation */
+/* _ (Word16) Enc : Encoder = 1; decoder = 0 */
+/*--------------------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16*) voice_factors_fx : TBE voicing factor (Q15) */
+/*--------------------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ (Word32*) gc_threshold : gain code threshold (Q16) */
+/* _ (Word16*[]) code : innovation (Q12) */
+/* _ (Word16*[]) exc2 : adapt. excitation/total exc (Q0) */
+/* _ (struct dispMem_fx*) dm_fx : phase dispersion algorithm memory */
+/* (a[0]->Q0,a[1]->Q16,a[2-7]->Q14) */
+/*--------------------------------------------------------------------------------------*/
+
+/* _ None */
+/*--------------------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*======================================================================================*/
+void enhancer_fx(
+ const Word32 core_brate, /* i : decoder bitrate */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 i_subfr, /* i : subframe number */
+ const Word16 L_frame, /* i : frame size */
+ const Word16 voice_fac, /* i : subframe voicing estimation Q15 */
+ const Word16 stab_fac, /* i : LP filter stablility measure Q15 */
+ Word32 norm_gain_code, /* i : normalised innovative cb. gain Q16 */
+ const Word16 gain_inov, /* i : gain of the unscaled innovation Q12 */
+ Word32 *gc_threshold,/* i/o: gain code threshold Q16 */
+ Word16 *code, /* i/o: innovation Q12 */
+ Word16 *exc2, /* i/o: adapt. excitation/total exc. Q_exc*/
+ const Word16 gain_pit, /* i : quantized pitch gain Q14 */
+ struct dispMem_fx *dm_fx, /* i/o: phase dispersion algorithm memory */
+ const Word16 Q_exc /* i : Q of the excitation */
+)
+{
+ Word16 tmp, fac, *pt_exc2;
+ Word16 i;
+ Word32 L_tmp;
+ Word16 gain_code_hi;
+ Word16 pit_sharp, tmp16;
+ Word16 excp[L_SUBFR], sc;
+
+ pit_sharp = gain_pit;
+ move16(); /* to remove gcc warning */
+ pt_exc2 = exc2 + i_subfr;
+ move16();
+
+ /*------------------------------------------------------------*
+ * Phase dispersion to enhance noise at low bit rate
+ *------------------------------------------------------------*/
+
+ i = 2;
+ move16(); /* no dispersion */
+ IF (Opt_AMR_WB)
+ {
+ IF ( LE_32(core_brate,ACELP_6k60))
+ {
+ i = 0;
+ move16(); /* high dispersion */
+ }
+ ELSE if ( LE_32(core_brate,ACELP_8k85))
+ {
+ i = 1;
+ move16(); /* low dispersion */
+ }
+ }
+ ELSE IF( NE_16(coder_type,UNVOICED))
+
+ {
+ test();
+ test();
+ test();
+ test();
+ IF ( LE_32(core_brate,ACELP_7k20))
+ {
+ i = 0;
+ move16(); /* high dispersion */
+ }
+ ELSE if ( ( EQ_16(coder_type,GENERIC)||EQ_16(coder_type,TRANSITION)||EQ_16(coder_type,AUDIO)||EQ_16(coder_type,INACTIVE))&&LE_32(core_brate,ACELP_9k60))
+ {
+ i = 1;
+ move16(); /* low dispersion */
+ }
+ }
+ phase_dispersion_fx(norm_gain_code, gain_pit, code, i, dm_fx);
+
+ /*------------------------------------------------------------
+ * noise enhancer
+ *
+ * - Enhance excitation on noise. (modify gain of code)
+ * If signal is noisy and LPC filter is stable, move gain
+ * of code 1.5 dB toward gain of code threshold.
+ * This decreases by 3 dB noise energy variation.
+ *-----------------------------------------------------------*/
+
+ /* tmp = 0.5f * (1.0f - voice_fac) */
+ tmp = msu_r(0x40000000, voice_fac, 16384); /*Q15 */ /* 1=unvoiced, 0=voiced */
+ /* fac = stab_fac * tmp */
+ fac = mult(stab_fac, tmp); /*Q15*/
+
+ IF (LT_32(norm_gain_code, *gc_threshold))
+ {
+ L_tmp = Madd_32_16(norm_gain_code, norm_gain_code, 6226);/*Q16 */
+ L_tmp = L_min(L_tmp, *gc_threshold);/*Q16 */
+ }
+ ELSE
+ {
+ L_tmp = Mult_32_16(norm_gain_code, 27536);/*Q16 */
+ L_tmp = L_max(L_tmp, *gc_threshold); /*Q16 */
+ }
+ *gc_threshold = L_tmp;
+ move32(); /*Q16 */
+
+ /* gain_code = (fac * tmp) + (1.0 - fac) * gain_code ==> fac * (tmp - gain_code) + gain_code */
+ L_tmp = L_sub(L_tmp, norm_gain_code); /*Q16 */
+ norm_gain_code = Madd_32_16(norm_gain_code, L_tmp, fac);/*Q16 */
+
+ /* gain_code *= gain_inov - Inverse the normalization */
+ L_tmp = Mult_32_16(norm_gain_code, gain_inov); /*Q13*/ /* gain_inov in Q12 */
+
+ sc = 6;
+ move16();
+
+ gain_code_hi = round_fx(L_shl(L_tmp, add(Q_exc, 3))); /* in Q_exc */
+
+ /*------------------------------------------------------------*
+ * pitch enhancer
+ *
+ * - Enhance excitation on voiced. (HP filtering of code)
+ * On voiced signal, filtering of code by a smooth fir HP
+ * filter to decrease energy of code at low frequency.
+ *------------------------------------------------------------*/
+ test();
+ IF( !Opt_AMR_WB && EQ_16(coder_type,UNVOICED))
+ {
+ /* Copy(code, exc2, L_SUBFR) */
+ FOR (i = 0; i < L_SUBFR; i++)
+ {
+ pt_exc2[i] = round_fx(L_shl(L_mult(gain_code_hi, code[i]), sc)); /*Q0 */ /* code in Q12 (Q9 for encoder) */
+ }
+ }
+ ELSE
+ {
+ test();
+ test();
+ IF ( Opt_AMR_WB && ( EQ_32(core_brate,ACELP_8k85)||EQ_32(core_brate,ACELP_6k60)))
+ {
+ pit_sharp = shl(gain_pit, 1); /* saturation can occur here Q14 -> Q15 */
+
+ /* saturation takes care of "if (pit_sharp > 1.0) { pit_sharp=1.0; }" */
+ IF (GT_16(pit_sharp, 16384))
+ {
+ tmp16 = mult(pit_sharp, 8192);
+ FOR (i = 0; i < L_SUBFR; i++)
+ {
+ /* excp[i] = pt_exc2[i] * pit_sharp * 0.25 */
+ excp[i] = mult_r(pt_exc2[i], tmp16);
+ move16();
+ }
+ }
+ }
+
+ IF ( EQ_16(L_frame, L_FRAME16k))
+ {
+ /* tmp = 0.150 * (1.0 + voice_fac) */
+ /* 0.30=voiced, 0=unvoiced */
+ tmp = mac_r(0x10000000L, voice_fac, 4915);/*Q15 */
+ }
+ ELSE
+ {
+ /* tmp = 0.125 * (1.0 + voice_fac) */
+ /* 0.25=voiced, 0=unvoiced */
+ tmp = mac_r(0x10000000L, voice_fac, 4096);/*Q15 */
+ }
+
+ /*-----------------------------------------------------------------
+ * Do a simple noncasual "sharpening": effectively an FIR
+ * filter with coefs [-tmp 1.0 -tmp] where tmp=0...0.25.
+ * This is applied to code and add_fxed to exc2
+ *-----------------------------------------------------------------*/
+ /* pt_exc2[0] += code[0] - tmp * code[1] */
+ L_tmp = L_deposit_h(code[0]); /* if Enc :Q9 * Q15 -> Q25 */
+ L_tmp = L_msu(L_tmp, code[1], tmp); /* Q12 * Q15 -> Q28 */
+ L_tmp = L_shl(L_mult(gain_code_hi, extract_h(L_tmp)), sc);
+ pt_exc2[0] = msu_r(L_tmp, -32768, pt_exc2[0]);
+ move16();/* in Q_exc */
+
+ FOR (i = 1; i < L_SUBFR-1; i++)
+ {
+ /* pt_exc2[i] += code[i] - tmp * code[i-1] - tmp * code[i+1] */
+ L_tmp = L_msu(-32768, code[i], -32768);
+ L_tmp = L_msu(L_tmp, code[i + 1], tmp);
+ tmp16 = msu_r(L_tmp, code[i - 1], tmp);
+ L_tmp = L_shl(L_mult(gain_code_hi, tmp16), sc);
+ pt_exc2[i] = msu_r(L_tmp, -32768, pt_exc2[i]);
+ move16(); /* in Q_exc */
+ }
+
+ /* pt_exc2[L_SUBFR-1] += code[L_SUBFR-1] - tmp * code[L_SUBFR-2] */
+ L_tmp = L_deposit_h(code[L_SUBFR - 1]);/*Q28 */
+ L_tmp = L_msu(L_tmp, code[L_SUBFR - 2], tmp);/*Q28 */
+ L_tmp = L_shl(L_mult(gain_code_hi, extract_h(L_tmp)), sc);
+ pt_exc2[L_SUBFR - 1] = msu_r(L_tmp, -32768, pt_exc2[L_SUBFR - 1]);
+ move16();/* in Q_exc */
+ test();
+ test();
+ IF ( Opt_AMR_WB && ( EQ_32(core_brate,ACELP_8k85)||EQ_32(core_brate,ACELP_6k60)))
+ {
+ IF (GT_16(pit_sharp, 16384))
+ {
+ FOR (i = 0; i < L_SUBFR; i++)
+ {
+ /* excp[i] += pt_exc2[i] */
+ excp[i] = add(excp[i], pt_exc2[i]);
+ move16();
+ }
+ agc2_fx(pt_exc2, excp, L_SUBFR);
+ Copy(excp, pt_exc2, L_SUBFR);
+ }
+ }
+ }
+}
+
+/*---------------------------------------------------------*
+ * Enhancement of the excitation signal before synthesis
+ *---------------------------------------------------------*/
+
+Word16 E_UTIL_enhancer(
+ Word16 voice_fac, /* i : subframe voicing estimation Q15 */
+ Word16 stab_fac, /* i : LP filter stability measure Q15 */
+ Word32 gain_code, /* i : innovative cb. gain 15Q16 */
+ Word16 gain_inov, /* i : gain of the unscaled innovation Q11 */
+ Word32 *gc_threshold, /* i/o: gain code threshold 15Q16 */
+ Word16 *code, /* i/o: innovation(in: Q9) code_exp */
+ Word16 *exc2, /* i/o: adapt. excitation/total exc. */
+ Word16 gain_pit, /* i : Quantized pitch gain 1Q14 */
+ Word32 *prev_gain_code, /* i/o: previous codebook gain 15Q16 */
+ Word16 prev_gain_pit[], /* i/o: previous pitch gain, size=6 1Q14 */
+ Word16 *prev_state, /* i/o: Phase dispersion algorithm memory Q0 */
+ Word16 coder_type, /* i : coder type */
+ Word16 cdk_index, /* i : */
+ Word16 L_subfr, /* i : length of subframe */
+ Word16 L_frame, /* i : frame size */
+ Word16 Q_new
+)
+{
+ Word16 disp_mode, i;
+ Word16 tmp, fac, gain;
+ Word32 L_tmp;
+ Word16 code_exp, exc2_exp;
+ Word16 max_cdk_index_uv;
+
+ move16();
+ code_exp = 15-9;
+ exc2_exp = 15-Q_new;
+ gain_inov = shr(gain_inov,1);
+ /*-----------------------------------------------------------------*
+ * Phase dispersion to enhance noise at low bit rates
+ *-----------------------------------------------------------------*/
+
+ max_cdk_index_uv = 10;
+ move16();
+ if ( EQ_16(L_frame, L_FRAME16k))
+ {
+ max_cdk_index_uv = 14;
+ move16();
+ }
+ disp_mode = 2; /* any=off */ move16();
+ test();
+ test();
+ test();
+ test();
+ IF ( ( (NE_16(coder_type, VOICED))&&(LE_16(cdk_index,2)))||((EQ_16(coder_type,UNVOICED))&&(LE_16(cdk_index,max_cdk_index_uv))))
+ {
+ disp_mode = 0; /* high */ move16();
+ }
+ ELSE IF ( (NE_16(coder_type, VOICED))&&(LE_16(cdk_index,7)))
+ {
+ disp_mode = 1; /* low */ move16();
+ }
+
+ phase_dispersion(gain_code, gain_pit,code, &code_exp, disp_mode, prev_gain_code, prev_gain_pit, prev_state, L_subfr);
+
+ /*------------------------------------------------------------*
+ * noise enhancer *
+ * ~~~~~~~~~~~~~~ *
+ * - Enhance excitation on noise. (modify gain of code) *
+ * If signal is noisy and LPC filter is stable, move gain *
+ * of code 1.5 dB toward gain of code threshold. *
+ * This decrease by 3 dB noise energy variation. *
+ *------------------------------------------------------------*/
+ fac = 0;
+ move16();
+
+ /* if gain_code is computed function of energy, noise enhancer is by-passed.*/
+ BASOP_SATURATE_WARNING_OFF
+ tmp = msu_r(1073741824l/*0.5f Q31*/, 16384/*0.5f Q15*/, voice_fac); /* 1=unvoiced, 0=voiced */
+ BASOP_SATURATE_WARNING_ON
+ fac = mult_r(stab_fac, tmp); /* fac in Q15 */
+
+ L_tmp = gain_code; /* L_tmp in 15Q16 */
+ move32();
+
+ IF (LT_32(L_tmp,*gc_threshold))
+ {
+ L_tmp = L_shl(Mpy_32_32(L_tmp, 1277752832l/*1.19f/2.0f Q31*/),1);
+ L_tmp = L_min(L_tmp, *gc_threshold);
+ }
+ ELSE
+ {
+ L_tmp = Mpy_32_32(L_tmp, 1804608000l/*1.0f/1.19f Q31*/);
+ L_tmp = L_max(L_tmp, *gc_threshold);
+ }
+ move32();
+ *gc_threshold = L_tmp; /* in 15Q16 */
+
+ /* gain = ( (fac * L_tmp) + (gain_code - fac*gain_code) ) * gain_inov */
+ /* exponent of L_tmp: 31-16 + 15-11 */
+ L_tmp = Mpy_32_16_1(L_add(Mpy_32_16_1(L_tmp, fac), L_sub(gain_code, Mpy_32_16_1(gain_code, fac))), gain_inov);
+
+ /* exponent gain: 31-16 + 15-11 - tmp */
+ tmp = norm_l(L_tmp);
+
+ /* exponent of code: 31-16 + 15-11 - tmp + code_exp */
+ move16();
+ code_exp = sub(add(31-16 + 15-11, code_exp), tmp);
+
+ L_tmp = L_shl(L_tmp, tmp);
+ gain = round_fx(L_tmp);
+
+ FOR (i=0; iQ0,a[1]->Q16,a[2-7]->Q14) */
+/*--------------------------------------------------------------------------------------*/
+
+/* _ None */
+/*--------------------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*======================================================================================*/
+static void phase_dispersion_fx(
+ Word32 gain_code, /* i : gain of code Q16 */
+ Word16 gain_pit, /* i : gain of pitch Q14 */
+ Word16 code[], /* i/o: code vector */
+ Word16 mode, /* i : level, 0=hi, 1=lo, 2=off */
+ struct dispMem_fx *dm_fx /* i/o: static memory (size = 8) */
+)
+{
+ Word16 i, j, state;
+ Word16 *prev_gain_pit, *prev_state;
+ Word32 *prev_gain_code;
+ Word16 *code2_real, *code2_imag;
+ Word16 *code_real, *code_imag;
+ const Word16 *h_real, *h_imag;
+
+ Word16 code2[2 * L_SUBFR];
+
+ prev_state = &(dm_fx->prev_state);
+ prev_gain_code = &(dm_fx->prev_gain_code);
+ prev_gain_pit = dm_fx->prev_gain_pit;
+
+ state = 2;
+ move16();
+ if (LT_16(gain_pit, pitch_0_9))
+ {
+ state = 1;
+ move16();
+ }
+
+ if (LT_16(gain_pit, pitch_0_6))
+ {
+ state = 0;
+ move16();
+ }
+
+ FOR (i = 5; i > 0; i--)
+ {
+ prev_gain_pit[i] = prev_gain_pit[i - 1];
+ move16();
+ }
+ prev_gain_pit[0] = gain_pit;
+ move16();
+
+ IF (GT_32(L_sub(gain_code, *prev_gain_code), L_shl(*prev_gain_code, 1)))
+ {
+ state = s_min(add(state, 1), 2);
+ }
+ ELSE
+ {
+ j = 0;
+ move16();
+
+ FOR (i = 0; i < 6; i++)
+ {
+ j = sub(j, shr(sub(prev_gain_pit[i], pitch_0_6), 15));
+ }
+
+ if (GT_16(j, 2))
+ {
+ state = 0;
+ move16();
+ }
+
+ if (GT_16(sub(state, *prev_state), 1))
+ {
+ state = sub(state, 1);
+ }
+ }
+
+ *prev_gain_code = gain_code;
+ move32();
+ *prev_state = state;
+ move16();
+
+ /*-----------------------------------------------------------------*
+ * circular convolution
+ *-----------------------------------------------------------------*/
+
+ state = add(state, mode); /* level of dispersion */
+
+ IF (LT_16(state, 2))
+ {
+ r_fft_fx_lc(phs_tbl_dec, SIZE, SIZE2, NUM_STAGES, code, code2, 1);
+
+ h_real = Mid_H_phasedisp;
+ move16();
+ if (state == 0)
+ {
+ h_real = Low_H_phasedisp;
+ move16();
+ }
+
+ /* FFT Coefs are in code2 */
+ code2_real = code2;
+ move16();
+ code2_imag = code2 + L_SUBFR - 1;
+ move16();
+
+ code_real = code;
+ move16();
+ code_imag = code + L_SUBFR - 1;
+ move16();
+
+ h_imag = h_real + L_SUBFR - 1;
+ move16();
+
+ *code_real++ = mult(*code2_real++, *h_real++);
+ move16(); /* DC */
+
+ FOR (i=1; i 0 && pulses[i-1] != 0 && pulses[i+1] != 0 )
+ {
+ adj[i] = 11796; /* Q15, 0.36f */ move16();
+ }
+ ELSE IF ( i > 0 && ( pulses[i-1] == 0 || pulses[i+1] == 0) )
+ {
+ adj[i] = 17695; /* Q15, 0.54f */ move16();
+ }
+ ELSE
+ {
+ adj[i] = 23593; /* Q15, 0.72f */ move16();
+ }
+ }
+ ELSE IF ( LT_16(i,last_sfm))
+ {
+ test();
+ IF ( pulses[i-1] != 0 && pulses[i+1] != 0 )
+ {
+ adj[i] = 17695; /* Q15, 0.54f */ move16();
+ }
+ ELSE
+ {
+ adj[i] = 23593; /* Q15, 0.72f */ move16();
+ }
+ }
+ ELSE
+ {
+ adj[i] = 23593; /* Q15, 0.72f */ move16();
+ }
+
+ if( att_state == 0 )
+ {
+ start = i;
+ move16();
+ }
+
+ len = add(len,1);
+ move16();
+ att_state = 1;
+ move16();
+ }
+ ELSE
+ {
+ adj[i] = MAX_16; /* Q15, 1.0f (saturated) */
+ IF( EQ_16(att_state, 1)) /* End of attenuation region found */
+ {
+ /* tmp = min(1, max(0, len-ENV_ADJ_START)*(1.0f/ENV_ADJ_INCL)); */
+ tmp = round_fx(L_shl(L_mult0(s_max( 0, sub(len, ENV_ADJ_START_FX)), ENV_ADJ_INV_INCL_FX),16)); /* Q15 (15+16-16) */
+ tmp_diff = sub(MAX_16, tmp); /* Q15 */ move16();
+ FOR( j = start; j < i ; j++ )
+ {
+ /* adj[j] = max(tmp + (1-tmp)*adj[j],env_stab); */
+ adj[j] = s_max(add(tmp, mult(tmp_diff, adj[j])), env_stab); /* Q15 (15+15-15) */ move16();
+ }
+ len = 0;
+ move16();
+ att_state = 0;
+ move16();
+ }
+ }
+ }
+ /* length == L_FRAME16k */
+ ELSE
+ {
+
+ /* Calculate low accuracy band attenuation */
+ gain_adj = 32767; /* Q15, 1.0f (saturated) */ move16();
+
+ test();
+ IF( npul > 0 && LT_16(npul, MAX_P_ATT))
+ {
+ /*idx = (short)(npul * att_step[group] + 0.5f) - 1; */
+ idx = sub(mult_r(shl(npul,2),att_step_fx[group]), 1); /* Q0 (2+13+1-16) */
+ if( LT_16(idx, MAX_P_ATT))
+ {
+ gain_adj = gain_att_fx[idx]; /* Q15 */ move16();
+ }
+ }
+ adj[i] = gain_adj;
+ move16();
+ }
+ }
+
+ /* Check if the sequence ended with an attenuation region */
+ IF( EQ_16(att_state, 1))
+ {
+ /* tmp = min(1, max(0, len-ENV_ADJ_START)*(1.0f/ENV_ADJ_INCL)); */
+ tmp = round_fx(L_shl(L_mult0(s_max( 0, sub(len, ENV_ADJ_START_FX)), ENV_ADJ_INV_INCL_FX),16)); /* Q15 (15+16-16) */
+ tmp_diff = sub(MAX_16, tmp); /* Q15 */ move16();
+ FOR( j = start; j < i ; j++ )
+ {
+
+ /* adj[j] = max(tmp + (1-tmp)*adj[j],env_stab); */
+ adj[j] = s_max(add(tmp, mult(tmp_diff, adj[j])), env_stab); /* Q15 (15+15-15) */ move16();
+ }
+ }
+
+ return;
+}
diff --git a/lib_com/env_stab_fx.c b/lib_com/env_stab_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..e3e8c63297f0c51402ac555e456a91360aa4df45
--- /dev/null
+++ b/lib_com/env_stab_fx.c
@@ -0,0 +1,188 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "stl.h" /* required by wmc_tool */
+
+/*--------------------------------------------------------------------------*
+ * Local constants
+ *--------------------------------------------------------------------------*/
+#define ENV_STAB_SMO_HO 10 /* number of hangover frames when switching from music to speech state */
+
+/*--------------------------------------------------------------------------*/
+/* Function env_stability_fx */
+/* ~~~~~~~~~~~~~~~~~~~~~ */
+/* */
+/* Envelope stability measure */
+/*--------------------------------------------------------------------------*/
+
+Word16 env_stability_fx( /* in Q15 */
+ const Word16 *ynrm, /*i: Norm vector for current frame */
+ const Word16 nb_sfm, /*i: Number of sub-bands */
+ Word16 *mem_norm, /*i/o: Norm vector memory from past frame */
+ Word16 *mem_env_delta /*i/o: Envelope stability memory for smoothing in Q12 */
+)
+{
+ Word16 env_delta;
+ Word16 env_stab;
+ Word16 tmp, tmp_stab;
+ Word16 i;
+
+ Word16 exp, exp2;
+ Word32 L_tmp, L_env_delta;
+ Word16 inv_nb_sfm;
+
+ /* Calculate envelope stability parameter */
+ L_env_delta = L_deposit_l(0);
+ FOR (i = 0; i < nb_sfm; i++)
+ {
+ tmp = sub(mem_norm[i],ynrm[i]);
+ L_env_delta = L_mac0(L_env_delta, tmp, tmp);
+ mem_norm[i] = ynrm[i];
+ move16();
+ }
+
+ inv_nb_sfm = 19418; /* Q19 */ move16();
+ if (nb_sfm == 26)
+ {
+ inv_nb_sfm = 20165; /* Q19 */ move16();
+ }
+ exp = norm_l(L_env_delta);
+ L_env_delta = Mult_32_16(L_shl(L_env_delta, exp), inv_nb_sfm); /* 0+exp+19-15 */
+
+ L_tmp = Sqrt_l(L_env_delta, &exp2); /* exp+4+31+exp2 */
+
+ exp = add(35, add(exp, exp2));
+ if ( EQ_16(s_and(exp, 1), 1))
+ {
+ L_tmp = Mult_32_16(L_tmp, 23170); /* 1/sqrt(2) in Q15 */
+ }
+ exp = shr(exp, 1);
+
+ env_delta = round_fx(L_shl(L_tmp, sub(26, exp))); /* Q10 */
+
+ L_tmp = L_mult0(26214, env_delta); /* 26214 is 0.1 in Q18. Q28 */
+ L_tmp = L_mac(L_tmp, 29491, *mem_env_delta); /* 29491 is 0.9 in Q15. Q28 */
+
+ *mem_env_delta = round_fx(L_tmp); /* Q12 */
+ Overflow = 0;
+ move16();
+ env_delta = round_fx(L_shl(L_tmp, 1)); /* Q13 */
+
+ IF (Overflow != 0) /* Saturated due to the above up-shifting operation. */
+ {
+ return stab_trans_fx[L_STAB_TBL-1]; /* The highest quantized index. */
+ }
+
+ /* If tmp_stab > (D_STAB_TBL*L_STAB_TBL + M_STAB_TBL), i.e., 0.103138*10+2.51757=3.603137,
+ * the quantized index is equal to 9. Hence, we only need to worry about any tmpStab < 4.
+ * In this case, Q13 is good enough.
+ */
+ tmp_stab = sub(env_delta, M_STAB_TBL_FX); /* in Q13 */
+ tmp_stab = abs_s(tmp_stab);
+
+ /* Table lookup for smooth transitions
+ * First, find the quantization level, i, of tmpStab. */
+#if L_STAB_TBL > 10
+#error env_stability_fx: Use more efficient usquant()
+#endif
+ tmp_stab = sub(tmp_stab, HALF_D_STAB_TBL_FX); /* in Q13 */
+ FOR (i = 0; i < L_STAB_TBL-1; i++)
+ {
+ IF (tmp_stab < 0)
+ {
+ BREAK;
+ }
+ ELSE
+ {
+ tmp_stab = sub(tmp_stab, D_STAB_TBL_FX); /* in Q13 */
+ }
+ }
+
+ env_stab = stab_trans_fx[i];
+ move16();
+ if(LT_16(env_delta, M_STAB_TBL_FX))
+ {
+ env_stab = sub(0x7FFF,stab_trans_fx[i]);
+ }
+
+ return env_stab;
+}
+
+/*--------------------------------------------------------------------------*
+ * env_stab_smo_fx()
+ *
+ *
+ *--------------------------------------------------------------------------*/
+Word16 env_stab_smo_fx( /* Q0 */
+ Word16 env_stab, /*i : env_stab value Q15 */
+ Word16 *env_stab_state_p, /*i/o: env_stab state probabilities Q15 */
+ Word16 *ho_cnt /*i/o: hangover counter for speech state */
+)
+{
+ Word16 state, prev_state;
+ Word16 maxval, pp[NUM_ENV_STAB_PLC_STATES], pa[NUM_ENV_STAB_PLC_STATES];
+ Word16 i;
+ Word16 tmp, sum, exp;
+
+ /* get previous state */
+ prev_state = maximum_fx(env_stab_state_p, NUM_ENV_STAB_PLC_STATES, &maxval);
+
+ /* assume two states: speech(0), music(1) */
+ /* set a posteriori likelihoods for the two states according to env_stab */
+ /* re-scale. Unclear if needed */
+ /* env_stab = (env_stab - stab_trans_fx[L_STAB_TBL-1])/(1-2*stab_trans_fx[L_STAB_TBL-1]); */
+ tmp = sub(env_stab, stab_trans_fx[L_STAB_TBL-1]);
+ tmp = round_fx(L_shl(L_mult(tmp, INV_STAB_TRANS_FX), 1)); /* Q15 */
+
+ pp[0] = sub(32767, tmp);
+ move16(); /* 1 in Q15 */
+ pp[1] = tmp;
+ move16();
+
+ /* calculate a priori likelihoods */
+ pa[0] = round_fx(Dot_product(env_stab_tp_fx[0], env_stab_state_p, NUM_ENV_STAB_PLC_STATES)); /* Q15*/
+ pa[1] = round_fx(Dot_product(env_stab_tp_fx[1], env_stab_state_p, NUM_ENV_STAB_PLC_STATES));
+
+ /* multiply elementwise with a posteriori likelihoods */
+ sum = 0;
+ move16();
+ FOR (i = 0; i < NUM_ENV_STAB_PLC_STATES; i++)
+ {
+ env_stab_state_p[i] = mult_r(pa[i], pp[i]);
+ move16(); /* Q15 */
+ sum = add(sum, env_stab_state_p[i]);
+ }
+
+ /* renormalize state probabilities */
+ exp = norm_s(sum);
+ tmp = div_s(16384, shl(sum, exp)); /* Q(14-exp) */
+ /*tmp = shl(tmp, add(exp, 1));*/ /* Q15 */
+ FOR (i = 0; i < NUM_ENV_STAB_PLC_STATES; i++)
+ {
+ env_stab_state_p[i] = round_fx(L_shl(L_mult(env_stab_state_p[i], tmp), add(exp, 1))); /* Q15 */
+ }
+
+ /* find maximum index as return value */
+ state = maximum_fx(env_stab_state_p, NUM_ENV_STAB_PLC_STATES, &maxval);
+
+ /* apply some hangover for speech */
+ test();
+ if (state == 0 && EQ_16(prev_state, 1))
+ {
+ *ho_cnt = ENV_STAB_SMO_HO;
+ move16();
+ }
+
+ IF (*ho_cnt > 0)
+ {
+ *ho_cnt = sub(*ho_cnt, 1);
+ move16();
+ }
+
+ return state;
+}
diff --git a/lib_com/env_stab_trans_fx.c b/lib_com/env_stab_trans_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..6e86bca565b2981cb1b1d0eeedba19517d571c28
--- /dev/null
+++ b/lib_com/env_stab_trans_fx.c
@@ -0,0 +1,161 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "math_op.h" /* WMOPS macros */
+#include "stl.h" /* required by wmc_tool */
+
+/*--------------------------------------------------------------------------*
+ * env_stab_transient_detect()
+ *
+ * Transient detector for envelope stability measure
+ *--------------------------------------------------------------------------*/
+
+void env_stab_transient_detect_fx(
+ const Word16 is_transient, /* i: Transient flag */
+ const Word16 length, /* i : Length of spectrum (32 or 48 kHz) */
+ const Word16 norm[], /* i : quantization indices for norms */
+ Word16 *no_att_hangover, /* i/o: Frame counter for attenuation hangover (Q0) */
+ Word32 *L_energy_lt, /* i/o: Long-term energy measure for transient detection (Q13) */
+ const Word16 HQ_mode, /* i : HQ coding mode */
+ const Word16 bin_th, /* i : HVQ cross-over frequency bin */
+ const Word32 *L_coeff, /* i : Coded spectral coefficients */
+ const Word16 Qcoeff /* i : Q of coded spectral coefficients */
+)
+{
+ Word16 i, blk, norm_ind, sqrt_exp, bin_th_1, temp, sh;
+ Word32 L_e_frame, L_temp, L_d_max;
+ Word32 L_energy_lt_local;
+ Word32 L_E_sub[4];
+ Word32 L_delta_e_sub;
+
+ L_energy_lt_local = *L_energy_lt;
+ move32();
+
+ L_d_max = L_deposit_l(0);
+ L_e_frame = L_deposit_l(0);
+ temp = 32;
+ move16();
+
+ IF( EQ_16(HQ_mode,HQ_HVQ))
+ {
+ FOR (i = 0; i < bin_th; i++) /* find adaptive shift */
+ {
+ temp = s_min(temp,norm_l(L_coeff[i]));
+ }
+ sh = sub(temp,2); /* scale such that 2 msbs are not used, the resulting adaptive Qcoeff will be: Qcoeff+sh-16 */
+ FOR (i = 0; i < bin_th; i++) /* Maximum number of loop runs 320 */
+ {
+ temp = extract_h(L_shl(L_coeff[i],sh));
+ L_e_frame = L_mac(L_e_frame,temp,temp); /* Q(2*(Qcoeff+sh-16)+1)=Q(2*(Qcoeff+sh)-31 */
+ }
+
+ bin_th_1 = INV_HVQ_THRES_BIN_24k;
+ move16();
+ if (EQ_16(bin_th, HVQ_THRES_BIN_32k))
+ {
+ bin_th_1 = INV_HVQ_THRES_BIN_32k;
+ move16();
+ }
+ L_temp = Mult_32_16(L_e_frame,bin_th_1); /* Q(2*(Qcoeff-16+sh)+1+21-15) -> Q(2*(Qcoeff+sh)-25) */
+ L_e_frame = Sqrt_l(L_temp,&sqrt_exp);
+ L_e_frame = L_shr(L_e_frame, add(sub(add(sh,Qcoeff),10),shr(sqrt_exp,1))); /* Adjust by (Qcoeff+sh-10) to fixed Q13: Qcoeff+sh+(-25+31)/2 - (Qcoeff+sh-10) -> Q13 */
+
+ IF ( GT_32(L_e_frame, ENERGY_TH_FX))
+ {
+ L_energy_lt_local = Mult_32_16(*L_energy_lt, ENERGY_LT_BETA_FX);
+ L_temp = Mult_32_16(L_e_frame, ENERGY_LT_BETA_1_FX);
+ *L_energy_lt = L_add(L_energy_lt_local,L_temp);
+ move32();
+ }
+
+ IF (*no_att_hangover > 0)
+ {
+ (*no_att_hangover) = sub((*no_att_hangover), 1);
+ move16();
+ }
+ }
+ ELSE
+ {
+ L_e_frame = L_deposit_l(0);
+
+ test();
+ IF (is_transient && EQ_16(length,L_FRAME32k))
+ {
+ /* Measure subframe energies */
+ FOR (blk = 0; blk < NUM_SUBFRAMES; blk++)
+ {
+ L_E_sub[blk] = L_deposit_l(0); /* Q9 */
+
+ FOR (i=0; i < 2^4 */
+ {
+ norm_ind = subf_norm_groups_fx[blk][i];
+ move16();
+ L_E_sub[blk] = L_add(L_E_sub[blk],L_shr(dicn_fx[norm[norm_ind]],4));
+ move32(); ; /* Q10 */
+ }
+
+ L_E_sub[blk] = Mult_32_16(L_E_sub[blk], INV_BANDS_PER_SUBFRAMES);
+ move32(); /* Q(10+17-15) -> Q12 */
+
+ L_e_frame = L_add(L_e_frame,L_E_sub[blk]); /* Q12 */
+ }
+
+ /* Test for transient */
+ /* if (e_frame > ENERGY_TH * NUM_SUBFRAMES) */
+ IF (GT_32(L_e_frame, ENERGY_TH_NUM_SUBFRAMES))
+ {
+ FOR (blk = 0; blk < NUM_SUBFRAMES-1; blk++)
+ {
+ L_delta_e_sub = L_sub(L_E_sub[blk+1],L_E_sub[blk]); /* Q12 */
+ if (GT_32(L_delta_e_sub,L_d_max))
+ {
+ L_d_max = L_delta_e_sub; /* L_d_max is NOT normalized with *energy_lt */
+ move32();
+ }
+ }
+ }
+ }
+ ELSE
+ {
+ /* Update long-term energy measure */
+ L_e_frame = L_deposit_l(0); /* Q9 */
+ FOR (i = 0; i < SFM_N_ENV_STAB; i++) /* 27 times -> < 2^5 */
+ {
+ L_e_frame = L_add(L_e_frame,L_shr(dicn_fx[norm[i]],5));
+ /* Q9 */
+ }
+
+ L_e_frame = Mult_32_16(L_e_frame, INV_SFM_N_ENV_STAB); /* Q(9+19-15) -> Q13 */
+
+ IF ( GT_32(L_e_frame, ENERGY_TH_FX))
+ {
+ L_energy_lt_local = Mult_32_16(*L_energy_lt, ENERGY_LT_BETA_FX);
+ L_temp = Mult_32_16(L_e_frame, ENERGY_LT_BETA_1_FX);
+ *L_energy_lt = L_add(L_energy_lt_local,L_temp);
+ move32();
+ }
+ }
+
+ /* Add hang-over for conservative application of stability dependent attenuation */
+ /* -> Note: L_d_max not normalized with *energy_lt */
+ /* Hence, we compare L_d_max/DELTA_TH with *energy_lt */
+ IF (GT_32(Mult_32_16(L_d_max, INV_DELTA_TH),L_energy_lt_local)) /* Q13 = Q(12 + 16 -15) */
+ {
+ *no_att_hangover = ATT_LIM_HANGOVER;
+ move16();
+ }
+ ELSE if (*no_att_hangover > 0)
+ {
+ *no_att_hangover = sub(*no_att_hangover,1);
+ move16();
+ }
+ }
+
+ return;
+}
+
diff --git a/lib_com/est_tilt_fx.c b/lib_com/est_tilt_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..07a7ac03db0ce8d384756e1ed0938f01f393c99d
--- /dev/null
+++ b/lib_com/est_tilt_fx.c
@@ -0,0 +1,269 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+#include "basop_mpy.h"
+#include "basop_util.h"
+
+
+/*======================================================================*/
+/* FUNCTION : est_tilt_fx() */
+/*-----------------------------------------------------------------------*/
+/* PURPOSE : Estimate spectral tilt based on the relative E of adaptive */
+/* and innovative excitations */
+/* */
+/*-----------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16 *) exc : adaptive excitation vector Q0 */
+/* _ (Word16) gain_pit : adaptive gain Q14 */
+/* _ (Word16 *) code : algebraic exctitation vector Q12 */
+/* _ (Word32) gain_code : algebraic code gain Q16 */
+/* _ (Word16) Q_exc : Scaling factor of excitation Q0 */
+/*-----------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16 *) voice_fac : voicing factor Q15 */
+/*-----------------------------------------------------------------------*/
+/* INPUT OUTPUT ARGUMENTS */
+/*-----------------------------------------------------------------------*/
+
+/*-----------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ (Word16) tolt_code : tilt of the code Q15 */
+/*=======================================================================*/
+Word16 est_tilt_fx( /* o : tilt of the code Q15 */
+ const Word16 *exc, /* i : adaptive excitation vector Qx */
+ const Word16 gain_pit, /* i : adaptive gain Q14 */
+ const Word16 *code, /* i : algebraic exctitation vector Q9 */
+ const Word32 gain_code, /* i : algebraic code gain Q16 */
+ Word16 *voice_fac, /* o : voicing factor Q15 */
+ const Word16 Q_exc /* i : Scaling factor of excitation Q0 */
+)
+{
+ Word16 i, tmp, exp, ener1, exp1, ener2, exp2;
+ Word32 L_tmp;
+ Word16 tilt_code;
+
+ ener1 = extract_h(Dot_product12(exc, exc, L_SUBFR, &exp1));
+ exp1 = sub(exp1, add(Q_exc, Q_exc));
+ L_tmp = L_mult(gain_pit, gain_pit); /* energy of pitch excitation */
+ exp = norm_l(L_tmp);
+ tmp = extract_h(L_shl(L_tmp, exp));
+ ener1 = mult(ener1, tmp);
+ exp1 = sub(sub(exp1, exp), 10); /* 10 -> gain_pit Q14 to Q9 */
+
+ ener2 = extract_h(Dot_product12(code, code, L_SUBFR, &exp2));
+
+ exp = norm_l(gain_code);
+ tmp = extract_h(L_shl(gain_code, exp));
+ tmp = mult(tmp, tmp); /* energy of innovative code excitation */
+ ener2 = mult(ener2, tmp);
+ exp2 = sub(exp2, add(exp, exp));
+
+ i = sub(exp1, exp2);
+ BASOP_SATURATE_WARNING_OFF
+ ener1 = shr(ener1, sub(1, s_min(i, 0)));
+ ener2 = shr(ener2, add(s_max(0, i), 1));
+ BASOP_SATURATE_WARNING_ON
+ tmp = sub(ener1, ener2);
+ ener1 = add(add(ener1, ener2), 1);
+
+ /* find voice factor (1=voiced, -1=unvoiced) */
+ exp = div_s(abs_s(tmp), ener1);
+ if (tmp < 0)
+ {
+ exp = negate(exp);
+ }
+ *voice_fac = exp;
+ move16();
+
+ /* tilt of code for next subframe: 0.5=voiced, 0=unvoiced */
+
+ /* tilt_code = (float)(0.25*(1.0 + *voice_fac)) */
+ tilt_code = mac_r(8192L*65536-0x8000, *voice_fac, 8192); /*Q15 */
+
+ return tilt_code;
+}
+/*-------------------------------------------------------------------*
+ * Est_tilt2:
+ *
+ * Estimate spectral tilt based on the relative E of adaptive
+ * and innovative excitations
+ *-------------------------------------------------------------------*/
+Word16 Est_tilt2( /* o : tilt of the code */
+ const Word16 *exc, /* i : adaptive excitation vector Qx */
+ const Word16 gain_pit, /* i : adaptive gain Q14 */
+ const Word16 *code, /* i : algebraic exctitation vector Q9 */
+ const Word32 gain_code, /* i : algebraic code gain Q16 */
+ Word16 *voice_fac, /* o : voicing factor Q15 */
+ const Word16 Q_exc /* i : Scaling factor of excitation Q0 */
+)
+{
+ Word16 i, tmp, exp, ener1, exp1, ener2, exp2;
+ Word32 L_tmp;
+ Word16 tilt_code;
+
+ /* Scale exc to avoid overflow */
+ ener1 = extract_h(Energy_scale(exc, L_SUBFR, Q_exc, &exp1));
+
+ exp1 = sub(exp1, add(Q_exc, Q_exc));
+ L_tmp = L_mult(gain_pit, gain_pit); /* energy of pitch excitation */
+ exp = norm_l(L_tmp);
+ tmp = extract_h(L_shl(L_tmp, exp));
+ ener1 = mult(ener1, tmp);
+ exp1 = sub(sub(exp1, exp), 10); /* 10 -> gain_pit Q14 to Q9 */
+
+ ener2 = extract_h(Dot_product12(code, code, L_SUBFR, &exp2));
+
+ exp = norm_l(gain_code);
+ tmp = extract_h(L_shl(gain_code, exp));
+ tmp = mult(tmp, tmp); /* energy of innovative code excitation */
+ ener2 = mult(ener2, tmp);
+ exp2 = sub(exp2, add(exp, exp));
+
+ i = sub(exp1, exp2);
+ ener1 = shr(ener1, sub(1, s_min(i, 0)));
+ ener2 = shr(ener2, add(s_max(0, i), 1));
+
+ tmp = sub(ener1, ener2);
+ ener1 = add(add(ener1, ener2), 1);
+
+ /* find voice factor (1=voiced, -1=unvoiced) */
+ exp = div_s(abs_s(tmp), ener1);
+ if (tmp < 0)
+ {
+ exp = negate(exp);
+ }
+ *voice_fac = exp;
+ move16();
+
+ /* tilt of code for next subframe: 0.5=voiced, 0=unvoiced */
+
+ /* tilt_code = (float)(0.25*(1.0 + *voice_fac)) */
+ tilt_code = mac_r(8192L*65536-0x8000, *voice_fac, 8192);
+
+ return tilt_code;
+}
+
+/*---------------------------------------------------------*
+ * Find voice factor and tilt code *
+ *---------------------------------------------------------*/
+void E_UTIL_voice_factor( Word16 *exc, /* i : pointer to the excitation frame Q_new */
+ Word16 i_subfr, /* i : subframe index */
+ Word16 *code, /* i : innovative codebook Q9 */
+ Word16 gain_pit, /* i : adaptive codebook gain 1Q14 */
+ Word32 gain_code, /* i : innovative cb. gain 15Q16 */
+ Word16 *voice_fac, /* o : subframe voicing estimation Q15 */
+ Word16 *tilt_code, /* o : tilt factor Q15 */
+ Word16 L_subfr, /* i : subframe length */
+ Word16 flag_tilt, /* i : Flag for triggering new voice factor tilt*/
+ Word16 Q_new, /* i : excitation buffer format */
+ Word16 shift /* i : scaling to get 12bit */
+ )
+{
+ Word16 i, e, e2, stmp, exp_ener, fac;
+ Word32 ener, tmp, num;
+ Word64 ener_64;
+
+ BASOP_SATURATE_ERROR_ON;
+
+
+ IF(shift != 0)
+ {
+ fac = shl(0x4000,add(1,shift));
+ /* energy of pitch excitation */
+ stmp = mult_r(exc[0+i_subfr], fac); /* remove fac bits */
+ ener_64 = W_mult0_16_16(stmp, stmp);
+ FOR (i=1; i exponent = (15-Q_new)*2+1 */
+ }
+ }
+ ener = W_sat_l( ener_64 );
+
+
+ /* exponent of ener: (2*(15-Q_new+shift)+1+2-exp_ener-2*e2) */
+ exp_ener = norm_l(ener);
+ if(ener == 0)
+ {
+ exp_ener = 31;
+ move16();
+ }
+ ener = L_shl(ener,exp_ener);
+ e2 = norm_s(gain_pit);
+ gain_pit = shl(gain_pit,e2);
+ ener = Mpy_32_16_1(ener, mult_r(gain_pit, gain_pit));
+
+
+ /* energy of innovative code excitation */
+ tmp = L_deposit_l(1);
+
+ FOR (i=0; i 13Q18 */
+ }
+ /* exponent of tmp: 2*(15-9)+1+2*(15-e)) */
+ e = norm_l(gain_code);
+ gain_code = L_shl(gain_code, e);
+ tmp = Mpy_32_32(tmp, Mpy_32_32(gain_code,gain_code));
+
+ /* find voice factor (1=voiced, -1=unvoiced) */
+ /*i = (2*(15-Q_new+shift)+1+2-exp_ener-2*e2) - (2*(15-9)+1 + 2*(15-e));*/
+ i = sub(sub(sub(sub(sub(33,add(shift,shift)),add(Q_new,Q_new)),exp_ener),add(e2,e2)),sub(43,add(e,e)));
+ IF(i >= 0)
+ {
+ ener = L_shr(ener,1);
+ tmp = L_shr(tmp, add(1,i));
+ }
+ ELSE
+ {
+ tmp = L_shr(tmp,1);
+ BASOP_SATURATE_WARNING_OFF
+ ener = L_shr(ener, sub(1,i));
+ BASOP_SATURATE_WARNING_ON
+ }
+
+ *voice_fac = 0;
+ move16();
+ num = L_sub(ener, tmp);
+ IF(num != 0)
+ {
+ BASOP_SATURATE_WARNING_OFF /* Allow saturating the voice factor because if has a limited range by definition. */
+ *voice_fac = divide3232(num, L_add(ener, tmp));
+ move16();
+ BASOP_SATURATE_WARNING_ON
+ }
+
+ /* find tilt of code for next subframe */
+ IF (flag_tilt==0)
+ {
+ /*Between 0 (=unvoiced) and 0.5 (=voiced)*/
+ move16();
+ *tilt_code = add(8192/*0.25f Q15*/, mult_r(8192/*0.25f Q15*/, *voice_fac));
+ }
+ ELSE IF (flag_tilt==1)
+ {
+ /*Between 0.25 (=unvoiced) and 0.5 (=voiced)*/
+ move16();
+ *tilt_code = add(mult_r(4096/*0.125f Q15*/, *voice_fac), 12288/*0.125f+0.25f Q15*/);
+ }
+ ELSE
+ {
+ /*Between 0.28 (=unvoiced) and 0.56 (=voiced)*/
+ move16();
+ *tilt_code = add(mult_r(4588/*0.14f Q15*/, *voice_fac), 13763/*0.14f+0.28f Q15*/);
+ }
+ BASOP_SATURATE_ERROR_OFF;
+}
diff --git a/lib_com/fd_cng_com.c b/lib_com/fd_cng_com.c
new file mode 100644
index 0000000000000000000000000000000000000000..400a41d8e78c6647600445e9e622d653ab601d77
--- /dev/null
+++ b/lib_com/fd_cng_com.c
@@ -0,0 +1,1826 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "stl.h"
+#include "basop_util.h"
+#include "options.h"
+#include "stl.h"
+#include "rom_basop_util.h"
+#include "rom_com_fx.h"
+#include "prot_fx.h"
+
+#define DELTA_SHIFT 2
+#define DELTA_SHIFT_LD64 67108864l/*DELTA_SHIFT/64.0 Q31*/
+
+
+
+/*****************************************
+* Create an instance of type FD_CNG_COM *
+*****************************************/
+void createFdCngCom(HANDLE_FD_CNG_COM * hFdCngCom)
+{
+ HANDLE_FD_CNG_COM hs;
+
+ /* Allocate memory */
+ hs = (HANDLE_FD_CNG_COM) calloc(1, sizeof (FD_CNG_COM));
+ move16();
+
+
+ *hFdCngCom = hs;
+ move16();
+ return;
+}
+
+void initFdCngCom(HANDLE_FD_CNG_COM hs, Word16 scale)
+{
+ /* Calculate CLDFB scaling factor */
+ /* shl(i_mult2(scale, scale), 3) does not fit in 16 bit */
+ /*hs->scalingFactor = div_s(1, shl(i_mult2(scale, scale), 3));*/
+ assert(2048/*1.0/(1<<4) Q15*/ < mult(scale, scale));
+ /* Exponent invScalingFactor: -16 = -(2*7 (scale) + 2 (8.0) */
+ hs->invScalingFactor = shl(mult(scale,scale),1);
+ /* Exponent scalingFactor: -15 = -(2*7 (scale) + 2 (8.0) - 1 (1.0)) */
+ hs->scalingFactor = div_s(0x4000,hs->invScalingFactor);
+
+ /* Initialize the overlap-add */
+ set16_fx( hs->timeDomainBuffer, 0, L_FRAME16k );
+ hs->olapBufferAna = NULL;
+ move16();
+ set16_fx( hs->olapBufferSynth, 0, FFTLEN );
+ hs->olapBufferSynth2 = NULL;
+ move16();
+
+ /* Initialize the comfort noise generation */
+ set32_fx( hs->fftBuffer, 0, FFTLEN );
+ set32_fx( hs->cngNoiseLevel, 0, FFTCLDFBLEN );
+
+ /* Initialize quantizer */
+ set32_fx( hs->sidNoiseEst, 0, NPART );
+ set16_fx( hs->A_cng, 0, M+1 );
+ hs->A_cng[0] = 4096/*1.f Q12*/; /* 3Q12 */ move16();
+
+ /* Set some counters and flags */
+ hs->inactive_frame_counter = 0; /* Either SID or zero frames */ move16();
+ hs->active_frame_counter = 0;
+ move16();
+ hs->frame_type_previous = ACTIVE_FRAME;
+ move16();
+ hs->flag_noisy_speech = 0;
+ move16();
+ hs->likelihood_noisy_speech = 0;
+ move16();
+ hs->numCoreBands = 0;
+ move16();
+ hs->stopBand = 0;
+ move16();
+ hs->startBand = 0;
+ move16();
+ hs->stopFFTbin = 0;
+ move16();
+ hs->frameSize = 0;
+ move16();
+ hs->fftlen = 0;
+ move16();
+
+ /* Initialize noise estimation algorithm */
+ set32_fx( hs->periodog, 0, PERIODOGLEN );
+ mhvals(MSNUMSUBFR*MSSUBFRLEN, &(hs->msM_win));
+ mhvals(MSSUBFRLEN, &(hs->msM_subwin));
+ set32_fx( hs->msPeriodogSum, 0, 2 );
+ hs->msPeriodogSum_exp[0] = 0;
+ move16();
+ hs->msPeriodogSum_exp[1] = 0;
+ move16();
+ set32_fx( hs->msPsdSum, 0, 2 );
+ set16_fx( hs->msSlope, 0, 2 );
+ set32_fx( hs->msQeqInvAv, 0, 2 );
+ hs->msQeqInvAv_exp[0] = 0;
+ move16();
+ hs->msQeqInvAv_exp[1] = 0;
+ move16();
+ hs->msFrCnt_init_counter = 0;
+ move16();
+ hs->msFrCnt_init_thresh = 1;
+ move16();
+ hs->init_old = 0;
+ move16();
+ hs->offsetflag = 0;
+ move16();
+ hs->msFrCnt = MSSUBFRLEN;
+ move16();
+ hs->msMinBufferPtr = 0;
+ move16();
+ hs->msAlphaCor[0] = 644245120l/*0.3f Q31*/;
+ move16();
+ hs->msAlphaCor[1] = 644245120l/*0.3f Q31*/;
+ move16();
+
+ /* Initialize exponents */
+ hs->exp_cldfb_periodog = 0;
+ move16();
+
+ return;
+}
+
+/*****************************************
+* Delete an instance of type FD_CNG_COM *
+*****************************************/
+void deleteFdCngCom(HANDLE_FD_CNG_COM * hFdCngCom) /* i/o: Contains the variables related to the CLDFB-based CNG process */
+{
+ HANDLE_FD_CNG_COM hsCom;
+ hsCom = *hFdCngCom;
+ move16();
+ IF (hsCom != NULL)
+ {
+ free(hsCom);
+ *hFdCngCom = NULL;
+ move16();
+ }
+}
+
+/***************************************
+* Initialize the spectral partitioning *
+****************************************/
+void initPartitions( const Word16* part_in,
+ Word16 npart_in,
+ Word16 startBand,
+ Word16 stopBand,
+ Word16* part_out,
+ Word16* npart_out,
+ Word16* midband,
+ Word16* psize,
+ Word16* psize_norm,
+ Word16* psize_norm_exp,
+ Word16* psize_inv,
+ Word16 stopBandFR
+ )
+{
+ Word16 i, j, len_out, tmp16;
+
+
+ IF (part_in != NULL)
+ {
+ len_out = 0;
+ move16();
+ IF (GT_16(stopBandFR, startBand))
+ {
+ len_out = sub(stopBandFR, startBand);
+ FOR(i = 0 ; i < len_out; i++)
+ {
+ part_out[i] = i;
+ move16();
+ }
+ }
+ FOR(j=0 ; j < npart_in; j++)
+ {
+ IF (GE_16(part_in[j], stopBand))
+ {
+ BREAK;
+ }
+ tmp16 = sub(part_in[j],startBand);
+ test();
+ if (GE_16(part_in[j],stopBandFR)&&tmp16>=0)
+ {
+ part_out[len_out++] = tmp16;
+ move16();
+ }
+ }
+ }
+ ELSE
+ {
+ len_out = sub(stopBand, startBand);
+ FOR (i = 0 ; i < len_out; i++)
+ {
+ part_out[i] = i;
+ move16();
+ }
+ }
+
+ *npart_out = len_out;
+ move16();
+ getmidbands(part_out, len_out, midband, psize, psize_norm, psize_norm_exp, psize_inv);
+
+}
+
+#define CNG_HS 4 /* 4 bit headroom for dot product */
+#define CNG_S 6 /* 1 sign bit, 6 bit integer part, 9 bit frational part for input and output data */
+
+
+
+
+/********************************************************
+* Apply some dynamic range compression based on the log *
+********************************************************/
+void compress_range(
+ Word32 *in,
+ Word16 in_exp,
+ Word16 *out,
+ Word16 len
+)
+{
+ Word16 i;
+ Word32 in_s;
+ Word32 one_s;
+ Word32 in_exp32;
+ Word32 L_tmp;
+
+
+ /* out = log2( 1 + in ) */
+ IF ( in_exp >= 0 )
+ {
+ one_s = L_shr(1073741824l/*0.5 Q31*/,in_exp);
+ in_exp32 = L_shl(L_deposit_l(add(in_exp,1)),WORD32_BITS-1-LD_DATA_SCALE);
+ FOR (i=0; i < len; i++)
+ {
+ in_s = L_add(L_shr(in[i],1),one_s);
+ L_tmp = L_add(BASOP_Util_Log2(in_s),in_exp32);
+ if (in_s == 0)
+ {
+ out[i] = 0;
+ move16();
+ }
+ if (in_s != 0)
+ {
+ out[i] = extract_h(L_tmp);
+ }
+ if(out[i] == 0)
+ {
+ out[i] = 1;
+ }
+ }
+ }
+ ELSE
+ {
+ in_exp = sub(in_exp,1);
+ in_exp32 = L_shl(L_deposit_l(1),WORD32_BITS-1-LD_DATA_SCALE);
+ FOR (i=0; i < len; i++)
+ {
+ L_tmp = L_add(BASOP_Util_Log2(L_add(L_shl(in[i],in_exp),1073741824l/*0.5 Q31*/)),in_exp32);
+ if (in[i] == 0)
+ {
+ out[i] = 0;
+ move16();
+ }
+ if (in[i] != 0)
+ {
+ out[i] = extract_h(L_tmp);
+ }
+ if (out[i] == 0)
+ {
+ out[i] = 1;
+ }
+ }
+ }
+
+}
+
+/*************************************************************
+* Apply some dynamic range expansion to undo the compression *
+*************************************************************/
+void expand_range(
+ Word16 *in,
+ Word32 *out,
+ Word16 *out_exp,
+ Word16 len
+)
+{
+ Word16 i;
+ Word16 s;
+ Word16 tmp;
+ Word32 one_s, tmp32;
+ Word16 maxVal;
+ Word16 maxVal2;
+
+
+ maxVal = 0;
+ move16();
+ FOR (i=0; i < len; i++)
+ {
+ maxVal = s_max(maxVal,in[i]);
+ }
+
+ maxVal2 = maxVal;
+ move16();
+ s = 0;
+ move16();
+ WHILE ( maxVal >= 0 )
+ {
+ maxVal = sub(maxVal,512/*0.015625 Q15*/);
+ s = add(s,1);
+ }
+ tmp = sub(maxVal2,maxVal);
+
+ one_s = L_shr(1073741824l/*0.5 Q31*/,sub(s,1));
+ tmp32 = L_shr(726941l/*0.0003385080526823181 Q31*/,s);
+ /* out = (2^(in) - 1) */
+ FOR (i=0; i < len; i++)
+ {
+ out[i] = L_sub(BASOP_Util_InvLog2(L_deposit_h(sub(in[i],tmp))),one_s);
+ move32();
+ if ( out[i] == 0 )
+ {
+ out[i] = tmp32;
+ move32();
+ }
+ }
+ *out_exp = s;
+ move16();
+
+}
+
+/*************************************************
+* Noise estimation using Minimum Statistics (MS) *
+*************************************************/
+void minimum_statistics (
+ Word16 len, /* i : Total number of partitions (CLDFB or FFT) */
+ Word16 lenFFT, /* i : Number of FFT partitions */
+ Word16 *psize, /* i : Partition sizes, fractional */
+ Word16 *msPeriodog, /* i : Periodogram (energies) */
+ Word16 *msNoiseFloor, /* i/o: Noise floors (energies) */
+ Word16 *msNoiseEst, /* i/o: Noise estimates (energies) */
+ Word32 *msAlpha, /* i/o: Forgetting factors */
+ Word16 *msPsd, /* i/o: Power Spectral Density (smoothed periodogram => energies) */
+ Word16 *msPsdFirstMoment, /* i/o: PSD statistics of 1st order (energy means) */
+ Word32 *msPsdSecondMoment, /* i/o: PSD statistics of 2nd order (energy variances) */
+ Word32 *msMinBuf, /* i/o: Buffer of minima (energies) */
+ Word32 *msBminWin, /* o : Bias correction factors */
+ Word32 *msBminSubWin, /* o : Bias correction factors */
+ Word32 *msCurrentMin, /* i/o: Local minima (energies) */
+ Word32 *msCurrentMinOut, /* i/o: Local minima (energies) */
+ Word32 *msCurrentMinSubWindow, /* i/o: Local minima (energies) */
+ Word16 *msLocalMinFlag, /* i : Binary flag */
+ Word16 *msNewMinFlag, /* i : Binary flag */
+ Word16 *msPeriodogBuf, /* i/o: Buffer of periodograms (energies) */
+ Word16 *msPeriodogBufPtr, /* i/o: Counter */
+ HANDLE_FD_CNG_COM st /* i/o: FD_CNG structure containing buffers and variables */
+)
+{
+ Word16 i,j,k,s,s1,s2,s3;
+ Word16 len2;
+ Word16 current_len;
+ Word16 start, stop, cnt;
+ Word16 totsize;
+ Word16 inv_totsize;
+
+ Word32 tmp, tmp0, tmp1;
+ Word32 scalar, scalar2, scalar3;
+ Word32 snr;
+ Word32 msAlphaHatMin2;
+ Word32 BminCorr;
+ Word32 QeqInvAv;
+ Word32 *ptr;
+ Word32 *msPsdSum;
+ Word32 *msPeriodogSum;
+
+ Word16 tmp16, tmp16_1;
+ Word16 beta;
+ Word16 slope;
+ Word16 QeqInv;
+ Word16 scalar16;
+ Word16 scalar216;
+ Word16 scalar316;
+ Word16 msM_win;
+ Word16 msM_subwin;
+ Word16 msAlphaCorAlpha;
+ Word16 msAlphaCorAlpha2;
+ Word16 msPeriodogSum16;
+ Word16 msNoiseFloor16;
+
+
+ len2 = i_mult(MSNUMSUBFR,len);
+
+ msM_win = st->msM_win;
+ move16();
+ msM_subwin = st->msM_subwin;
+ move16();
+
+ msAlphaCorAlpha = MSALPHACORALPHA;
+ move16();
+ msAlphaCorAlpha2 = MSALPHACORALPHA2;
+ move16();
+
+ msPsdSum = st->msPsdSum;
+ msPeriodogSum = st->msPeriodogSum;
+
+ /* No minimum statistics at initialization */
+ IF ( LT_16(st->msFrCnt_init_counter,st->msFrCnt_init_thresh))
+ {
+ Copy(msPeriodog, msPsd, len); /* 6Q9 */
+ Copy(msPeriodog, msNoiseFloor, len); /* 6Q9 */
+ Copy(msPeriodog, msNoiseEst, len); /* 6Q9 */
+ Copy(msPeriodog, msPsdFirstMoment, len); /* 6Q9 */
+
+ set32_fx(msPsdSecondMoment, 0l/*0.0 Q31*/, len);
+ msPeriodogSum[0] = dotp_s_fx(msPeriodog, psize, lenFFT, CNG_HS);
+ move32();
+ msPsdSum[0] = msPeriodogSum[0]; /* 16Q15 */ move32();
+
+ IF ( LT_16(lenFFT,len))
+ {
+ msPeriodogSum[1] = dotp_s_fx(msPeriodog+lenFFT, psize+lenFFT, sub(len,lenFFT), CNG_HS);
+ move32();
+ msPsdSum[1] = msPeriodogSum[1]; /* 16Q15 */ move32();
+ }
+
+ /* Increment frame counter at initialization */
+ /* Some frames are sometimes zero at initialization => ignore them */
+ IF ( LT_16(msPeriodog[0],st->init_old))
+ {
+ set32_fx(msCurrentMinOut, 2147483647l/*1.0 Q31*/, len); /* 16Q15 */
+ set32_fx(msCurrentMin, 2147483647l/*1.0 Q31*/, len); /* 16Q15 */
+ set32_fx(msMinBuf, 2147483647l/*1.0 Q31*/, len2); /* 16Q15 */
+ set32_fx(msCurrentMinSubWindow, 2147483647l/*1.0 Q31*/, len); /* 16Q15 */
+
+ st->msFrCnt_init_counter = add(st->msFrCnt_init_counter,1);
+ move16();
+ }
+ st->init_old = msPeriodog[0]; /* 6Q9 */ move16();
+ }
+ ELSE
+ {
+ /* Consider the FFT and CLDFB bands separately
+ - first iteration for FFT bins,
+ - second one for CLDFB bands in SWB mode */
+ cnt = 0;
+ move16();
+ start = 0;
+ move16();
+ stop = lenFFT;
+ move16();
+ totsize = sub(st->stopFFTbin,st->startBand);
+ WHILE ( GT_16(stop,start))
+ {
+ current_len = sub(stop,start);
+
+ /* Compute smoothed correction factor for PSD smoothing */
+
+ /* msPeriodogSum[cnt] with format 16Q15 */
+ msPeriodogSum[cnt] = dotp_s_fx(msPeriodog+start, psize+start, current_len, CNG_HS);
+ move32();
+
+ IF ( msPeriodogSum[cnt] == 0 )
+ {
+ st->msAlphaCor[cnt] = Mpy_32_16_1(st->msAlphaCor[cnt], msAlphaCorAlpha);
+ move32();
+ }
+ ELSE
+ {
+ /* calculate scalar with normalized msPeriodogSum[cnt], exponent -2*s1 */
+ s1 = norm_l(msPeriodogSum[cnt]);
+ msPeriodogSum16 = round_fx(L_shl(msPeriodogSum[cnt],s1));
+ scalar = L_mult(msPeriodogSum16, msPeriodogSum16);
+
+ /* calculate difference, both elements in 16Q15 format, use absolute value
+ to avoid -1.0 x -1.0 multiplications later */
+ scalar2 = L_abs(L_sub(msPsdSum[cnt], msPeriodogSum[cnt]));
+
+ s2 = WORD32_BITS-1;
+ move16();
+ if ( scalar2 != 0 )
+ {
+ /* use absolute value to avoid -1.0 x -1.0 multiplications */
+ s2 = norm_l(scalar2);
+ }
+ scalar216 = round_fx(L_shl(scalar2,s2));
+ scalar2 = L_mult(scalar216, scalar216);
+
+ /* find common exponent */
+ tmp16_1 = sub(s1,s2);
+ tmp16 = s_min(shl(abs_s(tmp16_1),1),WORD32_BITS-1);
+ if ( tmp16_1 < 0 )
+ {
+ scalar2 = L_shr(scalar2,tmp16);
+ }
+ if(tmp16_1 > 0)
+ {
+ scalar = L_shr(scalar,tmp16);
+ }
+
+
+ /* add scalar and scalar2, avoid overflows */
+ scalar = L_shr(scalar,1);
+ scalar2 = L_shr(scalar2,1);
+ scalar3 = L_add(scalar,scalar2);
+
+ /* calculate division */
+ scalar16 = BASOP_Util_Divide3232_uu_1616_Scale(scalar, scalar3, &s3);
+ s3 = s_max(s3,-(WORD16_BITS-1));
+ scalar16 = shl(scalar16,s3);
+ scalar16 = s_max(scalar16, MSALPHACORMAX);
+
+ st->msAlphaCor[cnt] = L_add(Mpy_32_16_1(st->msAlphaCor[cnt], msAlphaCorAlpha),
+ L_mult(scalar16, msAlphaCorAlpha2));
+ move32();
+ }
+
+ /* Compute SNR */
+
+ /* msPeriodogSum[cnt] with format 16Q15 */
+ snr = dotp_s_fx(msNoiseFloor+start, psize+start, current_len, CNG_HS);
+
+ IF ( GT_32(L_shr(Mpy_32_16_1(msPsdSum[cnt],18431/*0.56246299817 Q15*/),13),snr))
+ {
+ tmp0 = BASOP_Util_Log2(msPsdSum[cnt]);
+ tmp1 = BASOP_Util_Log2(snr);
+ tmp1 = L_sub(tmp0, tmp1);
+ tmp1 = Mpy_32_16_1(tmp1, MSSNREXP);
+ msAlphaHatMin2 = BASOP_Util_InvLog2(tmp1);
+ }
+ ELSE
+ {
+ msAlphaHatMin2 = MSALPHAHATMIN;
+ move32();
+ }
+ scalar = Mpy_32_16_1(st->msAlphaCor[cnt], MSALPHAMAX);
+
+ FOR (j=start; j 0)
+ {
+ scalar2 = L_shr(scalar2,tmp16);
+ }
+
+ /* add scalar2 and scalar3, avoid overflows */
+ scalar2 = L_shr(scalar2,1);
+ scalar3 = L_shr(scalar3,1);
+ scalar3 = L_add(scalar2,scalar3);
+
+ /* calculate division */
+ tmp16 = BASOP_Util_Divide3232_uu_1616_Scale(scalar2, scalar3, &s3);
+ scalar2 = Mpy_32_16_1(scalar, tmp16);
+ s3 = s_max(s3,-(WORD32_BITS-1));
+ scalar2 = L_shl(scalar2,s3);
+ msAlpha[j] = L_max(scalar2, msAlphaHatMin2);
+ move32();
+ }
+
+ /* Compute the PSD (smoothed periodogram) in each band */
+ msPsd[j] = round_fx(L_add(Mpy_32_16_1(msAlpha[j], msPsd[j]),
+ Mpy_32_16_1(L_sub(2147483647l/*1.0 Q31*/,msAlpha[j]), msPeriodog[j])));
+ }
+ msPsdSum[cnt] = dotp_s_fx(msPsd+start, psize+start, current_len, CNG_HS);
+ move32();
+
+ QeqInvAv = 0l/*0.0 Q31*/;
+ move32();
+
+ /* scalar: 7Q24 format */
+ tmp = 1191182336l/*(float)(MSNUMSUBFR*MSSUBFRLEN)-1.0 Q24*/;
+ move32();
+ scalar = L_sub(tmp, L_mult(round_fx(tmp), msM_win));
+
+ /* scalar2: 4Q27 format */
+ tmp = 1476395008l/*(float)MSSUBFRLEN-1.0 Q27*/;
+ move32();
+ scalar2 = L_sub(tmp, L_mult(round_fx(tmp), msM_subwin));
+
+ FOR (j=start; jmsQeqInvAv[cnt] = QeqInvAv;
+ move32();
+
+ /* New minimum? */
+
+ /* exponent QeqInvAv: CNG_S, exponent MSAV: (4>>1) */
+ s = CNG_S+2*MSAV_EXP;
+ move16();
+ BminCorr = Mpy_32_16_1(Sqrt32(QeqInvAv, &s), MSAV);
+ BminCorr = L_shl(BminCorr,sub(s,1));
+
+ /* exponent BminCorr: 1 */
+ BminCorr = L_add(BminCorr, 1073741824l/*0.5 Q31*/);
+
+ FOR (j=start; jmsFrCnt,MSSUBFRLEN))
+ {
+ FOR ( i = 0; i < 3; i++ )
+ {
+ IF ( LT_32(st->msQeqInvAv[cnt],L_shr(L_deposit_h(msQeqInvAv_thresh[i]),CNG_S))/*0.0 Q31*/)
+ {
+ BREAK;
+ }
+ }
+ /* format 1Q30 */
+ st->msSlope[cnt] = msNoiseSlopeMax[i];
+ move32();
+ }
+
+ /* Consider the FFT and CLDFB bands separately */
+ start = stop;
+ move16();
+ stop = len;
+ move16();
+ totsize = sub(st->stopBand,st->stopFFTbin);
+ cnt = add(cnt,1);
+ } /*while (stop > start)*/
+
+ /* Update minimum between sub windows */
+ test();
+ IF ( GT_16(st->msFrCnt,1)&<_16(st->msFrCnt,MSSUBFRLEN))
+ {
+ FOR (j=0; j 0 )
+ {
+ msLocalMinFlag[j] = 1;
+ move16();
+ }
+ if ( LT_32(msCurrentMinSubWindow[j],msCurrentMinOut[j])/*0.0 Q31*/)
+ {
+ /* msCurrentMinOut[j] scaled with CNG_S */
+ msCurrentMinOut[j] = msCurrentMinSubWindow[j];
+ move32();
+ }
+ }
+ /* Get the current noise floor */
+ Copy_Scale_sig_32_16(msCurrentMinOut, msNoiseFloor, len, -16);
+ }
+ ELSE /* sub window complete */
+ {
+ IF ( GE_16(st->msFrCnt,MSSUBFRLEN))
+ {
+ /* Collect buffers */
+ Copy32(msCurrentMinSubWindow, msMinBuf+len*st->msMinBufferPtr, len);
+
+ /* Compute minimum among all buffers */
+ Copy32(msMinBuf, msCurrentMinOut, len);
+ ptr = msMinBuf + len;
+ FOR (i=1; imsSlope[0];
+ move16();
+ FOR (j=0; jmsSlope[1];
+ move16();
+ }
+ test();
+ test();
+ test();
+ IF ( ( msLocalMinFlag[j] != 0 )
+ && ( msNewMinFlag[j] == 0 )
+ && ( LT_32(L_shr(msCurrentMinSubWindow[j],1),Mpy_32_16_1(msCurrentMinOut[j],slope)) /*0.0 Q31*/ )
+ && ( GT_32(msCurrentMinSubWindow[j],msCurrentMinOut[j]) /*0.0 Q31*/ )
+ )
+ {
+ msCurrentMinOut[j] = msCurrentMinSubWindow[j];
+ move32();
+ i = j;
+ move16();
+ FOR (k=0; koffsetflag > 0 )
+ {
+ Copy(msPeriodog, msPsd, len);
+ FOR (j=0; j < len; j++)
+ {
+ msCurrentMinOut[j] = L_deposit_h(msPeriodog[j]);
+ }
+ set32_fx(st->msAlphaCor, 2147483647l/*1.0 Q31*/, cnt);
+ set32_fx(msAlpha, 0l/*0.0 Q31*/, len);
+ Copy(msPeriodog, msPsdFirstMoment, len);
+ set32_fx(msPsdSecondMoment, 0l/*0.0 Q31*/, len);
+
+ msPsdSum[0] = dotp_s_fx(msPeriodog, psize, lenFFT, CNG_HS);
+ move32();
+ IF ( LT_16(lenFFT,len))
+ {
+ msPsdSum[1] = dotp_s_fx(msPeriodog+lenFFT, psize+lenFFT, sub(len,lenFFT), CNG_HS);
+ move32();
+ }
+ }
+ st->offsetflag = 1;
+ move16();
+ }
+ ELSE
+ {
+ st->offsetflag = 0;
+ move16();
+ }
+
+
+ /* Increment frame counter */
+ IF ( EQ_16(st->msFrCnt,MSSUBFRLEN))
+ {
+ st->msFrCnt = 1;
+ move16();
+ st->msMinBufferPtr = add(st->msMinBufferPtr,1);
+ move16();
+ if ( EQ_16(st->msMinBufferPtr,MSNUMSUBFR))
+ {
+ st->msMinBufferPtr = 0;
+ move16();
+ }
+ }
+ ELSE
+ {
+ st->msFrCnt = add(st->msFrCnt,1);
+ }
+
+ /* Smooth noise estimate during CNG phases */
+ FOR (j=0; j= 0/*0.0 Q15*/);
+ }
+
+}
+
+
+/***********************************
+* Apply bitrate-dependant scale *
+***********************************/
+void apply_scale(Word32 *scale, Word16 bwmode, Word32 bitrate)
+{
+ Word16 i;
+ Word16 scaleTableSize = sizeof (scaleTable) / sizeof (scaleTable[0]);
+
+
+
+ FOR (i=0; i < scaleTableSize; i++)
+ {
+ cast16();
+ IF ( s_and( (Word16)EQ_16(bwmode, (Word16)scaleTable[i].bwmode),
+ s_and( L_sub(bitrate,scaleTable[i].bitrateFrom) >= 0,
+ L_sub(bitrate,scaleTable[i].bitrateTo) < 0))
+ )
+ {
+ BREAK;
+ }
+ }
+
+ {
+ *scale = L_add(*scale, L_deposit_h(scaleTable[i].scale));
+ }
+
+}
+
+
+/***************************************
+* Compute the power for each partition *
+***************************************/
+void bandcombinepow(Word32* bandpow, /* i : Power for each band */
+ Word16 exp_bandpow, /* i : exponent of bandpow */
+ Word16 nband, /* i : Number of bands */
+ Word16* part, /* i : Partition upper boundaries (band indices starting from 0) */
+ Word16 npart, /* i : Number of partitions */
+ Word16* psize_inv, /* i : Inverse partition sizes */
+ Word32* partpow, /* o : Power for each partition */
+ Word16* exp_partpow)
+{
+
+ Word16 i, p;
+ Word32 temp;
+ Word16 smin, len, prev_part;
+ Word16 facTabExp[NPART_SHAPING];
+
+
+
+ IF (EQ_16(nband, npart))
+ {
+ Copy32(bandpow, partpow, nband);
+ smin = 0;
+ move16();
+ }
+ ELSE
+ {
+ /* Compute the power in each partition */
+ prev_part = -1;
+ move16();
+ FOR (p=0; p < npart; p++)
+ {
+ len = sub(part[p],prev_part);
+ facTabExp[p] = getScaleFactor32 (&bandpow[prev_part+1], len);
+ move16();
+ prev_part = part[p];
+ move16();
+ }
+
+ smin = WORD32_BITS-1;
+ move16();
+ FOR (p=0; p < npart; p++)
+ {
+ smin = s_min(smin,facTabExp[p]);
+ }
+
+ i = 0;
+ move16();
+ FOR (p = 0; p < npart; p++)
+ {
+ /* Arithmetic averaging of power for all bins in partition */
+ temp = 0;
+ move32();
+ FOR ( ; i <= part[p]; i++)
+ {
+ temp = L_add(temp, Mpy_32_16_1(L_shl(bandpow[i],facTabExp[p]),psize_inv[p]));
+ }
+ partpow[p] = L_shr(temp,sub(facTabExp[p],smin));
+ move32();
+ }
+
+ }
+
+ *exp_partpow = sub(exp_bandpow,smin);
+ move16();
+}
+
+
+/************************************
+* Scale partitions (with smoothing) *
+************************************/
+void scalebands (Word32 *partpow, /* i : Power for each partition */
+ Word16 *part, /* i : Partition upper boundaries (band indices starting from 0) */
+ Word16 npart, /* i : Number of partitions */
+ Word16 *midband, /* i : Central band of each partition */
+ Word16 nFFTpart, /* i : Number of FFT partitions */
+ Word16 nband, /* i : Number of bands */
+ Word32 *bandpow, /* o : Power for each band */
+ Word16 flag_fft_en
+ )
+{
+ Word16 i, j, s, s1, nint, delta, delta_cmp, delta_s;
+ Word16 startBand, startPart, stopPart, stopPartM1;
+ Word32 tmp, val, partpowLD64, partpowLD64M1;
+
+
+
+ j = 0;
+ move16();
+ delta = 0;
+ move16();
+ partpowLD64M1 = 0L; /* to avoid compilation warnings */
+
+ /* Interpolate the bin/band-wise levels from the partition levels */
+ IF ( EQ_16(nband, npart))
+ {
+ Copy32(partpow, bandpow, npart);
+ }
+ ELSE
+ {
+ startBand = 0;
+ move16();
+ startPart = 0;
+ move16();
+ stopPart = nFFTpart;
+ move16();
+
+ WHILE ( LT_16(startBand,nband))
+ {
+ stopPartM1 = sub(stopPart, 1);
+ test();
+ IF ( (flag_fft_en != 0) || (GE_16(startPart,nFFTpart)))
+ {
+ /* first half partition */
+ j = startPart;
+ move16();
+
+ FOR (i=startBand; i <= midband[j]; i++)
+ {
+ bandpow[i] = partpow[j];
+ move32();
+ }
+ j = add(j, 1);
+
+ /* inner partitions */
+ IF (j < stopPart)
+ {
+ partpowLD64M1 = BASOP_Util_Log2(partpow[j-1]);
+ }
+
+ /* Debug values to check this variable is set. */
+ delta = 0x4000;
+ move16();
+ delta_cmp = 0x4000;
+ move16();
+ s1 = 1;
+ move16();
+ s = 1;
+ move16();
+
+ FOR ( ; j < stopPart; j++)
+ {
+ nint = sub(midband[j], midband[j-1]);
+
+ /* log-linear interpolation */
+ partpowLD64 = BASOP_Util_Log2(partpow[j]);
+ tmp = L_sub(partpowLD64, partpowLD64M1);
+ tmp = Mpy_32_16_1(tmp, getNormReciprocalWord16(nint));
+
+ /* scale logarithmic value */
+ tmp = L_sub(tmp, DELTA_SHIFT_LD64);
+ delta_s = DELTA_SHIFT;
+ move16();
+
+ WHILE (tmp > 0)
+ {
+ tmp = L_sub(tmp,33554432l/*0.015625 Q31*/);
+ delta_s = add(delta_s,1);
+ }
+ delta_cmp = shl(1, s_max(-15, sub(WORD16_BITS-1,delta_s)));
+
+ tmp = BASOP_Util_InvLog2(tmp);
+ s = norm_l(tmp);
+ s1 = sub(delta_s, s);
+
+ delta = round_fx(L_shl(tmp, s));
+
+ /* Choose scale such that the interpolation start and end point both are representable and add 1 additional bit hr. */
+ delta_s = sub(s_min(norm_l(partpow[j-1]), norm_l(partpow[j])), 1);
+ val = L_shl(partpow[j-1], delta_s);
+ FOR ( ; i < midband[j]; i++)
+ {
+ val = L_shl(Mpy_32_16_1(val, delta), s1);
+ bandpow[i] = L_shr(val, delta_s);
+ move32();
+ }
+ bandpow[i++] = partpow[j];
+ move32();
+ partpowLD64M1 = partpowLD64;
+ move32();
+ }
+
+ IF ( GT_16(shr(delta, s), delta_cmp))
+ {
+ delta = 0x4000;
+ move16();
+ s1 = 1;
+ move16();
+ }
+
+ /* last half partition */
+ val = partpow[stopPartM1];
+ move32();
+ FOR ( ; i <= part[stopPartM1]; i++)
+ {
+ val = L_shl(Mpy_32_16_1(val,delta), s1);
+ bandpow[i] = val;
+ move32();
+ }
+
+ }
+ startBand = add(part[stopPartM1], 1);
+ startPart = stopPart;
+ move16();
+ stopPart = npart;
+ move16();
+ }
+ }
+
+}
+
+
+/**************************************
+* Get central band for each partition *
+**************************************/
+void getmidbands(Word16* part, /* i : Partition upper boundaries (band indices starting from 0) */
+ Word16 npart, /* i : Number of partitions */
+ Word16* midband, /* o : Central band of each partition */
+ Word16* psize, /* o : Partition sizes */
+ Word16* psize_norm, /* o : Partition sizes, fractional values */
+ Word16* psize_norm_exp, /* o : Exponent for fractional partition sizes */
+ Word16* psize_inv) /* o : Inverse of partition sizes */
+{
+ Word16 j, max_psize, shift;
+
+
+ max_psize = psize[0];
+ move16();
+ /* first half partition */ move16();
+ midband[0] = part[0];
+ psize[0] = add(part[0], 1);
+ move16();
+ psize_inv[0] = getNormReciprocalWord16(psize[0]);
+ move16();
+ /* inner partitions */
+ FOR (j = 1; j < npart; j++)
+ {
+ midband[j] = shr(add(add(part[j-1], 1), part[j]), 1);
+ move16();
+ psize[j] = sub(part[j], part[j-1]);
+ move16();
+ psize_inv[j] = getNormReciprocalWord16(psize[j]);
+ move16();
+ if(GT_16(psize[j], max_psize))
+ {
+ max_psize = psize[j];
+ move16();
+ }
+ }
+
+ shift = 9;
+ move16();
+ *psize_norm_exp = sub(15, shift);
+ move16();
+ FOR(j=0; j < npart; j++)
+ {
+ psize_norm[j] = shl(psize[j], shift);
+ move16();
+ }
+ /* minimum_statistics needs fixed exponent of 6 */
+ assert(norm_s(-max_psize) >= 9 );
+}
+
+
+/*
+ AnalysisSTFT
+
+ Parameters:
+
+ timeDomainInput, i : pointer to time signal
+ fftBuffer, o : FFT bins
+ fftBufferExp, i : exponent of FFT bins
+ st i/o: FD_CNG structure containing all buffers and variables
+
+ Function:
+ STFT analysis filterbank
+
+ Returns:
+ void
+*/
+void AnalysisSTFT (const Word16 *timeDomainInput, /* i : pointer to time signal */
+ Word16 Q,
+ Word32 *fftBuffer, /* o : FFT bins */
+ Word16 *fftBuffer_exp, /* i : exponent of FFT bins */
+ HANDLE_FD_CNG_COM st /* i/o: FD_CNG structure containing all buffers and variables */
+ )
+{
+ Word16 i, len;
+ Word16 len2;
+ const PWord16 *olapWin;
+ Word16 *olapBuffer;
+
+
+
+ assert( (st->fftlen>>1) == st->frameSize);
+
+ /* pointer inititialization */
+ assert(st->olapBufferAna != NULL);
+ olapBuffer = st->olapBufferAna;
+ olapWin = st->olapWinAna;
+
+ /* olapWin factor is scaled with one bit */
+ *fftBuffer_exp = 1;
+ move16();
+ len = sub(st->fftlen,st->frameSize);
+ assert(len <= 320); /* see size of olapBuffer */
+
+ /* Window the signal */
+ len2 = shr(len,1);
+ FOR (i=0; i < len2; i++)
+ {
+ move32();
+ move32();
+ fftBuffer[i] = L_mult(olapBuffer[i], mult_r(olapWin[i].v.im, 23170/*1.4142135623730950488016887242097 Q14*/));
+ fftBuffer[i+len2] = L_mult(olapBuffer[i+len2], mult_r(olapWin[len2-1-i].v.re, 23170/*1.4142135623730950488016887242097 Q14*/));
+ }
+ len2 = shr(st->frameSize,1);
+ FOR (i=0; i fftlen, fftBuffer_exp, -1);
+
+ FOR (i=0; i frameSize,len)+i], Q );
+ move16();
+ }
+
+}
+
+
+/*
+ SynthesisSTFT
+
+ Parameters:
+
+ fftBuffer i : pointer to FFT bins
+ fftBufferExp i : exponent of FFT bins
+ timeDomainOutput o : pointer to time domain signal
+ timeDomainOutputExp o : pointer to exponent of time domain output
+ olapBuffer i/o : pointer to overlap buffer
+ olapWin i : pointer to overlap window
+ st i/o : pointer to FD_CNG structure containing all buffers and variables
+
+ Function:
+ STFT synthesis filterbank
+
+ Returns:
+ void
+*/
+void
+SynthesisSTFT (Word32 *fftBuffer, /* i : pointer to FFT bins */
+ Word16 fftBufferExp, /* i : exponent of FFT bins */
+ Word16 *timeDomainOutput, /* o : pointer to time domain signal */
+ Word16 *olapBuffer, /* i/o : pointer to overlap buffer */
+ const PWord16 *olapWin, /* i : pointer to overlap window */
+ Word16 tcx_transition,
+ HANDLE_FD_CNG_COM st, /* i/o : pointer to FD_CNG structure containing all buffers and variables */
+ Word16 gen_exc,
+ Word16 *Q_new
+ )
+{
+ Word16 i, len, scale, tmp;
+ Word16 len2, len3, len4;
+ Word16 buf[M+1+L_FRAME16k];
+
+
+ /* Perform IFFT */
+ scale = 0;
+ BASOP_rfft(fftBuffer, st->fftlen, &scale, 1);
+ fftBufferExp = add(fftBufferExp, scale);
+ fftBufferExp = add(fftBufferExp, st->fftlenShift);
+
+ /* Perform overlap-add */
+ Copy(olapBuffer+st->frameSize, olapBuffer, st->frameSize);
+ set16_fx(olapBuffer+st->frameSize, 0, st->frameSize);
+
+ len2 = shr(st->fftlen,2);
+ len4 = shr(st->fftlen,3);
+ len3 = add(len2,len4);
+ len = add(st->frameSize,len4);
+ IF ( tcx_transition )
+ {
+ FOR (i=0; i < len; i++)
+ {
+ olapBuffer[i] = round_fx(L_shl(fftBuffer[i],fftBufferExp-15));
+ }
+ }
+ ELSE
+ {
+ FOR (i=0; i < len4; i++)
+ {
+ olapBuffer[i+1*len4] = add(olapBuffer[i+1*len4], mult_r(round_fx(L_shl(fftBuffer[i+1*len4],fftBufferExp-15)),olapWin[i].v.im));
+ move16();
+ olapBuffer[i+2*len4] = add(olapBuffer[i+2*len4], mult_r(round_fx(L_shl(fftBuffer[i+2*len4],fftBufferExp-15)),olapWin[len4-1-i].v.re));
+ move16();
+ }
+ FOR (i=len3; i < len; i++)
+ {
+ olapBuffer[i] = round_fx(L_shl(fftBuffer[i],fftBufferExp-15));
+ }
+ }
+
+ FOR (i=0; i < len4; i++)
+ {
+ olapBuffer[i+5*len4] = mult_r(round_fx(L_shl(fftBuffer[i+5*len4],fftBufferExp-15)),olapWin[i].v.re);
+ move16();
+ olapBuffer[i+6*len4] = mult_r(round_fx(L_shl(fftBuffer[i+6*len4],fftBufferExp-15)),olapWin[len4-1-i].v.im);
+ move16();
+ }
+
+ len = add( len, len2 );
+ FOR (i=len; i < st->fftlen ; i++)
+ {
+ olapBuffer[i] = 0;
+ move16();
+ }
+
+ /* Get time-domain signal */
+ FOR (i=0; i < st->frameSize; i++)
+ {
+ timeDomainOutput[i] = mult_r( olapBuffer[i+len4], st->fftlenFac );
+ move16();
+ }
+
+ /* Generate excitation */
+ IF ( EQ_16( gen_exc, 1 ))
+ {
+ FOR (i=0; i < M+1+st->frameSize; i++)
+ {
+ buf[i] = mult_r( olapBuffer[i+len4-M-1], st->fftlenFac );
+ move16();
+ }
+ tmp = buf[0];
+ E_UTIL_f_preemph2( *Q_new-1, buf+1, PREEMPH_FAC, M+st->frameSize, &tmp );
+ Residu3_fx( st->A_cng, buf+1+M, st->exc_cng, st->frameSize, 1 );
+ }
+ IF ( EQ_16( gen_exc, 2 ))
+ {
+ FOR (i=0; i < M+1+st->frameSize; i++)
+ {
+ buf[i] = mult_r( olapBuffer[i+len4-M-1], st->fftlenFac );
+ move16();
+ }
+ tmp = buf[0];
+ *Q_new = E_UTIL_f_preemph3( buf+1, PREEMPH_FAC, M+st->frameSize, &tmp, 1 );
+ Residu3_fx( st->A_cng, buf+1+M, st->exc_cng, st->frameSize, 1 );
+ }
+
+}
+
+
+/**************************************************************************************
+* Compute some values used in the bias correction of the minimum statistics algorithm *
+**************************************************************************************/
+void mhvals(Word16 d,
+ Word16 * m /*, float * h*/
+ )
+{
+ Word16 i, j;
+ Word16 len = sizeof(d_array)/sizeof(Word16);
+
+
+ assert( d==72 || d==12); /* function only tested for d==72 and d==12) */
+ i = 0;
+ move16();
+ FOR (i=0 ; i < len ; i++)
+ {
+ IF (LE_16(d,d_array[i]))
+ {
+ BREAK;
+ }
+ }
+ IF (EQ_16(i, len))
+ {
+ i = sub(len, 1);
+ j = i;
+ move16();
+ }
+ ELSE
+ {
+ j = sub(i, 1);
+ }
+ IF (EQ_16(d, d_array[i]))
+ {
+ *m = m_array[i];
+ move16();
+ }
+ ELSE
+ {
+ Word32 qi_m, qj_m, q_m, tmp1_m, tmp2_m;
+ Word16 qi_e, qj_e, q_e, tmp1_e, tmp2_e, tmp1_w16_m, tmp1_w16_e, shift;
+
+
+ /* d_array has exponent 15 */
+ qj_e = 15;
+ move16();
+ qj_m = L_deposit_h(d_array[i-1]);
+
+ qi_e = 15;
+ move16();
+ qi_m = L_deposit_h(d_array[i]);
+
+ q_e = 15;
+ move16();
+ q_m = L_deposit_h(d);
+
+ qj_m = Sqrt32(qj_m, &qj_e);
+ qi_m = Sqrt32(qi_m, &qi_e);
+ q_m = Sqrt32(q_m, &q_e);
+
+ tmp1_m = Mpy_32_32(qi_m, qj_m);
+ tmp1_e = add(qi_e, qj_e);
+ tmp1_m = L_deposit_h(BASOP_Util_Divide3232_Scale(tmp1_m, q_m, &shift));
+ tmp1_e = sub(tmp1_e, q_e);
+ tmp1_e = add(tmp1_e, shift);
+ tmp1_m = BASOP_Util_Add_Mant32Exp(tmp1_m, tmp1_e, L_negate(qj_m), qj_e, &tmp1_e);
+
+ tmp2_m = BASOP_Util_Add_Mant32Exp (qi_m, qi_e, L_negate(qj_m), qj_e, &tmp2_e);
+ tmp1_w16_m = round_fx(tmp2_m);
+ tmp1_w16_e = tmp2_e;
+ move16();
+ BASOP_Util_Divide_MantExp(sub(m_array[j], m_array[i]), 0, tmp1_w16_m, tmp1_w16_e, &tmp1_w16_m, &tmp1_w16_e);
+
+ tmp2_m = Mpy_32_16_1(tmp1_m, tmp1_w16_m);
+ tmp2_e = add(tmp1_e, tmp1_w16_e);
+
+ tmp2_m = BASOP_Util_Add_Mant32Exp (tmp2_m, tmp2_e, L_deposit_h(m_array[i]), 0, &tmp2_e);
+ assert(tmp2_e == 0);
+ *m = extract_h(tmp2_m);
+ }
+}
+
+
+/*
+ rand_gauss
+
+ Parameters:
+
+ seed i/o : pointer to seed
+
+ Function:
+ Random generator with Gaussian distribution with mean 0 and std 1
+
+ Returns:
+ random signal format Q3.29
+*/
+Word32 rand_gauss (Word16 *seed)
+{
+ Word32 temp;
+ Word16 loc_seed;
+
+
+
+ /* This unrolled version reduces the cycles from 17 to 10 */
+ loc_seed = extract_l(L_mac0(13849, *seed, 31821));
+ temp = L_deposit_l(loc_seed);
+
+ loc_seed = extract_l(L_mac0(13849, loc_seed, 31821));
+ temp = L_msu0(temp,loc_seed,-1);
+
+ loc_seed = extract_l(L_mac0(13849, loc_seed, 31821));
+ temp = L_msu0(temp,loc_seed,-1);
+
+ *seed = loc_seed;
+ move16();
+ return L_shl(temp,WORD16_BITS-CNG_RAND_GAUSS_SHIFT);
+}
+
+
+/*
+ lpc_from_spectrum
+
+ Parameters:
+
+ powspec i : pointer to noise levels format Q5.27
+ start i : start band
+ stop i : stop band
+ fftlen i : size of fft
+ A o : lpc coefficients format Q3.12
+ s i : lpc order
+ preemph_fac i : preemphase factor format Q1.15
+
+
+ Function:
+ calculate lpc coefficients from the spectrum
+
+ Returns:
+ void
+*/
+void lpc_from_spectrum (Word32 *powspec,
+ Word16 powspec_exp,
+ Word16 start,
+ Word16 stop,
+ Word16 fftlen,
+ Word16 *A,
+ Word16 lpcorder,
+ Word16 preemph_fac
+ )
+{
+ Word16 i, s1, s2, s3, fftlen2, scale, fftlen4, fftlen8, len, step, preemph_fac2;
+ Word32 maxVal, r[32], fftBuffer[FFTLEN], *ptr, *pti, nf;
+ Word16 tmp, r_h[32], r_l[32];
+ const PWord16 *table;
+
+
+
+ scale = 0;
+ move16();
+ fftlen2 = shr(fftlen,1);
+ fftlen4 = shr(fftlen,2);
+ fftlen8 = shr(fftlen,3);
+
+ /* Power Spectrum */
+ maxVal = 0;
+ move32();
+ len = sub(stop, start);
+ FOR (i=0; i < len; i++)
+ {
+ maxVal = L_max(maxVal, L_abs(powspec[i]));
+ }
+ s1 = norm_l(maxVal);
+ nf = L_shr_r(1099511680l/*1e-3f Q40*/,add(sub(powspec_exp,s1),9));
+
+ ptr = fftBuffer;
+ pti = fftBuffer+1;
+
+ FOR (i=0; i < start; i++)
+ {
+ *ptr = nf;
+ move32();
+ *pti = L_deposit_l(0);
+ ptr += 2;
+ pti += 2;
+ }
+
+ FOR ( ; i < stop; i++ )
+ {
+ *ptr = L_max( nf, L_shl(powspec[i-start], s1) );
+ move32();
+ *pti = L_deposit_l(0);
+ ptr += 2;
+ pti += 2;
+ }
+
+ FOR ( ; i < fftlen2; i++ )
+ {
+ *ptr = nf;
+ move32();
+ *pti = L_deposit_l(0);
+ ptr += 2;
+ pti += 2;
+ }
+
+ fftBuffer[1] = nf;
+ move32();
+
+ /* Pre-emphasis */
+
+ BASOP_getTables(&table, NULL, &step, fftlen4);
+ tmp = round_fx(L_shr(L_add(0x40000000, L_mult0(preemph_fac, preemph_fac)),1));
+ preemph_fac2 = shr(preemph_fac,1);
+ ptr = fftBuffer;
+ *ptr = Mpy_32_16_1( *ptr, sub( tmp, preemph_fac2 ) );
+ move32();
+ ptr += 2;
+ FOR ( i = 1; i < fftlen8; i++ )
+ {
+ move32();
+ *ptr = Mpy_32_16_1( *ptr, sub( tmp, mult_r(preemph_fac2,add(shr(table[i-1].v.re,1),shr(table[i].v.re,1)) ) ) );
+ ptr += 2;
+ }
+ move32();
+ *ptr = Mpy_32_16_1( *ptr, sub( tmp, mult_r(preemph_fac2,add(shr(table[fftlen8-1].v.re,1),shr(table[fftlen8-1].v.im,1)) ) ) );
+ ptr += 2;
+ FOR ( i = 1; i < fftlen8; i++ )
+ {
+ move32();
+ *ptr = Mpy_32_16_1( *ptr, sub( tmp, mult_r(preemph_fac2,add(shr(table[fftlen8-i-1].v.im,1),shr(table[fftlen8-i].v.im,1)) ) ) );
+ ptr += 2;
+ }
+ move32();
+ *ptr = Mpy_32_16_1( *ptr, tmp );
+ ptr += 2;
+ FOR ( i = 1; i < fftlen8; i++ )
+ {
+ move32();
+ *ptr = Mpy_32_16_1( *ptr, add( tmp, mult_r(preemph_fac2,add(shr(table[i-1].v.im,1),shr(table[i].v.im,1)) ) ) );
+ ptr += 2;
+ }
+ move32();
+ *ptr = Mpy_32_16_1( *ptr, add( tmp, mult_r(preemph_fac2,add(shr(table[fftlen8-1].v.re,1),shr(table[fftlen8-1].v.im,1)) ) ) );
+ ptr += 2;
+ FOR ( i = 1; i < fftlen8; i++ )
+ {
+ move32();
+ *ptr = Mpy_32_16_1( *ptr, add( tmp, mult_r(preemph_fac2,add(shr(table[fftlen8-i-1].v.re,1),shr(table[fftlen8-i].v.re,1)) ) ) );
+ ptr += 2;
+ }
+ move32();
+ fftBuffer[1] = Mpy_32_16_1( fftBuffer[1], add( tmp, preemph_fac2 ) );
+ maxVal = 0;
+ move32();
+ FOR (i=0; i < fftlen; i++)
+ {
+ maxVal = L_max(maxVal, L_abs(fftBuffer[i]));
+ }
+ s2 = norm_l(maxVal);
+ FOR (i=0; i < fftlen; i++)
+ {
+ fftBuffer[i] = L_shl( fftBuffer[i], s2 );
+ move32();
+ }
+
+ /* Autocorrelation */
+
+ BASOP_rfft(fftBuffer, fftlen, &scale, 1);
+
+ s3 = getScaleFactor32(fftBuffer, add(lpcorder,1));
+
+ FOR (i=0; i <= lpcorder; i++ )
+ {
+ r[i] = L_shl(fftBuffer[i], s3);
+ move32();
+ }
+
+ r[0] = Mpy_32_32( r[0], 1074278656l/*1.0005f Q30*/ );
+ move32();
+ FOR (i=1; i <= lpcorder; i++ )
+ {
+ r[i] = Mpy_32_32( r[i], 1073741824l/*1.f Q30*/ );
+ move32();
+ }
+ s3 = getScaleFactor32(r, add(lpcorder,1));
+
+ FOR (i=0; i <= lpcorder; i++ )
+ {
+ r[i] = L_shl(r[i], s3);
+ move32();
+ }
+
+ FOR (i=0; i <= lpcorder; i++ )
+ {
+ L_Extract(r[i], &r_h[i], &r_l[i]);
+ }
+
+ /* LPC */
+
+ E_LPC_lev_dur(r_h, r_l, A, NULL, lpcorder, NULL);
+
+}
+
+/*
+ msvq_decoder
+
+ Parameters:
+
+ cb i : Codebook (indexed cb[stages][levels][p]) format Q9.7
+ stages i : Number of stages
+ N i : Vector dimension
+ maxN i : Codebook vector dimension
+ Idx o : Indices
+ uq[] i : Quantized vector format Q9.7
+
+
+ Function:
+ multi stage vector dequantisation
+
+ Returns:
+ void
+*/
+void msvq_decoder (const Word16 *const cb[], /* i : Codebook (indexed cb[*stages][levels][p]) */
+ Word16 stages, /* i : Number of stages */
+ Word16 N, /* i : Vector dimension */
+ Word16 maxN, /* i : Codebook vector dimension */
+ Word16 Idx[], /* i : Indices */
+ Word16 *uq /* o : quantized vector */
+ )
+{
+ Word16 s, i, offset;
+
+
+
+ offset = i_mult(Idx[0], maxN);
+ FOR (i=0; iA_cng, Aq+i*(M+1), M+1 );
+ }
+
+ E_LPC_a_lsp_conversion( Aq, lsp_new, lsp_old, M );
+
+ IF( first_CNG == 0 )
+ {
+ Copy( lsp_old, lspCNG, M );
+ }
+ FOR( i=0; iexc_cng, exc, L_frame );
+ Copy( hs->exc_cng, exc2, L_frame );
+
+ IF( EQ_16(L_frame,L_FRAME))
+ {
+ interp_code_5over2_fx( exc2, bwe_exc, L_frame );
+ }
+ ELSE
+ {
+ interp_code_4over2_fx( exc2, bwe_exc, L_frame );
+ }
+}
+
diff --git a/lib_com/fft.c b/lib_com/fft.c
new file mode 100644
index 0000000000000000000000000000000000000000..9869909efb3e7ecb7dd6157f255b72cbde97eb85
--- /dev/null
+++ b/lib_com/fft.c
@@ -0,0 +1,2475 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "prot_fx.h"
+#include "basop_util.h"
+#include "rom_basop_util.h"
+#include "options.h"
+#include "stl.h"
+
+void fft16_with_cmplx_data( cmplx *pInp, Word16 bsacle);
+
+/**
+ * \brief Profiling / Precision results
+ *
+ * Profiling / Precision of complex valued FFTs: BASOP_cfft()
+ *
+ * WOPS BASOP Precision BASOP
+ * FFT5 87 16.96
+ * FFT8 108 17.04
+ * FFT10 194 16.70
+ * FFT15 354 16.97
+ * FFT16 288 16.62
+ * FFT20 368 16.06
+ * FFT30 828 16.80
+ * FFT32 752 15.45 (cplx mult mit 3 mult und 3 add)
+ * FFT32 824 16.07 (cplx mult mit 4 mult und 2 add)
+ * FFT64 ( 8x 8) 3.129 15.16
+ * FFT80 (10x 8) 4.385 15.55
+ * FFT100 (20x 5) 6.518 15.65
+ * FFT120 (15x 8) 7.029 15.38
+ * FFT128 (16x 8) 6.777 15.28
+ * FFT160 (20x 8) 9.033 14.95
+ * FFT240 (30x 8) 14.961 15.49
+ * FFT256 (32x 8) 14.905 14.61 (cplx mult mit 3 mult und 3 add)
+ * FFT256 (32x 8) 15.265 15.04 (cplx mult mit 4 mult und 2 add)
+ * FFT320 (20x16) 21.517 15.21
+ *
+ *
+ * Profiling / Precision of real valued FFTs / iFFTs: BASOP_rfft()
+ *
+ * WOPS BASOP Precision BASOP
+ * rFFT40 955 15.68
+ * rFFT64 1635 16.17
+ *
+ * irFFT40 1116 15.36
+ * irFFT64 1759 15.18
+ *
+ */
+
+
+#define Mpy_32_xx Mpy_32_16_1
+
+#define FFTC(x) WORD322WORD16((Word32)x)
+
+#define C31 (FFTC(0x91261468)) /* FL2WORD32( -0.86602540) -sqrt(3)/2 */
+
+#define C51 (FFTC(0x79bc3854)) /* FL2WORD32( 0.95105652) */
+#define C52 (FFTC(0x9d839db0)) /* FL2WORD32(-1.53884180/2) */
+#define C53 (FFTC(0xd18053ce)) /* FL2WORD32(-0.36327126) */
+#define C54 (FFTC(0x478dde64)) /* FL2WORD32( 0.55901699) */
+#define C55 (FFTC(0xb0000001)) /* FL2WORD32(-1.25/2) */
+
+#define C81 (FFTC(0x5a82799a)) /* FL2WORD32( 7.071067811865475e-1) */
+#define C82 (FFTC(0xa57d8666)) /* FL2WORD32(-7.071067811865475e-1) */
+
+#define C161 (FFTC(0x5a82799a)) /* FL2WORD32( 7.071067811865475e-1) INV_SQRT2 */
+#define C162 (FFTC(0xa57d8666)) /* FL2WORD32(-7.071067811865475e-1) -INV_SQRT2 */
+
+#define C163 (FFTC(0x7641af3d)) /* FL2WORD32( 9.238795325112867e-1) COS_PI_DIV8 */
+#define C164 (FFTC(0x89be50c3)) /* FL2WORD32(-9.238795325112867e-1) -COS_PI_DIV8 */
+
+#define C165 (FFTC(0x30fbc54d)) /* FL2WORD32( 3.826834323650898e-1) COS_3PI_DIV8 */
+#define C166 (FFTC(0xcf043ab3)) /* FL2WORD32(-3.826834323650898e-1) -COS_3PI_DIV8 */
+
+
+#define cplxMpy4_8_0(re,im,a,b,c,d) re = L_shr(L_sub(Mpy_32_xx(a,c),Mpy_32_xx(b,d)),1); \
+ im = L_shr(L_add(Mpy_32_xx(a,d),Mpy_32_xx(b,c)),1);
+
+#define cplxMpy4_8_1(re,im,a,b) re = L_shr(a,1); \
+ im = L_shr(b,1);
+
+
+
+
+/**
+ * \brief Function performs a complex 5-point FFT
+ * The FFT is performed inplace. The result of the FFT
+ * is scaled by SCALEFACTOR5 bits.
+ *
+ * WOPS with 32x16 bit multiplications: 88 cycles
+ *
+ * \param [i/o] re real input / output
+ * \param [i/o] im imag input / output
+ * \param [i ] s stride real and imag input / output
+ *
+ * \return void
+ */
+static void fft5_with_cmplx_data(cmplx *inp)
+{
+ cmplx x0,x1,x2,x3,x4;
+ cmplx y1,y2,y3,y4;
+ cmplx t;
+
+ x0 = CL_shr(inp[0],SCALEFACTOR5);
+ x1 = CL_shr(inp[1],SCALEFACTOR5);
+ x2 = CL_shr(inp[2],SCALEFACTOR5);
+ x3 = CL_shr(inp[3],SCALEFACTOR5);
+ x4 = CL_shr(inp[4],SCALEFACTOR5);
+
+ y1 = CL_add(x1,x4);
+ y4 = CL_sub(x1,x4);
+ y3 = CL_add(x2,x3);
+ y2 = CL_sub(x2,x3);
+ t = CL_scale_t(CL_sub(y1,y3),C54);
+ y1 = CL_add(y1,y3);
+ inp[0] = CL_add(x0,y1);
+
+ /* Bit shift left because of the constant C55 which was scaled with the factor 0.5 because of the representation of
+ the values as fracts */
+ y1 = CL_add(inp[0],(CL_shl(CL_scale_t(y1,C55),1)));
+ y3 = CL_sub(y1,t);
+ y1 = CL_add(y1,t);
+
+ t = CL_scale_t(CL_add(y4,y2),C51);
+ /* Bit shift left because of the constant C55 which was scaled with the factor 0.5 because of the representation of
+ the values as fracts */
+ y4 = CL_add(t,CL_shl(CL_scale_t(y4, C52),1));
+ y2 = CL_add(t,CL_scale_t(y2,C53));
+
+
+ /* combination */
+ inp[1] = CL_msu_j(y1,y2);
+ inp[4] = CL_mac_j(y1,y2);
+
+ inp[2] = CL_mac_j(y3,y4);
+ inp[3] = CL_msu_j(y3,y4);
+
+#if (WMOPS)
+ multiCounter[currCounter].CL_move += 5;
+#endif
+
+}
+
+/**
+ * \brief Function performs a complex 8-point FFT
+ * The FFT is performed inplace. The result of the FFT
+ * is scaled by SCALEFACTOR8 bits.
+ *
+ * WOPS with 32x16 bit multiplications: 108 cycles
+ *
+ * \param [i/o] re real input / output
+ * \param [i/o] im imag input / output
+ * \param [i ] s stride real and imag input / output
+ *
+ * \return void
+ */
+static void fft8_with_cmplx_data(cmplx *inp)
+{
+ cmplx x0, x1, x2, x3, x4, x5, x6, x7;
+ cmplx s0, s1, s2, s3, s4, s5, s6, s7;
+ cmplx t0, t1, t2, t3, t4, t5, t6, t7;
+
+ /* Pre-additions */
+ x0 = CL_shr(inp[0], SCALEFACTOR8);
+ x1 = CL_shr(inp[1], SCALEFACTOR8);
+ x2 = CL_shr(inp[2], SCALEFACTOR8);
+ x3 = CL_shr(inp[3], SCALEFACTOR8);
+ x4 = CL_shr(inp[4], SCALEFACTOR8);
+ x5 = CL_shr(inp[5], SCALEFACTOR8);
+ x6 = CL_shr(inp[6], SCALEFACTOR8);
+ x7 = CL_shr(inp[7], SCALEFACTOR8);
+
+ /* loops are unrolled */
+ {
+ t0 = CL_add(x0,x4);
+ t1 = CL_sub(x0,x4);
+
+ t2 = CL_add(x1,x5);
+ t3 = CL_sub(x1,x5);
+
+ t4 = CL_add(x2,x6);
+ t5 = CL_sub(x2,x6);
+
+ t6 = CL_add(x3,x7);
+ t7 = CL_sub(x3,x7);
+ }
+
+ /* Pre-additions and core multiplications */
+
+ s0 = CL_add(t0, t4);
+ s2 = CL_sub(t0, t4);
+
+ s4 = CL_mac_j(t1, t5);
+ s5 = CL_msu_j(t1, t5);
+
+ s1 = CL_add(t2, t6);
+ s3 = CL_sub(t2, t6);
+ s3 = CL_mul_j(s3);
+
+ t0 = CL_add(t3, t7);
+ t1 = CL_sub(t3, t7);
+
+ s6 = CL_scale_t(CL_msu_j(t1, t0), C81);
+ s7 = CL_dscale_t(CL_swap_real_imag(CL_msu_j(t0, t1)), C81, C82);
+
+ /* Post-additions */
+
+ inp[0] = CL_add(s0, s1);
+ inp[4] = CL_sub(s0, s1);
+
+ inp[2] = CL_sub(s2, s3);
+ inp[6] = CL_add(s2, s3);
+
+ inp[3] = CL_add(s4, s7);
+ inp[7] = CL_sub(s4, s7);
+
+ inp[1] = CL_add(s5, s6);
+ inp[5] = CL_sub(s5, s6);
+#if (WMOPS)
+ multiCounter[currCounter].CL_move += 8;
+#endif
+
+
+}
+
+
+/**
+ * \brief Function performs a complex 10-point FFT
+ * The FFT is performed inplace. The result of the FFT
+ * is scaled by SCALEFACTOR10 bits.
+ *
+ * WOPS with 32x16 bit multiplications: 196 cycles
+ *
+ * \param [i/o] re real input / output
+ * \param [i/o] im imag input / output
+ * \param [i ] s stride real and imag input / output
+ *
+ * \return void
+ */
+
+static void fft10_with_cmplx_data(cmplx *inp_data)
+{
+ cmplx r1,r2,r3,r4;
+ cmplx x0,x1,x2,x3,x4,t;
+ cmplx y[10];
+
+ /* FOR i=0 */
+ {
+ x0 = CL_shr(inp_data[0],SCALEFACTOR10);
+ x1 = CL_shr(inp_data[2],SCALEFACTOR10);
+ x2 = CL_shr(inp_data[4],SCALEFACTOR10);
+ x3 = CL_shr(inp_data[6],SCALEFACTOR10);
+ x4 = CL_shr(inp_data[8],SCALEFACTOR10);
+
+ r1 = CL_add(x3,x2);
+ r4 = CL_sub(x3,x2);
+ r3 = CL_add(x1,x4);
+ r2 = CL_sub(x1,x4);
+ t = CL_scale_t(CL_sub(r1,r3),C54);
+ r1 = CL_add(r1,r3);
+ y[0] = CL_add(x0,r1);
+ r1 = CL_add(y[0],(CL_shl(CL_scale_t(r1,C55),1)));
+ r3 = CL_sub(r1,t);
+ r1 = CL_add(r1,t);
+ t = CL_scale_t((CL_add(r4,r2)),C51);
+ r4 = CL_add(t,CL_shl(CL_scale_t(r4, C52),1));
+ r2 = CL_add(t,CL_scale_t(r2,C53));
+
+
+ y[2] = CL_msu_j(r1,r2);
+ y[8] = CL_mac_j(r1,r2);
+ y[4] = CL_mac_j(r3,r4);
+ y[6] = CL_msu_j(r3,r4);
+ }
+ /* FOR i=1 */
+ {
+ x0 = CL_shr(inp_data[5],SCALEFACTOR10);
+ x1 = CL_shr(inp_data[1],SCALEFACTOR10);
+ x2 = CL_shr(inp_data[3],SCALEFACTOR10);
+ x3 = CL_shr(inp_data[7],SCALEFACTOR10);
+ x4 = CL_shr(inp_data[9],SCALEFACTOR10);
+
+ r1 = CL_add(x1,x4);
+ r4 = CL_sub(x1,x4);
+ r3 = CL_add(x3,x2);
+ r2 = CL_sub(x3,x2);
+ t = CL_scale_t(CL_sub(r1,r3),C54);
+ r1 = CL_add(r1,r3);
+ y[1] = CL_add(x0,r1);
+ r1 = CL_add(y[1],(CL_shl(CL_scale_t(r1,C55),1)));
+ r3 = CL_sub(r1,t);
+ r1 = CL_add(r1,t);
+ t = CL_scale_t((CL_add(r4,r2)),C51);
+ r4 = CL_add(t,CL_shl(CL_scale_t(r4, C52),1));
+ r2 = CL_add(t,CL_scale_t(r2,C53));
+
+
+ y[3] = CL_msu_j(r1,r2);
+ y[9] = CL_mac_j(r1,r2);
+ y[5] = CL_mac_j(r3,r4);
+ y[7] = CL_msu_j(r3,r4);
+ }
+
+ /* FOR i=0 */
+ {
+ inp_data[0] = CL_add(y[0],y[1]);
+ inp_data[5] = CL_sub(y[0],y[1]);
+ }
+ /* FOR i=2 */
+ {
+ inp_data[2] = CL_add(y[2],y[3]);
+ inp_data[7] = CL_sub(y[2],y[3]);
+ }
+ /* FOR i=4 */
+ {
+ inp_data[4] = CL_add(y[4],y[5]);
+ inp_data[9] = CL_sub(y[4],y[5]);
+ }
+ /* FOR i=6 */
+ {
+ inp_data[6] = CL_add(y[6],y[7]);
+ inp_data[1] = CL_sub(y[6],y[7]);
+ }
+ /* FOR i=8 */
+ {
+ inp_data[8] = CL_add(y[8],y[9]);
+ inp_data[3] = CL_sub(y[8],y[9]);
+ }
+
+#if (WMOPS)
+ multiCounter[currCounter].CL_move += 10;
+#endif
+
+}
+
+
+/**
+ * \brief Function performs a complex 15-point FFT
+ * The FFT is performed inplace. The result of the FFT
+ * is scaled by SCALEFACTOR15 bits.
+ *
+ * WOPS with 32x16 bit multiplications: 354 cycles
+ *
+ * \param [i/o] re real input / output
+ * \param [i/o] im imag input / output
+ * \param [i ] s stride real and imag input / output
+ *
+ * \return void
+ */
+
+static void fft15_with_cmplx_data(cmplx *inp_data)
+{
+ cmplx c0,c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14;
+ cmplx c_z0,c_z1, c_z2, c_z3, c_z4, c_z5, c_z6, c_z7, c_z8, c_z9, c_z10, c_z11, c_z12, c_z13, c_z14;
+ cmplx c_y1,c_y2,c_y3,c_y4;
+ cmplx c_t;
+
+ c0 = CL_shr(inp_data[ 0],SCALEFACTOR15);
+ c1 = CL_shr(inp_data[ 3],SCALEFACTOR15);
+ c2 = CL_shr(inp_data[ 6],SCALEFACTOR15);
+ c3 = CL_shr(inp_data[ 9],SCALEFACTOR15);
+ c4 = CL_shr(inp_data[12],SCALEFACTOR15);
+ c5 = CL_shr(inp_data[ 5],SCALEFACTOR15);
+ c6 = CL_shr(inp_data[ 8],SCALEFACTOR15);
+ c7 = CL_shr(inp_data[11],SCALEFACTOR15);
+ c8 = CL_shr(inp_data[14],SCALEFACTOR15);
+ c9 = CL_shr(inp_data[ 2],SCALEFACTOR15);
+ c10 = CL_shr(inp_data[10],SCALEFACTOR15);
+ c11 = CL_shr(inp_data[13],SCALEFACTOR15);
+ c12 = CL_shr(inp_data[ 1],SCALEFACTOR15);
+ c13 = CL_shr(inp_data[ 4],SCALEFACTOR15);
+ c14 = CL_shr(inp_data[ 7],SCALEFACTOR15);
+
+ /* 1. FFT5 stage */
+ c_y1 = CL_add(c1,c4);
+ c_y4 = CL_sub(c1,c4);
+ c_y3 = CL_add(c2,c3);
+ c_y2 = CL_sub(c2,c3);
+ c_t = CL_scale_t(CL_sub(c_y1,c_y3),C54);
+ c_y1 = CL_add(c_y1,c_y3);
+ c_z0 = CL_add(c0,c_y1);
+ c_y1 = CL_add(c_z0,(CL_shl(CL_scale_t(c_y1,C55),1)));
+ c_y3 = CL_sub(c_y1,c_t);
+ c_y1 = CL_add(c_y1,c_t);
+ c_t = CL_scale_t(CL_add(c_y4,c_y2),C51);
+ c_y4 = CL_add(c_t,CL_shl(CL_scale_t(c_y4,C52),1));
+ c_y2 = CL_add(c_t,CL_scale_t(c_y2,C53));
+
+ /* combination */
+ c_z1 = CL_msu_j(c_y1,c_y2);
+ c_z2 = CL_mac_j(c_y3,c_y4);
+ c_z3 = CL_msu_j(c_y3,c_y4);
+ c_z4 = CL_mac_j(c_y1,c_y2);
+
+
+ /* 2. FFT5 stage */
+ c_y1 = CL_add(c6,c9);
+ c_y4 = CL_sub(c6,c9);
+ c_y3 = CL_add(c7,c8);
+ c_y2 = CL_sub(c7,c8);
+ c_t = CL_scale_t(CL_sub(c_y1,c_y3),C54);
+ c_y1 = CL_add(c_y1,c_y3);
+ c_z5 = CL_add(c5,c_y1);
+ c_y1 = CL_add(c_z5,(CL_shl(CL_scale_t(c_y1,C55),1)));
+ c_y3 = CL_sub(c_y1,c_t);
+ c_y1 = CL_add(c_y1,c_t);
+ c_t = CL_scale_t(CL_add(c_y4,c_y2),C51);
+ c_y4 = CL_add(c_t,CL_shl(CL_scale_t(c_y4,C52),1));
+ c_y2 = CL_add(c_t,CL_scale_t(c_y2,C53));
+ /* combination */
+ c_z6 = CL_msu_j(c_y1,c_y2);
+ c_z7 = CL_mac_j(c_y3,c_y4);
+ c_z8 = CL_msu_j(c_y3,c_y4);
+ c_z9 = CL_mac_j(c_y1,c_y2);
+
+
+ /* 3. FFT5 stage */
+
+ c_y1 = CL_add(c11,c14);
+ c_y4 = CL_sub(c11,c14);
+ c_y3 = CL_add(c12,c13);
+ c_y2 = CL_sub(c12,c13);
+ c_t = CL_scale_t(CL_sub(c_y1,c_y3),C54);
+ c_y1 = CL_add(c_y1,c_y3);
+ c_z10 = CL_add(c10,c_y1);
+ c_y1 = CL_add(c_z10,(CL_shl(CL_scale_t(c_y1,C55),1)));
+ c_y3 = CL_sub(c_y1,c_t);
+ c_y1 = CL_add(c_y1,c_t);
+ c_t = CL_scale_t(CL_add(c_y4,c_y2),C51);
+ c_y4 = CL_add(c_t,CL_shl(CL_scale_t(c_y4,C52),1));
+ c_y2 = CL_add(c_t,CL_scale_t(c_y2,C53));
+ /* combination */
+ c_z11 = CL_msu_j(c_y1,c_y2);
+ c_z12 = CL_mac_j(c_y3,c_y4);
+ c_z13 = CL_msu_j(c_y3,c_y4);
+ c_z14 = CL_mac_j(c_y1,c_y2);
+
+
+
+ /* 1. FFT3 stage */
+
+ c_y1 = CL_add(c_z5,c_z10);
+ c_y2 = CL_scale_t(CL_sub(c_z5,c_z10),C31);
+ inp_data[0] = CL_add(c_z0,c_y1);
+ c_y1 = CL_sub(c_z0,CL_shr(c_y1,1));
+ inp_data[10] = CL_mac_j(c_y1,c_y2);
+ inp_data[5] = CL_msu_j(c_y1,c_y2);
+
+ /* 2. FFT3 stage */
+ c_y1 = CL_add(c_z6,c_z11);
+ c_y2 = CL_scale_t(CL_sub(c_z6,c_z11),C31);
+ inp_data[6] = CL_add(c_z1,c_y1);
+ c_y1 = CL_sub(c_z1,CL_shr(c_y1,1));
+ inp_data[1] = CL_mac_j(c_y1,c_y2);
+ inp_data[11] = CL_msu_j(c_y1,c_y2);
+
+ /* 3. FFT3 stage */
+ c_y1 = CL_add(c_z7,c_z12);
+ c_y2 = CL_scale_t(CL_sub(c_z7,c_z12),C31);
+ inp_data[12] = CL_add(c_z2,c_y1);
+ c_y1 = CL_sub(c_z2,CL_shr(c_y1,1));
+ inp_data[7] = CL_mac_j(c_y1,c_y2);
+ inp_data[2] = CL_msu_j(c_y1,c_y2);
+
+
+ /* 4. FFT3 stage */
+ c_y1 = CL_add(c_z8,c_z13);
+ c_y2 = CL_scale_t(CL_sub(c_z8,c_z13),C31);
+ inp_data[3] = CL_add(c_z3,c_y1);
+ c_y1 = CL_sub(c_z3,CL_shr(c_y1,1));
+ inp_data[13] = CL_mac_j(c_y1,c_y2);
+ inp_data[8] = CL_msu_j(c_y1,c_y2);
+
+
+ /* 5. FFT3 stage */
+ c_y1 = CL_add(c_z9,c_z14);
+ c_y2 = CL_scale_t(CL_sub(c_z9,c_z14),C31);
+ inp_data[9] = CL_add(c_z4,c_y1);
+ c_y1 = CL_sub(c_z4,CL_shr(c_y1,1));
+ inp_data[4] = CL_mac_j(c_y1,c_y2);
+ inp_data[14] = CL_msu_j(c_y1,c_y2);
+
+#if (WMOPS)
+ multiCounter[currCounter].CL_move += 15;
+#endif
+
+}
+
+
+/**
+ * \brief Function performs a complex 16-point FFT
+ * The FFT is performed inplace. The result of the FFT
+ * is scaled by SCALEFACTOR16 bits.
+ *
+ * WOPS with 32x16 bit multiplications (scale on ): 288 cycles
+ * WOPS with 32x16 bit multiplications (scale off): 256 cycles
+ *
+ * \param [i/o] re real input / output
+ * \param [i/o] im imag input / output
+ * \param [i ] s stride real and imag input / output
+ *
+ * \return void
+ */
+void fft16(Word32 *re, Word32 *im, Word16 s, Word16 bScale)
+{
+ int i;
+ if ( s == 2 )
+ {
+ fft16_with_cmplx_data( (cmplx *) re, bScale );
+ }
+ else
+ {
+ cmplx inp_data[16];
+ FOR(i=0; i<16; i++)
+ {
+ inp_data[i] = CL_form(re[s*i], im[s*i]);
+ }
+ fft16_with_cmplx_data(inp_data, bScale );
+ FOR(i=0; i<16; i++)
+ {
+ re[s*i] = CL_Extract_real(inp_data[i]);
+ im[s*i] = CL_Extract_imag(inp_data[i]);
+ }
+ }
+}
+
+void fft16_with_cmplx_data(cmplx *input, Word16 bScale )
+{
+ cmplx x0, x1, x2, x3, temp;
+ cmplx t0,t2,t4,t6,t7;
+ cmplx y[16];
+
+ IF (bScale)
+ {
+ {
+ x0 = CL_shr(input[0],SCALEFACTOR16);
+ x1 = CL_shr(input[4],SCALEFACTOR16);
+ x2 = CL_shr(input[8],SCALEFACTOR16);
+ x3 = CL_shr(input[12],SCALEFACTOR16);
+ t0 = CL_add(x0,x2);
+ t2 = CL_sub(x0,x2);
+ t4 = CL_add(x1,x3);
+ t6 = CL_sub(x1,x3);
+ t6 = CL_mul_j(t6);
+ y[0] = CL_add(t0,t4);
+ y[1] = CL_sub(t2,t6);
+ y[2] = CL_sub(t0,t4);
+ y[3] = CL_add(t2,t6);
+
+
+ x0 = CL_shr(input[1],SCALEFACTOR16);
+ x1 = CL_shr(input[5],SCALEFACTOR16);
+ x2 = CL_shr(input[9],SCALEFACTOR16);
+ x3 = CL_shr(input[13],SCALEFACTOR16);
+ t0 = CL_add(x0,x2);
+ t2 = CL_sub(x0,x2);
+ t4 = CL_add(x1,x3);
+ t6 = CL_sub(x1,x3);
+ t6 = CL_mul_j(t6);
+ y[4] = CL_add(t0,t4);
+ y[5] = CL_sub(t2,t6);
+ y[6] = CL_sub(t0,t4);
+ y[7] = CL_add(t2,t6);
+
+
+ x0 = CL_shr(input[2],SCALEFACTOR16);
+ x1 = CL_shr(input[6],SCALEFACTOR16);
+ x2 = CL_shr(input[10],SCALEFACTOR16);
+ x3 = CL_shr(input[14],SCALEFACTOR16);
+ t0 = CL_add(x0,x2);
+ t2 = CL_sub(x0,x2);
+ t4 = CL_add(x1,x3);
+ t6 = CL_sub(x1,x3);
+ t6 = CL_mul_j(t6);
+ y[8] = CL_add(t0,t4);
+ y[9] = CL_sub(t2,t6);
+ y[10] = CL_sub(t4,t0);
+ y[10] = CL_mul_j(y[10]);
+ y[11] = CL_add(t2,t6);
+
+
+ x0 = CL_shr(input[3],SCALEFACTOR16);
+ x1 = CL_shr(input[7],SCALEFACTOR16);
+ x2 = CL_shr(input[11],SCALEFACTOR16);
+ x3 = CL_shr(input[15],SCALEFACTOR16);
+ t0 = CL_add(x0,x2);
+ t2 = CL_sub(x0,x2);
+ t4 = CL_add(x1,x3);
+ t6 = CL_sub(x1,x3);
+ t6 = CL_mul_j(t6);
+ y[12] = CL_add(t0,t4);
+ y[13] = CL_sub(t2,t6);
+ y[14] = CL_sub(t0,t4);
+ y[15] = CL_add(t2,t6);
+ }
+ }
+ else
+ {
+ {
+ t0 = CL_add(input[ 0],input[ 8]);
+ t2 = CL_sub(input[ 0],input[ 8]);
+ t4 = CL_add(input[ 4],input[12]);
+ t7 = CL_sub(input[ 4],input[12]);
+
+ y[0] = CL_add(t0,t4);
+ y[1] = CL_msu_j(t2,t7);
+ y[2] = CL_sub(t0,t4);
+ y[3] = CL_mac_j(t2,t7);
+ }
+ /* i=1 */
+ {
+ t0 = CL_add(input[ 1],input[ 9]);
+ t2 = CL_sub(input[ 1],input[ 9]);
+ t4 = CL_add(input[ 5],input[13]);
+ t7 = CL_sub(input[ 5],input[13]);
+
+ y[4] = CL_add(t0,t4);
+ y[5] = CL_msu_j(t2,t7);
+ y[6] = CL_sub(t0,t4);
+ y[7] = CL_mac_j(t2,t7);
+ }
+ /* i=2 */
+ {
+ t0 = CL_add(input[ 2],input[ 10]);
+ t2 = CL_sub(input[ 2],input[ 10]);
+ t4 = CL_add(input[ 6],input[14]);
+ t7 = CL_sub(input[ 6],input[14]);
+
+ y[8] = CL_add(t0,t4);
+ y[9] = CL_msu_j(t2,t7);
+ temp = CL_sub(t0,t4);
+ y[10] = CL_negate(CL_mul_j(temp));
+ y[11] = CL_mac_j(t2,t7);
+ }
+ /* i=3 */
+ {
+ t0 = CL_add(input[ 3],input[ 11]);
+ t2 = CL_sub(input[ 3],input[ 11]);
+ t4 = CL_add(input[ 7],input[15]);
+ t7 = CL_sub(input[ 7],input[15]);
+
+ y[12] = CL_add(t0,t4);
+ y[13] = CL_msu_j(t2,t7);
+ y[14] = CL_sub(t0,t4);
+ y[15] = CL_mac_j(t2,t7);
+ }
+
+ }
+
+ x0 = CL_scale_t(y[11],C162);
+ y[11] = CL_mac_j(x0,x0);
+
+ x0 = CL_scale_t(y[14],C162);
+ y[14] = CL_mac_j(x0,x0);
+
+ x0 = CL_scale_t(y[6],C161);
+ y[6] = CL_msu_j(x0,x0);
+
+ x0 = CL_scale_t(y[9],C161);
+ y[9] = CL_msu_j(x0,x0);
+
+ y[5] = CL_mac_j(CL_scale_t(y[5], C163), CL_scale_t(y[5], C166));
+ y[7] = CL_mac_j(CL_scale_t(y[7], C165), CL_scale_t(y[7], C164));
+ y[13] = CL_mac_j(CL_scale_t(y[13], C165), CL_scale_t(y[13], C164));
+ y[15] = CL_mac_j(CL_scale_t(y[15], C164), CL_scale_t(y[15], C165));
+
+
+ /* i=0 */
+ {
+ t0 = CL_add(y[ 0],y[ 8]);
+ t2 = CL_sub(y[ 0],y[ 8]);
+ t4 = CL_add(y[ 4],y[12]);
+ t7 = CL_sub(y[ 4],y[12]);
+
+ input[0] = CL_add(t0,t4);
+ input[4] = CL_msu_j(t2,t7);
+ input[8] = CL_sub(t0,t4);
+ input[12] = CL_mac_j(t2,t7);
+ }
+ /* i=1 */
+ {
+ t0 = CL_add(y[ 1],y[ 9]);
+ t2 = CL_sub(y[ 1],y[ 9]);
+ t4 = CL_add(y[ 5],y[13]);
+ t7 = CL_sub(y[ 5],y[13]);
+
+ input[1] = CL_add(t0,t4);
+ input[5] = CL_msu_j(t2,t7);
+ input[9] = CL_sub(t0,t4);
+ input[13] = CL_mac_j(t2,t7);
+ }
+ /* i=2 */
+ {
+ t0 = CL_add(y[ 2],y[ 10]);
+ t2 = CL_sub(y[ 2],y[ 10]);
+ t4 = CL_add(y[ 6],y[14]);
+ t7 = CL_sub(y[ 6],y[14]);
+
+ input[2] = CL_add(t0,t4);
+ input[6] = CL_msu_j(t2,t7);
+ input[10] = CL_sub(t0,t4);
+ input[14] = CL_mac_j(t2,t7);
+ }
+ /* i=3 */
+ {
+ t0 = CL_add(y[ 3],y[ 11]);
+ t2 = CL_sub(y[ 3],y[ 11]);
+ t4 = CL_add(y[ 7],y[15]);
+ t7 = CL_sub(y[ 7],y[15]);
+
+ input[3] = CL_add(t0,t4);
+ input[7] = CL_msu_j(t2,t7);
+ input[11] = CL_sub(t0,t4);
+ input[15] = CL_mac_j(t2,t7);
+ }
+#if (WMOPS)
+ multiCounter[currCounter].CL_move += 16;
+#endif
+
+}
+
+
+/**
+ * \brief Function performs a complex 20-point FFT
+ * The FFT is performed inplace. The result of the FFT
+ * is scaled by SCALEFACTOR20 bits.
+ *
+ * WOPS with 32x16 bit multiplications: 432 cycles
+ *
+ * \param [i/o] re real input / output
+ * \param [i/o] im imag input / output
+ * \param [i ] s stride real and imag input / output
+ *
+ * \return void
+ */
+static void fft20_with_cmplx_data(cmplx *inp_data)
+{
+ cmplx r1,r2,r3,r4;
+ cmplx x0,x1,x2,x3,x4;
+ cmplx t,t0,t1,t2,t3;
+ cmplx y[20];
+ cmplx *y0, *y1,*y2,*y3,*y4;
+
+ y0 = y;
+ y1 = &y[4];
+ y2 = &y[16];
+ y3 = &y[8];
+ y4 = &y[12];
+
+ {
+ x0 = CL_shr(inp_data[0],SCALEFACTOR20);
+ x1 = CL_shr(inp_data[16],SCALEFACTOR20);
+ x2 = CL_shr(inp_data[12],SCALEFACTOR20);
+ x3 = CL_shr(inp_data[8],SCALEFACTOR20);
+ x4 = CL_shr(inp_data[4],SCALEFACTOR20);
+
+ r4 = CL_sub(x1,x4);
+ r2 = CL_sub(x2,x3);
+ r1 = CL_add(x1,x4);
+ r3 = CL_add(x2,x3);
+ t = CL_scale_t(CL_sub(r1,r3),C54);
+ r1 = CL_add(r1,r3);
+ y0[0] = CL_add(x0,r1);
+ r1 = CL_add(y0[0],(CL_shl(CL_scale_t(r1,C55),1)));
+ r3 = CL_sub(r1,t);
+ r1 = CL_add(r1,t);
+ t = CL_scale_t((CL_add(r4,r2)),C51);
+ r4 = CL_add(t,CL_shl(CL_scale_t(r4, C52),1));
+ r2 = CL_add(t,CL_scale_t(r2,C53));
+
+
+ y1[0] = CL_msu_j(r1,r2);
+ y2[0] = CL_mac_j(r1,r2);
+ y3[0] = CL_mac_j(r3,r4);
+ y4[0] = CL_msu_j(r3,r4);
+ }
+ {
+ x0 = CL_shr(inp_data[5],SCALEFACTOR20);
+ x1 = CL_shr(inp_data[1],SCALEFACTOR20);
+ x2 = CL_shr(inp_data[17],SCALEFACTOR20);
+ x3 = CL_shr(inp_data[13],SCALEFACTOR20);
+ x4 = CL_shr(inp_data[9],SCALEFACTOR20);
+
+ r4 = CL_sub(x1,x4);
+ r2 = CL_sub(x2,x3);
+ r1 = CL_add(x1,x4);
+ r3 = CL_add(x2,x3);
+ t = CL_scale_t(CL_sub(r1,r3),C54);
+ r1 = CL_add(r1,r3);
+ y0[1] = CL_add(x0,r1);
+ r1 = CL_add(y0[1],(CL_shl(CL_scale_t(r1,C55),1)));
+ r3 = CL_sub(r1,t);
+ r1 = CL_add(r1,t);
+ t = CL_scale_t((CL_add(r4,r2)),C51);
+ r4 = CL_add(t,CL_shl(CL_scale_t(r4, C52),1));
+ r2 = CL_add(t,CL_scale_t(r2,C53));
+
+
+ y1[1] = CL_msu_j(r1,r2);
+ y2[1] = CL_mac_j(r1,r2);
+ y3[1] = CL_mac_j(r3,r4);
+ y4[1] = CL_msu_j(r3,r4);
+ }
+ {
+ x0 = CL_shr(inp_data[10],SCALEFACTOR20);
+ x1 = CL_shr(inp_data[6],SCALEFACTOR20);
+ x2 = CL_shr(inp_data[2],SCALEFACTOR20);
+ x3 = CL_shr(inp_data[18],SCALEFACTOR20);
+ x4 = CL_shr(inp_data[14],SCALEFACTOR20);
+
+ r4 = CL_sub(x1,x4);
+ r2 = CL_sub(x2,x3);
+ r1 = CL_add(x1,x4);
+ r3 = CL_add(x2,x3);
+ t = CL_scale_t(CL_sub(r1,r3),C54);
+ r1 = CL_add(r1,r3);
+ y0[2] = CL_add(x0,r1);
+ r1 = CL_add(y0[2],(CL_shl(CL_scale_t(r1,C55),1)));
+ r3 = CL_sub(r1,t);
+ r1 = CL_add(r1,t);
+ t = CL_scale_t((CL_add(r4,r2)),C51);
+ r4 = CL_add(t,CL_shl(CL_scale_t(r4, C52),1));
+ r2 = CL_add(t,CL_scale_t(r2,C53));
+
+
+ y1[2] = CL_msu_j(r1,r2);
+ y2[2] = CL_mac_j(r1,r2);
+ y3[2] = CL_mac_j(r3,r4);
+ y4[2] = CL_msu_j(r3,r4);
+ }
+ {
+ x0 = CL_shr(inp_data[15],SCALEFACTOR20);
+ x1 = CL_shr(inp_data[11],SCALEFACTOR20);
+ x2 = CL_shr(inp_data[7],SCALEFACTOR20);
+ x3 = CL_shr(inp_data[3],SCALEFACTOR20);
+ x4 = CL_shr(inp_data[19],SCALEFACTOR20);
+
+ r4 = CL_sub(x1,x4);
+ r2 = CL_sub(x2,x3);
+ r1 = CL_add(x1,x4);
+ r3 = CL_add(x2,x3);
+ t = CL_scale_t(CL_sub(r1,r3),C54);
+ r1 = CL_add(r1,r3);
+ y0[3] = CL_add(x0,r1);
+ r1 = CL_add(y0[3],(CL_shl(CL_scale_t(r1,C55),1)));
+ r3 = CL_sub(r1,t);
+ r1 = CL_add(r1,t);
+ t = CL_scale_t((CL_add(r4,r2)),C51);
+ r4 = CL_add(t,CL_shl(CL_scale_t(r4, C52),1));
+ r2 = CL_add(t,CL_scale_t(r2,C53));
+
+
+ y1[3] = CL_msu_j(r1,r2);
+ y2[3] = CL_mac_j(r1,r2);
+ y3[3] = CL_mac_j(r3,r4);
+ y4[3] = CL_msu_j(r3,r4);
+ }
+
+ {
+ cmplx * ptr_y = y;
+ {
+ cmplx Cy0, Cy1, Cy2, Cy3;
+
+ Cy0 = *ptr_y++;
+ Cy1 = *ptr_y++;
+ Cy2 = *ptr_y++;
+ Cy3 = *ptr_y++;
+
+ /* Pre-additions */
+ t0 = CL_add(Cy0,Cy2);
+ t1 = CL_sub(Cy0,Cy2);
+ t2 = CL_add(Cy1,Cy3);
+ t3 = CL_sub(Cy1,Cy3);
+
+
+ inp_data[0] = CL_add(t0,t2);
+ inp_data[5] = CL_msu_j(t1,t3);
+ inp_data[10] = CL_sub(t0,t2);
+ inp_data[15] = CL_mac_j(t1,t3);
+ }
+
+ {
+ cmplx Cy0, Cy1, Cy2, Cy3;
+
+ Cy0 = *ptr_y++;
+ Cy1 = *ptr_y++;
+ Cy2 = *ptr_y++;
+ Cy3 = *ptr_y++;
+
+ /* Pre-additions */
+ t0 = CL_add(Cy0,Cy2);
+ t1 = CL_sub(Cy0,Cy2);
+ t2 = CL_add(Cy1,Cy3);
+ t3 = CL_sub(Cy1,Cy3);
+
+
+ inp_data[4] = CL_add(t0,t2);
+ inp_data[9] = CL_msu_j(t1,t3);
+ inp_data[14] = CL_sub(t0,t2);
+ inp_data[19] = CL_mac_j(t1,t3);
+ }
+
+ {
+ cmplx Cy0, Cy1, Cy2, Cy3;
+
+ Cy0 = *ptr_y++;
+ Cy1 = *ptr_y++;
+ Cy2 = *ptr_y++;
+ Cy3 = *ptr_y++;
+
+ /* Pre-additions */
+ t0 = CL_add(Cy0,Cy2);
+ t1 = CL_sub(Cy0,Cy2);
+ t2 = CL_add(Cy1,Cy3);
+ t3 = CL_sub(Cy1,Cy3);
+
+
+ inp_data[8] = CL_add(t0,t2);
+ inp_data[13] = CL_msu_j(t1,t3);
+ inp_data[18] = CL_sub(t0,t2);
+ inp_data[3] = CL_mac_j(t1,t3);
+ }
+
+ {
+ cmplx Cy0, Cy1, Cy2, Cy3;
+
+ Cy0 = *ptr_y++;
+ Cy1 = *ptr_y++;
+ Cy2 = *ptr_y++;
+ Cy3 = *ptr_y++;
+
+ /* Pre-additions */
+ t0 = CL_add(Cy0,Cy2);
+ t1 = CL_sub(Cy0,Cy2);
+ t2 = CL_add(Cy1,Cy3);
+ t3 = CL_sub(Cy1,Cy3);
+
+ inp_data[12] = CL_add(t0,t2);
+ inp_data[17] = CL_msu_j(t1,t3);
+ inp_data[2] = CL_sub(t0,t2);
+ inp_data[7] = CL_mac_j(t1,t3);
+ }
+
+ {
+ cmplx Cy0, Cy1, Cy2, Cy3;
+
+ Cy0 = *ptr_y++;
+ Cy1 = *ptr_y++;
+ Cy2 = *ptr_y++;
+ Cy3 = *ptr_y++;
+
+ /* Pre-additions */
+ t0 = CL_add(Cy0,Cy2);
+ t1 = CL_sub(Cy0,Cy2);
+ t2 = CL_add(Cy1,Cy3);
+ t3 = CL_sub(Cy1,Cy3);
+
+
+ inp_data[16] = CL_add(t0,t2);
+ inp_data[1] = CL_msu_j(t1,t3);
+ inp_data[6] = CL_sub(t0,t2);
+ inp_data[11] = CL_mac_j(t1,t3);
+ }
+ }
+#if (WMOPS)
+ multiCounter[currCounter].CL_move += 20;
+#endif
+
+}
+
+
+/**
+ * \brief Function performs a complex 30-point FFT
+ * The FFT is performed inplace. The result of the FFT
+ * is scaled by SCALEFACTOR30 bits.
+ *
+ * WOPS with 32x16 bit multiplications: 828 cycles
+ *
+ * \param [i/o] re real input / output
+ * \param [i/o] im imag input / output
+ * \param [i ] s stride real and imag input / output
+ *
+ * \return void
+ */
+
+static void fft30_with_cmplx_data(cmplx * inp)
+{
+ cmplx *l = &inp[0];
+ cmplx *h = &inp[15];
+
+ cmplx z[30], y[15], x[15], rs1, rs2, rs3, rs4, t;
+
+ /* 1. FFT15 stage */
+
+ x[0] = CL_shr(inp[0],SCALEFACTOR30_1);
+ x[1] = CL_shr(inp[18],SCALEFACTOR30_1);
+ x[2] = CL_shr(inp[6],SCALEFACTOR30_1);
+ x[3] = CL_shr(inp[24],SCALEFACTOR30_1);
+ x[4] = CL_shr(inp[12],SCALEFACTOR30_1);
+
+ x[5] = CL_shr(inp[20],SCALEFACTOR30_1);
+ x[6] = CL_shr(inp[8],SCALEFACTOR30_1);
+ x[7] = CL_shr(inp[26],SCALEFACTOR30_1);
+ x[8] = CL_shr(inp[14],SCALEFACTOR30_1);
+ x[9] = CL_shr(inp[2],SCALEFACTOR30_1);
+
+ x[10] = CL_shr(inp[10],SCALEFACTOR30_1);
+ x[11] = CL_shr(inp[28],SCALEFACTOR30_1);
+ x[12] = CL_shr(inp[16],SCALEFACTOR30_1);
+ x[13] = CL_shr(inp[4],SCALEFACTOR30_1);
+ x[14] = CL_shr(inp[22],SCALEFACTOR30_1);
+
+
+ /* 1. FFT5 stage */
+ rs1 = CL_add(x[1],x[4]);
+ rs4 = CL_sub(x[1],x[4]);
+ rs3 = CL_add(x[2],x[3]);
+ rs2 = CL_sub(x[2],x[3]);
+ t = CL_scale_t(CL_sub(rs1,rs3),C54);
+ rs1 = CL_add(rs1,rs3);
+ y[0] = CL_add(x[0],rs1);
+ rs1 = CL_add(y[0],(CL_shl(CL_scale_t(rs1,C55),1)));
+ rs3 = CL_sub(rs1,t);
+ rs1 = CL_add(rs1,t);
+ t = CL_scale_t(CL_add(rs4,rs2),C51);
+ rs4 = CL_add(t,CL_shl(CL_scale_t(rs4, C52),1));
+ rs2 = CL_add(t,CL_scale_t(rs2,C53));
+
+ /* combination */
+ y[1] = CL_msu_j(rs1,rs2);
+ y[4] = CL_mac_j(rs1,rs2);
+ y[2] = CL_mac_j(rs3,rs4);
+ y[3] = CL_msu_j(rs3,rs4);
+
+
+ /* 2. FFT5 stage */
+ rs1 = CL_add(x[6],x[9]);
+ rs4 = CL_sub(x[6],x[9]);
+ rs3 = CL_add(x[7],x[8]);
+ rs2 = CL_sub(x[7],x[8]);
+ t = CL_scale_t(CL_sub(rs1,rs3),C54);
+ rs1 = CL_add(rs1,rs3);
+ y[5] = CL_add(x[5],rs1);
+ rs1 = CL_add(y[5],(CL_shl(CL_scale_t(rs1,C55),1)));
+ rs3 = CL_sub(rs1,t);
+ rs1 = CL_add(rs1,t);
+ t = CL_scale_t(CL_add(rs4,rs2),C51);
+ rs4 = CL_add(t,CL_shl(CL_scale_t(rs4, C52),1));
+ rs2 = CL_add(t,CL_scale_t(rs2,C53));
+
+ /* combination */
+ y[6] = CL_msu_j(rs1,rs2);
+ y[9] = CL_mac_j(rs1,rs2);
+ y[7] = CL_mac_j(rs3,rs4);
+ y[8] = CL_msu_j(rs3,rs4);
+
+
+ /* 3. FFT5 stage */
+ rs1 = CL_add(x[11],x[14]);
+ rs4 = CL_sub(x[11],x[14]);
+ rs3 = CL_add(x[12],x[13]);
+ rs2 = CL_sub(x[12],x[13]);
+ t = CL_scale_t(CL_sub(rs1,rs3),C54);
+ rs1 = CL_add(rs1,rs3);
+ y[10] = CL_add(x[10],rs1);
+ rs1 = CL_add(y[10],(CL_shl(CL_scale_t(rs1,C55),1)));
+ rs3 = CL_sub(rs1,t);
+ rs1 = CL_add(rs1,t);
+ t = CL_scale_t(CL_add(rs4,rs2),C51);
+ rs4 = CL_add(t,CL_shl(CL_scale_t(rs4, C52),1));
+ rs2 = CL_add(t,CL_scale_t(rs2,C53));
+
+ /* combination */
+ y[11] = CL_msu_j(rs1,rs2);
+ y[14] = CL_mac_j(rs1,rs2);
+ y[12] = CL_mac_j(rs3,rs4);
+ y[13] = CL_msu_j(rs3,rs4);
+ /*for (i=10; i<15; i++)
+ {
+ printf("%d,\t %d,\t",y[i].re, y[i].im);
+ }
+ printf("\n\n");*/
+
+
+ /* 1. FFT3 stage */
+ /* real part */
+ rs1 = CL_add(y[5],y[10]);
+ rs2 = CL_scale_t(CL_sub(y[5],y[10]),C31);
+ z[0] = CL_add(y[0],rs1);
+ rs1 = CL_sub(y[0],CL_shr(rs1,1));
+
+ z[10] = CL_mac_j(rs1,rs2);
+ z[5] = CL_msu_j(rs1,rs2);
+
+ /* 2. FFT3 stage */
+ rs1 = CL_add(y[6],y[11]);
+ rs2 = CL_scale_t(CL_sub(y[6],y[11]),C31);
+ z[6] = CL_add(y[1],rs1);
+ rs1 = CL_sub(y[1],CL_shr(rs1,1));
+
+ z[1] = CL_mac_j(rs1,rs2);
+ z[11] = CL_msu_j(rs1,rs2);
+
+
+ /* 3. FFT3 stage */
+ rs1 = CL_add(y[7],y[12]);
+ rs2 = CL_scale_t(CL_sub(y[7],y[12]),C31);
+ z[12] = CL_add(y[2],rs1);
+ rs1 = CL_sub(y[2],CL_shr(rs1,1));
+
+ z[7] = CL_mac_j(rs1,rs2);
+ z[2] = CL_msu_j(rs1,rs2);
+
+
+ /* 4. FFT3 stage */
+ rs1 = CL_add(y[8],y[13]);
+ rs2 = CL_scale_t(CL_sub(y[8],y[13]),C31);
+ z[3] = CL_add(y[3],rs1);
+ rs1 = CL_sub(y[3],CL_shr(rs1,1));
+
+ z[13] = CL_mac_j(rs1,rs2);
+ z[8] = CL_msu_j(rs1,rs2);
+
+
+ /* 5. FFT3 stage */
+ rs1 = CL_add(y[9],y[14]);
+ rs2 = CL_scale_t(CL_sub(y[9],y[14]),C31);
+ z[9] = CL_add(y[4],rs1);
+ rs1 = CL_sub(y[4],CL_shr(rs1,1));
+
+ z[4] = CL_mac_j(rs1,rs2);
+ z[14] = CL_msu_j(rs1,rs2);
+
+ /*for (i=0; i<15; i++)
+ printf("%d,\t %d,\t",z[i].re, z[i].im);
+ printf("\n\n");*/
+
+
+ /* 2. FFT15 stage */
+
+ x[0] = CL_shr(inp[15],SCALEFACTOR30_1);
+ x[1] = CL_shr(inp[3],SCALEFACTOR30_1);
+ x[2] = CL_shr(inp[21],SCALEFACTOR30_1);
+ x[3] = CL_shr(inp[9],SCALEFACTOR30_1);
+ x[4] = CL_shr(inp[27],SCALEFACTOR30_1);
+
+ x[5] = CL_shr(inp[5],SCALEFACTOR30_1);
+ x[6] = CL_shr(inp[23],SCALEFACTOR30_1);
+ x[7] = CL_shr(inp[11],SCALEFACTOR30_1);
+ x[8] = CL_shr(inp[29],SCALEFACTOR30_1);
+ x[9] = CL_shr(inp[17],SCALEFACTOR30_1);
+
+ x[10] = CL_shr(inp[25],SCALEFACTOR30_1);
+ x[11] = CL_shr(inp[13],SCALEFACTOR30_1);
+ x[12] = CL_shr(inp[1],SCALEFACTOR30_1);
+ x[13] = CL_shr(inp[19],SCALEFACTOR30_1);
+ x[14] = CL_shr(inp[7],SCALEFACTOR30_1);
+
+ /* 1. FFT5 stage */
+ rs1 = CL_add(x[1],x[4]);
+ rs4 = CL_sub(x[1],x[4]);
+ rs3 = CL_add(x[2],x[3]);
+ rs2 = CL_sub(x[2],x[3]);
+ t = CL_scale_t(CL_sub(rs1,rs3),C54);
+ rs1 = CL_add(rs1,rs3);
+ y[0] = CL_add(x[0],rs1);
+ rs1 = CL_add(y[0],(CL_shl(CL_scale_t(rs1,C55),1)));
+ rs3 = CL_sub(rs1,t);
+ rs1 = CL_add(rs1,t);
+ t = CL_scale_t(CL_add(rs4,rs2),C51);
+ rs4 = CL_add(t,CL_shl(CL_scale_t(rs4, C52),1));
+ rs2 = CL_add(t,CL_scale_t(rs2,C53));
+
+ /* combination */
+ y[1] = CL_msu_j(rs1,rs2);
+ y[4] = CL_mac_j(rs1,rs2);
+ y[2] = CL_mac_j(rs3,rs4);
+ y[3] = CL_msu_j(rs3,rs4);
+
+
+ /* 2. FFT5 stage */
+ rs1 = CL_add(x[6],x[9]);
+ rs4 = CL_sub(x[6],x[9]);
+ rs3 = CL_add(x[7],x[8]);
+ rs2 = CL_sub(x[7],x[8]);
+ t = CL_scale_t(CL_sub(rs1,rs3),C54);
+ rs1 = CL_add(rs1,rs3);
+ y[5] = CL_add(x[5],rs1);
+ rs1 = CL_add(y[5],(CL_shl(CL_scale_t(rs1,C55),1)));
+ rs3 = CL_sub(rs1,t);
+ rs1 = CL_add(rs1,t);
+ t = CL_scale_t(CL_add(rs4,rs2),C51);
+ rs4 = CL_add(t,CL_shl(CL_scale_t(rs4, C52),1));
+ rs2 = CL_add(t,CL_scale_t(rs2,C53));
+
+ /* combination */
+ y[6] = CL_msu_j(rs1,rs2);
+ y[9] = CL_mac_j(rs1,rs2);
+ y[7] = CL_mac_j(rs3,rs4);
+ y[8] = CL_msu_j(rs3,rs4);
+
+
+ /* 3. FFT5 stage */
+ rs1 = CL_add(x[11],x[14]);
+ rs4 = CL_sub(x[11],x[14]);
+ rs3 = CL_add(x[12],x[13]);
+ rs2 = CL_sub(x[12],x[13]);
+ t = CL_scale_t(CL_sub(rs1,rs3),C54);
+ rs1 = CL_add(rs1,rs3);
+ y[10] = CL_add(x[10],rs1);
+ rs1 = CL_add(y[10],(CL_shl(CL_scale_t(rs1,C55),1)));
+ rs3 = CL_sub(rs1,t);
+ rs1 = CL_add(rs1,t);
+ t = CL_scale_t(CL_add(rs4,rs2),C51);
+ rs4 = CL_add(t,CL_shl(CL_scale_t(rs4, C52),1));
+ rs2 = CL_add(t,CL_scale_t(rs2,C53));
+
+ /* combination */
+ y[11] = CL_msu_j(rs1,rs2);
+ y[14] = CL_mac_j(rs1,rs2);
+ y[12] = CL_mac_j(rs3,rs4);
+ y[13] = CL_msu_j(rs3,rs4);
+ /*for (i=10; i<15; i++)
+ {
+ printf("%d,\t %d,\t",y[i].re, y[i].im);
+ }
+ printf("\n\n");*/
+
+
+ /* 1. FFT3 stage */
+ /* real part */
+ rs1 = CL_add(y[5],y[10]);
+ rs2 = CL_scale_t(CL_sub(y[5],y[10]),C31);
+ z[15] = CL_add(y[0],rs1);
+ rs1 = CL_sub(y[0],CL_shr(rs1,1));
+
+ z[25] = CL_mac_j(rs1,rs2);
+ z[20] = CL_msu_j(rs1,rs2);
+
+ /* 2. FFT3 stage */
+ rs1 = CL_add(y[6],y[11]);
+ rs2 = CL_scale_t(CL_sub(y[6],y[11]),C31);
+ z[21] = CL_add(y[1],rs1);
+ rs1 = CL_sub(y[1],CL_shr(rs1,1));
+
+ z[16] = CL_mac_j(rs1,rs2);
+ z[26] = CL_msu_j(rs1,rs2);
+
+
+ /* 3. FFT3 stage */
+ rs1 = CL_add(y[7],y[12]);
+ rs2 = CL_scale_t(CL_sub(y[7],y[12]),C31);
+ z[27] = CL_add(y[2],rs1);
+ rs1 = CL_sub(y[2],CL_shr(rs1,1));
+
+ z[22] = CL_mac_j(rs1,rs2);
+ z[17] = CL_msu_j(rs1,rs2);
+
+
+ /* 4. FFT3 stage */
+ rs1 = CL_add(y[8],y[13]);
+ rs2 = CL_scale_t(CL_sub(y[8],y[13]),C31);
+ z[18] = CL_add(y[3],rs1);
+ rs1 = CL_sub(y[3],CL_shr(rs1,1));
+
+ z[28] = CL_mac_j(rs1,rs2);
+ z[23] = CL_msu_j(rs1,rs2);
+
+
+ /* 5. FFT3 stage */
+ rs1 = CL_add(y[9],y[14]);
+ rs2 = CL_scale_t(CL_sub(y[9],y[14]),C31);
+ z[24] = CL_add(y[4],rs1);
+ rs1 = CL_sub(y[4],CL_shr(rs1,1));
+
+ z[19] = CL_mac_j(rs1,rs2);
+ z[29] = CL_msu_j(rs1,rs2);
+
+ /*for (i=0; i<30; i++)
+ printf("%d,\t %d,\t",z[i].re, z[i].im);
+ printf("\n\n");*/
+
+
+ /* 1. FFT2 stage */
+ rs1 = CL_shr(z[0], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[15],SCALEFACTOR30_2);
+ *l = CL_add(rs1,rs2);
+ *h = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 2. FFT2 stage */
+ rs1 = CL_shr(z[8], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[23],SCALEFACTOR30_2);
+ *h = CL_add(rs1,rs2);
+ *l = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+
+ /* 3. FFT2 stage */
+ rs1 = CL_shr(z[1], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[16],SCALEFACTOR30_2);
+ *l = CL_add(rs1,rs2);
+ *h = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+
+ /* 4. FFT2 stage */
+ rs1 = CL_shr(z[9], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[24],SCALEFACTOR30_2);
+ *h = CL_add(rs1,rs2);
+ *l = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 5. FFT2 stage */
+ rs1 = CL_shr(z[2], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[17],SCALEFACTOR30_2);
+ *l = CL_add(rs1,rs2);
+ *h = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 6. FFT2 stage */
+ rs1 = CL_shr(z[10], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[25],SCALEFACTOR30_2);
+ *h = CL_add(rs1,rs2);
+ *l = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 7. FFT2 stage */
+ rs1 = CL_shr(z[3], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[18],SCALEFACTOR30_2);
+ *l = CL_add(rs1,rs2);
+ *h = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 8. FFT2 stage */
+ rs1 = CL_shr(z[11], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[26],SCALEFACTOR30_2);
+ *h = CL_add(rs1,rs2);
+ *l = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 9. FFT2 stage */
+ rs1 = CL_shr(z[4], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[19],SCALEFACTOR30_2);
+ *l = CL_add(rs1,rs2);
+ *h = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 10. FFT2 stage */
+ rs1 = CL_shr(z[12], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[27],SCALEFACTOR30_2);
+ *h = CL_add(rs1,rs2);
+ *l = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 11. FFT2 stage */
+ rs1 = CL_shr(z[5], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[20],SCALEFACTOR30_2);
+ *l = CL_add(rs1,rs2);
+ *h = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 12. FFT2 stage */
+ rs1 = CL_shr(z[13], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[28],SCALEFACTOR30_2);
+ *h = CL_add(rs1,rs2);
+ *l = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 13. FFT2 stage */
+ rs1 = CL_shr(z[6], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[21],SCALEFACTOR30_2);
+ *l = CL_add(rs1,rs2);
+ *h = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 14. FFT2 stage */
+ rs1 = CL_shr(z[14], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[29],SCALEFACTOR30_2);
+ *h = CL_add(rs1,rs2);
+ *l = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+ /* 15. FFT2 stage */
+ rs1 = CL_shr(z[7], SCALEFACTOR30_2);
+ rs2 = CL_shr(z[22],SCALEFACTOR30_2);
+ *l = CL_add(rs1,rs2);
+ *h = CL_sub(rs1,rs2);
+ l+=1; h+=1;
+
+#if (WMOPS)
+ multiCounter[currCounter].CL_move += 30;
+#endif
+
+}
+
+/**
+ * \brief Function performs a complex 32-point FFT
+ * The FFT is performed inplace. The result of the FFT
+ * is scaled by SCALEFACTOR32 bits.
+ *
+ * WOPS with 32x16 bit multiplications: 752 cycles
+ *
+ * \param [i/o] re real input / output
+ * \param [i/o] im imag input / output
+ * \param [i ] s stride real and imag input / output
+ *
+ * \return void
+ */
+
+
+static void fft32_with_cmplx_data(cmplx * inp)
+{
+ cmplx x[32], y[32], t[32], s[32], temp, temp1;
+ const cmplx_s *pRotVector_32 = ( const cmplx_s *)RotVector_32;
+
+ /* 1. FFT8 stage */
+
+ x[0] = CL_shr(inp[0], SCALEFACTOR32_1);
+ x[1] = CL_shr(inp[4], SCALEFACTOR32_1);
+ x[2] = CL_shr(inp[8], SCALEFACTOR32_1);
+ x[3] = CL_shr(inp[12], SCALEFACTOR32_1);
+ x[4] = CL_shr(inp[16], SCALEFACTOR32_1);
+ x[5] = CL_shr(inp[20], SCALEFACTOR32_1);
+ x[6] = CL_shr(inp[24], SCALEFACTOR32_1);
+ x[7] = CL_shr(inp[28], SCALEFACTOR32_1);
+
+
+ t[0] = CL_add(x[0],x[4]);
+ t[1] = CL_sub(x[0],x[4]);
+ t[2] = CL_add(x[1],x[5]);
+ t[3] = CL_sub(x[1],x[5]);
+ t[4] = CL_add(x[2],x[6]);
+ t[5] = CL_sub(x[2],x[6]);
+ t[6] = CL_add(x[3],x[7]);
+ t[7] = CL_sub(x[3],x[7]);
+
+ /* Pre-additions and core multiplications */
+
+ s[0] = CL_add(t[0], t[4]);
+ s[2] = CL_sub(t[0], t[4]);
+ s[4] = CL_mac_j(t[1], t[5]);
+ s[5] = CL_msu_j(t[1], t[5]);
+ s[1] = CL_add(t[2], t[6]);
+ s[3] = CL_sub(t[2], t[6]);
+ s[3] = CL_mul_j(s[3]);
+
+ temp = CL_add(t[3], t[7]);
+ temp1 = CL_sub(t[3], t[7]);
+ s[6] = CL_scale_t(CL_msu_j(temp1, temp), C81);
+ s[7] = CL_dscale_t(CL_swap_real_imag( CL_msu_j(temp, temp1)), C81, C82);
+
+
+ y[0] = CL_add(s[0],s[1]);
+ y[4] = CL_sub(s[0],s[1]);
+ y[2] = CL_sub(s[2],s[3]);
+ y[6] = CL_add(s[2],s[3]);
+ y[3] = CL_add(s[4],s[7]);
+ y[7] = CL_sub(s[4],s[7]);
+ y[1] = CL_add(s[5],s[6]);
+ y[5] = CL_sub(s[5],s[6]);
+
+ /* 2. FFT8 stage */
+
+ x[0] = CL_shr(inp[1], SCALEFACTOR32_1);
+ x[1] = CL_shr(inp[5], SCALEFACTOR32_1);
+ x[2] = CL_shr(inp[9], SCALEFACTOR32_1);
+ x[3] = CL_shr(inp[13], SCALEFACTOR32_1);
+ x[4] = CL_shr(inp[17], SCALEFACTOR32_1);
+ x[5] = CL_shr(inp[21], SCALEFACTOR32_1);
+ x[6] = CL_shr(inp[25], SCALEFACTOR32_1);
+ x[7] = CL_shr(inp[29], SCALEFACTOR32_1);
+
+
+ t[0] = CL_add(x[0],x[4]);
+ t[1] = CL_sub(x[0],x[4]);
+ t[2] = CL_add(x[1],x[5]);
+ t[3] = CL_sub(x[1],x[5]);
+ t[4] = CL_add(x[2],x[6]);
+ t[5] = CL_sub(x[2],x[6]);
+ t[6] = CL_add(x[3],x[7]);
+ t[7] = CL_sub(x[3],x[7]);
+
+ /* Pre-additions and core multiplications */
+
+ s[0] = CL_add(t[0], t[4]);
+ s[2] = CL_sub(t[0], t[4]);
+ s[4] = CL_mac_j(t[1], t[5]);
+ s[5] = CL_msu_j(t[1], t[5]);
+ s[1] = CL_add(t[2], t[6]);
+ s[3] = CL_sub(t[2], t[6]);
+ s[3] = CL_mul_j(s[3]);
+
+ temp = CL_add(t[3], t[7]);
+ temp1 = CL_sub(t[3], t[7]);
+ s[6] = CL_scale_t(CL_msu_j(temp1, temp), C81);
+ s[7] = CL_dscale_t(CL_swap_real_imag( CL_msu_j(temp, temp1)), C81, C82);
+
+ /* Post-additions */
+
+ y[8] = CL_add(s[0],s[1]);
+ y[12] = CL_sub(s[0],s[1]);
+ y[10] = CL_sub(s[2],s[3]);
+ y[14] = CL_add(s[2],s[3]);
+ y[11] = CL_add(s[4],s[7]);
+ y[15] = CL_sub(s[4],s[7]);
+ y[9] = CL_add(s[5],s[6]);
+ y[13] = CL_sub(s[5],s[6]);
+
+ /* 3. FFT8 stage */
+
+ x[0] = CL_shr(inp[2], SCALEFACTOR32_1);
+ x[1] = CL_shr(inp[6], SCALEFACTOR32_1);
+ x[2] = CL_shr(inp[10], SCALEFACTOR32_1);
+ x[3] = CL_shr(inp[14], SCALEFACTOR32_1);
+ x[4] = CL_shr(inp[18], SCALEFACTOR32_1);
+ x[5] = CL_shr(inp[22], SCALEFACTOR32_1);
+ x[6] = CL_shr(inp[26], SCALEFACTOR32_1);
+ x[7] = CL_shr(inp[30], SCALEFACTOR32_1);
+
+
+ t[0] = CL_add(x[0],x[4]);
+ t[1] = CL_sub(x[0],x[4]);
+ t[2] = CL_add(x[1],x[5]);
+ t[3] = CL_sub(x[1],x[5]);
+ t[4] = CL_add(x[2],x[6]);
+ t[5] = CL_sub(x[2],x[6]);
+ t[6] = CL_add(x[3],x[7]);
+ t[7] = CL_sub(x[3],x[7]);
+
+ /* Pre-additions and core multiplications */
+
+ s[0] = CL_add(t[0], t[4]);
+ s[2] = CL_sub(t[0], t[4]);
+ s[4] = CL_mac_j(t[1], t[5]);
+ s[5] = CL_msu_j(t[1], t[5]);
+ s[1] = CL_add(t[2], t[6]);
+ s[3] = CL_sub(t[2], t[6]);
+ s[3] = CL_mul_j(s[3]);
+
+ temp = CL_add(t[3], t[7]);
+ temp1 = CL_sub(t[3], t[7]);
+ s[6] = CL_scale_t(CL_msu_j(temp1, temp), C81);
+ s[7] = CL_dscale_t(CL_swap_real_imag( CL_msu_j(temp, temp1)), C81, C82);
+
+ /* Post-additions */
+
+ y[16] = CL_add(s[0],s[1]);
+ y[20] = CL_sub(s[0],s[1]);
+ y[18] = CL_sub(s[2],s[3]);
+ y[22] = CL_add(s[2],s[3]);
+ y[19] = CL_add(s[4],s[7]);
+ y[23] = CL_sub(s[4],s[7]);
+ y[17] = CL_add(s[5],s[6]);
+ y[21] = CL_sub(s[5],s[6]);
+
+ /* 4. FFT8 stage */
+
+ x[0] = CL_shr(inp[3], SCALEFACTOR32_1);
+ x[1] = CL_shr(inp[7], SCALEFACTOR32_1);
+ x[2] = CL_shr(inp[11], SCALEFACTOR32_1);
+ x[3] = CL_shr(inp[15], SCALEFACTOR32_1);
+ x[4] = CL_shr(inp[19], SCALEFACTOR32_1);
+ x[5] = CL_shr(inp[23], SCALEFACTOR32_1);
+ x[6] = CL_shr(inp[27], SCALEFACTOR32_1);
+ x[7] = CL_shr(inp[31], SCALEFACTOR32_1);
+
+
+ t[0] = CL_add(x[0],x[4]);
+ t[1] = CL_sub(x[0],x[4]);
+ t[2] = CL_add(x[1],x[5]);
+ t[3] = CL_sub(x[1],x[5]);
+ t[4] = CL_add(x[2],x[6]);
+ t[5] = CL_sub(x[2],x[6]);
+ t[6] = CL_add(x[3],x[7]);
+ t[7] = CL_sub(x[3],x[7]);
+
+
+ /* Pre-additions and core multiplications */
+
+ s[0] = CL_add(t[0], t[4]);
+ s[2] = CL_sub(t[0], t[4]);
+ s[4] = CL_mac_j(t[1], t[5]);
+ s[5] = CL_msu_j(t[1], t[5]);
+ s[1] = CL_add(t[2], t[6]);
+ s[3] = CL_sub(t[2], t[6]);
+ s[3] = CL_mul_j(s[3]);
+
+ temp = CL_add(t[3], t[7]);
+ temp1 = CL_sub(t[3], t[7]);
+ s[6] = CL_scale_t(CL_msu_j(temp1, temp), C81);
+ s[7] = CL_dscale_t(CL_swap_real_imag( CL_msu_j(temp, temp1)), C81, C82);
+
+ /* Post-additions */
+
+ y[24] = CL_add(s[0],s[1]);
+ y[28] = CL_sub(s[0],s[1]);
+ y[26] = CL_sub(s[2],s[3]);
+ y[30] = CL_add(s[2],s[3]);
+ y[27] = CL_add(s[4],s[7]);
+ y[31] = CL_sub(s[4],s[7]);
+ y[25] = CL_add(s[5],s[6]);
+ y[29] = CL_sub(s[5],s[6]);
+
+
+ /* apply twiddle factors */
+ y[0] = CL_shr(y[0],SCALEFACTOR32_2);
+ y[1] = CL_shr(y[1],SCALEFACTOR32_2);
+ y[2] = CL_shr(y[2],SCALEFACTOR32_2);
+ y[3] = CL_shr(y[3],SCALEFACTOR32_2);
+ y[4] = CL_shr(y[4],SCALEFACTOR32_2);
+ y[5] = CL_shr(y[5],SCALEFACTOR32_2);
+ y[6] = CL_shr(y[6],SCALEFACTOR32_2);
+ y[7] = CL_shr(y[7],SCALEFACTOR32_2);
+ y[8] = CL_shr(y[8],SCALEFACTOR32_2);
+ y[16] = CL_shr(y[16],SCALEFACTOR32_2);
+ y[24] = CL_shr(y[24],SCALEFACTOR32_2);
+ y[20] = CL_shr(y[20],SCALEFACTOR32_2);
+
+
+ y[9] = CL_mult_32x16((CL_shr(y[9],1)), pRotVector_32[ 0 ]);
+ y[10] = CL_mult_32x16((CL_shr(y[10],1)), pRotVector_32[ 1 ]);
+ y[11] = CL_mult_32x16((CL_shr(y[11],1)), pRotVector_32[ 2 ]);
+ y[12] = CL_mult_32x16((CL_shr(y[12],1)), pRotVector_32[ 3 ]);
+ y[13] = CL_mult_32x16((CL_shr(y[13],1)), pRotVector_32[ 4 ]);
+ y[14] = CL_mult_32x16((CL_shr(y[14],1)), pRotVector_32[ 5 ]);
+ y[15] = CL_mult_32x16((CL_shr(y[15],1)), pRotVector_32[ 6 ]);
+ y[17] = CL_mult_32x16((CL_shr(y[17],1)), pRotVector_32[ 7 ]);
+ y[18] = CL_mult_32x16((CL_shr(y[18],1)), pRotVector_32[ 8 ]);
+ y[19] = CL_mult_32x16((CL_shr(y[19],1)), pRotVector_32[ 9 ]);
+ y[21] = CL_mult_32x16((CL_shr(y[21],1)), pRotVector_32[ 10 ]);
+ y[22] = CL_mult_32x16((CL_shr(y[22],1)), pRotVector_32[ 11 ]);
+ y[23] = CL_mult_32x16((CL_shr(y[23],1)), pRotVector_32[ 12 ]);
+ y[25] = CL_mult_32x16((CL_shr(y[25],1)), pRotVector_32[ 13 ]);
+ y[26] = CL_mult_32x16((CL_shr(y[26],1)), pRotVector_32[ 14 ]);
+ y[27] = CL_mult_32x16((CL_shr(y[27],1)), pRotVector_32[ 15 ]);
+ y[28] = CL_mult_32x16((CL_shr(y[28],1)), pRotVector_32[ 16 ]);
+ y[29] = CL_mult_32x16((CL_shr(y[29],1)), pRotVector_32[ 17 ]);
+ y[30] = CL_mult_32x16((CL_shr(y[30],1)), pRotVector_32[ 18 ]);
+ y[31] = CL_mult_32x16((CL_shr(y[31],1)), pRotVector_32[ 19 ]);
+
+ /* 1. FFT4 stage */
+
+ /* Pre-additions */
+ t[0] = CL_add(y[0],y[16]);
+ t[1] = CL_sub(y[0],y[16]);
+ t[2] = CL_add(y[8],y[24]);
+ t[3] = CL_mul_j(CL_sub(y[8],y[24]));
+
+ /* Post-additions */
+ inp[0] = CL_add(t[0], t[2]);
+ inp[8] = CL_sub(t[1], t[3]);
+ inp[16] = CL_sub(t[0], t[2]);
+ inp[24] = CL_add(t[1], t[3]);
+
+ /* 2. FFT4 stage */
+
+ /* Pre-additions */
+ t[0] = CL_add(y[1],y[17]);
+ t[1] = CL_sub(y[1],y[17]);
+ t[2] = CL_add(y[9],y[25]);
+ t[3] = CL_mul_j(CL_sub(y[9],y[25]));
+
+ /* Post-additions */
+ inp[1] = CL_add(t[0], t[2]);
+ inp[9] = CL_sub(t[1], t[3]);
+ inp[17] = CL_sub(t[0], t[2]);
+ inp[25] = CL_add(t[1], t[3]);
+
+
+ /* 3. FFT4 stage */
+
+ /* Pre-additions */
+ t[0] = CL_add(y[2],y[18]);
+ t[1] = CL_sub(y[2],y[18]);
+ t[2] = CL_add(y[10],y[26]);
+ t[3] = CL_mul_j(CL_sub(y[10],y[26]));
+
+ /* Post-additions */
+ inp[2] = CL_add(t[0], t[2]);
+ inp[10] = CL_sub(t[1], t[3]);
+ inp[18] = CL_sub(t[0], t[2]);
+ inp[26] = CL_add(t[1], t[3]);
+
+
+ /* 4. FFT4 stage */
+
+ /* Pre-additions */
+ t[0] = CL_add(y[3],y[19]);
+ t[1] = CL_sub(y[3],y[19]);
+ t[2] = CL_add(y[11],y[27]);
+ t[3] = CL_mul_j(CL_sub(y[11],y[27]));
+
+
+ /* Post-additions */
+ inp[3] = CL_add(t[0], t[2]);
+ inp[11] = CL_sub(t[1], t[3]);
+ inp[19] = CL_sub(t[0], t[2]);
+ inp[27] = CL_add(t[1], t[3]);
+
+
+ /* 5. FFT4 stage */
+
+ /* Pre-additions */
+ t[0] = CL_msu_j(y[4],y[20]);
+ t[1] = CL_mac_j(y[4],y[20]);
+ t[2] = CL_add(y[12],y[28]);
+ t[3] = CL_mul_j(CL_sub(y[12],y[28]));
+
+
+ /* Post-additions */
+ inp[4] = CL_add(t[0], t[2]);
+ inp[12] = CL_sub(t[1], t[3]);
+ inp[20] = CL_sub(t[0], t[2]);
+ inp[28] = CL_add(t[1], t[3]);
+
+
+ /* 6. FFT4 stage */
+
+ /* Pre-additions */
+ t[0] = CL_add(y[5],y[21]);
+ t[1] = CL_sub(y[5],y[21]);
+ t[2] = CL_add(y[13],y[29]);
+ t[3] = CL_mul_j(CL_sub(y[13],y[29]));
+
+
+ /* Post-additions */
+ inp[5] = CL_add(t[0], t[2]);
+ inp[13] = CL_sub(t[1], t[3]);
+ inp[21] = CL_sub(t[0], t[2]);
+ inp[29] = CL_add(t[1], t[3]);
+
+
+ /* 7. FFT4 stage */
+
+ /* Pre-additions */
+ t[0] = CL_add(y[6],y[22]);
+ t[1] = CL_sub(y[6],y[22]);
+ t[2] = CL_add(y[14],y[30]);
+ t[3] = CL_mul_j(CL_sub(y[14],y[30]));
+
+
+ /* Post-additions */
+ inp[6] = CL_add(t[0], t[2]);
+ inp[14] = CL_sub(t[1], t[3]);
+ inp[22] = CL_sub(t[0], t[2]);
+ inp[30] = CL_add(t[1], t[3]);
+
+
+ /* 8. FFT4 stage */
+
+ /* Pre-additions */
+ t[0] = CL_add(y[7],y[23]);
+ t[1] = CL_sub(y[7],y[23]);
+ t[2] = CL_add(y[15],y[31]);
+ t[3] = CL_mul_j(CL_sub(y[15],y[31]));
+
+
+ /* Post-additions */
+ inp[7] = CL_add(t[0], t[2]);
+ inp[15] = CL_sub(t[1], t[3]);
+ inp[23] = CL_sub(t[0], t[2]);
+ inp[31] = CL_add(t[1], t[3]);
+
+#if (WMOPS)
+ multiCounter[currCounter].CL_move += 32;
+#endif
+
+
+}
+
+
+/**
+ * \brief Combined FFT
+ *
+ * \param [i/o] re real part
+ * \param [i/o] im imag part
+ * \param [i ] W rotation factor
+ * \param [i ] len length of fft
+ * \param [i ] dim1 length of fft1
+ * \param [i ] dim2 length of fft2
+ * \param [i ] sx stride real and imag part
+ * \param [i ] sc stride phase rotation coefficients
+ * \param [tmp] x 32-bit workbuffer of length=2*len
+ * \param [i ] Woff offset for addressing the rotation vector table
+ *
+ * \return void
+ */
+
+static void fftN2(
+ cmplx *__restrict pComplexBuf,
+ const Word16 *__restrict W,
+ Word16 len,
+ Word16 dim1,
+ Word16 dim2,
+ Word16 sc,
+ Word32 *x,
+ Word16 Woff
+)
+{
+ Word16 i, j;
+ cmplx *x_cmplx = (cmplx *)x;
+
+ assert(len == (dim1*dim2));
+ assert((dim1 == 3) || (dim1 == 5) || (dim1 == 8) || (dim1 == 10) || (dim1 == 15) || (dim1 == 16) || (dim1 == 20) || (dim1 == 30) || (dim1 == 32));
+ assert((dim2 == 4) || (dim2 == 8) || (dim2 == 10) || (dim2 == 12) || (dim2 == 16) || (dim2 == 20));
+
+ FOR(i = 0; i
+
+/*-----------------------------------------------------------------*
+* Local functions
+*-----------------------------------------------------------------*/
+
+#define FFT3_ONE_THIRD 21845 /* 1/3 in Q16 */
+
+static void fft5_shift4_16fx( Word16 n1, Word16 *zRe, Word16 *zIm, const Word16 *Idx );
+static void fft64_16fx( Word16 *x, Word16 *y, const Word16 *Idx );
+static void fft32_5_16fx( Word16 *x, Word16 *y, const Word16 *Idx );
+static void cftmdl_16fx(Word16 n, Word16 l, Word16 *a, const Word32 *w);
+static void cftfsub_16fx( Word16 n, Word16 *a, const Word32 *w );
+static void cft1st_16fx(Word16 n, Word16 *a, const Word32 *w);
+static void cftmdl_16fx(Word16 n, Word16 l, Word16 *a, const Word32 *w);
+static void fft5_shift4_16fx( Word16 n1, Word16 *zRe, Word16 *zIm, const Word16 *Idx );
+static void bitrv2_SR_16fx( Word16 n, const Word16 *ip, Word16 *a );
+static void fft64_16fx( Word16 *x, Word16 *y, const Word16 *Idx );
+static void fft5_32_16fx( Word16 *zRe, Word16 *zIm, const Word16 *Idx );
+static void cdftForw_16fx( Word16 n, Word16 *a, const Word16 *ip, const Word32 *w );
+
+#include "math_32.h"
+
+/*-----------------------------------------------------------------*
+* Local functions
+*-----------------------------------------------------------------*/
+static void cdftForw_fx( Word16 n, Word32 *a, const Word16 *ip, const Word16 *w );
+static void bitrv2_SR_fx( Word16 n, const Word16 *ip, Word32 *a );
+static void cftfsub_fx( Word16 n, Word32 *a, const Word16 *w );
+static void cft1st_fx( Word16 n, Word32 *a, const Word16 *w );
+static void cftmdl_fx( Word16 n, Word16 l, Word32 *a, const Word16 *w );
+
+
+void DoRTFTn_fx(
+ Word32 *x, /* i/o : real part of input and output data */
+ Word32 *y, /* i/o : imaginary part of input and output data */
+ const Word16 n /* i : size of the FFT up to 1024 */
+)
+{
+
+ Word16 i;
+ Word32 z[2048], *pt;
+
+ pt = z;
+ FOR ( i=0; i=1 ; i--)
+ {
+ x[i]=*pt++;
+ move16();
+ y[i]=*pt++;
+ move16();
+ }
+
+ return;
+}
+
+/*-----------------------------------------------------------------*
+ * cdftForw_fx()
+ * Main fuction of Complex Discrete Fourier Transform
+ *-----------------------------------------------------------------*/
+static void cdftForw_fx(
+ Word16 n, /* i : data length of real and imag */
+ Word32 *a, /* i/o : input/output data Q(q)*/
+ const Word16 *ip, /* i : work area for bit reversal */
+ const Word16 *w /* i : cos/sin table Q14*/
+)
+{
+ /* bit reversal */
+ bitrv2_SR_fx(n, ip + 2, a);
+
+ /* Do FFT */
+ cftfsub_fx(n, a, w);
+}
+
+/*-----------------------------------------------------------------*
+ * bitrv2_SR_fx()
+ * Bit reversal
+ *-----------------------------------------------------------------*/
+static void bitrv2_SR_fx(
+ Word16 n, /* i : data length of real and imag */
+ const Word16 *ip, /* i/o : work area for bit reversal */
+ Word32 *a /* i/o : input/output data Q(q)*/
+)
+{
+ Word16 j, j1, k, k1, m, m2;
+ Word16 l;
+ Word32 xr, xi, yr, yi;
+
+ l = n;
+ move16();
+ m = 1;
+ move16();
+
+ WHILE (shl(m, 3) < l)
+ {
+ l = shr(l, 1);
+ m = shl(m, 1);
+ }
+
+ m2 = shl(m, 1);
+ IF (shl(m, 3) == l)
+ {
+ FOR (k = 0; k < m; k++)
+ {
+ FOR (j = 0; j < k; j++)
+ {
+ j1 = add(shl(j, 1), ip[k]);
+ k1 = add(shl(k, 1), ip[j]);
+ xr = a[j1]; move32();
+ xi = a[j1 + 1]; move32();
+ yr = a[k1]; move32();
+ yi = a[k1 + 1]; move32();
+ a[j1] = yr;
+ move32();
+ a[j1 + 1] = yi;
+ move32();
+ a[k1] = xr;
+ move32();
+ a[k1 + 1] = xi;
+ move32();
+ j1 = add(j1, m2);
+ k1 = add(k1, shl(m2, 1));
+ xr = a[j1]; move32();
+ xi = a[j1 + 1]; move32();
+ yr = a[k1]; move32();
+ yi = a[k1 + 1]; move32();
+ a[j1] = yr;
+ move32();
+ a[j1 + 1] = yi;
+ move32();
+ a[k1] = xr;
+ move32();
+ a[k1 + 1] = xi;
+ move32();
+ j1 = add(j1, m2);
+ k1 = sub(k1, m2);
+ xr = a[j1]; move32();
+ xi = a[j1 + 1]; move32();
+ xi = a[j1 + 1]; move32();
+ yr = a[k1]; move32();
+ yi = a[k1 + 1]; move32();
+ a[j1] = yr;
+ move32();
+ a[j1 + 1] = yi;
+ move32();
+ a[k1] = xr;
+ move32();
+ a[k1 + 1] = xi;
+ move32();
+ j1 = add(j1, m2);
+ k1 = add(k1, shl(m2, 1));
+ xr = a[j1]; move32();
+ xi = a[j1 + 1]; move32();
+ yr = a[k1]; move32();
+ yi = a[k1 + 1]; move32();
+ a[j1] = yr;
+ move32();
+ a[j1 + 1] = yi;
+ move32();
+ a[k1] = xr;
+ move32();
+ a[k1 + 1] = xi;
+ move32();
+ }
+
+ j1 = add(add(shl(k, 1), m2), ip[k]);
+ k1 = add(j1, m2);
+ xr = a[j1]; move32();
+ xi = a[j1 + 1]; move32();
+ yr = a[k1]; move32();
+ yi = a[k1 + 1]; move32();
+ a[j1] = yr;
+ move32();
+ a[j1 + 1] = yi;
+ move32();
+ a[k1] = xr;
+ move32();
+ a[k1 + 1] = xi;
+ move32();
+ }
+ }
+ ELSE
+ {
+ FOR (k = 1; k < m; k++)
+ {
+ FOR (j = 0; j < k; j++)
+ {
+ j1 = add(shl(j, 1), ip[k]);
+ k1 = add(shl(k, 1), ip[j]);
+ xr = a[j1]; move32();
+ xi = a[j1 + 1]; move32();
+ yr = a[k1]; move32();
+ yi = a[k1 + 1]; move32();
+ a[j1] = yr;
+ move32();
+ a[j1 + 1] = yi;
+ move32();
+ a[k1] = xr;
+ move32();
+ a[k1 + 1] = xi;
+ move32();
+ j1 = add(j1, m2);
+ k1 = add(k1, m2);
+ xr = a[j1]; move32();
+ xi = a[j1 + 1]; move32();
+ yr = a[k1]; move32();
+ yi = a[k1 + 1]; move32();
+ a[j1] = yr;
+ move32();
+ a[j1 + 1] = yi;
+ move32();
+ a[k1] = xr;
+ move32();
+ a[k1 + 1] = xi;
+ move32();
+ }
+ }
+ }
+
+ return;
+}
+
+/*-----------------------------------------------------------------*
+ * cftfsub_fx()
+ * Complex Discrete Fourier Transform
+ *-----------------------------------------------------------------*/
+static void cftfsub_fx(
+ Word16 n, /* i : data length of real and imag */
+ Word32 *a, /* i/o : input/output data Q(q)*/
+ const Word16 *w /* i : cos/sin table Q14*/
+)
+{
+ Word16 j, j1, j2, j3, l;
+ Word32 x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+
+ l = 2;
+ move16();
+
+ IF (n > 8)
+ {
+ cft1st_fx(n, a, w);
+ l = 8;
+ move16();
+ WHILE ((shl(l, 2) < n))
+ {
+ cftmdl_fx(n, l, a, w);
+ l = shl(l, 2);
+ }
+ }
+ IF (shl(l, 2) == n)
+ {
+ FOR (j = 0; j < l; j += 2)
+ {
+ j1 = add(j, l);
+ j2 = add(j1, l);
+ j3 = add(j2, l);
+ x0r = L_add(a[j], a[j1]);
+ x0i = L_add(a[j + 1], a[j1 + 1]);
+ x1r = L_sub(a[j], a[j1]);
+ x1i = L_sub(a[j + 1], a[j1 + 1]);
+ x2r = L_add(a[j2], a[j3]);
+ x2i = L_add(a[j2 + 1], a[j3 + 1]);
+ x3r = L_sub(a[j2], a[j3]);
+ x3i = L_sub(a[j2 + 1], a[j3 + 1]);
+ a[j] = L_add(x0r, x2r);
+ move32();
+ a[j2] = L_sub(x0r, x2r);
+ move32();
+ a[j + 1] = L_add(x0i, x2i);
+ move32();
+ a[j2 + 1] = L_sub(x0i, x2i);
+ move32();
+ a[j1] = L_sub(x1r, x3i);
+ move32();
+ a[j1 + 1] = L_add(x1i, x3r);
+ move32();
+ a[j3] = L_add(x1r, x3i);
+ move32();
+ a[j3 + 1] = L_sub(x1i, x3r);
+ move32();
+ }
+ }
+ ELSE
+ {
+ FOR (j = 0; j < l; j += 2)
+ {
+ j1 = add(j, l);
+ x0r = L_sub(a[j], a[j1]);
+ x0i = L_sub(a[j + 1], a[j1 + 1]);
+ a[j] = L_add(a[j], a[j1]);
+ move32();
+ a[j + 1] = L_add(a[j + 1], a[j1 + 1]);
+ move32();
+ a[j1] = x0r;
+ move32();
+ move32();
+ a[j1 + 1] = x0i;
+ move32();
+ move32();
+ }
+ }
+
+ return;
+}
+
+/*-----------------------------------------------------------------*
+ * cft1st_fx()
+ * Subfunction of Complex Discrete Fourier Transform
+ *-----------------------------------------------------------------*/
+static void cft1st_fx(
+ Word16 n, /* i : data length of real and imag */
+ Word32 *a, /* i/o : input/output data Q(q)*/
+ const Word16 *w /* i : cos/sin table Q14*/
+)
+{
+ Word16 j, k1, k2;
+ Word16 wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
+ Word32 x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+
+ x0r = L_add(a[0], a[2]);
+ x0i = L_add(a[1], a[3]);
+ x1r = L_sub(a[0], a[2]);
+ x1i = L_sub(a[1], a[3]);
+ x2r = L_add(a[4], a[6]);
+ x2i = L_add(a[5], a[7]);
+ x3r = L_sub(a[4], a[6]);
+ x3i = L_sub(a[5], a[7]);
+ a[0] = L_add(x0r, x2r);
+ move32();
+ a[1] = L_add(x0i, x2i);
+ move32();
+ a[4] = L_sub(x0r, x2r);
+ move32();
+ a[5] = L_sub(x0i, x2i);
+ move32();
+ a[2] = L_sub(x1r, x3i);
+ move32();
+ a[3] = L_add(x1i, x3r);
+ move32();
+ a[6] = L_add(x1r, x3i);
+ move32();
+ a[7] = L_sub(x1i, x3r);
+ move32();
+
+ wk1r = w[2];
+ move16();
+ x0r = L_add(a[8], a[10]);
+ x0i = L_add(a[9], a[11]);
+ x1r = L_sub(a[8], a[10]);
+ x1i = L_sub(a[9], a[11]);
+ x2r = L_add(a[12], a[14]);
+ x2i = L_add(a[13], a[15]);
+ x3r = L_sub(a[12], a[14]);
+ x3i = L_sub(a[13], a[15]);
+ a[8] = L_add(x0r, x2r);
+ move32();
+ a[9] = L_add(x0i, x2i);
+ move32();
+ a[12] = L_sub(x2i, x0i);
+ move32();
+ a[13] = L_sub(x0r, x2r);
+ move32();
+
+ x0r = L_sub(x1r, x3i);
+ x0i = L_add(x1i ,x3r);
+ a[10] = Mult_32_16(L_shl(L_sub(x0r, x0i), 1), wk1r);
+ move32();
+ a[11] = Mult_32_16(L_shl(L_add(x0r, x0i), 1), wk1r);
+ move32();
+ x0r = L_add(x3i, x1r);
+ x0i = L_sub(x3r,x1i);
+ a[14] = Mult_32_16(L_shl(L_sub(x0i, x0r), 1), wk1r);
+ move32();
+ a[15] = Mult_32_16(L_shl(L_add(x0i, x0r), 1), wk1r);
+ move32();
+
+ k1 = 0;
+ move16();
+ FOR (j = 16; j < n; j += 16)
+ {
+ k1 = add(k1, 2);
+ k2 = shl(k1, 1);
+ wk2r = w[k1];
+ move16();
+ wk2i = w[k1 + 1];
+ move16();
+ wk1r = w[k2];
+ move16();
+ wk1i = w[k2 + 1];
+ move16();
+ wk3r = extract_l(L_sub(L_deposit_l(wk1r), L_shr(L_mult(wk2i, wk1i), 14)));
+ wk3i = extract_l(L_msu0(L_shr(L_mult(wk2i, wk1r), 14), wk1i, 1));
+ x0r = L_add(a[j], a[j + 2]);
+ x0i = L_add(a[j + 1], a[j + 3]);
+ x1r = L_sub(a[j], a[j + 2]);
+ x1i = L_sub(a[j + 1], a[j + 3]);
+ x2r = L_add(a[j + 4], a[j + 6]);
+ x2i = L_add(a[j + 5], a[j + 7]);
+ x3r = L_sub(a[j + 4], a[j + 6]);
+ x3i = L_sub(a[j + 5], a[j + 7]);
+ a[j] = L_add(x0r, x2r);
+ move32();
+ a[j + 1] = L_add(x0i, x2i);
+ move32();
+ x0r = L_sub(x0r, x2r);
+ x0i = L_sub(x0i, x2i);
+ a[j + 4] = L_sub(Mult_32_16(L_shl(x0r, 1), wk2r), Mult_32_16(L_shl(x0i, 1), wk2i));
+ move32();
+ a[j + 5] = L_add(Mult_32_16(L_shl(x0i, 1), wk2r), Mult_32_16(L_shl(x0r, 1), wk2i));
+ move32();
+ x0r = L_sub(x1r, x3i);
+ x0i = L_add(x1i, x3r);
+ a[j + 2] = L_sub(Mult_32_16(L_shl(x0r, 1), wk1r), Mult_32_16(L_shl(x0i, 1), wk1i));
+ move32();
+ a[j + 3] = L_add(Mult_32_16(L_shl(x0i, 1), wk1r), Mult_32_16(L_shl(x0r, 1), wk1i));
+ move32();
+ x0r = L_add(x1r, x3i);
+ x0i = L_sub(x1i, x3r);
+ a[j + 6] = L_sub(Mult_32_16(L_shl(x0r, 1), wk3r), Mult_32_16(L_shl(x0i, 1), wk3i));
+ move32();
+ a[j + 7] = L_add(Mult_32_16(L_shl(x0i, 1), wk3r), Mult_32_16(L_shl(x0r, 1), wk3i));
+ move32();
+
+ wk1r = w[k2 + 2];
+ move16();
+ wk1i = w[k2 + 3];
+ move16();
+ wk3r = extract_l(L_sub(L_deposit_l(wk1r), L_shr(L_mult(wk2r, wk1i), 14)));
+ wk3i = extract_l(L_msu0(L_shr(L_mult(wk2r, wk1r), 14), wk1i, 1));
+ x0r = L_add(a[j + 8], a[j + 10]);
+ x0i = L_add(a[j + 9], a[j + 11]);
+ x1r = L_sub(a[j + 8], a[j + 10]);
+ x1i = L_sub(a[j + 9], a[j + 11]);
+ x2r = L_add(a[j + 12], a[j + 14]);
+ x2i = L_add(a[j + 13], a[j + 15]);
+ x3r = L_sub(a[j + 12], a[j + 14]);
+ x3i = L_sub(a[j + 13], a[j + 15]);
+ a[j + 8] = L_add(x0r, x2r);
+ move32();
+ a[j + 9] = L_add(x0i, x2i);
+ move32();
+ x0r = L_sub(x0r, x2r);
+ x0i = L_sub(x0i, x2i);
+ a[j + 12] = L_negate(L_add(Mult_32_16(L_shl(x0r, 1), wk2i), Mult_32_16(L_shl(x0i, 1), wk2r)));
+ move32();
+ a[j + 13] = L_sub(Mult_32_16(L_shl(x0r, 1), wk2r), Mult_32_16(L_shl(x0i, 1), wk2i));
+ move32();
+ x0r = L_sub(x1r, x3i);
+ x0i = L_add(x1i, x3r);
+ a[j + 10] = L_sub(Mult_32_16(L_shl(x0r, 1), wk1r), Mult_32_16(L_shl(x0i, 1), wk1i));
+ move32();
+ a[j + 11] = L_add(Mult_32_16(L_shl(x0i, 1), wk1r), Mult_32_16(L_shl(x0r, 1), wk1i));
+ move32();
+ x0r =L_add(x1r, x3i);
+ x0i =L_sub(x1i, x3r);
+ a[j + 14] = L_sub(Mult_32_16(L_shl(x0r, 1), wk3r), Mult_32_16(L_shl(x0i, 1), wk3i));
+ move32();
+ a[j + 15] = L_add(Mult_32_16(L_shl(x0i, 1), wk3r), Mult_32_16(L_shl(x0r, 1), wk3i));
+ move32();
+ }
+
+ return;
+}
+
+/*-----------------------------------------------------------------*
+ * cftmdl_fx()
+ * Subfunction of Complex Discrete Fourier Transform
+ *-----------------------------------------------------------------*/
+static void cftmdl_fx(
+ Word16 n, /* i : data length of real and imag */
+ Word16 l, /* i : initial shift for processing */
+ Word32 *a, /* i/o : input/output data Q(Qx+Q_edct)*/
+ const Word16 *w /* i : cos/sin table Q30*/
+)
+{
+ Word16 j, j1, j2, j3, k, k1, k2, m, m2;
+ Word16 wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
+ Word32 x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+ Word16 tmp;
+
+ m = shl(l, 2);
+ FOR (j = 0; j < l; j += 2)
+ {
+ j1 = add(j, l);
+ j2 = add(j1, l);
+ j3 = add(j2, l);
+ x0r = L_add(a[j], a[j1]);
+ x0i = L_add(a[j + 1], a[j1 + 1]);
+ x1r = L_sub(a[j], a[j1]);
+ x1i = L_sub(a[j + 1], a[j1 + 1]);
+ x2r = L_add(a[j2], a[j3]);
+ x2i = L_add(a[j2 + 1], a[j3 + 1]);
+ x3r = L_sub(a[j2], a[j3]);
+ x3i = L_sub(a[j2 + 1], a[j3 + 1]);
+ a[j] = L_add(x0r, x2r);
+ move32();
+ a[j + 1] = L_add(x0i, x2i);
+ move32();
+ a[j2] = L_sub(x0r, x2r);
+ move32();
+ a[j2 + 1] =L_sub(x0i, x2i);
+ move32();
+ a[j1] = L_sub(x1r, x3i);
+ move32();
+ a[j1 + 1] = L_add(x1i, x3r);
+ move32();
+ a[j3] = L_add(x1r, x3i);
+ move32();
+ a[j3 + 1] = L_sub(x1i, x3r);
+ move32();
+ }
+
+ wk1r = w[2];
+ move16();
+ tmp = add(l, m);
+ FOR (j = m; j < tmp; j += 2)
+ {
+ j1 = add(j, l);
+ j2 = add(j1, l);
+ j3 = add(j2, l);
+ x0r = L_add(a[j], a[j1]);
+ x0i = L_add(a[j + 1], a[j1 + 1]);
+ x1r = L_sub(a[j], a[j1]);
+ x1i = L_sub(a[j + 1], a[j1 + 1]);
+ x2r = L_add(a[j2], a[j3]);
+ x2i = L_add(a[j2 + 1], a[j3 + 1]);
+ x3r = L_sub(a[j2], a[j3]);
+ x3i = L_sub(a[j2 + 1], a[j3 + 1]);
+ a[j] = L_add(x0r, x2r);
+ move32();
+ a[j + 1] = L_add(x0i, x2i);
+ move32();
+ a[j2] = L_sub(x2i, x0i);
+ move32();
+ a[j2 + 1] = L_sub(x0r, x2r);
+ move32();
+ x0r = L_sub(x1r, x3i);
+ x0i = L_add(x1i, x3r);
+ a[j1] = Mult_32_16(L_shl(L_sub(x0r, x0i), 1), wk1r);
+ move32();
+ a[j1 + 1] = Mult_32_16(L_shl(L_add(x0r, x0i), 1), wk1r);
+ move32();
+ x0r = L_add(x3i, x1r);
+ x0i = L_sub(x3r, x1i);
+ a[j3] = Mult_32_16(L_shl(L_sub(x0i, x0r), 1), wk1r);
+ move32();
+ a[j3 + 1] = Mult_32_16(L_shl(L_add(x0r, x0i), 1), wk1r);
+ move32();
+ }
+
+ k1 = 0;
+ move16();
+ m2 = shl(m, 1);
+ FOR (k = m2; k < n; k += m2)
+ {
+ k1 = add(k1, 2);
+ k2 = shl(k1, 1);
+ wk2r = w[k1];
+ move16();
+ wk2i = w[k1 + 1];
+ move16();
+ wk1r = w[k2];
+ move16();
+ wk1i = w[k2 + 1];
+ move16();
+ wk3r = extract_l(L_sub(L_deposit_l(wk1r), L_shr(L_mult(wk2i, wk1i), 14)));
+ wk3i = extract_l(L_msu0(L_shr(L_mult(wk2i, wk1r), 14), wk1i, 1));
+
+ tmp = add(l, k) ;
+ FOR (j = k; j < tmp; j += 2)
+ {
+ j1 = add(j, l);
+ j2 = add(j1, l);
+ j3 = add(j2, l);
+ x0r = L_add(a[j], a[j1]);
+ x0i = L_add(a[j + 1], a[j1 + 1]);
+ x1r = L_sub(a[j], a[j1]);
+ x1i = L_sub(a[j + 1], a[j1 + 1]);
+ x2r = L_add(a[j2], a[j3]);
+ x2i = L_add(a[j2 + 1], a[j3 + 1]);
+ x3r = L_sub(a[j2], a[j3]);
+ x3i = L_sub(a[j2 + 1], a[j3 + 1]);
+ a[j] = L_add(x0r, x2r);
+ move32();
+ a[j + 1] = L_add(x0i, x2i);
+ move32();
+ x0r = L_sub(x0r, x2r);
+ x0i = L_sub(x0i, x2i);
+ a[j2] = L_sub(Mult_32_16(L_shl(x0r, 1), wk2r), Mult_32_16(L_shl(x0i, 1), wk2i));
+ move32();
+ a[j2 + 1] = L_add(Mult_32_16(L_shl(x0i, 1), wk2r), Mult_32_16(L_shl(x0r, 1), wk2i));
+ move32();
+ x0r = L_sub(x1r, x3i);
+ x0i = L_add(x1i, x3r);
+ a[j1] = L_sub(Mult_32_16(L_shl(x0r, 1), wk1r), Mult_32_16(L_shl(x0i, 1), wk1i));
+ move32();
+ a[j1 + 1] = L_add(Mult_32_16(L_shl(x0i, 1), wk1r), Mult_32_16(L_shl(x0r, 1), wk1i));
+ move32();
+ x0r = L_add(x1r, x3i);
+ x0i = L_sub(x1i, x3r);
+ a[j3] = L_sub(Mult_32_16(L_shl(x0r, 1), wk3r), Mult_32_16(L_shl(x0i, 1), wk3i));
+ move32();
+ a[j3 + 1] = L_add(Mult_32_16(L_shl(x0i, 1), wk3r), Mult_32_16(L_shl(x0r, 1), wk3i));
+ move32();
+ }
+
+ wk1r = w[k2 + 2];
+ move16();
+ wk1i = w[k2 + 3];
+ move16();
+ wk3r = extract_l(L_sub(L_deposit_l(wk1r), L_shr(L_mult(wk2r, wk1i), 14)));
+ wk3i = extract_l(L_msu0(L_shr(L_mult(wk2r, wk1r), 14), wk1i, 1));
+
+ tmp = add(l, add(k, m));
+ FOR (j = add(k, m); j < tmp; j += 2)
+ {
+ j1 = add(j, l);
+ j2 = add(j1, l);
+ j3 = add(j2, l);
+ x0r = L_add(a[j], a[j1]);
+ x0i = L_add(a[j + 1], a[j1 + 1]);
+ x1r = L_sub(a[j], a[j1]);
+ x1i = L_sub(a[j + 1], a[j1 + 1]);
+ x2r = L_add(a[j2], a[j3]);
+ x2i = L_add(a[j2 + 1], a[j3 + 1]);
+ x3r = L_sub(a[j2], a[j3]);
+ x3i = L_sub(a[j2 + 1], a[j3 + 1]);
+ a[j] = L_add(x0r, x2r);
+ move32();
+ a[j + 1] = L_add(x0i, x2i);
+ move32();
+ x0r= L_sub(x0r, x2r);
+ x0i=L_sub(x0i, x2i);
+ a[j2] = L_negate(L_add(Mult_32_16(L_shl(x0r, 1), wk2i), Mult_32_16(L_shl(x0i, 1), wk2r)));
+ move32();
+ a[j2 + 1] = L_sub(Mult_32_16(L_shl(x0r, 1), wk2r), Mult_32_16(L_shl(x0i, 1), wk2i));
+ move32();
+ x0r = L_sub(x1r, x3i);
+ x0i = L_add(x1i, x3r);
+ a[j1] = L_sub(Mult_32_16(L_shl(x0r, 1), wk1r), Mult_32_16(L_shl(x0i, 1), wk1i));
+ move32();
+ a[j1 + 1] = L_add(Mult_32_16(L_shl(x0i, 1), wk1r), Mult_32_16(L_shl(x0r, 1), wk1i));
+ move32();
+ x0r = L_add(x1r, x3i);
+ x0i = L_sub(x1i, x3r);
+ a[j3] = L_sub(Mult_32_16(L_shl(x0r, 1), wk3r), Mult_32_16(L_shl(x0i, 1), wk3i));
+ move32();
+ a[j3 + 1] = L_add(Mult_32_16(L_shl(x0i, 1), wk3r), Mult_32_16(L_shl(x0r, 1), wk3i));
+ move32();
+ }
+ }
+
+ return;
+}
+
+
+static void cftbsub_fx(
+ Word16 n,
+ Word32 *a,
+ const Word16 *w /* i : cos/sin table */
+)
+{
+ Word16 j, j1, j2, j3, l;
+ Word32 x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+
+ l = 2;
+ move16();
+ IF (n > 8)
+ {
+ cft1st_fx(n, a, w);
+ l = 8;
+ move16();
+
+ WHILE (LT_16(shl(l, 2), n))
+ {
+ cftmdl_fx(n, l, a, w);
+ l = shl(l, 2);
+ }
+ }
+
+ IF (EQ_16(shl(l, 2), n))
+ {
+ FOR (j = 0; j < l; j += 2)
+ {
+ j1 = add(j, l);
+ j2 = add(j1, l);
+ j3 = add(j2, l);
+ x0r = L_add(a[j], a[j1]);
+ x0i = L_negate(L_add(a[j + 1], a[j1 + 1]));
+ x1r = L_sub(a[j], a[j1]);
+ x1i = L_sub(a[j1 + 1], a[j + 1]);
+ x2r = L_add(a[j2], a[j3]);
+ x2i = L_add(a[j2 + 1], a[j3 + 1]);
+ x3r = L_sub(a[j2], a[j3]);
+ x3i = L_sub(a[j2 + 1], a[j3 + 1]);
+ a[j] = L_add(x0r, x2r);
+ move32();
+ a[j + 1] = L_sub(x0i, x2i);
+ move32();
+ a[j2] = L_sub(x0r, x2r);
+ move32();
+ a[j2 + 1] = L_add(x0i, x2i);
+ move32();
+ a[j1] = L_sub(x1r, x3i);
+ move32();
+ a[j1 + 1] = L_sub(x1i, x3r);
+ move32();
+ a[j3] = L_add(x1r, x3i);
+ move32();
+ a[j3 + 1] = L_add(x1i, x3r);
+ move32();
+ }
+ }
+ ELSE
+ {
+ FOR (j = 0; j < l; j += 2)
+ {
+ j1 = add(j, l);
+ x0r = L_sub(a[j], a[j1]);
+ x0i = L_sub(a[j1 + 1], a[j + 1]);
+ a[j] = L_add(a[j], a[j1]);
+ move32();
+ a[j + 1] = L_negate(L_add(a[j + 1], a[j1 + 1]));
+ move32();
+ a[j1] = x0r;
+ move32();
+ move32();
+ a[j1 + 1] = x0i;
+ move32();
+ move32();
+ }
+ }
+}
+
+static void rftfsub_fx(
+ Word16 n,
+ Word32 *a,
+ Word16 nc,
+ const Word16 *c
+)
+{
+ Word16 j, k, kk, ks, m, tmp;
+ Word32 xr, xi, yr, yi;
+ Word16 wkr, wki;
+
+ m = shr(n, 1);
+ /*ks = 2 * nc / m; */
+ tmp = shl(nc, 1);
+ ks = 0;
+ move16();
+ WHILE (GE_16(tmp, m))
+ {
+ ks = add(ks, 1);
+ tmp = sub(tmp, m);
+ }
+ kk = 0;
+ move16();
+ FOR (j = 2; j < m; j += 2)
+ {
+ k = sub(n, j);
+ kk = add(kk, ks);
+ wkr = sub(8192, c[nc - kk]);
+ wki = c[kk];
+ move16();
+ xr = L_sub(a[j], a[k]);
+ xi = L_add(a[j + 1], a[k + 1]);
+ yr = L_sub(Mult_32_16(L_shl(xr, 1), wkr), Mult_32_16(L_shl(xi, 1), wki));
+ yi = L_add(Mult_32_16(L_shl(xi, 1), wkr), Mult_32_16(L_shl(xr, 1), wki));
+ a[j] = L_sub(a[j], yr);
+ move32();
+ a[j + 1] = L_sub(a[j + 1], yi);
+ move32();
+ a[k] = L_add(a[k], yr);
+ move32();
+ a[k + 1] = L_sub(a[k + 1], yi);
+ move32();
+ }
+}
+
+
+static void rftbsub_fx(
+ Word16 n,
+ Word32 *a,
+ Word16 nc,
+ const Word16 *c
+)
+{
+ Word16 j, k, kk, ks, m, tmp;
+ Word32 xr, xi, yr, yi;
+ Word16 wkr, wki;
+
+ a[1] = L_negate(a[1]);
+ m = shr(n, 1);
+ /*ks = 2 * nc / m; */
+ tmp = shl(nc, 1);
+ ks = 0;
+ move16();
+ WHILE (GE_16(tmp, m))
+ {
+ ks = add(ks, 1);
+ tmp = sub(tmp, m);
+ }
+ kk = 0;
+ move16();
+ FOR (j = 2; j < m; j += 2)
+ {
+ k = sub(n, j);
+ kk = add(kk, ks);
+ wkr = sub(8192, c[nc - kk]);
+ wki = c[kk];
+ move16();
+ xr = L_sub(a[j], a[k]);
+ xi = L_add(a[j + 1], a[k + 1]);
+ yr = L_add(Mult_32_16(L_shl(xr, 1), wkr), Mult_32_16(L_shl(xi, 1), wki));
+ yi = L_sub(Mult_32_16(L_shl(xi, 1), wkr), Mult_32_16(L_shl(xr, 1), wki));
+ a[j] = L_sub(a[j], yr);
+ move32();
+ a[j + 1] = L_sub(yi, a[j + 1]);
+ move32();
+ a[k] = L_add(a[k], yr);
+ move32();
+ a[k + 1] = L_sub(yi, a[k + 1]);
+ move32();
+ }
+ a[m + 1] = L_negate(a[m + 1]);
+ move32();
+}
+
+
+static void dctsub_fx(
+ Word16 n,
+ Word32 *a,
+ Word16 nc,
+ const Word16 *c
+)
+{
+ Word16 j, k, kk, ks, m, tmp;
+ Word16 wkr, wki;
+ Word32 xr;
+
+ m = shr(n, 1);
+ /*ks = nc / n; */
+ tmp = nc;
+ move16();
+ ks = 0;
+ move16();
+ WHILE (GE_16(tmp, n))
+ {
+ ks = add(ks, 1);
+ tmp = sub(tmp, n);
+ }
+ kk = 0;
+ move16();
+ FOR (j = 1; j < m; j++)
+ {
+ k = sub(n, j);
+ kk = add(kk, ks);
+ wkr = sub(c[kk], c[nc - kk]);
+ wki = add(c[kk], c[nc - kk]);
+ xr = L_sub(Mult_32_16(L_shl(a[j], 1), wki), Mult_32_16(L_shl(a[k], 1), wkr));
+ a[j] = L_add(Mult_32_16(L_shl(a[j], 1), wkr), Mult_32_16(L_shl(a[k], 1), wki));
+ move32();
+ a[k] = xr;
+ move32();
+ }
+ a[m] = Mult_32_16(L_shl(a[m], 1), c[0]);
+}
+
+/*-----------------------------------------------------------------*
+ * edct2_fx()
+ *
+ * Transformation of the signal to DCT domain
+ * OR Inverse EDCT-II for short frames
+ *-----------------------------------------------------------------*/
+
+void edct2_fx(
+ Word16 n,
+ Word16 isgn,
+ Word16 *in,
+ Word32 *a,
+ Word16 *q,
+ const Word16 *ip,
+ const Word16 *w
+)
+{
+ Word16 j, nw, nc;
+ Word32 xr;
+
+ *q = Exp16Array(n, in);
+ *q = add(*q, 6);
+ FOR (j = 0; j < n; j++)
+ {
+ a[j] = L_shl((Word32) in[j], *q);
+ move32();
+ }
+
+ nw = ip[0];
+ move16();
+ if (GT_16(n, shl(nw, 2)))
+ {
+ nw = shr(n, 2);
+ }
+
+ nc = ip[1];
+ move16();
+ if (n > nc)
+ {
+ nc = n;
+ move16();
+ }
+
+ IF (isgn < 0)
+ {
+ xr = a[n - 1];
+ move32();
+ FOR (j = n - 2; j >= 2; j -= 2)
+ {
+ a[j + 1] = L_sub(a[j], a[j - 1]);
+ move32();
+ a[j] = L_add(a[j], a[j - 1]);
+ move32();
+ }
+ a[1] = L_sub(a[0], xr);
+ move32();
+ a[0] = L_add(a[0], xr);
+ move32();
+
+ IF (n > 4)
+ {
+ rftbsub_fx(n, a, nc, w + nw);
+ bitrv2_SR_fx(n, ip + 2, a);
+ cftbsub_fx(n, a, w);
+ }
+ ELSE IF (n == 4)
+ {
+ cftfsub_fx(n, a, w);
+ }
+ }
+
+ IF (isgn >= 0)
+ {
+ a[0] = L_shr(a[0], 1);
+ move32();
+ }
+
+ dctsub_fx(n, a, nc, w + nw);
+
+ IF (isgn >= 0)
+ {
+ IF (n > 4)
+ {
+ bitrv2_SR_fx(n, ip + 2, a);
+ cftfsub_fx(n, a, w);
+ rftfsub_fx(n, a, nc, w + nw);
+ }
+ ELSE IF (n == 4)
+ {
+ cftfsub_fx(n, a, w);
+ }
+ xr = L_sub(a[0], a[1]);
+ a[0] = L_add(a[0], a[1]);
+ move32();
+ FOR (j = 2; j < n; j += 2)
+ {
+ a[j - 1] = L_sub(a[j], a[j + 1]);
+ move32();
+ a[j] = L_add(a[j], a[j + 1]);
+ move32();
+ }
+ a[n - 1] = xr;
+ move32();
+
+ FOR (j = 0; j < n; j ++)
+ {
+ a[j] = L_shr(a[j], 5);
+ move32();
+ }
+ }
+}
+
+
+/*-----------------------------------------------------------------*
+* fft5_shift4()
+* 5-point FFT with 4-point circular shift
+*-----------------------------------------------------------------*/
+
+static void fft5_shift4_16fx(
+ Word16 n1, /* i : length of data */
+ Word16 *zRe, /* i/o : real part of input and output data */
+ Word16 *zIm, /* i/o : imaginary part of input and output data */
+ const Word16 *Idx /* i : pointer of the address table */
+)
+{
+ Word16 T1, To, T8, Tt, T9, Ts, Te, Tp, Th, Tn,T2, T3, T4, T5, T6, T7;
+ Word16 i0,i1,i2,i3,i4;
+ Word32 L_tmp;
+
+ i0 = Idx[0];
+ move16();
+ i1 = Idx[n1];
+ move16();
+ i2 = Idx[n1*2];
+ move16();
+ i3 = Idx[n1*3];
+ move16();
+ i4 = Idx[n1*4];
+ move16();
+
+ T1 = zRe[i0];
+ move16();
+ To = zIm[i0];
+ move16();
+
+ T2 = zRe[i1];
+ move16();
+ T3 = zRe[i4];
+ move16();
+ T4 = add(T2,T3);
+ T5 = zRe[i2];
+ move16();
+ T6 = zRe[i3];
+ move16();
+ T7 = add(T5,T6);
+ T8 = add(T4,T7);
+ Tt = sub(T5,T6);
+ /* T9 = KP559016994 * (T4 - T7); */
+ L_tmp = Mult_32_16(KP559016994_16FX,sub(T4,T7));
+ T9 = round_fx(L_tmp);
+ Ts = sub(T2,T3);
+
+ T2 = zIm[i1];
+ move16();
+ T3 = zIm[i4];
+ move16();
+ T4 = add(T2,T3);
+ T5 = zIm[i2];
+ move16();
+ T6 = zIm[i3];
+ move16();
+ T7 = add(T5,T6);
+ Te = sub(T2,T3);
+ Tp = add(T4,T7);
+ Th = sub(T5,T6);
+ /* Tn = KP559016994 * (T4 - T7); */
+ L_tmp = Mult_32_16(KP559016994_16FX,sub(T4,T7));
+ Tn = round_fx(L_tmp);
+
+ zRe[i0] = add(T1,T8);
+ move16();
+ zIm[i0] = add(To,Tp);
+ move16();
+
+ /* T2 = KP951056516*Te + KP587785252*Th; */
+ L_tmp = Mult_32_16(KP951056516_16FX,Te);
+ L_tmp = Madd_32_16(L_tmp,KP587785252_16FX,Th);
+ T2 = round_fx(L_tmp);
+
+ /*T3 = KP951056516*Th - KP587785252*Te; */
+ L_tmp = Mult_32_16(KP951056516_16FX,Th);
+ L_tmp = Msub_32_16(L_tmp,KP587785252_16FX,Te);
+ T3 = round_fx(L_tmp);
+
+ T6 = sub(T1,shr(T8,2));
+ T4 = add(T9,T6);
+ T5 = sub(T6,T9);
+ zRe[i1] = sub(T4,T2);
+ move16();
+ zRe[i2] = add(T5,T3);
+ move16();
+ zRe[i4] = add(T4,T2);
+ move16();
+ zRe[i3] = sub(T5,T3);
+ move16();
+
+ /* T2 = KP951056516 * Ts + KP587785252 * Tt; */
+ L_tmp = Mult_32_16(KP951056516_16FX,Ts);
+ L_tmp = Madd_32_16(L_tmp,KP587785252_16FX,Tt);
+ T2 = round_fx(L_tmp);
+
+ /* T3 = KP951056516 * Tt - KP587785252 * Ts; */
+ L_tmp = Mult_32_16(KP951056516_16FX,Tt);
+ L_tmp = Msub_32_16(L_tmp,KP587785252_16FX,Ts);
+ T3 = round_fx(L_tmp);
+
+ T6 = sub(To,shr(Tp,2));
+ T4 = add(Tn,T6);
+ T5 = sub(T6,Tn);
+ zIm[i4] = sub(T4,T2);
+ move16();
+ zIm[i2] = sub(T5,T3);
+ move16();
+ zIm[i1] = add(T2,T4);
+ move16();
+ zIm[i3] = add(T3,T5);
+ move16();
+
+ return;
+}
+
+/*-----------------------------------------------------------------*
+* fft5_32()
+* 5-point FFT called for 32 times
+*-----------------------------------------------------------------*/
+static void fft5_32_16fx(
+ Word16 *zRe, /* i/o : real part of input and output data */
+ Word16 *zIm, /* i/o : imaginary part of input and output data */
+ const Word16 *Idx /* i : pointer of the address table */
+)
+{
+ Word16 T1, To, T8, Tt, T9, Ts, Te, Tp, Th, Tn,T2, T3, T4, T5, T6, T7;
+ Word16 i0,i1,i2,i3,i4;
+ Word32 L_tmp;
+
+ i0 = Idx[0];
+ move16();
+ i1 = Idx[32];
+ move16();
+ i2 = Idx[64];
+ move16();
+ i3 = Idx[96];
+ move16();
+ i4 = Idx[128];
+ move16();
+
+ T1 = zRe[i0];
+ move16();
+ To = zIm[i0];
+ move16();
+
+ T2 = zRe[i1];
+ move16();
+ T3 = zRe[i4];
+ move16();
+ T4 = add(T2, T3);
+ T5 = zRe[i2];
+ move16();
+ T6 = zRe[i3];
+ move16();
+ T7 = add(T5,T6);
+ T8 = add(T4,T7);
+ Tt = sub(T5,T6);
+ /* T9 = KP559016994 * (T4 - T7); */
+ L_tmp = Mult_32_16(KP559016994_16FX,sub(T4,T7));
+ T9 = round_fx(L_tmp);
+ Ts = sub(T2,T3);
+
+ T2 = zIm[i1];
+ move16();
+ T3 = zIm[i4];
+ move16();
+ T4 = add(T2,T3);
+ T5 = zIm[i2];
+ move16();
+ T6 = zIm[i3];
+ move16();
+ T7 = add(T5,T6);
+ Te = sub(T2,T3);
+ Tp = add(T4,T7);
+ Th = sub(T5,T6);
+ L_tmp = Mult_32_16(KP559016994_16FX,sub(T4,T7));
+ Tn = round_fx(L_tmp);
+
+
+
+ zRe[i0] = add(T1,T8);
+ move16();
+ zIm[i0] = add(To,Tp);
+ move32();
+
+
+
+ /*T2 = KP951056516*Te + KP587785252*Th; */
+ L_tmp = Mult_32_16(KP951056516_16FX,Te);
+ L_tmp = Madd_32_16(L_tmp,KP587785252_16FX,Th);
+ T2 = round_fx(L_tmp);
+
+ /*T3 = KP951056516*Th - KP587785252*Te; */
+ L_tmp = Mult_32_16(KP951056516_16FX,Th);
+ L_tmp = Msub_32_16(L_tmp,KP587785252_16FX,Te);
+ T3 = round_fx(L_tmp);
+
+
+
+ T6 = sub(T1,shr(T8,2));
+ T4 = add(T9,T6);
+ T5 = sub(T6,T9);
+ zRe[i3] = sub(T4,T2);
+ move32();
+ zRe[i1] = add(T5,T3);
+ move32();
+ zRe[i2] = add(T4,T2);
+ move32();
+ zRe[i4] = sub(T5,T3);
+ move32();
+
+ /* T2 = KP951056516 * Ts + KP587785252 * Tt; */
+ L_tmp = Mult_32_16(KP951056516_16FX,Ts);
+ L_tmp = Madd_32_16(L_tmp,KP587785252_16FX,Tt);
+ T2 = round_fx(L_tmp);
+
+ /* T3 = KP951056516 * Tt - KP587785252 * Ts; */
+ L_tmp = Mult_32_16(KP951056516_16FX,Tt);
+ L_tmp = Msub_32_16(L_tmp,KP587785252_16FX,Ts);
+ T3 = round_fx(L_tmp);
+
+ T6 = sub(To,shr(Tp,2));
+ T4 = add(Tn,T6);
+ T5 = sub(T6,Tn);
+ zIm[i2] = sub(T4,T2);
+ move16();
+ zIm[i1] = sub(T5,T3);
+ move16();
+ zIm[i3] = add(T2,T4);
+ move16();
+ zIm[i4] = add(T3,T5);
+ move16();
+
+
+ return;
+}
+
+/*-----------------------------------------------------------------*
+* fft64()
+* 64-point FFT
+*-----------------------------------------------------------------*/
+static void fft64_16fx(
+ Word16 *x, /* i/o : real part of input and output data */
+ Word16 *y, /* i/o : imaginary part of input and output data */
+ const Word16 *Idx /* i : pointer of the address table */
+)
+{
+ Word16 i,id,jd;
+ Word16 z[128];
+ move16();/*penalty for 1 ptr init */
+ FOR ( i=0; i<64; i++ )
+ {
+ id = Idx[i];
+ move16();
+ z[2*i] = x[id];
+ move16();
+ z[2*i+1] = y[id];
+ move16();
+ }
+
+ cdftForw_16fx(128, z, Ip_fft64_16fx, w_fft128_16fx);
+
+ move16();/*penalty for 1 ptr init */
+ FOR( i=0; i<64 ; i++)
+ {
+ jd = Odx_fft64_16fx[i];
+ move16();
+ id = Idx[jd];
+ move16();
+ x[id]=z[2*i];
+ move16();
+ y[id]=z[2*i+1];
+ move16();
+ }
+
+ return;
+}
+
+
+/*-----------------------------------------------------------------*
+* fft32_5()
+* 32-point FFT called for 5 times
+*-----------------------------------------------------------------*/
+static void fft32_5_16fx(
+ Word16 *x, /* i/o : real part of input and output data */
+ Word16 *y, /* i/o : imaginary part of input and output data */
+ const Word16 *Idx /* i : pointer of the address table */
+)
+{
+ Word16 i,id,jd;
+ Word16 z[64];
+
+ move16();/*penalty for 1 ptr init */
+ FOR( i=0; i<32; i++ )
+ {
+ id = Idx[i];
+ move16();
+ z[2*i] = x[id];
+ move16();
+ z[2*i+1] = y[id];
+ move16();
+ }
+
+ cdftForw_16fx(64,z,Ip_fft32_16fx,w_fft32_16fx);
+
+ move16();/*penalty for 1 ptr init */
+ FOR( i=0; i<32; i++ )
+ {
+ jd = Odx_fft32_5[i];
+ move16();
+ id = Idx[jd];
+ move16();
+ x[id]=z[2*i];
+ move16();
+ y[id]=z[2*i+1];
+ move16();
+ }
+
+ return;
+}
+
+
+
+/*-----------------------------------------------------------------*
+* DoRTFT160()
+* a low complexity 2-dimensional DFT of 160 points
+*-----------------------------------------------------------------*/
+void DoRTFT160_16fx(
+ Word16 x[], /* i/o : real part of input and output data */
+ Word16 y[] /* i/o : imaginary part of input and output data */
+)
+{
+ Word16 j;
+
+ /* Applying 32-point FFT for 5 times based on the address table Idx_dortft160 */
+ FOR(j=0; j<5; j++)
+ {
+ fft32_5_16fx(x,y,Idx_dortft160+shl(j,5)/*32*j*/);
+ }
+
+ /* Applying 5-point FFT for 32 times based on the address table Idx_dortft160 */
+ FOR(j=0; j<32; j++)
+ {
+ fft5_32_16fx(x,y,Idx_dortft160+j);
+ }
+
+ return;
+}
+
+/*-----------------------------------------------------------------*
+* DoRTFT320()
+* a low complexity 2-dimensional DFT of 320 points
+*-----------------------------------------------------------------*/
+void DoRTFT320_16fx(
+ Word16 *x, /* i/o : real part of input and output data */
+ Word16 *y /* i/o : imaginary part of input and output data */
+)
+{
+ Word16 j;
+
+ /* Applying 64-point FFT for 5 times based on the address table Idx_dortft160 */
+ FOR(j=0; j<5; j++)
+ {
+ fft64_16fx(x,y,Idx_dortft320_16fx+shl(j,6)/*64*j*/);
+ }
+
+ /* Applying 5-point FFT for 64 times based on the address table Idx_dortft160 */
+ FOR(j=0; j<64; j++)
+ {
+ fft5_shift4_16fx(64,x,y,Idx_dortft320_16fx+j);
+ }
+
+ return;
+}
+
+/*-----------------------------------------------------------------*
+* DoRTFT128()
+* FFT with 128 points
+*-----------------------------------------------------------------*/
+void DoRTFT128_16fx(
+ Word16 *x, /* i/o : real part of input and output data Q(Qx+Q_edct)*/
+ Word16 *y /* i/o : imaginary part of input and output data Q(Qx+Q_edct)*/
+)
+{
+
+ Word16 i;
+ Word16 z[256];
+
+ move16();/*penalty for 1 ptr init */
+ FOR ( i=0; i<128; i++ )
+ {
+ z[2*i] = x[i];
+ move16();
+ z[2*i+1] = y[i];
+ move16();
+ }
+
+ cdftForw_16fx(256,z,Ip_fft128_16fx,w_fft128_16fx);
+
+ x[0]=z[0];
+ move16();
+ y[0]=z[1];
+ move16();
+ move16();/*penalty for 1 ptr init */
+ move16();/*penalty for 1 ptr init */
+ FOR( i=1; i<128 ; i++)
+ {
+ x[128-i]=z[2*i];
+ move16();
+ y[128-i]=z[2*i+1];
+ move16();
+ }
+
+ return;
+}
+/*-----------------------------------------------------------------*
+* cdftForw()
+* Main fuction of Complex Discrete Fourier Transform
+*-----------------------------------------------------------------*/
+static void cdftForw_16fx(
+ Word16 n, /* i : data length of real and imag */
+ Word16 *a, /* i/o : input/output data Q(Qx+Q_edct)*/
+ const Word16 *ip, /* i : work area for bit reversal */
+ const Word32 *w /* i : cos/sin table Q30*/
+)
+{
+ /* bit reversal */
+ bitrv2_SR_16fx(n, ip + 2, a);
+
+ /* Do FFT */
+ cftfsub_16fx(n, a, w);
+}
+
+/*-----------------------------------------------------------------*
+* bitrv2_SR()
+* Bit reversal
+*-----------------------------------------------------------------*/
+static void bitrv2_SR_16fx(
+ Word16 n, /* i : data length of real and imag */
+ const Word16 *ip, /* i/o : work area for bit reversal */
+ Word16 *a /* i/o : input/output data Q(Qx+Q_edct)*/
+)
+{
+ Word16 j, j1, k, k1, m, m2;
+ Word16 l;
+ Word16 xr, xi, yr, yi;
+
+ l = n;
+ move16();
+ m = 1;
+ move16();
+
+ WHILE (LT_16(shl(m,3),l))
+ {
+ l = shr(l,1);
+ m = shl(m,1);
+ }
+
+ m2 = shl(m,1);
+ IF (EQ_16(shl(m, 3),l))
+ {
+ FOR (k = 0; k < m; k++)
+ {
+ FOR (j = 0; j < k; j++)
+ {
+ j1 = add(shl(j,1),ip[k]);
+ k1 = add(shl(k,1),ip[j]);
+ xr = a[j1];
+ move16();
+ xi = a[j1 + 1];
+ move16();
+ yr = a[k1];
+ move16();
+ yi = a[k1 + 1];
+ move16();
+ a[j1] = yr;
+ move16();
+ a[j1 + 1] = yi;
+ move16();
+ a[k1] = xr;
+ move16();
+ a[k1 + 1] = xi;
+ move16();
+ j1 = add(j1,m2);
+ k1 = add(k1,shl(m2,1));
+ xr = a[j1];
+ move16();
+ xi = a[j1 + 1];
+ move16();
+ yr = a[k1];
+ move16();
+ yi = a[k1 + 1];
+ move16();
+ a[j1] = yr;
+ move16();
+ a[j1 + 1] = yi;
+ move16();
+ a[k1] = xr;
+ move16();
+ a[k1 + 1] = xi;
+ move16();
+ j1 = add(j1,m2);
+ k1 = sub(k1,m2);
+ xr = a[j1];
+ move16();
+ xi = a[j1 + 1];
+ move16();
+ xi = a[j1 + 1];
+ move16();
+ yr = a[k1];
+ move16();
+ yi = a[k1 + 1];
+ move16();
+ a[j1] = yr;
+ move16();
+ a[j1 + 1] = yi;
+ move16();
+ a[k1] = xr;
+ move16();
+ a[k1 + 1] = xi;
+ move16();
+ j1 = add(j1,m2);
+ k1 = add(k1,shl(m2,1));
+ xr = a[j1];
+ move16();
+ xi = a[j1 + 1];
+ move16();
+ yr = a[k1];
+ move16();
+ yi = a[k1 + 1];
+ move16();
+ a[j1] = yr;
+ move16();
+ a[j1 + 1] = yi;
+ move16();
+ a[k1] = xr;
+ move16();
+ a[k1 + 1] = xi;
+ move16();
+ }
+
+ j1 = add(add(shl(k,1),m2),ip[k]);
+ k1 = add(j1,m2);
+ xr = a[j1];
+ move16();
+ xi = a[j1 + 1];
+ move16();
+ yr = a[k1];
+ move16();
+ yi = a[k1 + 1];
+ move16();
+ a[j1] = yr;
+ move16();
+ a[j1 + 1] = yi;
+ move16();
+ a[k1] = xr;
+ move16();
+ a[k1 + 1] = xi;
+ move16();
+ }
+ }
+ ELSE
+ {
+ FOR (k = 1; k < m; k++)
+ {
+ FOR (j = 0; j < k; j++)
+ {
+ j1 = add(shl(j,1),ip[k]);
+ k1 = add(shl(k,1),ip[j]);
+ xr = a[j1];
+ move16();
+ xi = a[j1 + 1];
+ move16();
+ yr = a[k1];
+ move16();
+ yi = a[k1 + 1];
+ move16();
+ a[j1] = yr;
+ move16();
+ a[j1 + 1] = yi;
+ move16();
+ a[k1] = xr;
+ move16();
+ a[k1 + 1] = xi;
+ move16();
+ j1 = add(j1,m2);
+ k1 = add(k1,m2);
+ xr = a[j1];
+ move16();
+ xi = a[j1 + 1];
+ move16();
+ yr = a[k1];
+ move16();
+ yi = a[k1 + 1];
+ move16();
+ a[j1] = yr;
+ move16();
+ a[j1 + 1] = yi;
+ move16();
+ a[k1] = xr;
+ move16();
+ a[k1 + 1] = xi;
+ move16();
+ }
+ }
+ }
+
+ return;
+}
+
+/*-----------------------------------------------------------------*
+* cftfsub()
+* Complex Discrete Fourier Transform
+*-----------------------------------------------------------------*/
+static void cftfsub_16fx(
+ Word16 n, /* i : data length of real and imag */
+ Word16 *a, /* i/o : input/output data Q(Qx+Q_edct)*/
+ const Word32 *w /* i : cos/sin table Q30*/
+)
+{
+ Word16 j, j1, j2, j3, l;
+ Word16 x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+
+ l = 2;
+ move16();
+ IF (GT_16(n,8))
+ {
+ cft1st_16fx(n, a, w);
+ l = 8;
+ move16();
+ WHILE (LT_16(shl(l, 2),n))
+ {
+ cftmdl_16fx(n, l, a, w);
+ l = shl(l,2);
+ }
+ }
+
+ IF (EQ_16(shl(l,2),n))
+ {
+ FOR (j = 0; j < l; j += 2)
+ {
+ j1 = add(j,l);
+ j2 = add(j1,l);
+ j3 = add(j2,l);
+ x0r = add(a[j],a[j1]);
+ x0i = add(a[j + 1],a[j1 + 1]);
+ x1r = sub(a[j],a[j1]);
+ x1i = sub(a[j + 1],a[j1 + 1]);
+ x2r = add(a[j2],a[j3]);
+ x2i = add(a[j2 + 1],a[j3 + 1]);
+ x3r = sub(a[j2],a[j3]);
+ x3i = sub(a[j2 + 1],a[j3 + 1]);
+ a[j] = add(x0r,x2r);
+ move16();
+ a[j + 1] = add(x0i,x2i);
+ move16();
+ a[j2] = sub(x0r,x2r);
+ move16();
+ a[j2 + 1] = sub(x0i,x2i);
+ move16();
+ a[j1] = sub(x1r,x3i);
+ move16();
+ a[j1 + 1] = add(x1i,x3r);
+ move16();
+ a[j3] = add(x1r,x3i);
+ move16();
+ a[j3 + 1] = sub(x1i,x3r);
+ move16();
+ }
+ }
+ ELSE
+ {
+ FOR (j = 0; j < l; j += 2)
+ {
+ j1 = add(j,l);
+ x0r = sub(a[j],a[j1]);
+ x0i = sub(a[j + 1],a[j1 + 1]);
+ a[j] = add(a[j],a[j1]);
+ move16();
+ a[j + 1] = add(a[j + 1],a[j1 + 1]);
+ move16();
+ a[j1] = x0r;
+ move16();
+ a[j1 + 1] = x0i;
+ move16();
+ }
+ }
+ return;
+}
+
+/*-----------------------------------------------------------------*
+* cft1st()
+* Subfunction of Complex Discrete Fourier Transform
+*-----------------------------------------------------------------*/
+static void cft1st_16fx(
+ Word16 n, /* i : data length of real and imag */
+ Word16 *a, /* i/o : input/output data Q(Qx+Q_edct)*/
+ const Word32 *w /* i : cos/sin table Q30*/
+)
+{
+ Word16 j, k1, k2;
+ Word32 wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
+ Word16 x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+ Word16 tmp;
+ Word32 L_tmp;
+
+ x0r = add(a[0],a[2]);
+ x0i = add(a[1],a[3]);
+ x1r = sub(a[0],a[2]);
+ x1i = sub(a[1],a[3]);
+ x2r = add(a[4],a[6]);
+ x2i = add(a[5],a[7]);
+ x3r = sub(a[4],a[6]);
+ x3i = sub(a[5],a[7]);
+ a[0] = add(x0r,x2r);
+ move16();
+ a[1] = add(x0i,x2i);
+ move16();
+ a[4] = sub(x0r,x2r);
+ move16();
+ a[5] = sub(x0i,x2i);
+ move16();
+ a[2] = sub(x1r,x3i);
+ move16();
+ a[3] = add(x1i,x3r);
+ move16();
+ a[6] = add(x1r,x3i);
+ move16();
+ a[7] = sub(x1i,x3r);
+ move16();
+
+ wk1r = w[2];
+ move32();
+
+ x0r = add(a[8],a[10]);
+ x0i = add(a[9],a[11]);
+ x1r = sub(a[8],a[10]);
+ x1i = sub(a[9],a[11]);
+ x2r = add(a[12],a[14]);
+ x2i = add(a[13],a[15]);
+ x3r = sub(a[12],a[14]);
+ x3i = sub(a[13],a[15]);
+ a[8] = add(x0r,x2r);
+ move16();
+ a[9] = add(x0i,x2i);
+ move16();
+ a[12] = sub(x2i,x0i);
+ move16();
+ a[13] = sub(x0r,x2r);
+ move16();
+
+ x0r = sub(x1r,x3i);
+ x0i = add(x1i,x3r);
+ tmp = sub(x0r,x0i);
+ L_tmp = Mult_32_16(wk1r,tmp); /*Q(15+Qx+Q_edct) */
+
+ a[10] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ tmp = add(x0r,x0i);
+ L_tmp = Mult_32_16(wk1r,tmp); /*Q(15+Qx+Q_edct) */
+ a[11] = round_fx(L_shl(L_tmp,1)); /* Q(Qx+Q_edct) */
+
+ x0r = add(x3i,x1r);
+ x0i = sub(x3r,x1i);
+ tmp = sub(x0i,x0r);
+ L_tmp = Mult_32_16(wk1r,tmp); /*Q(15+Qx+Q_edct) */
+ a[14] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ tmp = add(x0i,x0r);
+ L_tmp = Mult_32_16(wk1r,tmp); /*Q(15+Qx+Q_edct) */
+ a[15] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ k1 = 0;
+ move16();
+
+ FOR (j = 16; j < n; j += 16)
+ {
+ k1 = add(k1,2);
+ k2 = shl(k1,1);
+
+ wk2r = w[k1]; move32();
+ wk2i = w[k1 + 1]; move32();
+ wk1r = w[k2]; move32();
+ wk1i = w[k2 + 1]; move32();
+
+ L_tmp = L_shl(Mult_32_32(wk2i,wk1i),1);/*Q29 */
+ wk3r = L_sub(wk1r,L_shl(L_tmp,1));/*Q30 */
+
+ L_tmp = L_shl(Mult_32_32(wk2i,wk1r),1);/*Q29 */
+ wk3i = L_sub(L_shl(L_tmp,1),wk1i);/*Q30 */
+
+ x0r = add(a[j],a[j + 2]);
+ x0i = add(a[j + 1],a[j + 3]);
+ x1r = sub(a[j],a[j + 2]);
+ x1i = sub(a[j + 1],a[j + 3]);
+ x2r = add(a[j + 4],a[j + 6]);
+ x2i = add(a[j + 5],a[j + 7]);
+ x3r = sub(a[j + 4],a[j + 6]);
+ x3i = sub(a[j + 5],a[j + 7]);
+ a[j] = add(x0r,x2r);
+ move16();
+ a[j + 1] = add(x0i,x2i);
+ move16();
+
+ x0r = sub(x0r,x2r);
+ x0i = sub(x0i,x2i);
+ L_tmp = Mult_32_16(wk2r,x0r);/*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk2i,x0i); /*Q(15+Qx+Q_edct) */
+ a[j + 4] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_tmp = Mult_32_16(wk2r,x0i);/*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk2i,x0r); /*Q(15+Qx+Q_edct) */
+ a[j + 5] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ x0r = sub(x1r,x3i);
+ x0i = add(x1i,x3r);
+ L_tmp = Mult_32_16(wk1r,x0r);/*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk1i,x0i); /*Q(15+Qx+Q_edct) */
+ a[j + 2] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_tmp = Mult_32_16(wk1r,x0i);/*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk1i,x0r); /*Q(15+Qx+Q_edct) */
+ a[j + 3] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ x0r = add(x1r,x3i);
+ x0i = sub(x1i,x3r);
+ L_tmp = Mult_32_16(wk3r,x0r); /*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk3i,x0i); /*Q(15+Qx+Q_edct) */
+ a[j + 6] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_tmp = Mult_32_16(wk3r,x0i); /*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk3i,x0r); /*Q(15+Qx+Q_edct) */
+ a[j + 7] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ wk1r = w[k2 + 2]; move32();
+ wk1i = w[k2 + 3]; move32();
+ L_tmp = L_shl(Mult_32_32(wk2r,wk1i),1);/*Q29 */
+ wk3r = L_sub(wk1r,L_shl(L_tmp,1)); /*Q30 */
+
+ L_tmp = L_shl(Mult_32_32(wk2r,wk1r),1);/*Q29 */
+ wk3i = L_sub(L_shl(L_tmp,1),wk1i); /*Q30 */
+
+ x0r = add(a[j + 8],a[j + 10]);
+ x0i = add(a[j + 9],a[j + 11]);
+ x1r = sub(a[j + 8],a[j + 10]);
+ x1i = sub(a[j + 9],a[j + 11]);
+ x2r = add(a[j + 12],a[j + 14]);
+ x2i = add(a[j + 13],a[j + 15]);
+ x3r = sub(a[j + 12],a[j + 14]);
+ x3i = sub(a[j + 13],a[j + 15]);
+ a[j + 8] = add(x0r,x2r);
+ move16();
+ a[j + 9] = add(x0i,x2i);
+ move16();
+
+ x0r = sub(x0r,x2r);
+ x0i = sub(x0i,x2i);
+ tmp = negate(x0r);
+ L_tmp = Mult_32_16(wk2i,tmp);/*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk2r,x0i); /*Q(15+Qx+Q_edct) */
+ a[j + 12] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ tmp = negate(x0i);
+ L_tmp = Mult_32_16(wk2i,tmp);/*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk2r,x0r); /*Q(15+Qx+Q_edct) */
+ a[j + 13] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ x0r = sub(x1r,x3i);
+ x0i = add(x1i,x3r);
+ L_tmp = Mult_32_16(wk1r,x0r);/*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk1i,x0i); /*Q(15+Qx+Q_edct) */
+ a[j + 10] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_tmp = Mult_32_16(wk1r,x0i);/*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk1i,x0r); /*Q(15+Qx+Q_edct) */
+ a[j + 11] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ x0r = add(x1r,x3i);
+ x0i = sub(x1i,x3r);
+
+ L_tmp = Mult_32_16(wk3r,x0r); /*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk3i,x0i); /*Q(15+Qx+Q_edct) */
+ a[j + 14] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_tmp = Mult_32_16(wk3r,x0i); /*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk3i,x0r); /*Q(15+Qx+Q_edct) */
+ a[j + 15] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+ }
+
+ return;
+}
+
+/*-----------------------------------------------------------------*
+* cftmdl()
+* Subfunction of Complex Discrete Fourier Transform
+*-----------------------------------------------------------------*/
+static void cftmdl_16fx(
+ Word16 n, /* i : data length of real and imag */
+ Word16 l, /* i : initial shift for processing */
+ Word16 *a, /* i/o : input/output data Q(Qx+Q_edct)*/
+ const Word32 *w /* i : cos/sin table Q30*/
+)
+{
+ Word16 j, j1, j2, j3, k, k1, k2, m, m2;
+ Word32 wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
+ Word16 x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+ Word16 tmp, tmp2;
+ Word32 L_tmp;
+ Word32 L_x0r, L_x0i;
+
+ m = shl(l, 2);
+ move16();
+ FOR (j = 0; j < l; j += 2)
+ {
+ j1 = add(j,l);
+ j2 = add(j1,l);
+ j3 = add(j2,l);
+ x0r = add(a[j],a[j1]);
+ x0i = add(a[j + 1],a[j1 + 1]);
+ x1r = sub(a[j],a[j1]);
+ x1i = sub(a[j + 1],a[j1 + 1]);
+ x2r = add(a[j2],a[j3]);
+ x2i = add(a[j2 + 1],a[j3 + 1]);
+ x3r = sub(a[j2],a[j3]);
+ x3i = sub(a[j2 + 1],a[j3 + 1]);
+ a[j] = add(x0r,x2r);
+ move16();
+ a[j + 1] = add(x0i,x2i);
+ move16();
+ a[j2] = sub(x0r,x2r);
+ move16();
+ a[j2 + 1] = sub(x0i,x2i);
+ move16();
+ a[j1] = sub(x1r,x3i);
+ move16();
+ a[j1 + 1] = add(x1i,x3r);
+ move16();
+ a[j3] = add(x1r,x3i);
+ move16();
+ a[j3 + 1] = sub(x1i,x3r);
+ move16();
+ }
+
+ wk1r = w[2];
+ move32();
+ tmp2 = add(l,m);
+ FOR (j = m; j < tmp2; j += 2)
+ {
+ j1 = add(j,l);
+ j2 = add(j1,l);
+ j3 = add(j2,l);
+ x0r = add(a[j],a[j1]);
+ x0i = add(a[j + 1],a[j1 + 1]);
+ x1r = sub(a[j],a[j1]);
+ x1i = sub(a[j + 1],a[j1 + 1]);
+ x2r = add(a[j2],a[j3]);
+ x2i = add(a[j2 + 1],a[j3 + 1]);
+ x3r = sub(a[j2],a[j3]);
+ x3i = sub(a[j2 + 1],a[j3 + 1]);
+ a[j] = add(x0r,x2r);
+ move16();
+ a[j + 1] = add(x0i,x2i);
+ move16();
+ a[j2] = sub(x2i,x0i);
+ move16();
+ a[j2 + 1] = sub(x0r,x2r);
+ move16();
+
+ x0r = sub(x1r,x3i);
+ x0i = add(x1i,x3r);
+ tmp = sub(x0r,x0i);
+ L_tmp = Mult_32_16(wk1r,tmp);/*Q(15+Qx+Q_edct) */
+ a[j1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ tmp = add(x0r,x0i);
+ L_tmp = Mult_32_16(wk1r,tmp); /*Q(15+Qx+Q_edct) */
+ a[j1 + 1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ x0r = add(x3i,x1r);
+ x0i = sub(x3r,x1i);
+ tmp = sub(x0i,x0r);
+ L_tmp = Mult_32_16(wk1r,tmp);/*Q(15+Qx+Q_edct) */
+ a[j3] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ tmp = add(x0i,x0r);
+ L_tmp = Mult_32_16(wk1r,tmp); /*Q(15+Qx+Q_edct) */
+ a[j3 + 1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+ }
+
+ k1 = 0;
+ move16();
+ m2 = shl(m,1);
+ FOR (k = m2; k < n; k += m2)
+ {
+ k1 = add(k1,2);
+ k2 = shl(k1,1);
+ wk2r = w[k1]; move32();
+ wk2i = w[k1 + 1]; move32();
+ wk1r = w[k2]; move32();
+ wk1i = w[k2 + 1]; move32();
+ L_tmp = L_shl(Mult_32_32(wk2i,wk1i),1);/*Q29 */
+ wk3r = L_sub(wk1r,L_shl(L_tmp,1));/*Q30 */
+
+ L_tmp = L_shl(Mult_32_32(wk2i,wk1r),1);/*Q29 */
+ wk3i = L_sub(L_shl(L_tmp,1),wk1i);/*Q30 */
+
+ tmp2 = add(l,k);
+ FOR (j = k; j < tmp2; j += 2)
+ {
+ j1 = add(j,l);
+ j2 = add(j1,l);
+ j3 = add(j2,l);
+ x0r = add(a[j],a[j1]);
+ x0i = add(a[j + 1],a[j1 + 1]);
+ x1r = sub(a[j],a[j1]);
+ x1i = sub(a[j + 1],a[j1 + 1]);
+ x2r = add(a[j2],a[j3]);
+ x2i = add(a[j2 + 1],a[j3 + 1]);
+ x3r = sub(a[j2],a[j3]);
+ x3i = sub(a[j2 + 1],a[j3 + 1]);
+ a[j] = add(x0r,x2r);
+ move16();
+ a[j + 1] = add(x0i,x2i);
+ move16();
+
+ x0r = sub(x0r,x2r);
+ x0i = sub(x0i,x2i);
+
+ L_tmp = Mult_32_16(wk2r,x0r); /*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk2i,x0i); /*Q(15+Qx+Q_edct) */
+ a[j2] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_tmp = Mult_32_16(wk2r,x0i); /*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk2i,x0r); /*Q(15+Qx+Q_edct) */
+ a[j2 + 1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ x0r = sub(x1r,x3i);
+ x0i = add(x1i,x3r);
+
+ L_tmp = Mult_32_16(wk1r,x0r); /*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk1i,x0i); /*Q(15+Qx+Q_edct) */
+ a[j1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_tmp = Mult_32_16(wk1r,x0i); /*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk1i,x0r); /*Q(15+Qx+Q_edct) */
+ a[j1 + 1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_x0r = L_add((Word32) x1r, (Word32) x3i);
+ L_x0i = L_sub((Word32) x1i, (Word32) x3r);
+ x0r = extract_l(L_x0r);
+ x0i = extract_l(L_x0i);
+ L_tmp = Mult_32_16(wk3r,x0r); /*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk3i,x0i); /*Q(15+Qx+Q_edct) */
+ a[j3] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_tmp = Mult_32_16(wk3r,x0i); /*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk3i,x0r); /*Q(15+Qx+Q_edct) */
+ a[j3 + 1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+ }
+
+ wk1r = w[k2 + 2];
+ move32();
+ wk1i = w[k2 + 3];
+ move32();
+ L_tmp = L_shl(Mult_32_32(wk2r,wk1i),1);/*Q29 */
+ wk3r = L_sub(wk1r,L_shl(L_tmp,1)); /*Q30 */
+
+ L_tmp = L_shl(Mult_32_32(wk2r,wk1r),1);/*Q29 */
+ wk3i = L_sub(L_shl(L_tmp,1),wk1i); /*Q30 */
+
+ tmp2 = add(l,add(k,m));
+ FOR (j = add(k,m); j < tmp2; j += 2)
+ {
+ j1 = add(j,l);
+ j2 = add(j1,l);
+ j3 = add(j2,l);
+ x0r = add(a[j],a[j1]);
+ x0i = add(a[j + 1],a[j1 + 1]);
+ x1r = sub(a[j],a[j1]);
+ x1i = sub(a[j + 1],a[j1 + 1]);
+ x2r = add(a[j2],a[j3]);
+ x2i = add(a[j2 + 1],a[j3 + 1]);
+ x3r = sub(a[j2],a[j3]);
+ x3i = sub(a[j2 + 1],a[j3 + 1]);
+ a[j] = add(x0r,x2r);
+ move16();
+ a[j + 1] = add(x0i,x2i);
+ move16();
+
+ x0r = sub(x0r,x2r);
+ x0i = sub(x0i,x2i);
+
+ tmp = negate(x0r);
+ L_tmp = Mult_32_16(wk2i,tmp);/*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk2r,x0i); /*Q(15+Qx+Q_edct) */
+ a[j2] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ tmp = negate(x0i);
+ L_tmp = Mult_32_16(wk2i,tmp);/*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk2r,x0r); /*Q(15+Qx+Q_edct) */
+ a[j2 + 1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ x0r = sub(x1r,x3i);
+ x0i = add(x1i,x3r);
+
+ L_tmp = Mult_32_16(wk1r,x0r);/*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk1i,x0i); /*Q(15+Qx+Q_edct) */
+ a[j1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_tmp = Mult_32_16(wk1r,x0i);/*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk1i,x0r); /*Q(15+Qx+Q_edct) */
+ a[j1 + 1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ x0r = add(x1r,x3i);
+ x0i = sub(x1i,x3r);
+
+ L_tmp = Mult_32_16(wk3r,x0r); /*Q(15+Qx+Q_edct) */
+ L_tmp = Msub_32_16(L_tmp,wk3i,x0i); /*Q(15+Qx+Q_edct) */
+ a[j3] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+
+ L_tmp = Mult_32_16(wk3r,x0i); /*Q(15+Qx+Q_edct) */
+ L_tmp = Madd_32_16(L_tmp,wk3i,x0r); /*Q(15+Qx+Q_edct) */
+ a[j3 + 1] = round_fx(L_shl(L_tmp,1)); /*Q(Qx+Q_edct) */
+ }
+ }
+
+ return;
+}
+
+void fft3_fx(const Word16 X[], Word16 Y[], const Word16 n)
+{
+ Word16 Z[PH_ECU_SPEC_SIZE];
+ Word16 *Z0, *Z1, *Z2;
+ Word16 *z0, *z1, *z2;
+ const Word16 *x;
+ const Word16 *t_sin = sincos_t_rad3_fx;
+ Word16 m, mMinus1, step;
+ Word16 i, l;
+ Word16 c1_ind, s1_ind, c2_ind, s2_ind;
+ Word16 c1_step, s1_step, c2_step, s2_step;
+ Word16 *RY, *IY, *RZ0, *IZ0, *RZ1, *IZ1, *RZ2, *IZ2;
+ Word32 acc;
+ Word16 mBy2, orderMinus1;
+ const Word16 *pPhaseTbl;
+
+ /* Determine the order of the transform, the length of decimated */
+ /* transforms m, and the step for the sine and cosine tables. */
+ SWITCH(n)
+ {
+ case 1536:
+ orderMinus1 = 9-1;
+ move16();
+ m = 512;
+ move16();
+ step = 1;
+ move16();
+ pPhaseTbl = FFT_W256;
+ BREAK;
+ case 384:
+ orderMinus1 = 7-1;
+ move16();
+ m = 128;
+ move16();
+ step = 4;
+ move16();
+ pPhaseTbl = FFT_W64;
+ BREAK;
+ default:
+ orderMinus1 = 7-1;
+ move16();
+ m = 128;
+ move16();
+ step = 4;
+ move16();
+ pPhaseTbl = FFT_W64;
+ BREAK;
+ }
+
+ /* Compose decimated sequences X[3i], X[3i+1],X[3i+2] */
+ /* compute their FFT of length m. */
+ Z0 = &Z[0];
+ z0 = &Z0[0];
+ Z1 = &Z0[m];
+ z1 = &Z1[0]; /* Z1 = &Z[ m]; */
+ Z2 = &Z1[m];
+ z2 = &Z2[0]; /* Z2 = &Z[2m]; */
+ x = &X[0];
+ FOR (i = 0; i < m; i++)
+ {
+ *z0++ = *x++; /* Z0[i] = X[3i]; */ move16();
+ *z1++ = *x++; /* Z1[i] = X[3i+1]; */ move16();
+ *z2++ = *x++; /* Z2[i] = X[3i+2]; */ move16();
+ }
+ mBy2 = shr(m,1);
+ r_fft_fx_lc(pPhaseTbl, m, mBy2, orderMinus1, Z0, Z0, 1);
+ r_fft_fx_lc(pPhaseTbl, m, mBy2, orderMinus1, Z1, Z1, 1);
+ r_fft_fx_lc(pPhaseTbl, m, mBy2, orderMinus1, Z2, Z2, 1);
+
+ /* Butterflies of order 3. */
+ /* pointer initialization */
+ mMinus1 = sub(m,1);
+ RY = &Y[0];
+ IY = &Y[n];
+ IY--; /* Decrement the address counter.*/
+ RZ0 = &Z0[0];
+ IZ0 = &Z0[mMinus1];
+ RZ1 = &Z1[0];
+ IZ1 = &Z1[mMinus1];
+ RZ2 = &Z2[0];
+ IZ2 = &Z2[mMinus1];
+
+ c1_step = negate(step);
+ s1_step = step;
+ move16();
+ c2_step = shl(c1_step,1);
+ s2_step = shl(s1_step,1);
+ c1_ind = add(T_SIN_PI_2, c1_step);
+ s1_ind = s1_step;
+ move16();
+ c2_ind = add(T_SIN_PI_2, c2_step);
+ s2_ind = s2_step;
+ move16();
+
+ /* special case: i = 0 */
+ acc = L_mult(*RZ0++, 0x4000);
+ acc = L_mac(acc, *RZ1++, 0x4000);
+ *RY++ = mac_r(acc, *RZ2++, 0x4000);
+ move16();
+
+ /* first 3/12-- from 1 to (3*m/8)-1 */
+ l = sub(shr(n, 3),1); /* (3*m/8) - 1 = (n/8) - 1 */
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_shl(*RZ0++, 15); /* Align with the following non-fractional mode so as to gain 1 more bit headroom. */
+ acc = L_mac0(acc, *RZ1, t_sin[c1_ind]); /* Non-fractional mode gains 1 more bit headroom. */
+ acc = L_mac0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_mac0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_mac0(acc, *IZ2, t_sin[s2_ind]);
+ *RY++ = round_fx(acc); /* bit growth = 1 (compensated by non-fractional mode MAC). */
+
+ acc = L_shl(*IZ0--, 15);
+ acc = L_msu0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_mac0(acc, *IZ1--, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2++, t_sin[s2_ind]);
+ acc = L_mac0(acc, *IZ2--, t_sin[c2_ind]);
+ *IY-- = round_fx(acc);
+
+ c1_ind = add(c1_ind, c1_step);
+ s1_ind = add(s1_ind, s1_step);
+ c2_ind = add(c2_ind, c2_step);
+ s2_ind = add(s2_ind, s2_step);
+ }
+
+ /* next 1/12-- from (3*m/8) to (4*m/8)-1 */
+ l = shr(m,3); /* (4*m/8) - (3*m/8) = m/8 */
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_shl(*RZ0++, 15);
+ acc = L_mac0(acc, *RZ1, t_sin[c1_ind]); /* Non-fractional mode gains 1 more bit headroom. */
+ acc = L_mac0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_mac0(acc, *IZ2, t_sin[s2_ind]);
+ *RY++ = round_fx(acc);
+
+ acc = L_shl(*IZ0--, 15);
+ acc = L_msu0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_mac0(acc, *IZ1--, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2++, t_sin[s2_ind]);
+ acc = L_msu0(acc, *IZ2--, t_sin[c2_ind]);
+ *IY-- = round_fx(acc);
+
+ c1_ind = add(c1_ind, c1_step);
+ s1_ind = add(s1_ind, s1_step);
+ c2_ind = sub(c2_ind, c2_step);
+ s2_ind = sub(s2_ind, s2_step);
+ }
+
+ /* special case: i = m/2 i.e. 1/3 */
+ acc = L_shl(*RZ0--, 15);
+ acc = L_mac0(acc, *RZ1, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ *RY++ = round_fx(acc);
+
+ acc = 0;
+ acc = L_msu0(acc, *RZ1--, t_sin[s1_ind]);
+ acc = L_msu0(acc, *RZ2--, t_sin[s2_ind]);
+ *IY-- = round_fx(acc);
+ IZ0++;
+ IZ1++;
+ IZ2++;
+
+ c1_ind = add(c1_ind, c1_step);
+ s1_ind = add(s1_ind, s1_step);
+ c2_ind = sub(c2_ind, c2_step);
+ s2_ind = sub(s2_ind, s2_step);
+
+ /* next 2/12-- from ((m/2)+1) to (6*m/8)-1 */
+ l = sub(shr(m,2), 1); /* (6*m/8) - ((m/2)+1) = m/4 - 1 */
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_shl(*RZ0--, 15);
+ acc = L_mac0(acc, *RZ1, t_sin[c1_ind]); /* Non-fractional mode gains 1 more bit headroom. */
+ acc = L_msu0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ2, t_sin[s2_ind]);
+ *RY++ = round_fx(acc);
+
+ acc = L_mult0(*IZ0++, -32768);
+ acc = L_msu0(acc, *RZ1--, t_sin[s1_ind]);
+ acc = L_msu0(acc, *IZ1++, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2--, t_sin[s2_ind]);
+ acc = L_mac0(acc, *IZ2++, t_sin[c2_ind]);
+ *IY-- = round_fx(acc);
+
+ c1_ind = add(c1_ind, c1_step);
+ s1_ind = add(s1_ind, s1_step);
+ c2_ind = sub(c2_ind, c2_step);
+ s2_ind = sub(s2_ind, s2_step);
+ }
+
+ /*--------------------------half--------------------------// */
+ /* next 2/12-- from (6*m/8) to (8*m/8) - 1 */
+ l = shr(m,2);
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_shl(*RZ0--, 15);
+ acc = L_msu0(acc, *RZ1, t_sin[c1_ind]); /* Non-fractional mode gains 1 more bit headroom. */
+ acc = L_msu0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_mac0(acc, *IZ2, t_sin[s2_ind]);
+ *RY++ = round_fx(acc);
+
+ acc = L_mult0(*IZ0++, -32768);
+ acc = L_msu0(acc, *RZ1--, t_sin[s1_ind]);
+ acc = L_mac0(acc, *IZ1++, t_sin[c1_ind]);
+ acc = L_mac0(acc, *RZ2--, t_sin[s2_ind]);
+ acc = L_mac0(acc, *IZ2++, t_sin[c2_ind]);
+ *IY-- = round_fx(acc);
+
+ c1_ind = sub(c1_ind, c1_step);
+ s1_ind = sub(s1_ind, s1_step);
+ c2_ind = add(c2_ind, c2_step);
+ s2_ind = add(s2_ind, s2_step);
+ }
+
+ /* special case: i = m, i.e 2/3 */
+ acc = L_shl(*RZ0++, 15);
+ acc = L_msu0(acc, *RZ1, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ *RY++ = round_fx(acc);
+
+ acc = L_deposit_l(0);
+ acc = L_msu0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_mac0(acc, *RZ2++, t_sin[s2_ind]);
+ *IY-- = round_fx(acc);
+ IZ0--; /* Just decrement the address counter */
+ IZ1--;
+ IZ2--;
+
+ c1_ind = sub(c1_ind, c1_step);
+ s1_ind = sub(s1_ind, s1_step);
+ c2_ind = add(c2_ind, c2_step);
+ s2_ind = add(s2_ind, s2_step);
+
+ /* next 1/12-- from (m + 1) to (9*m/8) - 1 */
+ l = sub(shr(m, 3), 1); /* (9*m/8) - (m +1) = m/8 - 1 */
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_shl(*RZ0++, 15);
+ acc = L_msu0(acc, *RZ1, t_sin[c1_ind]); /* Non-fractional mode gains 1 more bit headroom. */
+ acc = L_mac0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ2, t_sin[s2_ind]);
+ *RY++ = round_fx(acc);
+
+ acc = L_shl(*IZ0--, 15);
+ acc = L_msu0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_msu0(acc, *IZ1--, t_sin[c1_ind]);
+ acc = L_mac0(acc, *RZ2++, t_sin[s2_ind]);
+ acc = L_msu0(acc, *IZ2--, t_sin[c2_ind]);
+ *IY-- = round_fx(acc);
+
+ c1_ind = sub(c1_ind, c1_step);
+ s1_ind = sub(s1_ind, s1_step);
+ c2_ind = add(c2_ind, c2_step);
+ s2_ind = add(s2_ind, s2_step);
+ }
+
+ /* last 3/12-- from (9*m/8) to (12*m/8) - 1 */
+ l = shr(n,3); /* (12*m/8) - (9*m/8) = 3*m/8 = n/8 */
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_shl(*RZ0++, 15);
+ acc = L_msu0(acc, *RZ1, t_sin[c1_ind]); /* Non-fractional mode gains 1 more bit headroom. */
+ acc = L_mac0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_mac0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ2, t_sin[s2_ind]);
+ *RY++ = round_fx(acc);
+
+ acc = L_shl(*IZ0--, 15);
+ acc = L_msu0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_msu0(acc, *IZ1--, t_sin[c1_ind]);
+ acc = L_mac0(acc, *RZ2++, t_sin[s2_ind]);
+ acc = L_mac0(acc, *IZ2--, t_sin[c2_ind]);
+ *IY-- = round_fx(acc);
+
+ c1_ind = sub(c1_ind, c1_step);
+ s1_ind = sub(s1_ind, s1_step);
+ c2_ind = sub(c2_ind, c2_step);
+ s2_ind = sub(s2_ind, s2_step);
+ }
+
+ /* special case: i = 3*m/2 */
+ acc = L_shl(*RZ0, 15);
+ acc = L_msu0(acc, *RZ1, t_sin[c1_ind]);
+ acc = L_mac0(acc, *RZ2, t_sin[c2_ind]);
+ *RY = round_fx(acc);
+
+ return;
+}
+
+
+void ifft3_fx(const Word16 Z[], Word16 X[], const Word16 n)
+{
+ Word16 Y[PH_ECU_SPEC_SIZE];
+ const Word16 *t_sin = sincos_t_rad3_fx;
+ Word16 m, mMinus1, step, step2;
+ Word16 i, l;
+ Word16 c0_ind, s0_ind, c1_ind, s1_ind, c2_ind, s2_ind;
+ const Word16 *RZ0, *IZ0, *RZ1, *IZ1, *RZ2, *IZ2;
+ const Word16 *RZ00, *IZ00, *RZ10, *IZ10, *RZ20, *IZ20;
+ Word16 *RY0, *IY0, *RY1, *IY1, *RY2, *IY2, *y0, *y1, *y2, *pX;
+ Word32 acc;
+ Word16 mBy2, orderMinus1, nMinusMBy2;
+ const Word16 *pPhaseTbl;
+
+ /* Determine the order of the transform, the length of decimated */
+ /* transforms m, and the step for the sine and cosine tables. */
+ SWITCH(n)
+ {
+ case 1536:
+ orderMinus1 = 9-1;
+ move16();
+ m = 512;
+ move16();
+ step = 1;
+ move16();
+ pPhaseTbl = FFT_W256;
+ BREAK;
+ case 384:
+ orderMinus1 = 7-1;
+ move16();
+ m = 128;
+ move16();
+ step = 4;
+ move16();
+ pPhaseTbl = FFT_W64;
+ BREAK;
+ default:
+ orderMinus1 = 7-1;
+ move16();
+ m = 128;
+ move16();
+ step = 4;
+ move16();
+ pPhaseTbl = FFT_W64;
+ BREAK;
+ }
+
+ nMinusMBy2 = shr(sub(n, m),1);
+ mMinus1 = sub(m,1);
+ /* pointer initialization */
+ RY0 = &Y[0];
+ IY0 = &Y[m];
+ RY1 = &RY0[m];
+ IY1 = &RY1[mMinus1];
+ RY2 = &RY1[m];
+ IY2 = &RY2[mMinus1];
+
+ RZ00 = &Z[0]; /* The zero positions of the pointers */
+ RZ10 = &RZ00[m];
+ RZ20 = &RZ00[nMinusMBy2];
+ IZ00 = &Z[n];
+ IZ10 = &IZ00[-m];
+ IZ20 = &IZ00[-nMinusMBy2];
+
+ RZ0 = RZ00; /* Reset the pointers to zero positions. */
+ RZ1 = RZ10;
+ RZ2 = RZ20;
+ IZ0 = IZ00;
+ IZ1 = IZ10;
+ IZ2 = IZ20;
+
+ /* Inverse butterflies of order 3. */
+
+ /* Construction of Y0 */
+ acc = L_mult(*RZ0++, 0x4000);
+ acc = L_mac(acc, *RZ1++, 0x4000);
+ *RY0++ = mac_r(acc, *RZ2--, 0x4000);
+ move16();
+ IZ0--;
+ IZ1--;
+ IZ2++;
+ IY0--;
+
+ l = sub(shr(m, 1), 1);
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_mult(*RZ0++, 0x4000);
+ acc = L_mac(acc, *RZ1++, 0x4000);
+ *RY0++ = mac_r(acc, *RZ2--, 0x4000);
+ move16();
+
+ acc = L_mult(*IZ0--, 0x4000);
+ acc = L_mac(acc, *IZ1--, 0x4000);
+ *IY0-- = msu_r(acc, *IZ2++, 0x4000);
+ move16();
+ }
+
+ /* m/2 */
+ acc = L_mult(*RZ0, 0x4000);
+ acc = L_mac(acc, *RZ1, 0x4000);
+ *RY0++ = mac_r(acc, *RZ2, 0x4000);
+ move16();
+
+
+ /* Construction of Y1 */
+ c0_ind=T_SIN_PI_2;
+ s0_ind=0;
+ c1_ind=T_SIN_PI_2*1/3;
+ s1_ind=T_SIN_PI_2*2/3;
+ c2_ind=T_SIN_PI_2*1/3;
+ s2_ind=T_SIN_PI_2*2/3;
+
+ RZ0 = RZ00; /* Reset pointers to zero positions. */
+ RZ1 = RZ10;
+ RZ2 = RZ20;
+ IZ0 = IZ00;
+ IZ1 = IZ10;
+ IZ2 = IZ20;
+ acc = L_mult0(*RZ0++, t_sin[c0_ind]);
+ acc = L_msu0(acc, *RZ1++, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2--, t_sin[c2_ind]);
+ IZ0--;
+ acc = L_msu0(acc, *IZ1--, t_sin[s1_ind]);
+ acc = L_msu0(acc, *IZ2++, t_sin[s2_ind]);
+ *RY1++ = round_fx(acc);
+
+ c0_ind=sub(c0_ind,step);
+ s0_ind=add(s0_ind,step);
+ c1_ind=add(c1_ind,step);
+ s1_ind=sub(s1_ind,step);
+ c2_ind=sub(c2_ind,step);
+ s2_ind=add(s2_ind,step);
+
+ /* From 1 to (m/4) - 1. */
+ l = sub(shr(m,2),1);
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_mult0(*RZ0, t_sin[c0_ind]);
+ acc = L_msu0(acc, *RZ1, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ0, t_sin[s0_ind]);
+ acc = L_msu0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_msu0(acc, *IZ2, t_sin[s2_ind]);
+ *RY1++ = round_fx(acc);
+
+ acc = L_mult0(*IZ0--, t_sin[c0_ind]);
+ acc = L_msu0(acc, *IZ1--, t_sin[c1_ind]);
+ acc = L_mac0(acc, *IZ2++, t_sin[c2_ind]);
+ acc = L_mac0(acc, *RZ0++, t_sin[s0_ind]);
+ acc = L_mac0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_msu0(acc, *RZ2--, t_sin[s2_ind]);
+ *IY1-- = round_fx(acc);
+
+ c0_ind=sub(c0_ind,step);
+ s0_ind=add(s0_ind,step);
+ c1_ind=add(c1_ind,step);
+ s1_ind=sub(s1_ind,step);
+ c2_ind=sub(c2_ind,step);
+ s2_ind=add(s2_ind,step);
+ }
+
+ /* From m/4 to m/2 -1. */
+ l = shr(m, 2); /* m/2 - m/4 = m/4 */
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_mult0(*RZ0, t_sin[c0_ind]);
+ acc = L_msu0(acc, *RZ1, t_sin[c1_ind]);
+ acc = L_mac0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ0, t_sin[s0_ind]);
+ acc = L_msu0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_msu0(acc, *IZ2, t_sin[s2_ind]);
+ *RY1++ = round_fx(acc);
+
+ acc = L_mult0(*IZ0--, t_sin[c0_ind]);
+ acc = L_msu0(acc, *IZ1--, t_sin[c1_ind]);
+ acc = L_msu0(acc, *IZ2++, t_sin[c2_ind]);
+ acc = L_mac0(acc, *RZ0++, t_sin[s0_ind]);
+ acc = L_mac0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_msu0(acc, *RZ2--, t_sin[s2_ind]);
+ *IY1-- = round_fx(acc);
+
+ c0_ind=sub(c0_ind,step);
+ s0_ind=add(s0_ind,step);
+ c1_ind=add(c1_ind,step);
+ s1_ind=sub(s1_ind,step);
+ c2_ind=add(c2_ind,step);
+ s2_ind=sub(s2_ind,step);
+ }
+
+ /* m/2 */
+ acc = L_mult0(*RZ0, t_sin[c0_ind]);
+ acc = L_msu0(acc, *RZ1, t_sin[c1_ind]);
+ acc = L_mac0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ0, t_sin[s0_ind]);
+ acc = L_msu0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_msu0(acc, *IZ2, t_sin[s2_ind]);
+ *RY1++ = round_fx(acc);
+
+ /* Construction of Y2 */
+ c0_ind=T_SIN_PI_2;
+ s0_ind=0;
+ c1_ind=T_SIN_PI_2*1/3;
+ s1_ind=T_SIN_PI_2*2/3;
+ c2_ind=T_SIN_PI_2*1/3;
+ s2_ind=T_SIN_PI_2*2/3;
+ step2 = shl(step,1);
+
+ RZ0 = RZ00; /* Reset pointers to zero positions. */
+ RZ1 = RZ10;
+ RZ2 = RZ20;
+ IZ0 = IZ00;
+ IZ1 = IZ10;
+ IZ2 = IZ20;
+ acc = L_mult0(*RZ0++, t_sin[c0_ind]);
+ acc = L_msu0(acc, *RZ1++, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2--, t_sin[c2_ind]);
+ IZ0--;
+ acc = L_mac0(acc, *IZ1--, t_sin[s1_ind]);
+ acc = L_mac0(acc, *IZ2++, t_sin[s2_ind]);
+ *RY2++ = round_fx(acc);
+
+ c0_ind=sub(c0_ind,step2);
+ s0_ind=add(s0_ind,step2);
+ c1_ind=sub(c1_ind,step2);
+ s1_ind=add(s1_ind,step2);
+ c2_ind=add(c2_ind,step2);
+ s2_ind=sub(s2_ind,step2);
+
+ /* From 1 to (m/8) - 1. */
+ l = sub(shr(m, 3),1); /* m/8 - 1. */
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_mult0(*RZ0, t_sin[c0_ind]);
+ acc = L_msu0(acc, *RZ1, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ0, t_sin[s0_ind]);
+ acc = L_mac0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_mac0(acc, *IZ2, t_sin[s2_ind]);
+ *RY2++ = round_fx(acc);
+
+ acc = L_mult0(*IZ0--, t_sin[c0_ind]);
+ acc = L_msu0(acc, *IZ1--, t_sin[c1_ind]);
+ acc = L_mac0(acc, *IZ2++, t_sin[c2_ind]);
+ acc = L_mac0(acc, *RZ0++, t_sin[s0_ind]);
+ acc = L_msu0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_mac0(acc, *RZ2--, t_sin[s2_ind]);
+ *IY2-- = round_fx(acc);
+
+ c0_ind=sub(c0_ind,step2);
+ s0_ind=add(s0_ind,step2);
+ c1_ind=sub(c1_ind,step2);
+ s1_ind=add(s1_ind,step2);
+ c2_ind=add(c2_ind,step2);
+ s2_ind=sub(s2_ind,step2);
+ }
+
+ /* From (m/8) to (m/4) - 1. */
+ l = shr(m, 3); /* m/4 - m/8 = m/8 */
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_mult0(*RZ0, t_sin[c0_ind]);
+ acc = L_mac0(acc, *RZ1, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ0, t_sin[s0_ind]);
+ acc = L_mac0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_mac0(acc, *IZ2, t_sin[s2_ind]);
+ *RY2++ = round_fx(acc);
+
+ acc = L_mult0(*IZ0--, t_sin[c0_ind]);
+ acc = L_mac0(acc, *IZ1--, t_sin[c1_ind]);
+ acc = L_mac0(acc, *IZ2++, t_sin[c2_ind]);
+ acc = L_mac0(acc, *RZ0++, t_sin[s0_ind]);
+ acc = L_msu0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_mac0(acc, *RZ2--, t_sin[s2_ind]);
+ *IY2-- = round_fx(acc);
+
+ c0_ind=sub(c0_ind,step2);
+ s0_ind=add(s0_ind,step2);
+ c1_ind=add(c1_ind,step2);
+ s1_ind=sub(s1_ind,step2);
+ c2_ind=add(c2_ind,step2);
+ s2_ind=sub(s2_ind,step2);
+ }
+
+ /* From m/4 to 3*m/8 - 1. */
+ l = shr(m, 3); /* 3*m/8 - m/4 = m/8 */
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_mult0(*RZ0, t_sin[c0_ind]);
+ acc = L_mac0(acc, *RZ1, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ0, t_sin[s0_ind]);
+ acc = L_mac0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_msu0(acc, *IZ2, t_sin[s2_ind]);
+ *RY2++ = round_fx(acc);
+
+ acc = L_mult0(*IZ0--, t_sin[c0_ind]);
+ acc = L_mac0(acc, *IZ1--, t_sin[c1_ind]);
+ acc = L_mac0(acc, *IZ2++, t_sin[c2_ind]);
+ acc = L_mac0(acc, *RZ0++, t_sin[s0_ind]);
+ acc = L_msu0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_msu0(acc, *RZ2--, t_sin[s2_ind]);
+ *IY2-- = round_fx(acc);
+
+ c0_ind=sub(c0_ind,step2);
+ s0_ind=add(s0_ind,step2);
+ c1_ind=add(c1_ind,step2);
+ s1_ind=sub(s1_ind,step2);
+ c2_ind=sub(c2_ind,step2);
+ s2_ind=add(s2_ind,step2);
+ }
+
+ /* From 3*m/8 to m/2 - 1*/
+ l = shr(m, 3); /* m/2 - 3*m/8 = m/8 */
+ FOR (i = 0; i < l; i++)
+ {
+ acc = L_mult0(*RZ1, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ0, t_sin[c0_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ0, t_sin[s0_ind]);
+ acc = L_mac0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_msu0(acc, *IZ2, t_sin[s2_ind]);
+ *RY2++ = round_fx(acc);
+
+ acc = L_mult0(*IZ1--, t_sin[c1_ind]);
+ acc = L_msu0(acc, *IZ0--, t_sin[c0_ind]);
+ acc = L_mac0(acc, *IZ2++, t_sin[c2_ind]);
+ acc = L_mac0(acc, *RZ0++, t_sin[s0_ind]);
+ acc = L_msu0(acc, *RZ1++, t_sin[s1_ind]);
+ acc = L_msu0(acc, *RZ2--, t_sin[s2_ind]);
+ *IY2-- = round_fx(acc);
+
+ c0_ind=add(c0_ind,step2);
+ s0_ind=sub(s0_ind,step2);
+ c1_ind=add(c1_ind,step2);
+ s1_ind=sub(s1_ind,step2);
+ c2_ind=sub(c2_ind,step2);
+ s2_ind=add(s2_ind,step2);
+ }
+
+ /* m/2 */
+ acc = L_mult0(*RZ1, t_sin[c1_ind]);
+ acc = L_msu0(acc, *RZ0, t_sin[c0_ind]);
+ acc = L_msu0(acc, *RZ2, t_sin[c2_ind]);
+ acc = L_msu0(acc, *IZ0, t_sin[s0_ind]);
+ acc = L_mac0(acc, *IZ1, t_sin[s1_ind]);
+ acc = L_msu0(acc, *IZ2, t_sin[s2_ind]);
+ *RY2++ = round_fx(acc);
+
+ /* Compute the inverse FFT for all 3 blocks. */
+ RY0 = &Y[0]; /* Rewind the pointers. */
+ RY1 = &Y[m];
+ RY2 = &RY1[m];
+ mBy2 = shr(m,1);
+ r_fft_fx_lc(pPhaseTbl, m, mBy2, orderMinus1, RY0, RY0, 0); /* inverse FFT */
+ r_fft_fx_lc(pPhaseTbl, m, mBy2, orderMinus1, RY1, RY1, 0); /* inverse FFT */
+ r_fft_fx_lc(pPhaseTbl, m, mBy2, orderMinus1, RY2, RY2, 0); /* inverse FFT */
+
+ y0 = RY0;
+ y1 = RY1;
+ y2 = RY2;
+
+ /* Interlacing and scaling, scale = 1/3 */
+ pX = X;
+ FOR (i = 0; i < m; i++)
+ {
+ *pX++ = shl(mult_r(*y0++, FFT3_ONE_THIRD), 1);
+ move16();
+ *pX++ = shl(mult_r(*y1++, FFT3_ONE_THIRD), 1);
+ move16();
+ *pX++ = shl(mult_r(*y2++, FFT3_ONE_THIRD), 1);
+ move16();
+ }
+
+ return;
+}
diff --git a/lib_com/fft_rel_fx.c b/lib_com/fft_rel_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..51aa3e6eb8973562472f99dc4bcc5572c6012371
--- /dev/null
+++ b/lib_com/fft_rel_fx.c
@@ -0,0 +1,433 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "prot_fx.h" /* Function prototypes */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "stl.h"
+
+#include "stdint.h"
+/*------------------------------------------------------------------
+ *
+ * This is an implementation of decimation-in-time FFT algorithm for
+ * real sequences. The techniques used here can be found in several
+ * books, e.g., i) Proakis and Manolakis, "Digital Signal Processing",
+ * 2nd Edition, Chapter 9, and ii) W.H. Press et. al., "Numerical
+ * Recipes in C", 2nd Edition, Chapter 12.
+ *
+ * Input - There are two inputs to this function:
+ *
+ * 1) An integer pointer to the input data array
+ * 2) An integer value which should be set as +1 for FFT
+ * and some other value, e.g., -1 for ifFT
+ *
+ * Output - There is no return value.
+ * The input data are replaced with transformed data. if the
+ * input is a real time domain sequence, it is replaced with
+ * the complex FFT for positive frequencies. The FFT value
+ * for DC and the foldover frequency are combined to form the
+ * first complex number in the array. The remaining complex
+ * numbers correspond to increasing frequencies. if the input
+ * is a complex frequency domain sequence arranged as above,
+ * it is replaced with the corresponding time domain sequence.
+ *
+ * Notes:
+ *
+ * 1) This function is designed to be a part of a noise supp-
+ * ression algorithm that requires 128-point FFT of real
+ * sequences. This is achieved here through a 64-point
+ * complex FFT. Consequently, the FFT size information is
+ * not transmitted explicitly. However, some flexibility
+ * is provided in the function to change the size of the
+ * FFT by specifying the size information through "define"
+ * statements.
+ *
+ * 2) The values of the complex sinusoids used in the FFT
+ * algorithm are computed once (i.e., the first time the
+ * r_fft function is called) and stored in a table. To
+ * further speed up the algorithm, these values can be
+ * precomputed and stored in a ROM table in actual DSP
+ * based implementations.
+ *
+ * 3) In the c_fft function, the FFT values are divided by
+ * 2 after each stage of computation thus dividing the
+ * final FFT values by 64. No multiplying factor is used
+ * for the ifFT. This is somewhat different from the usual
+ * definition of FFT where the factor 1/N, i.e., 1/64, is
+ * used for the ifFT and not the FFT. No factor is used in
+ * the r_fft function.
+ *
+ * 4) Much of the code for the FFT and ifFT parts in r_fft
+ * and c_fft functions are similar and can be combined.
+ * They are, however, kept separate here to speed up the
+ * execution.
+ *------------------------------------------------------------------------*/
+/*------------------------------------------------------------------------*
+ * c_fft_fx:
+ *
+ * Computes the complex part of the split-radix FFT
+ *------------------------------------------------------------------------*/
+
+static void c_fft_fx(
+ const Word16 *phs_tbl, /* i : Table of phases */
+ Word16 SIZE, /* i : Size of the FFT */
+ Word16 NUM_STAGE, /* i : Number of stages */
+ const Word16 *in_ptr, /* i : coefficients in the order re[0], re[n/2], re[1], im[1], ..., re[n/2-1], im[n/2-1] */
+ Word16 *out_ptr, /* o : coefficients in the order re[0], re[n/2], re[1], im[1], ..., re[n/2-1], im[n/2-1] */
+ /* in_ptr & out_ptr must not overlap! */
+ const Word16 isign) /* i : 1=fft, otherwise it is ifft*/
+{
+ Word16 i, j, k, ii, jj, kk, ji, kj;
+ Word32 L_tmp1, L_tmp2;
+ Word16 tmp1,tmp2,tmp3,tmp4;
+ const Word16 *table_ptr;
+ const Word16 *input_ptr1,*input_ptr2,*input_ptr3,*input_ptr4;
+ Word16 shift=0;
+ /* Setup Reorder Variables */
+ table_ptr = NULL;
+ table_ptr = FFT_REORDER_1024;
+ SWITCH(SIZE)
+ {
+ case 1024:
+ shift = 0;
+ BREAK;
+ case 512:
+ shift = 1;
+ BREAK;
+ case 256:
+ shift = 2;
+ BREAK;
+ case 128:
+ shift = 3;
+ BREAK;
+ case 64:
+ shift = 4;
+ BREAK;
+ }
+ /* The FFT part */
+ IF (isign != 0)
+ {
+ /* Unrolled 1st/2nd Stage
+ * 1) to take advantage of Table Values (0 & +/- 16384)
+ * 2) to perform reordering of Input Values
+ */
+ FOR (k = 0; k < SIZE; k += 8)
+ {
+ /*
+ * This loop use:
+ * 4 Word16 (tmp1...tmp4)
+ * 2 Word32 (L_tmp1 & L_tmp2)
+ * 4 Pointers (table_ptr, input_ptr1, input_ptr2, input_ptr3)
+ *
+ * The addition of 'in_ptr' + and index value from 'reorder_ptr'
+ * is counted as a move16()
+ */
+
+ input_ptr1 = in_ptr + (const Word16 ) ((uintptr_t)(*table_ptr++)>>(uintptr_t)shift);
+
+ L_tmp1 = L_mult(*input_ptr1++, 16384);
+ L_tmp2 = L_mult(*input_ptr1, 16384);
+
+ input_ptr1 = in_ptr + (const Word16)((uintptr_t)(*table_ptr++) >> (uintptr_t)shift);
+
+ tmp1 = msu_r(L_tmp1, *input_ptr1, 16384);
+ tmp3 = mac_r(L_tmp1, *input_ptr1++, 16384);
+
+ input_ptr2 = in_ptr + (const Word16)((uintptr_t)(*table_ptr++) >> (uintptr_t)shift);
+ input_ptr3 = in_ptr + (const Word16)((uintptr_t)(*table_ptr++) >> (uintptr_t)shift);
+
+ L_tmp1 = L_mult(*input_ptr2++, 16384);
+ tmp2 = mac_r(L_tmp1, *input_ptr3, 16384);
+ tmp4 = msu_r(L_tmp1, *input_ptr3++, 16384);
+
+ L_tmp1 = L_mult(tmp3, 16384);
+ out_ptr[k] = mac_r(L_tmp1, tmp2, 16384);
+ move16();
+ out_ptr[k+4] = msu_r(L_tmp1, tmp2, 16384);
+ move16();
+
+ tmp2 = mac_r(L_tmp2, *input_ptr1, 16384);
+ tmp3 = msu_r(L_tmp2, *input_ptr1, 16384);
+
+ L_tmp2 = L_mult(*input_ptr2, 16384);
+
+ L_tmp1 = L_mult(tmp1, 16384);
+ tmp1 = msu_r(L_tmp2, *input_ptr3, 16384);
+ out_ptr[k+2] = mac_r(L_tmp1, tmp1, 16384);
+ move16();
+ out_ptr[k+6] = msu_r(L_tmp1, tmp1, 16384);
+ move16();
+
+ L_tmp1 = L_mult(tmp2, 16384);
+ tmp2 = mac_r(L_tmp2, *input_ptr3, 16384);
+ out_ptr[k+1] = mac_r(L_tmp1, tmp2, 16384);
+ move16();
+ out_ptr[k+5] = msu_r(L_tmp1, tmp2, 16384);
+ move16();
+
+ L_tmp1 = L_mult(tmp3, 16384);
+ out_ptr[k+3] = msu_r(L_tmp1, tmp4, 16384);
+ move16();
+ out_ptr[k+7] = mac_r(L_tmp1, tmp4, 16384);
+ move16();
+ }
+
+ /* Remaining Stages */
+ FOR (i = 2; i < NUM_STAGE; i++)
+ {
+ /* i is stage counter */
+ jj = shl(2, i); /* FFT size */
+ kk = shl(jj, 1); /* 2 * FFT size */
+ ii = shr(SIZE, i);
+ ji = 0;
+ move16(); /* ji is phase table index */
+
+ FOR (j = 0; j < jj; j += 2)
+ {
+ /* j is sample counter */
+ FOR (k = j; k < SIZE; k += kk)
+ {
+ /* k is butterfly top */
+ kj = add(k, jj); /* kj is butterfly bottom */
+
+ /* Butterfly computations */
+ L_tmp1 = L_msu(L_mult(*(out_ptr + kj), phs_tbl[ji]),
+ *(out_ptr + kj + 1), phs_tbl[ji + 1]);
+ L_tmp2 = L_mac(L_mult(*(out_ptr + kj + 1), phs_tbl[ji]),
+ *(out_ptr + kj), phs_tbl[ji + 1]);
+
+ out_ptr[kj] = mac_r(L_negate(L_tmp1), out_ptr[k], 16384);
+ move16();
+ out_ptr[kj+1] = mac_r(L_negate(L_tmp2), out_ptr[k+1], 16384);
+ move16();
+ out_ptr[k] = mac_r(L_tmp1, out_ptr[k], 16384);
+ move16();
+ out_ptr[k+1] = mac_r(L_tmp2, out_ptr[k+1], 16384);
+ move16();
+ }
+ ji = add(ji, ii);
+ }
+ }
+ }
+ ELSE /* The ifFT part */
+ {
+ /* Unrolled 1st/2nd Stage
+ * 1) to take advantage of Table Values (0 & +/- 16384)
+ * 2) to perform reordering of Input Values
+ */
+ FOR (k = 0; k < SIZE; k += 8)
+ {
+ /*
+ * This loop use:
+ * 4 Word16 (tmp1...tmp4)
+ * 2 Word32 (L_tmp1 & L_tmp2)
+ * 5 Pointers (reorder_ptr, input_ptr1...input_ptr4)
+ *
+ * The addition of 'in_ptr' + and index value from 'reorder_ptr'
+ * is counted as a move16()
+ */
+ input_ptr1= in_ptr + (const Word16)((uintptr_t)(*table_ptr++) >> (uintptr_t)shift);
+ input_ptr2 = in_ptr + (const Word16)((uintptr_t)(*table_ptr++) >> (uintptr_t)shift);
+
+ input_ptr3 = in_ptr + (const Word16)((uintptr_t)(*table_ptr++) >> (uintptr_t)shift);
+ input_ptr4 = in_ptr + (const Word16)((uintptr_t)(*table_ptr++) >> (uintptr_t)shift);
+
+
+ tmp3 = sub(*input_ptr1, *input_ptr2);
+ tmp4 = add(*input_ptr1++, *input_ptr2++);
+
+ tmp2 = sub(input_ptr3[0], input_ptr4[0]);
+ tmp1 = sub(input_ptr3[1], input_ptr4[1]);
+
+ out_ptr[k+2] = sub(tmp3, tmp1);
+ move16();
+ out_ptr[k+6] = add(tmp3, tmp1);
+ move16();
+
+ tmp1 = sub(*input_ptr1, *input_ptr2);
+ out_ptr[k+3] = add(tmp1, tmp2);
+ move16();
+ out_ptr[k+7] = sub(tmp1, tmp2);
+ move16();
+
+ tmp1 = add(input_ptr3[0], input_ptr4[0]);
+ tmp3 = add(input_ptr3[1], input_ptr4[1]);
+
+ out_ptr[k] = add(tmp4, tmp1);
+ move16();
+ out_ptr[k+4] = sub(tmp4, tmp1);
+ move16();
+
+ tmp4 = add(*input_ptr1, *input_ptr2);
+ out_ptr[k+1] = add(tmp4, tmp3);
+ move16();
+ out_ptr[k+5] = sub(tmp4, tmp3);
+ move16();
+ }
+
+ table_ptr = phs_tbl + SIZE; /* access part of table that is scaled by 2 */
+
+ /* Remaining Stages */
+ FOR (i = 2; i < NUM_STAGE; i++)
+ {
+ /* i is stage counter */
+ jj = shl(2, i); /* FFT size */
+ kk = shl(jj, 1); /* 2 * FFT size */
+ ii = shr(SIZE, i);
+ ji = 0;
+ move16(); /* ji is phase table index */
+
+ FOR (j = 0; j < jj; j += 2)
+ {
+ /* j is sample counter */
+ /* This can be computed by successive add_fxitions of ii to ji, starting from 0
+ hence line-count it as a one-line add (still need to increment op count!!) */
+
+ FOR (k = j; k < SIZE; k += kk)
+ {
+ /* k is butterfly top */
+ kj = add(k, jj); /* kj is butterfly bottom */
+
+ /* Butterfly computations */
+ tmp1 = mac_r(L_mult(out_ptr[kj], table_ptr[ji]),
+ out_ptr[kj+1], table_ptr[ji + 1]);
+
+ tmp2 = msu_r(L_mult(out_ptr[kj+1], table_ptr[ji]),
+ out_ptr[kj], table_ptr[ji+1]);
+
+ out_ptr[kj] = sub(out_ptr[k], tmp1);
+ move16();
+ out_ptr[kj+1] = sub(out_ptr[k+1], tmp2);
+ move16();
+ out_ptr[k] = add(out_ptr[k], tmp1);
+ move16();
+ out_ptr[k+1] = add(out_ptr[k+1], tmp2);
+ move16();
+ }
+ ji = add(ji, ii);
+ }
+ }
+ }
+}
+
+/*--------------------------------------------------------------------------------*
+ * r_fft_fx:
+ *
+ * Perform FFT fixed-point for real-valued sequences of length 32, 64 or 128
+ *--------------------------------------------------------------------------------*/
+void r_fft_fx_lc(
+ const Word16 *phs_tbl, /* i : Table of phase */
+ const Word16 SIZE, /* i : Size of the FFT */
+ const Word16 SIZE2, /* i : Size / 2 */
+ const Word16 NUM_STAGE, /* i : Number of stage */
+ const Word16 *in_ptr, /* i : coefficients in the order re[0], re[1], ... re[n/2], im[n/2-1], im[n/2-2], ..., im[1] */
+ Word16 *out_ptr, /* o : coefficients in the order re[0], re[1], ... re[n/2], im[n/2-1], im[n/2-2], ..., im[1] */
+ const Word16 isign /* i : 1=fft, otherwize it's ifft */
+)
+{
+ Word16 tmp2_real, tmp2_imag;
+ Word32 Ltmp1_real, Ltmp1_imag;
+ Word16 i;
+ Word32 Ltmp1;
+ const Word16 *phstbl_ptrDn;
+ Word16 *ptrDn;
+ Word16 temp[1024]; /* Accommodates real input FFT size up to 1024. */
+
+ /* Setup Pointers */
+ phstbl_ptrDn = &phs_tbl[SIZE-1];
+
+ /* The FFT part */
+ IF (isign != 0)
+ {
+ Word16 *ptRealUp, *ptRealDn, *ptImaUp, *ptImaDn;
+
+ /* Perform the complex FFT */
+ c_fft_fx(phs_tbl, SIZE, NUM_STAGE, in_ptr, temp, isign);
+
+ /* First, handle the DC and foldover frequencies */
+ out_ptr[SIZE2] = sub(temp[0], temp[1]);
+ move16();
+ out_ptr[0] = sub(add(temp[0], temp[1]), shr(NUM_STAGE, 1));
+ move16();/* DC have a small offset */
+
+ ptrDn = &temp[SIZE-1];
+
+ ptImaDn = &out_ptr[SIZE-1];
+ ptRealUp = &out_ptr[1];
+ ptImaUp = &out_ptr[SIZE2+1];
+ ptRealDn = &out_ptr[SIZE2-1];
+
+ /* Now, handle the remaining positive frequencies */
+ FOR (i = 2; i <= SIZE2; i += 2)
+ {
+ Ltmp1_imag = L_mult(temp[i+1], 16384);
+ Ltmp1_imag = L_msu(Ltmp1_imag, *ptrDn, 16384);
+ tmp2_real = add(temp[i+1], *ptrDn--);
+
+ Ltmp1_real = L_mult(temp[i], 16384);
+ Ltmp1_real = L_mac(Ltmp1_real, *ptrDn, 16384);
+ tmp2_imag = sub(*ptrDn--, temp[i]);
+
+
+ *ptRealUp++ = msu_r(L_mac(Ltmp1_real, tmp2_real, phs_tbl[i]), tmp2_imag, phs_tbl[i+1]);
+ move16();
+ *ptImaDn-- = mac_r(L_mac(Ltmp1_imag, tmp2_imag, phs_tbl[i]), tmp2_real, phs_tbl[i+1]);
+ move16();
+ Ltmp1 = L_mac(L_negate(Ltmp1_imag), tmp2_real, *phstbl_ptrDn);
+ Ltmp1_real = L_mac(Ltmp1_real, tmp2_imag, *phstbl_ptrDn--);
+ *ptImaUp++ = msu_r(Ltmp1, tmp2_imag, *phstbl_ptrDn);
+ move16();
+ *ptRealDn-- = mac_r(Ltmp1_real, tmp2_real, *phstbl_ptrDn--);
+ move16();
+ }
+ }
+ ELSE /* The ifFT part */
+ {
+ const Word16 *ptRealUp, *ptRealDn, *ptImaUp, *ptImaDn;
+
+ /* First, handle the DC and foldover frequencies */
+ Ltmp1 = L_mult(in_ptr[0], 16384);
+ temp[0] = mac_r(Ltmp1, in_ptr[SIZE2], 16384);
+ move16();
+ temp[1] = msu_r(Ltmp1, in_ptr[SIZE2], 16384);
+ move16();
+
+ ptrDn = &temp[SIZE-1];
+
+ /* Here we cast to Word16 * from a const Word16 *. */
+ /* This is ok because we use these pointers for */
+ /* reading only. This is just to avoid declaring a */
+ /* bunch of 4 other pointer with const Word16 *. */
+ ptImaDn = &in_ptr[SIZE-1];
+ ptRealUp = &in_ptr[1];
+ ptImaUp = &in_ptr[SIZE2+1];
+ ptRealDn = &in_ptr[SIZE2-1];
+
+ /* Now, handle the remaining positive frequencies */
+ FOR (i = 2; i <= SIZE2; i += 2)
+ {
+ Ltmp1_imag = L_mult(*ptImaDn, 16384);
+ Ltmp1_imag = L_msu(Ltmp1_imag, *ptImaUp, 16384);
+ tmp2_real = add(*ptImaDn--, *ptImaUp++);
+ Ltmp1_real = L_mult(*ptRealUp, 16384);
+ Ltmp1_real = L_mac(Ltmp1_real, *ptRealDn, 16384);
+ tmp2_imag = sub(*ptRealUp++, *ptRealDn--);
+
+
+ temp[i] = mac_r(L_msu(Ltmp1_real, tmp2_real, phs_tbl[i]), tmp2_imag, phs_tbl[i+1]);
+ move16();
+ temp[i+1] = mac_r(L_mac(Ltmp1_imag, tmp2_imag, phs_tbl[i]), tmp2_real, phs_tbl[i+1]);
+ move16();
+ Ltmp1 = L_mac(L_negate(Ltmp1_imag), tmp2_real, *phstbl_ptrDn);
+ Ltmp1_real = L_msu(Ltmp1_real, tmp2_imag, *phstbl_ptrDn--);
+ *ptrDn-- = msu_r(Ltmp1, tmp2_imag, *phstbl_ptrDn);
+ move16();
+ *ptrDn-- = msu_r(Ltmp1_real, tmp2_real, *phstbl_ptrDn--);
+ move16();
+ }
+
+ /* Perform the complex ifFT */
+ c_fft_fx(phs_tbl, SIZE, NUM_STAGE, temp, out_ptr, isign);
+ }
+}
diff --git a/lib_com/fft_rel_sas_fx.c b/lib_com/fft_rel_sas_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..06a7c0f28d993d69051bdfcb153f9add388502f1
--- /dev/null
+++ b/lib_com/fft_rel_sas_fx.c
@@ -0,0 +1,456 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "prot_fx.h" /* Function prototypes */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+
+/*---------------------------------------------------------------------*
+ * Local constants
+ *---------------------------------------------------------------------*/
+
+#define INV_SQR2_FX 23170
+#define N_MAX_SAS 256
+
+/*---------------------------------------------------------------------*
+ * fft_rel_fx()
+ *
+ * Computes the split-radix FFT in place for the real-valued
+ * signal x of length n. The algorithm has been ported from
+ * the fortran code of [1].
+ *
+ * The function needs sine and cosine tables t_sin and t_cos,
+ * and the constant N_MAX_SAS. The table entries are defined as
+ * sin(2*pi*i) and cos(2*pi*i) for i = 0, 1, ..., N_MAX_SAS-1. The
+ * implementation assumes that any entry will not be needed
+ * outside the tables. Therefore, N_MAX_SAS and n must be properly
+ * set. The function has been tested with the values n = 16,
+ * 32, 64, 128, 256, and N_MAX_SAS = 1280.
+ *
+ * References
+ * [1] H.V. Sorensen, D.L. Jones, M.T. Heideman, C.S. Burrus,
+ * "Real-valued fast Fourier transform algorithm," IEEE
+ * Trans. on Signal Processing, Vol.35, No.6, pp 849-863,
+ * 1987.
+ *
+ * OUTPUT
+ * x[0:n-1] Transform coeffients in the order re[0], re[1],
+ * ..., re[n/2], im[n/2-1], ..., im[1].
+ *---------------------------------------------------------------------*/
+/*MERGE fft_rel_fx and fft_rel_fx_lc */
+void fft_rel_fx(
+ Word16 x[], /* i/o: input/output vector */
+ const Word16 n, /* i : vector length */
+ const Word16 m /* i : log2 of vector length */
+)
+{
+ Word16 i, j, k, n1, n2, n4;
+ Word16 step;
+ Word16 xt, t1, t2;
+ Word16 *x0, *x1, *x2;
+ const Word16 *s, *c;
+ Word16 *xi2, *xi3, *xi4, *xi1;
+
+
+ /*-----------------------------------------------------------------*
+ * Digit reverse counter
+ *-----------------------------------------------------------------*/
+
+ j = 0;
+ move16();
+ x0 = &x[0];
+ move16();
+ FOR (i = 0; i < n-1; i++)
+ {
+ IF (LT_16(i,j))
+ {
+ xt = x[j];
+ move16();
+ x[j] = *x0;
+ move16();
+ *x0 = xt;
+ move16();
+ }
+ x0++;
+ k = shr(n,1);
+ WHILE (LE_16(k,j))
+ {
+ j = sub(j,k);
+ k = shr(k,1);
+ }
+ j = add(j,k);
+ }
+
+ /*-----------------------------------------------------------------*
+ * Length two butterflies
+ *-----------------------------------------------------------------*/
+
+ x0 = &x[0];
+ move16();
+ x1 = &x[1];
+ move16();
+ FOR (i = 0; i < n/2; i++)
+ {
+ xt = *x0;
+ move16();
+ *x0 = add(xt,*x1);
+ move16();
+ *x1 = sub(xt,*x1);
+ move16();
+ x0++;
+ x0++;
+ x1++;
+ x1++;
+ }
+
+ /*-----------------------------------------------------------------*
+ * Other butterflies
+ *
+ * The implementation described in [1] has been changed by using
+ * table lookup for evaluating sine and cosine functions. The
+ * variable ind and its increment step are needed to access table
+ * entries. Note that this implementation assumes n4 to be so
+ * small that ind will never exceed the table. Thus the input
+ * argument n and the constant N_MAX_SAS must be set properly.
+ *-----------------------------------------------------------------*/
+
+ n2 = 1;
+ move16();
+ /* step = N_MAX_SAS/4; */
+ FOR (k = 2; k <= m; k++)
+ {
+ n4 = n2;
+ move16();
+ n2 = shl(n4,1);
+ n1 = shl(n2,1);
+
+ step = N_MAX_SAS/n1;
+
+ x0 = x;
+ x1 = x + n2;
+ x2 = x + add(n2, n4);
+ FOR (i = 0; i < n; i += n1)
+ {
+ xt = *x0;
+ move16(); /* xt = x[i]; */
+ *x0 = add(xt,*x1);
+ move16(); /* x[i] = xt + x[i+n2]; */
+ *x1 = sub(xt,*x1);
+ move16(); /* x[i+n2] = xt - x[i+n2]; */
+ *x2 = negate(*x2);
+ move16(); /* x[i+n2+n4] = -x[i+n2+n4]; */
+
+
+ s = sincos_t_fx + step;
+ c = s + 64;
+ xi1 = x + add(i, 1);
+ xi3 = xi1 + n2;
+ xi2 = xi3 - 2;
+ xi4 = xi1 + sub(n1, 2);
+
+ FOR (j = 1; j < n4; j++)
+ {
+ t1 = add(mult_r(*xi3,*c),mult_r(*xi4,*s)); /* t1 = *xi3**(pt_c+ind) + *xi4**(pt_s+ind); */
+ t2 = sub(mult_r(*xi3,*s),mult_r(*xi4,*c)); /* t2 = *xi3**(pt_s+ind) - *xi4**(pt_c+ind); */
+ *xi4 = sub(*xi2,t2);
+ move16();
+ *xi3 = negate(add(*xi2,t2));
+ move16();
+ *xi2 = sub(*xi1,t1);
+ move16();
+ *xi1 = add(*xi1,t1);
+ move16();
+
+ xi4--;
+ xi2--;
+ xi3++;
+ xi1++;
+ c += step;
+ s += step; /* autoincrement by ar0 */
+ }
+
+ x0 += n1;
+ x1 += n1;
+ x2 += n1;
+ }
+ /* step = shr(step, 1); */
+ }
+
+ return;
+}
+
+void ifft_rel_fx(
+ Word16 io[], /* i/o: input/output vector */
+ const Word16 n, /* i : vector length */
+ const Word16 m /* i : log2 of vector length */
+)
+{
+ Word16 i, j, k;
+ Word16 step;
+ Word16 n2, n4, n8, i0;
+ Word16 is, id;
+ Word16 *x,*xi0, *xi1, *xi2, *xi3, *xi4, *xup1, *xdn6, *xup3, *xdn8;
+ Word16 xt;
+ Word16 r1;
+ Word16 t1, t2, t3, t4, t5;
+ const Word16 *s, *c, *s3, *c3;
+
+ Word16 cc1, cc3, ss1, ss3;
+ Word16 tmp;
+
+
+ /*-----------------------------------------------------------------*
+ * ifft
+ *-----------------------------------------------------------------*/
+
+ x = &io[-1];
+ move16();
+ n2 = shl(n,1);
+ FOR (k=1; k
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h" /* required for wmc_tool */
+
+/*--------------------------------------------------------------------------*
+ * fill_spectrum()
+ *
+ * Apply spectral filling by
+ * - filling zero-bit bands below BWE region
+ * - applying BWE above transition frequency
+ *--------------------------------------------------------------------------*/
+
+void fill_spectrum_fx(
+ Word16 *coeff, /* i/o: normalized MLT spectrum / nf spectrum Q12 */
+ Word32 *L_coeff_out, /* i/o: Noisefilled MLT spectrum Q12 */
+ const Word16 *R, /* i : number of pulses per band Q0 */
+ const Word16 is_transient, /* i : transient flag Q0 */
+ Word16 norm[], /* i : quantization indices for norms Q0 */
+ const Word16 *hq_generic_fenv, /* i : HQ GENERIC envelope Q1 */
+ const Word16 hq_generic_offset, /* i : HQ GENERIC offset Q0 */
+ const Word16 nf_idx, /* i : noise fill index Q0 */
+ const Word16 length, /* i : Length of spectrum (32 or 48 kHz) Q0 */
+ const Word16 env_stab, /* i : Envelope stability measure [0..1] Q15 */
+ Word16 *no_att_hangover, /* i/o: Frame counter for attenuation hangover Q0 */
+ Word32 *L_energy_lt, /* i/o: Long-term energy measure for transient detection Q13 */
+ Word16 *bwe_seed, /* i/o: random seed for generating BWE input Q0 */
+ const Word16 hq_generic_exc_clas, /* i : BWE excitation class Q0 */
+ const Word16 core_sfm, /* i : index of the end band for core Q0 */
+ const Word16 HQ_mode, /* i : HQ mode Q0 */
+ Word16 noise_level[], /* i : noise levels for harmonic modes Q15 */
+ const Word32 L_core_brate, /* i : target bit-rate Q0 */
+ Word16 prev_noise_level[], /* i/o: noise factor in previous frame Q15 */
+ Word16 *prev_R, /* i/o: bit allocation info. in previous frame Q0 */
+ Word32 *prev_coeff_out, /* i/o: decoded spectrum in previous frame Q12 */
+ const Word16 *peak_idx, /* i : peak indices for hvq Q0 */
+ const Word16 Npeaks, /* i : number of peaks in hvq Q0 */
+ const Word16 *npulses, /* i : number of pulses per band Q0 */
+ const Word16 prev_is_transient, /* i : previous transient flag Q0 */
+ Word32 *prev_normq, /* i/o: previous norms Q14 */
+ Word32 *prev_env, /* i/o: previous noise envelopes Q(prev_env_Q) */
+ const Word16 prev_bfi, /* i : previous bad frame indicator Q0 */
+ const Word16 *sfmsize, /* i : Length of bands Q0 */
+ const Word16 *sfm_start, /* i : Start of bands Q0 */
+ const Word16 *sfm_end, /* i : End of bands Q0 */
+ Word16 *prev_L_swb_norm, /* i/o: HVQ/Harmonic mode normalization length Q0 */
+ const Word16 prev_hq_mode, /* i : Previous HQ mode Q0 */
+ const Word16 num_sfm /* i : Total number of bands Q0 */
+ ,Word16 *prev_env_Q
+ ,const Word16 num_env_bands /* i : Number sub bands to be encoded for HQ_GEN Q0 */
+)
+{
+ Word16 CodeBook[FREQ_LENGTH]; /* Q12 */
+ Word16 cb_size;
+ Word16 last_sfm;
+ Word16 CodeBook_mod[FREQ_LENGTH]; /*Q12 */
+ Word16 norm_adj[NB_SFM]; /*Q15 */
+ Word16 high_sfm;
+ Word16 flag_32K_env_hangover;
+ Word16 bin_th;
+ Word16 peak_pos[L_HARMONIC_EXC];
+ Word16 bwe_peaks[L_FRAME48k];
+ Word32 L_normq_v[NB_SFM]; /*Q14 */
+ Word16 coeff_fine[L_FRAME48k]; /*Q15 */
+ Word32 L_coeff_out1[L_FRAME48k]; /*Q12 */
+
+ set16_fx( peak_pos, 0, L_HARMONIC_EXC );
+ set16_fx( bwe_peaks, 0, L_FRAME48k );
+ set16_fx(norm_adj, 32767, num_sfm); /* 1.0, Q15 */
+ cb_size = 0;
+ move16();
+ bin_th = 0;
+ move16();
+ high_sfm = 23;
+ move16();
+
+ test();
+ IF ( EQ_16(HQ_mode, HQ_TRANSIENT))
+ {
+ last_sfm = sub(num_sfm, 1);
+ }
+ ELSE IF ( EQ_16(HQ_mode,HQ_GEN_SWB)||EQ_16(HQ_mode,HQ_GEN_FB))
+ {
+ last_sfm = s_max(core_sfm,sub(num_env_bands,1));
+ }
+ ELSE
+ {
+ last_sfm = core_sfm;
+ move16();
+ }
+
+ IF ( EQ_16(HQ_mode, HQ_HARMONIC))
+ {
+ /*high_sfm = (core_brate == HQ_24k40) ? HVQ_THRES_SFM_24k-1 : HVQ_THRES_SFM_32k-3; */
+ high_sfm = sub(HVQ_THRES_SFM_32k, 1);
+ if (EQ_32(L_core_brate, HQ_24k40))
+ {
+ high_sfm = sub(HVQ_THRES_SFM_24k, 1);
+ }
+
+ if( LT_16(last_sfm, high_sfm))
+ {
+ last_sfm = high_sfm;
+ move16();
+ }
+ }
+ ELSE if ( EQ_16(HQ_mode, HQ_HVQ))
+ {
+ bin_th = sfm_end[last_sfm];
+ move16();
+ }
+
+ /* Transient analysis for envelope stability measure */
+ IF ( EQ_16(length, L_FRAME32k))
+ {
+ env_stab_transient_detect_fx( is_transient, length, norm, no_att_hangover, L_energy_lt, HQ_mode, bin_th, L_coeff_out, 12 );
+ }
+
+ test();
+ test();
+ test();
+ test();
+ IF ( EQ_16(length, L_FRAME16k)||
+ ((EQ_16(length, L_FRAME32k) && NE_16(HQ_mode, HQ_HARMONIC) && NE_16(HQ_mode, HQ_HVQ) ) && *no_att_hangover == 0) )
+ {
+ /* Norm adjustment function */
+ env_adj_fx( npulses, length, last_sfm, norm_adj, env_stab, sfmsize );
+ }
+
+ /*flag_32K_env_hangover = ( length == L_FRAME32k && ( (env_stab < 0.5f && *no_att_hangover == 0) || HQ_mode == HQ_HVQ ) ); */
+ flag_32K_env_hangover = 0;
+ move16();
+ test();
+ test();
+ test();
+ if ( EQ_16(length, L_FRAME32k)&&((LT_16(env_stab,16384)&&*no_att_hangover==0)||EQ_16(HQ_mode,HQ_HVQ)))
+ {
+ flag_32K_env_hangover = 1;
+ move16();
+ }
+
+
+ /*----------------------------------------------------------------*
+ * Build noise-fill codebook
+ *----------------------------------------------------------------*/
+
+ IF ( NE_16(HQ_mode, HQ_HVQ))
+ {
+ cb_size = build_nf_codebook_fx(flag_32K_env_hangover, coeff, sfm_start, sfmsize, sfm_end, last_sfm, R, CodeBook, CodeBook_mod);
+ }
+ /*----------------------------------------------------------------*
+ * Prepare fine structure for Harmonic and HVQ
+ *----------------------------------------------------------------*/
+
+ IF ( EQ_16(HQ_mode, HQ_HARMONIC))
+ {
+ harm_bwe_fine_fx( R, last_sfm, high_sfm, num_sfm, norm, sfm_start, sfm_end, prev_L_swb_norm, coeff, L_coeff_out, coeff_fine );
+ }
+ ELSE IF ( EQ_16(HQ_mode, HQ_HVQ))
+ {
+ hvq_bwe_fine_fx( last_sfm, num_sfm, sfm_end, peak_idx, Npeaks, peak_pos, prev_L_swb_norm, L_coeff_out, bwe_peaks, coeff_fine );
+ }
+
+ /*----------------------------------------------------------------*
+ * Apply noise-fill
+ *----------------------------------------------------------------*/
+
+ test();
+ IF ( NE_16(HQ_mode, HQ_HVQ)&&cb_size>0)
+ {
+ apply_noisefill_HQ_fx( R, length, flag_32K_env_hangover, L_core_brate, last_sfm, CodeBook,
+ CodeBook_mod, cb_size, sfm_start, sfm_end, sfmsize, coeff );
+ }
+
+ /*----------------------------------------------------------------*
+ * Normal mode BWE
+ *----------------------------------------------------------------*/
+
+ IF ( HQ_mode == HQ_NORMAL )
+ {
+ hq_fold_bwe_fx(last_sfm, sfm_end, num_sfm, coeff);
+ }
+
+ /*----------------------------------------------------------------*
+ * Apply noise-fill adjustment
+ *----------------------------------------------------------------*/
+
+ test();
+ test();
+ test();
+ IF( (GE_16(length, L_FRAME32k)||GT_32(L_core_brate,HQ_32k)||LT_32(L_core_brate,HQ_24k40))
+ && NE_16(HQ_mode, HQ_HVQ) )
+ {
+ apply_nf_gain_fx(nf_idx, last_sfm, R, sfm_start, sfm_end, coeff);
+ }
+
+ /*----------------------------------------------------------------*
+ * Prepare fine strucutre for HQ GENERIC
+ *----------------------------------------------------------------*/
+ test();
+ IF ( EQ_16(HQ_mode, HQ_GEN_SWB)||EQ_16(HQ_mode,HQ_GEN_FB))
+ {
+ hq_generic_fine_fx( coeff, last_sfm, sfm_start, sfm_end, bwe_seed, coeff_fine );
+ }
+
+ /*----------------------------------------------------------------*
+ * Apply envelope
+ *----------------------------------------------------------------*/
+
+ test();
+ IF ( NE_16(HQ_mode, HQ_HARMONIC)&&NE_16(HQ_mode,HQ_HVQ))
+ {
+ apply_envelope_fx( coeff, norm, norm_adj, num_sfm, last_sfm, HQ_mode, length, sfm_start, sfm_end,
+ L_normq_v, L_coeff_out, coeff_fine, L_coeff_out1 );
+ }
+
+ /*----------------------------------------------------------------*
+ * Harmonic BWE, HVQ BWE and HQ SWB BWE
+ *----------------------------------------------------------------*/
+ test();
+ IF ( EQ_16(HQ_mode, HQ_HARMONIC))
+ {
+ harm_bwe_fx( coeff_fine, coeff, num_sfm, sfm_start, sfm_end, last_sfm, R, prev_hq_mode, norm, noise_level, prev_noise_level, bwe_seed, L_coeff_out );
+ }
+ ELSE IF ( EQ_16(HQ_mode, HQ_HVQ))
+ {
+ hvq_bwe_fx( L_coeff_out, coeff_fine, sfm_start, sfm_end, sfmsize, last_sfm,
+ prev_hq_mode, bwe_peaks, bin_th, num_sfm, L_core_brate, R, norm,
+ noise_level, prev_noise_level, bwe_seed, L_coeff_out, 15, 12 );
+ }
+ ELSE IF ( EQ_16(HQ_mode, HQ_GEN_SWB)||EQ_16(HQ_mode,HQ_GEN_FB))
+ {
+ hq_bwe_fx( HQ_mode, L_coeff_out1, hq_generic_fenv, L_coeff_out, hq_generic_offset, prev_L_swb_norm, hq_generic_exc_clas, sfm_end, num_sfm, num_env_bands, R );
+ }
+
+ /*----------------------------------------------------------------*
+ * HQ WB BWE refinements
+ *----------------------------------------------------------------*/
+ test();
+ IF ( EQ_16(length, L_FRAME16k)&&EQ_32(L_core_brate,HQ_32k))
+ {
+ hq_wb_nf_bwe_fx( coeff, is_transient, prev_bfi, L_normq_v, num_sfm, sfm_start, sfm_end, sfmsize, last_sfm, R,
+ prev_is_transient, prev_normq, prev_env, bwe_seed, prev_coeff_out, prev_R, L_coeff_out, prev_env_Q );
+ }
+
+ /*----------------------------------------------------------------*
+ * Update memories
+ *----------------------------------------------------------------*/
+
+ test();
+ IF ( NE_16(HQ_mode, HQ_HARMONIC)&&NE_16(HQ_mode,HQ_HVQ))
+ {
+ prev_noise_level[0] = 3277;
+ move16();/* 0.1 in Q15 */
+ prev_noise_level[1] = 3277;
+ move16();/* 0.1 in Q15 */
+ }
+ test();
+ IF ( !(EQ_16(length, L_FRAME16k)&&EQ_32(L_core_brate,HQ_32k)))
+ {
+ set32_fx( prev_env, 0, SFM_N_WB );
+ set32_fx( prev_normq, 0, SFM_N_WB );
+ }
+
+ test();
+ IF ( EQ_16(length, L_FRAME32k)&&LE_32(L_core_brate,HQ_32k))
+ {
+ *prev_R = R[SFM_N_WB-1];
+ Copy32( L_coeff_out + L_FRAME16k - L_HQ_WB_BWE, prev_coeff_out, L_HQ_WB_BWE );
+ }
+
+ return;
+}
diff --git a/lib_com/findpulse_fx.c b/lib_com/findpulse_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..f292b65847cd9d05a3d68d700555079d608d65e1
--- /dev/null
+++ b/lib_com/findpulse_fx.c
@@ -0,0 +1,117 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+
+/*----------------------------------------------------------------------------------*
+ * findpulse()
+ *
+ * Find first pitch pulse in a frame
+ *----------------------------------------------------------------------------------*/
+Word16 findpulse_fx( /* o : pulse position */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 res[], /* i : Residual signal <12 bits */
+ const Word16 T0, /* i : Pitch estimation Q0 */
+ const Word16 enc, /* i : enc = 1 -> encoder side; enc = 0 -> decoder side */
+ Word16 *sign /* i/o: sign of the maximum */
+)
+{
+ const Word16 *ptr;
+ Word16 maxval;
+ Word16 i, maxi;
+ Word32 Ltmp;
+ Word16 resf[L_FRAME16k]; /* Low pass filtered residual */
+
+ IF (enc != DEC)
+ {
+ /*------------------------------------------------------------------------*
+ * 1. Very simple LP filter
+ *------------------------------------------------------------------------*/
+
+ /* resf[0] = 0.50f * res[0] + 0.25f * res[1] */
+ Ltmp = L_mult(res[0], 16384);
+ resf[0] = mac_r(Ltmp, res[1], 8192);
+ move16();
+ FOR (i=1; i= 0)
+ {
+ *sign = 0; move16();
+ }*/
+ *sign = negate(shr(ptr[-maxi], 15));
+ move16();
+ }
+ ELSE
+ {
+ /*-----------------------------------------------------------------*
+ * 2. Find "biggest" pulse in the last pitch section according to the sign
+ *-----------------------------------------------------------------*/
+
+ maxval = 0;
+ move16();
+ maxi = 0;
+ move16();
+
+ IF (*sign == 0)
+ {
+ FOR (i = 0; i < T0; i++)
+ {
+ if (GE_16(res[i], maxval))
+ {
+ maxi = add(i, 1);
+ }
+ maxval = s_max(res[i], maxval);
+ }
+ }
+ ELSE
+ {
+ FOR (i = 0; i < T0; i++)
+ {
+ if (LE_16(res[i], maxval))
+ {
+ maxi = add(i, 1);
+ }
+ maxval = s_min(res[i], maxval);
+ }
+ }
+ }
+
+ return maxi;
+}
diff --git a/lib_com/fine_gain_bits_fx.c b/lib_com/fine_gain_bits_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..d6db7260ea16b162cd85c43514c21d3b8ace3166
--- /dev/null
+++ b/lib_com/fine_gain_bits_fx.c
@@ -0,0 +1,107 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h" /* required for wmc_tool */
+
+
+/*--------------------------------------------------------------------------
+ * subband_gain_bits()
+ *
+ * HQ core encoder
+ *--------------------------------------------------------------------------*/
+
+void subband_gain_bits_fx(
+ const Word16 *Rk, /* i : bit allocation per band Q3 */
+ const Word16 N, /* i : number of bands */
+ Word16 *bits, /* o : gain bits per band */
+ const Word16 *sfmsize /* i : Size of bands */
+)
+{
+ Word16 i,b,tot;
+ Word16 bps;
+
+ tot = 0;
+ move16();
+
+ FOR ( i = 0; i < N; i++ )
+ {
+ /*bps = (short)(Rk[i]*((word16)min(32767, ceil(32767.0f/sfmsize[i]); inexact C-integer division approx. */
+ bps = extract_l(L_shr(L_mult0(Rk[i], inv_tbl_fx[sfmsize[i]]), 18)); /* 3+15 */
+ if (EQ_32(L_shl(L_mult0(sfmsize[i], add(bps, 1)), 3), Rk[i]))
+ {
+ bps = add(bps, 1);
+ }
+
+ bps = s_min(7, bps);
+ b = fine_gain_bits[bps];
+ move16();
+ bits[i] = b;
+ move16();
+ tot = add(tot, b);
+ }
+
+ if ( tot == 0)
+ {
+ /* If no gain bits were assigned, use one bit anyway for potential PVQ overage */
+ bits[0] = 1;
+ move16();
+ }
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * assign_gain_bits()
+ *
+ * Assign gain adjustment bits and update bit budget
+ *--------------------------------------------------------------------------*/
+
+Word16 assign_gain_bits_fx( /* o : Number of assigned gain bits */
+ const Word16 core, /* i : HQ core */
+ const Word16 BANDS, /* i : Number of bands */
+ const Word16 *band_width, /* i : Sub band bandwidth */
+ Word16 *Rk, /* i/o: Bit allocation/Adjusted bit alloc. Q3 */
+ Word16 *gain_bits_array, /* o : Assigned gain bits */
+ Word16 *Rcalc /* o : Bit budget for shape quantizer Q3 */
+)
+{
+ Word16 subband_cnt;
+ Word16 gain_bits_tot;
+ Word16 i;
+
+ /* Allocate gain bits for every subband used, based on bit rate and bandwidth */
+ IF( EQ_16(core, HQ_CORE))
+ {
+ subband_gain_bits_fx(Rk, BANDS, gain_bits_array, band_width);
+ }
+ ELSE
+ {
+ set16_fx( gain_bits_array, 0, BANDS );
+ }
+
+ /* Re-adjust bit budget for gain quantization */
+ subband_cnt = 0;
+ move16();
+ gain_bits_tot = 0;
+ move16();
+ *Rcalc = 0;
+ move16();
+ FOR (i = 0; i < BANDS; i++)
+ {
+ IF (Rk[i] > 0)
+ {
+ subband_cnt = add(subband_cnt, 1);
+ Rk[i] = sub(Rk[i], shl(gain_bits_array[i], 3));
+ move16();
+ gain_bits_tot = add(gain_bits_tot, gain_bits_array[i]);
+ *Rcalc = add(*Rcalc, Rk[i]);
+ move16();
+ }
+ }
+
+ return gain_bits_tot;
+}
diff --git a/lib_com/frame_ener_fx.c b/lib_com/frame_ener_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..a70235e53e4b69a8413455723d99b51c4928e826
--- /dev/null
+++ b/lib_com/frame_ener_fx.c
@@ -0,0 +1,196 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+
+/*----------------------------------------------------------------------------------*
+ * frame_ener()
+ *
+ * Estimation of pitch-synchronous (voiced) or mean half-frame (unvoiced) energy
+ *----------------------------------------------------------------------------------*/
+Word16 frame_ener_fx(
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 clas, /* i : frame classification */
+ const Word16 *synth, /* i : synthesized speech at Fs = 12k8 Hz Q_new */
+ const Word16 pitch, /* i : pitch period Q0 */
+ Word32 *enr_q, /* o : pitch-synchronous or half_frame energy Q0 */
+ const Word16 offset, /* i : speech pointer offset (0 or L_FRAME) */
+ const Word16 Q_new, /* i : Scaling factor */
+ Word16 shift, /* i : Shift need to obtain 12 bits vectors */
+ const Word16 enc /* i : Encoder/decoder */
+)
+{
+ Word16 len, exp_enrq, exp_tmp, pos;
+ Word16 i;
+ const Word16 *pt_synth;
+ Word32 Ltmp;
+
+ exp_enrq = 0;
+ move16();
+ test();
+ test();
+ IF( (EQ_16(clas, VOICED_CLAS))||(EQ_16(clas,ONSET))||(EQ_16(clas,SIN_ONSET))) /* current frame is voiced */
+ {
+ /* current frame is voiced */
+ len = pitch;
+ move16(); /* pitch value at the end of frame */
+ pt_synth = synth;
+ move16();
+ if (offset != 0)
+ {
+ pt_synth = synth + sub(L_frame, len);
+ }
+ emaximum_fx(Q_new, pt_synth, len, enr_q);
+ move16();/* pitch synchronous E */
+ IF (enc != 0)
+ {
+ exp_enrq = norm_l(*enr_q);
+ *enr_q = L_shl(*enr_q, exp_enrq);
+ move32();
+ exp_enrq = sub(exp_enrq, 2);
+ }
+ }
+ ELSE
+ {
+ /* current frame is unvoiced */
+ Word16 L_frame2, exp2, enr_q_tmp;
+
+ L_frame2 = shr(L_frame,1);
+ pos = 0;
+ move16();
+
+ if (offset != 0)
+ {
+ pos = sub(L_frame, L_frame2);
+ }
+ Ltmp = L_mult(synth[pos], synth[pos]);
+ FOR (i = 1; i < L_frame2; i++)
+ {
+ Ltmp = L_mac(Ltmp, synth[pos+i], synth[pos+i]);
+ }
+ test();
+ IF (EQ_32(Ltmp, MAX_32)||enc!=0)
+ {
+ /* scale down when overflow occurs */
+ *enr_q = Energy_scale(synth+pos, L_frame2, shift, &exp_enrq);
+ move32();
+ }
+ ELSE
+ {
+ shift = 0;
+ move16();
+ /* Normalize acc in Q31 (energy already calculated) */
+ pos = norm_l(Ltmp);
+ Ltmp = L_shl(Ltmp, pos);
+ exp_enrq = sub(30, pos); /* exponent = 0..30 */
+ *enr_q = Ltmp;
+ move32();
+ }
+
+ /* enr2 = 1.0f/L_FRAME2 * dot_product(synth, synth, L_FRAME2) */
+ exp_enrq = sub(exp_enrq, shl(shift, 1));
+
+ IF (enc != 0)
+ {
+ assert(L_frame == 256 || L_frame == 320);
+
+ exp_tmp = add(shl(Q_new, 1), -2+7); /* L_subfr == L_SUBFR */
+ exp_enrq = sub(exp_enrq, exp_tmp);
+ exp_enrq = sub(31, exp_enrq);
+
+ IF(EQ_16(L_frame, 320))
+ {
+ *enr_q = Mult_32_16(*enr_q, 26214); /*x 0.8 to get /160*/
+ i = norm_l(*enr_q);
+ *enr_q = L_shl(*enr_q, i);
+ exp_enrq = add(i, exp_enrq);
+ }
+ }
+ ELSE
+ {
+ exp_enrq = sub(exp_enrq, add(Q_new, Q_new));
+ enr_q_tmp /*Q30 exp2+exp_enrq*/ = BASOP_Util_Divide3216_Scale(*enr_q /*Q31*/, L_frame2 /*Q0*/, &exp2);
+ *enr_q = L_shr(L_deposit_l(enr_q_tmp),sub(30,add(exp2,exp_enrq))); /*Q0*/
+ *enr_q = L_add(*enr_q, 1);
+ move32();
+ exp_enrq = 0;
+ move16();
+ }
+
+
+
+
+
+
+ }
+
+ return exp_enrq;
+}
+
+/*------------------------------------------------------------------------*
+ * frame_energy()
+ *
+ * Compute pitch-synchronous energy at the frame end
+ *------------------------------------------------------------------------*/
+Word16 frame_energy_fx( /* o : Frame energy in Q8 */
+ Word16 L_frame,
+ const Word16 *pitch, /* i : pitch values for each subframe Q6 */
+ const Word16 *speech, /* i : pointer to speech signal for E computation Q_syn*/
+ const Word16 lp_speech, /* i : long term active speech energy average Q8 */
+ Word16 *frame_ener, /* o : pitch-synchronous energy at frame end Q8 */
+ const Word16 Q_syn /* i : Synthesis scaling */
+)
+{
+ Word32 Ltmp;
+ const Word16 *pt1;
+ Word16 tmp16, exp1, exp2, tmp1, tmp2;
+ Word16 len, enern;
+
+ /* len = (0.5f * (pitch[2]/64.0 + pitch[3]/64.0) + 0.5f) */
+ len = mult_r(add(pitch[2], pitch[3]), 256);
+
+ if(LT_16(len,L_SUBFR))
+ {
+ len = shl(len, 1);
+ }
+ pt1 = speech + sub(L_frame,len);
+
+ /* *frame_ener = 10.0f * log10(dot_product(pt1, pt1, len) / (float)len) */
+
+ tmp1 = norm_s(len);
+ tmp2 = shl(len, tmp1);
+ tmp1 = sub(15, tmp1);
+
+ Ltmp = Dot_productSq16HQ( 0, pt1, len, &exp1);
+ exp1 = sub(exp1, shl(Q_syn, 1));
+ exp1 = sub(exp1, 1); /* compensation of leftshift caused by mac operation in dot_productSq16HQ */
+ tmp16 = BASOP_Util_Divide3216_Scale( Ltmp, len, &exp2);
+
+ exp1 = add(exp1, exp2);
+ exp1 = add(exp1, 1); /* compensate result of division Q-1 */
+
+
+ tmp2 = norm_s(tmp16);
+ Ltmp = L_shl(L_deposit_h(tmp16),tmp2); /*Q16, (exp1-tmp2) = Q31, exp1-tmp2+15*/
+
+ Ltmp = BASOP_Util_Log2(Ltmp);/*Q(31-6) = Q25*/
+ exp1 = sub(15+exp1,tmp2);
+
+ /*add ld(2^exp1)=exp1 but check format, first*/
+ tmp16=sub(sub(15,norm_s(exp1)),5); /*factor to shift Ltmp and exp1 with (shr) to avoid overflows when adding*/
+ Ltmp= L_shr(Ltmp,tmp16); /*Q25, tmp16*/
+ exp2 = shr(exp1,tmp16); /*Q0 , tmp16*/
+ Ltmp = L_add(Ltmp,L_shl(L_deposit_l(exp2),25)); /*Q25, tmp16, normalized*/
+
+ /*make 10*log10 out of log2*/
+ Ltmp = Mpy_32_16_1(Ltmp,LG10); /*Q25,tmp16 * Q13 = Q23, tmp16*/
+ *frame_ener = extract_h(L_shl(Ltmp,add(tmp16,1)));/*Q8*/ move16();
+ enern = sub( *frame_ener ,lp_speech); /*Q8*/
+
+ return enern;
+}
diff --git a/lib_com/g192.c b/lib_com/g192.c
new file mode 100644
index 0000000000000000000000000000000000000000..05ad613443a08e809ea128ee598fd7e8e18eec7a
--- /dev/null
+++ b/lib_com/g192.c
@@ -0,0 +1,254 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.442 May 28, 2020. Version 12.13.0 / 13.8.0 / 14.4.0 / 15.2.0 / 16.0.0
+ ====================================================================================*/
+
+#include
+#include
+#include
+#include
+
+#ifndef _WIN32
+#include
+#include
+#else
+#include
+typedef unsigned short uint16_t;
+typedef signed short int16_t;
+typedef unsigned int uint32_t;
+typedef signed int int32_t;
+typedef unsigned __int64 uint64_t;
+typedef signed __int64 int64_t;
+#endif
+#include "options.h"
+#include "stl.h"
+#include "g192.h"
+
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4996 )
+#endif
+
+#define G192_SYNC_GOOD_FRAME (Word16)0x6B21
+#define G192_SYNC_BAD_FRAME (Word16)0x6B20
+#define G192_BIT0 (Word16)0x007F
+#define G192_BIT1 (Word16)0x0081
+#define MAX_BITS_PER_FRAME 2560
+#define RTP_HEADER_PART1 (Word16)22 /* magic number by network simulator */
+
+/*
+ * Structures
+ */
+
+/* main handle */
+struct __G192
+{
+ FILE * file;
+};
+
+/*
+ * Functions
+ */
+
+G192_ERROR
+G192_Reader_Open(G192_HANDLE* phG192, FILE * filename)
+{
+ /* create handle */
+ *phG192 = (G192_HANDLE) calloc(1, sizeof(struct __G192) );
+ if ( *phG192 == NULL )
+ {
+ return G192_MEMORY_ERROR;
+ }
+
+ memset(*phG192, 0, sizeof(struct __G192));
+
+ /* associate file stream */
+ (*phG192)->file = filename;
+ if( (*phG192)->file == NULL )
+ {
+ G192_Reader_Close(phG192);
+ return G192_FILE_NOT_FOUND;
+ }
+
+ return G192_NO_ERROR;
+}
+
+G192_ERROR
+G192_ReadVoipFrame_compact(G192_HANDLE const hG192,
+ unsigned char * const serial,
+ Word16 * const num_bits,
+ Word16 *rtpSequenceNumber,
+ Word32 *rtpTimeStamp,
+ Word32 *rcvTime_ms)
+{
+ Word16 short_serial [MAX_BITS_PER_FRAME];
+ G192_ERROR err;
+ Word16 i;
+
+ err = G192_ReadVoipFrame_short(hG192, short_serial, num_bits, rtpSequenceNumber, rtpTimeStamp, rcvTime_ms);
+ if(err != G192_NO_ERROR)
+ {
+ return err;
+ }
+
+ for(i=0; i<*num_bits; i++)
+ {
+ unsigned char bit = (short_serial[i] == G192_BIT1) ? 1 : 0;
+ unsigned char bitinbyte = bit << (7- (i&0x7));
+ if(!(i&0x7))
+ serial[i>>3] = 0;
+ serial[i>>3] |= bitinbyte;
+ }
+
+ return G192_NO_ERROR;
+}
+
+G192_ERROR
+G192_ReadVoipFrame_short(G192_HANDLE const hG192,
+ Word16 * const serial,
+ Word16 *num_bits,
+ Word16 *rtpSequenceNumber,
+ Word32 *rtpTimeStamp,
+ Word32 *rcvTime_ms)
+{
+ Word32 rtpPacketSize;
+ Word16 rtpPacketHeaderPart1;
+ Word32 ssrc;
+ Word16 rtpPayloadG192[2];
+ Word16 rtpPayloadSize;
+
+ /* RTP packet size */
+ if(fread(&rtpPacketSize, sizeof(rtpPacketSize), 1, hG192->file) != 1)
+ {
+ if(feof( hG192->file) != 0)
+ {
+ return G192_EOF;
+ }
+ fprintf(stderr, "RTP Packet Size could't be read\n");
+ return G192_READ_ERROR;
+ }
+
+ if(rtpPacketSize <= 12)
+ {
+ fprintf(stderr, "RTP Packet size too small: %d\n", rtpPacketSize);
+ return G192_INVALID_DATA;
+ }
+
+ /* RTP packet arrival time */
+ if(fread(rcvTime_ms, sizeof(*rcvTime_ms), 1, hG192->file) != 1)
+ {
+ if(feof( hG192->file) != 0)
+ {
+ return G192_EOF;
+ }
+ fprintf(stderr, "Reception Time in ms could't be read\n");
+ return G192_READ_ERROR;
+ }
+
+ /* RTP packet header (part without sequence number) */
+ if(fread(&rtpPacketHeaderPart1, sizeof(rtpPacketHeaderPart1), 1, hG192->file) != 1)
+ {
+ if(feof( hG192->file) != 0)
+ {
+ return G192_EOF;
+ }
+ fprintf(stderr, "RTP Header couldn't be read\n");
+ return G192_READ_ERROR;
+ }
+
+ if(rtpPacketHeaderPart1 != RTP_HEADER_PART1)
+ {
+ fprintf(stderr, "Unexpected RTP Packet header\n");
+ return G192_INVALID_DATA;
+ }
+
+ /* RTP sequence number */
+ if(fread(rtpSequenceNumber, sizeof(*rtpSequenceNumber), 1, hG192->file) != 1)
+ {
+ if(feof( hG192->file) != 0)
+ {
+ return G192_EOF;
+ }
+ fprintf(stderr, "RTP Sequence Number be read\n");
+ return G192_READ_ERROR;
+ }
+
+ *rtpSequenceNumber = ntohs(*rtpSequenceNumber);
+ /* RTP timestamp */
+ if(fread(rtpTimeStamp, sizeof(*rtpTimeStamp), 1, hG192->file) != 1)
+ {
+ if(feof( hG192->file) != 0)
+ {
+ return G192_EOF;
+ }
+ fprintf(stderr, "RTP Timestamp could't be read\n");
+ return G192_READ_ERROR;
+ }
+
+ *rtpTimeStamp = ntohl(*rtpTimeStamp);
+ /* RTP ssrc */
+ if(fread(&ssrc, sizeof(ssrc), 1, hG192->file) != 1)
+ {
+ if(feof( hG192->file) != 0)
+ {
+ return G192_EOF;
+ }
+ fprintf(stderr, "RTP SSRC could't be read\n");
+ return G192_READ_ERROR;
+ }
+
+ /* RTP payload size */
+ rtpPayloadSize = (Word16)(rtpPacketSize - 12);
+ if(rtpPayloadSize <= 2)
+ {
+ fprintf(stderr, "RTP payload size too small: %d\n", rtpPayloadSize);
+ return G192_INVALID_DATA;
+ }
+ /* RTP payload */
+ if(fread(rtpPayloadG192, sizeof(Word16), 2, hG192->file) != 2)
+ {
+ if(feof( hG192->file) != 0)
+ {
+ return G192_EOF;
+ }
+ fprintf(stderr, "Premature end of file, cannot read G.192 header\n");
+ return G192_READ_ERROR;
+ }
+ if(rtpPayloadG192[0] != G192_SYNC_GOOD_FRAME)
+ {
+ fprintf(stderr, "G192_SYNC_WORD missing from RTP payload!");
+ return G192_INVALID_DATA;
+ }
+ *num_bits = rtpPayloadG192[1];
+ if(*num_bits == 0 || *num_bits + 2 != rtpPayloadSize || *num_bits > MAX_BITS_PER_FRAME)
+ {
+ fprintf(stderr, "error in parsing RTP payload: rtpPayloadSize=%u nBits=%d",
+ rtpPayloadSize, *num_bits);
+ return G192_INVALID_DATA;
+ }
+ if( (Word16)fread(serial, sizeof(Word16), *num_bits, hG192->file) != *num_bits)
+ {
+ if(feof( hG192->file) != 0)
+ {
+ return G192_EOF;
+ }
+ fprintf(stderr, "Premature end of file, cannot read G.192 payload\n");
+ return G192_READ_ERROR;
+ }
+
+ return G192_NO_ERROR;
+}
+
+G192_ERROR
+G192_Reader_Close(G192_HANDLE* phG192)
+{
+ if(phG192 == NULL || *phG192 == NULL)
+ {
+ return G192_NO_ERROR;
+ }
+
+ free( *phG192 );
+ *phG192 = NULL;
+ phG192 = NULL;
+
+ return G192_NO_ERROR;
+}
diff --git a/lib_com/g192.h b/lib_com/g192.h
new file mode 100644
index 0000000000000000000000000000000000000000..12981f6f78db56a7d474856419d68f5b4a242330
--- /dev/null
+++ b/lib_com/g192.h
@@ -0,0 +1,64 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.442 May 28, 2020. Version 12.13.0 / 13.8.0 / 14.4.0 / 15.2.0 / 16.0.0
+ ====================================================================================*/
+
+#ifndef G192_H
+#define G192_H G192_H
+
+/*
+ * ENUMS
+ */
+
+/* error enums */
+
+typedef enum _G192_ERROR
+{
+ G192_NO_ERROR = 0x0000,
+ G192_MEMORY_ERROR = 0x0001,
+ G192_WRONG_PARAMS = 0x0002,
+ G192_INIT_ERROR = 0x0003,
+ G192_WRITE_ERROR = 0x0004,
+ G192_READ_ERROR = 0x0005,
+ G192_FILE_NOT_FOUND = 0x0006,
+ G192_INVALID_DATA = 0x0007, /* error returned when read data is invalid */
+ G192_NOT_IMPLEMENTED = 0x0010,
+ G192_NOT_INITIALIZED = 0x0100,
+ G192_UNKNOWN_ERROR = 0x1000,
+ G192_EOF = 0xffff /* EOF during reading */
+} G192_ERROR;
+
+/*
+ * Structures
+ */
+
+/* main handle */
+struct __G192;
+typedef struct __G192 * G192_HANDLE;
+
+/*
+ * Functions
+ */
+
+G192_ERROR
+G192_Reader_Open(G192_HANDLE* phG192, FILE * filename);
+
+G192_ERROR
+G192_ReadVoipFrame_compact(G192_HANDLE const hG192,
+ unsigned char * const serial,
+ Word16 * const num_bits,
+ Word16 *rtpSequenceNumber,
+ Word32 *rtpTimeStamp,
+ Word32 *rcvTime_ms);
+
+G192_ERROR
+G192_ReadVoipFrame_short(G192_HANDLE const hG192,
+ Word16 * const serial,
+ Word16 *num_bits,
+ Word16 *rtpSequenceNumber,
+ Word32 *rtpTimeStamp,
+ Word32 *rcvTime_ms);
+
+G192_ERROR
+G192_Reader_Close(G192_HANDLE* phG192);
+
+#endif /* G192_H */
diff --git a/lib_com/gain_inov.c b/lib_com/gain_inov.c
new file mode 100644
index 0000000000000000000000000000000000000000..703054cc05030a0adc532b3e57f5c7dc69f1903a
--- /dev/null
+++ b/lib_com/gain_inov.c
@@ -0,0 +1,54 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "prot_fx.h"
+#include "stl.h"
+#include "basop_util.h"
+#include "rom_com_fx.h"
+
+
+Word32 calc_gain_inov( /* returns innovation gain Q16 */
+ const Word16 *code, /* i : algebraic excitation Q9 */
+ Word16 lcode, /* i : Subframe size Q0 */
+ Word32 *dotp, /* o : intermediate result Q31-e */
+ Word16 *dotp_e /* o : intermediate result exponent Q0 */
+)
+{
+ Word32 L_tmp;
+ Word16 exp_L_tmp, i;
+
+ /* L_tmp = dot_product(code, code, lcode) + 0.01 */
+ L_tmp = Dot_product12_offs(code, code, lcode, &exp_L_tmp, 2621l/*0.01f/2.0f Q19*/);
+ exp_L_tmp = sub(exp_L_tmp, 18);
+
+ /* gain_inov = 1.0f / sqrt((dot_product(code, code, lcode) + 0.01) / lcode) */
+ /* Note: lcode is in range: 32,40,64,80 */
+ assert((lcode == 32) || (lcode == 40) || (lcode == 64) || (lcode == 80));
+ if (s_and(lcode, sub(lcode, 1)) != 0)
+ {
+ L_tmp = Mpy_32_32(L_tmp, 1717986918l/*64.0/80.0 Q31*/);
+ }
+ exp_L_tmp = sub(exp_L_tmp, sub(14, norm_s(lcode)));
+
+ i = norm_l(L_tmp);
+ L_tmp = L_shl(L_tmp, i);
+ exp_L_tmp = sub(exp_L_tmp, i);
+
+ if (dotp != NULL)
+ {
+ *dotp = L_tmp;
+ move32();
+ }
+ if (dotp_e != NULL)
+ {
+ *dotp_e = exp_L_tmp;
+ move16();
+ }
+
+ L_tmp = ISqrt32norm(L_tmp, &exp_L_tmp);
+
+ return L_shl(L_tmp, sub(exp_L_tmp, 15)); /* 15Q16 */
+}
+
diff --git a/lib_com/get_gain.c b/lib_com/get_gain.c
new file mode 100644
index 0000000000000000000000000000000000000000..9db8199567f9a798b2ab5742134d02df68500ba9
--- /dev/null
+++ b/lib_com/get_gain.c
@@ -0,0 +1,97 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h"
+#include "prot_fx.h"
+#include "stl.h"
+#include "basop_util.h"
+
+Word32 get_gain( /* output: codebook gain (adaptive or fixed) Q16 */
+ Word16 x[], /* input : target signal */
+ Word16 y[], /* input : filtered codebook excitation */
+ Word16 n /* input : segment length */
+)
+{
+ Word32 tcorr, tener, Lgain;
+ Word16 exp_c, exp_e, exp, tmp;
+
+
+ tcorr = L_deposit_l(0);
+ tener = L_deposit_l(0);
+
+
+
+ /*----------------------------------------------------------------*
+ * Find gain based on inter-correlation product
+ *----------------------------------------------------------------*/
+
+ tcorr = Dot_product16HQ( 0, x, y, n, &exp_c );
+ tener = Dot_productSq16HQ( 0, y, n, &exp_e );
+
+ BASOP_Util_Divide_MantExp(round_fx(tcorr), exp_c, s_max(round_fx(tener),1), exp_e, &tmp,&exp);
+ Lgain = L_shl(L_deposit_l(tmp)/*Q15*/,add(1,exp))/*Q16*/;
+
+ return Lgain;
+}
+
+Word32 get_gain2( /* output: codebook gain (adaptive or fixed) Q16 */
+ Word16 x[], /* input : target signal */
+ Word16 y[], /* input : filtered codebook excitation */
+ Word16 n /* input : segment length */
+)
+{
+ Word32 tcorr, tener, Lgain;
+ Word16 m_corr, m_ener, negative, Q_corr, Q_ener;
+
+ negative = 0;
+ move16();
+
+ /*----------------------------------------------------------------*
+ * Find gain based on inter-correlation product
+ *----------------------------------------------------------------*/
+ tcorr = Dot_product16HQ(0, x, y, n, &Q_corr);
+ tener = Dot_productSq16HQ(0, y, n, &Q_ener);
+
+ tener = L_max(tener, 1);
+
+ if (tcorr <= 0)
+ {
+ negative = 1;
+ move16();
+ }
+ BASOP_SATURATE_WARNING_OFF /*tcorr max be negative maxvall - not critical*/
+ tcorr = L_abs(tcorr);
+ BASOP_SATURATE_WARNING_ON
+
+ m_corr = extract_h(tcorr);
+
+ m_ener = extract_h(tener);
+
+ IF (GT_16(m_corr, m_ener))
+ {
+ m_corr = shr(m_corr, 1);
+ Q_corr = add(Q_corr,1);
+ }
+ if (m_ener==0)
+ {
+ move16();
+ m_corr = 0x7FFF;
+ }
+ if (m_ener != 0)
+ {
+ m_corr = div_s(m_corr, m_ener);
+ }
+
+ Q_corr = sub(Q_corr,Q_ener);
+
+ Lgain = L_shl(L_deposit_l(m_corr), add(Q_corr, 1)); /* Lgain in Q16 */
+
+ if (negative != 0)
+ {
+ Lgain = L_negate(Lgain); /* Lgain in Q16 */
+ }
+
+
+ return Lgain;
+}
diff --git a/lib_com/gs_bitallocation_fx.c b/lib_com/gs_bitallocation_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..f82fb3f2440533834e20398ae7f3f10803382af8
--- /dev/null
+++ b/lib_com/gs_bitallocation_fx.c
@@ -0,0 +1,481 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "assert.h" /* Debug prototypes */
+#include "stl.h"
+
+/*==================================================================================*/
+/* FUNCTION : void bands_and_bit_alloc_fx(); */
+/*----------------------------------------------------------------------------------*/
+/* PURPOSE : AC mode (GSC) bands and bits allocation */
+/*----------------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) cor_strong_limit : HF correlation */
+/* _ (Word16) noise_lev : dwn scaling factor Q0 */
+/* _ (Word32) core_brate : core codec used Q0 */
+/* _ (Word16) Diff_len : Lenght of the difference signal Q0 */
+/* _ (Word16) bits_used : Number of bit used before frequency Q0 */
+/* _ (Word16) idx : Energy band 14 Q0 */
+/* _ (Word16*) exc_diff : Difference signal to quantize (Encoder only) */
+/* _ (Word16) coder_type : coding type Q0 */
+/* _ (Word16) bwidth : input signal bandwidth Q0 */
+/*----------------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16*) max_ener_band : Sorted order */
+/* _ (Word16*) nb_subbands : Number of subband allowed Q0 */
+/* _ (Word16*) concat_in : Concatened PVQ's input vector (Encoder Only) */
+/* _ (Word16*) pvq_len : Number of bin covered with the PVQ Q0 */
+/*----------------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ (Word16*) bit :Number of bit allowed for frequency quantization */
+/* _ (Word16*) Ener_per_bd_iQ : Quantized energy vector Q13 */
+/* _ (Word32*) bits_per_bands : Number of bit allowed per allowed subband Q18 */
+/*----------------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*==================================================================================*/
+void bands_and_bit_alloc_fx(
+ const Word16 cor_strong_limit, /* i : HF correlation */
+ const Word16 noise_lev, /* i : dwn scaling factor */
+ const Word32 core_brate, /* i : core bit rate */
+ const Word16 Diff_len, /* i : Lenght of the difference signal (before pure spectral)*/
+ const Word16 bits_used, /* i : Number of bit used before frequency Q */
+ Word16 *bit, /* i/o: Number of bit allowed for frequency quantization */
+ const Word16 *Ener_per_bd_iQ, /* i/o: Quantized energy vector */
+ Word16 *max_ener_band, /* o : Sorted order */
+ Word16 *out_bits_per_bands, /* i/o: Number of bit allowed per allowed subband Q3 */
+ Word16 *nb_subbands, /* o : Number of subband allowed */
+ const Word16 *exc_diff, /* i : Difference signal to quantize (encoder side only) */
+ Word16 *concat_in, /* o : Concatened PVQ's input vector (encoder side only) */
+ Word16 *pvq_len, /* o : Number of bin covered with the PVQ */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 bwidth, /* i : input signal bandwidth */
+ const Word16 GSC_noisy_speech
+)
+{
+
+ Word16 bandoffset, i, j, nb_bands_max, bit_new_bands, bit_tmp, st_band, nb_bands;
+ Word16 ener_vec[MBANDS_GN]; /*Q12 */
+ Word16 nb_tot_bands = 16;
+ Word16 bit_index, bit_index_mem, imax;
+ Word32 L_tmp;
+ Word32 sum_bit, bit_fracf;
+ Word16 etmp;
+ Word16 tmp;
+ Word16 Ener_per_bd_iQ_tmp[MBANDS_GN];
+ Word16 pos, band;
+ Word16 SWB_bit_budget;
+ Word32 bits_per_bands[MBANDS_GN];
+ Word16 w_sum_bit;
+
+ Copy( Ener_per_bd_iQ, Ener_per_bd_iQ_tmp, MBANDS_GN );
+
+ set32_fx( bits_per_bands, 0, MBANDS_GN );
+ set16_fx( out_bits_per_bands, 0, MBANDS_GN );
+
+ /* To adapt current energy band to PVQ freq band for sorting*/
+ ener_vec[0] = add(Ener_per_bd_iQ[0],Ener_per_bd_iQ[1]); /*Q12 */
+ Copy( Ener_per_bd_iQ_tmp+1, ener_vec, 15 ); /*Q12 */
+ ener_vec[15] = ener_vec[14];
+ move16();
+
+ /*------------------------------------------------------------------------
+ * Determination of the number of bits available to the frequency domain
+ * Allocation of a maximum number of band to be encoded
+ *-----------------------------------------------------------------------*/
+
+ nb_bands_max = nb_tot_bands;
+ move16();
+ bit_new_bands = 5;
+ move16();
+
+ bit_index = i_mult2(BRATE2IDX_fx(core_brate),17);
+ bit_index_mem = bit_index;
+ move16();
+
+ test();
+ test();
+ IF( (EQ_16(coder_type,AUDIO)||EQ_16(coder_type,INACTIVE))&&EQ_16(bwidth,NB))
+ {
+ IF(GE_32(core_brate,ACELP_9k60))
+ {
+ /* *bit = (short)(core_brate*(1.0f/50) + 0.5f) - bits_used - 25; */
+ L_tmp = Mult_32_16(core_brate,20971);
+ tmp = extract_l(L_shr_r(L_tmp,5));
+ *bit = sub(sub(tmp,bits_used), 25);
+ move16();
+ }
+ ELSE
+ {
+ L_tmp = Mult_32_16(core_brate,20971);
+ tmp = extract_l(L_shr_r(L_tmp,5));
+ *bit = sub(sub(tmp,bits_used), 21);
+ move16();
+ }
+ nb_tot_bands = 10;
+ move16();
+ }
+ ELSE
+ {
+ /* *bit = (short)(core_brate*(1.0f/50) + 0.5f) - bits_used - GSC_freq_bits[bit_index]; */
+
+ L_tmp = Mult_32_16(core_brate,20971);
+ tmp = extract_l(L_shr_r(L_tmp,5));
+ *bit = sub(sub(tmp,bits_used),GSC_freq_bits[bit_index]);
+ move16();
+ }
+
+ IF( EQ_16(GSC_noisy_speech,1))
+ {
+ SWB_bit_budget = *bit;
+ move16();
+ nb_bands = 5;
+ move16();
+ st_band = nb_bands;
+ move16();
+
+ set32_fx( bits_per_bands, 0, MBANDS_GN );
+ /*bit_fracf = (1.0f/nb_bands)*(SWB_bit_budget); */
+ bit_fracf = L_mult(div_s(1,nb_bands),shl(SWB_bit_budget,2)); /* Q18 */
+
+ nb_tot_bands = sub(nb_bands_max,6);
+ nb_tot_bands = s_min(nb_tot_bands, 16);
+
+ FOR(j = 0; j < 2; j++)
+ {
+ i = j;
+ move16();
+ max_ener_band[j] = i;
+ move16();
+ ener_vec[i] = 0;
+ move16();
+ }
+
+ FOR(; j < nb_bands; j++)
+ {
+ i = maximum_fx(ener_vec, nb_tot_bands, &etmp);
+ max_ener_band[j] = i;
+ move16();
+ ener_vec[i] = 0;
+ move16();
+ }
+
+ set32_fx(bits_per_bands, bit_fracf, nb_bands);
+ }
+ ELSE
+ {
+ bit_index++;
+ bit_tmp = sub(*bit,GSC_freq_bits[bit_index]);
+ bit_index++;
+ nb_bands_max = add(nb_bands_max,GSC_freq_bits[bit_index]);
+ bit_index++;
+
+ *pvq_len = 112;
+ move16();
+ st_band = 7;
+ move16();
+
+ IF( LE_32(core_brate,ACELP_9k60))
+ {
+ *pvq_len = 80;
+ move16();
+ st_band = 5;
+ move16();
+
+ IF( Diff_len == 0 )
+ {
+ nb_bands_max = add(nb_bands_max,2);
+ bit_tmp = sub(bit_tmp,13);
+ }
+ }
+
+ ELSE IF( Diff_len == 0 )
+ {
+ nb_bands_max = add(nb_bands_max,2);
+ bit_tmp = sub(bit_tmp,17);
+ }
+
+ nb_bands = shr(*pvq_len,4);
+
+ /*------------------------------------------------------------------------
+ * Ajustement of the maximum number of bands in function of the
+ * dynamics of the spectrum (more or less speech like)
+ *-----------------------------------------------------------------------*/
+ test();
+ test();
+ test();
+ test();
+ IF( EQ_16(coder_type,INACTIVE)||GE_16(noise_lev,NOISE_LEVEL_SP3))
+ {
+ /* Probably classification error -> concentrate bits on LF */
+ nb_bands_max = nb_bands;
+ move16();
+ if( GE_32(core_brate,ACELP_8k00))
+ {
+ nb_bands_max = add(nb_bands,1);
+ }
+ }
+ ELSE IF( GE_16(noise_lev,NOISE_LEVEL_SP2)||
+ (LE_32(core_brate,ACELP_13k20) && GE_32(core_brate,ACELP_9k60) && cor_strong_limit == 0) ) /* Very low dynamic, tend to speech, do not try to code HF at all */
+ {
+ nb_bands_max = sub(nb_bands_max,2);
+ }
+ ELSE if( GE_16(noise_lev,NOISE_LEVEL_SP1)) /* Very low dynamic, tend to speech, code less HF */
+ {
+ nb_bands_max = sub(nb_bands_max,1);
+ }
+
+ test();
+ if( EQ_16(bwidth,NB)&>_16(nb_bands_max,10))
+ {
+ nb_bands_max = 10;
+ move16();
+ }
+
+ /*------------------------------------------------------------------------
+ * Find extra number of band to code according to bit rate availables
+ *-----------------------------------------------------------------------*/
+ WHILE ( GE_16(bit_tmp,bit_new_bands)&&LE_16(nb_bands,sub(nb_bands_max,1)))
+ {
+ bit_tmp = sub(bit_tmp,bit_new_bands);
+ nb_bands = add(nb_bands,1);
+ }
+
+ /*------------------------------------------------------------------------
+ * Fractional bits to distribute on the first x bands
+ *-----------------------------------------------------------------------*/
+
+ bit_fracf = L_mult(div_s(1,st_band),shl(bit_tmp,2)); /* Q18 */
+
+ /*------------------------------------------------------------------------
+ * Complete the bit allocation per frequency band
+ *-----------------------------------------------------------------------*/
+ imax = 5;
+ move16();
+
+ if( GT_32(core_brate,ACELP_9k60))
+ {
+ imax = 7;
+ move16();
+ }
+ FOR(i = 0; i < imax; i++)
+ {
+ bits_per_bands[i] = L_add(GSC_freq_bits_fx[bit_index],bit_fracf);
+ move32();/* Q18 */
+ bit_index = add(bit_index,1);
+ }
+
+ IF( Diff_len == 0 )
+ {
+ bit_index = add(bit_index_mem,10);
+ FOR( i = 0; i < 7; i++ )
+ {
+ bits_per_bands[i] = L_add(bits_per_bands[i],GSC_freq_bits_fx[bit_index]);
+ move32();/*chk Q18 */
+ bit_index = add(bit_index,1);
+ }
+ }
+
+ /*--------------------------------------------------------------------------
+ * Complete the bit allocation per frequency band for 16kHz high brate mode
+ *--------------------------------------------------------------------------*/
+
+ FOR( j = st_band; j < nb_bands; j++ )
+ {
+ bits_per_bands[j] = L_shl(bit_new_bands,18);
+ move32(); /*chk Q18 */
+ }
+
+ /*--------------------------------------------------------------------------
+ * Compute a maximum band (band offset) for the search on maximal energy
+ * This is function of the spectral dynamic and the bitrate
+ *--------------------------------------------------------------------------*/
+
+ bandoffset = sub(nb_tot_bands,add(nb_bands,2));
+
+ test();
+ test();
+ test();
+ test();
+ test();
+ IF( LE_16(noise_lev,NOISE_LEVEL_SP1a))
+ {
+ bandoffset = sub(bandoffset,1);
+ }
+ ELSE if ( (LE_32(core_brate,ACELP_13k20)&&(EQ_16(coder_type,INACTIVE)||GE_16(noise_lev,NOISE_LEVEL_SP3)))||
+ (LE_32(core_brate,ACELP_13k20) && GE_32(core_brate,ACELP_9k60) && cor_strong_limit == 0) )
+ {
+ bandoffset = add(bandoffset,1);
+ }
+
+ bandoffset = s_max(bandoffset ,0);
+
+ /*--------------------------------------------------------------------------
+ * Initiazed sorted vector
+ * For the first x bands to be included in th final sorted vector
+ * Sort the remaining bands in decrease energy order
+ *--------------------------------------------------------------------------*/
+ FOR(j = 0; j < nb_tot_bands; j++)
+ {
+ max_ener_band[j] = -10;
+ move16();
+ }
+ FOR(j = 0; j < st_band; j++)
+ {
+ max_ener_band[j] = j;
+ move16();
+ ener_vec[j] = -10;
+ move16();
+ }
+ pos = st_band;
+ move16();
+ FOR(; j < nb_bands; j++)
+ {
+ i = maximum_fx(ener_vec, sub(nb_tot_bands,bandoffset), &etmp);
+ pos = s_max(pos,i);
+ max_ener_band[j] = i;
+ move16();
+ ener_vec[i] = -10;
+ move16();
+ }
+
+ /* re-allocate bits to the frames such that the highest band with allocated bits is higher than the threshold */
+ test();
+ test();
+ test();
+ IF( GT_16(sub(nb_tot_bands, bandoffset),nb_bands)&&(GT_16(pos,7)&&EQ_32(core_brate,ACELP_8k00))&&EQ_16(bwidth,WB))
+ {
+ band = sub(nb_tot_bands, add(bandoffset,nb_bands));
+ FOR(j=0; j 0; bit_tmp--)
+ {
+ bits_per_bands[j] = L_sub(bits_per_bands[j],262144); /*Q18 */
+ j = add(j,1);
+ if ( EQ_16(j,sub(st_band, i)))
+ {
+ j = 0;
+ move16();
+ }
+ test();
+ if( j == 0 && LT_16(i,sub(st_band, 1)))
+ {
+ i = add(i,1);
+ }
+ }
+ }
+ }
+ /*--------------------------------------------------------------------------
+ * Bit sum verification for GSC inactive at very high rate
+ * The maximum number of bits per band of length 16 is 112
+ * Redistribute the overage bits if needed
+ *--------------------------------------------------------------------------*/
+ sum_bit = 0;
+ move16();
+ j = 0;
+ move16();
+ FOR( i = 0; i < nb_bands; i++ )
+ {
+ L_tmp = Mult_32_16(sum_bit,10923);
+
+ IF( GT_32(bits_per_bands[i],29360128)) /* 112 in Q18 */
+ {
+ sum_bit = L_add(sum_bit,L_sub(bits_per_bands[i],29360128)); /* Q18 */
+ bits_per_bands[i] = 29360128;
+ move32();
+ j = add(i,1);
+ }
+ ELSE if( GT_32(L_add(bits_per_bands[i],L_tmp),29360128 )) /* Q18 */
+ {
+ j = add(i,1);
+ }
+ }
+
+ IF( sum_bit != 0 )
+ {
+ tmp = sub(nb_bands,j);
+ sum_bit = Mult_32_16(sum_bit,div_s(1,tmp)); /* Q18 */
+ FOR( i = j; i < nb_bands; i++ )
+ {
+ bits_per_bands[i] = L_add(bits_per_bands[i],sum_bit);
+ move32();/* Q18 */
+ }
+ }
+ /*--------------------------------------------------------------------------
+ * second step of bit sum verification, normally sum_bit == *bit
+ *--------------------------------------------------------------------------*/
+ w_sum_bit = 0;
+ move16();
+ FOR( i = 0; i < nb_bands; i++ )
+ {
+ out_bits_per_bands[i] = shl(extract_l(L_shr(bits_per_bands[i],18)),3);
+ move16();
+ w_sum_bit = add(w_sum_bit,out_bits_per_bands[i]); /* Q3 */
+ }
+ tmp = shl(*bit,3);
+
+ IF( GT_16(tmp,w_sum_bit))
+ {
+ i = sub(nb_bands,1);
+ move16();
+ FOR( ; tmp > w_sum_bit; w_sum_bit += (1<<3) )
+ {
+ out_bits_per_bands[i] = add(out_bits_per_bands[i],1<<3);
+ move16();
+ i = sub(i, 1);
+ if(i==0)
+ {
+ i = sub(nb_bands,1);
+ }
+ }
+ }
+ /*--------------------------------------------------------------------------
+ * Recompute the real number/length of frequency bands to encode
+ *--------------------------------------------------------------------------*/
+ *nb_subbands = nb_bands;
+ move16();
+ *pvq_len = shl(*nb_subbands,4);
+
+ /*--------------------------------------------------------------------------
+ * Concatenate bands (encoder only)
+ *--------------------------------------------------------------------------*/
+ IF( exc_diff != NULL )
+ {
+ FOR( j = 0; j < nb_bands; j++ )
+ {
+ Copy( exc_diff + shl(max_ener_band[j],4), concat_in+shl(j,4), 16 );
+ }
+ }
+
+ return;
+}
diff --git a/lib_com/gs_gains_fx.c b/lib_com/gs_gains_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..438c75016d15f61410dedeefef9e6db5f83274df
--- /dev/null
+++ b/lib_com/gs_gains_fx.c
@@ -0,0 +1,673 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+
+
+/*-------------------------------------------------------------------*
+ * Local constants
+ *-------------------------------------------------------------------*/
+
+static Word16 VDQ_vec_fx( Word16 *Qvec_out_fx, const Word16 *mean_dic_fx, const Word16 *dic_fx,
+ const Word16 index_fx, const Word16 vec_en_fx );
+
+/*========================================================================*/
+/* FUNCTION : void Comp_and_apply_gain_enc_fx */
+/*------------------------------------------------------------------------*/
+/* PURPOSE : Compute and apply the quantized per band gain */
+/*------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16[]) Ener_per_bd_iQ : Target ener per band Q12 */
+/*------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ (Word16[]) exc_diffQ : Quantized excitation Qexc */
+/* _ (Word16[]) Ener_per_bd_yQ : Ener per band for norm vectori->Q12/o->Q2*/
+/*------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ None */
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*========================================================================*/
+void Comp_and_apply_gain_fx(
+ Word16 exc_diffQ[], /* i/o: Quantized excitation */
+ Word16 Ener_per_bd_iQ[], /* i : Target ener per band Q13 */
+ Word16 Ener_per_bd_yQ[], /* i/o : Ener per band for norm vector i->Q13/o->Q13 */
+ Word16 Mbands_gn, /* i : number of bands */
+ const Word16 ReUseGain, /* i : Reuse the gain in Ener_per_bd_yQ */
+ Word16 Qexc_diff,
+ Word16 Q_exc
+)
+{
+ Word16 i, i_band;
+ Word16 StartBin, NB_Qbins;
+ Word16 y_gain;
+ Word16 L16, frac, exp1, tmp_exp;
+ Word32 L32;
+
+ /* Recreate excitation for local synthesis and decoder */
+ StartBin = 0;
+ move16();
+ NB_Qbins = 0;
+ move16();
+
+ tmp_exp = add(14,sub(Q_exc,Qexc_diff)); /* In case of reuse, it can be computed outside the loop*/
+ FOR( i_band = 0; i_band < Mbands_gn; i_band++ )
+ {
+ StartBin = add(StartBin, NB_Qbins);
+ NB_Qbins = mfreq_bindiv_loc[i_band];
+ move16();
+ IF( EQ_16(ReUseGain,1))
+ {
+ y_gain = Ener_per_bd_yQ[i_band];
+ move16();
+
+ FOR(i = StartBin ; i < NB_Qbins + StartBin ; i++)
+ {
+ L32 = L_shl(L_mult(exc_diffQ[i], y_gain),tmp_exp); /*Q_exc+16 */
+ exc_diffQ[i] = round_fx(L32);/*Q_exc */
+ }
+ }
+ ELSE
+ {
+ /*-----------------------------------------------------------------*
+ * y_gain = pow(10.0, (Ener_per_bd_iQ[i_band]-Ener_per_bd_yQ[i_band]))
+ * = pow(2, 3.321928*(Ener_per_bd_iQ[i_band]-Ener_per_bd_yQ[i_band]))
+ *-----------------------------------------------------------------*/
+ L16 = sub(Ener_per_bd_iQ[i_band], Ener_per_bd_yQ[i_band]);/*Q12 */
+ L32 = L_mult(L16, 27213); /* 3.321928 in Q13 -> Q26 */
+ L32 = L_shr(L32, 10); /* From Q26 to Q16 */
+ frac = L_Extract_lc(L32, &exp1); /* Extract exponent of gcode0 */
+ y_gain = extract_l(Pow2(14, frac));/* Put 14 as exponent so that */
+ /* output of Pow2() will be: */
+ /* 16384 < Pow2() <= 32767 */
+ Ener_per_bd_yQ[i_band] = shl(y_gain, sub(exp1, 13));
+ move16();/*Q1 */
+ tmp_exp = add(add(exp1,1),sub(Q_exc,Qexc_diff));
+
+ FOR(i = StartBin ; i < NB_Qbins + StartBin ; i++)
+ {
+ L32 = L_mult(exc_diffQ[i], y_gain); /*Qexc_diff+15 */
+ exc_diffQ[i] = round_fx(L_shl(L32,tmp_exp)); /*Q_exc */
+ }
+ }
+ }
+
+ return;
+}
+
+
+/*========================================================================*/
+/* FUNCTION : Ener_per_band_comp_fx() */
+/*------------------------------------------------------------------------*/
+/* PURPOSE : Compute the energy per band in log domain for quantization */
+/* purposes. */
+/* Loops are decomposed to accomodate the PVQ quantization */
+/*------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16*) edct_table_128_fx : edct table Q15 */
+/* _ (Word16*) Q_exc_diff : input format of exc_diff */
+/*------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/*------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16[]) y_gain4 : Energy per band to quantize Q12 */
+/* _ (Word32*) etmp14 : Energy band 14 Q_exc_diff*2+1 */
+/* _ (Word32*) etmp15 : Energy band 15 Q_exc_diff*2+1 */
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*========================================================================*/
+static Word16 Comp_band_log_ener( /* o : Band gain Q12 */
+ const Word16 *pt_fx, /* i : Dct input Q_sc */
+ const Word16 Len, /* i : Lenght en energy accumulation */
+ const Word16 Q_sc, /* i : scaling of input */
+ const Word16 E_sc /* i : Additional scaling factor for energy */
+)
+{
+ Word32 L_tmp;
+ Word16 e_tmp, f_tmp, tmp16, ener_exp;
+
+ /*for(i = 0; i < 8; i++){etmp += (*pt * *pt);pt++;}*/
+ L_tmp = Calc_Energy_Autoscaled(pt_fx, Q_sc, Len, &ener_exp);
+
+ /*y_gain4[j] = (float)log10(sqrt(etmp< Q12 */
+ }
+ ELSE IF (LE_32(core_brate,ACELP_8k00))
+ {
+ Gain_off = 27034;
+ move16(); /* 6.6f -> Q12 */
+ }
+ ELSE IF (LE_32(core_brate,ACELP_9k60))
+ {
+ Gain_off = 19661;
+ move16(); /*4.8f-> Q12 */
+ }
+ ELSE IF (LE_32(core_brate,ACELP_11k60))
+ {
+ Gain_off = 14336;
+ move16(); /* 3.5f -> Q12 */
+ }
+ ELSE IF (LE_32(core_brate,ACELP_13k20))
+ {
+ Gain_off = 12288;
+ move16(); /* 3.0f -> Q12 dB */
+ }
+
+ /*mimic ACELP decay of energy for low rates*/
+ FOR( i = 0; i < MBANDS_GN; i++ )
+ {
+ old_y_gain[i] = y_gain_tmp[i];
+ move16();
+ /*y_gainQ[i] = y_gain_tmp[i]+mean_4g[0]-(i*(Gain_off/20.f)/((float) Mbands_gn));*/
+ y_gainQ[i] = add(y_gain_tmp[i], sub(mean_g, i_mult2(i, mult_r(Gain_off, 102))));
+ move16();
+ }
+ }
+
+ return;
+}
+/*==========================================================================*/
+/* FUNCTION : Word16 gsc_gaindec_fx () */
+/*--------------------------------------------------------------------------*/
+/* PURPOSE : Generic signal frequency band decoding and application */
+/*--------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) pvq_bits_fx : core used Q0 */
+/* _ (Word16) coder_type_fx : coding type Q0 */
+/* _ (Word16) core_fx : core used Q0 */
+/* _ (Word16) bwidth_fx : input signal bandwidth Q0 */
+/*--------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16[]) y_gainQ_fx : quantized gain per band */
+/*--------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ (Word16[]) old_y_gain_fx : AR gain quantizer for low rate */
+/*--------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ (Word16) : average frequency gain */
+/*==========================================================================*/
+
+Word16 gsc_gaindec_fx( /* o : average frequency gain */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 y_gainQ_fx[], /* o : quantized gain per band */
+ const Word32 core_brate_fx, /* i : core used */
+ Word16 old_y_gain_fx[], /* i/o: AR gain quantizer for low rate */
+ const Word16 coder_type_fx, /* i : coding type */
+ const Word16 bwidth_fx /* i : input signal bandwidth */
+)
+{
+ Word16 idx_g_fx, i;
+ Word16 mean_4g_fx;
+ Word16 y_gain_tmp3_fx[MBANDS_GN];
+
+ test();
+ test();
+ IF( (EQ_16(coder_type_fx,AUDIO)||EQ_16(coder_type_fx,INACTIVE))&&EQ_16(bwidth_fx,NB))
+ {
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 6 );
+ VDQ_vec_fx(&mean_4g_fx, Gain_meanNB_fx, Gain_mean_dicNB_fx, idx_g_fx, 1 );
+
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 6 );
+ move16();
+ VDQ_vec_fx(y_gainQ_fx, Mean_dic_NB_fx, Gain_dic1_NB_fx, idx_g_fx, 3 );
+
+ IF(LT_32(core_brate_fx,ACELP_9k60))
+ {
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 5 );
+ VDQ_vec_fx(y_gainQ_fx+3, Mean_dic_NB_fx+3, Gain_dic2_NB_fx, idx_g_fx, 3 );
+
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 4 );
+ VDQ_vec_fx(y_gainQ_fx+6, Mean_dic_NB_fx+6, Gain_dic3_NB_fx, idx_g_fx, 4 );
+ }
+ ELSE
+ {
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 6 );
+ VDQ_vec_fx(y_gainQ_fx+3, Mean_dic_NB_fx+3, Gain_dic2_NBHR_fx, idx_g_fx, 3 );
+
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 7 );
+ VDQ_vec_fx(y_gainQ_fx+6, Mean_dic_NB_fx+6, Gain_dic3_NBHR_fx, idx_g_fx, 4 );
+ }
+ test();
+ IF( LE_32(core_brate_fx,ACELP_9k60)&&EQ_16(coder_type_fx,INACTIVE))
+ {
+ /* Some energy is needed in high band for stat_noise_uv_enc
+ to be functional in inactive speech */
+ y_gainQ_fx[10] = mean_fx(y_gainQ_fx+6, 3);
+ move16();
+ y_gainQ_fx[11] = mean_fx(y_gainQ_fx+7, 3);
+ move16();
+ y_gainQ_fx[12] = mean_fx(y_gainQ_fx+8, 3);
+ move16();
+ y_gainQ_fx[13] = mean_fx(y_gainQ_fx+9, 3);
+ move16();
+ y_gainQ_fx[14] = mean_fx(y_gainQ_fx+10, 3);
+ move16();
+ y_gainQ_fx[15] = mean_fx(y_gainQ_fx+11, 3);
+ move16();
+ }
+ ELSE
+ {
+ set16_fx( y_gainQ_fx + 10, 0, MBANDS_GN - 10 );
+ }
+ }
+ ELSE
+ {
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 6 );
+
+ VDQ_vec_fx(&mean_4g_fx, mean_m_fx, mean_gain_dic_fx, idx_g_fx, 1 );
+
+ IF(LE_32(core_brate_fx,ACELP_9k60))
+ {
+ /*--------------------------------------------------------------------------------------*
+ * UQ of the first 8 bands and half of the last 8 bands
+ *--------------------------------------------------------------------------------------*/
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 5 );
+ VDQ_vec_fx(y_gainQ_fx, YGain_mean_LR_fx, YGain_dic1_LR_fx, idx_g_fx, 3 );
+
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 5 );
+ VDQ_vec_fx(y_gainQ_fx+3, YGain_mean_LR_fx+3, YGain_dic2_LR_fx, idx_g_fx, 4 );
+
+ /*----------------------------------------------------------------------*
+ * Interpolation of the last 4 Q bands to create bands 8-16
+ * And scaling
+ *----------------------------------------------------------------------*/
+
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 5 );
+
+ VDQ_vec_fx(y_gainQ_fx+7, YGain_mean_LR_fx+7, YGain_dic3_LR_fx, idx_g_fx, 5 );
+
+ Copy(y_gainQ_fx+8, y_gain_tmp3_fx, 4);
+ set16_fx(y_gainQ_fx+12, 0, 4);
+
+ fft_rel_fx(y_gainQ_fx+8, 4, 2);
+
+ y_gainQ_fx[15] = y_gainQ_fx[11];
+ move16();
+ y_gainQ_fx[11] = 0;
+ move16();
+ ifft_rel_fx(y_gainQ_fx+8, 8, 3);
+ FOR(i = 8; i < 16; i++)
+ {
+ /*y_gainQ_fx[i] *= 1.41f;*/
+ y_gainQ_fx[i] = round_fx(L_shl(L_mult(y_gainQ_fx[i] , 23101),1));/*Q12 */
+ }
+ /*----------------------------------------------------------------------*
+ * Copy the true Q values in the specific bands
+ *----------------------------------------------------------------------*/
+ y_gainQ_fx[8] = y_gain_tmp3_fx[0];
+ move16();
+ y_gainQ_fx[10]= y_gain_tmp3_fx[1];
+ move16();
+ y_gainQ_fx[12]= y_gain_tmp3_fx[2];
+ move16();
+ y_gainQ_fx[14]= y_gain_tmp3_fx[3];
+ move16();
+ }
+ ELSE
+ {
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 6 );
+ VDQ_vec_fx(y_gainQ_fx, YG_mean16_fx, YG_dicMR_1_fx, idx_g_fx, 4 );
+
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 5 );
+ VDQ_vec_fx(y_gainQ_fx+4, YG_mean16_fx+4, YG_dicMR_2_fx, idx_g_fx, 4 );
+
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 5 );
+ VDQ_vec_fx(y_gainQ_fx+8, YG_mean16_fx+8, YG_dicMR_3_fx, idx_g_fx, 4 );
+
+ idx_g_fx = (Word16) get_next_indice_fx( st_fx, 4 );
+ VDQ_vec_fx(y_gainQ_fx+12, YG_mean16_fx+12, YG_dicMR_4_fx, idx_g_fx, 4 );
+ }
+ }
+
+ /* Gain adjustment to fit ACELP generic inactive coding gain at low rate */
+ GSC_gain_adj(coder_type_fx, core_brate_fx, mean_4g_fx, old_y_gain_fx, y_gainQ_fx, y_gainQ_fx);
+
+ return mean_4g_fx;
+
+}
+
+/*-------------------------------------------------------------------*
+ * gsc_gainQ()
+ *
+ * Quantization of the energy per band
+ *-------------------------------------------------------------------*/
+Word16 gsc_gainQ_fx( /*Q12*/
+ Encoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 y_gain4[], /* i : Energy per band Q12 */
+ Word16 y_gainQ[], /* o : quantized energy per band Q12 */
+ const Word32 core_brate, /* i : Core rate */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 bwidth /* i : input signal bandwidth */
+)
+{
+ Word16 y_gain_tmp[MBANDS_GN], y_gain_tmp2[MBANDS_GN];
+ Word16 i, idx_g = 0;
+ Word16 mean_4g[1] = {0}, tmp16,tmp1, tmp2;
+ Word16 Mbands_gn = MBANDS_GN;
+ Word16 y_gain_tmp3[MBANDS_GN];
+ Word16 cnt;
+ Word32 L_tmp;
+
+ mean_4g[0] = 0;
+
+ test();
+ test();
+ IF( (EQ_16(coder_type,AUDIO)||EQ_16(coder_type,INACTIVE))&&EQ_16(bwidth,NB))
+ {
+
+ /*ftmp1 = mean(y_gain4, 10)-0.6f;*/
+ L_tmp = L_deposit_l(0);
+ FOR(cnt = 0 ; cnt < 10 ; cnt++)
+ {
+ L_tmp = L_mac(L_tmp,y_gain4[cnt], 3277);
+ }
+ tmp16 = sub(round_fx(L_tmp), 4915);
+
+ FOR(i = 0; i < Mbands_gn; i++)
+ {
+ y_gain_tmp2[i] = y_gain4[i];
+ move16();
+ /*if(y_gain4[i] < ftmp1-0.6f)*/
+ y_gain_tmp2[i] = s_max(y_gain_tmp2[i], tmp16);
+ move16();
+ }
+
+ L_tmp = L_deposit_l(0);
+ FOR(i = 0; i < 10; i++)
+ {
+ L_tmp = L_mac(L_tmp,y_gain_tmp2[i], 3277);
+ }
+
+ /* Quantized mean gain without clipping */
+ mean_4g[0] = round_fx(L_tmp);
+ idx_g = vquant_fx(mean_4g, Gain_meanNB_fx, mean_4g, Gain_mean_dicNB_fx, 1, 64);
+ push_indice_fx( st_fx, IND_MEAN_GAIN2, idx_g, 6 );
+
+ FOR(i = 0; i < Mbands_gn; i++)
+ {
+ y_gain_tmp[i] = sub(y_gain_tmp2[i],mean_4g[0]);
+ move16();
+ }
+ /*if(y_gain_tmp[9] < -0.3f){y_gain_tmp[9] = -0.3f;}*/
+ y_gain_tmp[9] = s_max(y_gain_tmp[9], -1229);
+ move16();
+ set16_fx(y_gain_tmp+10, 0, MBANDS_GN-10);
+ idx_g = vquant_fx(y_gain_tmp, Mean_dic_NB_fx, y_gain_tmp, Gain_dic1_NB_fx, 3, 64);
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 6 );
+
+ IF(LT_32(core_brate,ACELP_9k60))
+ {
+ idx_g = vquant_fx(y_gain_tmp+3, Mean_dic_NB_fx+3, y_gain_tmp+3, Gain_dic2_NB_fx, 3, 32);
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 5 );
+ idx_g = vquant_fx(y_gain_tmp+6, Mean_dic_NB_fx+6, y_gain_tmp+6, Gain_dic3_NB_fx, 4, 16);
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 4 );
+ }
+ ELSE
+ {
+ idx_g = vquant_fx(y_gain_tmp+3, Mean_dic_NB_fx+3, y_gain_tmp+3, Gain_dic2_NBHR_fx, 3, 64);
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 6 );
+ idx_g = vquant_fx(y_gain_tmp+6, Mean_dic_NB_fx+6, y_gain_tmp+6, Gain_dic3_NBHR_fx, 4, 128);
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 7 );
+ }/*add end */
+
+ test();
+ IF( LE_32(core_brate,ACELP_9k60)&&EQ_16(coder_type,INACTIVE))
+ {
+ /* Some energy is needed in high band for stat_noise_uv_enc
+ to be functional in inactive speech */
+ y_gain_tmp[10] = round_fx(L_mac(L_mac(L_mult(y_gain_tmp[6],8192),y_gain_tmp[7],8192),y_gain_tmp[8],8192));
+ y_gain_tmp[11] = round_fx(L_mac(L_mac(L_mult(y_gain_tmp[7],8192),y_gain_tmp[8],8192),y_gain_tmp[9],8192));
+
+ y_gain_tmp[12] = round_fx(L_mac(L_mac(L_mult(y_gain_tmp[8],8192),y_gain_tmp[9],8192),y_gain_tmp[10],8192));
+ y_gain_tmp[13] = round_fx(L_mac(L_mac(L_mult(y_gain_tmp[9],8192),y_gain_tmp[10],8192),y_gain_tmp[11],8192));
+ y_gain_tmp[14] = round_fx(L_mac(L_mac(L_mult(y_gain_tmp[10],8192),y_gain_tmp[11],8192),y_gain_tmp[12],8192));
+ y_gain_tmp[15] = round_fx(L_mac(L_mac(L_mult(y_gain_tmp[11],8192),y_gain_tmp[12],8192),y_gain_tmp[13],8192));
+ }
+ ELSE
+ {
+ set16_fx( y_gain_tmp + 10, 0, MBANDS_GN - 10 );
+ }
+ }
+ ELSE
+ {
+ /*ftmp1 = mean(y_gain4, 16);*/
+
+ L_tmp =0;
+ FOR(cnt = 0 ; cnt < 16 ; cnt++)
+ {
+ L_tmp = L_mac(L_tmp,y_gain4[cnt], 2048);
+ }
+ tmp16 = round_fx(L_tmp);
+
+ tmp1 = sub(tmp16,4915);
+ tmp2 = add(tmp16,4915);
+ L_tmp =0;
+ FOR(i = 0; i < 16; i++)
+ {
+ y_gain_tmp2[i] = y_gain4[i];
+ move16();
+ /*if(y_gain4[i] < ftmp1-0.6f)*/
+ y_gain_tmp2[i] = s_max(y_gain_tmp2[i], tmp1);
+ move16();
+ /*else if(y_gain4[i] > ftmp1+0.6f)*/
+ y_gain_tmp2[i] = s_min(y_gain_tmp2[i], tmp2);
+ move16();
+ L_tmp = L_mac(L_tmp,y_gain_tmp2[i], 2048);
+ }
+ FOR(; i < Mbands_gn; i++)
+ {
+ y_gain_tmp2[i] = y_gain4[i];
+ /*if(y_gain4[i] < ftmp1-0.6f)*/
+ y_gain_tmp2[i] = s_max(y_gain_tmp2[i], tmp1); /* Just the last move is needed, because s_max and s_min could be done in 1 line*/
+ /*else if(y_gain4[i] > ftmp1+0.6f)*/
+ y_gain_tmp2[i] = s_min(y_gain_tmp2[i], tmp2);
+ move16();
+ }
+
+ /* Quantized mean gain without clipping */
+ mean_4g[0] = round_fx(L_tmp);
+
+
+ /*idx_g = (short)vquant(mean_4g, mean_m, mean_4g, mean_gain_dic, 1, 64);*/
+ idx_g = vquant_fx(mean_4g, mean_m_fx, mean_4g, mean_gain_dic_fx, 1, 64);
+ push_indice_fx( st_fx, IND_MEAN_GAIN2, idx_g, 6 );
+
+ FOR(i = 0; i < Mbands_gn; i++)
+ {
+ y_gain_tmp[i] = sub(y_gain_tmp2[i],mean_4g[0]);
+ move16();
+ }
+
+ IF( LT_32(core_brate,ACELP_9k60))
+ {
+ /*mvr2r(y_gain_tmp, y_gain_tmp2, 8); */
+ Copy(y_gain_tmp, y_gain_tmp2, 8);
+
+ y_gain_tmp2[8] = y_gain_tmp[8];
+ move16();
+ y_gain_tmp2[9] = y_gain_tmp[10];
+ move16();
+ y_gain_tmp2[10] =y_gain_tmp[12];
+ move16();
+ y_gain_tmp2[11] =y_gain_tmp[14];
+ move16();
+
+ idx_g = 0;
+
+ /*idx_g = (short)vquant(y_gain_tmp2, YGain_mean_LR, y_gain_tmp2, YGain_dic1_LR, 3, 32);*/
+ idx_g = vquant_fx(y_gain_tmp2, YGain_mean_LR_fx, y_gain_tmp2, YGain_dic1_LR_fx, 3, 32 );
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 5 );
+ /*idx_g = (short)vquant(y_gain_tmp2+3, YGain_mean_LR+3, y_gain_tmp2+3, YGain_dic2_LR, 4, 32);*/
+ idx_g = vquant_fx(y_gain_tmp2+3, YGain_mean_LR_fx+3, y_gain_tmp2+3, YGain_dic2_LR_fx, 4, 32 );
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 5 );
+ /*idx_g = (short)vquant(y_gain_tmp2+7, YGain_mean_LR+7, y_gain_tmp2+7, YGain_dic3_LR, 5, 32);*/
+ idx_g = vquant_fx(y_gain_tmp2+7, YGain_mean_LR_fx+7, y_gain_tmp2+7, YGain_dic3_LR_fx, 5, 32);
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 5 );
+ /*set_f(y_gain_tmp2+12, 0, MBANDS_GN-12);*/
+ set16_fx(y_gain_tmp2+12, 0, MBANDS_GN-12);
+
+ /* Update to quantized vector */
+ Copy(y_gain_tmp2, y_gain_tmp, 8);
+
+ Copy(y_gain_tmp2+8, y_gain_tmp3, 4);
+ set16_fx(y_gain_tmp+8, 0,8);
+ fft_rel_fx(y_gain_tmp2+8, 4, 2);
+
+ Copy(y_gain_tmp2+8, y_gain_tmp+8, 3);
+ y_gain_tmp[15] = y_gain_tmp2[11];
+ ifft_rel_fx(y_gain_tmp+8, 8, 3);
+
+ FOR(i = 8; i < 16; i++)
+ {
+ /*y_gain_tmp[i] *= 1.41f;*/
+ y_gain_tmp[i] = shl( mult_r(y_gain_tmp[i] , 23101),1) ;
+ move16();
+ }
+
+ y_gain_tmp[8] = y_gain_tmp3[0];
+ move16();
+ y_gain_tmp[10]= y_gain_tmp3[1];
+ move16();
+ y_gain_tmp[12]= y_gain_tmp3[2];
+ move16();
+ y_gain_tmp[14]= y_gain_tmp3[3];
+ move16();
+ }
+ ELSE
+ {
+ idx_g = vquant_fx(y_gain_tmp, YG_mean16_fx, y_gain_tmp, YG_dicMR_1_fx, 4, 64);
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 6 );
+ idx_g = vquant_fx(y_gain_tmp+4, YG_mean16_fx+4, y_gain_tmp+4, YG_dicMR_2_fx, 4, 32);
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 5 );
+ idx_g = vquant_fx(y_gain_tmp+8, YG_mean16_fx+8, y_gain_tmp+8, YG_dicMR_3_fx, 4, 32);
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 5 );
+ idx_g = vquant_fx(y_gain_tmp+12, YG_mean16_fx+12, y_gain_tmp+12, YG_dicMR_4_fx, 4, 16);
+ push_indice_fx( st_fx, IND_Y_GAIN_TMP, idx_g, 4 );
+ }
+ }
+
+ /* Gain adjustment to fit ACELP generic inactive coding gain at low rate */
+ GSC_gain_adj(coder_type, core_brate, mean_4g[0], y_gain_tmp2 /* dummy buffer */, y_gain_tmp, y_gainQ);
+
+ return mean_4g[0]; /*Q12*/
+}
+/*-------------------------------------------------------------------*
+ * VDQ_vec()
+ *
+ * Return the dequantized vector of index
+ *-------------------------------------------------------------------*/
+static Word16 VDQ_vec_fx(
+ Word16 *Qvec_out_fx, /* o: Quanitzed vector */
+ const Word16 *mean_dic_fx, /* i: average codebook */
+ const Word16 *dic_fx, /* i: codebook */
+ const Word16 index_fx, /* i: index of codebook*/
+ const Word16 vec_en_fx /* i: vector length */
+)
+{
+ Word16 i, j;
+
+ /*j = shr_r(extract_l(L_mult(index_fx,vec_en_fx)),1);*/
+ j = i_mult2(index_fx,vec_en_fx);
+ FOR ( i = 0; i < vec_en_fx; i++)
+ {
+ Qvec_out_fx[i] = dic_fx[j++];
+ move16();
+ }
+
+ FOR(i = 0; i < vec_en_fx; i++)
+ {
+ Qvec_out_fx[i] = add(Qvec_out_fx[i],mean_dic_fx[i]);
+ move16();
+ }
+
+ return index_fx;
+}
diff --git a/lib_com/gs_inact_switching_fx.c b/lib_com/gs_inact_switching_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..a92a7199e7d012c1f34b3782c5128dee350f0774
--- /dev/null
+++ b/lib_com/gs_inact_switching_fx.c
@@ -0,0 +1,153 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+
+/*-------------------------------------------------------------------*
+ * Local constants
+ *-------------------------------------------------------------------*/
+
+#define ALPHA0_FX 13107
+#define BETA0_FX (32768-ALPHA0_FX)
+
+/*========================================================================*/
+/* FUNCTION : Inac_swtch_ematch_fx() */
+/*------------------------------------------------------------------------*/
+/* PURPOSE : Apply energy matching when swithcing to INACTIVE frame coded */
+/* by the GSC technology */
+/*------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) coder_type : Coding mode */
+/* _ (Word16) L_frame : Frame lenght */
+/* _ (Word32) core_brate : core bitrate */
+/*------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ (Word16[]) exc2 : CELP/GSC excitation buffer Q_exc */
+/* _ (Word16[]) lt_ener_per_band : Long term energy per band Q12 */
+/* _ (Word16*) Q_exc : input and output format of exc2 */
+/*------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*========================================================================*/
+void Inac_swtch_ematch_fx(
+ Word16 exc2[], /* i/o: CELP/GSC excitation buffer Q_exc*/
+ Word16 dct_exc_tmp[], /* i : GSC excitation in DCT domain */
+ Word16 lt_ener_per_band[], /* i/o: Long term energy per band Q12 */
+ const Word16 coder_type, /* i : Coding mode */
+ const Word16 L_frame, /* i : Frame lenght */
+ const Word32 core_brate, /* i : Core bit rate */
+ const Word16 Q_exc /* i : input and output format of exc2 */
+ ,const Word16 bfi /* i : frame lost indicator */
+ ,const Word16 last_core, /* i : Last core used */
+ const Word16 last_codec_mode /* i : Last codec mode */
+)
+{
+ Word16 Ener_per_bd[MBANDS_GN];
+ Word16 ftmp;
+ Word16 *pt_exc;
+ Word16 j, i;
+
+ Word16 exp,frac;
+ Word32 L_tmp;
+
+ /*--------------------------------------------------------------------------
+ * average energy per band
+ *--------------------------------------------------------------------------*/
+
+ test();
+ test();
+ test();
+ test();
+ test();
+ test();
+ IF(EQ_16(coder_type,AUDIO)&&bfi==0)
+ {
+ Ener_per_band_comp_fx( dct_exc_tmp, Ener_per_bd, Q_exc, MBANDS_GN, 1);
+
+ /* reset long-term energy per band */
+ FOR(i = 0; i < MBANDS_GN; i++)
+ {
+ lt_ener_per_band[i] = Ener_per_bd[i];
+ move16();
+ }
+
+ }
+ ELSE IF( EQ_16(coder_type,VOICED)||EQ_16(coder_type,GENERIC)||EQ_16(coder_type,TRANSITION)||NE_16(last_core,ACELP_CORE)||NE_16(last_codec_mode,MODE1))
+ {
+ /* Find spectrum and energy per band for GC and VC frames */
+ edct_16fx( exc2, dct_exc_tmp, L_frame, 5 );
+
+ Ener_per_band_comp_fx( dct_exc_tmp, Ener_per_bd, Q_exc, MBANDS_GN, 1);
+
+ /* reset long-term energy per band */
+ FOR(i = 0; i < MBANDS_GN; i++)
+ {
+ lt_ener_per_band[i] = Ener_per_bd[i];
+ move16();
+ }
+ }
+ ELSE IF( EQ_16(coder_type,INACTIVE)&&LE_32(core_brate,ACELP_24k40))
+ {
+ /* Find spectrum and energy per band for inactive frames */
+ edct_16fx( exc2, dct_exc_tmp, L_frame, 5 );
+ Ener_per_band_comp_fx( dct_exc_tmp, Ener_per_bd, Q_exc, MBANDS_GN, 1 );
+
+ /* More agressive smoothing in the first 50 frames */
+ pt_exc = dct_exc_tmp;
+ move16();
+ FOR(i = 0; i < MBANDS_GN; i++)
+ {
+ /* Compute smoothing gain to apply with gain limitation */
+ L_tmp = L_mult(ALPHA0_FX,lt_ener_per_band[i]); /*Q(15+12+1)=Q(28) */
+ L_tmp = L_mac(L_tmp,BETA0_FX,Ener_per_bd[i]); /*Q28 */
+ lt_ener_per_band[i] = round_fx(L_tmp); /*Q12 */
+
+ ftmp = sub(lt_ener_per_band[i],Ener_per_bd[i]); /*Q12 */
+
+ /* ftmp = (float)pow(10, ftmp);= pow(2,3.321928*ftmp);*/
+
+ L_tmp = L_mult(27213,ftmp); /*Q(13+12+1)=Q26 ; 27213=3.321928 in Q13 */
+ L_tmp = L_shr(L_tmp, 10); /* From Q26 to Q16 */
+ frac = L_Extract_lc(L_tmp, &exp); /* Extract exponent of ftmp */
+ ftmp = extract_l(Pow2(14, frac));/* Put 14 as exponent so that */
+ /* output of Pow2() will be: */
+ /* 16384 < Pow2() <= 32767 */
+
+ exp = sub(exp,14);
+ IF( LT_16(i,2))
+ {
+ FOR (j = 0; j < 8; j ++)
+ {
+ L_tmp = L_mult(*pt_exc,ftmp); /* Q_exc*Q0 -> Q(Q_exc+1) */
+ L_tmp = L_shl(L_tmp, add(exp,15)); /* Q(Q_exc+1) -> Q(16+Q_exc)*/
+ *pt_exc = round_fx(L_tmp);
+ pt_exc++;
+ }
+ }
+ ELSE
+ {
+ FOR (j = 0; j < 16; j ++)
+ {
+ L_tmp = L_mult(*pt_exc,ftmp); /* Q_exc*Q0 -> Q(Q_exc+1) */
+ L_tmp = L_shl(L_tmp, add(exp,15)); /* Q(Q_exc+1) -> Q(16+Q_exc)*/
+ *pt_exc = round_fx(L_tmp); /*Q_exc*/
+ pt_exc++;
+ }
+ }
+ }
+
+ /* Going back to time */
+ edct_16fx( dct_exc_tmp, exc2, L_frame, 5 );
+ }
+
+ return;
+}
diff --git a/lib_com/gs_noisefill_fx.c b/lib_com/gs_noisefill_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..4c83b664599aa3ac5d35e3c1fe3fbc41a5f82fba
--- /dev/null
+++ b/lib_com/gs_noisefill_fx.c
@@ -0,0 +1,922 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h"
+#include "rom_com_fx.h"
+#include "prot_fx.h"
+#include "stl.h"
+
+/*-------------------------------------------------------------------*
+ * gs_noisf()
+ *
+ * Noise fill-in function
+ *-------------------------------------------------------------------*/
+
+static void gs_noisf_fx(
+ const Word16 Start_BIN, /* i : First bin for noise fill */
+ const Word16 NB_Qbins, /* i : Number of bin per band */
+ const Word16 Noise_fac, /* i : Noise level Q15 */
+ const Word16 *y_norm, /* i : Quantized pulses Qn */
+ Word16 *exc_diffQ, /* o : Quantized pulses with noise added Qn */
+ Word16 *seed_tcx, /* i : Random generator seed */
+ const Word16 coder_type, /* i : coder type */
+ Word16 qNoise_fac
+)
+{
+ Word32 ftmp;
+ Word16 i, k;
+ Word16 NB_zer;
+ Word32 const_1=1;
+ Word16 tmp;
+
+ NB_zer = shr(NB_Qbins,1);
+
+ const_1 = L_shl(const_1, add(qNoise_fac, qNoise_fac));
+ if( EQ_16(coder_type,INACTIVE))
+ {
+ NB_zer = 2;
+ move16();
+ }
+
+ /*----------------------------------------------*
+ * noise fill-in on unquantized subvector *
+ * injected only from 1066Hz to 6400Hz. *
+ *----------------------------------------------*/
+
+ FOR( k=Start_BIN; k ACELP_24k40 )
+ {
+ noise_offset = 6554;
+ move16(); /*.2f * 32768 */
+ }
+ ELSE IF ( bitrate >= ACELP_22k60 )
+ {
+ noise_offset = 9830;
+ move16();/*.3f * 32768 */
+ }
+ ELSE IF ( bitrate >= ACELP_9k60 )
+ {
+ noise_offset = 11469;
+ move16(); /*0.35f * 32768 */
+ }
+ ELSE
+ {
+ noise_offset = 13107;
+ move16(); /*.4f * 32768 */
+ }
+
+ set16_fx( noisepb + i_band, noise_offset, sub(Mbands_gn, i_band) );
+
+ FOR( i = i_band; i < 5; i++ )
+ {
+ noisepb[i] = s_min(noisepb[i], 6554);
+ move16();
+ }
+
+ return;
+}
+/*==========================================================================*/
+/* FUNCTION : void EstimateNoiseLevel_fx() */
+/*--------------------------------------------------------------------------*/
+/* PURPOSE : */
+/*--------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word32) bitrate : Bitrate of the codec Q0 */
+/* _ (Word16) Diff_len : number of bin before cut-off frequency */
+/* _ (Word16) Mbands_gn : number of bands Q0 */
+/* _ (Word16) coder_type : coder type Q0 */
+/* _ (Word16) noise_lev : pulses dynamic Q0 */
+/* _ (Word16) pit_band_idx : bin position of the cut-off frequency */
+/* _ (Word16*) freq_nsbin_per_band : bin per bands tables Q0 */
+/*--------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16*) noisepb : Noise per band Q15 */
+/*--------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* None */
+/*--------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*==========================================================================*/
+static void EstimateNoiseLevel_fx(
+ Word16 *noisepb, /* o : Noise per band */
+ const Word32 bitrate, /* i : Bitrate of the codec */
+ const Word16 Diff_len, /* i : number of bin before cut-off frequency */
+ const Word16 Mbands_gn, /* i : number of bands */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 noise_lev, /* i : pulses dynamic */
+ const Word16 pit_band_idx, /* i : bin position of the cut-off frequency */
+ Word16 last_bin, /* i : the last bin of bit allocation */
+ Word16 bwidth
+)
+{
+ Word16 i_band;
+
+ i_band = 0;
+ move16();
+
+ IF( LT_16(Diff_len,L_FRAME))
+ {
+ EstimateNoiseLevel_inner_fx(noisepb, bitrate, i_band, MBANDS_GN);
+ IF( coder_type != INACTIVE )
+ {
+ test();
+ test();
+ IF( (EQ_32(bitrate,ACELP_8k00)&>_16(last_bin,8))&&NE_16(bwidth,NB))
+ {
+ FOR( ; Mbands_gn > i_band; i_band++)
+ {
+ noisepb[i_band] = add(noisepb[i_band],noisepb[i_band]);
+ move16();
+ }
+ }
+ ELSE
+ {
+ FOR( ; pit_band_idx > i_band; i_band++ )
+ {
+ noisepb[i_band] = mult_r(noisepb[i_band], 16384);
+ move16();/* 1/2=0.5 in Q15 */
+ }
+ }
+ }
+ }
+ test();
+ IF ( (EQ_16(coder_type,INACTIVE)||GE_16(noise_lev,NOISE_LEVEL_SP3)))
+ {
+ FOR( i_band = 9; i_band < Mbands_gn; i_band++ )
+ {
+ noisepb[i_band] = add(noisepb[i_band], mult_r(noisepb[i_band], 4915));
+ move16();/*noisepb[i_band]*1.15=noisepb[i_band] *(1 + 0.15) */
+ }
+ }
+
+ return;
+}
+
+/*============================================================================*/
+/* FUNCTION : void Appy_NoiseFill_fx() */
+/*----------------------------------------------------------------------------*/
+/* PURPOSE : */
+/*----------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16*) seed_tcx : Seed for noise Q0 */
+/* _ (Word16*) noisepb : Noise per band Q15 */
+/* _ (Word16) Diff_len : number of bin before cut-off frequency Q0 */
+/* _ (Word16) Mbands_gn : number of bands Q0 */
+/* _ (Word16) coder_type : pulses dynamic Q0 */
+/* _ (Word16*) freq_nsbin_per_band: bin per bands tables Q0 */
+/* _ (Word16) qexc_diffQ : Q format of exc_diffQ */
+/*----------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16*) exc_diffQ : Noise per band qexc_diffQ */
+/*----------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* None */
+/*----------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*============================================================================*/
+static void Apply_NoiseFill_fx(
+ Word16 *exc_diffQ, /* i/o: Noise per band qexc_diffQ */
+ Word16 *seed_tcx, /* i : Seed for noise */
+ const Word16 *noisepb, /* i : Noise per band Q15 */
+ const Word16 Diff_len, /* i : number of bin before cut-off frequency */
+ const Word16 Mbands_gn, /* i : number of bands */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 *freq_nsbin_per_band, /* i : bin per bands tables */
+ Word16 qexc_diffQ
+)
+{
+ Word16 StartBin, NB_Qbins, i_band;
+ StartBin = 0;
+ move16();
+ NB_Qbins = 0;
+ move16();
+
+ FOR( i_band = 0; i_band < Mbands_gn; i_band++ )
+ {
+ StartBin += NB_Qbins;
+ move16();
+ NB_Qbins = freq_nsbin_per_band[i_band];
+ move16();
+
+ IF( LT_16(Diff_len,L_FRAME))
+ {
+ gs_noisf_fx( StartBin , NB_Qbins, noisepb[i_band], exc_diffQ, exc_diffQ, seed_tcx, coder_type, qexc_diffQ);
+ }
+ }
+
+ return;
+}
+/*==========================================================================*/
+/* FUNCTION :void freq_dnw_scaling_fx () */
+/*--------------------------------------------------------------------------*/
+/* PURPOSE : */
+/*--------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) cor_strong_limit : HF correlation Q0 */
+/* _ (Word16) coder_type : coder type Q0 */
+/* _ (Word16) noise_lev : Noise level Q0 */
+/* _ (Word32) core_brate : Core bitrate Q0 */
+/* _ (Word16) Qx : Q format of fy_norm */
+/*--------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ None */
+/*--------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ (Word16[]) fy_norm : Frequency quantized parameter Qx */
+/*--------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _None */
+/*==========================================================================*/
+void freq_dnw_scaling_fx(
+ const Word16 cor_strong_limit, /* i : HF correlation */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 noise_lev, /* i : Noise level */
+ const Word32 core_brate, /* i : Core bitrate */
+ Word16 fy_norm[], /* i/o: Frequency quantized parameter */
+ Word16 Qx /* Q format of fy_norm*/
+)
+{
+ Word16 sc_dyn;
+ Word16 start_sc, i;
+
+ sc_dyn = 32767;
+ move16(); /*Q15 */
+ start_sc = L_FRAME;
+ move16();
+ test();
+ IF( LE_32(core_brate,ACELP_8k00)&&EQ_16(coder_type,INACTIVE))
+ {
+ sc_dyn = mult_r(sc_dyn,4915); /*Q15 (0.15 in Q15) */
+ start_sc = 64;
+ move16();
+ }
+ ELSE IF ( EQ_16(coder_type,INACTIVE))
+ {
+ sc_dyn = mult_r(sc_dyn,8192); /*Q15 (0.25 in Q15) */
+ start_sc = 80;
+ move16();
+ }
+ ELSE
+ {
+ /*sc_dyn = (float)(NOISE_LEVEL_SP3 - noise_lev)/10.0f + 0.4f;*/
+ sc_dyn = extract_l(L_mac(13107, sub(NOISE_LEVEL_SP3, noise_lev), 1638)); /*Q0*Q14x2+Q15 =Q15*/
+ start_sc = add(112, shl(sub(NOISE_LEVEL_SP3, noise_lev), 4));
+ if( EQ_16(noise_lev,NOISE_LEVEL_SP0))
+ {
+ start_sc = L_FRAME;
+ move16();
+ }
+ }
+
+ FOR(i = start_sc; i < L_FRAME; i++)
+ {
+ fy_norm[i] = mult_r(fy_norm[i],sc_dyn);
+ move16();/*Qx */
+ }
+
+ test();
+ test();
+ IF( (LT_32(core_brate,ACELP_13k20)&&cor_strong_limit==0)||LT_32(core_brate,ACELP_9k60))
+ {
+ FOR(i = 160; i < L_FRAME; i++)
+ {
+ fy_norm[i] = s_min(fy_norm[i],shl(1,Qx));
+ move16();
+ fy_norm[i] = s_max(fy_norm[i],shl(-1,Qx));
+ move16();
+ }
+ }
+ ELSE IF ( LT_32(core_brate,ACELP_22k60))
+ {
+ FOR(i = 160; i < L_FRAME; i++)
+ {
+ fy_norm[i] = s_min(fy_norm[i],shr_r(1536,sub(10,Qx)));
+ move16();
+ fy_norm[i] = s_max(fy_norm[i],shr_r(-1536,sub(10,Qx)));
+ move16();
+ }
+ }
+
+ return;
+
+}
+
+static void Decreas_freqPeak_fx(
+ Word16 *lsf_new, /* i : ISFs at the end of the frame */
+ Word16 *exc_diffQ, /* i/o: frequency coefficients of per band */
+ Word16 rat /* i : threshold of ratio between consecutive lsf_new_diff */
+)
+{
+ Word16 i, j, k;
+ Word16 last_bin = 0;
+ Word16 pos = 0;
+ Word16 *src, max,avrg;
+ Word32 L_avrg,L_tmp;
+ Word16 lsf_new_diff[M];
+ Word16 tmp,tmp1,exp;
+ Word16 tmp2;
+
+ move16(); /*ptr init*/
+ lsf_new_diff[0] = 0; /* prevent unitialized value */
+ FOR(j=1; j<(M-1); j++)
+ {
+ lsf_new_diff[j] =sub( lsf_new[j] , lsf_new[j-1]);/*Qx2.56 */
+ }
+
+ avrg = 0;
+ move16();
+ L_avrg = L_deposit_l(0);
+ max = 1;
+ move16();
+ FOR(i=160; iQ_exc + 6 */
+ avrg = round_fx(L_shl(L_avrg,10));/*Q_exc */
+ last_bin = M-1;
+ move16(); /* When the search is false, should equate the end of the vector, not the beginning */
+ FOR(i=0; i<(M-1); i++)
+ {
+ if(GT_16(lsf_new[i],10240))
+ {
+ last_bin = i;
+ move16();
+ BREAK;
+ }
+ }
+
+ FOR(i=last_bin; i<14; i++)
+ {
+ tmp = mult_r(rat,lsf_new_diff[i-1] );/*Qx2.56 */
+ IF(GT_16(tmp , lsf_new_diff[i]))
+ {
+ src = &exc_diffQ[shl(sub(i,1),4)];
+ move16();
+ FOR(j=0; j<2; j++)
+ {
+ FOR(k=0; k<16; k++)
+ {
+ tmp = mult_r(16384,abs_s(*src));
+ IF(GT_16(tmp,avrg))
+ {
+ tmp = abs_s(*src) ;
+ exp = norm_s(max);
+ tmp1 = div_s(shl(1,sub(14,exp)),max);/*Q(29 - exp - Q_exc) */
+ L_tmp = L_mult(tmp,tmp1);/*Q(30 - exp) */
+ tmp = round_fx(L_shl(L_tmp,exp));/*Q14 */
+ tmp = sub(32767,tmp);/*Q14 */
+ L_tmp = L_mult(avrg,tmp);/*Q_exc +15 */
+
+ tmp = round_fx(L_shl(L_tmp,1));
+ tmp1 = negate(tmp);
+
+ tmp2 = *src;
+ *(src) = tmp1;
+ move16();
+ if( tmp2 > 0 )
+ {
+ *(src) = tmp;
+ move16();
+ }
+
+ }
+ src++;
+ }
+ }
+ }
+ }
+
+ tmp = mult_r(8192,max);/*Q_exc */
+ test();
+ IF(EQ_16(abs_s(exc_diffQ[pos]),max)&>_16(tmp,avrg))
+ {
+ FOR(i=pos-1; iQ(2*Q_exc-7) */
+
+ exp1 = norm_l(Ener_fx);
+ Ener_fx = L_shl(Ener_fx, exp1);
+ exp1 = 31-exp1-sub(shl(Q_exc,1),7);
+ move16();
+ Ener_fx = Isqrt_lc(Ener_fx, &exp1); /*Q(31-exp1) */
+
+ weight_fx = 16384; /*Q15 */
+ src_fx = &exc_diffQ_fx[start_band]; /*Q_exc */
+ FOR(i=last_bin; i Q16 */
+
+ frac = L_Extract_lc(L_tmp, &exp); /* Extract exponent of L_tmp */
+ tmp = extract_l(Pow2(14, frac));/* Put 14 as exponent so that */
+ /* output of Pow2() will be: */
+ /* 16384 < Pow2() <= 32767 */
+ exp = sub(exp, 14);
+ Ener1_fx = mult_r(13107, shl(tmp, exp)); /*Q0 */
+
+ FOR(j=0; j<16; j++)
+ {
+ /**src = Ener1*(weight*(*src)*Ener + (1.0f-weight)*own_random(seed_tcx)/32768.0f); */
+ L_tmp = Mult_32_16(Ener_fx, *src_fx); /*Q(31-exp+Q_exc-15) -> Q(16-exp+Q_exc) */
+ tmp = extract_l(L_shr(L_tmp, add(4, sub(Q_exc, exp1)))); /*Q12 */
+ tmp = mult_r(weight_fx, tmp); /*Q12 */
+
+ L_tmp = L_mult0(sub(32767, weight_fx), Random(seed_tcx)); /*Q30 */
+ tmp1 = round_fx(L_shr(L_tmp, 2));
+
+ L_exc_diffQ_fx[16*i+j] = L_mult0(Ener1_fx, add(tmp, tmp1)); /*Q12 */ move32();
+ src_fx++;
+ }
+ }
+
+ /*Ener1 = (float)(0.4f*pow(10, Ener_per_bd_iQ[15])); */
+ L_tmp = L_shr(L_mult0(Ener_per_bd_iQ_fx[15], 27213), 9); /* 3.321928 in Q13 -> Q16 */
+
+ frac = L_Extract_lc(L_tmp, &exp); /* Extract exponent of L_tmp */
+ tmp = extract_l(Pow2(14, frac));/* Put 14 as exponent so that */
+ /* output of Pow2() will be: */
+ /* 16384 < Pow2() <= 32767 */
+ exp = sub(exp, 14);
+ Ener1_fx = mult_r(13107, shl(tmp, exp)); /*Q0 */
+
+ src_fx = &exc_diffQ_fx[224];
+ FOR(j=0; j<32; j++)
+ {
+ /**src = Ener1*(weight*(*src)*Ener + (1.0f-weight)*own_random(seed_tcx)/32768.0f); */
+ L_tmp = Mult_32_16(Ener_fx, *src_fx); /*Q(31-exp+Q_exc-15) -> Q(16-exp+Q_exc) */
+ tmp = extract_l(L_shr(L_tmp, add(4, sub(Q_exc, exp1)))); /*Q12 */
+ tmp = mult_r(weight_fx, tmp); /*Q12 */
+
+ L_tmp = L_mult0(sub(32767, weight_fx), Random(seed_tcx)); /*Q30 */
+ tmp1 = round_fx(L_shr(L_tmp, 2)); /*Q12 */
+
+ L_exc_diffQ_fx[16*i+j] = L_mult0(Ener1_fx, add(tmp, tmp1)); /*Q12 */ move32();
+ src_fx++;
+ }
+
+ exc_diffQ_max = 0;
+ move16();
+ FOR(i=start_band; i Q27 */
+ L_tmp = L_shr(L_tmp, 10); /* From Q27 to Q16 */
+
+ frac = L_Extract_lc(L_tmp, &exp); /* Extract exponent of L_tmp */
+ tmp = extract_l(Pow2(14, frac));/* Put 14 as exponent so that */
+ /* output of Pow2() will be: */
+ /* 16384 < Pow2() <= 32767 */
+ exp = sub(exp, 14);
+ tmp1 = shl(tmp,exp);
+ move16();
+ ener = add (tmp1,ener);/*Q0 */
+ }
+
+ test();
+ IF( EQ_32(core_brate,ACELP_8k00)&&NE_16(bwidth,NB))
+ {
+ if(NE_16(last_coder_type,AUDIO))
+ {
+ *last_ener = ener;
+ move16();
+ }
+ test();
+ test();
+ IF((GT_16(last_bin,8)||Diff_len!=0)&&EQ_16(last_coder_type,AUDIO))
+ {
+ MAX_Bin = 10;
+ move16();
+ bwe_flag = 1;
+ move16();
+ }
+ ELSE
+ {
+ MAX_Bin = 15;
+ move16();
+ }
+
+ last_bin_tmp = last_bin;
+ move16();
+ last_bin = s_max(last_bin , MAX_Bin);
+ last_bin = add(last_bin, 1);
+ }
+ ELSE
+ {
+ last_bin = MBANDS_GN;
+ move16();
+ last_bin_tmp = last_bin;
+ move16();
+ }
+ IF( bfi )
+ {
+ set16_fx( noisepb, 13107, MBANDS_GN ); /*0.4 in Q15 */
+ }
+ ELSE
+ {
+ EstimateNoiseLevel_fx( noisepb, core_brate, Diff_len, last_bin, coder_type, noise_lev, pit_band_idx,
+ last_bin_tmp, bwidth );
+ }
+
+ IF( exc_wo_nf != NULL )
+ {
+ Copy( exc_diffQ, exc_wo_nf, L_FRAME );
+ }
+
+ test();
+ IF( GSC_noisy_speech && !bfi )
+ {
+ set16_fx( noisepb, 3277, MBANDS_GN );
+ }
+ Apply_NoiseFill_fx( exc_diffQ, seed_tcx, noisepb, Diff_len, last_bin, coder_type, mfreq_bindiv, Qexc_diffQ );
+
+ /*--------------------------------------------------------------------------------------*
+ * Quantize average gain
+ * Substract Q averaged gain
+ * VQ of remaining gain per band
+ *--------------------------------------------------------------------------------------*/
+ test();
+ IF( EQ_32(core_brate,ACELP_8k00)&&NE_16(bwidth,NB))
+ {
+ Ener_per_band_comp_fx(exc_diffQ, Ener_per_bd_yQ, Qexc_diffQ, add(last_bin,1), 0);
+ }
+ ELSE
+ {
+ Ener_per_band_comp_fx(exc_diffQ, Ener_per_bd_yQ, Qexc_diffQ, MBANDS_GN, 1 );
+
+ IF( LT_16(nb_subfr, 4))
+ {
+ FOR(i = L_FRAME-16; i < L_FRAME; i++)
+ {
+ /*exc_diffQ[i] *= 0.067f * i - 15.0f; = -15 - (-0.067f * i) */
+ tmp = msu_r(-7680*65536, -17564, shl(i,6));/*-15 in Q9; -0.067 in Q18 and i in Q6= Q9 */
+ L_tmp = L_mult(exc_diffQ[i],tmp); /*Q(Qexc_diffQ+10) */
+ exc_diffQ[i] = round_fx(L_shl(L_tmp,16-10));/*Qexc_diffQ */
+ }
+ }
+ }
+ /*--------------------------------------------------------------------------------------*
+ * Check potential energy excitation overshoot
+ *--------------------------------------------------------------------------------------*/
+ IF( bfi )
+ {
+ test();
+ IF (GSC_noisy_speech == 0 && GT_16(coder_type,UNVOICED)) /* Here coder_type == last_coder_type because of the bfi */
+ {
+ FOR( i=0; i end)
+ {
+ *src-- = *dst--;
+ move16();
+ }
+ test();
+ test();
+ if( (bitallocation_exc[0] != 0 || bitallocation_exc[1] != 0) && EQ_32(core_brate, ACELP_8k00))
+ {
+ exc_diffQ[160] = 0;
+ move16();
+ }
+
+ Q_hb_exc = 0;
+ move16();
+ envelop_modify_fx( exc_diffQ, seed_tcx, last_bin, Ener_per_bd_iQ, Q_exc, &Q_hb_exc);
+ Copy_Scale_sig( &exc_diffQ[tmp1], &exc_dct_in[tmp1], sub(L_FRAME,tmp1), sub(Q_exc, Q_hb_exc)); /* from Q_hb_exc -> Q_exc as expected */
+ }
+
+ IF( LT_16(nb_subfr,4))
+ {
+ FOR( i = sub(L_FRAME,16); i < L_FRAME; i++ )
+ {
+ /*exc_dct_in[i] *= (0.067f*i-15.f); */
+ tmp = mult_r(17564,shl(i,6)); /*0.067 in Q18 and i in Q6= Q9 */
+ tmp = sub(tmp,7680); /*15 in Q9 = Q9 */
+ L_tmp = L_mult(exc_dct_in[i],tmp);/*Q(Q_exc+10) */
+ exc_dct_in[i] = round_fx(L_shl(L_tmp,6));/*Q_exc */
+ }
+ }
+
+ tmp1 = mult_r(ener,16384);
+ tmp1 = sub(*last_ener,tmp1);
+ tmp = mult_r(*last_ener,16384);
+ tmp = sub(ener,tmp);
+ test();
+ IF( tmp>0 && tmp1>0 )
+ {
+ length_bin = 6;
+ move16();
+ IF(last_coder_type != AUDIO)
+ {
+ set16_fx( last_bitallocation_band, 0, 6 );
+ Copy( &exc_dct_in[(4+length_bin)*16], &last_exc_dct_in[(4+length_bin)*16], length_bin*16 );
+ }
+
+ FOR(i=4; i<(4+length_bin); i++)
+ {
+ test();
+ IF( !(bitallocation_band[i] == 0 && last_bitallocation_band[i-4] == 0))
+ {
+ k = shl(add(i,length_bin),4);
+ src = &exc_dct_in[k]; /*(i+length_bin)*16*/
+ dst = &last_exc_dct_in[k];
+ FOR(j=0; j<16; j++)
+ {
+ tmp= mult_r(10923,abs_s(*src));
+ tmp1 =mult_r(10923,abs_s(*dst));
+
+ IF(GT_16(tmp,abs_s(*dst)))
+ {
+ tmp2 = *src;
+ *src = mult_r(16384,sub(*src , abs_s(*dst))); /*Q_exc */ move16();
+ tmp = mult_r(16384,add(tmp2 , abs_s(*dst))); /*Q_exc */
+ if( tmp2 > 0 )
+ {
+ *src = tmp;
+ move16();
+ }
+ }
+ ELSE IF (GT_16(tmp1,abs_s(*src)))
+ {
+ tmp = mult_r(*src,22938);
+ tmp1 = mult_r(9830,abs_s(*dst));
+ tmp2 = *src;
+ *src = sub(tmp,tmp1); /*Q_exc */ move16();
+ if( tmp2 > 0 )
+ {
+ *src = add(tmp,tmp1); /*Q_exc */ move16();
+ }
+ }
+ src++;
+ dst++;
+ }
+ }
+ }
+ }
+ IF(EQ_16(bwe_flag,1))
+ {
+ Decreas_freqPeak_fx( lsf_new, exc_dct_in, 9830 );
+ }
+ ELSE
+ {
+ Decreas_freqPeak_fx( lsf_new, exc_dct_in, 16384 );
+ }
+ }
+
+ Copy( &exc_dct_in[64], &last_exc_dct_in[64], L_FRAME-64 );
+ Copy(&bitallocation_band[4], last_bitallocation_band, 6);
+ *last_ener = ener;
+ move16();
+
+ return;
+}
diff --git a/lib_com/gs_preech_fx.c b/lib_com/gs_preech_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..75928b745fcb7a5c252fda8d2f469a6191ff760b
--- /dev/null
+++ b/lib_com/gs_preech_fx.c
@@ -0,0 +1,139 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+
+
+/*-------------------------------------------------------------------*
+ * Local constants
+ *-------------------------------------------------------------------*/
+
+#define ATT_LENGHT 64
+#define ATT_SEG_LEN (L_FRAME/ATT_LENGHT)
+#define INV_ATT_SEG_LEN (1.0f/ATT_SEG_LEN)
+#define INV_L_FRAME (1.0f/L_FRAME)
+
+/*==========================================================================*/
+/* FUNCTION : void pre_echo_att_fx(); */
+/*--------------------------------------------------------------------------*/
+/* PURPOSE : Attenuation of the pre-echo when encoder specifies an attack */
+/*--------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) L_frame_fx : length of the frame Q0 */
+/* _ (Word16) gsc_attack_flag_fx : LP filter coefficient Q0 */
+/* _ (Word16) core_fx : core codec used Q0 */
+/*--------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ None */
+/*--------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ (Word16*) exc_fx : adapt. excitation exc Q_exc */
+/* _ (Word32*) Last_frame_ener_fx : Energy of the last frame Q1 */
+/*--------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*==========================================================================*/
+void pre_echo_att_fx(
+ Word32 *Last_frame_ener_fx, /* i/o: Energy of the last frame 2*Q_new+1*/
+ Word16 *exc_fx, /* i/o: Excitation of the current frame Q_new*/
+ const Word16 gsc_attack_flag_fx /* i : flag signalling attack encoded by AC mode (GSC) */
+ ,const Word16 Q_new
+ ,const Word16 last_coder_type_fx /* i : Last coding mode */
+)
+{
+ Word32 etmp_fx;
+ Word32 finc_fx[ATT_LENGHT] = {0};
+ Word16 ratio_fx;
+ Word16 attack_pos_fx, i;
+ Word32 L_tmp, L_tmp1;
+ Word16 tmp, n1, n2, exp, frac1, frac2;
+ Word32 etmp1_fx;
+ test();
+ IF ( EQ_16(gsc_attack_flag_fx,1)&&EQ_16(last_coder_type_fx,AUDIO)) /*gsc_attack_flag_fx does not get set for all the test cases */
+ {
+ /*-------------------------------------------------------------------------*
+ * Find where the onset (attack) occurs by computing the energy per section
+ * The inverse weighting aims to favor the first maxima in case of
+ * gradual onset
+ *-------------------------------------------------------------------------*/
+ FOR(i = 0; i < ATT_LENGHT; i++)
+ {
+ L_tmp = sum2_fx(&exc_fx[shl(i,2)], ATT_SEG_LEN ); /*2*Q_new+1, //ATT_SEG_LEN=(L_FRAME/ATT_LENGHT)=4(=shl(x,2))*/
+ tmp = div_s(sub(ATT_LENGHT,i),ATT_LENGHT); /*Q15 */
+ L_tmp = Mult_32_16(L_tmp, tmp); /*2*Q_new+1 */
+ finc_fx[i] = L_tmp;
+ move32(); /*2*Q_new+1 */
+ }
+
+ attack_pos_fx = maximum_32_fx(finc_fx, ATT_LENGHT, &etmp_fx);
+
+ /* Scaled the maximum energy and allowed 6 dB increase*/
+ etmp_fx = L_shr(etmp_fx,add(2+1-4, shl(Q_new,1)));/*2*Q_new+1 //INV_ATT_SEG_LEN=1/4(=shr(x,2)) -> Q4 */
+ etmp1_fx = etmp_fx;
+ move32();
+ *Last_frame_ener_fx = L_shl(*Last_frame_ener_fx,2);
+ move32(); /*2*Q_new+1 */
+
+ /* If the maximum normalized energy > last frame energy + 6dB */
+ test();
+ IF( GT_32(etmp_fx,*Last_frame_ener_fx)&&attack_pos_fx>0)
+ {
+ /* Find the average energy before the attack */
+ L_tmp = sum32_fx( finc_fx, attack_pos_fx); /*Q1 */
+ L_tmp1 = L_shr(L_mult(attack_pos_fx,attack_pos_fx),1); /*Q0 */
+ tmp = round_fx(Isqrt(L_tmp1)); /*Q15 */
+ L_tmp = L_shr(L_tmp,2); /*Q1 ; ATT_SEG_LEN=4 */
+ etmp_fx = Mult_32_16(L_tmp,tmp); /*Q1 */
+
+ etmp_fx = L_shr(etmp_fx,add(1-4, shl(Q_new,1))); /* makes etmp i nQ4 as *Last_frame_ener_fx */
+ /* Find the correction factor and apply it before the attack */
+ /* ratio = (float)sqrt(*Last_frame_ener/etmp);*/
+ /* = isqrt(etmp/(*Last_frame_ener)) */
+ etmp_fx = L_max(etmp_fx,1);
+ *Last_frame_ener_fx = L_max(*Last_frame_ener_fx,1);
+ n1 = norm_l(etmp_fx);
+ n2 = norm_l(*Last_frame_ener_fx);
+
+ n1 = sub(n1,1);
+ exp = sub(n1,n2);
+
+ frac1 = round_fx(L_shl(etmp_fx,n1));
+ frac2 = round_fx(L_shl(*Last_frame_ener_fx,n2));
+
+ L_tmp = L_mult0(128, div_s(frac1, frac2)); /* s = gain_out / gain_in */
+ L_tmp = L_shr(L_tmp, exp); /* add exponent */
+
+ L_tmp = Isqrt(L_tmp);
+ ratio_fx = round_fx(L_shl(L_tmp, 9));
+
+ /* Pre-echo atttenuation should never increase the energy */
+ ratio_fx = s_min(ratio_fx, 8192);
+ FOR(i = 0; i < attack_pos_fx*ATT_SEG_LEN; i++)
+ {
+ /*exc_fx[i] *= ratio_fx;*/
+ exc_fx[i] = round_fx(L_shl(L_mac(-8192, exc_fx[i], ratio_fx), 2));
+ }
+ }
+ *Last_frame_ener_fx = etmp1_fx;
+ move32();
+ }
+ ELSE
+ {
+ /*-------------------------------------------------------*
+ * In normal cases, just compute the energy of the frame
+ *-------------------------------------------------------*/
+
+ etmp_fx = sum2_fx( exc_fx, L_FRAME ); /*2*Q_new+1 */
+
+ etmp_fx = L_shr(etmp_fx,add(8+1-4, shl(Q_new,1))); /*2*Q_new+1 //INV_L_FRAME = 1/256 -> Q4*/
+ *Last_frame_ener_fx = etmp_fx;
+ move32(); /*2*Q_new+1*/
+ }
+
+ return;
+}
diff --git a/lib_com/guided_plc_util.c b/lib_com/guided_plc_util.c
new file mode 100644
index 0000000000000000000000000000000000000000..5c1fa7debd30a01d29742bb43b4b84fdbe417e39
--- /dev/null
+++ b/lib_com/guided_plc_util.c
@@ -0,0 +1,324 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "prot_fx.h"
+#include "stl.h"
+#include "rom_com_fx.h"
+
+#include "basop_util.h"
+#include "rom_basop_util.h"
+
+void getLookAheadResSig( Word16 *speechLookAhead, Word16 *A_3Q12, Word16 *res, Word16 L_frame, Word16 numSubFrame )
+{
+ Word16 *p_A;
+ Word16 i_subfr;
+ Word16 subfr_len[2] = { L_SUBFR, L_SUBFR };
+
+ if( GT_16( L_FRAME16k, L_frame ))
+ {
+ subfr_len[1] = 48;
+ move16(); /* 0.75 * L_SUBFR(64) */
+ }
+
+ p_A = A_3Q12;
+ FOR(i_subfr=0; i_subfrlsfoldbfi1_14Q1[i] );
+ L_tmp = L_mac( L_tmp, divide_by_3_Q15, decState->lsfoldbfi0_14Q1[i] );
+ decState->lsf_adaptive_mean_14Q1[i] = mac_r( L_tmp, divide_by_3_Q15, lsf_14Q1[i] );
+ decState->lsfoldbfi1_14Q1[i] = decState->lsfoldbfi0_14Q1[i];
+ move16();
+ decState->lsfoldbfi0_14Q1[i] = lsf_14Q1[i];
+ move16();
+ }
+
+ return;
+}
+
+void getConcealedLP( HANDLE_PLC_ENC_EVS memDecState, Word16 *AqCon, const Word16 lsfBase[], Word16 last_good, Word16 L_frame)
+{
+ Word16 *lsf;
+ Word16 lsp[(NB_DIV+1)*M];
+ Word32 int_fs;
+
+ move16();
+ lsf = memDecState->lsf_con;
+
+
+ dlpc_bfi( L_frame, &lsf[0], memDecState->lsfold_14Q1, last_good,
+ 1, memDecState->mem_MA_14Q1, memDecState->mem_AR, &(memDecState->stab_fac_Q15), memDecState->lsf_adaptive_mean_14Q1,
+ 1,
+ NULL,
+ 0,
+ NULL,
+ NULL,
+ lsfBase,
+ 0
+ );
+ Copy( memDecState->lspold_Q15, lsp, M );
+
+ int_fs = INT_FS_FX;
+ move32();
+ if( EQ_16(L_frame,L_FRAME_16k))
+ {
+ int_fs = INT_FS_16k_FX;
+ move32();
+ }
+ lsf2lsp_fx( lsf, &lsp[M], M, int_fs );
+
+ int_lsp_fx( L_frame, &lsp[0], &lsp[M], AqCon, M, interpol_frac_fx, 0 );
+
+ return;
+}
+
+void getConcealedLSF( HANDLE_PLC_ENC_EVS memDecState, const Word16 lsfBase[], Word16 last_good, Word16 L_frame)
+{
+ Word16 *lsf = memDecState->lsf_con;
+
+
+ dlpc_bfi( L_frame, &lsf[0], memDecState->lsfold_14Q1, last_good,
+ 1, memDecState->mem_MA_14Q1, memDecState->mem_AR, &(memDecState->stab_fac_Q15), memDecState->lsf_adaptive_mean_14Q1,
+ 1,
+ NULL,
+ 0,
+ NULL,
+ NULL,
+ lsfBase,
+ 0
+ );
+
+ return;
+}
+
+static void reorder_lsfs(Word16 *lsf, const Word16 min_dist, const Word16 n, const Word32 sr_core);
+
+void RecLpcSpecPowDiffuseLc( Word16 *lspq, Word16 *lsp_old, Word16 *lsfq, Decoder_State_fx *st, Word16 reset_q )
+{
+ const Word16 *means;
+ Word16 lsf_old[M];
+ Word16 i;
+
+ means = PlcGetLsfBase ( st->lpcQuantization,
+ st->narrowBand,
+ st->sr_core );
+
+ Copy( st->lsf_old_fx, lsf_old, M );
+
+ modify_lsf( lsf_old, M, st->sr_core, reset_q );
+
+ lsf2lsp_fx( lsf_old, lsp_old, M, st->sr_core );
+
+ IF( reset_q )
+ {
+ FOR ( i=0; imem_MA_fx[i], means[i]);
+ move16();
+ }
+ sort_fx( lsfq, 0, sub(M, 1) );
+
+ reorder_lsfs( lsfq, LSF_GAP_FX, M, st->sr_core );
+ lsf2lsp_fx( lsfq, lspq, M, st->sr_core );
+ }
+ ELSE
+ {
+ modify_lsf( lsfq, M, st->sr_core, reset_q );
+ lsf2lsp_fx(lsfq, lspq, M, st->sr_core);
+ }
+
+ return;
+}
+
+void modify_lsf(
+ Word16 *lsf,
+ const Word16 n,
+ const Word32 sr_core
+ , Word16 reset_q
+)
+{
+ Word16 i, k, th_x1p28_Q14;
+ Word16 gap, gap_sum;
+
+
+ th_x1p28_Q14 = 4864/*1900.0f*1.28f Q1*/;
+ move16();
+ if( EQ_32( sr_core, 16000 ))
+ {
+ th_x1p28_Q14 = 6080/*2375.0f*1.28f Q1*/;
+ move16();
+ }
+
+ IF( reset_q == 0 )
+ {
+ th_x1p28_Q14 = 2048; /* 800.0f*1.28f Q1*/ move16();
+ if( EQ_32( sr_core, 16000 ))
+ {
+ th_x1p28_Q14 = 2560; /*1000.0f*1.28f Q1*/ move16();
+ }
+ }
+
+ FOR ( i=1; i= 0; i--) /* Reverify the minimum ISF gap in the reverse direction */
+ {
+ IF (LE_16(lsf[i], th2))
+ {
+ curr_min_dist = min_dist_fac2;
+ move16();
+ }
+ ELSE
+ {
+ if (LE_16(lsf[i], th1))
+ {
+ curr_min_dist = min_dist_fac3;
+ move16();
+ }
+ }
+
+ if (GT_16(lsf[i], lsf_max))
+ {
+ lsf[i] = lsf_max;
+ move16();
+ }
+ lsf_max = sub(lsf[i], curr_min_dist);
+ }
+ }
+
+ return;
+}
+
diff --git a/lib_com/hp50.c b/lib_com/hp50.c
new file mode 100644
index 0000000000000000000000000000000000000000..93b5219b68ae1e2efd597fe4adf368611364c5b5
--- /dev/null
+++ b/lib_com/hp50.c
@@ -0,0 +1,250 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+
+#include
+#include "stl.h"
+#include "prot_fx.h"
+#include "basop_util.h"
+#include "options.h"
+
+
+#define HP20_COEFF_SCALE (2)
+
+/*
+ * hp20
+ *
+ * Function:
+ * 2nd order high pass filter with nominal cut off frequency at 20 Hz.
+ *
+ * Returns:
+ * void
+ */
+
+static Word32 HP50_Mode2_Mpy_32_16_fix(Word32 a, Word16 b)
+{
+ Word32 result = Mpy_32_16_1(a,b);
+ /* perform rounding towards lower value for negative results */
+ if (result < 0) result = L_add(result,1);
+ return result;
+}
+
+static Word32 HP50_Mpy_32_32_fix(Word32 a, Word32 b)
+{
+ Word32 result = Mpy_32_32(a,b);
+ /* perform rounding towards lower value for negative results */
+ if (result < 0) result = L_add(result,1);
+ return result;
+}
+
+
+static void filter_2nd_order(
+ Word16 signal[],
+ const Word16 stride,
+ const Word16 prescale,
+ const Word16 lg,
+ Word32 mem[4],
+ Word32 a1,
+ Word32 a2,
+ Word32 b1,
+ Word32 b2
+)
+{
+
+ Word16 i;
+ Word16 x2, x1;
+ Word32 L_sum, L_y1, L_y2;
+
+
+ /*
+ * Saturation: The states of the filter, namely L_y1 and L_y2 shall
+ * never saturate, because that causes error in the filter feedback.
+ * The final output written into signal[] might saturate because of
+ * unavoidable filter overshoot.
+ */
+
+ /* Execute first 2 iterations with 32-bit x anx y memory values */
+ BASOP_SATURATE_ERROR_ON
+ L_sum = HP50_Mpy_32_32_fix(b2,mem[2]); /* b2*x2 */
+ L_sum = L_add(L_sum,HP50_Mpy_32_32_fix(b1,mem[3])); /* b1*x1 */
+ x2 = shr(signal[0*stride], prescale);
+ L_sum = L_add(L_sum,HP50_Mode2_Mpy_32_16_fix(b2,x2)); /* b2*x0 */
+ L_sum = L_add(L_sum, HP50_Mpy_32_32_fix(mem[0],a2)); /* y2*a2 */
+ L_sum = L_add(L_sum, HP50_Mpy_32_32_fix(mem[1],a1)); /* y1*a1 */
+
+ L_y2 = L_shl(L_sum, HP20_COEFF_SCALE);
+ BASOP_SATURATE_ERROR_OFF
+ BASOP_SATURATE_WARNING_OFF
+ signal[0*stride] = round_fx(L_shl(L_y2, prescale));
+ BASOP_SATURATE_WARNING_ON
+
+ BASOP_SATURATE_ERROR_ON
+ L_sum = HP50_Mpy_32_32_fix(b2,mem[3]); /* b2*x2 */
+ L_sum = L_add(L_sum,HP50_Mode2_Mpy_32_16_fix(b1,x2)); /* b1*x1 */
+ x1 = shr(signal[1*stride], prescale);
+ L_sum = L_add(L_sum,HP50_Mode2_Mpy_32_16_fix(b2,x1)); /* b2*x0 */
+ L_sum = L_add(L_sum, HP50_Mpy_32_32_fix(mem[1],a2)); /* y2*a2 */
+ L_sum = L_add(L_sum, HP50_Mpy_32_32_fix(L_y2, a1)); /* y1*a1 */
+
+ L_y1 = L_shl(L_sum, HP20_COEFF_SCALE);
+ BASOP_SATURATE_ERROR_OFF
+ BASOP_SATURATE_WARNING_OFF
+ signal[1*stride] = round_fx(L_shl(L_y1, prescale));
+ BASOP_SATURATE_WARNING_ON
+
+ /* New we use a trick and toggle x1/x2 and L_y1/L_y2 to save a few cycles unrolling the loop by 2 */
+ FOR (i = 2; i < lg; i+=2)
+ {
+ /* y[i+0] = b2*x[i-2] + b1*x[i-1] + b2*x[i-0] + a2*y[i-2] + a1*y[i-1]; */
+ BASOP_SATURATE_ERROR_ON
+ L_sum = HP50_Mode2_Mpy_32_16_fix(b2,x2);
+ L_sum = L_add(L_sum,HP50_Mode2_Mpy_32_16_fix(b1,x1));
+ x2 = shr(signal[i*stride], prescale);
+ L_sum = L_add(L_sum,HP50_Mode2_Mpy_32_16_fix(b2,x2));
+ L_sum = L_add(L_sum, HP50_Mpy_32_32_fix(L_y2,a2));
+ L_sum = L_add(L_sum, HP50_Mpy_32_32_fix(L_y1,a1));
+
+ L_y2 = L_shl(L_sum, HP20_COEFF_SCALE);
+ BASOP_SATURATE_ERROR_OFF
+ BASOP_SATURATE_WARNING_OFF
+ signal[i*stride] = round_fx(L_shl(L_y2, prescale));
+ BASOP_SATURATE_WARNING_ON
+ /* y[i+1] = b2*x[i-1] + b1*x[i-0] + b2*x[i+1] + a2*y[i-1] + a1*y[i+0]; */
+ BASOP_SATURATE_ERROR_ON
+ L_sum = HP50_Mode2_Mpy_32_16_fix(b2,x1);
+ L_sum = L_add(L_sum,HP50_Mode2_Mpy_32_16_fix(b1,x2));
+ x1 = shr(signal[(i+1)*stride], prescale);
+ L_sum = L_add(L_sum,HP50_Mode2_Mpy_32_16_fix(b2,x1));
+ L_sum = L_add(L_sum, HP50_Mpy_32_32_fix(L_y1,a2));
+ L_sum = L_add(L_sum, HP50_Mpy_32_32_fix(L_y2,a1));
+
+ L_y1 = L_shl(L_sum, HP20_COEFF_SCALE);
+ BASOP_SATURATE_ERROR_OFF
+ BASOP_SATURATE_WARNING_OFF
+ signal[(i+1)*stride] = round_fx(L_shl(L_y1, prescale));
+ BASOP_SATURATE_WARNING_ON
+ }
+ /* update static filter memory from variables */
+ mem[0] = L_y2;
+ move32();
+ mem[1] = L_y1;
+ move32();
+ mem[2] = L_deposit_h(x2);
+ mem[3] = L_deposit_h(x1);
+
+
+ return;
+}
+
+
+void hp20(Word16 signal[], /* i/o: signal to filter any */
+ const Word16 stride, /* i : stride to be applied accessing signal */
+ const Word16 lg, /* i : length of signal (integer) Q0 */
+ Word32 mem[5], /* i/o: static filter memory with this layout: */
+ /* mem[0]: y[-2] (32-bit) */
+ /* mem[1]; y[-1] (32-bit) */
+ /* mem[2]: x[-2] << 16 */
+ /* mem[3]: x[-1] << 16 */
+ /* Note: mem[0..3] need to be scaled per frame */
+ /* mem[4]: states scale */
+ const Word32 sFreq) /* i : input sampling rate Q0 */
+{
+ Word32 a1, b1, a2, b2;
+ Word16 prescale, prescaleOld, diff;
+
+
+
+ prescale = getScaleFactor16(signal, lg);
+ prescaleOld = extract_l(mem[4]);
+ diff = norm_l(L_shl(mem[2], prescaleOld));
+ if (mem[2] != 0)
+ {
+ prescale = s_min(prescale, diff);
+ }
+ diff = norm_l(L_shl(mem[3], prescaleOld));
+ if (mem[3] != 0)
+ {
+ prescale = s_min(prescale, diff);
+ }
+ /* Take into account the left shift performed into the loop + 1 bit headroom*/
+ prescale = s_max(-12, sub(1+HP20_COEFF_SCALE, prescale));
+ IF (prescale != prescaleOld)
+ {
+ diff = sub(prescale, prescaleOld);
+ mem[0] = L_shr(mem[0], diff);
+ move32();
+ mem[1] = L_shr(mem[1], diff);
+ move32();
+ mem[2] = L_shr(mem[2], diff);
+ move32();
+ mem[3] = L_shr(mem[3], diff);
+ move32();
+ mem[4] = L_deposit_l(prescale);
+ }
+
+ IF ( EQ_32(sFreq,8000))
+ {
+ /* hp filter 20Hz at 3dB for 8000 Hz input sampling rate
+ [b,a] = butter(2, 20.0/4000.0, 'high');
+ b = [0.988954248067140 -1.977908496134280 0.988954248067140]
+ a = [1.000000000000000 -1.977786483776764 0.978030508491796]*/
+ a1 = 1061816033l/* 1.977786483776764 Q29*/; move32();
+ a2 = -525076131l/*-0.978030508491796 Q29*/; move32();
+ b1 = -1061881538l/*-1.977908496134280 Q29*/; move32();
+ b2 = 530940769l/* 0.988954248067140 Q29*/; move32();
+
+ }
+ ELSE IF ( EQ_32(sFreq,16000))
+ {
+ /* hp filter 20Hz at 3dB for 16000KHz sampling rate
+ [b,a] = butter(2, 20.0/8000.0, 'high');
+ b = [0.994461788958195 -1.988923577916390 0.994461788958195]
+ a = [1.000000000000000 -1.988892905899653 0.988954249933127] */
+ a1 = 1067778748l/* 1.988892905899653 Q29*/; move32();
+ a2 = -530940770l/*-0.988954249933127 Q29*/; move32();
+ b1 = -1067795215l/*-1.988923577916390 Q29*/; move32();
+ b2 = 533897608l/* 0.994461788958195 Q29*/; move32();
+
+ }
+ ELSE IF ( EQ_32(sFreq,32000))
+ {
+ /* hp filter 20Hz at 3dB for 32000KHz sampling rate
+ [b,a] = butter(2, 20.0/16000.0, 'high');
+ b = [0.997227049904470 -1.994454099808940 0.997227049904470]
+ a = [1.000000000000000 -1.994446410541927 0.994461789075954]*/
+ a1 = 1070760263l/* 1.994446410541927 Q29*/; move32();
+ a2 = -533897608l/*-0.994461789075954 Q29*/; move32();
+ b1 = -1070764392l/*-1.994454099808940 Q29*/; move32();
+ b2 = 535382196l/* 0.997227049904470 Q29*/; move32();
+ }
+ ELSE
+ {
+ assert (sFreq == 48000);
+ /* hp filter 20Hz at 3dB for 48000KHz sampling rate
+ [b,a] = butter(2, 20.0/24000.0, 'high');
+ b =[0.998150511190452 -1.996301022380904 0.998150511190452]
+ a =[1.000000000000000 -1.996297601769122 0.996304442992686]*/
+ a1 = 1071754114l/* 1.996297601769122 Q29*/; move32();
+ a2 = -534886875l/*-0.996304442992686 Q29*/; move32();
+ b1 = -1071755951l/*-1.996301022380904 Q29*/; move32();
+ b2 = 535877975l/* 0.998150511190452 Q29*/; move32();
+ }
+
+
+ filter_2nd_order(signal,
+ stride,
+ prescale,
+ lg,
+ mem,
+ a1,
+ a2,
+ b1,
+ b2);
+
+ return;
+}
+
+
+
+
diff --git a/lib_com/hq2_bit_alloc_fx.c b/lib_com/hq2_bit_alloc_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..802ffc0eb4433bbb19e409c7fc66a22c63c10b24
--- /dev/null
+++ b/lib_com/hq2_bit_alloc_fx.c
@@ -0,0 +1,914 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h"
+#include "prot_fx.h"
+#include "stl.h" /* required for wmc_tool */
+
+#define MIN_BITS_FIX 0 /* QRk=18 */
+#define HQ_16k40_BIT (HQ_16k40/50) /* 16400/50=328 */
+#define Qbf 14 /* Q value for bits_fact */
+#define C1_QRk (1< 0 )
+ {
+ be_sum_fx = add(be_sum_fx, y_index_fx[k]);
+ }
+ }
+ QBavg = 0;
+ move16();
+
+ /*Ravg = (float) be_sum/be_cnt;*/
+ Ravg_fx = 0;
+ move16();
+ QRavg = 0;
+ move16();
+ IF( be_cnt_fx != 0x0 )
+ {
+ exp_normn = norm_s(be_sum_fx);
+ exp_normn = sub(exp_normn, 1);
+ exp_normd = norm_s(be_cnt_fx);
+ Ravg_fx = div_s(shl(be_sum_fx, exp_normn), shl(be_cnt_fx, exp_normd));
+
+ Ravg_fx = shr(Ravg_fx, 2); /* safe shift */
+ QRavg = add(sub(exp_normn, exp_normd), 15-2);
+ }
+
+ enr_diffcnt_fx = 0;
+ move16();
+ th_5_fx = shl(5, QRavg);
+ FOR (j = 0; j < be_cnt_fx; j++)
+ {
+ if( GT_16(abs_s(sub(Ravg_fx, shl(y_index_fx[j], QRavg))), th_5_fx))
+ {
+ enr_diffcnt_fx = add(enr_diffcnt_fx, 1);
+ }
+ }
+
+ scale_fact_fx = 19661;
+ move16(); /* 0.60f 19660.8(Q15) */
+ if( enr_diffcnt_fx > 0 )
+ {
+ scale_fact_fx = 11468;
+ move16(); /* 0.35f 11468.8(Q15) */
+ }
+
+ /* Bits allocation to individual SB's in a group based on Band Energies */
+ FOR (j = 0; j < be_cnt_fx; j++)
+ {
+ Rcnt_fx = add(i, 1);
+
+ /* Ravg = (float) be_sum/Rcnt; */
+ exp_normn = norm_s(be_sum_fx);
+ exp_normn = sub(exp_normn, 1);
+ exp_normd = norm_s(Rcnt_fx);
+ Ravg_fx = div_s(shl(be_sum_fx, exp_normn), shl(Rcnt_fx, exp_normd));
+ Ravg_fx = shr(Ravg_fx, 2); /* safe shift */
+ QRavg = add(sub(exp_normn, exp_normd), 15-2);
+
+ if(be_sum_fx <= 0)
+ {
+ be_sum_fx = 1;
+ move16();
+ }
+
+ /* Bits_avg = (float) Bits/(be_sum+EPSILON); */
+ Bits_avg_fx = 0;
+ move16();
+ QBavg = 0;
+ move16();
+ IF ( Bits != 0 )
+ {
+ exp_normn = norm_s(Bits);
+ exp_normn = sub(exp_normn, 1);
+ exp_normd = norm_s(be_sum_fx);
+ Bits_avg_fx = div_s(shl(Bits, exp_normn), shl(be_sum_fx, exp_normd));
+ Bits_avg_fx = shr(Bits_avg_fx, 2); /* safe_shift */
+ QBavg = add(sub(exp_normn, exp_normd), 15-2);
+ }
+ FOR (k = 0; k <=i; k++)
+ {
+ IF(L_R_temp[k] > 0) /* Rtemp -> SWB_BWE_LR_QRk */
+ {
+ /* Allocate more bits to SB, if SB bandenergy is higher than average energy */
+ /* R_temp[k] = (float)( Bits_avg * y_index[k]+( scale_fact * (y_index[k] - Ravg))); */
+ L_temp1 = L_mult(Bits_avg_fx, y_index_fx[k]); /* QBavg+1 */
+ L_temp2 = L_mult(scale_fact_fx, sub(shl(y_index_fx[k], QRavg), Ravg_fx)); /* 15+QRavg+1 */
+ L_R_temp[k] = L_add(L_shr(L_temp1, sub(add(QBavg, 1), SWB_BWE_LR_QRk)), L_shr(L_temp2, sub(add(QRavg, 16), SWB_BWE_LR_QRk))); /* SWB_BWE_LR_QRk */
+ }
+ }
+ IF ( LT_32(L_R_temp[i], L_Bits_needed))
+ {
+ L_R_temp[i] = L_deposit_l(0);
+
+ p2aflags_fx_ptr[index_fx[i]] = 0;
+ move16();
+
+ /* be_sum -= y_index[i]; */
+ be_sum_fx = sub(be_sum_fx, y_index_fx[i]);
+
+ i = sub(i, 1);
+ }
+ ELSE
+ {
+ BREAK;
+ }
+ }
+
+ /* Rearrange the bit allocation to align with original */
+ FOR ( k = 0 ; k < band_num_fx; k++ )
+ {
+ j = index_fx[k];
+ move16();
+ L_R_ptr[j] = L_R_temp[k];
+ move32();
+ }
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * hq2_bit_alloc_har()
+ *
+ * Bit allocation mechanism for HQ_HARMONIC mode
+ *-------------------------------------------------------------------*/
+
+void hq2_bit_alloc_har_fx (
+ const Word32 *L_y, /* i : Qbe band energy of sub-vectors */
+ Word16 B_fx, /* i : Q0 number of available bits */
+ const Word16 N_fx, /* i : Q0 number of sub-vectors */
+ Word32 *L_Rsubband, /* o : QRk sub-band bit-allocation vector */
+ Word16 p2a_bands_fx, /* i : highfreq bands */
+ const Word32 L_core_brate, /* i : Q0 core bit rate */
+ Word16 p2a_flags_fx[], /* i/o: Q0 p2a_flags */
+ const Word16 band_width_fx[] /* i : Q0 table of band_width */
+)
+{
+ Word16 i, j, k;
+
+ Word32 L_norm_sum; /* Qbe */
+ Word32 L_Ravg_sub[GRP_SB]; /* Qbe */
+ Word32 L_temp_band_energy[BANDS_MAX]; /* Qbe */
+
+ Word16 j_fx, k_fx, Bits_grp_fx[GRP_SB];
+
+ Word32 L_temp_band_energydiff[BANDS_MAX];
+ Word16 G1_BE_DIFF_POS_fx; /* Q0 */
+ Word32 L_G1_BE_DIFF_VAL; /* Qbe Word32 */
+ Word16 final_gr_fact_pos_fx, gmax_range_fx[2], temp_fx;
+ Word16 bits_fact_fx, bits_fact1_fx; /* Q? */
+ Word16 grp_rngmax_fx[2] = {0};
+ Word16 index_fx[NB_SWB_SUBBANDS_HAR], y_index_fx[NB_SWB_SUBBANDS_HAR], esthf_bits_fx, grp_bit_avg_fx, harmonic_band_fx;
+ Word32 L_norm_sum_avg;
+ Word32 L_norm_diff; /* Qbe */
+ Word16 bits_allocweigh_fx; /* Q15 */
+ Word16 grp_bound_fx[5];
+ Word32 L_grp_thr[GRP_SB]; /* not require Word32 precission */
+ Word16 lf_hf_ge_r_fx; /* Q15 */
+ Word32 L_avg_enhf_en_diff; /* Qbe */
+
+ Word16 B_norm_fx;
+
+ Word32 L_temp, L_temp2;
+ Word16 exp, frac;
+
+ Word32 L_THR1, L_THR2, L_THR3;
+
+ Word16 exp_norm;
+ Word16 norm_sum_fx;
+ Word16 Qns; /* Q value for norm_sum_fx */
+ Word16 Inv_norm_sum_fx; /* 1/norm_sum */
+ Word16 QIns; /* Q value for Inv_norm_sum_fx */
+
+ Word16 exp_normn, exp_normd;
+ Word16 div_fx;
+
+ Word16 Inv_p2a_bands_fx;
+ Word16 QIpb;
+
+ Word16 exp_shift;
+
+ L_THR1 = L_shl(L_deposit_l(THR1), SWB_BWE_LR_QRk);
+ L_THR2 = L_shl(L_deposit_l(THR2), SWB_BWE_LR_QRk);
+ L_THR3 = L_shl(L_deposit_l(THR3), SWB_BWE_LR_QRk);
+
+ set16_fx(Bits_grp_fx, 0, GRP_SB);
+
+ /* Initialize subbands bits allocation vector based on harmonic bands */
+ harmonic_band_fx = add(sub(N_fx, p2a_bands_fx), 1);
+ /*printf("harmonic_band= %d %d\n", harmonic_band, harmonic_band_fx);*/
+ FOR (k = 0; k < N_fx; k++)
+ {
+ L_Rsubband[k] = (Word32)(C1_QRk);
+ move32(); /* Constant Value */
+ L_temp_band_energy[k] = L_y[k];
+ move32(); /* SWB_BWE_LR_Qbe */
+ }
+ final_gr_fact_pos_fx = 2;
+ move16();
+ bits_fact_fx = C1_Qbf;
+ move16();
+ bits_fact1_fx = C1_Qbf;
+ move16();
+
+ gmax_range_fx[0]= G1_RANGE;
+ move16();
+ gmax_range_fx[1]= G1G2_RANGE;
+ move16();
+
+ IF( EQ_32(L_core_brate, HQ_16k40))
+ {
+ gmax_range_fx[1] = add(gmax_range_fx[1], 2);
+ move16();
+ }
+
+ /* decide each group range, for grouping spectral coefficients */
+ grp_rngmax_fx[1] = 16;
+ move16();
+ grp_rngmax_fx[0] = 7;
+ move16();
+ temp_fx = 0;
+ move16();
+ FOR( i=0; i<2; i++ )
+ {
+ j_fx = gmax_range_fx[i];
+ move16();
+ k_fx = 0;
+ move16();
+ WHILE(GE_32(L_temp_band_energy[gmax_range_fx[i] - 1], L_temp_band_energy[j_fx]) && LT_16(j_fx, grp_rngmax_fx[i]) )
+ {
+ test();
+ k_fx = add(k_fx, 1);
+ j_fx = add(j_fx, 1);
+ }
+
+ temp_fx = k_fx;
+ move16();
+ IF( GT_16(temp_fx, 1))
+ {
+ FOR( temp_fx = 2; temp_fx <= k_fx ; )
+ {
+ IF( LT_32(L_temp_band_energy[gmax_range_fx[i]+temp_fx-1], L_temp_band_energy[gmax_range_fx[i]+temp_fx]))
+ {
+ BREAK;
+ }
+ ELSE IF( GE_32(L_temp_band_energy[gmax_range_fx[i]+temp_fx-1], L_temp_band_energy[gmax_range_fx[i]+temp_fx]))
+ {
+ temp_fx = add(temp_fx, 1);;
+ IF( GT_16(temp_fx, k_fx))
+ {
+ temp_fx = sub(temp_fx, 1);
+ BREAK;
+ }
+ }
+ }
+
+ gmax_range_fx[i] = add(gmax_range_fx[i], temp_fx);
+ move16();
+ }
+ ELSE
+ {
+ gmax_range_fx[i] = add(gmax_range_fx[i], temp_fx);
+ move16();
+ }
+ }
+
+ grp_bound_fx[0] = 0;
+ move16();
+ FOR(i=1; i 0x0L )
+ {
+ L_Ravg_sub[i] = L_add(L_Ravg_sub[i], L_temp_band_energy[j]);
+ move32();
+ }
+ }
+ }
+
+ L_temp_band_energydiff[0] = L_temp_band_energy[0];
+ move32();
+ FOR ( j = 1; j < harmonic_band_fx; j++ )
+ {
+ L_temp_band_energydiff[j]= L_abs(L_sub(L_temp_band_energy[j], L_temp_band_energy[j-1]));
+ move32();
+ }
+
+ G1_BE_DIFF_POS_fx = 0;
+ move16();
+ L_G1_BE_DIFF_VAL = L_deposit_l(0);
+
+ FOR(j=1; j< harmonic_band_fx; j++)
+ {
+ IF( GT_32(L_temp_band_energydiff[j], L_G1_BE_DIFF_VAL))
+ {
+ G1_BE_DIFF_POS_fx = j;
+ move16();
+ L_G1_BE_DIFF_VAL = L_temp_band_energydiff[j];
+ }
+ }
+
+ test();
+ test();
+ IF( LT_16(G1_BE_DIFF_POS_fx, gmax_range_fx[0] )&&G1_BE_DIFF_POS_fx>0)
+ {
+ final_gr_fact_pos_fx = 0;
+ move16();
+ }
+ ELSE IF ( GE_16(G1_BE_DIFF_POS_fx, gmax_range_fx[0])&<_16(G1_BE_DIFF_POS_fx,gmax_range_fx[1]))
+ {
+ final_gr_fact_pos_fx = 1;
+ move16();
+ }
+ ELSE
+ {
+ final_gr_fact_pos_fx = 2;
+ move16();
+ }
+
+ test();
+ IF( final_gr_fact_pos_fx == 0 || EQ_16(final_gr_fact_pos_fx, 1))
+ {
+ IF( EQ_32(L_core_brate, HQ_16k40 ))
+ {
+ bits_fact_fx = BITS_FACT_1p10;
+ move16(); /* 1.10f; */ /* G1 */
+ bits_fact1_fx = BITS_FACT_0p92;
+ move16(); /* 0.92f; */ /* G3 */
+ }
+ ELSE
+ {
+ bits_fact_fx = BITS_FACT_1p05;
+ move16(); /* 1.05f; */ /* G1 */
+ bits_fact1_fx = BITS_FACT_0p97;
+ move16(); /* 0.97f; */ /* G3 */
+ }
+ }
+ ELSE
+ {
+ IF( EQ_32(L_core_brate, HQ_16k40))
+ {
+ bits_fact_fx = BITS_FACT_0p97;
+ move16(); /* 0.97f; */ /* G1 */
+ bits_fact1_fx = BITS_FACT_1p00;
+ move16(); /* 1.00f; */ /* G3 */
+ }
+ ELSE
+ {
+ bits_fact_fx = BITS_FACT_0p92;
+ move16(); /* 0.92f; */ /* G1 */
+ bits_fact1_fx = BITS_FACT_1p00;
+ move16(); /* 1.00f; */ /* G3 */
+ }
+ }
+
+ j = sub(N_fx, harmonic_band_fx);
+ FOR ( i = 0; i < j; i++ )
+ {
+ y_index_fx[i] = extract_h(L_shl(L_temp_band_energy[harmonic_band_fx+i], sub(16, SWB_BWE_LR_Qbe)));
+ index_fx[i] = add(harmonic_band_fx, i);
+ move16();
+ }
+
+ reordvct_fx(y_index_fx, sub(N_fx, harmonic_band_fx), index_fx);
+
+ /* Log2 */
+ L_temp = L_deposit_l(band_width_fx[index_fx[0]]);
+ exp = norm_l(L_temp);
+ frac = Log2_norm_lc(L_shl(L_temp, exp));
+ exp = sub(30, exp);
+ L_temp = L_Comp(exp, frac);
+ /* ceil */
+ if( L_and(0x0000ffff, L_temp) > 0 )
+ {
+ L_temp = L_add(L_temp, 0x00010000);
+ }
+ esthf_bits_fx = extract_h(L_temp);
+
+ L_grp_thr[0] = L_THR1;
+ move32();
+ L_grp_thr[1] = L_THR2;
+ move32();
+ L_grp_thr[2] = L_THR3;
+ move32();
+ L_grp_thr[3] = L_shl(L_deposit_l(esthf_bits_fx), SWB_BWE_LR_QRk);
+ move16();
+
+ L_norm_sum = L_deposit_l(1);
+ FOR(i=0; i<3; i++)
+ {
+ L_norm_sum = L_add( L_norm_sum, L_Ravg_sub[i]);
+ }
+
+ /*reserve bits for HF coding */
+ L_temp = L_add(L_norm_sum, L_Ravg_sub[GRP_SB-1]);
+ exp_normn = norm_l(L_temp);
+ exp_normn = sub(exp_normn, 1);
+ exp_normd = norm_s(N_fx);
+
+ div_fx = div_l(L_shl(L_temp, exp_normn), shl(N_fx, exp_normd)); /* (Qbe+exp_normn)-(0+exp_normd)-1) */
+ L_norm_sum_avg = L_shr(L_deposit_h(div_fx), add(sub(exp_normn, exp_normd), 15)); /* -> Qbe */
+
+ exp_norm = norm_l(L_norm_sum);
+ norm_sum_fx = extract_h( L_shl(L_norm_sum, exp_norm) ); /* SWB_BWE_LR_Qbe+exp_norm-16 */
+ Qns = sub(add(SWB_BWE_LR_Qbe, exp_norm), 16);
+
+ Inv_norm_sum_fx = div_s( 0x4000 /* Q15 */ , norm_sum_fx );
+ QIns = sub(31, exp_norm); /* 14 - (14+exp_norm-16) + 15 */
+
+ grp_bit_avg_fx = div_s_ss(B_fx, GRP_SB); /* Q0 */
+
+ exp_normd = norm_s(p2a_bands_fx);
+ Inv_p2a_bands_fx = div_s(0x3fff, shl(p2a_bands_fx, exp_normd)); /* 14-exp_normd+15 */
+ QIpb = sub(29, exp_normd);
+
+ L_temp = L_shl(Mult_32_16(L_Ravg_sub[GRP_SB-1], Inv_p2a_bands_fx), sub(SWB_BWE_LR_Qbe, sub(QIpb,1)));
+ L_norm_diff = L_sub(L_temp, L_norm_sum_avg); /* Qbe */
+
+ L_temp = Mult_32_16(L_Ravg_sub[GRP_SB-1], sub(GRP_SB, 1)); /* Qbe+0+1 */
+ L_temp = Mult_32_16(L_temp, Inv_norm_sum_fx); /* Qbe+1+QIpb+1 */
+ lf_hf_ge_r_fx = round_fx(L_shl(L_temp, sub(15+16, sub(add(SWB_BWE_LR_Qbe, QIns),30))));
+
+ exp_normn = norm_s(norm_sum_fx);
+ exp_normn = sub(exp_normn, 1);
+ exp_normd = norm_s(harmonic_band_fx);
+
+ div_fx = div_s(shl(norm_sum_fx, exp_normn), shl(harmonic_band_fx, exp_normd));
+ L_avg_enhf_en_diff = L_sub(L_temp_band_energy[index_fx[0]], L_shl(L_deposit_h(div_fx), sub(sub(SWB_BWE_LR_Qbe, (add(Qns,sub(exp_normn,exp_normd)))),31))); /* Qbe - (Qns+exp_normn-(exp_normd)+15) -16 */
+
+ test();
+ IF(GT_16(lf_hf_ge_r_fx, 26214) && GT_32(L_avg_enhf_en_diff, (Word32)(8 << SWB_BWE_LR_Qbe))) /* 0.8=26214.4(Q15) 8.0f=131072(Qbe) */
+ {
+ bits_allocweigh_fx = 6554;
+ move16(); /* 0.2 6553.6(Q15) */
+ if(L_norm_diff < 0x0L)
+ {
+ bits_allocweigh_fx = 13107;
+ move16(); /* 0.4 13107.2(Q15) */
+ }
+
+ /*allocate bits*/
+ /*Bits_grp[GRP_SB-1] = (short)min((grp_bit_avg/p2a_bands + bits_allocweigh*norm_diff),10);*/
+ L_temp = L_mult(grp_bit_avg_fx, Inv_p2a_bands_fx); /* Q0+QIpb+1 */
+ L_temp2 = Mult_32_16(L_norm_diff, bits_allocweigh_fx); /* Qbe+Q15-15 */
+
+ L_temp = L_shr(L_temp, add(QIpb, 1));
+ L_temp = L_add(L_shl(L_temp,SWB_BWE_LR_Qbe), L_temp2);
+
+ Bits_grp_fx[GRP_SB-1] = extract_h(L_shl(L_temp, sub(16, SWB_BWE_LR_Qbe)));
+ Bits_grp_fx[GRP_SB-1] = s_min(Bits_grp_fx[GRP_SB-1], 10);
+ move16();
+
+ if( LT_16(Bits_grp_fx[GRP_SB-1], esthf_bits_fx))
+ {
+ Bits_grp_fx[GRP_SB-1] = 0;
+ move16();
+ }
+ B_fx = sub(B_fx, Bits_grp_fx[GRP_SB-1]);
+ }
+
+ exp_shift = sub(add(SWB_BWE_LR_Qbe, QIns), 47); /* (SWB_BWE_LR_Qbe+14+1+QIns-15-16) */
+ exp_norm = norm_s(B_fx);
+ B_norm_fx = shl(B_fx, exp_norm);
+ exp_shift = add(exp_shift, exp_norm);
+
+ IF( EQ_16(final_gr_fact_pos_fx, 1))
+ {
+ L_temp = Mult_32_16(L_Ravg_sub[1], extract_h(L_mult(bits_fact_fx, B_norm_fx)));
+ L_temp = Mult_32_16(L_temp, Inv_norm_sum_fx);
+ Bits_grp_fx[1] = extract_h(L_shr(L_temp, exp_shift));
+
+ L_temp = Mult_32_16(L_Ravg_sub[2], extract_h(L_mult(bits_fact1_fx, B_norm_fx)));
+ L_temp = Mult_32_16(L_temp, Inv_norm_sum_fx);
+ Bits_grp_fx[2] = extract_h(L_shr(L_temp, exp_shift));
+
+ Bits_grp_fx[0] = sub(sub(B_fx, Bits_grp_fx[1]), Bits_grp_fx[2]);
+ move16();
+ }
+ ELSE
+ {
+ L_temp = Mult_32_16(L_Ravg_sub[0], extract_h(L_mult(bits_fact_fx, B_norm_fx)));
+ L_temp = Mult_32_16(L_temp, Inv_norm_sum_fx);
+ Bits_grp_fx[0] = extract_h(L_shr(L_temp, exp_shift));
+
+ L_temp = Mult_32_16(L_Ravg_sub[2], extract_h(L_mult(bits_fact1_fx, B_norm_fx)));
+ L_temp = Mult_32_16(L_temp, Inv_norm_sum_fx);
+ Bits_grp_fx[2] = extract_h(L_shr(L_temp, exp_shift));
+
+ Bits_grp_fx[1] = sub(sub(B_fx, Bits_grp_fx[0]), Bits_grp_fx[2]);
+ move16();
+ }
+
+ IF( LT_16(Bits_grp_fx[2], THR2 ))
+ {
+ Bits_grp_fx[1] = add(Bits_grp_fx[1], Bits_grp_fx[2]);
+ move16();
+ Bits_grp_fx[2] = 0;
+ move16();
+ }
+
+ FOR(i=0; i 0)
+ {
+ Bits2indvsb_fx( L_temp_band_energy, grp_bound_fx[i], grp_bound_fx[i+1] , Bits_grp_fx[i], L_grp_thr[i], L_Rsubband, p2a_flags_fx);
+ }
+ ELSE
+ {
+ set32_fx(L_Rsubband+grp_bound_fx[i], 0x0L, sub(grp_bound_fx[i+1], grp_bound_fx[i]));
+ IF( EQ_16(i, GRP_SB-1))
+ {
+ set16_fx(p2a_flags_fx+grp_bound_fx[i], 0, sub(grp_bound_fx[i+1], grp_bound_fx[i]));
+ }
+ }
+ }
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * hq2_bit_alloc()
+ *
+ * HQ2 bit-allocation
+ *--------------------------------------------------------------------------*/
+
+Word32 hq2_bit_alloc_fx (
+ const Word32 L_band_energy[], /* i : band energy of each subband */
+ const Word16 bands, /* i : total number of subbands in a frame */
+ Word32 L_Rk[], /* i/o: Bit allocation/Adjusted bit alloc. */
+ Word16 *bit_budget_fx, /* i/o: bit bugdet */
+ Word16 *p2a_flags, /* i : HF tonal indicator */
+ const Word16 weight_fx, /* i : weight */
+ const Word16 band_width[], /* i : Sub band bandwidth */
+ const Word16 num_bits, /* i : available bits */
+ const Word16 hqswb_clas, /* i : HQ2 class information */
+ const Word16 bwidth, /* i : input bandwidth */
+ const Word16 is_transient /* i : indicator HQ_TRANSIENT or not */
+)
+{
+ Word16 j, k;
+ Word16 tmp;
+ Word16 bit_budget_norm_fx;
+
+ Word32 L_Rcalc, L_Ravg, L_Rcalc1;
+
+ Word16 exp_normn, exp_normd;
+
+ Word16 Rcnt_fx;
+
+ Word16 div_fx;
+ Word16 Qdiv;
+
+ Word32 L_tmp;
+ Word16 tmp_fx;
+
+ Word32 L_maxxy;
+ Word16 maxdex_fx;
+ Word32 L_dummy;
+
+ Word16 bit_budget_temp_fx;
+
+ Word16 negflag;
+
+ Word32 L_THR1, L_THR2, L_THR3;
+
+ L_THR1 = L_shl(L_deposit_l(THR1), SWB_BWE_LR_QRk);
+ L_THR2 = L_shl(L_deposit_l(THR2), SWB_BWE_LR_QRk);
+ L_THR3 = L_shl(L_deposit_l(THR3), SWB_BWE_LR_QRk);
+
+ /* Init Rk to non-zero values for bands to be allocated bits */
+ IF( LE_16(num_bits, HQ_16k40_BIT))
+ {
+ set32_fx( L_Rk, (Word32)(C1_QRk), bands); /* 1< 0 )
+ {
+ L_Ravg = L_add(L_Ravg, L_shl(L_band_energy[k], sub(SWB_BWE_LR_QRk, SWB_BWE_LR_Qbe))); /* SWB_BWE_LR_QRk-SWB_BWE_LR_Qbe */
+ Rcnt_fx = add(Rcnt_fx, 1);
+ }
+ }
+ /* Ravg Qband_energy */
+
+ /*L_Ravg /= Rcnt; */
+ exp_normd = norm_l(L_Ravg);
+ exp_normd = sub(exp_normd, 1);
+ exp_normn = norm_s(Rcnt_fx);
+
+ tmp = shl(Rcnt_fx, exp_normn);
+ tmp = s_max(tmp,1);
+ IF ( L_Ravg > 0 )
+ {
+ div_fx = div_l(L_shl(L_Ravg, exp_normd), tmp); /* Qdiv = 14+exp_normd-(exp_normn)-1 */
+ }
+ ELSE
+ {
+ div_fx = div_l(L_shl(L_abs(L_Ravg), exp_normd), tmp); /* Qdiv = 14+exp_normd-(exp_normn)-1 */
+ div_fx = negate(div_fx);
+ }
+
+ Qdiv = sub(sub(add(SWB_BWE_LR_QRk, exp_normd), exp_normn), 1);
+
+ L_Ravg = L_shr(L_deposit_l(div_fx), sub(Qdiv, SWB_BWE_LR_QRk));
+
+ exp_normd = norm_s(*bit_budget_fx);
+ exp_normd = sub(exp_normd, 1);
+ bit_budget_norm_fx = shl(*bit_budget_fx, exp_normd);
+ div_fx = 0;
+ move16();
+
+ test();
+ IF( bit_budget_norm_fx > 0 && LT_16(bit_budget_norm_fx, tmp))
+ {
+ div_fx = div_s(bit_budget_norm_fx, tmp);
+ }
+ Qdiv = add(sub(exp_normd, exp_normn), 15);
+ FOR (k = 0; k < bands; k++)
+ {
+ IF ( L_Rk[k] > 0)
+ {
+ /*Rk[k] = ((float) *bit_budget / Rcnt + weight * (band_energy[k] - Ravg)); */
+
+ L_tmp = Mult_32_16(L_sub(L_shl(L_band_energy[k], sub(SWB_BWE_LR_QRk, SWB_BWE_LR_Qbe)), L_Ravg), weight_fx); /* SWB_BWE_LR_QRk + Q13 - 15 */
+ L_tmp = L_shl(L_tmp, 2); /* -> SWB_BWE_LR_QRk */
+
+ L_Rk[k] = L_add(L_shr(L_deposit_l(div_fx), sub(Qdiv, SWB_BWE_LR_QRk)) , L_tmp);
+ move32();
+ }
+ }
+
+ negflag = 0;
+ move16();
+ L_Rcalc = L_deposit_l(0);
+ FOR (k = 0; k < bands; k++)
+ {
+ IF ( LT_32(L_Rk[k], MIN_BITS_FIX))
+ {
+ L_Rk[k] = L_deposit_l(0);
+ negflag = 1;
+ move16();
+ }
+ L_Rcalc = L_add( L_Rcalc , L_Rk[k]); /*SWB_BWE_LR_QRk */
+ }
+
+ /* prune noiselike bands with low allocation */
+ test();
+ IF ( LE_16(num_bits, HQ_16k40_BIT)&&negflag==0)
+ {
+ L_maxxy = L_deposit_l(0);
+ maxdex_fx = -1;
+ move16();
+ L_Rcalc = L_deposit_l(0);
+
+ /* find worst under-allocation */
+ FOR (k = sub(bands, 1); k >= 0; k--)
+ {
+ tmp_fx = s_min( band_width[k], s_max(12, shr( band_width[k], 2)));
+ L_dummy = L_sub(L_shl(L_deposit_l(tmp_fx), SWB_BWE_LR_QRk), L_Rk[k]) ; /*SWB_BWE_LR_QRk */
+ test();
+ test();
+ IF ( p2a_flags[k] == 0 && GT_32(L_dummy, L_maxxy)&&L_Rk[k]>0)
+ {
+ maxdex_fx = k;
+ move16();
+ L_maxxy = L_dummy; /*SWB_BWE_LR_QRk */
+ move32();
+ }
+ }
+
+ /* prune worst allocation and recalculate total allocation */
+ if ( GT_16(maxdex_fx, -1))
+ {
+ L_Rk[maxdex_fx] = L_deposit_l(0);
+ }
+ FOR (k = 0; k < bands; k++)
+ {
+ L_Rcalc = L_add(L_Rcalc, L_Rk[k]); /*SWB_BWE_LR_QRk */
+ }
+ }
+ test();
+ test();
+ IF ( EQ_32(L_Rcalc, L_Rcalc1)&&EQ_16(bwidth,SWB))
+ {
+ /* Reallocate bits to individual subbands for HQ_NORMAL mode */
+ /* if bits allocated to subbands areless than predefined threshold */
+ test();
+ IF( EQ_16(hqswb_clas, HQ_NORMAL)&<_16(num_bits,HQ_16k40_BIT))
+ {
+ L_dummy = L_deposit_l(0);
+ FOR( k = 0; k < bands; k++ )
+ {
+ test();
+ test();
+ test();
+ test();
+ test();
+ IF( LT_16(k, 11)&<_32(L_Rk[k],L_THR1))
+ {
+ L_Rk[k] = L_deposit_l(0);
+ }
+ ELSE IF( GE_16(k, 11)&<_16(k,16)&<_32(L_Rk[k],L_THR2))
+ {
+ L_Rk[k] = L_deposit_l(0);
+ }
+ ELSE if( GE_16(k, 16)&<_16(k,bands)&<_32(L_Rk[k],L_THR3))
+ {
+ L_Rk[k] = L_deposit_l(0);
+ }
+
+ L_dummy = L_add(L_dummy, L_Rk[k]);
+ }
+
+ IF( EQ_32(L_dummy, L_Rcalc ))
+ {
+ test();
+ IF( EQ_16(hqswb_clas, HQ_NORMAL)&<_16(num_bits,HQ_16k40_BIT))
+ {
+ bit_budget_temp_fx = *bit_budget_fx;
+ move16();
+ FOR( k=0; kBER_detect */
+ }
+ ELSE IF( EQ_16(bit_budget_temp_fx, *bit_budget_fx ))
+ {
+ BREAK;
+ }
+ }
+ ELSE
+ {
+ BREAK;
+ }
+ }
+ }
+ ELSE
+ {
+ BREAK;
+ }
+ }
+ ELSE IF ( EQ_32(L_Rcalc, L_Rcalc1 )&&NE_16(bwidth,SWB))
+ {
+ BREAK;
+ }
+
+ L_Rcalc1 = L_Rcalc;
+ move32();
+
+ }
+
+ return L_Rcalc;
+}
+
diff --git a/lib_com/hq2_core_com_fx.c b/lib_com/hq2_core_com_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..8fd73d140b04b8f28e6b84274ce1eefe27cc11a5
--- /dev/null
+++ b/lib_com/hq2_core_com_fx.c
@@ -0,0 +1,770 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h"
+#include "cnst_fx.h" /* Audio core constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h"
+#include "stl.h"
+#include "basop_mpy.h"
+
+/*--------------------------------------------------------------------------*
+ * mdct_spectrum_denorm()
+ *
+ *
+ *--------------------------------------------------------------------------*/
+
+void mdct_spectrum_denorm_fx(
+ const Word16 inp_vector[], /* i : Q0 : */
+ Word32 L_y2[], /* i/o : Qs : decoded spectrum */
+ const Word16 band_start[], /* i : Q0 : table of start freq for every subband */
+ const Word16 band_end[], /* i : Q0 : table of end freq for every subband */
+ const Word16 band_width[], /* i : Q0 : table of bandwidth for every subband */
+ const Word32 L_band_energy[], /* i : Qbe : band energy */
+ const Word16 npulses[], /* i : Q0 : number of coded spectrum */
+ const Word16 bands, /* i : Q0 : number of subbands */
+ const Word16 ld_slope_fx, /* i : Q15 : */
+ const Word16 pd_thresh_fx /* i : Q15 : */
+)
+{
+ Word16 i, k;
+ Word32 L_Eyy;
+ Word32 L_tmp, L_temp;
+ Word16 temp_fx, temp_lo_fx, temp_hi_fx;
+ Word32 L_inp_tmp[L_FRAME48k];
+ Word16 exp_norm;
+ Word16 exp_safe;
+ Word16 exp_normn, exp_normd;
+
+ Word16 pd_fx;
+ Word16 Qpd;
+
+ Word16 div_pd_fx;
+ Word16 Qdivpd;
+ Word32 L_div_pd;
+
+ Word16 frac, exp;
+
+ Word16 gain_tweak_fx;
+ Word16 Qtweak;
+
+ Word16 exp_shift;
+
+ Word16 QEyy;
+ Word16 pow_fx;
+ Word16 Qpow;
+ Word16 Qdiv;
+ Word16 Qgamma;
+ Word16 gamma_fx;
+
+ Word16 cond_fx;
+
+ exp_safe = 4; /* safe bit for overflow */
+
+ FOR (k = 0; k < bands; k++)
+ {
+ L_tmp = L_deposit_l(0);
+ FOR (i = band_start[k]; i <= band_end[k]; i++)
+ {
+ L_inp_tmp[i] = L_mult(inp_vector[i], inp_vector[i]);
+ move32(); /* Q0+Q0+1 */
+ L_tmp = L_or(L_tmp, L_inp_tmp[i]);
+ }
+ exp_norm = norm_l(L_tmp);
+ exp_norm = sub(exp_norm, exp_safe);
+
+ L_Eyy = L_deposit_l(0);
+ FOR (i = band_start[k]; i <= band_end[k]; i++)
+ {
+ /*Eyy += (float) inp_vector[i] * inp_vector[i]; */
+ L_Eyy = L_add(L_Eyy, L_shl(L_inp_tmp[i], exp_norm)); /* Q1+exp_norm */
+ }
+ QEyy = add(1, exp_norm);
+
+ IF ( L_Eyy > 0x0L )
+ {
+ /* Set gamma to be pulse gain which results in perfect quantized subband energy */
+ /*gamma = (float) sqrt (pow (2.0f, band_energy[k]) / Eyy); */
+
+ /* Pow part (pow(2.0f, band_energy) ) */
+ L_temp = L_shr(L_band_energy[k], sub(SWB_BWE_LR_Qbe, 16));
+ temp_lo_fx = L_Extract_lc(L_temp, &temp_hi_fx);
+ Qpow = sub(14, temp_hi_fx);
+ pow_fx = extract_l(Pow2(14, temp_lo_fx)); /* Qpow */
+
+ /* Div part ( pow (2.0f, band_energy[i])/Eyy ) */
+ exp_normn = norm_s(pow_fx);
+ exp_normn = sub(exp_normn, 1);
+ exp_normd = norm_l(L_Eyy);
+ temp_fx = div_s( shl( pow_fx, exp_normn), extract_h(L_shl(L_Eyy, exp_normd)));
+ Qdiv = add(sub(add(Qpow, exp_normn) , add(QEyy, exp_normd)), 31);
+
+ exp_norm = norm_s(temp_fx);
+ temp_fx = shl(temp_fx, exp_norm);
+ Qdiv = add(Qdiv, exp_norm);
+
+ /* Sqrt part sqrt(pow (2.0f, band_energy[i])/Eyy) */
+ Qgamma = add(Qdiv, 16);
+ IF ( s_and(Qdiv, 1) == 0 ) /* Qdiv % 2 == 0 */
+ {
+ L_temp = Sqrt_l(L_shr(L_deposit_h(temp_fx),1), &exp_norm);
+ L_temp = L_shr(L_temp, exp_norm);
+ Qgamma = sub(shr(Qgamma, 1), 1);
+ gamma_fx = round_fx(L_temp);
+ }
+ ELSE
+ {
+ L_temp = Sqrt_l(L_deposit_h(temp_fx), &exp_norm);
+ L_temp = L_shr(L_temp, exp_norm);
+ Qgamma = shr(Qgamma, 1);
+ gamma_fx = round_fx(L_temp);
+ }
+
+ /* Adjust gamma based on pulse density (0 bit MSE gain estimator) */
+ /*pd = (float) npulses[k] / band_width[k]; */
+ exp_normn = norm_s(npulses[k]);
+ exp_normn = sub(exp_normn, 1);
+ exp_normd = norm_s(band_width[k]);
+ pd_fx = div_s(shl(npulses[k],exp_normn), shl(band_width[k], exp_normd));
+ Qpd = add(sub(exp_normn, exp_normd), 15);
+
+ cond_fx = sub(shl(pd_fx, sub(15, Qpd)), pd_thresh_fx/*Q15*/);
+ Overflow = 0;
+ move16(); /* allow overflow happen. */
+ IF ( cond_fx < 0 )
+ {
+ /*gain_tweak = (float) pow (2.0f, (ld_slope * log2_f (pd / pd_thresh))); */
+ /* Div part */
+ exp_normn = norm_s(pd_fx);
+ exp_normn = sub(exp_normn, 1);
+ exp_normd = norm_s(pd_thresh_fx);
+ div_pd_fx = div_s(shl(pd_fx, exp_normn), shl(pd_thresh_fx, exp_normd)); /* Qpd+exp_normn - (15 + exp_normd) + 15 */
+ Qdivpd = add(sub(add(Qpd, exp_normn), add(15, exp_normd)), 15);
+
+ /* Log2 part */
+ exp_norm = norm_s(div_pd_fx);
+ L_div_pd = L_deposit_h(shl(div_pd_fx, exp_norm));
+ Qdivpd = add(add(Qdivpd, exp_norm), 16);
+
+ frac = Log2_norm_lc(L_div_pd);
+ exp = sub(30, Qdivpd);
+ L_tmp = L_Comp(exp, frac); /* Q16 */
+
+ /* Mult part */
+ L_tmp = Mpy_32_16_1(L_tmp, ld_slope_fx);
+
+ /* Pow part */
+ temp_lo_fx = L_Extract_lc(L_tmp, &temp_hi_fx);
+ Qtweak = sub(14, temp_hi_fx);
+ gain_tweak_fx = extract_l(Pow2(14, temp_lo_fx));
+
+ /*gamma *= gain_tweak; */
+ L_tmp = L_mult(gamma_fx, gain_tweak_fx); /* Qgamma+Qtweak+1 */
+ exp_norm = norm_l(L_tmp);
+ gamma_fx = round_fx(L_shl(L_tmp, exp_norm));
+ Qgamma = sub(add(add(Qgamma, Qtweak), exp_norm), 15);/*Qgamma+Qtweak+1+exp_norm-16; */
+ }
+
+ exp_shift = sub(SWB_BWE_LR_Qs-1, Qgamma);
+ FOR (i = band_start[k]; i <= band_end[k]; i++)
+ {
+ /*y2[i] = gamma * inp_vector[i]; */
+ L_tmp = L_mult(gamma_fx, (Word16)inp_vector[i]); /* Qgamma+0+1=Qgamma+1 */
+ L_y2[i] = L_shl(L_tmp, exp_shift);
+ move32();
+ }
+ }
+ }
+
+ return;
+}
+/*==========================================================================*/
+/* FUNCTION : void hq2_core_configure_fx() */
+/*--------------------------------------------------------------------------*/
+/* PURPOSE : */
+/*--------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/*--------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* Word16 *qint o: Q13 */
+/* Word16 *eref o: Q10 */
+/* Word16 *bit_alloc_weight o: Q13 */
+/* Word16 *p2a_th o: Q11 */
+/* Word16 *pd_thresh o: Q15 */
+/* Word16 *ld_slope o: Q15 */
+/* Word16 *ni_coef o: Q14 */
+/*--------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/*--------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*--------------------------------------------------------------------------*/
+/* CALLED FROM : */
+/*==========================================================================*/
+
+void hq2_core_configure_fx (
+ const Word16 frame_length,
+ const Word16 num_bits,
+ const Word16 is_transient,
+ Word16 *bands,
+ Word16 *length,
+ Word16 band_width[],
+ Word16 band_start[],
+ Word16 band_end[],
+ Word32 *L_qint,
+ Word16 *eref,
+ Word16 *bit_alloc_weight,
+ Word16 *gqlevs,
+ Word16 *Ngq,
+ Word16 *p2a_bands,
+ Word16 *p2a_th,
+ Word16 *pd_thresh,
+ Word16 *ld_slope,
+ Word16 *ni_coef,
+ Word32 L_bwe_br
+)
+{
+ const Xcore_Config_fx *xcore_config_fx;
+
+ Word16 i, k;
+ Word16 bands_sh;
+
+ xcore_config_fx = &xcore_config_32kHz_013200bps_long_fx; /* default set for VC Warning */
+
+ IF ( EQ_16(frame_length, L_FRAME8k))
+ {
+ IF( is_transient )
+ {
+ IF ( LE_16(num_bits, ACELP_7k20 / 50))
+ {
+ xcore_config_fx = &xcore_config_8kHz_007200bps_short_fx;
+ }
+ ELSE IF ( LE_16(num_bits, ACELP_8k00 / 50))
+ {
+ xcore_config_fx = &xcore_config_8kHz_008000bps_short_fx;
+ }
+ ELSE IF ( LE_16(num_bits, ACELP_13k20 / 50))
+ {
+ xcore_config_fx = &xcore_config_8kHz_013200bps_short_fx;
+ }
+ ELSE
+ {
+ xcore_config_fx = &xcore_config_8kHz_016400bps_short_fx;
+ }
+ }
+ ELSE
+ {
+ IF ( LE_16(num_bits, ACELP_7k20 / 50))
+ {
+ xcore_config_fx = &xcore_config_8kHz_007200bps_long_fx;
+ }
+ ELSE IF ( LE_16(num_bits, ACELP_8k00 / 50))
+ {
+ xcore_config_fx = &xcore_config_8kHz_008000bps_long_fx;
+ }
+ ELSE IF ( LE_16(num_bits, ACELP_13k20 / 50))
+ {
+ xcore_config_fx = &xcore_config_8kHz_013200bps_long_fx;
+ }
+ ELSE
+ {
+ xcore_config_fx = &xcore_config_8kHz_016400bps_long_fx;
+ }
+ }
+ }
+ ELSE IF ( EQ_16(frame_length, L_FRAME16k))
+ {
+ IF (is_transient)
+ {
+ IF ( LE_16(num_bits, ACELP_13k20 / 50))
+ {
+ xcore_config_fx = &xcore_config_16kHz_013200bps_short_fx;
+ move16();
+ }
+ ELSE if ( LE_16(num_bits, ACELP_16k40 / 50))
+ {
+ xcore_config_fx = &xcore_config_16kHz_016400bps_short_fx;
+ move16();
+ }
+ }
+ ELSE
+ {
+ IF ( LE_16(num_bits, ACELP_13k20 / 50))
+ {
+ xcore_config_fx = &xcore_config_16kHz_013200bps_long_fx;
+ move16();
+ }
+ ELSE if ( LE_16(num_bits, ACELP_16k40 / 50))
+ {
+ xcore_config_fx = &xcore_config_16kHz_016400bps_long_fx;
+ move16();
+ }
+ }
+ }
+ ELSE /* (frame_length == SWB) */
+ {
+ IF (is_transient)
+ {
+ IF ( LE_32(L_bwe_br, ACELP_13k20))
+ {
+ xcore_config_fx = &xcore_config_32kHz_013200bps_short_fx;
+ move16();
+ }
+ ELSE if ( LE_32(L_bwe_br, ACELP_16k40))
+ {
+ xcore_config_fx = &xcore_config_32kHz_016400bps_short_fx;
+ move16();
+ }
+ }
+ ELSE
+ {
+ IF ( LE_32(L_bwe_br, ACELP_13k20))
+ {
+ xcore_config_fx = &xcore_config_32kHz_013200bps_long_fx;
+ move16();
+ }
+ ELSE if ( LE_32(L_bwe_br, ACELP_16k40))
+ {
+ xcore_config_fx = &xcore_config_32kHz_016400bps_long_fx;
+ move16();
+ }
+ }
+ }
+
+ *bands = xcore_config_fx->bands;
+ move16();
+ *length = xcore_config_fx->bw;
+ move16();
+ *L_qint = xcore_config_fx->L_qint;
+ move32();
+
+ *eref = xcore_config_fx->eref;
+ move16();
+ *bit_alloc_weight = xcore_config_fx->bit_alloc_weight;
+ move16();
+ *gqlevs = xcore_config_fx->gqlevs;
+ move16();
+ *Ngq = xcore_config_fx->Ngq;
+ move16();
+
+ *p2a_bands = xcore_config_fx->p2a_bands;
+ move16();
+ *p2a_th = xcore_config_fx->p2a_th;
+ move16();
+
+ *pd_thresh = xcore_config_fx->pd_thresh;
+ move16();
+ *ld_slope = xcore_config_fx->ld_slope;
+ move16();
+ *ni_coef = xcore_config_fx->ni_coef;
+ move16();
+
+ /*mvs2s_fx (xcore_config_fx->band_width, band_width, *bands); */
+ Copy(xcore_config_fx->band_width, band_width, *bands);
+
+ /* Expand band_width[] table for short windows */
+ IF (is_transient)
+ {
+ bands_sh = *bands;
+ move16();
+ *bands = shl(bands_sh,2);
+ *length = shl(*length, 2);
+
+ FOR (i = 1; i <= 3; i++)
+ {
+ FOR (k = 0; k < bands_sh; k++)
+ {
+ band_width[i * bands_sh + k] = band_width[k];
+ move16();
+ }
+ }
+ }
+
+ /* Formulate band_start and band_end tables from band_width table */
+ band_start[0] = 0;
+ move16();
+ band_end[0] = sub(band_width[0], 1);
+ move16();
+ FOR (k = 1; k < *bands; k++)
+ {
+ band_start[k] = add( band_start[k - 1] , band_width[k - 1]);
+ move16();
+ band_end[k] = sub(add( band_start[k] , band_width[k]) , 1);
+ move16();
+ }
+
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * reverse_transient_frame_energies()
+ *
+ *
+ *--------------------------------------------------------------------------*/
+
+void reverse_transient_frame_energies_fx(
+ Word32 L_band_energy[], /* o : Q14 : band energies */
+ const Word16 bands /* i : Q0 : number of bands */
+)
+{
+ Word16 k, k1, k2;
+ Word32 L_be;
+ Word16 bands_2, bands_4, bands_8;
+ Word32 *p_be1, *p_be2;
+
+ bands_2 = shr(bands, 1);
+ bands_4 = shr(bands, 2);
+ bands_8 = shr(bands, 3);
+
+ k1 = bands_4;
+ k2 = sub(bands_2, 1);
+ p_be1 = &L_band_energy[k1];
+ p_be2 = &L_band_energy[k2];
+ FOR( k = 0; k < bands_8; k++ )
+ {
+ L_be = *p_be1;
+ move32();
+ *p_be1 = *p_be2;
+ move32();
+ *p_be2 = L_be;
+ move32();
+ p_be1++;
+ p_be2--;
+ }
+
+ k1 = sub(bands, bands_4); /* 3*bands/4 */
+ k2 = sub(bands, 1);
+ p_be1 = &L_band_energy[k1];
+ p_be2 = &L_band_energy[k2];
+ FOR( k = 0; k < bands_8; k++ )
+ {
+ L_be = *p_be1;
+ move32();
+ *p_be1 = *p_be2;
+ move32();
+ *p_be2 = L_be;
+ move32();
+ p_be1++;
+ p_be2--;
+ }
+
+ return;
+}
+
+
+/*--------------------------------------------------------------------------*
+ * spt_shorten_domain_pre()
+ *
+ * Compute shorten subband if previous frame has spectral peak.
+ *--------------------------------------------------------------------------*/
+
+void spt_shorten_domain_pre_fx(
+ const Word16 band_start[], /* i: Starting position of sub band */
+ const Word16 band_end[], /* i: End position of sub band */
+ const Word16 prev_SWB_peak_pos[], /* i: Spectral peak */
+ const Word16 BANDS, /* i: total number of bands */
+ const Word32 L_bwe_br, /* i: bitrate information */
+ Word16 new_band_start[], /* o: Starting position of new shorten sub band */
+ Word16 new_band_end[], /* o: End position of new shorten sub band */
+ Word16 new_band_width[] /* o: new sub band bandwidth */
+)
+{
+ Word16 j;
+ Word16 k;
+ Word16 kpos;
+
+ Word16 new_band_width_half;
+ const Word16 *p_bw_SPT_tbl; /* pointer of bw_SPT_tbl */
+
+ p_bw_SPT_tbl = bw_SPT_tbl[0];
+ if( EQ_32(L_bwe_br, HQ_16k40))
+ {
+ p_bw_SPT_tbl = bw_SPT_tbl[1];
+ }
+
+ kpos = 0;
+ j = 0;
+ move16();
+ FOR(k=sub(BANDS,SPT_SHORTEN_SBNUM); k0)
+ {
+ exp = norm_s(band_width[k_sort[k]]);
+ tmp = shl(band_width[k_sort[k]],exp);/*Q(exp) */
+ tmp = div_s(16384,tmp);/*Q(15+14-exp = 29-exp) */
+ L_tmp = Mult_32_16(Rk_sort[k],tmp);/* Q(16+29-exp-15 = 30-exp) */
+ tmp = sub(18,exp);
+ ever_sort[k] = extract_l(L_shr(L_tmp,tmp));/*Q12 */
+ IF(LT_16(ever_sort[k],ever_temp))
+ {
+ ever_temp = ever_sort[k];
+ move16();
+ k2 = k;
+ move16();
+ }
+ }
+ }
+ }
+
+ k_num[0] = k2;
+ IF(EQ_16(k_sort[k2],sub(BANDS,1)))
+ {
+ FOR (k = 0; k < BANDS; k++)
+ {
+ if(EQ_16(k_sort[k],sub(k_sort[k2],1)))
+ {
+ k_num[1] = k;
+ move16();
+ }
+ }
+ }
+ ELSE IF(k_sort[k2] == 0)
+ {
+ FOR (k = 0; k < BANDS; k++)
+ {
+ if(EQ_16(k_sort[k],add(k_sort[k2],1)))
+ {
+ k_num[1] = k;
+ move16();
+ }
+ }
+ }
+ ELSE
+ {
+ IF ( LT_32( Rk[sub(k_sort[k2],1)],Rk[add(k_sort[k2],1)] ))
+ {
+ FOR (k = 0; k < BANDS; k++)
+ {
+ if(EQ_16(k_sort[k],sub(k_sort[k2],1)))
+ {
+ k_num[1] = k;
+ move16();
+ }
+ }
+ }
+ ELSE
+ {
+ FOR (k = 0; k < BANDS; k++)
+ {
+ if(EQ_16(k_sort[k],add(k_sort[k2],1)))
+ {
+ k_num[1] = k;
+ move16();
+ }
+ }
+ }
+ }
+}
diff --git a/lib_com/hq2_noise_inject_fx.c b/lib_com/hq2_noise_inject_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..b6de4103e92697904a6581429c84d36b2efd1b90
--- /dev/null
+++ b/lib_com/hq2_noise_inject_fx.c
@@ -0,0 +1,618 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h"
+#include "stl.h"
+#include "prot_fx.h"
+#include "math_op.h"
+#include "math_32.h"
+#include "oper_32b.h"
+#include "move.h"
+#include "count.h"
+
+/*--------------------------------------------------------------------------*
+ * hq2_noise_inject()
+ *
+ * HQ2 noise injection for WB signals
+ *--------------------------------------------------------------------------*/
+void hq2_noise_inject_fx(
+ Word32 L_y2[],
+ const Word16 band_start[],
+ const Word16 band_end[],
+ const Word16 band_width[],
+ Word32 Ep_fx[],
+ Word32 Rk_fx[],
+ const Word16 npulses[],
+ Word16 ni_seed,
+ const Word16 bands,
+ const Word16 ni_start_band,
+ const Word16 bw_low,
+ const Word16 bw_high,
+ const Word32 enerL_fx,
+ const Word32 enerH_fx,
+ Word32 last_ni_gain_fx[],
+ Word16 last_env_fx[],
+ Word16 *last_max_pos_pulse,
+ Word16 *p2a_flags,
+ Word16 p2a_bands,
+ const Word16 hqswb_clas,
+ const Word16 bwidth,
+ const Word32 bwe_br
+)
+{
+ Word32 L_tmp,L_tmp2,L_tmp2x,L_tmp3,L_tmp1;
+ Word16 exp,exp2,Q_speech;
+ Word16 pd_fx[BANDS_MAX], rand_fx, peak_fx[BANDS_MAX], fac_fx;
+
+ Word16 tmp,tmpx,tmp1,tmp2,tmp3,tmp4,Q_env_fx[BANDS_MAX],Q_Ep_fx[BANDS_MAX];
+
+ Word16 Qs=SWB_BWE_LR_Qs;
+ Word32 env_fx[BANDS_MAX];
+ Word16 env_fx2[BANDS_MAX];
+ Word32 ni_gain_fx[BANDS_MAX];
+ Word16 y2hat_fx[L_FRAME48k];
+
+ Word16 i, j, k, ni_end_band, satur, count[BANDS_MAX], max_pos_pulse, pos;
+ Word16 sb = bands;
+
+ satur = 0;
+ move16();
+
+ FOR(i = 0 ; i < bands; i++)
+ {
+ Ep_fx[i] = L_shl(Ep_fx[i], 6);/* Q-6 -> Q0 */ move32();
+ }
+
+ tmp = add(band_end[bands-1], 1);
+ FOR (k = 0; k < tmp; k++)
+ {
+ y2hat_fx[k] = (Word16)L_min(L_max(L_shr(L_y2[k],Qs),-32768),32767);
+ move16(); /* Extract_l or something else is missing here */
+ }
+
+ test();
+ test();
+ test();
+ test();
+ IF( (EQ_16(hqswb_clas,HQ_HARMONIC)||EQ_16(hqswb_clas,HQ_NORMAL))&&(EQ_32(bwe_br,HQ_16k40)||EQ_32(bwe_br,HQ_13k20))&&EQ_16(bwidth,SWB))
+ {
+ sb = 17;
+ move16();
+ if( EQ_32(bwe_br,HQ_16k40))
+ {
+ sb = 19;
+ move16();
+ }
+ }
+
+ /* calculate the envelopes/ the decoded peak coeff./number of the decoded coeff./ the last subbands of the bit-allocated/saturation of bit-allocation */
+ ni_end_band = bands;
+ max_pos_pulse = bands;
+ FOR (k = ni_start_band; k < ni_end_band; k++)
+ {
+ tmp = div_s(1, band_width[k]); /*Q15 */
+ L_tmp = Mult_32_16(Rk_fx[k],tmp);/*Q(16+15-15=16) */
+ pd_fx[k] = extract_h(L_shl(L_tmp,10)); /*16+10-16 =Q10 */
+
+ L_tmp2 = Ep_fx[k];/*Q0 */
+ move32();
+ L_tmp = L_max(1, L_tmp2);
+ exp = norm_l(L_tmp);
+ tmp = extract_h(L_shl(L_tmp, exp));
+
+ L_tmp3 = (Word32)band_width[k];
+ move32();
+ exp2 = norm_l(L_tmp3);
+ tmp2 = extract_h(L_shl(L_tmp3, exp2));
+
+ exp2 = sub(exp, exp2); /* Denormalize and substract */
+
+ tmp3 = sub(tmp2, tmp);
+ if (tmp3 > 0)
+ {
+ tmp2 = shr(tmp2, 1);
+ }
+ if (tmp3 > 0)
+ {
+ exp2 = add(exp2, 1);
+ }
+ tmp = div_s(tmp2, tmp);
+ L_tmp = L_deposit_h(tmp);
+ L_tmp = Isqrt_lc(L_tmp, &exp2);
+ env_fx[k] = L_tmp;
+ move32();/*Q(31-exp2) move32(); */
+ Q_env_fx[k] = sub(31,exp2);
+ move16();
+ tmp = sub(17,Q_env_fx[k]);
+ env_fx2[k] = extract_h(L_shl(env_fx[k],tmp));/*Q1 */
+ peak_fx[k] = 0;
+ move16();
+ count[k] = 0;
+ move16();
+
+ IF(npulses[k] != 0)
+ {
+ FOR (i = band_start[k]; i <= band_end[k]; i++)
+ {
+ L_tmp =L_mult0(y2hat_fx[i],y2hat_fx[i]); /*0 */
+ Ep_fx[k] =L_sub(Ep_fx[k],L_tmp);
+ move32();/*0 */
+ IF(GT_16(abs_s(y2hat_fx[i]),peak_fx[k]))
+ {
+ peak_fx[k] = abs_s(y2hat_fx[i]);
+ move16();/*0 */
+ }
+
+ IF(y2hat_fx[i] != 0)
+ {
+ count[k] = add(count[k],1);
+ move16();
+ }
+ }
+
+ max_pos_pulse = k;
+ L_tmp2 = Ep_fx[k];
+ move32();
+ L_tmp = L_max(1, L_tmp2);
+ exp = norm_l(L_tmp);
+ tmp = extract_h(L_shl(L_tmp, exp));
+
+ L_tmp3 = (Word32)band_width[k];
+ exp2 = norm_l(L_tmp3);
+ tmp2 = extract_h(L_shl(L_tmp3, exp2));
+
+ exp2 = sub(exp, exp2); /* Denormalize and substract */
+
+ tmp3 = sub(tmp2, tmp);
+ if (tmp3 > 0)
+ {
+ tmp2 = shr(tmp2, 1);
+ }
+ if (tmp3 > 0)
+ {
+ exp2 = add(exp2, 1);
+ }
+ tmp = div_s(tmp2, tmp);
+ L_tmp = L_deposit_h(tmp);
+ L_tmp = Isqrt_lc(L_tmp, &exp2);
+ Ep_fx[k] = L_tmp;
+ move32();/*Q(31-exp2) */
+ Q_Ep_fx[k] = sub(31,exp2);
+ move16();
+ }
+ ELSE
+ {
+ Ep_fx[k] = env_fx[k];
+ move32();/*Q(Q_env_fx[k]) */
+ Q_Ep_fx[k] = Q_env_fx[k];
+ move16();/*31-exp2 */
+ }
+ }
+
+ FOR(k = ni_start_band; k < ni_end_band; k++)
+ {
+ /* calculate the noise gain */
+ satur =0;
+ move16();
+ if(GE_16(pd_fx[k],819))
+ {
+ satur =1;
+ move16();
+ }
+
+ test();
+ IF (satur == 0 && Ep_fx[k] > 0)
+ {
+ IF(npulses[k] != 0)
+ {
+ IF( EQ_16(bwidth,SWB))
+ {
+ IF(NE_16(hqswb_clas,HQ_TRANSIENT))
+ {
+ IF(peak_fx[k]!=0)
+ {
+ Q_speech = norm_s(peak_fx[k]);
+ tmp = shl(peak_fx[k],Q_speech);/*Q(Q_speech) */
+ tmp = div_s(16384,tmp);/*Q(15+14-Q_speech) */
+ }
+ ELSE
+ {
+ tmp = 0x7fff;
+ move16();
+ Q_speech = 0;
+ move16();
+ }
+ L_tmp2x = Mult_32_16(Ep_fx[k],tmp);/* Q(Q_Ep_fx[k]+29-Q_speech-15 = Q_Ep_fx[k]-Q_speech+14) */
+ tmp = sub(Q_Ep_fx[k],Q_speech);
+ tmpx = add(tmp,1);
+ tmp2 = extract_l(L_shr(L_tmp2x,s_min(tmpx, 31)));/*Q13 Ep[k]/peak[k] */
+
+ IF(EQ_16(hqswb_clas, HQ_HARMONIC))
+ {
+ tmp = sub(1536,pd_fx[k]); /*Q10 */
+ tmp3 = shl(tmp,4); /*Q14 */
+ L_tmp = Mult_32_16(env_fx[k],tmp3);/*Q(Q_env_fx[k]+14-15 = Q_env_fx[k]-1) */
+ L_tmp = Mult_32_16(L_tmp,6144);/*Q(Q_env_fx[k]-1+10-15 = Q_env_fx[k]-6) */
+
+ IF(peak_fx[k]!=0)
+ {
+ Q_speech = norm_s(peak_fx[k]);
+ tmp = shl(peak_fx[k],Q_speech);/*Q(Q_speech) */
+ tmp = div_s(16384,tmp);/*Q(15+14-Q_speech) */
+ }
+ ELSE
+ {
+ tmp = 0x7fff;
+ move16();
+ Q_speech = 0;
+ move16();
+ }
+
+ L_tmp2 = Mult_32_16(Ep_fx[k],tmp);/* Q(Q_Ep_fx[k]+29-Q_speech-15=Q_Ep_fx[k]-Q_speech+14) */
+ L_tmp3 = Mult_32_16(L_tmp,tmp);/* Q(Q_env_fx[k]-6+29-Q_speech-15=Q_env_fx[k]-Q_speech+8) */
+ L_tmp = Mult_32_32(L_tmp2,L_tmp3); /*Q(Q_Ep_fx[k]-Q_speech+14+Q_env_fx[k]-Q_speech+8-31=Q_Ep_fx[k]+Q_env_fx[k]-2*Q_speech-9) */
+
+ tmp = add(Q_Ep_fx[k],Q_env_fx[k]);
+ tmp = sub(tmp,Q_speech);
+ tmp = sub(tmp,Q_speech);
+ tmp = sub(37,tmp);
+ tmp1= extract_h(L_shl(L_tmp,tmp));/*Q12 //6.0f*(1.5f - pd[k])*env[k]*Ep[k]/(peak[k]*peak[k]) */
+
+ fac_fx = tmp1;
+ move16();/*Q12 */
+ if(GT_16(k,sb))
+ {
+ fac_fx =mult(24576,tmp2);/*//Q(14+13-15=12) */
+ }
+ }
+ ELSE
+ {
+ IF(LE_16(k,sb))
+ {
+ tmp = sub(1536,pd_fx[k]); /*Q10 */
+ tmp3 = shl(tmp,4); /*Q14 */
+ L_tmp = Mult_32_16(L_tmp2x,tmp3);/*Q(Q_Ep_fx[k]-Q_speech+14+14-15 = Q_Ep_fx[k]-Q_speech+13) */
+ L_tmp = Mult_32_16(L_tmp,20480);/*Q(Q_Ep_fx[k]-Q_speech+13+12-15 = Q_Ep_fx[k]-Q_speech+10) */
+ fac_fx= extract_h(L_shl(L_tmp,sub(add(18,Q_speech),Q_Ep_fx[k])));/*Q_Ep_fx[k]-Q_speech+10 +18+Q_speech-Q_Ep_fx[k] -16 =12 */
+ }
+ ELSE
+ {
+ fac_fx =shl(mult(32767,tmp2),1);/*//Q(13+13-15+1=12) */
+ }
+ }
+ }
+ ELSE
+ {
+ fac_fx = 4505;
+ move16();/*Q12 */
+ }
+ }
+ ELSE
+ {
+ tmp = sub(1536,pd_fx[k]); /*Q10 */
+ tmp2 = s_min(1024,tmp); /*q10 */
+ tmp2 = shl(tmp2,4); /*Q14 */
+ L_tmp = Mult_32_16(env_fx[k],tmp2);/*Q(Q_env_fx[k]+14-15 = Q_env_fx[k]-1) */
+ L_tmp = Mult_32_16(L_tmp,20480);/*Q(Q_env_fx[k]-1+10-15 = Q_env_fx[k]-6) */
+
+ IF(peak_fx[k]!=0)
+ {
+ Q_speech = norm_s(peak_fx[k]);
+ tmp = shl(peak_fx[k],Q_speech);/*Q(Q_speech) */
+ tmp = div_s(16384,tmp);/*Q(15+14-Q_speech) */
+ }
+ ELSE
+ {
+ tmp = 0x7fff;
+ move16();
+ Q_speech = 0;
+ move16();
+ }
+
+ L_tmp2 = Mult_32_16(Ep_fx[k],tmp);/* Q(Q_Ep_fx[k]+29-Q_speech-15=Q_Ep_fx[k]-Q_speech+14) */
+ L_tmp3 = Mult_32_16(L_tmp,tmp);/* Q(Q_env_fx[k]-6+29-Q_speech-15=Q_env_fx[k]-Q_speech+8) */
+ L_tmp = Mult_32_32(L_tmp2,L_tmp3); /*Q(Q_Ep_fx[k]-Q_speech+14+Q_env_fx[k]-Q_speech+8-31=Q_Ep_fx[k]+Q_env_fx[k]-2*Q_speech-9) */
+
+ tmp = add(Q_Ep_fx[k],Q_env_fx[k]);
+ tmp = sub(tmp,Q_speech);
+ tmp = sub(tmp,Q_speech);
+ tmp = sub(37,tmp);
+
+ fac_fx = extract_h(L_shl(L_tmp,tmp));/*Q12 */
+
+ test();
+ IF(GT_16(k,1)&<_16(k,sub(ni_end_band,1)))
+ {
+ IF(env_fx2[k]!=0)
+ {
+ Q_speech = norm_s(env_fx2[k]);
+ tmp = shl(env_fx2[k],Q_speech);/*Q(Q_speech+1) */
+ tmp = div_s(16384,tmp);/*Q(15+14-Q_speech-1=28-Q_speech) */
+ Q_speech = sub(28,Q_speech);
+ }
+ ELSE
+ {
+ tmp =0x7fff;
+ move16();
+ Q_speech = 0;
+ move16();
+ }
+ tmp1 = mult(env_fx2[add(k,1)],16384);/*Q(1+15-15=1) Q1 */
+ tmp2 = sub(env_fx2[k],tmp1);
+ tmp1 = mult(env_fx2[k],16384);/*Q(1+15-15=1) Q1 */
+ tmp3 = sub(tmp1,env_fx2[sub(k,1)]);
+ tmp1 = mult(peak_fx[k],16384);/*Q(0+15-15=0) Q0 */
+ tmp4 = sub(tmp1,shr(env_fx2[k],1));
+ test();
+ test();
+ test();
+ IF(count[add(k,1)] == 0 && tmp2 > 0 && tmp3 < 0)
+ {
+ L_tmp = L_mult(env_fx2[add(k,1)],tmp);/* Q(1+Q_speech+1 = Q_speech+2) */
+ L_tmp = Mult_32_16(L_tmp,24576); /*Q(Q_speech+2+14-15=Q_speech+1) */
+ fac_fx = extract_h(L_shl(L_tmp,sub(27,Q_speech)));/*Q12 */
+ }
+ ELSE IF(count[sub(k,1)] == 0 && tmp4 > 0)
+ {
+ L_tmp = L_mult(env_fx2[sub(k,1)],tmp); /* Q(1+Q_speech+1 = Q_speech+2) */
+ fac_fx = extract_h(L_shl(L_tmp,sub(26,Q_speech)));/*Q12 */
+ }
+ }
+
+ test();
+ IF(GE_16(k,sub(ni_end_band,p2a_bands))&&EQ_16(bwidth,WB))
+ {
+ L_tmp = Mult_32_16(enerH_fx, bw_low);
+ L_tmp2= Mult_32_16(enerL_fx, bw_high);
+ L_tmp = L_sub(L_tmp,L_tmp2);
+ tmp1 = mult(peak_fx[k],16384);/*Q(0+15-15=0) Q0 */
+ tmp4 = sub(tmp1,shr(env_fx2[k],1));
+ test();
+ IF(L_tmp > 0 && tmp4 < 0)
+ {
+ IF(peak_fx[k]!=0)
+ {
+ Q_speech = norm_s(peak_fx[k]);
+ tmp = shl(peak_fx[k],Q_speech);/*Q(Q_speech) */
+ tmp = div_s(16384,tmp);/*Q(15+14-Q_speech) */
+ }
+ ELSE
+ {
+ tmp = 0x7fff;
+ move16();
+ Q_speech = 0;
+ move16();
+ }
+ L_tmp2 = Mult_32_16(Ep_fx[k],tmp);/* Q(Q_Ep_fx[k]+29-Q_speech-15 = Q_Ep_fx[k]-Q_speech+14) */
+ tmp = sub(Q_Ep_fx[k],Q_speech);
+ tmp = add(tmp,1);
+ tmp = extract_l(L_shr(L_tmp2,tmp));/*Q13 */
+ tmp = sub(16384,tmp);/*Q13 */
+ fac_fx = extract_h(L_shl(L_mult(fac_fx,tmp),2));/*Q12*/
+ }
+
+ IF(p2a_flags[k] == 0)
+ {
+ L_tmp2 = Mult_32_16(Ep_fx[k],fac_fx);/*Q(Q_Ep_fx[k]+12-15 = Q_Ep_fx[k]-3) */
+ Q_speech = norm_l(L_tmp2);
+ tmp = extract_h(L_shl(L_tmp2,Q_speech));/*Q(Q_Ep_fx[k]-3+Q_speech-16 = Q_Ep_fx[k]+Q_speech-19) */
+ IF(tmp != 0)
+ {
+ tmp = div_s(16384,tmp);/*Q(15+14-Q_Ep_fx[k]-Q_speech+19 = 48-Q_Ep_fx[k]-Q_speech) */
+ L_tmp2 = Mult_32_16(env_fx[k],tmp);/*Q(Q_env_fx[k]+48-Q_Ep_fx[k]-Q_speech-15 = Q_env_fx[k]-Q_Ep_fx[k]-Q_speech+33) */
+ L_tmp2 = Mult_32_16(L_tmp2,20480);/*Q(Q_env_fx[k]-Q_Ep_fx[k]-Q_speech+33+14-15 = Q_env_fx[k]-Q_Ep_fx[k]-Q_speech+32) */
+ tmp = sub(Q_env_fx[k],Q_Ep_fx[k]);
+ tmp = sub(tmp,Q_speech);
+ tmp = add(tmp,25);
+ L_tmp = L_shr(L_tmp2,tmp);/*Q7 */
+ tmp = extract_l(L_min(L_tmp,192));/* */
+ fac_fx = extract_h(L_shl(L_mult(fac_fx,tmp),8));/*Q12 */
+ }
+ ELSE
+ {
+ tmp = 0x7fff;/*Q0 */
+ L_tmp2 = Mult_32_16(env_fx[k],tmp);/*Q(Q_env_fx[k]+0-15 = Q_env_fx[k]-15) */
+ L_tmp2 = Mult_32_16(L_tmp2,20480);/*Q(Q_env_fx[k]-15+14-15 = Q_env_fx[k]-16) */
+ tmp = sub(Q_env_fx[k],23);
+ L_tmp = L_shr(L_tmp2,tmp);/*Q7 */
+ tmp = extract_l((L_min(L_tmp,192)));/* */
+ fac_fx = extract_h(L_shl(L_mult(fac_fx,tmp),8));/*Q12 */
+ }
+ }
+ }
+ }
+ }
+ ELSE
+ {
+ fac_fx = 4505;
+ move16();
+ test();
+ if( EQ_16(hqswb_clas,HQ_HARMONIC)&&EQ_16(bwidth,SWB))
+ {
+ fac_fx = 3277;
+ move16();
+ }
+ }
+
+ L_tmp = Mult_32_16(Ep_fx[k],fac_fx);/*Q(Q_Ep_fx[k]+12-15 = Q_Ep_fx[k]-3) */
+ ni_gain_fx[k] = L_shr(L_tmp,sub(Q_Ep_fx[k],20));
+ move32();/*Q17 */
+ }
+ ELSE
+ {
+ ni_gain_fx[k] = L_deposit_l(0);
+ }
+
+ /* smooth the noise gain between the current frame and the previous frame */
+ pos = s_max(max_pos_pulse, *last_max_pos_pulse);
+ move16();
+ if( EQ_16(bwidth,SWB))
+ {
+ pos = sub(ni_end_band,1);
+ move16();
+ }
+
+ IF(LE_16(k,pos))
+ {
+ test();
+ IF(k > 0 && LT_16(sub(k,ni_end_band),-1))
+ {
+ tmp1 = mult(last_env_fx[k],16384);/*Q(1+15-15=1) Q1 */
+ tmp2 = sub(env_fx2[k],tmp1);/*>0 */
+ tmp1 = mult(env_fx2[k],16384);/*Q(1+15-15=1) Q1 */
+ tmp3 = sub(tmp1,last_env_fx[k]);/*<0 */
+ L_tmp = L_add((Word32)env_fx2[k],(Word32)env_fx2[sub(k,1)]);
+ L_tmp = L_add(L_tmp,(Word32)env_fx2[add(k,1)]);/*Q1 */
+ L_tmp1 = L_add((Word32)last_env_fx[k],(Word32)last_env_fx[sub(k,1)]);
+ L_tmp1 = L_add(L_tmp1,(Word32)last_env_fx[add(k,1)]);/*Q1 */
+ L_tmp2 = Mult_32_16(L_tmp1,16384);/*Q(1+15-15) Q1 */
+ L_tmp2 = L_sub(L_tmp,L_tmp2);/*>0 */
+ L_tmp3 = Mult_32_16(L_tmp,16384);/*Q(1+15-15) Q1 */
+ L_tmp3 = L_sub(L_tmp3,L_tmp1);/*<0 */
+ test();
+ test();
+ test();
+ IF( (tmp2 > 0 && tmp3 < 0) ||(L_tmp2 > 0 && L_tmp3 < 0))
+ {
+ IF( GT_32(ni_gain_fx[k],last_ni_gain_fx[k]))
+ {
+ L_tmp = Mult_32_16(ni_gain_fx[k],6554);/*Q(17+15-15 = 17) */
+ L_tmp1 = Mult_32_16(last_ni_gain_fx[k],26214);/*Q17 */
+ ni_gain_fx[k] = L_add(L_tmp,L_tmp1);
+ move32();
+ }
+ ELSE
+ {
+ L_tmp = Mult_32_16(ni_gain_fx[k],19661);/*Q(17+15-15 = 17) */
+ L_tmp1 = Mult_32_16(last_ni_gain_fx[k],13107);/*Q17 */
+ ni_gain_fx[k] = L_add(L_tmp,L_tmp1);
+ move32();
+ }
+ }
+ }
+ ELSE IF (add(sub(k,ni_end_band),1) == 0)
+ {
+ tmp1 = mult(last_env_fx[k],16384);/*Q(1+15-15=1) Q1 */
+ tmp2 = sub(env_fx2[k],tmp1);/*>0 */
+ tmp1 = mult(env_fx2[k],16384);/*Q(1+15-15=1) Q1 */
+ tmp3 = sub(tmp1,last_env_fx[k]);/*<0 */
+ L_tmp = L_add((Word32)env_fx2[k],(Word32)env_fx2[sub(k,1)]);/*Q1 */
+ L_tmp1 = L_add((Word32)last_env_fx[k],(Word32)last_env_fx[sub(k,1)]);/*Q1 */
+ L_tmp2 = Mult_32_16(L_tmp1,16384);/*Q(1+15-15) Q1 */
+ L_tmp2 = L_sub(L_tmp,L_tmp2);/*>0 */
+ L_tmp3 = Mult_32_16(L_tmp,16384);/*Q(1+15-15) Q1 */
+ L_tmp3 = L_sub(L_tmp3,L_tmp1);/*<0 */
+
+ test();
+ test();
+ test();
+ IF( (tmp2 > 0 && tmp3 < 0) ||(L_tmp2 > 0 && L_tmp3 < 0))
+ {
+ IF( GT_32(ni_gain_fx[k],last_ni_gain_fx[k]))
+ {
+ L_tmp = Mult_32_16(ni_gain_fx[k],6554);/*Q(17+15-15 = 17) */
+ L_tmp1 = Mult_32_16(last_ni_gain_fx[k],26214);/*Q17 */
+ ni_gain_fx[k] = L_add(L_tmp,L_tmp1);
+ move32();
+ }
+ ELSE
+ {
+ L_tmp = Mult_32_16(ni_gain_fx[k],19661);/*Q(17+15-15 = 17) */
+ L_tmp1 = Mult_32_16(last_ni_gain_fx[k],13107);/*Q17 */
+ ni_gain_fx[k] = L_add(L_tmp,L_tmp1);
+ move32();
+ }
+ }
+ }
+ }
+
+ /* inject noise into the non-decoded coeffs */
+ test();
+ test();
+ IF(add(sub(k,ni_end_band),p2a_bands) >=0 && p2a_flags[k] == 0 && NE_16(bwidth,SWB) )
+ {
+ FOR (i = band_start[k]; i <= band_end[k]; i++)
+ {
+ IF (L_y2[i] != 0)
+ {
+ L_y2[i] = Mult_32_16(L_y2[i],26215);
+ move32();/*Q(12+15-15=12) */
+ }
+ }
+ }
+
+ test();
+ test();
+ test();
+ IF(EQ_16(k,max_pos_pulse)&&add(sub(k,bands),p2a_bands)<0&&NE_16(satur,1)&&NE_16(bwidth,SWB))
+ {
+ j = 0;
+ Q_speech = norm_l(ni_gain_fx[k]);
+ tmp = extract_h(L_shl(ni_gain_fx[k],Q_speech));/*Q(Q_speech+1) */
+ IF(tmp != 0)
+ {
+ tmp = div_s(16384,tmp);/*Q(15+14-Q_speech-1 = 28-Q_speech) */
+ L_tmp = Mult_32_16(Ep_fx[k],tmp); /*Q(Q_Ep_fx[k]+28-Q_speech-15 = Q_Ep_fx[k]+13-Q_speech) */
+ tmp = sub(Q_Ep_fx[k],Q_speech);
+ tmp = sub(15,tmp);
+ tmp = extract_h(L_shl(L_tmp,tmp));/*Q12 */
+ }
+ ELSE
+ {
+ tmp = 0x7fff;/*Q0 */
+ L_tmp = Mult_32_16(Ep_fx[k],tmp); /*Q(Q_Ep_fx[k]+0-15 = Q_Ep_fx[k]-15) */
+ tmp = sub(43,Q_Ep_fx[k]);
+ tmp = extract_h(L_shl(L_tmp,tmp));/*Q12 */
+ }
+ fac_fx = s_max(tmp,4096);/*Q12 */
+
+ FOR (i = band_start[k]; i <= band_end[k]; i++)
+ {
+ IF (L_y2[i] == 0)
+ {
+ rand_fx = Random(&ni_seed); /*Q15 */
+ IF(band_width[k] != 0)
+ {
+ Q_speech = norm_s(band_width[k]);
+ tmp = shl(band_width[k],Q_speech);/*Q(Q_speech) */
+ tmp = div_s(16384,tmp);/*Q(15+14-Q_speech) */
+ }
+ ELSE
+ {
+ tmp = 0x7fff;
+ Q_speech = 0;
+ }
+ tmp1 = sub(fac_fx,4096);/*Q12 */
+ L_tmp = L_mult(tmp1,j);/*Q13 */
+ L_tmp = Mult_32_16(L_tmp,tmp);/*Q(13+29-Q_speech-15 = 27-Q_speech) */
+ tmp = extract_h(L_shl(L_tmp,add(1,Q_speech)));/*Q12 */
+ tmp = sub(fac_fx,tmp);/*Q12 */
+ L_tmp = Mult_32_16(ni_gain_fx[k],tmp);/*Q(17+12-15=14) */
+ L_y2[i] = L_add(L_y2[i],L_shr(Mult_32_16(L_tmp,rand_fx),2));
+ move32();/*Q12 */
+ }
+ j=add(j,1);
+ }
+ }
+ ELSE
+ {
+ FOR (i = band_start[k]; i <= band_end[k]; i++)
+ {
+ IF (L_y2[i] == 0)
+ {
+ rand_fx = Random(&ni_seed); /*Q15 */
+ L_tmp = Mult_32_16(ni_gain_fx[k],rand_fx);/*Q(17+15-15=17) */
+ L_y2[i] = L_add(L_y2[i],L_shr(L_tmp,5));
+ move32();/*Q12 */
+ }
+ }
+ }
+ }
+
+ Copy(env_fx2,last_env_fx,ni_end_band);
+ Copy32(ni_gain_fx,last_ni_gain_fx,ni_end_band);
+ *last_max_pos_pulse = max_pos_pulse;
+ move16();
+ return;
+}
diff --git a/lib_com/hq_bit_allocation_fx.c b/lib_com/hq_bit_allocation_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..7053a4922ac246c30f54b88d06cf8728b7d4f9f7
--- /dev/null
+++ b/lib_com/hq_bit_allocation_fx.c
@@ -0,0 +1,217 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "stl.h" /* required for wmc_tool */
+#include "prot_fx.h" /* Function prototypes */
+#include "cnst_fx.h" /* Common constants */
+
+/*--------------------------------------------------------------------------*
+ * hq_bit_allocation_fx()
+ *
+ * Assign bits for HQ fine structure coding with PVQ
+ *--------------------------------------------------------------------------*/
+
+void hq_bit_allocation_fx(
+ const Word32 core_brate, /* i : Core bit-rate Q0 */
+ const Word16 length, /* i : Frame length Q0 */
+ const Word16 hqswb_clas, /* i : HQ class Q0 */
+ Word16 *num_bits, /* i/o: Remaining bit budget Q0 */
+ const Word16 *normqlg2, /* i : Quantized norms Q0 */
+ const Word16 nb_sfm, /* i : Number sub bands to be encoded Q0 */
+ const Word16 *sfmsize, /* i : Sub band bandwidths Q0 */
+ Word16 *noise_level, /* o : HVQ noise level */
+ Word16 *R, /* o : Bit allocation per sub band Q0 */
+ Word16 *Rsubband, /* o : Fractional bit allocation Q3 */
+ Word16 *sum, /* o : Sum of allocated shape bits Q0 */
+ Word16 *core_sfm, /* o : Last coded band in core Q0 */
+ const Word16 num_env_bands /* i : Number sub bands to be encoded for HQ_GEN Q0 */
+)
+{
+ Word16 i;
+ Word16 idx[NB_SFM];
+ Word16 wnorm[NB_SFM];
+ Word16 avrg_wnorm;
+ Word16 tmp, tmp2;
+ Word16 E_low;
+ Word16 E_hb_mean;
+ Word16 E_max;
+ Word16 i_max;
+ /* Temp */
+
+ Word16 sfm_limit = nb_sfm;
+ move16();
+
+ set16_fx( R, 0, NB_SFM);
+ FOR( i = 0; i < nb_sfm; i++ )
+ {
+ idx[i] = i;
+ move16();
+ }
+ test();
+ test();
+ test();
+ if( NE_16(hqswb_clas, HQ_TRANSIENT)&&NE_16(hqswb_clas,HQ_HVQ)&&!(EQ_16(length,L_FRAME16k)&&EQ_32(core_brate,HQ_32k)))
+ {
+ /* 'nf_idx' 2-bits index written later */
+ *num_bits = sub(*num_bits, 2);
+ }
+
+ test();
+ IF ( EQ_16(hqswb_clas, HQ_GEN_SWB)||EQ_16(hqswb_clas,HQ_GEN_FB))
+ {
+ IF ( EQ_32(core_brate, HQ_32k))
+ {
+ *num_bits = sub(*num_bits, HQ_GENERIC_SWB_NBITS2 );
+ }
+ ELSE
+ {
+ *num_bits = sub(*num_bits, HQ_GENERIC_SWB_NBITS );
+ }
+
+ if ( EQ_16(hqswb_clas, HQ_GEN_FB))
+ {
+ *num_bits = sub(*num_bits, HQ_GENERIC_FB_NBITS );
+ }
+ }
+
+ IF( ( EQ_16(length, L_FRAME48k))&&(NE_16(hqswb_clas,HQ_HARMONIC))&&(NE_16(hqswb_clas,HQ_HVQ)))
+ {
+ tmp = 0;
+ move16();
+ if( EQ_16(hqswb_clas,HQ_TRANSIENT))
+ {
+ tmp = 1;
+ move16();
+ }
+ map_quant_weight_fx( normqlg2, wnorm, tmp );
+ }
+ ELSE
+ {
+ Copy( normqlg2, wnorm, nb_sfm );
+ }
+
+ IF( EQ_16(hqswb_clas, HQ_HARMONIC))
+ {
+ /* classification and limit bandwidth for bit allocation */
+ sfm_limit = sub(sfm_limit, 2);
+ limit_band_noise_level_calc_fx( wnorm, &sfm_limit, core_brate, noise_level );
+
+ /* Detect important band in high frequency region */
+ E_low = sum16_fx(wnorm, SFM_G1);
+ i_max = 0;
+ move16();
+ E_max = MIN16B;
+ move16();
+ E_hb_mean = 0;
+ move16();
+ FOR( i = SFM_G1; i < nb_sfm; i++)
+ {
+ E_hb_mean = add(E_hb_mean, wnorm[i]);
+ IF( GT_16(wnorm[i], E_max))
+ {
+ E_max = wnorm[i];
+ move16();
+ i_max = i;
+ move16();
+ }
+ }
+ E_hb_mean = shr(E_hb_mean, 4); /* Truncated division by SFM_G1 */
+ set16_fx( wnorm + sfm_limit, -20, sub(nb_sfm, sfm_limit) );
+ IF (L_msu0(L_deposit_l(E_low), E_max, 15) <= 0)
+ {
+ IF (L_msu(L_deposit_h(E_hb_mean), E_max, 21955) <= 0) /* 21955 = 0.67 (Q15) */
+ {
+ if (GE_16(i_max, sfm_limit))
+ {
+ wnorm[i_max] = E_max;
+ move16();
+ }
+ }
+ }
+ }
+ test();
+ test();
+ test();
+ test();
+ IF( EQ_16(hqswb_clas, HQ_HVQ))
+ {
+ *sum = 0;
+ move16();
+ }
+ ELSE IF ( EQ_16(hqswb_clas, HQ_GEN_SWB)||(EQ_16(hqswb_clas,HQ_TRANSIENT)&&EQ_16(length,L_FRAME32k)&&LE_32(core_brate,HQ_32k)))
+ {
+ *sum = BitAllocF_fx( wnorm, core_brate, *num_bits, nb_sfm, R, Rsubband, hqswb_clas, num_env_bands );
+ }
+ ELSE IF( EQ_16(length, L_FRAME16k)&&EQ_32(core_brate,HQ_32k))
+ {
+ IF( NE_16(hqswb_clas, HQ_TRANSIENT))
+ {
+ avrg_wnorm = wnorm[10];
+ move16();
+ FOR( i=11; i<18; i++ )
+ {
+ avrg_wnorm = add(avrg_wnorm, wnorm[i]);
+ }
+
+ avrg_wnorm = shr(avrg_wnorm, 3);
+ FOR( i=0; i<4; i++ )
+ {
+ if( LT_16(wnorm[i], avrg_wnorm))
+ {
+ wnorm[i] = avrg_wnorm;
+ move16();
+ }
+ }
+
+ /* Estimate number of bits per band */
+ *sum = BitAllocWB_fx( wnorm, *num_bits, nb_sfm, R, Rsubband );
+ }
+ ELSE
+ {
+ reordvct_fx(wnorm, nb_sfm, idx);
+ bitalloc_fx( wnorm, idx, *num_bits, nb_sfm, QBIT_MAX2, R, sfmsize, hqswb_clas );
+ bitallocsum_fx( R, nb_sfm, sum, Rsubband, *num_bits, length, sfmsize );
+ }
+ }
+ ELSE
+ {
+ reordvct_fx(wnorm, nb_sfm, idx);
+
+ /* enlarge the wnorm value so that more bits can be allocated to (sfm_limit/2 ~ sfm_limit) range */
+ IF( EQ_16(hqswb_clas, HQ_HARMONIC))
+ {
+ tmp = shr(sfm_limit,1);
+ tmp2 = sub(tmp,1);
+ FOR( i=tmp; i
+#include "options.h"
+#include "cnst_fx.h" /* Audio core constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h" /* required for wmc_tool */
+
+/*--------------------------------------------------------------------------*
+ * hq_configure()
+ *
+ * Configuration routine for HQ mode
+ *--------------------------------------------------------------------------*/
+
+void hq_configure_fx(
+ const Word16 length, /* i : Frame length Q0 */
+ const Word16 hqswb_clas, /* i : HQ SWB class Q0 */
+ const Word32 core_brate, /* i : Codec bitrate Q0 */
+ Word16 *num_sfm, /* o : Total number of subbands Q0 */
+ Word16 *nb_sfm, /* o : Total number of coded bands Q0 */
+ Word16 *start_norm, /* o : First norm to be SDE encoded Q0 */
+ Word16 *num_env_bands, /* o : Number coded envelope bands Q0 */
+ Word16 *numnrmibits, /* o : Number of bits in fall-back norm encoding Q0 */
+ Word16 *hq_generic_offset, /* o : Freq offset for HQ GENERIC Q0 */
+ Word16 const **sfmsize, /* o : Subband bandwidths Q0 */
+ Word16 const **sfm_start, /* o : Subband start coefficients Q0 */
+ Word16 const **sfm_end /* o : Subband end coefficients Q0 */
+)
+{
+ *start_norm = 0;
+ move16();
+
+ IF ( EQ_16(length, L_FRAME48k))
+ {
+ IF ( EQ_16(hqswb_clas, HQ_GEN_FB))
+ {
+ *num_sfm = NB_SFM;
+ move16();
+ *sfmsize = band_len_HQ;
+ move16();
+ *sfm_start = band_start_HQ;
+ move16();
+ *sfm_end = band_end_HQ;
+ move16();
+
+ test();
+ IF ( EQ_32(core_brate, HQ_32k))
+ {
+ *hq_generic_offset = HQ_GENERIC_FOFFSET_32K;
+ move16();
+ }
+ ELSE IF ( EQ_32(core_brate, HQ_16k40)||EQ_32(core_brate,HQ_24k40))
+ {
+ *hq_generic_offset = HQ_GENERIC_FOFFSET_24K4;
+ move16();
+ }
+
+ /* setting start frequency of FD BWE */
+ test();
+ IF ( EQ_32(core_brate, HQ_32k))
+ {
+ *num_env_bands = SFM_N_STA_10k;
+ move16();
+ }
+ ELSE IF ( EQ_32(core_brate, HQ_16k40)||EQ_32(core_brate,HQ_24k40))
+ {
+ *num_env_bands = SFM_N_STA_8k;
+ move16();
+ }
+ *nb_sfm = *num_sfm;
+ move16();
+ }
+ ELSE
+ {
+ IF(EQ_16(hqswb_clas, HQ_HARMONIC))
+ {
+ *num_sfm = SFM_N_HARM_FB;
+ move16();
+ *nb_sfm = SFM_N_HARM_FB;
+ move16();
+ *num_env_bands = SFM_N_HARM_FB;
+ move16();
+
+ *sfmsize = band_len_harm;
+ move16();
+ *sfm_start = band_start_harm;
+ move16();
+ *sfm_end = band_end_harm;
+ move16();
+ }
+ ELSE IF ( EQ_16(hqswb_clas, HQ_HVQ))
+ {
+ IF ( EQ_32(core_brate, HQ_24k40))
+ {
+ *num_sfm = SFM_N_HARM_FB;
+ move16();
+ *nb_sfm = HVQ_THRES_SFM_24k;
+ move16();
+ *num_env_bands = sub(*num_sfm, *nb_sfm);
+
+ *sfmsize = band_len_harm;
+ move16();
+ *sfm_start = band_start_harm;
+ move16();
+ *sfm_end = band_end_harm;
+ move16();
+ *start_norm = HVQ_THRES_SFM_24k;
+ move16();
+ }
+ ELSE
+ {
+ *num_sfm = SFM_N_HARM_FB;
+ move16();
+ *nb_sfm = HVQ_THRES_SFM_32k;
+ move16();
+ *num_env_bands = sub(*num_sfm, *nb_sfm);
+
+ *sfmsize = band_len_harm;
+ move16();
+ *sfm_start = band_start_harm;
+ move16();
+ *start_norm = HVQ_THRES_SFM_32k;
+ move16();
+ *sfm_end = band_end_harm;
+ move16();
+ }
+ }
+ ELSE
+ {
+ *num_sfm = NB_SFM;
+ move16();
+ *nb_sfm = *num_sfm;
+ move16();
+ *num_env_bands = NB_SFM;
+ move16();
+
+ *sfmsize = band_len_HQ;
+ move16();
+ *sfm_start = band_start_HQ;
+ move16();
+ *sfm_end = band_end_HQ;
+ move16();
+ }
+ }
+ }
+ ELSE IF( EQ_16(length, L_FRAME32k))
+ {
+ IF ( EQ_16(hqswb_clas, HQ_HARMONIC))
+ {
+ *num_sfm = SFM_N_HARM;
+ move16();
+ *nb_sfm = SFM_N_HARM;
+ move16();
+ *num_env_bands = SFM_N_HARM;
+ move16();
+
+ *sfmsize = band_len_harm;
+ move16();
+ *sfm_start = band_start_harm;
+ move16();
+ *sfm_end = band_end_harm;
+ move16();
+ }
+ ELSE IF ( EQ_16(hqswb_clas, HQ_HVQ))
+ {
+ IF ( EQ_32(core_brate, HQ_24k40))
+ {
+ *num_sfm = SFM_N_HARM;
+ move16();
+ *nb_sfm = HVQ_THRES_SFM_24k;
+ move16();
+ *num_env_bands = sub(*num_sfm, *nb_sfm);
+
+ *sfmsize = band_len_harm;
+ move16();
+ *sfm_start = band_start_harm;
+ move16();
+ *sfm_end = band_end_harm;
+ move16();
+ *start_norm = HVQ_THRES_SFM_24k;
+ move16();
+ }
+ ELSE
+ {
+ *num_sfm = SFM_N_HARM;
+ move16();
+ *nb_sfm = HVQ_THRES_SFM_32k;
+ move16();
+ *num_env_bands = sub(*num_sfm, *nb_sfm);
+
+ *sfmsize = band_len_harm;
+ move16();
+ *sfm_start = band_start_harm;
+ move16();
+ *start_norm = HVQ_THRES_SFM_32k;
+ move16();
+ *sfm_end = band_end_harm;
+ move16();
+ }
+ }
+ ELSE IF ( EQ_16(hqswb_clas, HQ_GEN_SWB))
+ {
+ *num_sfm = SFM_N_SWB;
+ move16();
+ *sfmsize = band_len_HQ;
+ move16();
+ *sfm_start = band_start_HQ;
+ move16();
+ *sfm_end = band_end_HQ;
+ move16();
+
+ IF ( EQ_32(core_brate, HQ_32k))
+ {
+ *hq_generic_offset = HQ_GENERIC_FOFFSET_32K;
+ move16();
+ }
+ ELSE if ( EQ_32(core_brate, HQ_24k40))
+ {
+ *hq_generic_offset = HQ_GENERIC_FOFFSET_24K4;
+ move16();
+ }
+
+ /* setting start frequency of HQ Generic */
+ IF ( EQ_32(core_brate, HQ_32k))
+ {
+ *num_env_bands = SFM_N_STA_10k;
+ move16();
+ }
+ ELSE if( EQ_32(core_brate, HQ_24k40))
+ {
+ *num_env_bands = SFM_N_STA_8k;
+ move16();
+ }
+
+ *nb_sfm = *num_sfm;
+ move16();
+ }
+ ELSE
+ {
+ /* HQ_NORMAL and HQ_TRANSIENT */
+ *num_sfm = SFM_N_SWB;
+ move16();
+ *nb_sfm = *num_sfm;
+ move16();
+ *num_env_bands = SFM_N_SWB;
+ move16();
+
+ *sfmsize = band_len_HQ;
+ move16();
+ *sfm_start = band_start_HQ;
+ move16();
+ *sfm_end = band_end_HQ;
+ move16();
+ }
+ }
+ ELSE
+ {
+ *num_sfm = SFM_N_WB;
+ move16();
+ *nb_sfm = *num_sfm;
+ move16();
+ *num_env_bands = SFM_N_WB;
+ move16();
+
+ *sfmsize = band_len_wb;
+ move16();
+ *sfm_start = band_start_wb;
+ move16();
+ *sfm_end = band_end_wb;
+ move16();
+ }
+
+ *numnrmibits = extract_l(L_mult0(sub(*num_env_bands, 1), NORMI_BITS));
+
+ return;
+}
diff --git a/lib_com/hq_tools_fx.c b/lib_com/hq_tools_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..f20cca9c493f4179132538f429da019311d751ba
--- /dev/null
+++ b/lib_com/hq_tools_fx.c
@@ -0,0 +1,2342 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "options.h" /* Compilation switches */
+#include "rom_com_fx.h" /* Static table prototypes FIP version */
+#include "stl.h" /* required for wmc_tool */
+#include "prot_fx.h"
+
+/*--------------------------------------------------------------------------*
+ * Local functions
+ *--------------------------------------------------------------------------*/
+
+static void overlap_hq_bwe_fx( const Word32 *hq_swb_overlap_buf, Word32 *coeff_out, const Word16 n_swb_overlap_offset,
+ const Word16 n_swb_overlap, const Word16 *R, const Word16 num_env_bands, const Word16 num_sfm, const Word16 *sfm_end);
+
+/*--------------------------------------------------------------------------*
+* hq_swb_harmonic_calc_norm_envelop()
+*
+* Calculate normalization envelop
+*--------------------------------------------------------------------------*/
+
+void hq_swb_harmonic_calc_norm_envelop_fx(
+ Word32 *L_SWB_signal, /* i : input signal Q=12*/
+ Word32 *L_envelope, /* o : output envelope Q=12*/
+ Word16 L_swb_norm, /* i : length of normaliztion */
+ Word16 SWB_flength /* i : length of input signal */
+)
+{
+
+ Word16 lookback;
+ Word16 env_index;
+ Word16 n_freq;
+ Word16 n_lag_now;
+ Word16 n_lag;
+ Word16 i;
+ Word32 L_tmp;
+
+ lookback = shr(L_swb_norm,1);
+ env_index = 0;
+ move16();
+ FOR (n_freq = 0; n_freq < lookback; n_freq++)
+ {
+ n_lag_now = add(lookback,n_freq);
+
+ /* Apply MA filter */
+ L_envelope[env_index] = EPSILLON_FX;
+ move16();
+
+ FOR (n_lag=0; n_lag 0)
+ {
+ CodeBook_mod[cb_size] = 1<<12;
+ move16(); /* set to 1, Q value 12 */
+ E_cb_vec = add(E_cb_vec,1);
+ }
+ ELSE IF (coeff[j] < 0)
+ {
+ CodeBook_mod[cb_size] = -1 * (1<<12);
+ move16(); /* set to -1, Q value 12 */
+ E_cb_vec = add(E_cb_vec,1);
+ }
+ ELSE
+ {
+ CodeBook_mod[cb_size] = 0;
+ move16();
+ }
+ cb_size = add(cb_size,1);
+ }
+
+ if (E_cb_vec < 2)
+ {
+ cb_size = sub(cb_size,8);
+ }
+ }
+ }
+ ELSE
+ {
+ FOR (j = sfm_start[sfm]; j < sfm_end[sfm]; j++)
+ {
+ CodeBook[cb_size] = coeff[j];
+ move16();
+ cb_size = add(cb_size,1);
+ }
+ }
+ }
+ }
+
+ IF (flag_32K_env_ho)
+ {
+ FOR (j = 0; j < cb_size; j++)
+ {
+ IF (CodeBook_mod[j] != 0)
+ {
+ /* Densify codebook */
+ CodeBook[j] = -4096;
+ move16(); /* -1 in Q12 */
+ if (CodeBook_mod[j] > 0)
+ {
+ CodeBook[j] = 4096;
+ move16(); /* 1 in Q12 */
+ }
+
+ IF (CodeBook_mod[cb_size-j-1] != 0)
+ {
+ CodeBook[j] = shl(CodeBook[j], 1);
+ move16(); /* Mult by 2 */
+ }
+ }
+ ELSE
+ {
+ CodeBook[j] = CodeBook_mod[cb_size-j-1];
+ move16();
+ }
+ }
+ }
+
+ return cb_size;
+}
+
+
+/*--------------------------------------------------------------------------*
+* find_last_band()
+*
+* Find the last band which has bits allocated
+*--------------------------------------------------------------------------*/
+
+Word16 find_last_band_fx( /* o : index of last band */
+ const Word16 *bitalloc, /* i : bit allocation */
+ const Word16 nb_sfm /* i : number of possibly coded bands */
+)
+{
+ Word16 sfm, core_sfm;
+
+ core_sfm = sub(nb_sfm,1);
+
+ FOR (sfm = nb_sfm-1; sfm >= 0; sfm--)
+ {
+ IF ( bitalloc[sfm] != 0 )
+ {
+ core_sfm = sfm;
+ move16();
+ BREAK;
+ }
+ }
+
+ return core_sfm;
+}
+
+/*--------------------------------------------------------------------------*
+ * apply_noisefill_HQ()
+ *
+ * Inject noise in non-coded bands
+ *--------------------------------------------------------------------------*/
+
+void apply_noisefill_HQ_fx(
+ const Word16 *R, /* i : bit allocation Q0 */
+ const Word16 length, /* i : input frame length Q0 */
+ const Word16 flag_32K_env_ho,/* i : envelope stability hangover flag Q0 */
+ const Word32 L_core_brate, /* i : core bit rate Q0 */
+ const Word16 last_sfm, /* i : last coded subband Q0 */
+ const Word16 *CodeBook, /* i : Noise-fill codebook Q12 */
+ const Word16 *CodeBook_mod, /* i : Densified noise-fill codebook Q12 */
+ const Word16 cb_size, /* i : Codebook length Q0 */
+ const Word16 *sfm_start, /* i : Subband start coefficient Q0 */
+ const Word16 *sfm_end, /* i : Subband end coefficient Q0 */
+ const Word16 *sfmsize, /* i : Subband band width Q0 */
+ Word16 *coeff /* i/o: coded/noisefilled spectrum Q12 */
+)
+{
+ Word16 sfm;
+ Word16 cb_pos;
+ Word16 E_corr;
+ Word16 cb_buff[PVQ_MAX_BAND_SIZE];
+ Word16 i, j;
+ Word16 istart;
+ UWord16 lsb;
+ Word32 L_E_cb_vec;
+ Word32 L_E_corr;
+
+ test();
+ test();
+ IF ( (GE_16(length, L_FRAME32k))||(GT_32(L_core_brate,HQ_32k))||(LT_32(L_core_brate,HQ_24k40)))
+ {
+ /* Read from codebook */
+ cb_pos = 0;
+ move16();
+
+ FOR (sfm = 0; sfm <= last_sfm; sfm++)
+ {
+ IF (R[sfm] == 0)
+ {
+ IF (EQ_16(flag_32K_env_ho, 1))
+ {
+ L_E_cb_vec = L_deposit_l(0);
+ IF (LT_16(sfm, 20))
+ {
+ FOR (i = 0; i < sfmsize[sfm]; i++)
+ {
+ cb_buff[i] = CodeBook_mod[cb_pos++];
+ move16();
+ L_E_cb_vec = L_mac0(L_E_cb_vec, cb_buff[i], cb_buff[i]); /*Q24 (12+12) */
+
+ if (GE_16(cb_pos, cb_size))
+ {
+ cb_pos = 0;
+ move16();
+ }
+ }
+ }
+ ELSE
+ {
+ FOR (i = 0; i < sfmsize[sfm]; i++)
+ {
+ cb_buff[i] = CodeBook[cb_pos++];
+ move16();
+ L_E_cb_vec = L_mac0(L_E_cb_vec, cb_buff[i], cb_buff[i]); /*Q24 (12+12) */
+
+ if (GE_16(cb_pos, cb_size))
+ {
+ cb_pos = 0;
+ move16();
+ }
+ }
+ }
+
+ /*E_corr = E_cb_vec / ((float) sfmsize[sfm]); */
+ Mpy_32_16_ss(L_E_cb_vec, inv_tbl_fx[sfmsize[sfm]], &L_E_corr, &lsb); /*Q24 (24+15+1-16) */
+ move16();
+
+ /*E_corr = 1.0f / (float)sqrt(E_corr); */
+ L_E_corr = Isqrt(L_E_corr); /*Q19 (31-24/2) */
+ E_corr = extract_h(L_shl(L_E_corr, 10)); /*Q13 (13-(19-16)) */
+
+ istart = sfm_start[sfm];
+ move16();
+ FOR(j = istart; j < sfm_end[sfm]; j++)
+ {
+ /*coeff[j] = cb_buff[j - istart] * E_corr; */
+ coeff[j] = extract_h(L_shl(L_mult(cb_buff[j - istart], E_corr), 2)); /*Q12 (12+13+1+2-16) */
+ }
+ }
+ ELSE
+ {
+ FOR (j = sfm_start[sfm]; j < sfm_end[sfm]; j++)
+ {
+ coeff[j] = CodeBook[cb_pos++];
+ move16();
+ if (GE_16(cb_pos, cb_size))
+ {
+ cb_pos = 0;
+ move16();
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * harm_bwe_fine_fx()
+ *
+ * Prepare harmonic BWE fine structure
+ *--------------------------------------------------------------------------*/
+
+void harm_bwe_fine_fx(
+ const Word16 *R, /* i : bit allocation */
+ const Word16 last_sfm, /* i : last coded subband */
+ const Word16 high_sfm, /* i : higher transition band to BWE */
+ const Word16 num_sfm, /* i : total number of bands */
+ const Word16 *norm, /* i : quantization indices for norms */
+ const Word16 *sfm_start, /* i : Subband start coefficient */
+ const Word16 *sfm_end, /* i : Subband end coefficient */
+ Word16 *prev_L_swb_norm, /* i/o: last normalize length */
+ Word16 *coeff, /* i/o: coded/noisefilled normalized spectrum */
+ Word32 *coeff_out /* o : coded/noisefilled spectrum */
+ , Word16 *coeff_fine /* o : BWE fine structure */
+)
+{
+ Word16 sfm;
+ Word16 i;
+ Word32 normq;
+ Word16 SWB_signal[L_HARMONIC_EXC];
+ Word32 envelope[L_HARMONIC_EXC], L_signal[L_HARMONIC_EXC];
+ Word16 enve_lo[L_HARMONIC_EXC], enve_hi[L_HARMONIC_EXC];
+ Word16 *src, *dst, *end;
+ Word16 norm_signal;
+
+ Word16 norm_width = 64;
+ move16();
+
+ /* shape the spectrum */
+ FOR (sfm = 0; sfm <= last_sfm; sfm++)
+ {
+ IF( R[sfm] != 0 )
+ {
+ normq = dicn_fx[norm[sfm]];
+ move32();
+
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ coeff_out[i] = L_shl(Mult_32_16(normq, coeff[i]),1); /*12 14+12+1+1-16 */
+ move32();
+ }
+ }
+ ELSE
+ {
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ coeff_out[i] = L_deposit_l(0);
+ }
+ }
+ }
+
+ /* excitation replication */
+ Copy32(coeff_out, L_signal, L_HARMONIC_EXC);
+ calc_normal_length_fx_32( HQ_CORE, coeff_out, HQ_HARMONIC, -1, &norm_width, prev_L_swb_norm );
+ hq_swb_harmonic_calc_norm_envelop_fx( L_signal, envelope, norm_width, L_HARMONIC_EXC );
+
+ /* Normalize with envelope */
+ FOR (i = 0; i < L_HARMONIC_EXC; i++)
+ {
+ IF (L_signal[i] > 0)
+ {
+ norm_signal = norm_l(envelope[i]);
+ enve_lo[i] = L_Extract_lc(L_shl(envelope[i], norm_signal), &enve_hi[i]);
+ L_signal[i] = Div_32(L_signal[i], enve_hi[i], enve_lo[i]);
+ SWB_signal[i] = round_fx(L_shl(L_signal[i], norm_signal));
+ move16();
+ move16();
+ move32();
+
+ }
+ ELSE
+ {
+ norm_signal = norm_l(envelope[i]);
+ enve_lo[i] = L_Extract_lc(L_shl(envelope[i], norm_signal), &enve_hi[i]);
+ L_signal[i] = L_negate(Div_32(L_negate(L_signal[i]), enve_hi[i], enve_lo[i]));
+ SWB_signal[i] = round_fx(L_shl(L_signal[i], norm_signal));
+ move16();
+ move16();
+ move32();
+
+ }
+ }
+
+ dst = coeff_fine + sfm_end[last_sfm];
+ end = coeff_fine + sfm_end[num_sfm-1];
+
+ IF (LE_16(sub(sfm_end[last_sfm], sfm_end[high_sfm]),(L_HARMONIC_EXC - START_EXC) ))
+ {
+ src = SWB_signal + START_EXC + sub(sfm_end[last_sfm], sfm_end[high_sfm]);
+ }
+ ELSE
+ {
+ src = SWB_signal + L_HARMONIC_EXC - 1;
+ }
+
+ WHILE (dst < end)
+ {
+ logic32();
+ WHILE (dst < end && src < &SWB_signal[L_HARMONIC_EXC])
+ {
+ *dst++ = *src++;
+ move16();
+ }
+ src --;
+
+ logic32();
+ WHILE (dst < end && src >= &SWB_signal[START_EXC])
+ {
+ *dst++ = *src--;
+ move16();
+ }
+ src++;
+ }
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * hvq_bwe_fine()
+ *
+ * Prepare HVQ BWE fine structure
+ *--------------------------------------------------------------------------*/
+
+void hvq_bwe_fine_fx(
+ const Word16 last_sfm, /* i : last coded subband Q0 */
+ const Word16 num_sfm, /* i : total number of bands Q0 */
+ const Word16 *sfm_end, /* i : Subband end coefficient Q0 */
+ const Word16 *peak_idx, /* i : Peak index Q0 */
+ const Word16 Npeaks, /* i : Number of peaks Q0 */
+ Word16 *peak_pos, /* o : Peak positions Q0 */
+ Word16 *prev_L_swb_norm, /* i/o: last normalize length Q0 */
+ Word32 *L_coeff, /* i : coded/noisefilled normalized spectrum Q12 */
+ Word16 *bwe_peaks, /* o : Positions of peaks in BWE Q0 */
+ Word16 *coeff_fine /* o : HVQ BWE fine structure Q15 */
+)
+{
+ Word16 i, j;
+ Word16 SWB_signal[L_HARMONIC_EXC];
+ Word32 L_envelope[L_HARMONIC_EXC];
+ Word16 *src, *dst, *end;
+ Word16 *peak_dst, *peak_src;
+ Word16 norm_width = 64;
+ Word16 tmp;
+ Word16 shift, shift2;
+ Word32 L_tmp;
+ UWord16 lsb;
+
+ calc_normal_length_fx_32( HQ_CORE, L_coeff, HQ_HVQ, -1, &norm_width, prev_L_swb_norm );
+
+ hq_swb_harmonic_calc_norm_envelop_fx(L_coeff, L_envelope, norm_width, L_HARMONIC_EXC);
+
+ /* Normalize with envelope */
+ FOR (i = 0; i < L_HARMONIC_EXC; i++)
+ {
+ /*SWB_signal[i] = SWB_signal[i] / envelope[i]; */
+
+ shift = norm_l(L_envelope[i]);
+ tmp = round_fx(L_shl(L_envelope[i], shift)); /* 12+s-16=Q(-4+s) */
+
+ /* Avoid division by zero */
+ if (tmp == 0)
+ {
+ tmp = 1<<14;
+ move16();
+ }
+
+ tmp = div_s(1<<14, tmp); /* 15+14-(-4+s)=Q(33-s) */
+ Mpy_32_16_ss(L_coeff[i], tmp, &L_tmp, &lsb); /* 12+33-s+1-16=Q(30-s) */
+ shift2 = add(shift, 1);
+ tmp = round_fx(L_shl(L_tmp, shift2)); /* 30-s+s+1-16=Q(15) */
+ SWB_signal[i] = add(tmp, lshr(lsb, sub(32, shift2)));
+ move16(); /* Q15 */
+ /*SWB_signal[i] = round_fx(L_shl(L_tmp, add(shift, 1))); // 30-s+s+1-16=Q(15) */
+
+ }
+
+ dst = coeff_fine;
+ end = coeff_fine + sfm_end[num_sfm-1] - sfm_end[last_sfm];
+
+ src = SWB_signal + START_EXC;
+ peak_src = peak_pos + START_EXC;
+
+ FOR (i = 0; i < Npeaks; i++)
+ {
+ if ( LT_16(peak_idx[i], L_HARMONIC_EXC))
+ {
+ peak_pos[peak_idx[i]] = 1;
+ move16();
+ }
+ }
+
+ i = sub(L_HARMONIC_EXC, 1);
+ WHILE ( i-- > 0 )
+ {
+ IF ( EQ_16(peak_pos[i], 1))
+ {
+ BREAK;
+ }
+ }
+
+ if ( LT_16(i, 180))
+ {
+ i = 180;
+ move16();
+ }
+
+ FOR ( j = L_HARMONIC_EXC-1; j > i+1; j-- )
+ {
+ SWB_signal[j] = 0;
+ move16();
+ }
+
+ peak_dst = bwe_peaks + sfm_end[last_sfm];
+ WHILE ( dst < end )
+ {
+ test();
+ WHILE ( dst < end && src < &SWB_signal[L_HARMONIC_EXC] )
+ {
+ *dst++ = *src++;
+ move16();
+ *peak_dst++ = *peak_src++;
+ move16();
+ }
+ peak_src--;
+ src --;
+
+ test();
+ WHILE ( dst < end && src >= &SWB_signal[START_EXC] )
+ {
+ *dst++ = *src--;
+ move16();
+ *peak_dst++ = *peak_src--;
+ move16();
+ }
+ peak_src++;
+ src++;
+ }
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * hq_fold_bwe_fx()
+ *
+ * HQ mode folding BWE
+ *--------------------------------------------------------------------------*/
+
+void hq_fold_bwe_fx(
+ const Word16 last_sfm, /* i : last coded subband Q0 */
+ const Word16 *sfm_end, /* i : Subband end coefficient Q0 */
+ const Word16 num_sfm, /* i : Number of subbands Q0 */
+ Word16 *coeff /* i/o: coded/noisefilled normalized spectrum Q12 */
+)
+{
+ Word16 low_coeff;
+ Word16 first_coeff;
+ Word16 *src, *dst, *end;
+
+ low_coeff = shr(sfm_end[last_sfm], 1);
+ src = coeff + sfm_end[last_sfm] - 1;
+
+ first_coeff = sfm_end[last_sfm];
+ dst = coeff + sfm_end[last_sfm];
+ end = coeff + sfm_end[num_sfm-1];
+
+ WHILE(dst < end)
+ {
+ WHILE(dst < end && src >= &coeff[low_coeff])
+ {
+ *dst++ = *src--;
+ move16();
+ }
+
+ src++;
+
+ WHILE(dst < end && src < &coeff[first_coeff])
+ {
+ *dst++ = *src++;
+ move16();
+ }
+ }
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * apply_nf_gain()
+ *
+ * Apply noise fill gain
+ *--------------------------------------------------------------------------*/
+
+void apply_nf_gain_fx(
+ const Word16 nf_idx, /* i : noise fill gain index Q0 */
+ const Word16 last_sfm, /* i : last coded subband Q0 */
+ const Word16 *R, /* i : bit allocation Q0 */
+ const Word16 *sfm_start, /* i : Subband start coefficient Q0 */
+ const Word16 *sfm_end, /* i : Subband end coefficient Q0 */
+ Word16 *coeff /* i/o: coded/noisefilled normalized spectrum Q12 */
+)
+{
+ Word16 sfm;
+ Word16 j;
+
+ FOR (sfm = 0; sfm <= last_sfm; sfm++)
+ {
+ IF (R[sfm] == 0)
+ {
+ FOR (j = sfm_start[sfm]; j < sfm_end[sfm]; j++)
+ {
+ /* Scale NoiseFill */
+ coeff[j] = shr(coeff[j], nf_idx);
+ move16();
+ }
+ }
+ }
+
+ return;
+}
+
+
+/*--------------------------------------------------------------------------*
+ * harm_bwe_fx()
+ *
+ * HQ Harmonic BWE
+ *--------------------------------------------------------------------------*/
+
+void harm_bwe_fx(
+ const Word16 *coeff_fine, /* i : fine structure for BWE */
+ const Word16 *coeff, /* i : coded/noisefilled normalized spectrum */
+ const Word16 num_sfm, /* i : Number of subbands */
+ const Word16 *sfm_start, /* i : Subband start coefficient */
+ const Word16 *sfm_end, /* i : Subband end coefficient */
+ const Word16 last_sfm, /* i : last coded subband */
+ const Word16 *R, /* i : bit allocation */
+ const Word16 prev_hq_mode, /* i : previous hq mode */
+ Word16 *norm, /* i/o: quantization indices for norms */
+ Word16 *noise_level, /* i/o: noise levels for harmonic modes */
+ Word16 *prev_noise_level, /* i/o: noise factor in previous frame */
+ Word16 *bwe_seed, /* i/o: random seed for generating BWE input */
+ Word32 *coeff_out /* o : coded/noisefilled spectrum */
+)
+{
+ Word16 i, j;
+ Word16 sfm, band_width;
+ Word32 normq, L_tmp,L_tmp2;
+ Word32 E_L;
+ Word16 alfa = 16384;
+ Word16 tmp, tmp1, exp1;
+ Word16 beta;
+ Word32 *src, *dst;
+
+ move16(); /* alfa */
+
+ FOR (sfm = 0; sfm <= last_sfm; sfm++)
+ {
+ IF (R[sfm] == 0)
+ {
+ normq = dicn_fx[norm[sfm]]; /*Q14 */ move16();
+
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ coeff_out[i] = L_shl(Mult_32_16(normq, coeff[i]),1);
+ move32(); /*12 Q(14 +12+1-16 +1) */
+
+ }
+ }
+ }
+ noise_level[1] = noise_level[0];
+ move16();
+
+ /* shaping the BWE spectrum further by envelopes and noise factors */
+ L_tmp = L_mult(29491, prev_noise_level[0]); /* 15 +1 +15 */
+ noise_level[0] = round_fx(L_mac(L_tmp, 3277, noise_level[0])); /*15 */
+
+ L_tmp = L_mult(29491, prev_noise_level[1]);
+ noise_level[1] = round_fx(L_mac(L_tmp, 3277, noise_level[1]));
+
+ test();
+ IF (prev_hq_mode == HQ_NORMAL || EQ_16(prev_hq_mode, HQ_GEN_SWB))
+ {
+ IF (LT_16(noise_level[0], 8192))
+ {
+ noise_level[0] = shl(noise_level[0], 2);
+ move16();
+ }
+
+ IF (LT_16(noise_level[1], 8192))
+ {
+ noise_level[1] = shl(noise_level[1], 2);
+ move16();
+ }
+ }
+
+ FOR (i = add(last_sfm, 1); i < num_sfm; i++)
+ {
+ E_L = 1;
+ move32();
+ FOR (j = sfm_start[i]; j < sfm_end[i]; j++)
+ {
+ L_tmp =L_mult0(coeff_fine[j], coeff_fine[j]);/*Q30 */
+ E_L =L_add(E_L,L_shr(L_tmp,6));/*Q24 */
+ }
+
+ normq = dicn_fx[norm[i]];
+ move32();
+
+ alfa = noise_level[0];
+ move16();
+ if (GT_16(i, 27))
+ {
+ alfa = noise_level[1];
+ move16();
+ }
+
+ band_width = sub(sfm_end[i], sfm_start[i]); /* */
+ exp1 =norm_l(E_L);
+ IF(exp1 ==0)
+ {
+ E_L = Mult_32_16(E_L, inv_tbl_fx[band_width]); /* Q24 (24+15+1-16) *//*24+15+1-16 */
+ tmp = div_l(E_L,sub(32767,alfa)); /*Q24-15-1 =8 */
+ tmp = s_max(1,tmp);
+ L_tmp =L_deposit_h(tmp); /*24 */
+ E_L = Isqrt(L_tmp); /* Q19 (31-24/2) */
+ }
+ ELSE
+ {
+ exp1 =sub(exp1,1);
+ E_L = Mult_32_16(L_shl(E_L,exp1), inv_tbl_fx[band_width]); /* Q24+exp1 (24+exp1+15+1-16) */
+ tmp = div_l(E_L,sub(32767,alfa)); /*Q24+exp1-15-1 =8+exp1 */
+ tmp = s_max(1,tmp);
+ L_tmp =L_shl(L_deposit_l(tmp),sub(16,exp1)); /*24 8+exp1+16-exp1 */
+ E_L = Isqrt(L_tmp); /* Q19 (31-24/2) */
+ }
+
+ exp1 = norm_s(alfa);
+ tmp1 = shl(alfa, exp1);
+ exp1 = add(1, exp1);
+ tmp1 = s_max(tmp1, 16384);
+ tmp1 = div_s(16384, tmp1);
+ L_tmp2 = L_deposit_h(tmp1);
+ L_tmp2 = Isqrt_lc(L_tmp2, &exp1);
+ beta = round_fx(L_shl(L_tmp2, exp1));
+ beta =shr(beta,1); /*Q15 */
+
+
+ FOR(sfm = sfm_start[i]; sfm < sfm_end[i]; sfm++)
+ {
+ L_tmp = Mult_32_16(E_L,coeff_fine[sfm]); /*Q19 19 + 15 +1-16 */
+ L_tmp = L_shl(L_tmp,9);/*Q28 */
+ tmp = Random(bwe_seed); /*Q15 */
+ L_tmp2 =L_shr(L_mult(beta,tmp),3);/* Q28 31-3 15+15 +1-3 */
+ L_tmp =L_add(L_tmp,L_tmp2);/*Q28 */
+ coeff_out[sfm] = L_shl(Mult_32_32(L_tmp, normq),1);/*Q12 28 +14 +1 -31 */ move32();
+ }
+ }
+
+ prev_noise_level[0] = noise_level[0];
+ move16();
+ prev_noise_level[1] = noise_level[1];
+ move16();
+
+ src = &coeff_out[add(sfm_end[last_sfm], L_HARMONIC_EXC - START_EXC)]; /*Q12 */
+
+ dst = src-1;
+ FOR( i = 0; i < 16; i++ )
+ {
+ *src = Mult_32_16(*src, hvq_bwe_fac_fx[i]); /* Q12 (12+15+1-16) */ move32();
+ src++;
+ *dst = Mult_32_16(*dst, hvq_bwe_fac_fx[i]); /* Q12 (12+15+1-16) */ move32();
+ dst--;
+ }
+ IF(EQ_16(num_sfm, 33))
+ {
+ set32_fx(&coeff_out[800], 0, 160);
+ }
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * HVQ_bwe_fx()
+ *
+ * HQ HVQ BWE
+ *--------------------------------------------------------------------------*/
+
+void hvq_bwe_fx(
+ const Word32 *L_coeff, /* i : coded/noisefilled normalized spectrum Q12 */
+ const Word16 *coeff_fine, /* i : coded/noisefilled normalized spectrum Qin */
+ const Word16 *sfm_start, /* i : Subband start coefficient Q0 */
+ const Word16 *sfm_end, /* i : Subband end coefficient Q0 */
+ const Word16 *sfm_len, /* i : Subband length Q0 */
+ const Word16 last_sfm, /* i : last coded subband Q0 */
+ const Word16 prev_hq_mode, /* i : previous hq mode Q0 */
+ const Word16 *bwe_peaks, /* i : HVQ bwe peaks Q0 */
+ const Word16 bin_th, /* i : HVQ transition bin Q0 */
+ const Word16 num_sfm, /* i : Number of bands Q0 */
+ const Word32 core_brate, /* i : Core bit-rate Q0 */
+ const Word16 *R, /* i : Bit allocation */
+ Word16 *norm, /* i/o: quantization indices for norms Q0 */
+ Word16 *noise_level, /* i/o: noise levels for harmonic modes Q15 */
+ Word16 *prev_noise_level, /* i/o: noise factor in previous frame Q15 */
+ Word16 *bwe_seed, /* i/o: random seed for generating BWE input Q0 */
+ Word32 *L_coeff_out, /* o : coded/noisefilled spectrum Qout*/
+ const Word16 qin,
+ const Word16 qout
+)
+{
+ Word16 i, j;
+ Word16 N;
+ Word32 L_normq;
+ Word32 L_E;
+ Word32 L_tmp_norm = 0;
+ Word16 bwe_noise_th = 0;
+ Word16 peak_band, low, high, sel_norm;
+ Word16 norm_ind;
+ Word32 *L_src, *L_dst;
+ Word16 istart, iend;
+ Word16 offset = sfm_end[last_sfm];
+
+ /* Fx specific variables */
+ Word32 L_tmp0, L_tmp1;
+ Word16 tmp, tmp2, band_size;
+ Word16 last_norm_ind;
+ Word16 shift, power_shift;
+ Word16 coeff_s[L_FRAME48k];
+ Word16 j_N;
+ Word16 n_c;
+ UWord16 lsb;
+
+ move32(); /* L_tmp_norm */
+ move16(); /* bwe_noise_th */
+
+ bwe_noise_th = add(bin_th, shr(sub(sfm_end[sub(num_sfm,1)], bin_th),1));
+ logqnorm_fx(&L_coeff_out[sfm_start[last_sfm]], qout, &norm[last_sfm], 40, sfm_len[last_sfm], 0);
+ move16();
+
+ /* shaping the BWE spectrum further by envelopes and noise factors */
+ noise_level[0] = round_fx(L_mac(L_mult(29491,prev_noise_level[0]),3277,noise_level[0])); /* Q15 (15+15+1-16) */
+ noise_level[1] = round_fx(L_mac(L_mult(29491,prev_noise_level[1]),3277,noise_level[1])); /* Q15 (15+15+1-16) */
+
+ test();
+ IF (prev_hq_mode == HQ_NORMAL || EQ_16(prev_hq_mode, HQ_GEN_SWB))
+ {
+ IF( LT_16(noise_level[0], 8192 /* 0.25f */))
+ {
+ noise_level[0] = shl(noise_level[0], 2);
+ move16();
+ }
+
+ IF( LT_16(noise_level[1], 8192 /* 0.25f */))
+ {
+ noise_level[1] = shl(noise_level[1], 2);
+ move16();
+ }
+ }
+
+ norm_ind = add(last_sfm, 1);
+ IF ( EQ_32(core_brate, HQ_24k40))
+ {
+ peak_band = 0;
+ move16();
+
+ tmp = 1;
+ move16();
+ FOR (i = sfm_start[norm_ind]; i < sfm_end[norm_ind+1]; i++)
+ {
+ tmp2 = abs_s(coeff_fine[i-offset]);
+ tmp = s_max(tmp, tmp2);
+ }
+ band_size = sub(sfm_end[norm_ind+1], sfm_start[norm_ind]);
+
+ /* Headroom for square and accumulate */
+ shift = sub(norm_s(tmp), sqac_headroom_fx[band_size]);
+ L_E = L_deposit_l(1);
+ FOR (i = sfm_start[norm_ind]; i < sfm_end[norm_ind+1]; i++)
+ {
+ if (bwe_peaks[i])
+ {
+ peak_band = 1;
+ move16();
+ }
+ /* E_L += coeff_fine[i-offset] * coeff_fine[i-offset]; */
+ coeff_s[i] = shl(coeff_fine[i-offset], shift);
+ move16();/* Q15 + shift */
+ L_E = L_mac0(L_E, coeff_s[i], coeff_s[i]); /* Q2*(qin + shift) */
+ }
+ power_shift = shl(shift, 1);
+
+ L_E = L_shr(L_E,sub(power_shift,28-2*qin)); /* Q28 */
+
+ /* E_L = (float)sqrt((sfm_end[norm_ind+1] - sfm_start[norm_ind])/E_L); */
+ L_E = Mult_32_16(L_E, inv_tbl_fx[band_size]); /* Q28 (28+15+1-16) */
+ /* To avoid overflow in Isqrt() */
+ if( L_E == 0 )
+ {
+ L_E = L_deposit_l(1);
+ }
+ L_E = Isqrt(L_E); /* Q17 (31-28/2) */
+
+ /* normq = 0.1f*dicn[norm[norm_ind-1]] + 0.8f*dicn[norm[norm_ind]] + 0.1f*dicn[norm[norm_ind+1]]; */
+ /* tmp_norm = 0.1f*dicn[norm[norm_ind]] + 0.8f*dicn[norm[norm_ind+1]] + 0.1f*dicn[norm[norm_ind+2]]; */
+ L_tmp0 = L_add(dicn_fx[norm[norm_ind]], 0);
+ L_tmp1 = L_add(dicn_fx[norm[norm_ind+1]], 0);
+ L_normq = Madd_32_16(Madd_32_16(Mult_32_16(L_tmp0, 26214 /* Q15, 0.8f */), dicn_fx[norm[norm_ind-1]], 3277 /* Q15, 0.1f */), L_tmp1, 3277 /* Q15, 0.1f */); /* Q14 (14+15+1-16) */ move16();
+ L_tmp_norm = Madd_32_16(Madd_32_16(Mult_32_16(L_tmp1, 26214 /* Q15, 0.8f */), dicn_fx[norm[norm_ind+2]], 3277 /* Q15, 0.1f */), L_tmp0, 3277 /* Q15, 0.1f */); /* Q14 (14+15+1-16) */ move16();
+
+ istart = sfm_start[norm_ind];
+ move16();
+ /* iend = istart + sfm_len[norm_ind]/2; */
+ iend = 240;
+ move16();
+
+ noise_mix_fx( &coeff_fine[-offset], L_E, L_normq, bwe_seed, istart, iend, noise_level[0], L_coeff_out, qin, qout);
+
+ j = 0;
+ move16();
+ /* N = sfm_len[norm_ind]/2+sfm_len[norm_ind+1]/2-1; */
+ N = 31;
+ move16();
+ j_N = N;
+ move16();
+
+ istart = iend;
+ move16();
+ /* iend = sfm_start[norm_ind+1] + sfm_len[norm_ind+1]/2; */
+ iend = 272;
+ move16();
+
+ /* special case that is not handled by noise_mix_fx() */
+ n_c = sub(MAX_16,noise_level[0]); /* Q15 */
+ FOR (i = istart; i < iend; i++)
+ {
+ /* coeff_out[i] = ((float)(N-j)/N*normq + (float)j/N*tmp_norm)*((1.0f - noise_level[i/bwe_noise_th])*coeff_fine[i-offset]*E_L + noise_level[i/bwe_noise_th]*own_random(bwe_seed)/32768.0f); */
+ L_tmp1 = Madd_32_16(Mult_32_16(L_normq, inv_N_fx[j_N] ), L_tmp_norm, inv_N_fx[j]); /* Q14 (14+15+1-16) */
+ j = add(j,1);
+ j_N = sub(j_N,1);
+
+ Mpy_32_16_ss(L_E, coeff_fine[i-offset], &L_tmp0, &lsb); /* Qin+2 (17+qin+1-16) */
+ Mpy_32_16_ss(L_tmp0, n_c, &L_tmp0, &lsb); /* Qin+2-15 (qin+2+15+1-16) */
+
+ IF(L_tmp0 != 0)
+ {
+ /* Normalize with 1 bit headroom for addition */
+ tmp = 30-(qin+2); /* Assuming fixed Q values */
+ tmp = s_min(norm_l(L_tmp0), tmp);
+ tmp = sub(tmp,1);
+
+ L_tmp0 = L_add(L_shl(L_tmp0,tmp), L_deposit_l(lshr(lsb, sub(16,tmp)))); /* Qin+2+tmp */
+
+ L_tmp0 = L_add(L_tmp0, L_shr(L_mult0(noise_level[0], Random(bwe_seed)), sub(30-(qin+2), tmp))); /* Qin+2+tmp */
+ tmp = round_fx(L_shl(L_tmp0,27-(qin+2)-tmp)); /* Q11 (Qin+2+tmp+27-qin-2-tmp-16) */
+
+ Mpy_32_16_ss(L_tmp1, tmp, &L_tmp0, &lsb); /* Q10 (14+11+1-16) */
+ L_coeff_out[i] = L_add(L_shl(L_tmp0,qout-10), L_deposit_l(lshr(lsb, 10+16-qout)));
+ move32(); /* Qout (10+qout-10) */
+ }
+ ELSE
+ {
+ L_tmp0 = L_mult0(noise_level[0], Random(bwe_seed)); /* Q30 (15+15) */
+ tmp = round_fx(L_tmp0); /* Q14 (30-16) */
+ Mpy_32_16_ss(L_tmp1, tmp, &L_tmp0, &lsb); /* Q13 (14+14+1-16) */
+ L_coeff_out[i] = L_shr(L_tmp0,13-qout);
+ move32();/* Qout (13-(13-qout)) */
+ }
+ }
+
+ istart = iend;
+ move16();
+ iend = sfm_end[norm_ind+1];
+ move16();
+
+ noise_mix_fx( &coeff_fine[-offset], L_E, L_tmp_norm, bwe_seed, istart, iend, noise_level[0], L_coeff_out, qin, qout);
+
+ norm_ind = add(norm_ind, 2);
+ }
+
+ FOR ( ; norm_ind < num_sfm; norm_ind++)
+ {
+ IF ( R[norm_ind] == 0 )
+ {
+ peak_band = 0;
+ move16();
+
+ FOR (i = sfm_start[norm_ind]; i < sfm_end[norm_ind]; i++)
+ {
+ if (bwe_peaks[i])
+ {
+ peak_band = 1;
+ move16();
+ }
+ }
+
+ istart = sfm_start[norm_ind];
+ move16();
+ iend = sfm_end[norm_ind];
+ move16();
+
+ last_norm_ind = sub(num_sfm, 1);
+ test();
+ test();
+ IF ( EQ_16(peak_band, 1)&>_16(norm_ind,add(last_sfm,1))&<_16(norm_ind,last_norm_ind))
+ {
+ istart = sub(istart, shr(sfm_len[norm_ind-1],1));
+ iend = add(iend, shr(sfm_len[norm_ind+1],1));
+ }
+
+ tmp = 1;
+ move16();
+ FOR (i = istart; i < iend; i++)
+ {
+ tmp2 = abs_s(coeff_fine[i-offset]);
+ tmp = s_max(tmp, tmp2);
+ }
+ band_size = sub(iend, istart);
+ /* Headroom for square and accumulate */
+ shift = sub(norm_s(tmp), sqac_headroom_fx[band_size]);
+
+ L_E = 1L;
+ move32();
+ FOR (i = istart; i < iend; i++)
+ {
+ /* E_L += coeff_fine[i-offset] * coeff_fine[i-offset]; */
+ coeff_s[i] = shl(coeff_fine[i-offset], shift);
+ move16();/* Q15 + shift */
+ L_E = L_mac0(L_E, coeff_s[i], coeff_s[i]); /* Q2*(15 + shift) */
+ }
+ power_shift = shl(shift, 1);
+
+ L_E = L_shr(L_E,sub(power_shift,28-2*qin)); /* Q28 */
+
+ /* E_L = (float)sqrt((iend - istart)/E_L); */
+ L_E = Mult_32_16(L_E, inv_tbl_fx[band_size]); /* Q28 (28+15+1-16) */
+ /* To avoid overflow in Isqrt() */
+ if( L_E == 0 )
+ {
+ L_E = 1L;
+ move32();
+ }
+ L_E = Isqrt(L_E); /* Q17 (31-28/2) */
+
+ IF ( peak_band )
+ {
+ IF ( GT_16(add(norm_ind,2), num_sfm))
+ {
+ /* normq = 0.15f*dicn[norm[norm_ind-1]] + 0.85f*dicn[norm[norm_ind]]; */
+ L_normq = Madd_32_16(Mult_32_16(dicn_fx[norm[norm_ind]], 27853 /* Q15, 0.85f */), dicn_fx[norm[norm_ind-1]], 4915 /* Q15, 0.1f */); /* Q14 (14+15+1-16) */ move16();
+ move16();
+ }
+ ELSE
+ {
+ /* normq = 0.1f*dicn[norm[norm_ind-1]] + 0.8f*dicn[norm[norm_ind]] + 0.1f*dicn[norm[norm_ind+1]]; */
+ L_normq = Madd_32_16(Madd_32_16(Mult_32_16(dicn_fx[norm[norm_ind]], 26214 /* Q15, 0.8f */), dicn_fx[norm[norm_ind+1]], 3277 /* Q15, 0.1f */), dicn_fx[norm[norm_ind-1]], 3277 /* Q15, 0.1f */); /* Q14 (14+15+1-16) */ move16();
+ move16();
+ move16();
+ }
+ }
+ ELSE
+ {
+ low = norm_ind;
+ move16();
+ high = s_min(add(norm_ind,1), last_norm_ind);
+ move16();
+ sel_norm = norm[norm_ind-1];
+ move16();
+ FOR (j = low; j <= high; j++)
+ {
+ if ( GT_16(norm[j], sel_norm))
+ {
+ sel_norm = norm[j];
+ move16();
+ }
+ }
+ L_normq = dicn_fx[sel_norm];
+ move16();
+ }
+
+ iend = s_min(sfm_end[norm_ind], bwe_noise_th);
+ move16();
+ IF( GT_16(iend, sfm_start[norm_ind]))
+ {
+ noise_mix_fx( &coeff_fine[-offset], L_E, L_normq, bwe_seed, sfm_start[norm_ind], iend, noise_level[0], L_coeff_out, qin, qout);
+ }
+ ELSE
+ {
+ iend = sfm_end[norm_ind];
+ move16();
+ noise_mix_fx( &coeff_fine[-offset], L_E, L_normq, bwe_seed, sfm_start[norm_ind], iend, noise_level[1], L_coeff_out, qin, qout);
+ }
+ /* Noisemix up to threshold done */
+ IF( EQ_16(iend, bwe_noise_th))
+ {
+ noise_mix_fx( &coeff_fine[-offset], L_E, L_normq, bwe_seed, iend, sfm_end[norm_ind], noise_level[1], L_coeff_out, qin, qout);
+ }
+
+ }
+ ELSE /* R[norm_ind] > 0 */
+ {
+ FOR (i = sfm_start[norm_ind]; i < sfm_end[norm_ind]; i++)
+ {
+ L_coeff_out[i] = L_coeff[i]; /* Scaling already applied */ move32();
+ }
+ }
+ }
+
+ prev_noise_level[0] = noise_level[0];
+ move16();
+ prev_noise_level[1] = noise_level[1];
+ move16();
+ L_src = &L_coeff_out[add(sfm_end[last_sfm], L_HARMONIC_EXC - START_EXC)]; /* Address initialization */
+ L_dst = L_src - 1 ; /* Address computation */
+
+ FOR( i = 0; i < 16; i++ )
+ {
+ *L_src = Mult_32_16(*L_src, hvq_bwe_fac_fx[i]);
+ L_src++; /* Qout (Qout+15+1-16) */ move32();
+ *L_dst = Mult_32_16(*L_dst, hvq_bwe_fac_fx[i]);
+ L_dst--; /* Qout (Qout+15+1-16) */ move32();
+ }
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+* hvq_concat_bands_fx()
+*
+* Compute the band limits for concatenated bands for PVQ target signal in HVQ
+*--------------------------------------------------------------------------*/
+void hvq_concat_bands_fx
+(
+ const Word16 pvq_bands, /* i : Number of bands in concatenated PVQ target */
+ const Word16 *sel_bnds, /* i : Array of selected high bands */
+ const Word16 n_sel_bnds, /* i : Number of selected high bands */
+ Word16 *hvq_band_start, /* i : Band start indices */
+ Word16 *hvq_band_width, /* i : Band widths */
+ Word16 *hvq_band_end /* i : Band end indices */
+)
+{
+ Word16 k, k_1;
+ const Word16 *pSelBnds;
+
+ pSelBnds = sel_bnds;
+ FOR (k = 0; k < pvq_bands; k++)
+ {
+
+ IF( GE_16(k, sub(pvq_bands, n_sel_bnds)))
+ {
+ k_1 = sub(k, 1);
+ hvq_band_start[k] = hvq_band_end[k_1];
+ move16();
+ hvq_band_width[k] = band_len_harm[*pSelBnds++];
+ move16();
+ move16();
+ hvq_band_end[k] = add(hvq_band_end[k_1], hvq_band_width[k]);
+ move16();
+ }
+ ELSE
+ {
+ hvq_band_start[k] = extract_l(L_mult0(k, HVQ_PVQ_COEFS));
+ hvq_band_width[k] = HVQ_PVQ_COEFS;
+ move16();
+ hvq_band_end[k] = add(hvq_band_start[k], HVQ_PVQ_COEFS);
+ move16();
+ }
+ }
+
+ return;
+}
+/*--------------------------------------------------------------------------*
+ * noise_mix_fx()
+ *--------------------------------------------------------------------------*/
+
+void noise_mix_fx(
+ const Word16 *coeff_fine, /* i : normalized fine structure spectrum Qin */
+ const Word32 L_E, /* i : normalization factor Q17 */
+ const Word32 L_normq, /* i : quantized norm Q14 */
+ Word16 *seed, /* i/o: random seed Q0 */
+ const Word16 istart, /* i : start coefficient Q0 */
+ const Word16 iend, /* i : end coefficient Q0 */
+ const Word16 noise_level, /* i : noise_level Q0 */
+ Word32 *L_coeff_out, /* o : noise mixed spectrum Qout */
+ const Word16 qin,
+ const Word16 qout
+)
+{
+ Word16 i, tmp, n_c;
+ Word32 L_tmp0;
+ UWord16 lsb;
+
+ n_c = sub(MAX_16,noise_level); /* Q15 */
+ FOR (i = istart; i < iend; i++)
+ {
+ /* L_coeff_out[i] = ((1.0f - noise_level)*coeff_fine[i]*L_E + noise_level*own_random(seed)/32768.0f)*normq; */
+ Mpy_32_16_ss(L_E, coeff_fine[i], &L_tmp0, &lsb); /* Qin+qL_E-15 (qL_E+qin+1-16) */
+ Mpy_32_16_ss(L_tmp0, n_c, &L_tmp0, &lsb); /* Qin+qL_E-15 (qin+qL_E-15+15+1-16) */
+
+ IF(L_tmp0 != 0)
+ {
+ /* Normalize with 1 bit headroom for addition */
+ tmp = 30-(qin+2); /* Assuming fixed Q values */
+ tmp = s_min(norm_l(L_tmp0), tmp);
+ tmp = sub(tmp,1);
+
+ L_tmp0 = L_add(L_shl(L_tmp0,tmp), L_deposit_l(lshr(lsb, sub(16,tmp)))); /* Qin+2+tmp */
+ L_tmp0 = L_add(L_tmp0, L_shr(L_mult0(noise_level, Random(seed)), sub(30-(qin+2), tmp))); /* Qin+2+tmp */
+
+ tmp = round_fx(L_shl(L_tmp0,27-(qin+2)-tmp)); /* Q11 (Qin+2+tmp+27-qin-2-tmp-16) */
+ Mpy_32_16_ss(L_normq, tmp, &L_tmp0, &lsb); /* Q10 (14+11+1-16) */
+ L_coeff_out[i] = L_add(L_shl(L_tmp0,qout-10), L_deposit_l(lshr(lsb, 10+16-qout)));
+ move32();/* Qout (10+qout-10) */
+ }
+ ELSE
+ {
+ L_tmp0 = L_mult0(noise_level, Random(seed)); /* Q30 (15+15) */
+ tmp = round_fx(L_tmp0); /* Q14 (30-16) */
+ Mpy_32_16_ss(L_normq, tmp, &L_tmp0, &lsb); /* Q13 (14+14+1-16) */
+ L_coeff_out[i] = L_shr(L_tmp0,13-qout);
+ move32();/* Qout (13-(13-qout)) */
+ }
+ }
+}
+
+
+/*--------------------------------------------------------------------------*
+ * hq_generic_fine_fx()
+ *
+ * Prepare HQ GENERIC HF fine structure
+ *--------------------------------------------------------------------------*/
+void hq_generic_fine_fx(
+ Word16 *coeff, /* i : coded/noisefilled normalized spectrum */
+ const Word16 last_sfm, /* i : Last coded band */
+ const Word16 *sfm_start, /* i : Subband start coefficient */
+ const Word16 *sfm_end, /* i : Subband end coefficient */
+ Word16 *bwe_seed, /* i/o: random seed for generating BWE input */
+ Word16 *coeff_out1 /* o : HQ GENERIC input */
+)
+{
+ Word16 sfm;
+ Word16 i;
+
+ FOR (sfm = 0; sfm <= last_sfm; sfm++)
+ {
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ IF (coeff[i]==0)
+ {
+ coeff_out1[i] = -2048;
+ move16();
+ if (Random(bwe_seed) > 0)
+ {
+ coeff_out1[i] = 2048;
+ move16();
+ }
+ }
+ ELSE
+ {
+ coeff_out1[i] = coeff[i];
+ move16();
+ }
+ }
+ }
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * overlap_hq_bwe_fx()
+ *
+ * Overlapping at the boundary between HQ core and BWE
+ *--------------------------------------------------------------------------*/
+static void overlap_hq_bwe_fx(
+ const Word32 *hq_swb_overlap_buf, /* i : spectrum from HQ core */
+ Word32 *coeff_out, /* i/o: spectrum from BWE, overlapped output */
+ const Word16 n_swb_overlap_offset, /* i : starting offset of overlapping */
+ const Word16 n_swb_overlap, /* i : length of overlapping */
+ const Word16 *R,
+ const Word16 num_env_bands,
+ const Word16 num_sfm,
+ const Word16 *sfm_end
+)
+{
+ Word16 i;
+ Word16 weighting;
+ Word16 step;
+ Word16 exp, tmp, n_band;
+
+ IF ( R[sub(num_env_bands,1)] != 0)
+ {
+ Copy32( hq_swb_overlap_buf, &coeff_out[n_swb_overlap_offset], n_swb_overlap );
+ }
+ ELSE
+ {
+ exp = norm_s(n_swb_overlap);
+ tmp = div_s(16384, shl(n_swb_overlap, exp));/*15 + 14 - exp */
+ tmp = shr(tmp, sub(14, exp));/*15 */
+ step = mult_r(tmp, 32767);/*15 */
+ weighting = 32767;
+ move16();
+ FOR (i = 0; i < n_swb_overlap; i++)
+ {
+ coeff_out[add(n_swb_overlap_offset,i)] = L_add(coeff_out[add(n_swb_overlap_offset,i)],
+ Mult_32_16(L_sub(hq_swb_overlap_buf[i], coeff_out[add(n_swb_overlap_offset,i)]), weighting));
+ move32();
+ weighting = sub(weighting, step);
+ }
+ }
+
+ FOR (n_band = num_env_bands; n_band < num_sfm; n_band++)
+ {
+ IF (R[n_band] !=0 )
+ {
+ FOR(i=sfm_end[sub(n_band,1)]; i0)
+ {
+ i=sub(nb_sfm,1);
+ WHILE(b_add_bits_denv>0 && i>=0)
+ {
+ IF ( GT_16(Rsubband[i], 24))
+ {
+ Rsubband[i] = sub(Rsubband[i] , 8);
+ move16();
+ b_add_bits_denv = sub(b_add_bits_denv,1);
+ }
+ i = sub(i,1);
+ }
+ }
+
+ return;
+}
+
+Word16 get_nor_delta_hf_fx(
+ Decoder_State_fx *st,
+ Word16 *ynrm,
+ Word16 *Rsubband, /* Q3 */
+ const Word16 num_env_bands,
+ const Word16 nb_sfm,
+ const Word16 core_sfm
+)
+{
+ Word16 i;
+ Word16 delta,bitsforDelta,add_bits_denv;
+
+ add_bits_denv = 0;
+ move16();
+ IF (GE_16(core_sfm ,num_env_bands))
+ {
+ bitsforDelta = (Word16)get_next_indice_fx(st,2);
+ bitsforDelta = add(bitsforDelta, 2);
+ add_bits_denv = add(add_bits_denv,2);
+
+ FOR(i=num_env_bands; iBER_detect = 1;
+ move16();
+ }
+ /*ynrm[i] += delta - (1<<(bitsforDelta-1));*/
+ add_bits_denv = add(add_bits_denv,bitsforDelta);
+ }
+ }
+ update_rsubband_fx(nb_sfm, Rsubband,add_bits_denv);
+ }
+ return add_bits_denv;
+}
+
+Word16 calc_nor_delta_hf_fx(
+ Encoder_State_fx *st,
+ const Word32 *t_audio,
+ Word16 *ynrm,
+ Word16 *Rsubband,
+ const Word16 num_env_bands,
+ const Word16 nb_sfm,
+ const Word16 *sfmsize,
+ const Word16 *sfm_start,
+ const Word16 core_sfm
+)
+{
+ Word16 i;
+ Word16 ynrm_t[44],normqlg2_t[44];
+ Word16 delta,max_delta,min_delta,bitsforDelta,add_bits_denv;
+ Word16 temp_num;
+
+ temp_num=0;
+ move16();
+
+ max_delta=-100;
+ move16();
+ calc_norm_fx( t_audio, 12, ynrm_t, normqlg2_t, 0, nb_sfm, sfmsize, sfm_start );
+ add_bits_denv = 0;
+ move16();
+ FOR(i=num_env_bands; i 0)
+ {
+ delta = add(delta,1);
+ }
+ ELSE
+ {
+ delta = negate(delta);
+ }
+ if (GT_16(delta,max_delta))
+ {
+ max_delta = delta;
+ move16();
+ }
+ }
+ }
+ IF (GE_16(core_sfm ,num_env_bands))
+ {
+ IF (LT_16(max_delta, 16))
+ {
+ bitsforDelta = 2;
+ move16();
+ FOR( ; max_delta >= 2; max_delta >>= 1 )
+ {
+ bitsforDelta = add(bitsforDelta,1);
+ }
+ }
+ ELSE
+ {
+ bitsforDelta = 5;
+ move16();
+ }
+ max_delta = sub( shl(1, sub(bitsforDelta,1)), 1);
+ min_delta = negate(add(max_delta,1));
+
+ /* updating norm & storing delta norm */
+ add_bits_denv = 2;
+ move16();
+ push_indice_fx( st, IND_DELTA_ENV_HQ, sub(bitsforDelta,2) , 2 );
+ FOR(i=num_env_bands; i0)
+ {
+ exp = norm_s(total_bit);
+ tmp = shl(total_bit,exp);/*Q(exp) */
+ tmp = div_s(16384,tmp);/*Q(15+14-exp) */
+ L_tmp = L_mult(tmp, bitalloc_var_fx); /*Q(29-exp+1) */
+ bitalloc_var_fx = round_fx(L_shl(L_tmp,exp));/*Q14 */
+ }
+ ELSE
+ {
+ bitalloc_var_fx = 0; /*Q14 */
+ }
+ /* calculate the peak-average ratio of saturable subbands */
+ num = 0;
+ sharp_fx = 0;
+ FOR(sfm = last_sfm; sfm >= 8; sfm--)
+ {
+ tmp = shl(sfmsize[sfm], 9);/*Q9 */
+ tmp = mult( rat_fx[sfm],tmp );/*Q(14+9-15=8) */
+ IF(GE_16(shl(R[sfm],8),tmp))
+ {
+ peak_fx = 0;
+ move16();
+ mean_fx = 0;
+ move16();
+ FOR( i = sfm_start[sfm]; i < sfm_end[sfm]; i++ )
+ {
+ fabs_coeff_out_fx = L_abs(L_coeff_out[i]);
+ mean_fx = L_add(mean_fx, fabs_coeff_out_fx);/*Q12 */
+ if(GT_32(fabs_coeff_out_fx, peak_fx))
+ {
+ peak_fx = fabs_coeff_out_fx;/*Q12 */
+ move32();
+ }
+ }
+
+ IF(mean_fx != 0)
+ {
+ exp = norm_l(mean_fx);
+ mean_fx = L_shl(mean_fx, exp);/*Q(exp+12) */
+ tmp = round_fx(mean_fx);/*Q(exp-4) */
+ tmp = div_s(16384,tmp); /*Q(15+14-exp+4 = 33-exp) */
+ L_tmp = Mult_32_16(peak_fx, tmp);/*Q(12+33-exp-15 = 30-exp) */
+ tmp = shl(sfmsize[sfm], 9);/*Q9 */
+ L_tmp = Mult_32_16(L_tmp, tmp);/*Q(30-exp+9-15 = 24-exp) */
+ tmp = round_fx(L_shl(L_tmp,exp));/*Q8 */
+ sharp_fx = add(sharp_fx,tmp);
+ }
+ num = add(num,1);
+ }
+ }
+ test();
+ IF(num != 0 && sharp_fx != 0)
+ {
+ num = add(num,num);
+ exp = norm_s(sharp_fx);
+ sharp_fx = shl(sharp_fx,exp);/*Q(8+exp) */
+ tmp = div_s(16384,sharp_fx);/*Q(21-exp) */
+ L_tmp = L_mult(num,tmp);/*Q(22-exp) */
+ sharp_fx = round_fx(L_shl(L_tmp,add(8,exp)));/*Q14 */
+ }
+ ELSE
+ {
+ sharp_fx = 16384;
+ move16();/*Q14 = 1 */
+ }
+ harm_para_fx = sharp_fx;
+ move16();/*Q14 */
+
+ IF(last_sfm == 0)
+ {
+ tmp = 0;
+ move16();
+ }
+ ELSE
+ {
+ tmp = div_s(1,last_sfm);/*Q15 */
+ }
+
+ L_tmp = L_mult(5,sharp_fx);/*Q15 */
+ L_tmp = Mult_32_16(L_tmp,tmp);/*Q15 */
+ step_fx = round_fx(L_shl(L_tmp,16));/*Q15 */
+ alfa_fx = 20480;
+ move16();/*Q13 = 2.5 */
+ /* fill noise for the insaturable subbands */
+ FOR( sfm = 0; sfm < num_sfm; sfm++ )
+ {
+ env_fx = L_deposit_l(0);
+ L_tmp2 =L_deposit_l(0);
+ exp = 0;
+ move16();
+ test();
+ IF(R[sfm] != 0 && LT_16(R[sfm], shl(mult(24756,sfmsize[sfm]),1)))
+ {
+ /* calculate the energy of the undecoded coefficients */
+ env_fx =L_deposit_l(0);
+ exp1=norm_l(L_normq_v[sfm]);
+ L_tmp4 = L_shl(L_normq_v[sfm],exp1); /*14+exp1 */
+ L_tmp1 = Mult_32_32(L_tmp4,L_tmp4); /*2*exp1-3 14+exp1+14+exp1 -31 */
+ L_tmp2 =L_deposit_l(0);
+ peak_fx = L_deposit_l(0);
+ min_coef_fx = 0x7fffffff;
+ move32();
+
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ fabs_coeff_out_fx = L_abs(L_coeff_out[i]);
+ test();
+ if(LT_32(fabs_coeff_out_fx, min_coef_fx)&&L_coeff_out[i]!=0)
+ {
+ min_coef_fx = fabs_coeff_out_fx;
+ move32();
+ }
+ if(GT_32(fabs_coeff_out_fx,peak_fx))
+ {
+ peak_fx = fabs_coeff_out_fx;
+ move32();
+ }
+ }
+
+ exp2 =norm_l(peak_fx);
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ L_tmp4 = L_shl(L_coeff_out[i],exp2); /*12+exp2 */
+ L_tmp3 = L_shr(Mult_32_32(L_tmp4,L_tmp4),4);/*2*exp2-7-4 12+exp2+12+exp2-31-4 */
+ L_tmp2 = L_add(L_tmp2 ,L_tmp3); /*2*exp2-11 */
+ }
+
+ tmp1 =div_s(1,sfmsize[sfm]); /*15 */
+ L_tmp4 = Mult_32_16(L_tmp2,tmp1);/*2*exp2-11 2*exp2-7+15+1-16 */
+
+ exp =norm_l(L_tmp1);
+ L_tmp1 = L_shl(L_tmp1,exp);/*exp + 2*exp1 - 3 */
+ exp1 =sub(add(exp,shl(exp1,1)),3);
+
+ exp =norm_l(L_tmp4);
+ L_tmp4 = L_shl(L_tmp4,exp);/*exp + 2*exp1 - 3 */
+ exp2 =sub(add(exp,shl(exp2,1)),11);
+ exp = s_min(exp1,exp2);
+
+ L_tmp1 = L_shl(L_tmp1,sub(exp,exp1));
+ L_tmp4 = L_shl(L_tmp4,sub(exp,exp2));
+ env_fx= L_sub(L_tmp1,L_tmp4); /*exp */
+ exp1 = norm_l(env_fx);
+ env_fx = L_shl(env_fx,exp1);/*exp + exp1 */
+ exp =add(exp,exp1);
+
+ IF (env_fx > 0 )
+ {
+ IF(sfm == 0)
+ {
+ avrg_norm_fx = L_add(L_shr(L_normq_v[0],1),L_shr(L_normq_v[1],1));/*13 */
+ avrg_norm_fx = L_add(avrg_norm_fx,L_shr(L_normq_v[2],1));/*13 */
+ prev_avrg_norm_fx = L_add(L_shr(prev_normq_fx[0],1),L_shr(prev_normq_fx[1],1));/*13 */
+ prev_avrg_norm_fx = L_add(prev_avrg_norm_fx,L_shr(prev_normq_fx[2],1));/*13 */
+ }
+ ELSE IF (EQ_16(sfm,25))
+ {
+ avrg_norm_fx = L_add(L_shr(L_normq_v[23],1),L_shr(L_normq_v[24],1));/*13 */
+ avrg_norm_fx = L_add(avrg_norm_fx,L_shr(L_normq_v[25],1));/*13 */
+ prev_avrg_norm_fx = L_add(L_shr(prev_normq_fx[23],1),L_shr(prev_normq_fx[24],1));/*13 */
+ prev_avrg_norm_fx = L_add(prev_avrg_norm_fx,L_shr(prev_normq_fx[25],1));/*13 */
+ }
+ ELSE
+ {
+ avrg_norm_fx = L_add(L_shr(L_normq_v[sub(sfm,1)],1),L_shr(L_normq_v[sfm],1));/*13 */
+ avrg_norm_fx = L_add(avrg_norm_fx,L_shr(L_normq_v[sfm+1],1));/*13 */
+ prev_avrg_norm_fx = L_add(L_shr(prev_normq_fx[sub(sfm,1)],1),L_shr(prev_normq_fx[sfm],1));/*13 */
+ prev_avrg_norm_fx = L_add(prev_avrg_norm_fx,L_shr(prev_normq_fx[add(sfm,1)],1));/*13 */
+ }
+
+ test();
+ test();
+ IF((GT_16(bitalloc_var_fx,4915)||LT_32(L_normq_v[sfm],peak_fx))&&peak_fx!=0)
+ {
+ Word16 exp_p;
+ exp_p =norm_l(peak_fx);
+ exp =sub(31,exp);
+ env_fx = Isqrt_lc(env_fx, &exp);
+ L_tmp1 = Mult_32_32(env_fx, L_shl(peak_fx, exp_p));/*12+exp2-exp 31-exp+12+exp1-31 */
+ L_tmp2 = Mult_32_16(avrg_norm_fx,harm_para_fx);/*12 13 + 14 + 1 -16 */
+ exp1 = norm_l(L_tmp1);
+ L_tmp1 = L_shl(L_tmp1,exp1);/* 12+exp2-exp+exp1 */
+ exp = add(sub(12,exp), add(exp1, exp_p));
+ L_tmp2 = Div_32(L_tmp2, extract_h(L_tmp1), extract_l(L_tmp1));
+ exp=sub(43,exp);
+ }
+ ELSE
+ {
+ L_tmp1 = Mult_32_16(L_normq_v[sfm],alfa_fx);/*12 13 + 14 + 1 -16 */
+ IF(LT_32(L_tmp1,peak_fx))
+ {
+ exp=sub(31,exp);
+ env_fx = Isqrt_lc(env_fx,&exp);
+ exp1 = norm_l(env_fx);
+ env_fx = L_shl(env_fx,exp1);/* 31-exp+exp1 */
+ exp = add(sub(31,exp),exp1);
+ L_tmp1 = (Word32)sharp_fx;
+ L_tmp2 = Div_32(L_tmp1, extract_h(env_fx), extract_l(env_fx)); /* 45-exp 14 - exp + 31 //39-exp 8 - exp + 31 */
+ exp = sub(45,exp);
+ exp1 = norm_l(peak_fx);
+ L_tmp1 = L_shl(peak_fx,exp1); /*12 + exp1 */
+ L_tmp1 = Div_32(L_tmp2,extract_h(L_tmp1), extract_l(L_tmp1)); /* exp - (12 + exp1) +31 */
+ L_tmp2 = Mult_32_32(L_tmp2,L_tmp1);/*2*exp+exp1-12 exp +exp - (12 + exp1) +31 - 31 */
+ exp = sub(add(shl(exp,1),exp1),12);
+ }
+ ELSE
+ {
+ exp = sub(31,exp);
+ env_fx = Isqrt_lc(env_fx,&exp);
+ exp1 = norm_l(env_fx);
+ env_fx =L_shl(env_fx,exp1);/* 31-exp+exp1 */
+ exp = add(sub(31,exp),exp1);
+ L_tmp1=(Word32)(sharp_fx);
+ L_tmp2 = Div_32(L_tmp1, extract_h(env_fx), extract_l(env_fx)); /* 45-exp 14 - exp + 31 //39-exp 8 - exp + 31 */
+ exp =sub(45,exp);
+ }
+
+ sharp_fx = add(sharp_fx,shr(step_fx,1));
+ }
+
+ IF(GT_32(L_tmp2,L_shl(min_coef_fx,sub(exp,13))))/*exp */
+ {
+ L_tmp2 = L_shr(min_coef_fx,1);
+ exp = 12;
+ move16();
+ }
+
+ IF(EQ_16(prev_bfi,1))
+ {
+ prev_env_Q[sfm] = exp;
+ move16();
+ prev_env_fx[sfm] = L_tmp2;
+ move32();
+ }
+ /* smooth the noise magnitudes between inter-frame */
+ test();
+ test();
+ IF(GT_32(prev_avrg_norm_fx,L_shr(avrg_norm_fx,1))&<_32(prev_avrg_norm_fx,L_shl(avrg_norm_fx,1))&&prev_is_transient==0)
+ {
+ exp1 =norm_l(prev_env_fx[sfm]);
+ L_tmp1 = L_shl(prev_env_fx[sfm],exp1);/* prev_env_Q[sfm] +exp1 */
+
+ exp2= norm_l(L_tmp2);
+ L_tmp3 = L_shl(L_tmp2,exp2);/* exp +exp2 */
+ exp3 = s_min(add(prev_env_Q[sfm],exp1),add(exp,exp2));
+
+ L_tmp1 = L_shl(L_tmp1,sub(sub(exp3,prev_env_Q[sfm]),exp1)); /*exp3 */
+ L_tmp3 = L_shl(L_tmp3,sub(sub(exp3,exp),exp2)); /*exp3 */
+ L_tmp2 = L_add(L_shr(L_tmp1,1),L_shr(L_tmp3,1));/*exp3 */
+ exp = exp3;
+ move16();
+ }
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ IF (coeff_fx[i] == 0)
+ {
+ tmp1 = Random(bwe_seed);/*Q15 */
+ L_tmp1= Mult_32_16(L_tmp2,tmp1);/*exp exp+15+1 -16 */
+ L_tmp1 = L_shl(L_tmp1,sub(12,exp));
+ L_coeff_out[i] = L_tmp1;
+ move32();
+ }
+ }
+ }
+ ELSE
+ {
+ exp =0;
+ move16();
+ L_tmp2 =L_deposit_l(0);
+ }
+ }
+ ELSE IF(R[sfm] == 0)
+ {
+ /* fill random noise for 0 bit subbands */
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ IF(coeff_fx[i] == 0)
+ {
+ tmp1 =Random(bwe_seed);/*Q15 */
+ L_tmp1= Mult_32_16(L_normq_v[sfm],tmp1);/*14 14+15+1 -16 */
+ L_tmp1 = L_shr(L_tmp1,2);/* */
+ L_coeff_out[i] = L_tmp1;
+ move32();
+ }
+ }
+ L_tmp2 = L_normq_v[sfm];
+ move32();
+ exp = 14;
+ move16();
+ }
+
+ test();
+ test();
+ test();
+ test();
+ IF(EQ_16(sfm,sub(SFM_N_WB,1))&&prev_is_transient==0&>_32(prev_normq_fx[sfm],L_shr(L_normq_v[sfm],1))
+ && LT_32(prev_normq_fx[sfm],L_shl(L_normq_v[sfm],1)) && LE_16(bitalloc_var_fx,4915))
+ {
+ Word32 *p_prev_coeff_out = prev_coeff_out_fx;
+ FOR (i = add(sfm_start[sfm],12); i < sfm_end[sfm]; i++)
+ {
+ test();
+ test();
+ test();
+ test();
+ IF(GT_32(L_abs(L_coeff_out[i]),L_shl(L_abs(*p_prev_coeff_out),2))
+ || LT_32(L_abs(L_coeff_out[i]),L_shr(L_abs(*p_prev_coeff_out),2))
+ || ((R[sfm] == 0 || *prev_R == 0) && add(R[sfm], *prev_R) != 0))
+ {
+ L_tmp = L_add(L_shr(L_abs(L_coeff_out[i]),1),L_shr(L_abs(*p_prev_coeff_out),1));
+
+ if(L_coeff_out[i] <= 0 )
+ {
+ L_tmp = L_negate(L_tmp);
+ }
+ L_coeff_out[i] = L_tmp;
+ move32();
+ }
+ p_prev_coeff_out++;
+ }
+ }
+ prev_env_Q[sfm] = exp;
+ move16();
+ prev_env_fx[sfm] = L_tmp2;
+ move32();
+ }
+ }
+ ELSE
+ {
+ /* fill random noise for 0 bit subbands of transient frame */
+ FOR(sfm = 0; sfm < num_sfm; sfm++)
+ {
+ IF( R[sfm] == 0 )
+ {
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ tmp1 =Random(bwe_seed);/*Q15 */
+ L_tmp1= Mult_32_16(L_normq_v[sfm],tmp1);/*14 14+15+1 -16 */
+ L_tmp1 =L_shr(L_tmp1,2);/* */
+ L_coeff_out[i] = L_tmp1;
+ move32();
+ }
+ }
+ }
+ set16_fx( prev_env_Q, 0, SFM_N_WB );
+ set32_fx( prev_env_fx, 0, SFM_N_WB );
+ }
+
+ Copy32(L_normq_v,prev_normq_fx,SFM_N_WB);
+ Copy32( L_coeff_out + L_FRAME16k - L_HQ_WB_BWE, prev_coeff_out_fx, L_HQ_WB_BWE );
+ *prev_R = R[SFM_N_WB-1];
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * enforce_zero_for_min_envelope_fx()
+ *
+ * Detect minimum level of envelope and set corresponding bands to zero
+ *--------------------------------------------------------------------------*/
+
+void enforce_zero_for_min_envelope_fx(
+ const Word16 hqswb_clas, /* i : HQ coding mode Q0 */
+ const Word16 *ynrm, /* i : Envelope indices Q0 */
+ Word32 *L_coefsq, /* i/o: Quantized spectrum/zeroed spectrum Q12 */
+ const Word16 nb_sfm, /* i : Number of coded sub bands Q0 */
+ const Word16 *sfm_start, /* i : Sub band start indices Q0 */
+ const Word16 *sfm_end /* i : Sub band end indices Q0 */
+)
+{
+ Word16 i, j;
+
+ /* prevent non-zero output for all-zero input */
+ IF( NE_16(hqswb_clas,HQ_HVQ))
+ {
+ IF( EQ_16(ynrm[0], 31))
+ {
+ FOR( j = sfm_start[0]; j < sfm_end[0]; j++ )
+ {
+ L_coefsq[j] = L_deposit_l(0);
+ }
+ }
+
+ FOR( i = 1; i < nb_sfm; i++ )
+ {
+ IF( EQ_16(ynrm[i], 39))
+ {
+ FOR( j = sfm_start[i]; j < sfm_end[i]; j++ )
+ {
+ L_coefsq[j] = L_deposit_l(0);
+ }
+ }
+ }
+ }
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * apply_envelope()
+ *
+ * Apply spectral envelope with envelope adjustments
+ *--------------------------------------------------------------------------*/
+
+void apply_envelope_fx(
+ const Word16 *coeff, /* i/o: Coded/noisefilled normalized spectrum Q12 */
+ const Word16 *norm, /* i : Envelope Q0 */
+ const Word16 *norm_adj, /* i : Envelope adjustment Q15 */
+ const Word16 num_sfm, /* i : Total number of bands Q0 */
+ const Word16 last_sfm, /* i : Last coded band Q0 */
+ const Word16 HQ_mode, /* i : HQ mode Q0 */
+ const Word16 length, /* i : Frame length Q0 */
+ const Word16 *sfm_start, /* i : Sub band start indices Q0 */
+ const Word16 *sfm_end, /* i : Sub band end indices Q0 */
+ Word32 *normq_v, /* o : Envelope with adjustment Q14 */
+ Word32 *coeff_out, /* o : coded/noisefilled spectrum Q12 */
+ const Word16 *coeff1, /* i : coded/noisefilled spectrum Q12 */
+ Word32 *coeff_out1 /* o : coded/noisefilled spectrum Q12 */
+)
+{
+ Word16 i;
+ Word16 sfm;
+ UWord16 lsb;
+ Word32 normq;
+ Word32 L_tmp;
+ Word16 len;
+
+ len = num_sfm;
+ move16();
+ test();
+ if( EQ_16(HQ_mode, HQ_GEN_SWB)||EQ_16(HQ_mode,HQ_GEN_FB))
+ {
+ len = add(last_sfm, 1);
+ }
+
+ IF( EQ_16(length, L_FRAME16k))
+ {
+ FOR (sfm = 0; sfm < num_sfm; sfm++)
+ {
+ normq_v[sfm] = dicn_fx[norm[sfm]];
+ move16();
+ move32();
+ /*normq = normq_v[sfm] * norm_adj[sfm]; */
+ Mpy_32_16_ss(normq_v[sfm], norm_adj[sfm], &normq, &lsb); /* Q14 (14+15+1-16) */
+
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ /*coeff_out[i] = coeff[i]*normq; */
+ Mpy_32_16_ss(normq, coeff[i], &L_tmp, &lsb);
+ coeff_out[i] = L_add(L_shl(L_tmp, 1), lshr(lsb, 15));
+ move32(); /* Q12 (14+12+1-16)+1 */
+ }
+ }
+ }
+ ELSE
+ {
+ FOR (sfm = 0; sfm < len; sfm++)
+ {
+ normq_v[sfm] = dicn_fx[norm[sfm]];
+ move16();
+ move32();
+ /*normq_v[sfm] *= norm_adj[sfm]; */
+ Mpy_32_16_ss(normq_v[sfm], norm_adj[sfm], &normq_v[sfm], &lsb);
+ move32(); /* Q14 (14+15+1-16) */
+
+ normq = normq_v[sfm];
+ move32();
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ /*coeff_out[i] = coeff[i]*normq; */
+ Mpy_32_16_ss(normq, coeff[i], &L_tmp, &lsb);
+ coeff_out[i] = L_add(L_shl(L_tmp, 1), lshr(lsb, 15));
+ move32(); /* Q12 (14+12+1-16)+1 */
+ }
+ }
+
+ test();
+ IF ( EQ_16(HQ_mode, HQ_GEN_SWB)||EQ_16(HQ_mode,HQ_GEN_FB))
+ {
+ FOR (sfm = 0; sfm <= last_sfm; sfm++)
+ {
+ normq = normq_v[sfm];
+ move32();
+ FOR (i = sfm_start[sfm]; i < sfm_end[sfm]; i++)
+ {
+ /*coeff_out1[i] = coeff_out1[i]*normq; */
+ Mpy_32_16_ss(normq, coeff1[i], &L_tmp, &lsb);
+ coeff_out1[i] = L_add(L_shl(L_tmp, 1), lshr(lsb, 15));
+ move32(); /* Q12 (14+12+1-16)+1 */
+ }
+ }
+ }
+ }
+
+
+ return;
+}
+
+
diff --git a/lib_com/hvq_pvq_bitalloc_fx.c b/lib_com/hvq_pvq_bitalloc_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..6d21a77720614ee8fd1601a5909e043988d2fac1
--- /dev/null
+++ b/lib_com/hvq_pvq_bitalloc_fx.c
@@ -0,0 +1,191 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "stl.h" /* required by wmc_tool */
+
+#include "rom_com_fx.h"
+
+#include "prot_fx.h" /* Function prototypes */
+#include "cnst_fx.h" /* Common constants */
+
+/*--------------------------------------------------------------------------*/
+/* Function hvq_pvq_bitalloc */
+/* ~~~~~~~~~~~~~~~~~~~~~~~~ */
+/* */
+/* Calculate the number of PVQ bands to code and allocate bits based on */
+/* the number of available bits. */
+/*--------------------------------------------------------------------------*/
+
+Word16 hvq_pvq_bitalloc_fx(
+ Word16 num_bits, /* i/o: Number of available bits (including gain bits) */
+ const Word32 brate, /* i : bitrate */
+ const Word16 bwidth_fx, /* i : Encoded bandwidth */
+ const Word16 *ynrm, /* i : Envelope coefficients */
+ const Word32 manE_peak, /* i : Peak energy mantissa */
+ const Word16 expE_peak, /* i : Peak energy exponent */
+ Word16 *Rk, /* o : bit allocation for concatenated vector */
+ Word16 *R, /* i/o: Global bit allocation */
+ Word16 *sel_bands, /* o : Selected bands for encoding */
+ Word16 *n_sel_bands /* o : No. of selected bands for encoding */
+)
+{
+ Word16 num_bands, band_max_bits;
+ Word16 one_over_band_max_bits;
+ Word16 k;
+ Word16 reciprocal, envSum, expo, align, m, n, indx;
+ Word16 k_max;
+ Word16 k_start;
+ Word32 E_max, E_max5;
+ Word32 tmp, acc;
+ Word32 env_mean;
+ UWord16 lsb;
+ Word16 num_sfm;
+
+ IF (EQ_16(bwidth_fx, FB))
+ {
+ num_sfm = SFM_N_HARM_FB;
+ }
+ ELSE
+ {
+ num_sfm = SFM_N_HARM;
+ }
+
+ IF ( EQ_32(brate, HQ_24k40))
+ {
+ band_max_bits = HVQ_BAND_MAX_BITS_24k;
+ move16();
+ one_over_band_max_bits = ONE_OVER_HVQ_BAND_MAX_BITS_24k_FX;
+ move16();
+ k_start = HVQ_THRES_SFM_24k;
+ move16();
+ IF (EQ_16(bwidth_fx, FB))
+ {
+ reciprocal = 2731; /* Q15, 1/(SFM_N_HARM_FB + 1 - k_start) */ move16();
+ }
+ ELSE
+ {
+ reciprocal = 3277; /* Q15, 1/(SFM_N_HARM + 1 - k_start) */ move16();
+ }
+ }
+ ELSE
+ {
+ band_max_bits = HVQ_BAND_MAX_BITS_32k;
+ move16();
+ one_over_band_max_bits = ONE_OVER_HVQ_BAND_MAX_BITS_32k_FX;
+ move16();
+ k_start = HVQ_THRES_SFM_32k;
+ move16();
+ IF (EQ_16(bwidth_fx, FB))
+ {
+ reciprocal = 3641; /* Q15, 1/(SFM_N_HARM_FB + 1 - k_start) */ move16();
+ }
+ ELSE
+ {
+ reciprocal = 4681; /* Q15, 1/(SFM_N_HARM + 1 - k_start) */ move16();
+ }
+ }
+
+ num_bands = mult( num_bits, one_over_band_max_bits ); /* Q0 */
+ num_bits = sub( num_bits, i_mult(num_bands, band_max_bits) ); /* Q0 */
+
+ IF ( GE_16(num_bits, HVQ_NEW_BAND_BIT_THR))
+ {
+ num_bands = add(num_bands, 1);
+ }
+ ELSE
+ {
+ num_bits = add(num_bits, band_max_bits);
+ }
+
+ /* safety check in case of bit errors */
+ if (LT_16(num_bands, 1))
+ {
+ return 0;
+ }
+
+ *n_sel_bands = 0;
+ move16();
+ envSum = 0;
+ move16();
+ E_max = L_deposit_l(0);
+ k_max = k_start;
+ move16();
+ FOR ( k = k_start; k < num_sfm; k++ )
+ {
+ indx = ynrm[k];
+ move16();
+ tmp = dicn_fx[indx]; /* Q14 */
+ move32();
+ envSum = add(envSum, indx); /* Since the size of dicn_fx = 40, ynrm[k] must be less than 41. 16 bits are enough for envSum.*/
+ IF (GT_32(tmp, E_max))
+ {
+ E_max = tmp;
+ move32();
+ k_max = k;
+ move16();
+ }
+ }
+ env_mean = L_mult(envSum, reciprocal); /* env_mean in Q16 */
+ IF (GT_32(L_sub(env_mean, L_deposit_h(ynrm[k_max])), 0x30000L)) /* condition: env_mean - ynrm[k_max] > 3 */
+ {
+ expo = norm_l(E_max);
+ E_max = L_shl(E_max, expo);
+ Mpy_32_16_ss(E_max, 0x7a12, &E_max5, &lsb); /* NB: 5.0e5 = 0x7a12(Q15) x 2^19. */
+ /* True floating point value of E_max*5e5 = E_max5 x 2^(19 - expo - 14).
+ * In this context, the 32-bit E_max5 is in Q0, and
+ * -14 is due to Emax in Q14.
+ * True floating point value of E_peak = manE_peak x 2^(31 - expE_peak - 2*12). See peak_vq_enc_fx().
+ */
+
+ /* Align the Q-points of the floating point Emax*5e5 and E_peak. */
+ align = sub(expo, expE_peak);
+ align = add(align, (19 - 14) - (31 - 2*12));
+ IF (align < 0)
+ {
+ acc = L_sub(E_max5, L_shl(manE_peak, align));
+ }
+ ELSE
+ {
+ acc = L_sub(L_shr(E_max5, align), manE_peak);
+ }
+
+ IF (acc > 0) /* condition: E_max*5.e5 > E_peak */
+ {
+ IF ( EQ_16(band_len_harm[k_max], 96))
+ {
+ n = 61;
+ }
+ ELSE
+ {
+ QuantaPerDsDirac_fx(band_len_harm[k_max], 1, hBitsN, &n);
+ }
+ m = shl(sub(num_bits, HVQ_PVQ_GAIN_BITS), 3);
+ IF (GE_16(m, n))
+ {
+ IF (GT_16(num_bands, 1)) /* condition: num_bands > 1 */
+ {
+ sel_bands[*n_sel_bands] = k_max;
+ move16();
+ *n_sel_bands = add(*n_sel_bands, 1);
+ R[k_max] = 1; /* Mark that the band has been encoded for fill_spectrum */ move16();
+ }
+ }
+ }
+ }
+
+ /* Allocate bits */
+ tmp = sub(num_bands,1);
+ FOR (k = 0; k < tmp; k++)
+ {
+ Rk[k] = shl(sub(band_max_bits, HVQ_PVQ_GAIN_BITS), 3);
+ move16();
+ }
+ /* NB: When it exits the above loop, k = num_bands - 1. */
+ Rk[k] = shl(sub(num_bits, HVQ_PVQ_GAIN_BITS), 3);
+ move16();
+
+ return num_bands;
+}
+
diff --git a/lib_com/igf_base.c b/lib_com/igf_base.c
new file mode 100644
index 0000000000000000000000000000000000000000..3c799c5fca00f6fe8d37c88f3977a65b551f354e
--- /dev/null
+++ b/lib_com/igf_base.c
@@ -0,0 +1,936 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include
+#include
+#include
+#include "options.h"
+#include "stl.h"
+#include "prot_fx.h"
+#include "rom_com_fx.h"
+#include "basop_util.h"
+
+/**********************************************************************/ /*
+returns an int val, multiplied with transFac
+**************************************************************************/
+static Word16 IGF_ApplyTransFac( /**< out: Q0 | multiplication factor */
+ const Word16 val, /**< in: Q15 | input value for multiplication, Q15 */
+ const Word16 transFac /**< in: Q14 | multiplicator for variable val, Q14: 1.25f=0x5000, 1.0f=0x4000, 0.5f=0x2000 */
+)
+{
+ Word16 ret;
+
+ if(EQ_16(transFac, 0x4000))
+ {
+ return val;
+ }
+
+ ret = shl(val, 1);
+ ret = mac_r(0x00000000, ret, transFac);
+ ret = add(ret, s_and(ret, 1));
+
+
+ return ret;
+}
+
+/**********************************************************************/ /*
+maps a given bitrate to the IGF_BITRATE index
+**************************************************************************/
+static Word16 IGF_MapBitRateToIndex( /**< out: Q0 | return bit rate index */
+ Word32 bitRate, /**< in: | bitrate */
+ Word16 mode /**< in: | bandwidth mode */
+ , Word16 rf_mode /**< in: | flag to signal the RF mode */
+)
+{
+ Word16 bitRateIndex;
+
+
+ bitRateIndex = IGF_BITRATE_UNKNOWN;
+ move16();
+
+ switch (mode)
+ {
+ case IGF_MODE_WB:
+ switch (bitRate)
+ {
+ case 13200:
+ if (EQ_16(rf_mode,1))
+ {
+ bitRateIndex = IGF_BITRATE_RF_WB_13200;
+ }
+ break;
+ case 9600:
+ bitRateIndex = IGF_BITRATE_WB_9600;
+ break;
+ default:
+ assert(0);
+ }
+ break;
+ case IGF_MODE_SWB:
+ switch (bitRate)
+ {
+ case 9600:
+ bitRateIndex = IGF_BITRATE_SWB_9600;
+ break;
+ case 13200:
+ bitRateIndex = IGF_BITRATE_SWB_13200;
+ if (EQ_16(rf_mode,1))
+ {
+ bitRateIndex = IGF_BITRATE_RF_SWB_13200;
+ }
+ break;
+ case 16400:
+ bitRateIndex = IGF_BITRATE_SWB_16400;
+ break;
+ case 24400:
+ bitRateIndex = IGF_BITRATE_SWB_24400;
+ break;
+ case 32000:
+ bitRateIndex = IGF_BITRATE_SWB_32000;
+ break;
+ case 48000:
+ bitRateIndex = IGF_BITRATE_SWB_48000;
+ break;
+ default:
+ assert(0);
+ }
+ break;
+ case IGF_MODE_FB:
+ switch (bitRate)
+ {
+ case 16400:
+ bitRateIndex = IGF_BITRATE_FB_16400;
+ break;
+ case 24400:
+ bitRateIndex = IGF_BITRATE_FB_24400;
+ break;
+ case 32000:
+ bitRateIndex = IGF_BITRATE_FB_32000;
+ break;
+ case 48000:
+ bitRateIndex = IGF_BITRATE_FB_48000;
+ break;
+ case 96000:
+ bitRateIndex = IGF_BITRATE_FB_96000;
+ break;
+ case 128000:
+ bitRateIndex = IGF_BITRATE_FB_128000;
+ break;
+ default:
+ assert(0);
+ }
+ break;
+ default:
+ assert(0);
+ }
+
+ return bitRateIndex;
+}
+
+/**********************************************************************/ /*
+IGF grid setup
+**************************************************************************/
+static void IGF_gridSetUp(H_IGF_GRID hGrid, /**< out: | IGF grid handle */
+ Word16 bitRateIndex, /**< in: Q0 | IGF bitrate index */
+ Word32 sampleRate, /**< in: | sample rate */
+ Word16 frameLength, /**< in: | frame length */
+ Word16 transFac, /**< in: | transFac */
+ Word16 igfMinFq /**< in: | IGF minimum frequency indicating lower start frequency for copy up */
+ )
+{
+ Word16 t;
+ Word16 sfb;
+ const Word16 *swb_offset;
+ Word16 swb_offset_len;
+ Word16 bandwidth;
+ Word16 wrp_sfb;
+ Word16 tmp1;
+ Word16 tmp2;
+ Word32 L_tmp1;
+ Word32 L_tmp2;
+
+ swb_offset = NULL;
+ move16();
+ swb_offset_len = 0;
+ move16();
+
+ SWITCH (bitRateIndex)
+ {
+ case IGF_BITRATE_WB_9600:
+ case IGF_BITRATE_SWB_9600:
+ case IGF_BITRATE_RF_WB_13200:
+ case IGF_BITRATE_RF_SWB_13200:
+ case IGF_BITRATE_SWB_13200:
+ case IGF_BITRATE_SWB_16400:
+ case IGF_BITRATE_SWB_24400:
+ case IGF_BITRATE_SWB_32000:
+ case IGF_BITRATE_SWB_48000:
+ swb_offset = &swb_offset_LB_new[bitRateIndex][1];
+ swb_offset_len = swb_offset_LB_new[bitRateIndex][0];
+ move16();
+ Copy(&igf_whitening_TH[bitRateIndex][0][0], &hGrid->whiteningThreshold[0][0], IGF_MAX_TILES * 2);
+ BREAK;
+ case IGF_BITRATE_FB_16400:
+ case IGF_BITRATE_FB_24400:
+ case IGF_BITRATE_FB_32000:
+ swb_offset = &swb_offset_LB_new[bitRateIndex][1];
+ swb_offset_len = swb_offset_LB_new[bitRateIndex][0];
+ move16();
+ Copy(&igf_whitening_TH[bitRateIndex][0][0], &hGrid->whiteningThreshold[0][0], IGF_MAX_TILES * 2);
+ BREAK;
+ case IGF_BITRATE_FB_48000:
+ case IGF_BITRATE_FB_96000:
+ case IGF_BITRATE_FB_128000:
+ swb_offset = &swb_offset_LB_new[bitRateIndex][1];
+ swb_offset_len = swb_offset_LB_new[bitRateIndex][0];
+ move16();
+ Copy(&igf_whitening_TH[bitRateIndex][0][0], &hGrid->whiteningThreshold[0][0], IGF_MAX_TILES * 2);
+ BREAK;
+ case IGF_BITRATE_UNKNOWN:
+ default:
+ assert(0);
+ }
+
+ FOR(sfb = 0; sfb < swb_offset_len; sfb++)
+ {
+ hGrid->swb_offset[sfb] = IGF_ApplyTransFac(swb_offset[sfb], transFac);
+ move16();
+ }
+
+ hGrid->infoIsRefined = 0;
+ move16();
+ frameLength = IGF_ApplyTransFac(frameLength, transFac);
+ tmp2 = norm_s(frameLength);
+ bandwidth = shl(frameLength,tmp2);
+ hGrid->swb_offset_len = extract_l(L_shr(sampleRate, 2));
+ tmp1 = sub(norm_s(hGrid->swb_offset_len), 1);
+ hGrid->swb_offset_len = shl(hGrid->swb_offset_len, tmp1);
+ bandwidth = div_s(hGrid->swb_offset_len, bandwidth);
+ tmp2 = sub(add(tmp2, 1), tmp1);
+ bandwidth = shr(bandwidth, sub(15, tmp2));
+
+
+ hGrid->swb_offset_len = swb_offset_len;
+ move16();
+ hGrid->startSfb = 0;
+ move16();
+ hGrid->stopSfb = sub(hGrid->swb_offset_len, 1);
+ hGrid->startLine = hGrid->swb_offset[ hGrid->startSfb ];
+ move16();
+ hGrid->stopLine = hGrid->swb_offset[ hGrid->stopSfb ];
+ move16();
+ hGrid->startFrequency = imult1616(bandwidth, hGrid->startLine);
+ hGrid->stopFrequency = imult1616(bandwidth, hGrid->stopLine);
+
+ L_tmp1 = L_mult0(igfMinFq, frameLength);
+ tmp1 = sub(norm_l(L_tmp1), 1);
+ L_tmp1 = L_shl(L_tmp1, tmp1);
+
+ tmp2 = norm_l(sampleRate);
+ L_tmp2 = L_shl(sampleRate, tmp2);
+ tmp1 = add(WORD16_BITS-1, sub(tmp1, add(tmp2, 1))); /* takes into account sampleRate >> 1 */
+
+ hGrid->minSrcSubband = div_s(extract_h(L_tmp1), extract_h(L_tmp2));
+ hGrid->minSrcSubband = shr(hGrid->minSrcSubband, tmp1);
+
+
+ hGrid->minSrcSubband = add(hGrid->minSrcSubband, s_and(hGrid->minSrcSubband, 1));
+ hGrid->minSrcFrequency = imult1616(bandwidth, hGrid->minSrcSubband);
+ hGrid->infoGranuleLen = frameLength;
+ move16();
+ hGrid->infoTransFac = transFac;
+ move16();
+
+ hGrid->sfbWrap[0] = 0;
+ move16();
+ hGrid->tile[0] = hGrid->startLine;
+ move16();
+
+
+ /*************************************************************************/
+ SWITCH (bitRateIndex)
+ {
+ /* SWB 13200 */
+ case IGF_BITRATE_WB_9600:
+ hGrid->nTiles = 2;
+ move16();
+ wrp_sfb = 2;
+ move16();
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = wrp_sfb;
+ move16();
+ hGrid->sbWrap[0] = hGrid->minSrcSubband;
+ move16();
+ hGrid->tile[0+1] = hGrid->swb_offset[wrp_sfb];
+ move16();
+
+ /*2nd*/
+ hGrid->sfbWrap[1+1] = hGrid->stopSfb;
+ move16();
+ hGrid->sbWrap[1] = hGrid->minSrcSubband;
+ move16();
+ hGrid->tile[1+1] = hGrid->swb_offset[hGrid->stopSfb];
+ move16();
+ BREAK;
+
+ case IGF_BITRATE_RF_WB_13200:
+ hGrid->nTiles = 2;
+ wrp_sfb = 2;
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = wrp_sfb;
+ hGrid->sbWrap[0] = hGrid->minSrcSubband;
+ hGrid->tile[0+1] = hGrid->swb_offset[wrp_sfb];
+
+ /*2nd*/
+ hGrid->sfbWrap[1+1] = hGrid->stopSfb;
+ hGrid->sbWrap[1] = hGrid->minSrcSubband;
+ hGrid->tile[1+1] = hGrid->swb_offset[hGrid->stopSfb];
+
+ BREAK;
+ case IGF_BITRATE_SWB_9600:
+ hGrid->nTiles = 3;
+ wrp_sfb = 1;
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = wrp_sfb;
+ hGrid->sbWrap[0] = hGrid->minSrcSubband;
+ hGrid->tile[0+1] = hGrid->swb_offset[wrp_sfb];
+
+ /*2nd*/
+ wrp_sfb = 2;
+ hGrid->sfbWrap[1+1] = wrp_sfb;
+ hGrid->sbWrap[1] = hGrid->minSrcSubband + IGF_ApplyTransFac(32, transFac);
+ hGrid->tile[1+1] = hGrid->swb_offset[wrp_sfb];
+
+ /*3rd*/
+ hGrid->sfbWrap[2+1] = hGrid->stopSfb;
+ hGrid->sbWrap[2] = hGrid->minSrcSubband + IGF_ApplyTransFac(46, transFac);
+ hGrid->tile[2+1] = hGrid->swb_offset[hGrid->stopSfb];
+
+ BREAK;
+ case IGF_BITRATE_RF_SWB_13200:
+ hGrid->nTiles = 3;
+ wrp_sfb = 1;
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = wrp_sfb;
+ hGrid->sbWrap[0] = hGrid->minSrcSubband;
+ hGrid->tile[0+1] = hGrid->swb_offset[wrp_sfb];
+
+ /*2nd*/
+ wrp_sfb = 2;
+ hGrid->sfbWrap[1+1] = wrp_sfb;
+ hGrid->sbWrap[1] = hGrid->minSrcSubband + IGF_ApplyTransFac(32, transFac);
+ hGrid->tile[1+1] = hGrid->swb_offset[wrp_sfb];
+
+ /*3rd*/
+ hGrid->sfbWrap[2+1] = hGrid->stopSfb;
+ hGrid->sbWrap[2] = hGrid->minSrcSubband + IGF_ApplyTransFac(46, transFac);
+ hGrid->tile[2+1] = hGrid->swb_offset[hGrid->stopSfb];
+
+ BREAK;
+
+ case IGF_BITRATE_SWB_13200:
+ hGrid->nTiles = 2;
+ move16();
+ wrp_sfb = 4;
+ move16();
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = wrp_sfb;
+ move16();
+ hGrid->sbWrap[0] = hGrid->minSrcSubband;
+ move16();
+ hGrid->tile[0+1] = hGrid->swb_offset[wrp_sfb];
+ move16();
+
+ /*2nd*/
+ hGrid->sfbWrap[1+1] = hGrid->stopSfb;
+ move16();
+ hGrid->sbWrap[1] = add(hGrid->minSrcSubband, IGF_ApplyTransFac(32, transFac));
+ move16();
+ hGrid->tile[1+1] = hGrid->swb_offset[hGrid->stopSfb];
+ move16();
+ BREAK;
+
+ case IGF_BITRATE_SWB_16400:
+ hGrid->nTiles = 3;
+ move16();
+ wrp_sfb = 4;
+ move16();
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = wrp_sfb;
+ move16();
+ hGrid->sbWrap[0] = hGrid->minSrcSubband;
+ move16();
+ hGrid->tile[0+1] = hGrid->swb_offset[wrp_sfb];
+ move16();
+
+ /*2nd*/
+ hGrid->sfbWrap[1+1] = 6;
+ move16();
+ hGrid->sbWrap[1] = add(hGrid->minSrcSubband, IGF_ApplyTransFac(48, transFac));
+ move16();
+ hGrid->tile[1+1] = hGrid->swb_offset[6];
+ move16();
+
+ /*3nd*/
+ hGrid->sfbWrap[2+1] = hGrid->stopSfb;
+ move16();
+ hGrid->sbWrap[2] = add(hGrid->minSrcSubband, IGF_ApplyTransFac(64, transFac));
+ move16();
+ hGrid->tile[2+1] = hGrid->swb_offset[hGrid->stopSfb];
+ move16();
+ BREAK;
+
+ case IGF_BITRATE_SWB_24400:
+ case IGF_BITRATE_SWB_32000:
+ hGrid->nTiles = 3;
+ move16();
+ wrp_sfb = 4;
+ move16();
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = wrp_sfb;
+ move16();
+ hGrid->sbWrap[0] = hGrid->minSrcSubband;
+ move16();
+ hGrid->tile[0+1] = hGrid->swb_offset[wrp_sfb];
+ move16();
+
+ /*2nd*/
+ hGrid->sfbWrap[1+1] = 7;
+ move16();
+ hGrid->sbWrap[1] = add(hGrid->minSrcSubband, IGF_ApplyTransFac(32, transFac));
+ move16();
+ hGrid->tile[1+1] = hGrid->swb_offset[7];
+ move16();
+
+ /*3nd*/
+ hGrid->sfbWrap[2+1] = hGrid->stopSfb;
+ move16();
+ hGrid->sbWrap[2] = add(hGrid->minSrcSubband, IGF_ApplyTransFac(64, transFac));
+ move16();
+ hGrid->tile[2+1] = hGrid->swb_offset[hGrid->stopSfb];
+ move16();
+ BREAK;
+ case IGF_BITRATE_SWB_48000:
+ hGrid->nTiles = 1;
+ move16();
+ wrp_sfb = hGrid->stopSfb;
+ move16();
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = hGrid->stopSfb;
+ move16();
+ hGrid->sbWrap[0] = sub(shl(hGrid->startLine, 1), hGrid->stopLine);
+ move16();
+ hGrid->tile[0+1] = hGrid->swb_offset[hGrid->stopSfb];
+ move16();
+
+ BREAK;
+ case IGF_BITRATE_FB_16400:
+ hGrid->nTiles = 3;
+ move16();
+ wrp_sfb = 4;
+ move16();
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = wrp_sfb;
+ move16();
+ hGrid->sbWrap[0] = hGrid->minSrcSubband;
+ move16();
+ hGrid->tile[0+1] = hGrid->swb_offset[wrp_sfb];
+ move16();
+ wrp_sfb = 7;
+ move16();
+
+ /*2nd*/
+ hGrid->sfbWrap[1+1] = wrp_sfb;
+ move16();
+ hGrid->sbWrap[1] = hGrid->minSrcSubband;
+ move16();
+ hGrid->tile[1+1] = hGrid->swb_offset[wrp_sfb];
+ move16();
+
+ /*3nd*/
+ hGrid->sfbWrap[2+1] = hGrid->stopSfb;
+ move16();
+ hGrid->sbWrap[2] = hGrid->minSrcSubband;
+ move16();
+ hGrid->tile[2+1] = hGrid->swb_offset[hGrid->stopSfb];
+ move16();
+
+ BREAK;
+
+ case IGF_BITRATE_FB_24400:
+ case IGF_BITRATE_FB_32000:
+ hGrid->nTiles = 4;
+ move16();
+ wrp_sfb = 4;
+ move16();
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = wrp_sfb;
+ move16();
+ hGrid->sbWrap[0] = hGrid->minSrcSubband;
+ move16();
+ hGrid->tile[0+1] = hGrid->swb_offset[wrp_sfb];
+ move16();
+ wrp_sfb = 6;
+ move16();
+
+ /*2nd*/
+ hGrid->sfbWrap[1+1] = wrp_sfb;
+ move16();
+ hGrid->sbWrap[1] = add(hGrid->minSrcSubband, IGF_ApplyTransFac(32, transFac));
+ move16();
+ hGrid->tile[1+1] = hGrid->swb_offset[wrp_sfb];
+ move16();
+ wrp_sfb = 9;
+ move16();
+
+ /*3nd*/
+ hGrid->sfbWrap[2+1] = wrp_sfb;
+ move16();
+ hGrid->sbWrap[2] = hGrid->minSrcSubband;
+ move16();
+ hGrid->tile[2+1] = hGrid->swb_offset[wrp_sfb];
+ move16();
+
+ /*4nd*/
+ hGrid->sfbWrap[3+1] = hGrid->stopSfb;
+ move16();
+ hGrid->sbWrap[3] = add(hGrid->minSrcSubband, sub(hGrid->swb_offset[9], hGrid->swb_offset[8]));
+ move16();
+ hGrid->tile[3+1] = hGrid->swb_offset[hGrid->stopSfb];
+ move16();
+ BREAK;
+ case IGF_BITRATE_FB_48000:
+ case IGF_BITRATE_FB_96000:
+ case IGF_BITRATE_FB_128000:
+ hGrid->nTiles = 1;
+ move16();
+
+ /*1st*/
+ hGrid->sfbWrap[0+1] = hGrid->stopSfb;
+ move16();
+ hGrid->sbWrap[0] = sub(shl(hGrid->startLine, 1), hGrid->stopLine);
+ move16();
+ hGrid->tile[0+1] = hGrid->swb_offset[hGrid->stopSfb];
+ move16();
+
+ BREAK;
+ default:
+ assert(0);
+ }/*switch*/
+
+ /*************************************************************************/
+ /*************************************************************************/
+
+
+ /* adapt level envelope: */
+ SWITCH (bitRateIndex)
+ {
+ case IGF_BITRATE_RF_WB_13200:
+ case IGF_BITRATE_WB_9600:
+ hGrid->gFactor = 13107/*0.80f Q14*/;
+ move16();
+ hGrid->fFactor = 11469/*0.70f Q14*/;
+ move16();
+ hGrid->lFactor = 9830/*0.60f Q14*/;
+ move16();
+ BREAK;
+ case IGF_BITRATE_SWB_13200:
+ case IGF_BITRATE_FB_16400:
+ case IGF_BITRATE_SWB_16400:
+ hGrid->gFactor = 15237/*0.93f Q14*/;
+ move16();
+ hGrid->fFactor = 3277/*0.20f Q14*/;
+ move16();
+ hGrid->lFactor = 13926/*0.85f Q14*/;
+ move16();
+ BREAK;
+ case IGF_BITRATE_FB_24400:
+ case IGF_BITRATE_SWB_24400:
+ case IGF_BITRATE_FB_32000:
+ case IGF_BITRATE_SWB_32000:
+ hGrid->gFactor = 15811/*0.965f Q14*/;
+ move16();
+ hGrid->fFactor = 3277/*0.20f Q14*/;
+ move16();
+ hGrid->lFactor = 13926/*0.85f Q14*/;
+ move16();
+ BREAK;
+ case IGF_BITRATE_FB_48000:
+ case IGF_BITRATE_SWB_48000:
+ hGrid->gFactor = 16384/*1.00f Q14*/;
+ move16();
+ hGrid->fFactor = 3277/*0.20f Q14*/;
+ move16();
+ hGrid->lFactor = 16384/*1.00f Q14*/;
+ move16();
+ BREAK;
+ case IGF_BITRATE_SWB_9600:
+ case IGF_BITRATE_RF_SWB_13200:
+ default:
+ hGrid->gFactor = 16384/*1.00f Q14*/;
+ move16();
+ hGrid->fFactor = 0/*0.00f Q14*/;
+ move16();
+ hGrid->lFactor = 16384/*1.00f Q14*/;
+ move16();
+ }
+
+ FOR (t = add(hGrid->nTiles, 1); t < IGF_MAX_TILES; t++)
+ {
+ hGrid->tile[t] = 0;
+ move16();
+ hGrid->sbWrap[t - 1] = 0;
+ move16();
+ hGrid->sfbWrap[t] = 0;
+ move16();
+ }
+
+}
+
+/**********************************************************************/ /*
+calculates energy per sfb via power spectrum
+**************************************************************************/
+void IGFCommonFuncsCalcSfbEnergyPowerSpec(const Word16 startSfb, /**< in: Q0 | start sfb index */
+ const Word16 stopSfb, /**< in: Q0 | stop sfb index */
+ const Word16 *swb_offset, /**< in: Q0 | IGF swb offset table */
+ Word32 *pPowerSpectrum, /**< in: Q31 | power spectrum */
+ Word16 *pPowerSpectrum_exp, /**< in: | Exponent of PowerSpectrum */
+ Word32 *sfbEnergy, /**< out:Q31 | SFB energies , will be initialized inside this function */
+ Word16 *sfbEnergy_exp /**< out: | Exponent of PowerSpectrum */
+ )
+{
+ Word16/*Q0*/ sfb;
+ Word16/*Q0*/ line;
+ Word32 L_c;
+
+
+ FOR (sfb = startSfb; sfb < stopSfb; sfb++)
+ {
+ sfbEnergy[sfb] = L_deposit_l(0);
+ }
+ IF (NULL == pPowerSpectrum)
+ {
+ return;
+ }
+
+ FOR (sfb = startSfb; sfb < stopSfb; sfb++)
+ {
+ L_c = L_deposit_l(0);
+ FOR (line = swb_offset[sfb]; line < swb_offset[sfb+1]; line++)
+ {
+ Carry = 0;
+ sfbEnergy[sfb] = L_add_c(sfbEnergy[sfb], pPowerSpectrum[line]);
+ move32();
+ Overflow = 0;
+ L_c = L_macNs(L_c,0,0);
+ }
+ sfbEnergy[sfb] = norm_llQ31(L_c,sfbEnergy[sfb],&(sfbEnergy_exp[sfb]));
+ move32();
+ sfbEnergy_exp[sfb] = add(sfbEnergy_exp[sfb],*pPowerSpectrum_exp);
+ move16();
+ }
+}
+
+/**********************************************************************/ /*
+calculate the MDCT square spectrum in the IGF range
+**************************************************************************/
+void IGFCommonFuncsMDCTSquareSpec(const Word16 sqrtBgn, /**< in: Q0 | start MDCT subband index */
+ const Word16 sqrtEnd, /**< in: Q0 | stop MDCT subband index */
+ const Word32 *mdctSpec, /**< in: Q31 | MDCT spectrum to square */
+ const Word16 mdctSpec_e, /**< in: | exponent of mdctSpectrum */
+ Word32 *mdctSquareSpec, /**< out:Q31 | MDCT square spectrum */
+ Word16 *mdctSquareSpec_e, /**< out: | exponent of mdctSquareSpec */
+ Word16 indexOffset /**< in: Q0 | index offset */
+ )
+{
+ Word16 i;
+ Word16 j;
+ Word16 s1;
+ Word16 tmp;
+
+
+ /* get headroom, only in IGF range */
+ s1 = getScaleFactor32(mdctSpec + sqrtBgn, sub(sqrtEnd, sqrtBgn));
+
+ /* set new exponent */
+ *mdctSquareSpec_e = add(shl(sub(mdctSpec_e, s1), 1), 1);
+ move16();
+
+ /* MDCT square spectrum: MDCT^2 */
+ j = add(sqrtBgn, indexOffset); /* handle indexOffset with care, otherwise memory overruns may occur! */
+
+
+ FOR (i = sqrtBgn; i < sqrtEnd; i++)
+ {
+ tmp = round_fx(L_shl(mdctSpec[i], s1));
+ mdctSquareSpec[j++] = L_mult0(tmp, tmp);
+ move32();
+ }
+
+
+}
+
+/**********************************************************************/ /*
+write bits to stream
+**************************************************************************/
+void IGFCommonFuncsWriteSerialBit(void *st, /**< in: | encoder/decoder state structure */
+ Word16 *pBitOffset, /**< out: Q0 | bit offset */
+ Word16 bit /**< in: Q0 | value of bit */
+ )
+{
+
+ IF (st)
+ {
+ push_next_indice_fx(st, bit, 1);
+ }
+ *pBitOffset = add(*pBitOffset, 1);
+ move16();
+
+ return;
+}
+
+/**********************************************************************/ /*
+changes the IGF configuration
+**************************************************************************/
+Word16 IGFCommonFuncsIGFConfiguration( /**< out: | error value: 0 -> error, 1 -> ok */
+ Word32 bitRate, /**< in: Q0 | bitrate in bs e.g. 9600 for 9.6kbs */
+ Word16 mode, /**< in: Q0 | bandwidth mode */
+ H_IGF_INFO hIGFInfo /**< out: | IGF info handle */
+ ,Word16 rf_mode /**< in: flag to signal the RF mode */
+)
+{
+ H_IGF_GRID hGrid;
+ Word16 retValue;
+ Word32 sampleRate;
+ Word16 frameLength;
+ Word16 igfMinFq;
+ Word16 maxHopsize;
+
+ retValue = 0; /* bitrate index is unknown -> error! */ move16();
+
+ /* interface call for reading in settings */
+ hIGFInfo->bitRateIndex = IGF_MapBitRateToIndex(bitRate, mode
+ ,rf_mode
+ );
+
+ IF (NE_16(hIGFInfo->bitRateIndex, IGF_BITRATE_UNKNOWN))
+ {
+ retValue = 1; /* no error */ move16();
+
+ /* mapping to local values */
+ sampleRate = igfMode[hIGFInfo->bitRateIndex].sampleRate;
+ move32();
+ frameLength = igfMode[hIGFInfo->bitRateIndex].frameLength;
+ move16();
+ igfMinFq = igfMode[hIGFInfo->bitRateIndex].igfMinFq;
+ move16();
+ maxHopsize = igfMode[hIGFInfo->bitRateIndex].maxHopsize;
+ move16();
+
+ /* basic information */
+ hIGFInfo->sampleRate = sampleRate;
+ move32();
+ hIGFInfo->frameLength = frameLength;
+ move16();
+ hIGFInfo->maxHopsize = maxHopsize;
+ move16();
+ hIGFInfo->nfSeed = 0;
+ move16();
+
+ /* set up regular IGF grid for TCX 20 (transfac = 1.f) */
+ hGrid = &hIGFInfo->grid[IGF_GRID_LB_NORM];
+ IGF_gridSetUp(hGrid,
+ hIGFInfo->bitRateIndex,
+ sampleRate,
+ frameLength,
+ 16384/*1 Q14*/,
+ igfMinFq);
+
+ /* set up IGF grid for CELP->TCX 20 transitions (transfac = 1.25) */
+ hGrid = &hIGFInfo->grid[IGF_GRID_LB_TRAN];
+ IGF_gridSetUp(hGrid,
+ hIGFInfo->bitRateIndex,
+ sampleRate,
+ frameLength,
+ 20480/*1.25 Q14*/,
+ igfMinFq);
+ /* set up IGF grid for TCX 10 (transfac = 0.5) */
+ hGrid = &hIGFInfo->grid[IGF_GRID_LB_SHORT];
+ IGF_gridSetUp(hGrid,
+ hIGFInfo->bitRateIndex,
+ sampleRate,
+ frameLength,
+ 8192/*0.50f Q14*/,
+ igfMinFq);
+ }
+
+ return retValue;
+}
+
+/**********************************************************************/ /*
+selects cumulative frequency tables and offsets for the IGF SCF arithmetic coder
+**************************************************************************/
+Word16 IGFCommonFuncsIGFGetCFTables( /**< out: | error value: 0 -> error, 1 -> ok */
+ Word32 bitRate, /**< in: Q0 | bitrate in bs e.g. 9600 for 9.6kbs */
+ Word16 mode, /**< in: Q0 | bandwidth mode */
+ Word16 rf_mode, /**< in: | flag to signal the RF mode */
+ const Word16 **cf_se00, /**< out: | CF table for t == 0 and f == 0 */
+ const Word16 **cf_se01, /**< out: | CF table for t == 0 and f == 1 */
+ Word16 *cf_off_se01, /**< out: | offset for CF table above */
+ const Word16 **cf_se02, /**< out: | CF tables for t == 0 and f >= 2 */
+ const Word16 **cf_off_se02, /**< out: | offsets for CF tables above */
+ const Word16 **cf_se10, /**< out: | CF table for t == 1 and f == 0 */
+ Word16 *cf_off_se10, /**< out: | offset for CF table above */
+ const Word16 **cf_se11, /**< out: | CF tables for t == 1 and f >= 1 */
+ const Word16 **cf_off_se11 /**< out: | offsets for CF tables above */
+)
+{
+ Word16 retValue;
+ Word16 bitRateIndex;
+
+Word16 temp_var;
+
+ retValue = 0; /* bitrate index is unknown -> error! */ move16();
+ bitRateIndex = IGF_MapBitRateToIndex(bitRate, mode
+ ,rf_mode
+ );
+
+
+ IF (NE_16(bitRateIndex, IGF_BITRATE_UNKNOWN))
+ {
+ retValue = 1; /* no error */ move16();
+ SWITCH(bitRateIndex)
+ {
+ case IGF_BITRATE_WB_9600:
+ case IGF_BITRATE_RF_WB_13200:
+ case IGF_BITRATE_SWB_9600:
+ case IGF_BITRATE_SWB_13200:
+ case IGF_BITRATE_RF_SWB_13200:
+ case IGF_BITRATE_SWB_16400:
+ case IGF_BITRATE_SWB_24400:
+ case IGF_BITRATE_SWB_32000:
+ case IGF_BITRATE_SWB_48000:
+ *cf_se00 = cf_se00_tab;
+ *cf_se01 = cf_se01_tab[bitRateIndex];
+ *cf_off_se01 = cf_off_se01_tab[bitRateIndex];
+ temp_var = bitRateIndex;
+ if ((bitRateIndex == 0) || (bitRateIndex == 1))
+ {
+ bitRateIndex = 0;
+ }
+ else if ((bitRateIndex == 2) || (bitRateIndex == 3) || (bitRateIndex == 4) || (bitRateIndex == 5))
+ {
+ bitRateIndex = 1;
+ }
+ else if ((bitRateIndex == 6) || (bitRateIndex == 7))
+ {
+ bitRateIndex = 2;
+ }
+ else if (bitRateIndex == 8)
+ {
+ bitRateIndex = 3;
+ }
+ *cf_se02 = &cf_se02_tab[bitRateIndex][0][0];
+ move16();
+ bitRateIndex = temp_var;
+ *cf_off_se02 = &cf_off_se02_tab[bitRateIndex][0];
+ move16();
+ *cf_se10 = &cf_se10_tab[0];
+ move16();
+ *cf_off_se10 = cf_off_se10_tab;
+ *cf_se11 = &cf_se11_tab[0][0][0];
+ move16();
+ *cf_off_se11 = &cf_off_se11_tab[0][0];
+ move16();
+ BREAK;
+ case IGF_BITRATE_FB_16400:
+ case IGF_BITRATE_FB_24400:
+ case IGF_BITRATE_FB_32000:
+ bitRateIndex = add(sub(bitRateIndex, IGF_BITRATE_FB_16400), IGF_BITRATE_SWB_16400);
+ *cf_se00 = cf_se00_tab;
+ *cf_se01 = cf_se01_tab[bitRateIndex];
+ *cf_off_se01 = cf_off_se01_tab[bitRateIndex];
+ temp_var = bitRateIndex;
+ if (bitRateIndex == 5)
+ {
+ bitRateIndex = 1;
+ }
+ else if (bitRateIndex == 6 || bitRateIndex == 7)
+ {
+ bitRateIndex = 2;
+ }
+ *cf_se02 = &cf_se02_tab[bitRateIndex][0][0];
+ move16();
+ bitRateIndex = temp_var;
+ *cf_off_se02 = &cf_off_se02_tab[bitRateIndex][0];
+ move16();
+ *cf_se10 = &cf_se10_tab[0];
+ move16();
+ *cf_off_se10 = cf_off_se10_tab;
+ *cf_se11 = &cf_se11_tab[0][0][0];
+ move16();
+ *cf_off_se11 = &cf_off_se11_tab[0][0];
+ move16();
+ BREAK;
+ case IGF_BITRATE_FB_48000:
+ bitRateIndex = add(sub(bitRateIndex, IGF_BITRATE_FB_48000), IGF_BITRATE_SWB_48000);
+ *cf_se00 = cf_se00_tab;
+ *cf_se01 = cf_se01_tab[bitRateIndex];
+ *cf_off_se01 = cf_off_se01_tab[bitRateIndex];
+ temp_var = bitRateIndex;
+ bitRateIndex = 3;
+ *cf_se02 = &cf_se02_tab[bitRateIndex][0][0];
+ move16();
+ bitRateIndex = temp_var;
+ *cf_off_se02 = &cf_off_se02_tab[bitRateIndex][0];
+ move16();
+ *cf_se10 = &cf_se10_tab[0];
+ move16();
+ *cf_off_se10 = cf_off_se10_tab;
+ *cf_se11 = &cf_se11_tab[0][0][0];
+ move16();
+ *cf_off_se11 = &cf_off_se11_tab[0][0];
+ move16();
+ BREAK;
+ case IGF_BITRATE_FB_96000:
+ case IGF_BITRATE_FB_128000:
+ bitRateIndex = IGF_BITRATE_SWB_48000;
+ move16();
+ *cf_se00 = cf_se00_tab;
+ *cf_se01 = cf_se01_tab[bitRateIndex];
+ *cf_off_se01 = cf_off_se01_tab[bitRateIndex];
+ temp_var = bitRateIndex;
+ bitRateIndex = 3;
+ *cf_se02 = &cf_se02_tab[bitRateIndex][0][0];
+ move16();
+ bitRateIndex = temp_var;
+ *cf_off_se02 = &cf_off_se02_tab[bitRateIndex][0];
+ move16();
+ *cf_se10 = &cf_se10_tab[0];
+ move16();
+ *cf_off_se10 = cf_off_se10_tab;
+ *cf_se11 = &cf_se11_tab[0][0][0];
+ move16();
+ *cf_off_se11 = &cf_off_se11_tab[0][0];
+ move16();
+ BREAK;
+ case IGF_BITRATE_UNKNOWN:
+ default:
+ assert(0);
+ }
+ }
+ return retValue;
+}
+
diff --git a/lib_com/index_pvq_opt_fx.c b/lib_com/index_pvq_opt_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..68297f4c2e275719115c42c1546021c32022cced
--- /dev/null
+++ b/lib_com/index_pvq_opt_fx.c
@@ -0,0 +1,1187 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h"
+#include "cnst_fx.h" /* Common constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h" /* required for wmc_tool */
+#include "basop_util.h"
+#include
+
+#define N_OPT_FX 5 /* complexity setting, direct functional calculation limit & low dim recursion limit */
+#define TABLE_LIM_OPT_FX 96 /* odd divisor table , N-row_recursion limit setting, due to dim */
+
+
+/* local typedefs for optimized pvq indexing, used locally c-file to vectorize common function calls */
+typedef void (*VEC2INDFUNCM) (const Word16* , Word16* , UWord32*, UWord32*);
+typedef UWord32 (*NFUNCM) (Word16);
+typedef UWord32 (*H_FUNCM) ( UWord32 );
+typedef void (*IND2VECFUNCM) ( Word16, Word16, UWord32, Word16* ) ;
+typedef void (*NDIM_FUNCM) ( Word16, Word16, UWord32, Word16* );
+
+/* local constants for indexing functions */
+#define SIGNBIT_FX 0x80000000u
+#define SIGNBIT_SHRT_FX 0x8000
+#define UDIVBY3_FX 2863311531U
+
+/*-------------------------------------------------------------------*
+ * f_odd_exact_div_opt_fx()
+ *
+ * find 1/(den1*2+1) * ( num1p*num2p - num3) ,
+ * if the result is known a priori to be exactly a 32bit UWord32
+ *-------------------------------------------------------------------*/
+static
+UWord32 f_odd_exact_div_opt_fx( /* o : see Eq. */
+ UWord32 num1p, /* i : see Eq. */ /* (2n-1) or n , i.e can be short also */
+ UWord32 num2p, /* i : see Eq. */
+ UWord32 num3, /* i : see Eq. */
+ Word16 den1 /* i : see Eq. */ /*range [0..127] can be made to short */
+)
+{
+ UWord32 UL_tmp;
+ UL_tmp = UL_Mpy_32_32(exactdivodd_fx[den1],UL_subNsD(UL_Mpy_32_32(num1p,num2p),num3));
+
+ return (UL_tmp);
+}
+
+/*---------------------------------------------------------------------------*
+ * f_even_exact_div_opt_fx()
+ *
+ * returns (num1p*num2p - num3 )/ den1
+ * if the result is known a priori to be exactly a 32bit unsigned integer
+ *--------------------------------------------------------------------------*/
+static
+UWord32 f_even_exact_div_opt_fx( /* o : see Eq. */
+ UWord32 UL_num1p, /* i : see Eq. 2n-1 or n can be short input */
+ UWord32 UL_num2p, /* i : see Eq. range should be larger than num1p */
+ UWord32 UL_num3, /* i : see Eq. */
+ Word16 den1 /* i : see Eq. */
+)
+{
+ UWord32 UL_tmp, UL_oddfactor;
+ Word16 den1_m1, even_sh;
+ UWord32 UL_tmp_h;
+ UWord16 sgn;
+
+ den1_m1 = sub(den1,1); /* remove top bit */
+ even_sh = sub(15, norm_s(s_xor(den1_m1, den1))); /* STL signed ops ok as den1 <= 127 */
+
+ UL_oddfactor = exactdivodd_fx[lshr(den1_m1,even_sh)];
+ move32();
+ even_sh = sub(even_sh,1);
+
+
+ Mpy_32_32_uu(UL_num1p, UL_num2p, &UL_tmp_h, &UL_tmp); /* cost ~4 */
+ UL_tmp = UL_subNs(UL_tmp,UL_num3,&sgn); /* may wrap for underflow */
+ if(sgn) /* underflow */
+ {
+ UL_tmp_h = UL_subNsD(UL_tmp_h,1U); /* single basicop -> if */
+ }
+ UL_tmp = UL_or(UL_lshl(UL_tmp_h,sub(32,even_sh)), UL_lshr(UL_tmp,even_sh));
+ /* total cost 9-11 , old solution had 15-16*/
+
+ /* now use tabled modular multiplicative inverse for the odd part division */
+ return UL_Mpy_32_32(UL_tmp, UL_oddfactor);
+}
+
+/* direct calculation functions for smaller dimensions to speed up indexing
+
+N_MPVQ(1,k) = 1;
+N_MPVQ(2,k) = k*2;
+N_MPVQ(3,k) = 1+2*(k^2);
+N_MPVQ(4,k) = k/3 * 4*(k^2+2);
+N_MPVQ(5,k) = 1 + 2*(k*k*(5+k*k))/3;
+N_MPVQ(*,k) = iterations = 1 + A(n,k) + A(n+1,k);
+
+N_PVQ(n,k) = 2*N_MPVQ(n,k);
+
+
+A(1,k) = 1;
+A(2,k) = -1 + 2k;
+A(3,k) = 1+2(k-1)k;
+A(4,k) = 1/3*(((4k-6)k+8)*k-3),
+A(5,k) = 1/3*(3+ k(10+2(k-2)k)k-8);
+A(*,k) = recursive iterations;
+
+
+U(n,k) = (A(n,k)-1)/2;
+U(1,k) = 0;
+U(2,k) = k-1;
+U(3,k) = k*(k-1)
+U(4,k) = (1/3)*((k - 1)*(2*k^2 - k + 3))
+U(5,k) = (1/3)*(k*(k - 1)*(k^2 - k + 4))
+U(*,k) = recursive iterations;
+
+U(n,k) = U(k,n);
+U(n,k) = func(n, U(n,k-1), U(n,k-2) , 1/(k-1) );
+U(n,k) = 1 + U(n-1,k-1) + U(n-1,k) + U(n,k-1);
+U(n,k) = 1 + A(n-1,k-1)>>1 + A(n-1,k)>>1 + A(n,k-1)>>1; A(n,k) is always odd if k>0
+*/
+
+/*-------------------------------------------------------------------*
+ * a_three_fx()
+ *-------------------------------------------------------------------*/
+static
+UWord32 a_three_fx( /* o: offset for dim 3 */
+ UWord32 k_val /* i: nb unit pulses */
+) /* k_val may be higher than 16 bit signed */
+{
+ IF( k_val )
+ {
+ /* return (ONE_U + k_val*((k_val - ONE_U) << ONE)); */
+ return UL_addNsD(1U,UL_Mpy_32_32(k_val,UL_lshl(UL_subNsD(k_val,1U),1)));
+ }
+ ELSE
+ {
+ return 0;
+ }
+}
+
+/*-------------------------------------------------------------------*
+ * a_four_fx()
+ *-------------------------------------------------------------------*/
+static
+UWord32 a_four_fx( /* o: offset for dim 4 */
+ UWord32 k_val /* i: nb unit pulses */
+)
+{
+ UWord32 UL_2k;
+ IF(k_val)
+ {
+ /* return UDIVBY3*((k_val<0,k=0) */
+ h_mem[1] = UL_deposit_l(1); /* A(*,k=1) */
+
+ UL_k_val_in = UL_deposit_l(k_val_in);
+ IF(EQ_16(dim_in,2))
+ {
+ FOR( k_val = 2 ; k_val <= UL_k_val_in ; k_val++ )
+ {
+ h_mem[k_val] = UL_subNsD(UL_lshl(k_val,1),1U);
+ move32(); /* A(2, 2 .. k ) */
+ }
+ h_mem[k_val] = UL_k_val_in;
+ move32(); /* U(2,k+1) */
+ }
+ ELSE
+ {
+ k_val_prev = UL_deposit_l(1U);
+ FOR(k_val_curr = 2; k_val_curr<=UL_k_val_in; k_val_curr++)
+ {
+ h_mem[k_val_curr] = UL_addNsD(1U , UL_Mpy_32_32(k_val_curr, UL_lshl(k_val_prev,1)));
+ move32();
+ k_val_prev = UL_addNsD(k_val_curr, 0U); /* 1 op*/
+ }
+ h_mem[k_val_curr] = UL_Mpy_32_32(k_val_curr,k_val_prev);
+ move32(); /* % U(3,k_val_in+1) u_three(k+1) */
+ }
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * a_fwd_fx()
+ *
+ * create offsets for A(n,k) from lower A(n-1,k)
+ *-------------------------------------------------------------------*/
+static
+void a_fwd_fx(
+ UWord32 *a_in, /* i/o: offsets */
+ Word16 n_items /* i : items, k's */
+)
+{
+ UWord32 a_1, a_in0 ;
+ Word16 i ;
+ UWord32* a_in_prev_ptr;
+
+ a_in0 = UL_deposit_l(1);
+
+ a_in_prev_ptr=&(a_in[-1]); /* single loop ptr setup not counted; */
+ FOR(i=1; i<=n_items; i++) /* basic A fwd row recursion */
+ {
+ a_1 = UL_addNsD(a_in0, UL_addNsD(a_in_prev_ptr[i], a_in[i])) ;
+ a_in_prev_ptr[i] = a_in0;
+ move32();
+ a_in0 = UL_addNsD(a_1, 0U);
+ }
+ a_in_prev_ptr[i] = a_in0;
+ move32();
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * a_bwd_fx()
+ *
+ * create offsets for A(n,k) from higher A(n+1,k)
+ *-------------------------------------------------------------------*/
+static
+void a_bwd_fx(
+ UWord32 *a_in, /* i/o: offsets */
+ Word16 n_items /* i: n_items */
+)
+{
+ UWord32 a_1, a_in0;
+ Word16 i;
+ UWord32* a_in_prev_ptr;
+
+ a_in0 = UL_deposit_l(0);
+ a_in_prev_ptr = &(a_in[-1]);
+
+ FOR(i = 1; i<=n_items; i++) /*basic A reverse row recursion */
+ {
+ /* 2x[i] ptr memory access below are treated as ptr access */
+ a_1 = UL_subNsD(UL_subNsD(a_in[i], a_in0), a_in_prev_ptr[i]);
+ a_in_prev_ptr[i] = a_in0;
+ move32();
+ a_in0 = UL_addNsD(a_1, 0U);
+
+ }
+ a_in_prev_ptr[i] = a_in0;
+ move32();
+ return;
+}
+
+static
+UWord32 direct_row_A2U_rec_calc_fx(Word16 dim_in , Word16 k_val_in, UWord32 a_km2, UWord32 a_km1)
+{
+ /* U(n,k) = (A(n,k-2)-1)/2 + ((2*n-1)*A(n,k-1) - A(n,k-2) )/2*(k-1) */
+ /* U(n,k) = floor(A(n,k-2)/2) + (n*A(n,k-1) - floor(A(n,k-1)/2) - floor(A(n,k-2)/2) +1 )/(k-1) */
+ /* U(n,k) = floor(A(n,k-2)/2) + (n*A(n,k-1) - (floor(A(n,k-1)/2) + floor(A(n,k-2)/2) +1) )/(k-1) */
+
+ UWord32 km2_size, UL_um2, UL_dim ;
+ Word16 divisor;
+
+ divisor = sub(k_val_in,1);
+ UL_um2 = UL_lshr(a_km2,1U);
+ UL_dim = UL_deposit_l(dim_in);
+ km2_size = UL_addNsD(UL_addNsD(UL_lshr(a_km1,1), UL_um2), 1U);
+ IF(s_and(divisor,0x1) != 0)
+ {
+ /* odd */
+ return UL_addNsD(UL_um2, f_odd_exact_div_opt_fx( UL_dim, a_km1, km2_size, shr(divisor,1)));
+ }
+ ELSE
+ {
+ /* even divisor, */
+ return UL_addNsD(UL_um2, f_even_exact_div_opt_fx(UL_dim, a_km1, km2_size, divisor));
+ }
+}
+
+static
+void a_u_fwd_fx(UWord32 *a_u_in,
+ Word16 k_val_in,
+ Word16 mem_size_m1)
+{
+ UWord32 u_kp1_prev, u_kp1;
+ UWord32 u_k_prev ;
+
+ u_kp1_prev = a_u_in[mem_size_m1];
+ move32(); /* previous n U (n,k+1) value*/
+ u_k_prev = UL_lshr(a_u_in[k_val_in],1); /* previous n A(n,k) value*/
+
+ a_fwd_fx(&a_u_in[1], k_val_in); /* a_u_in[k==ZERO] = zero if n>0 */
+
+ /* low dynamic last offset entry mixed recursion */
+ /* used for size calculation */
+ /* U(n,k+1) = 1 + U(n-1,k+1) + U(n-1,k) + U(n,k) */
+ /* U(n,k+1) = 1 + U(n-1,k+1) + (A(n-1,k)-1)/2 + (A(n,k)-1)/2 */
+ /* Note, A(n,k) always odd for k>0 , subtracted one always shifted out */
+
+ u_kp1 = UL_lshr(a_u_in[k_val_in],1);
+ a_u_in[mem_size_m1] = UL_addNsD(1U, UL_addNsD(u_kp1_prev, UL_addNsD(u_k_prev,u_kp1)));
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * nm_h_prep_opt_fx()
+ *
+ * find and return N_MPVQ(n,k) and also offsets A(n, 0 to k ) and U(n,k+1).
+ *-------------------------------------------------------------------*/
+static
+UWord32 nm_h_prep_opt_fx( /* o: msize for dim */
+ Word16 dim_in, /* i: dimension */
+ Word16 k_val_in, /* i: nb unit pulses */
+ UWord32 *h /* o: A/U offsets array */
+)
+{
+ Word16 mem_size_m1, k_val,tmp ;
+ Word16 dim_tmp, d_start;
+ UWord32 h_saveA, h_saveB, u_kp1,a_k; /* registers for alternating A(n,k-1), A(n,k-2)*/
+ UWord32 numDsub1;
+ Word16 end_loop, add_last_odd ;
+
+ h[0] = UL_deposit_l(0); /* % A(=>0,k=0) */
+ h[1] = UL_deposit_l(1); /* % A(*,k=1) */
+
+ mem_size_m1 = add(k_val_in,1);
+
+ assert(dim_in > N_OPT_FX); /* code now optimized with direct functions for dim <= N_OPT_FX ) */
+ IF( (GT_16(k_val_in, TABLE_LIM_OPT_FX)))
+ {
+ d_start = 2;
+ move16();
+ if( GE_16(dim_in,3))
+ {
+ /* start from A(3), U(3) */
+ d_start = 3;
+ move16(); /* single op */
+ }
+ initOffsets_fx(d_start, h, k_val_in);
+ FOR(dim_tmp = d_start; dim_tmp < dim_in; dim_tmp++)
+ {
+ a_u_fwd_fx(h, k_val_in, mem_size_m1);
+ }
+ a_k = h[k_val_in];
+ move32();
+ u_kp1 = h[mem_size_m1];
+ move32();
+ }
+ ELSE
+ {
+ numDsub1 = UL_deposit_l(sub(shl(dim_in,1),1));
+ h[2] = numDsub1;
+ move32();
+
+ /* interleaved " odd, even [odd]" divisor calls */
+ h_saveA = numDsub1;
+ move32();
+ h_saveB = UL_deposit_l(1);
+
+ /* OPT: makes sure that the STL FOR loop is not broken */
+ tmp = sub(k_val_in,3);
+ add_last_odd = 0;
+ move16() ; /*k_val_in=0 1 2*/
+ if(tmp == 0)
+ {
+ add_last_odd = 1;
+ move16(); /*k_val_in =3 */
+ }
+ k_val = 3;
+ move16();
+ IF( tmp > 0 )
+ {
+ /* k_val_in = 3,4, 5,6, 7 ... */
+ end_loop = mem_size_m1;
+ move16();
+ add_last_odd = s_and(k_val_in,0x1) ;
+ move16(); /* odd -> 0x00100*/
+ /* even loop limits, and odd tail exists , and */
+ if(NE_16(add_last_odd,0))
+ {
+ end_loop = sub(end_loop,1); /* make initial loop to even number of (odd-even )pairs *//* one basicop */
+ }
+ FOR(k_val = 3; k_val < end_loop ; k_val++ )
+ {
+ /* the optimized non broken loop k=(3,4)(5,6)...(odd,even)*/
+ /* A(n,k) = A(n,k-2) + ((2*n-1)*A(n,k-1)-A(n,k-2)) /(k-1) */
+ /* first odd k, even divisor */
+ h_saveB = UL_addNsD(h_saveB, f_even_exact_div_opt_fx(numDsub1, h_saveA, h_saveB, sub(k_val,1)));
+ h[k_val] = h_saveB;
+ move32();
+
+ /* next even k, odd divisor */
+ /*k_val++; */
+ h_saveA = UL_addNsD(h_saveA, f_odd_exact_div_opt_fx(numDsub1, h_saveB, h_saveA,shr(k_val,1)));
+ k_val++; /* ptr incr */
+ h[k_val] = h_saveA;
+ move32();
+ }
+ }
+
+ if(NE_16(add_last_odd,0))
+ {
+ /* add a last odd call as needed , not to be called if k_val_in is [0,1,2] */
+ h_saveB = UL_addNsD(h_saveB,f_even_exact_div_opt_fx(numDsub1, h_saveA, h_saveB, sub(k_val,1)));
+ h[k_val_in] = h_saveB;
+ move32();
+ }
+
+ /* always do the last (k+1) recursion based on U(n,k+1) = func( A(n-2,k+1), A(n-1,k+1) ) */
+ a_k = h[k_val_in] ;
+ move32();
+ u_kp1 = direct_row_A2U_rec_calc_fx(dim_in, mem_size_m1 , h[sub(mem_size_m1,2)], a_k );
+ h[mem_size_m1] = u_kp1;
+ move32();
+ }
+
+ /* N_MPVQ(n,k) = 1 + U(n,k+1) + U(n,k) = 1 + U(n,k+1) + floor(A(n,k))/2) ; */ /* as A(n,k) always odd */
+ return ( UL_addNsD(1U, UL_addNsD(u_kp1, UL_lshr(a_k,1))));
+}
+
+/*
+ find_amp_split_offset_func_mem_fx()
+ find first offset in range 0..k_val_in that is less than ind_in
+ using a tree search with direct function calls [ or memory iteration]
+*/
+static
+Word16 find_amp_split_offset_func_mem_fx( /* o: found k_value */
+ UWord32 ind_in,
+ Word16 high, /* i: k_val_in (high bound) */
+ H_FUNCM h_func_ptr, /* i: offset function pointer */
+ UWord32 *UL_tmp_offset) /* o: offset found */
+{
+ Word16 not_ready, low, k_test=0;
+ UWord16 sgn ;
+ UWord32 UL_tmp;
+ /* split over A(n,k) = h_mem(k), or use direct A function evaluation */
+
+ low = 0;
+ move16();
+ move32(); /* account for adaptive function ptr setup */
+ not_ready = 1 ;
+ move16();
+
+ WHILE( not_ready != 0)
+ {
+ k_test = shr(add(low,high),1); /*% split range in half */
+ *UL_tmp_offset = (*h_func_ptr)(UL_deposit_l(k_test)); /* call direct A offset-function */
+
+ UL_tmp = UL_subNs(*UL_tmp_offset, ind_in, &sgn );
+ IF ( sgn )
+ {
+ /* (*tmp_offset < ind_in) */
+ low = add(1, k_test) ;
+ if( GE_16(k_test ,high))
+ {
+ not_ready = 0;
+ move16(); /* single basicop */
+ }
+ }
+ ELSE
+ {
+ /* (ind_in <= *tmp_offset ) */
+ high = sub(k_test,1);
+ if( UL_tmp == 0)
+ {
+ /* (*tmp_offset == ind_in) */
+ not_ready = 0;
+ move16(); /* single basicop */
+ }
+ }
+ }
+ return k_test;
+}
+
+/*
+ get_lead_sign_fx()
+ updated index and return leading sign
+*/
+static
+Word16 get_lead_sign_fx(UWord32 *ind)
+{
+ Word16 leading_sign;
+
+ leading_sign = 1;
+ move16();
+ if( UL_and(*ind,1) != 0 )
+ {
+ /* leading sign stored in LSB */
+ leading_sign = -1;
+ move16();
+ }
+ (*ind) = UL_lshr(*ind,1);
+
+ return leading_sign;
+}
+
+/*-------------------------------------------------------------------*
+ * mind2vec_one_fx()
+ *-------------------------------------------------------------------*/
+static
+void mind2vec_one_fx(
+ Word16 k_val_in, /* i: nb unit pulses */
+ Word16 leading_sign, /* i: leading sign -1, 0, 1*/
+ UWord32 ind, /* i: index */ /* parameter needed as it is used in a function array */
+ Word16* vec_out /* o: pulse train */
+)
+{
+ /* NB input k_val_in can be zero */
+ /* *vec_out = leading_sign*k_val_in; */
+ *vec_out = (Word16)ind; /* dummy assignment to avoid gcc "unused parameter" warning for ind, i.e no move16() needed */
+
+ /* *vec_out = extract_l(L_mult0(leading_sign,k_val_in)); move16(); // 3 ops */
+ if( leading_sign < 0 )
+ {
+ k_val_in = negate(k_val_in); /* single basicop --> if */
+ }
+ *vec_out = k_val_in;
+ move16(); /* 1 op */
+}
+
+static
+void mind2vec_two_fx(
+ Word16 k_val_in, /* i: nb unit pulses */
+ Word16 leading_sign, /* i: leading sign -1,0, 1 */
+ UWord32 ind_in, /* i: index */
+ Word16 *vec_out /* o: pulse train */
+)
+{
+ UWord32 UL_ind_tmp;
+ Word16 val1;
+
+ IF (ind_in == 0)
+ {
+ /* ind_in == 0 */
+ mind2vec_one_fx( k_val_in,leading_sign,ind_in,vec_out);
+ }
+ ELSE IF ( EQ_16((Word16)u_extract_l(ind_in), sub(shl(k_val_in,1),1)))
+ {
+ /* signed ops fine as 2*KMAX << 32767) */
+ /* (ind_in == ( (unsigned int)(k_val_in<dim; i++)
+ {
+ vec_out[i]=0;
+ move16(); /* set all of short vector to zero , required for fast/early exit logic */
+ }
+
+ leading_sign = 1;
+ move16();
+ if(entry->lead_sign_ind != 0)
+ {
+ leading_sign = -1;
+ move16();
+ }
+
+ IF(entry->k_val != 0)
+ {
+ IF(GT_16(entry->dim,N_OPT_FX)) /* N_OPT_FX */
+ {
+ /* generic */
+ mind2vec_fx(entry->dim, entry->k_val, leading_sign, entry->index, vec_out, h_mem);
+ }
+ ELSE
+ {
+ /* specialized functions, with direct offset calculations */
+ (mind2vec_f_fx[entry->dim])(entry->k_val, leading_sign, entry->index, vec_out);
+ }
+ }
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+* vec2mind_one_fx()
+*-------------------------------------------------------------------*/
+static
+void vec2mind_one_fx(
+ const Word16* vec_in, /* i : PVQ pulse train */
+ Word16 *k_val_out_ptr , /* o : number of unit pulses */ /* parameter needed as it is used in a function array */
+ UWord32 *next_sign_ind, /* i/o: next sign ind */
+ UWord32* ind /* o: MPVQ index */
+)
+{
+ *ind = (Word32)(*k_val_out_ptr) ; /* dummy assignment to avoid gcc "unused parameter" warning for *k_val_out_ptr, i.e no move32 needed() */
+ *ind = UL_deposit_l(0);
+
+ *next_sign_ind = UL_deposit_l(0);
+ if( *vec_in < 0 )
+ {
+ *next_sign_ind = UL_deposit_l(1); /*single basicop */
+ }
+ return ;
+}
+
+/*-------------------------------------------------------------------*
+* vec2mind_two_fx()
+*-------------------------------------------------------------------*/
+static
+void vec2mind_two_fx(
+ const Word16* vec_in, /* i : PVQ pulse train */
+ Word16 *k_val_out_ptr , /* o : number of unit pulses */
+ UWord32 *next_sign_ind, /* i/o: next sign ind */
+ UWord32* ind /* o: MPVQ index */
+)
+{
+ UWord32 lead_sign_ind_add;
+ Word16 abs0,abs1,abs01,sptr;
+
+ abs0 = abs_s(vec_in[0]);
+ abs1 = abs_s(vec_in[1]);
+ abs01 = add(abs0, abs1);
+ *k_val_out_ptr = abs01;
+ move16(); /* can be zero */
+ *ind = UL_deposit_l(0); /* [KMAX 0 ] , and dual zeros */
+
+ *next_sign_ind = UL_deposit_h(SIGNBIT_SHRT_FX); /* "unset" sign flag set */ /* dual zeroes can happen in a recursive encoding call */
+
+
+ IF( abs01 != 0 )
+ {
+ sptr = 0;
+ move16(); /*used as ptr to vec0 or vec1 value */
+ *next_sign_ind = UL_deposit_l(sptr);
+
+ test();
+ IF(abs0 != 0 && abs1 != 0 )
+ {
+ /* likely most frequent/common case */
+ /* [ KMAX-1 1],[ KMAX-1 -1] ... [ 1 +(KMAX-1) ],[ 1 -(KMAX-1)] */
+ /* sign always shifted to first pos */
+ lead_sign_ind_add = UL_deposit_l(1) ;
+ if( vec_in[1] < 0)
+ {
+ lead_sign_ind_add = UL_deposit_l(2); /* single op */
+ }
+ *ind = UL_addNsD(UL_deposit_l((UWord16)lshl(sub(abs1,1),1)),lead_sign_ind_add);
+ }
+ ELSE
+ {
+ /* one value is a zero */
+ IF( abs0 == 0 )
+ {
+ /* [ 0 KMAX]*/
+ *ind = UL_deposit_l((UWord16) sub(lshl(abs1,1),1));
+ sptr = 1;
+ move16();
+ }
+ }
+
+ /* *next_sign_ind= (unsigned int)(vec_in[*next_sign_ind]<0); */
+ if( vec_in[sptr] < 0 )
+ {
+ *next_sign_ind = UL_deposit_l(1); /*single instruction */
+ }
+ }
+ return;
+}
+
+static
+void enc_push_sign(Word16 val, UWord32* next_sign_ind, UWord32 *index)
+{
+ /*
+ % Check if the leading sign 'bit' is to be added
+ % here the leading sign bit is put in LSB as it saves about 3 cycles in sign-decoding
+ % (one can also put it in the MSB , but then one needs to access h_mem twice and shift the sign bit into position )
+ */
+ test();
+ IF( (UL_and(*next_sign_ind,SIGNBIT_FX) == 0) && (val != 0))
+ {
+ *index = UL_addNsD(UL_lshl(*index,1),*next_sign_ind);
+ }
+
+ /* push sign to next non_zero position */
+ /* *next_sign_ind = *next_sign_ind ;*/ /* default is to keep stored sign index */
+ if( val < 0 )
+ {
+ *next_sign_ind = UL_deposit_l(1); /* single basicop */
+ }
+ if( val > 0)
+ {
+ *next_sign_ind = UL_deposit_l(0); /* single basicop */
+ }
+}
+
+/*-------------------------------------------------------------------*
+ * vec2mind_gen345_fx( vec_in kval, next_dim_func , offset_func,....)
+ * generic call saves PROM ,
+ *-------------------------------------------------------------------*/
+
+static
+void vec2mind_gen345_fx(
+ const Word16* vec_in, /* i : PVQ abs pulse train */
+ Word16 *k_val_out_ptr, /* o : number of unit pulses */
+ UWord32 *next_sign_ind , /* i/o: next sign ind */
+ UWord32* index , /* o: MPVQ index */
+ VEC2INDFUNCM vec2indfunc_ptr, /* i: */
+ H_FUNCM a_func_ptr /*i: offset function */
+)
+{
+ Word16 tmp_val;
+
+ tmp_val = vec_in[0];
+ move16();
+ move32(); /* adaptive function call setup */
+ (*vec2indfunc_ptr)(&vec_in[1], k_val_out_ptr, next_sign_ind, index);
+
+ enc_push_sign(tmp_val, next_sign_ind, index);
+
+ move32(); /* adaptive function call setup */
+ *index = UL_addNsD(*index,(*a_func_ptr)(UL_deposit_l(*k_val_out_ptr)));
+
+ *k_val_out_ptr = add(*k_val_out_ptr, abs_s(tmp_val));
+
+ return ;
+}
+
+/*-------------------------------------------------------------------*
+ * vec2mind_three_fx()
+ *-------------------------------------------------------------------*/
+static
+void vec2mind_three_fx(
+ const Word16* vec_in, /* i : PVQ pulse train */
+ Word16* k_val_out_ptr, /* o : number of unit pulses */
+ UWord32 *next_sign_ind, /* i/o: next sign ind */
+ UWord32 *index /* o: MPVQ index */
+)
+{
+ vec2mind_gen345_fx(vec_in,k_val_out_ptr, next_sign_ind, index, vec2mind_two_fx, a_three_fx);
+ return ;
+}
+
+
+/*-------------------------------------------------------------------*
+ * vec2mind_four_fx()
+ *-------------------------------------------------------------------*/
+static
+void vec2mind_four_fx(
+ const Word16* vec_in, /* i : PVQ pulse train */
+ Word16* k_val_out_ptr, /* o : number of unit pulses */
+ UWord32* next_sign_ind , /* i/o: next sign ind */
+ UWord32* index /* o: MPVQ index */
+)
+{
+ vec2mind_gen345_fx(vec_in, k_val_out_ptr, next_sign_ind, index, vec2mind_three_fx, a_four_fx);
+ return ;
+}
+
+/*-------------------------------------------------------------------*
+ * vec2mind_five_fx()
+ *-------------------------------------------------------------------*/
+static
+void vec2mind_five_fx(
+ const Word16* vec_in, /* i : PVQ abs pulse train */
+ Word16 *k_val_out_ptr, /* o : number of unit pulses */
+ UWord32 *next_sign_ind , /* i/o: next sign ind */
+ UWord32* index /* o: MPVQ index */
+)
+{
+ vec2mind_gen345_fx(vec_in,k_val_out_ptr, next_sign_ind, index, vec2mind_four_fx, a_five_fx);
+ return ;
+}
+
+/*-------------------------------------------------------------------*
+* vec2mind_fx()
+*-------------------------------------------------------------------*/
+static
+void vec2mind_fx(Word16 dim_in, /* i : dim */
+ Word16 k_val_in, /* i : number of unit pulses */
+ const Word16* vec_in, /* i : PVQ pulse train */
+ UWord32 *next_sign_ind, /* o : pushed leading sign */
+ UWord32 *index , /* o : MPVQ index */
+ UWord32 *N_MPVQ_ptr, /* o : size(N_MPVQ(dim,K_val_in))*/
+ UWord32* h_mem) /* o : offsets */
+{
+ Word16 pos, mem_size_m1, k_val_acc, tmp_val;
+ UWord32 tmp_h;
+
+ /*
+ %% main steps
+ % quick encode two rightmost pos
+ % for every position from dim-3 to 0 (right to left)
+ % check if an sign is to be encoded ,
+ % add its offset
+ % check(and add) amplitude offset(for accumulated pulse sum) up to this point
+ % update total pulse sum
+ % update offset vector recursively (except for pos==0 )
+ % end
+ % calculate size
+ */
+
+ mem_size_m1 = add(k_val_in,1);
+ *next_sign_ind = UL_deposit_h(SIGNBIT_SHRT_FX); /* highest bit set signals no sign found yet, should always be 0 or 1 out, */
+
+ pos = sub(dim_in,2); /* adress 2nd last sample */
+ vec2mind_two_fx(&vec_in[pos],&k_val_acc,next_sign_ind ,index);
+ initOffsets_fx( 3, h_mem, k_val_in) ; /* start recursions at 3rd sample */
+
+ tmp_h = h_mem[k_val_acc];
+ move32();
+ FOR (pos--; pos>=0; pos--)
+ {
+ tmp_val = vec_in[pos];
+ move16();
+ enc_push_sign(tmp_val, next_sign_ind, index);
+
+ /* now add indexing offset up to this reverse (r_l) accumulated amplitude point */
+ *index = UL_addNsD(*index, tmp_h); /* k_val_acc==0 ==>0 */
+
+ /* k_val_acc = k_val_acc + vec_abs[pos];*/ /* now increase acc k value for next N */
+ k_val_acc = add(k_val_acc, abs_s(tmp_val));
+
+ IF( pos != 0 )
+ {
+ a_u_fwd_fx(h_mem, k_val_in ,mem_size_m1);
+ /* update A(n,k=1:k_val_in) and U(n,k_val_in+1) */
+ /* NB here (k_val_in + 2 elements always has to be updated */
+ }
+ tmp_h = UL_addNsD(h_mem[k_val_acc], 0U);
+ }
+
+ /* size is needed for the subseqent arithmetic encoding/transmission of the index.
+ use relation N_MPVQ(n,K) = 1 + (A(n, K)-1)/2 + U(n, 1 + K)
+ = N_MPVQ(n,K) = 1 + (A(n, K)>>1) + U(n, 1 + K) , as A(n,K) is odd) */
+ *N_MPVQ_ptr = UL_addNsD(1U,UL_addNsD(UL_lshr(tmp_h,1),h_mem[ mem_size_m1]));
+ move32();/* calc total size */
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * mpvq_encode_vec_fx()
+ *
+ * returns struct with lead sign index, MPVQ-index, dim and N_MPVQ size
+ *-------------------------------------------------------------------------*/
+
+PvqEntry_fx mpvq_encode_vec_fx( /* o : leading_sign_index, index, size, k_val */
+ const Word16* vec_in, /* i : signed pulse train */
+ Word16 dim_in, /* i : dimension */
+ Word16 k_val_local /* i : nb unit pulses */
+)
+{
+ PvqEntry_fx result;
+ UWord32 h_mem[ 1 + KMAX_NON_DIRECT_FX + 1 ] ; /* now always assign max offset buffer for dim 6 ,
+ actually only 1+k_val_in+1 needed ) */
+ UWord32 lead_sign_ind;
+
+ VEC2INDFUNCM vec2mind_f[1+N_OPT_FX] = { (VEC2INDFUNCM)NULL, vec2mind_one_fx, vec2mind_two_fx, vec2mind_three_fx, vec2mind_four_fx, vec2mind_five_fx };
+
+ result.k_val = k_val_local;
+ move16();
+ result.dim = dim_in;
+ move16();
+ /* NB , k_val_local may be changed in some sub encoding routines */
+ IF( GT_16(dim_in, N_OPT_FX))
+ {
+ /* use the generic dimension function */
+ vec2mind_fx(dim_in, k_val_local, vec_in, &lead_sign_ind, &result.index, &result.size, h_mem);
+ }
+ ELSE /* if (dim_in<=N_OPT), h_mem not used */
+ {
+ move32(); /* adaptive function ptr setup */
+ (vec2mind_f[dim_in])(vec_in, &k_val_local, &lead_sign_ind, &result.index);
+ result.size = direct_msize_fx(dim_in, k_val_local);
+ }
+ result.lead_sign_ind = u_extract_l(lead_sign_ind);
+
+ return result;
+}
+
+
diff --git a/lib_com/int_lsp_fx.c b/lib_com/int_lsp_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..f431ae38f5615693549c7c300716b7f7da068f91
--- /dev/null
+++ b/lib_com/int_lsp_fx.c
@@ -0,0 +1,173 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "stl.h"
+
+/*========================================================================*/
+/* FUNCTION : int_lsp4_fx() */
+/*------------------------------------------------------------------------*/
+/* PURPOSE : Interpolate LSPs find the A[z] parameters for all subframes */
+/* by interpolating between old end-frame LSPs, current */
+/* mid-frame LSPs and current end-frame LSPs */
+/*------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) L_frame : length of the frame */
+/* _ (Word16) m : order of LP filter */
+/* _ (Word16) clas : signal frame class */
+/* _ (Word16[]) lsp_old : LSPs from past frame Q15 */
+/* _ (Word16[]) lsp_mid : LSPs from mid-frame Q15 */
+/* _ (Word16[]) lsp_new : LSPs from present frame Q15 */
+/*------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/*------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16*) Aq : LP coefficients in both subframes Q12 */
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*========================================================================*/
+void int_lsp4_fx(
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 lsp_old[], /* i : LSPs from past frame Q15*/
+ const Word16 lsp_mid[], /* i : LSPs from mid-frame Q15*/
+ const Word16 lsp_new[], /* i : LSPs from present frame Q15*/
+ Word16 *Aq, /* o : LP coefficients in both subframes Q12*/
+ const Word16 m, /* i : order of LP filter */
+ Word16 relax_prev_lsf_interp /* i : relax prev frame lsf interp after erasure */
+)
+{
+ Word16 lsp[M16k];
+ Word16 i,j, k;
+ Word32 L_tmp;
+ const Word16 *pt_int_coeffs;
+
+ IF( EQ_16(L_frame,L_FRAME))
+ {
+ IF ( EQ_16(relax_prev_lsf_interp,1))
+ {
+ pt_int_coeffs = interpol_frac_mid_relaxprev_12k8_fx;
+ }
+ ELSE IF ( EQ_16(relax_prev_lsf_interp,2))
+ {
+ pt_int_coeffs = interpol_frac_mid_FEC_fx;
+ }
+ ELSE IF ( EQ_16(relax_prev_lsf_interp,-1))
+ {
+ pt_int_coeffs = interpol_frac_mid_relaxprev_pred_12k8_fx;
+ }
+ ELSE
+ {
+ pt_int_coeffs = interpol_frac_mid_fx;
+ }
+ }
+ ELSE /* L_frame == L_FRAME16k */
+ {
+ IF ( EQ_16(relax_prev_lsf_interp,1))
+ {
+ pt_int_coeffs = interpol_frac_mid_relaxprev_16k_fx;
+ }
+ ELSE IF ( EQ_16(relax_prev_lsf_interp,2))
+ {
+ pt_int_coeffs = interpol_frac_mid_16k_FEC_fx;
+ }
+ ELSE IF ( EQ_16(relax_prev_lsf_interp,-1))
+ {
+ pt_int_coeffs = interpol_frac_mid_relaxprev_pred_16k_fx;
+ }
+ ELSE
+ {
+ pt_int_coeffs = interpol_frac_mid_16k_fx;
+ }
+ }
+ k = sub(shr(L_frame,6),1);
+ FOR( j=0; jcore_brate_fx,SID_1k75))
+ {
+
+ indice[0] = (Word16)get_next_indice_fx( st, 6 );
+ move16();
+ indice[1] = (Word16)get_next_indice_fx( st, 6 );
+ move16();
+ indice[2] = (Word16)get_next_indice_fx( st, 6 );
+ move16();
+ indice[3] = (Word16)get_next_indice_fx( st, 5 );
+ move16();
+ indice[4] = (Word16)get_next_indice_fx( st, 5 );
+ move16();
+
+ disf_ns_28b_fx( indice, isf_new );
+
+ reorder_isf_fx( isf_new, ISF_GAP_FX, M, Fs_2);
+
+ E_LPC_isf_isp_conversion( isf_new, isp_new, M);
+ /* return if SID frame (conversion to A(z) done in the calling function) */
+ return;
+ }
+
+ /*-----------------------------------------------------------------*
+ * ISF de-quantization of all other frames
+ *-----------------------------------------------------------------*/
+
+ IF( EQ_32(st->core_brate_fx,ACELP_6k60))
+ {
+ indice[0] = (Word16)get_next_indice_fx( st, 8 );
+ move16();
+ indice[1] = (Word16)get_next_indice_fx( st, 8 );
+ move16();
+ indice[2] = (Word16)get_next_indice_fx( st, 7 );
+ move16();
+ indice[3] = (Word16)get_next_indice_fx( st, 7 );
+ move16();
+ indice[4] = (Word16)get_next_indice_fx( st, 6 );
+ move16();
+
+ disf_2s_36b_fx( indice, isf_new, st->mem_AR_fx, st->mem_MA_fx, 1 );
+ }
+ ELSE
+ {
+ indice[0] = (Word16)get_next_indice_fx( st, 8 );
+ move16();
+ indice[1] = (Word16)get_next_indice_fx( st, 8 );
+ move16();
+ indice[2] = (Word16)get_next_indice_fx( st, 6 );
+ move16();
+ indice[3] = (Word16)get_next_indice_fx( st, 7 );
+ move16();
+ indice[4] = (Word16)get_next_indice_fx( st, 7 );
+ move16();
+ indice[5] = (Word16)get_next_indice_fx( st, 5 );
+ move16();
+ indice[6] = (Word16)get_next_indice_fx( st, 5 );
+ move16();
+
+ disf_2s_46b_fx( indice, isf_new, st->mem_AR_fx, st->mem_MA_fx,1 );
+ }
+ reorder_isf_fx( isf_new, ISF_GAP_FX, M, Fs_2 );
+ /* convert quantized ISFs to ISPs */
+ E_LPC_isf_isp_conversion( isf_new, isp_new, M);
+
+ /*-------------------------------------------------------------------------------------*
+ * FEC - update adaptive mean ISF vector
+ *-------------------------------------------------------------------------------------*/
+
+ FOR ( i=0; ilsf_adaptive_mean[i] = (st->lsfoldbfi1[i] + st->lsfoldbfi0[i] + isf_new[i]) / 3;*/
+ L_tmp = L_mult(st->lsfoldbfi1_fx[i], 10923);
+ L_tmp = L_mac(L_tmp, st->lsfoldbfi0_fx[i], 10923);
+ st->lsf_adaptive_mean_fx[i] = round_fx(L_mac(L_tmp, isf_new[i], 10923));
+ }
+
+ /*-------------------------------------------------------------------------------------*
+ * ISP interpolation
+ * A(z) calculation
+ *-------------------------------------------------------------------------------------*/
+
+ if(st->rate_switching_reset)
+ {
+ /*extrapolation instead of interpolation*/
+ Copy(isp_new, st->lsp_old_fx, M);
+ Copy(isf_new, st->lsf_old_fx, M);
+ }
+
+ /* ISP interpolation and A(z) calculation */
+ int_lsp_fx( L_FRAME, st->lsp_old_fx, isp_new, Aq, M, interpol_isp_amr_wb_fx, 1 );
+
+ /*------------------------------------------------------------------*
+ * Check ISF stability : distance between old ISF and current ISF
+ *------------------------------------------------------------------*/
+
+ st->stab_fac_fx = lsf_stab_fx( isf_new, st->lsf_old_fx, 1, st->L_frame_fx );
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * disf_ns_28b()
+ *
+ * ISF de-quantizer for SID_1k75 frames (only for AMR-WB IO mode)
+ *-------------------------------------------------------------------*/
+
+void disf_ns_28b_fx(
+ Word16 *indice, /* i : quantized indices (use indice[0] = -1 in the decoder) */
+ Word16 *isf_q /* o : ISF in the frequency domain (0..6400) */
+)
+{
+ Word16 i;
+
+ FOR (i = 0; i < 2; i++)
+ {
+ isf_q[i] = dico1_ns_28b_fx[indice[0]*2+i];
+ move16();
+ }
+
+ FOR (i = 0; i < 3; i++)
+ {
+ isf_q[i+2] = dico2_ns_28b_fx[indice[1]*3+i];
+ move16();
+ isf_q[i+5] = dico3_ns_28b_fx[indice[2]*3+i];
+ move16();
+ }
+
+ FOR (i = 0; i < 4; i++)
+ {
+ isf_q[i+8] = dico4_ns_28b_fx[indice[3]*4+i];
+ move16();
+ isf_q[i+12] = dico5_ns_28b_fx[indice[4]*4+i];
+ move16();
+ }
+
+ FOR (i=0; i
+#include "prot_fx.h"
+#include "rom_com_fx.h"
+#include "basop_util.h"
+#include "stl.h"
+
+/*-------------------------------------------------------------------*
+ * Local constants
+ *-------------------------------------------------------------------*/
+
+#define kLagWinThGain1 19661 /* 0.6f in Q15 */
+#define kLagWinThGain2 9830 /* 0.3f in Q15 */
+
+/*-------------------------------------------------------------*
+ * procedure lag_wind: *
+ * ~~~~~~~~~ *
+ * lag windowing of the autocorrelations *
+ *-------------------------------------------------------------*/
+
+void lag_wind(
+ Word16 r_h[], /* in/out: autocorrelations */
+ Word16 r_l[], /* in/out: autocorrelations */
+ Word16 m, /* input : order of LP filter */
+ Word32 sr, /* input : sampling rate */
+ Word16 strength /* input : LAGW_WEAK, LAGW_MEDIUM, or LAGW_STRONG */
+)
+{
+ Word16 i;
+ Word32 tmp;
+ const Word16 *wnd_h, *wnd_l;
+
+
+ assert(0 <= strength && strength <= NUM_LAGW_STRENGTHS);
+ SWITCH (sr)
+ {
+ case 8000:
+ assert(m <= 16);
+ assert(strength == LAGW_STRONG);
+ wnd_h = lag_window_8k[0];
+ wnd_l = lag_window_8k[1];
+ BREAK;
+ case 12800:
+ assert(m <= 16);
+ wnd_h = lag_window_12k8[strength][0];
+ wnd_l = lag_window_12k8[strength][1];
+ BREAK;
+ case 16000:
+ assert(m <= 16);
+ wnd_h = lag_window_16k[strength][0];
+ wnd_l = lag_window_16k[strength][1];
+ BREAK;
+ case 24000:
+ case 25600:
+ assert(m <= 16);
+ wnd_h = lag_window_25k6[strength][0];
+ wnd_l = lag_window_25k6[strength][1];
+ BREAK;
+ case 32000:
+ assert(m <= 16);
+ wnd_h = lag_window_32k[strength][0];
+ wnd_l = lag_window_32k[strength][1];
+ BREAK;
+ case 48000:
+ assert(m <= 16);
+ assert(strength == LAGW_STRONG);
+ wnd_h = lag_window_48k[0];
+ wnd_l = lag_window_48k[1];
+ BREAK;
+ default:
+ assert(!"Lag window not implemented for this sampling rate");
+ return;
+ }
+
+ FOR (i = 1; i <= m; i++)
+ {
+ tmp = Mpy_32(r_h[i], r_l[i], wnd_h[i-1], wnd_l[i-1]);
+ L_Extract(tmp, &r_h[i], &r_l[i]);
+ }
+
+}
+
+void adapt_lag_wind(
+ Word16 r_h[], /* in/out: autocorrelations */
+ Word16 r_l[], /* in/out: autocorrelations */
+ Word16 m, /* input : order of LP filter */
+ const Word16 Top, /* input : open loop pitch lag */
+ const Word16 Tnc, /* input : open loop pitch gain */
+ Word32 sr /* input : sampling rate */
+)
+{
+ Word16 strength, pitch_lag;
+ Word16 pitch_gain;
+
+ pitch_lag = Top;
+ move16();
+ pitch_gain = Tnc;
+ move16();
+
+ IF (LT_16(pitch_lag, 80))
+ {
+ strength = LAGW_STRONG;
+ move16();
+ if (LE_16(pitch_gain, kLagWinThGain1))
+ {
+ strength = LAGW_MEDIUM;
+ move16();
+ }
+ }
+ ELSE IF (LT_16(pitch_lag, 160))
+ {
+ strength = LAGW_MEDIUM;
+ move16();
+ if (LE_16(pitch_gain, kLagWinThGain2))
+ {
+ strength = LAGW_WEAK;
+ move16();
+ }
+ }
+ ELSE
+ {
+ strength = LAGW_WEAK;
+ move16();
+ }
+
+ lag_wind(r_h, r_l, m, sr, strength);
+}
diff --git a/lib_com/lerp.c b/lib_com/lerp.c
new file mode 100644
index 0000000000000000000000000000000000000000..e866e231cb7d93492567ffa6bbc420d66ddc6c4f
--- /dev/null
+++ b/lib_com/lerp.c
@@ -0,0 +1,179 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h"
+#include "basop_util.h"
+#include "prot_fx.h"
+#include
+#include "stl.h"
+
+
+
+#define shift_e (16-1)
+#define pos_e (16-1)
+
+static void lerp_proc(Word16 *f, Word16 *f_out, Word16 bufferNewSize, Word16 bufferOldSize);
+
+
+void lerp(Word16 *f, Word16 *f_out, Word16 bufferNewSize, Word16 bufferOldSize)
+{
+ Word16 tmp1, tmp2, tmpexp;
+ BASOP_Util_Divide_MantExp(bufferNewSize, 0, bufferOldSize, 0, &tmp1, &tmpexp);
+ tmp1 = shr(tmp1,3); /*Q12*/
+ tmp1 = shl(tmp1,tmpexp);
+
+ BASOP_Util_Divide_MantExp(bufferOldSize, 0, bufferNewSize, 0, &tmp2, &tmpexp);
+ tmp2 = shr(tmp2,3); /*Q12*/
+ tmp2 = shl(tmp2,tmpexp);
+ test();
+ test();
+ IF(GT_16(tmp1,16224 /*3,9609375 in Q12*/))
+ {
+ Word16 tmpNewSize = shl(bufferOldSize,1);
+ WHILE(GT_16(bufferNewSize, bufferOldSize))
+ {
+ BASOP_Util_Divide_MantExp(bufferNewSize, 0, bufferOldSize, 0, &tmp1, &tmpexp);
+ tmp1 = shr(tmp1,3); /*Q12*/
+ tmp1 = shl(tmp1,tmpexp);
+ test();
+ IF(LE_16(tmp1,16224 /*3,9609375 in Q12*/))
+ {
+ tmpNewSize = bufferNewSize;
+ }
+
+ lerp_proc(f, f_out, tmpNewSize, bufferOldSize);
+
+ f = f_out;
+ bufferOldSize = tmpNewSize;
+ tmpNewSize = shl(tmpNewSize,1);
+ }
+ }
+ ELSE IF(GT_16(tmp2,16224 /*3,9609375 in Q12*/))
+ {
+ Word16 tmpNewSize = shr(bufferOldSize,1);
+ WHILE(LT_16(bufferNewSize, bufferOldSize))
+ {
+ BASOP_Util_Divide_MantExp(bufferOldSize, 0, bufferNewSize, 0, &tmp2, &tmpexp);
+ tmp2 = shr(tmp2,3); /*Q12*/
+ tmp2 = shl(tmp2,tmpexp);
+ test();
+ IF(LE_16(tmp2,16224 /*3,9609375 in Q12*/))
+ {
+ tmpNewSize = bufferNewSize;
+ }
+
+ lerp_proc(f, f_out, tmpNewSize, bufferOldSize);
+
+ f = f_out;
+ bufferOldSize = tmpNewSize;
+ tmpNewSize = shr(tmpNewSize,1);
+ }
+ }
+ else
+ {
+ lerp_proc(f, f_out, bufferNewSize, bufferOldSize);
+ }
+}
+
+void lerp_proc(Word16 *f, Word16 *f_out, Word16 bufferNewSize, Word16 bufferOldSize)
+{
+
+ Word16 i, idx, n;
+ Word16 diff;
+ Word32 pos, shift;
+ Word16 buf[2*L_FRAME_MAX];
+ Word16 *ptr;
+
+
+ ptr = f_out;
+ test();
+ test();
+ test();
+ if ( ((f <= f_out) && (f + bufferOldSize >= f_out)) || ((f_out <= f) && (f_out + bufferNewSize >= f)) )
+ {
+ ptr = buf;
+ move16();
+ }
+
+ IF( EQ_16(bufferNewSize, bufferOldSize))
+ {
+ Copy(f, f_out, bufferNewSize);
+ return;
+ }
+
+ shift = L_shl(L_deposit_l(div_s( bufferOldSize, shl(bufferNewSize, 4))), 4-shift_e+16);
+
+ pos = L_sub(L_shr(shift, 1), 32768l/*1.0f Q15*/);
+
+ /* Adjust interpolation shift to avoid accessing beyond end of input buffer. */
+ if ( LT_32(shift, 19661l/*0.3f Q16*/))
+ {
+ pos = L_sub(pos, 8520l/*0.13f Q16*/);
+ }
+
+ assert(pos_e == shift_e);
+
+ /* first point of interpolation */
+ IF (pos<0)
+ {
+
+ diff = shr(extract_l(pos), 1);
+ /*buf[0]=f[0]+pos*(f[1]-f[0]);*/
+ move16();
+ *ptr++ = add(f[0], msu_r(L_mult(diff, f[1]),diff, f[0]));
+ }
+ ELSE
+ {
+
+ idx=extract_h(pos);
+
+ diff = lshr(extract_l(pos), 1);
+
+ move16();
+ *ptr++ = add(f[idx], msu_r(L_mult(diff, f[idx+1]), diff, f[idx]));
+ }
+
+ pos = L_add(pos, shift);
+ idx = s_max(0, extract_h(pos));
+
+ n = sub(bufferNewSize, 1);
+ FOR ( i=1; i= f_out)) || ((f_out <= f) && (f_out + bufferNewSize >= f)) )
+ {
+ Copy( buf, f_out, bufferNewSize );
+ }
+
+}
diff --git a/lib_com/limit_t0_fx.c b/lib_com/limit_t0_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..d5b31b19bb2c7097d93e2a804aa01dfcb8a41c54
--- /dev/null
+++ b/lib_com/limit_t0_fx.c
@@ -0,0 +1,259 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+#include "rom_basop_util.h"
+
+
+/*-------------------------------------------------*
+ * Local constants
+ *-------------------------------------------------*/
+
+#define LIMIT_PIT_REL_LOWER 2 /* delta interval to extend pitch coding in relative Q */
+#define LIMIT_PIT_REL_UPPER 0
+
+/*-------------------------------------------------*
+ * limit_T0()
+ *
+ * Close-loop pitch lag search limitation
+ *-------------------------------------------------*/
+
+
+void limit_T0_fx(
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 delta, /* i : Half the close-loop searched interval */
+ const Word16 pit_flag, /* i : selecting absolute(0) or delta(1) pitch quantization */
+ const Word16 limit_flag, /* i : flag for Q limits (0=restrained, 1=extended) */
+ const Word16 T0, /* i : rough pitch estimate around which the search is done */
+ const Word16 T0_frac, /* i : pitch estimate fractional part */
+ Word16 *T0_min, /* o : lower pitch limit */
+ Word16 *T0_max /* o : higher pitch limit */
+)
+{
+
+ Word16 delta2,T1;
+ Word16 pit_min, pit_max;
+
+ IF( limit_flag == 0 ) /* restrained Q limits */
+ {
+ /* set limits */
+ IF( EQ_16(L_frame,L_FRAME))
+ {
+ pit_max = PIT_MAX;
+ move16();
+ pit_min = PIT_MIN;
+ move16();
+ }
+ ELSE /* L_frame == L_FRAME16k */
+ {
+ pit_max = PIT16k_MAX;
+ move16();
+ pit_min = PIT16k_MIN;
+ move16();
+ }
+
+ delta2 = sub(shl(delta,1),1);
+ T1 = T0;
+ move16();
+
+ if( GE_16(T0_frac,2))
+ {
+ T1 = add(T1,1);
+ }
+
+ *T0_min = sub(T1,delta);
+ move16();
+
+ *T0_min = s_max(*T0_min,pit_min);
+
+ *T0_max = add(*T0_min,delta2);
+ move16();
+
+ IF( GT_16(*T0_max,pit_max))
+ {
+ *T0_max = pit_max;
+ move16();
+ *T0_min = sub(*T0_max,delta2);
+ move16();
+ }
+ }
+ ELSE /* extended Q limits */
+ {
+ /* set limits */
+ IF( EQ_16(L_frame, L_FRAME))
+ {
+ pit_max = PIT_MAX;
+ move16();
+ pit_min = PIT_MIN_EXTEND;
+ move16();
+ if( EQ_16(limit_flag, 2))
+ {
+ pit_min = PIT_MIN_DOUBLEEXTEND;
+ move16();
+ }
+ }
+ ELSE /* L_frame == L_FRAME16k */
+ {
+ pit_max = PIT16k_MAX;
+ move16();
+ pit_min = PIT16k_MIN_EXTEND;
+ move16();
+ }
+
+ delta2 = sub(shl(delta,1),1) ;
+ move16();
+ T1 = T0;
+ move16();
+ if( GE_16(T0_frac,2))
+ {
+ T1 = add(T1,1);
+ }
+ *T0_min = sub(T1, delta);
+ move16();
+ IF( pit_flag == 0 )
+ {
+ /* subframes with absolute search: keep Q range */
+ *T0_min = s_max(*T0_min,pit_min);
+
+ *T0_max = add(*T0_min, delta2);
+ move16();
+ IF( GT_16(*T0_max,pit_max))
+ {
+ *T0_max = pit_max;
+ move16();
+ *T0_min = sub(*T0_max, delta2);
+ move16();
+ }
+ }
+ ELSE
+ {
+ /* subframes with relative search: extend Q range */
+ *T0_min = s_max(*T0_min,sub(pit_min, LIMIT_PIT_REL_LOWER));
+ move16();
+
+ *T0_min = s_max(*T0_min,L_INTERPOL);
+ *T0_max = *T0_min + delta2;
+ move16();
+
+ IF( GT_16(*T0_max, add(pit_max, LIMIT_PIT_REL_UPPER)))
+ {
+ *T0_max = add(pit_max, LIMIT_PIT_REL_UPPER);
+ move16();
+ *T0_min = sub(*T0_max, delta2);
+ move16();
+ }
+ }
+ }
+ return;
+}
+
+
+#define inv_T0_res InvIntTable
+
+/*-------------------------------------------------*
+* Routine limit_T0_voiced()
+*
+* Close-loop pitch lag search limitation
+*-------------------------------------------------*/
+void limit_T0_voiced(
+ const Word16 nbits,
+ const Word16 res,
+ const Word16 T0, /* i : rough pitch estimate around which the search is done */
+ const Word16 T0_frac, /* i : pitch estimate fractional part */
+ const Word16 T0_res, /* i : pitch resolution */
+ Word16 *T0_min, /* o : lower pitch limit */
+ Word16 *T0_min_frac, /* o : lower pitch limit */
+ Word16 *T0_max, /* o : higher pitch limit */
+ Word16 *T0_max_frac, /* o : higher pitch limit */
+ const Word16 pit_min, /* i : Minimum pitch lag */
+ const Word16 pit_max /* i : Maximum pitch lag */
+)
+{
+ Word16 T1, temp1, temp2, res2;
+
+
+ assert(res > 1 && res<=6);
+
+ res2 = res;
+ move16();
+ if(EQ_16(res,6))
+ {
+ res2 = shr(res2,1);
+ }
+
+ /* Mid-point */
+ T1 = T0;
+ test();
+ if( GT_16(T0_res,1)&&GE_16(T0_frac,(shr(T0_res,1))))
+ {
+ T1 = add(T1,1);
+ }
+
+ /* Lower-bound */
+ temp1 = sub(i_mult(T1,res),shl(1,sub(nbits,1)));
+
+ temp2 = mult(temp1,inv_T0_res[res2]);
+ if(EQ_16(res,6))
+ {
+ temp2 = shr(temp2,1);
+ }
+
+ *T0_min = temp2;
+ move16();
+
+ *T0_min_frac = sub(temp1,i_mult(temp2,res));
+ move16();
+
+ IF ( LT_16(*T0_min,pit_min))
+ {
+ *T0_min = pit_min;
+ move16();
+ *T0_min_frac = 0;
+ move16();
+ }
+
+ /* Higher-bound */
+ temp1 = add(i_mult(*T0_min,res),add(*T0_min_frac,sub(shl(1,nbits),1)));
+
+ temp2 = mult(temp1,inv_T0_res[res2]);
+ if(EQ_16(res,6))
+ {
+ temp2 = shr(temp2,1);
+ }
+
+ *T0_max = temp2;
+ move16();
+
+ *T0_max_frac = sub(temp1,i_mult(temp2,res));
+ move16();
+
+ IF ( GT_16(*T0_max,pit_max))
+ {
+ *T0_max = pit_max;
+ move16();
+
+ *T0_max_frac = sub(res,1);
+ move16();
+
+ temp1 = add(i_mult(*T0_max,res),sub(*T0_max_frac,sub(shl(1,nbits),1)));
+
+ temp2 = mult(temp1,inv_T0_res[res2]);
+ if(EQ_16(res,6))
+ {
+ temp2 = shr(temp2,1);
+ }
+ move16();
+ *T0_min = temp2;
+
+ *T0_min_frac = sub(temp1, i_mult(temp2,res));
+ move16();
+ }
+
+
+ return;
+}
diff --git a/lib_com/logqnorm_fx.c b/lib_com/logqnorm_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..957fcdfc6d3c965339f474960fa7dc874fd595b9
--- /dev/null
+++ b/lib_com/logqnorm_fx.c
@@ -0,0 +1,195 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h" /* required for wmc_tool */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "cnst_fx.h" /* Common constants */
+
+/* Local constants */
+#define THREN2POW 1518500250L
+
+/*--------------------------------------------------------------------------*
+ * logqnorm_fx
+ *
+ * Log quantization for norms of sub-vectors
+ *--------------------------------------------------------------------------*/
+
+void logqnorm_fx(
+ const Word32 *L_x, /* i : coefficient vector Qx */
+ const Word16 qx, /* i : Q value of input */
+ Word16 *k, /* o : index Q0 */
+ const Word16 L, /* i : codebook length Q0 */
+ const Word16 N, /* i : sub-vector size Q0 */
+ const Word16 hvq_flag /* i : HVQ flag Q0 */
+)
+{
+ Word16 i, m;
+ Word16 coefs_shift, power_shift, temp_shift;
+ Word32 L_temp, L_temp1, L_temp2;
+ Word16 coefs16[MAX_SFM_LEN_FX];
+ UWord16 lsb;
+
+ Word16 offset = add(3,shl(qx,1)); /* 3 + 2*qx */
+
+ lsb = 0U; /* to avoid compilation warnings */
+
+ L_temp1 = L_deposit_l(1);
+ FOR (i=0; i
+#include
+#include "prot_fx.h"
+#include "stl.h"
+
+
+/**
+ * \brief inplace long shift right: a[] = a[] >> bits
+ * Logical shift right of UWord32 vector a[] by 'bits' positions.
+ * BASOP cycles: FLC cycles
+ * len = 1: 8 lena = 2: 24
+ * len = 2: 13 lena = 4: 34
+ * len = 3: 18 lena = 6: 44
+ * len = 4: 23 lena = 8: 54
+ * \param UWord32 a[]
+ * Input: vector of the length len
+ * \param Word16 bits
+ * Input: number of bit positions to shift right in range 1..31
+ * Note: 'bits' must not be 0, this would cause a shift-overflow
+ * \param Word16 len
+ * Input: length of vector a[] in units of 'UWord32'
+ *
+ * \return void
+ */
+
+void longshr(UWord32 a[], Word16 bits, Word16 len)
+{
+ Word16 fracb_u, k;
+
+ assert ((bits > 0) && (bits < 32));
+
+ fracb_u = sub(32,bits);
+ len = sub(len,1);
+ FOR (k=0; k < len; k++)
+ {
+ a[k] = L_or(L_lshr(a[k],bits),L_lshl(a[k+1],fracb_u));
+ move32();
+ }
+ a[k] = L_lshr(a[k],bits);
+ move32();
+
+ return;
+}
diff --git a/lib_com/low_rate_band_att_fx.c b/lib_com/low_rate_band_att_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..680b95ed6324c7d6c0b9273213a3931791fecd21
--- /dev/null
+++ b/lib_com/low_rate_band_att_fx.c
@@ -0,0 +1,219 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "options.h" /* Compilation switches */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h"
+#include "stl.h" /* required for wmc_tool */
+
+
+/*--------------------------------------------------------------------------*
+ * fine_gain_pred()
+ *
+ * Fine gain prediction
+ *--------------------------------------------------------------------------*/
+
+void fine_gain_pred_fx(
+ const Word16 *sfm_start, /* i : Sub band start indices */
+ const Word16 *sfm_end, /* i : Sub band end indices */
+ const Word16 *sfm_size, /* i : Sub band bandwidths */
+ const Word16 *i_sort, /* i : Energy sorting indices */
+ const Word16 *K, /* i : Number of pulses per band */
+ const Word16 *maxpulse, /* i : Maximum pulse per band */
+ const Word16 *R, /* i : Bits per sub band Q3 */
+ const Word16 num_sfm, /* i : Number of sub bands */
+ Word16 *xq, /* i/o: Quantized vector /quantized vector with finegain adj Q15*/
+ Word16 *y, /* i/o: Quantized vector (int) */
+ Word16 *fg_pred, /* o : Predicted fine gains Q12 */
+ const Word16 core /* i : Core */
+)
+{
+ Word16 i, band;
+ Word16 gp;
+ Word32 xx;
+ Word16 accuracy;
+ Word16 k, bw;
+
+ Word16 shift, bw_idx;
+ Word16 tmp, exp, exp2;
+ Word32 L_tmp;
+ UWord16 lsb;
+
+ FOR( band = 0; band < num_sfm; band++)
+ {
+ k = K[i_sort[band]];
+ move16();
+
+ IF( k > 0)
+ {
+ /* bw, bw_idx only used if k>0 */
+ bw = sfm_size[i_sort[band]];
+ move16(); /* allowed. 8, 16, 24,32,48,64,80,96 */
+ bw_idx = band_len_idx[ shr(bw,3) ];
+ move16(); /* bw_idx= 0: 7 */
+ xx = L_deposit_l(0);
+ shift = band_len_ener_shift[bw_idx];
+ FOR(i = sfm_start[i_sort[band]]; i < sfm_end[i_sort[band]]; i++)
+ {
+ /*xx += xq[i] * xq[i]; */
+ tmp = shr(xq[i], shift); /*15-shift */
+ xx = L_mac0(xx, tmp, tmp); /*30-2*shift */
+ }
+
+ IF ( xx > 0)
+ {
+ /* Normalize synthesis to RMS=1.0 */
+ /*gp = (float) sqrt(bw / xx); */
+ exp = norm_l(xx);
+ L_tmp = L_shl(xx, exp); /*2*(15-shift)+exp */
+ exp = sub(31, add(exp, sub(30, shl(shift,1))));
+ L_tmp = Isqrt_lc(L_tmp, &exp); /*31 - exp */
+ Mpy_32_16_ss(L_tmp, fine_gain_pred_sqrt_bw[bw_idx], &L_tmp, &lsb); /*31-exp+11-15=27-exp */
+ gp = round_fx(L_shl(L_tmp, add(1, exp))); /*27-exp+1+exp-16=12 */
+
+ test();
+ test();
+ IF (EQ_16(core, HQ_CORE)&&R!=NULL&&LE_16(R[i_sort[band]],256)) /* 256 is 32 in Q3 */
+ {
+ /*accuracy = ((float)k/(float)bw)*maxpulse[i_sort[band]]; */
+ L_tmp = L_mult(k, inv_tbl_fx[bw]); /*0+15+1 */
+ exp2 = norm_l(L_tmp);
+ tmp = round_fx(L_shl(L_tmp, exp2)); /*16+exp2-16 */
+ L_tmp = L_mult0(maxpulse[i_sort[band]], tmp); /*0+exp2 */
+ exp = norm_l(L_tmp);
+ accuracy = round_fx(L_shl(L_tmp, exp)); /*exp2+exp-16=exp-16 */
+ exp = add(exp, exp2);
+
+ /*gp *= 1.0f - 0.05f / accuracy; */
+ tmp = div_s(13107, accuracy); /* 0.05 in Q18 */
+ tmp = shr(tmp, sub(34, exp)); /*15+18-exp+16-15=34-exp */
+ tmp = sub(32767, tmp);
+ tmp = s_max(27554, tmp); /* Limit attenuation to norm quantizer error, 2^-0.25 in Q15 */
+ gp = mult_r(tmp, gp); /*15+12+1-16=12 */
+ }
+
+ fg_pred[band] = gp;
+ move16();
+ }
+ ELSE
+ {
+ fg_pred[band] = 0;
+ move16();
+ }
+ }
+ ELSE
+ {
+ fg_pred[band] = 0;
+ move16();
+ FOR(i = sfm_start[i_sort[band]]; i < sfm_end[i_sort[band]]; i++)
+ {
+ y[i] = 0;
+ move16();
+ xq[i] = 0;
+ move16();
+ }
+ }
+ }
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * get_max_pulses()
+ *
+ * Find the maximum pulse height (in unit pulses) in each band
+ *--------------------------------------------------------------------------*/
+
+void get_max_pulses_fx(
+ const Word16 *band_start, /* i : Sub band start indices */
+ const Word16 *band_end, /* i : Sub band end indices */
+ const Word16 *k_sort, /* i : Indices for sorting by energy */
+ const Word16 *npulses, /* i : Pulses per sub band */
+ const Word16 BANDS, /* i : Number of bands */
+ Word16 *inp_vector, /* i/o: Encoded shape vectors (int)*/
+ Word16 *maxpulse /* o : Maximum pulse height per band */
+)
+{
+ Word16 i, k;
+ Word16 npul;
+ Word16 maxp;
+ Word16 tmp;
+
+ FOR (k = 0; k < BANDS; k++)
+ {
+ npul = npulses[k_sort[k]];
+ move16();
+ maxp = 0;
+ move16();
+ IF (npul > 0)
+ {
+ FOR (i = band_start[k_sort[k]]; i < band_end[k_sort[k]]; i++)
+ {
+ tmp = abs_s(inp_vector[i]);
+ if (GT_16(tmp, maxp))
+ {
+ maxp = tmp;
+ move16();
+ }
+ }
+ }
+ maxpulse[k_sort[k]] = maxp;
+ move16();
+ }
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * fine_gain_dec()
+ *
+ * Fine gain decoder. Decodes fine gain adjustments and applies correction to
+ * predicted fine gains
+ *--------------------------------------------------------------------------*/
+
+void fine_gain_dec_fx
+(
+ Decoder_State_fx *st,
+ const Word16 *ord, /* i : Indices for energy order */
+ const Word16 num_sfm, /* i : Number of bands */
+ const Word16 *gain_bits, /* i : Gain adjustment bits per sub band */
+ Word16 *fg_pred /* i/o: Predicted gains / Corrected gains */
+)
+{
+ Word16 band;
+ Word16 gbits;
+ Word16 idx, tmp1, exp1;
+ Word16 gain_dbq;
+ Word32 L_tmp;
+
+
+ FOR ( band = 0; band < num_sfm; band++)
+ {
+ gbits = gain_bits[ord[band]];
+ IF (gbits > 0)
+ {
+ IF (fg_pred[band] != 0)
+ {
+ idx = get_next_indice_fx( st, gbits );
+ gain_dbq = finegain_fx[gbits-1][idx];
+
+ /* Update predicted gain with quantized correction */
+ L_tmp = L_mult0(gain_dbq, 21771); /* 21771=0.05*log2(10) */ /* 14+17=31 */
+ L_tmp = L_shr(L_tmp, 15);
+ tmp1 = L_Extract_lc(L_tmp, &exp1);
+ tmp1 = abs_s(tmp1);
+ tmp1 = extract_l(Pow2(14, tmp1));
+ exp1 = sub(14, exp1);
+
+ L_tmp = L_mult0(fg_pred[band], tmp1); /*12+exp1 */
+ fg_pred[band] = round_fx(L_shl(L_tmp, sub(16, exp1))); /*12+exp1+16-exp1-16=12 */
+ }
+ }
+ }
+
+ return;
+}
+
+
diff --git a/lib_com/lpc_tools_fx.c b/lib_com/lpc_tools_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..d690482f5693b31a3e1318e296d5952a95a33415
--- /dev/null
+++ b/lib_com/lpc_tools_fx.c
@@ -0,0 +1,1009 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "rom_com_fx.h"
+#include "stl.h"
+#include "basop_mpy.h"
+#include "basop_util.h"
+
+
+/*-----------------------------------------------------------------*
+ * Local constants
+ *-----------------------------------------------------------------*/
+
+#define MAX_LEN_LP 960 /* maximum length in samples of the LP analysis window */
+
+/*---------------------------------------------------------------------*
+ * autocorr()
+ *
+ * Compute autocorrelations of input signal
+ *---------------------------------------------------------------------*/
+void autocorr_fx(
+ const Word16 x[], /* i : Input signal */
+ const Word16 m, /* i : LPC order Q0 */
+ Word16 r_h[], /* o : Autocorrelations (msb) Q15 */
+ Word16 r_l[], /* o : Autocorrelations (lsb) */
+ Word16 *Q_r, /* o : normalisation shift of r Q0 */
+ const Word16 len, /* i : Frame lenght */
+ const Word16* wind, /* i : Window used */
+ Word16 rev_flag,
+ const Word16 sym_flag /* i : symmetric window flag */
+)
+{
+ Word16 i, j, norm, shift, y[MAX_LEN_LP];
+ Word16 fact;
+ Word32 L_sum, L_tmp;
+
+ IF(EQ_16(rev_flag,1))
+ {
+ /* Windowing of signal */
+ FOR (i = 0; i < len; i++)
+ {
+ y[i] = mult_r(x[i], wind[len-i-1]);
+ move16();
+ }
+ }
+ ELSE IF( EQ_16(sym_flag,1))
+ {
+ /* symmetric window of even length */
+ FOR( i=0; i 0)
+ {
+ fact = lshr(-32768, shift);
+ FOR (i = 0; i < len; i++)
+ {
+ y[i] = mult_r(y[i], fact);
+ move16();
+ }
+ }
+ ELSE
+ {
+ shift = 0;
+ move16();
+ }
+
+ /* Compute and normalize r[0] */
+ L_sum = L_mac(1, y[0], y[0]);
+ FOR (i = 1; i < len; i++)
+ {
+ L_sum = L_mac(L_sum, y[i], y[i]);
+ }
+ norm = norm_l(L_sum);
+ L_sum = L_shl(L_sum, norm);
+ L_Extract(L_sum, &r_h[0], &r_l[0]); /* Put in DPF format (see oper_32b) */
+
+ /* Compute r[1] to r[m] */
+ FOR (i = 1; i <= m; i++)
+ {
+ L_sum = L_mult(y[0],y[i]);
+ FOR (j = 1; j < len - i; j++)
+ {
+ L_sum = L_mac(L_sum, y[j], y[j + i]);
+ }
+
+ L_sum = L_shl(L_sum, norm);
+ L_Extract(L_sum, &r_h[i], &r_l[i]); /* Put in DPF format (see oper_32b) */
+ }
+
+ *Q_r = sub(norm, shl(shift, 1));
+ move16();
+}
+
+/*****************************************************************************
+ * *
+ * Function Name : Div_32_opt *
+ * *
+ * Purpose : *
+ * Fractional integer division of two 32 bit numbers. *
+ * L_num / L_denom. *
+ * L_num and L_denom must be positive and L_num < L_denom. *
+ * L_denom = denom_hi<<16 + denom_lo<<1 *
+ * denom_hi is a normalize number. *
+ * *
+ * Inputs : *
+ * *
+ * L_num *
+ * 32 bit long signed integer (Word32) whose value falls in the *
+ * range : 0x0000 0000 < L_num < L_denom *
+ * *
+ * L_denom = denom_hi<<16 + denom_lo<<1 (DPF) *
+ * *
+ * denom_hi *
+ * 16 bit positive normalized integer whose value falls in the *
+ * range : 0x4000 < hi < 0x7fff *
+ * denom_lo *
+ * 16 bit positive integer whose value falls in the *
+ * range : 0 < lo < 0x7fff *
+ * *
+ * Return Value : *
+ * *
+ * L_div *
+ * 32 bit long signed integer (Word32) whose value falls in the *
+ * range : 0x0000 0000 <= L_div <= 0x7fff ffff. *
+ * *
+ * Algorithm: *
+ * *
+ * - find = 1/L_denom. *
+ * First approximation: approx = 1 / denom_hi *
+ * 1/L_denom = approx * (2.0 - L_denom * approx ) *
+ * *
+ * - result = L_num * (1/L_denom) *
+ *****************************************************************************
+*/
+static
+Word32 Div_32_opt (Word32 L_num, Word16 denom_hi, Word16 denom_lo)
+{
+ Word16 approx /*, hi, lo, n_hi , n_lo*/;
+ Word32 L_32;
+
+ /* First approximation: 1 / L_denom = 1/denom_hi */
+
+ approx = div_s ((Word16) 0x3fff, denom_hi);
+
+ /* 1/L_denom = approx * (2.0 - L_denom * approx) */
+
+ L_32 = Msu_32_16 ((Word32) 0x7fffffffL, denom_hi, denom_lo, approx);
+
+ L_32 = Mpy_32_16_1(L_32, approx);
+
+ /* L_num * (1/L_denom) */
+
+ L_32 = Mpy_32_32(L_num, L_32);
+
+ L_32 = L_shl (L_32, 2);
+
+ return (L_32);
+}
+
+/*
+ * E_LPC_lev_dur
+ *
+ * Parameters:
+ * Rh I: Rh[m+1] Vector of autocorrelations (msb)
+ * Rl I: Rl[m+1] Vector of autocorrelations (lsb)
+ * A O: A[m] LPC coefficients (m = 16) Qx (A[0] is always 1, so the format can be deduced in the caller with norm_s(A[0]))
+ * epsP O: error vector, msb
+ * order I: LPC order Q0
+ *
+ * Function:
+ * Levinson-Durbin algorithm to compute
+ * the LPC parameters from the autocorrelations of speech.
+ *
+ * Returns:
+ * void
+ */
+Word16 E_LPC_lev_dur(const Word16 Rh[], const Word16 Rl[], Word16 A[],
+ Word32 epsP[], const Word16 order
+ ,Word16 *mem
+ )
+{
+ return(E_LPC_lev_dur_stab(Rh, Rl, A, epsP, order, mem, 32750)); /* 0.99945 in Q15 */
+}
+
+Word16 E_LPC_lev_dur_stab(const Word16 Rh[], const Word16 Rl[], Word16 A[],
+ Word32 epsP[], const Word16 order,
+ Word16 *mem, Word16 k_max
+ )
+{
+ Word16 i, j, k;
+ Word16 hi, lo;
+ Word16 Kh, Kl; /* reflection coefficient; hi and lo */
+ Word16 alp_h, alp_l, alp_exp; /* Prediction gain; hi lo and exponent */
+ Word32 t0, t1, t2; /* temporary variables */
+ Word16 flag;
+ Word16 Ah[TCXLTP_LTP_ORDER + 1], Al[TCXLTP_LTP_ORDER + 1]; /* LPC coef. in double prec. */
+
+
+ BASOP_SATURATE_WARNING_OFF
+ if(epsP!=NULL)
+ {
+ epsP[0] = L_Comp(Rh[0], Rl[0]);
+ move32();
+ }
+
+ flag=0;
+ move16();
+
+ /* K = A[1] = -R[1] / R[0] */
+ t1 = L_Comp(Rh[1], Rl[1]); /* R[1] in Q31 */
+ t2 = L_abs(t1); /* abs R[1] */
+ t0 = L_deposit_l(0);
+ IF (Rh[0] != 0)
+ {
+ t0 = Div_32_opt(t2, Rh[0], Rl[0]); /* R[1]/R[0] in Q31 */
+ /* Cause a difference in MODE1 due to different implementation of div32*/
+ }
+ if (t1 > 0)
+ {
+ t0 = L_negate(t0); /* -R[1]/R[0] */
+ }
+ Kl = L_Extract_lc(t0, &Kh); /* K in DPF */
+ t0 = L_shr(t0, 4); /* A[1] in Q27 */
+ L_Extract(t0, &Ah[1], &Al[1]); /* A[1] in DPF */
+
+ /* Alpha = R[0] * (1-K**2) */
+ t0 = Sqr_32(Kh, Kl); /* K*K in Q31 */
+ t0 = L_abs(t0); /* Some case <0 !! */
+ t0 = L_sub((Word32) 0x7fffffffL, t0); /* 1 - K*K in Q31 */
+ lo = L_Extract_lc(t0, &hi); /* DPF format */
+ t0 = Mpy_32(Rh[0], Rl[0], hi, lo); /* Alpha in Q31 */
+ if(epsP!=NULL)
+ {
+ epsP[1] = t0;
+ move32();
+ }
+
+ /* Normalize Alpha */
+ alp_exp = norm_l(t0);
+ t0 = L_shl(t0, alp_exp);
+ alp_l = L_Extract_lc(t0, &alp_h);
+ /* DPF format */
+
+ /*--------------------------------------*
+ * ITERATIONS I=2 to m
+ *--------------------------------------*/
+
+ FOR (i = 2; i <= order; i++)
+ {
+ /* t0 = SUM(R[j]*A[i-j], j=1, i-1) + R[i] */
+ t0 = L_deposit_l(0);
+ FOR (j = 1; j < i; j++)
+ {
+ t0 = Mac_32(t0, Rh[j], Rl[j], Ah[i - j], Al[i - j]);
+ }
+
+ t0 = L_shl(t0, 4); /* result in Q27 -> convert to Q31 */
+ /* No overflow possible */
+
+ /* Compose and add R[i] in Q3 */
+ t0 = L_mac(t0, Rl[i], 1);
+ t0 = L_msu(t0, Rh[i], -32768);
+
+ /* K = -t0 / Alpha */
+ t1 = L_abs(t0);
+ t2 = L_deposit_l(0);
+ IF (alp_h != 0)
+ {
+ t2 = Div_32_opt(t1, alp_h, alp_l); /* abs(t0)/Alpha */
+ /* Cause a difference in MODE1 due to different implementation of div32*/
+ }
+
+ if (t0 > 0)
+ {
+ t2 = L_negate(t2); /* K =-t0/Alpha */
+ }
+ t2 = L_shl(t2, alp_exp); /* denormalize; compare to Alpha */
+ test();
+ if ((mem!=NULL) && ((GT_16(abs_s(extract_h(t2)), k_max))))
+ {
+ flag=1;
+ move16();/* Test for unstable filter. If unstable keep old A(z) */
+ }
+ if ((mem!=NULL) && ((LT_32(L_abs(t2), 5))))
+ {
+ flag=1;
+ move16(); /*R matrix not reliable (R saturated for many coeff), keep old A(z) */
+ }
+ Kl = L_Extract_lc(t2, &Kh); /* K in DPF */
+
+ /*------------------------------------------*
+ * Compute new LPC coeff. -> An[i]
+ * An[j]= A[j] + K*A[i-j] , j=1 to i-1
+ * An[i]= K
+ *------------------------------------------*/
+
+ k = mult_r(i, 16384);
+ FOR (j = 1; j < k; j++)
+ {
+ /* Do two Iterations Together to Allow Direct Update of Ah & Al */
+ t0 = Mac_32(L_Comp(Ah[j], Al[j]), Kh, Kl, Ah[i-j], Al[i-j]);
+ t1 = Mac_32(L_Comp(Ah[i-j], Al[i-j]), Kh, Kl, Ah[j], Al[j]);
+ L_Extract(t0, &Ah[j], &Al[j]);
+ L_Extract(t1, &Ah[i-j], &Al[i-j]);
+ }
+ IF (s_and(i, 1) == 0)
+ {
+ t0 = Mac_32(L_Comp(Ah[j], Al[j]), Kh, Kl, Ah[i-j], Al[i-j]);
+ L_Extract(t0, &Ah[j], &Al[j]);
+ }
+ t2 = L_shr(t2, 4); /* t2 = K in Q31 ->convert to Q27 */
+ L_Extract(t2, &Ah[i], &Al[i]); /* An[i] in Q27 */
+
+ /* Alpha = Alpha * (1-K**2) */
+ t1 = L_mult(Kh, Kh); /* K*K in Q31 */
+ t0 = L_mac(t1, mult(Kh, Kl), 2);
+ t0 = L_abs(t0); /* Some case <0 !! */
+ t0 = L_sub((Word32) 0x7fffffffL, t0); /* 1 - K*K in Q31 */
+ lo = L_Extract_lc(t0, &hi); /* DPF format */
+ t0 = Mpy_32(alp_h, alp_l, hi, lo); /* Alpha in Q31 */
+
+
+ /* store denormalized alpha in epsP */
+ t1 = L_shr(t0, alp_exp);
+ if(epsP!=NULL)
+ {
+ epsP[i] = t1;
+ move32();
+ }
+
+ /* Normalize Alpha */
+ j = norm_l(t0);
+ t0 = L_shl(t0, j);
+ alp_l = L_Extract_lc(t0, &alp_h);/* DPF format */
+ alp_exp = add(alp_exp, j); /* Add normalization to alp_exp */
+ }
+
+ /* Adaptive scaling */
+ t1 = L_deposit_l(0);
+ FOR (i = 1; i <= order; i++)
+ {
+ t0 = L_Comp(Ah[i], Al[i]);
+ t1 = L_max( t1, L_abs(t0) );
+ }
+ k = s_min( norm_l( t1 ), 3 );
+ A[0] = shl( 2048, k );
+ move16();
+ FOR (i = 1; i <= order; i++)
+ {
+ t0 = L_Comp(Ah[i], Al[i]);
+ A[i] = round_fx(L_shl(t0, k));
+ }
+
+ BASOP_SATURATE_WARNING_ON
+ IF (mem != NULL)
+ {
+ /* Enforce stable LPC filter - parcorr[0] and parcorr[1] are not LPC coeffiecients */
+ IF(flag)
+ {
+ Copy(mem, A, order + 1);
+ }
+ ELSE /* If stable LPC filter, store into memories */
+ {
+ Copy(A, mem, order + 1);
+ }
+ }
+
+
+ return(flag);
+}
+
+/*
+ * E_LPC_a_add_tilt
+ *
+ * Parameters:
+ * a I: LP filter coefficients (m+1 coeffs)
+ * ap O: modified LP filter coefficients (m+2 coeffs)
+ * gamma I: tilt factor
+ * m I: order of LP filter
+ *
+ * Function:
+ * Modified LP filter by adding 1st order pre-premphasis, Ap(z)=A(z).(1-gamma.z^(-1))
+ *
+ * Returns:
+ * void
+ */
+void E_LPC_a_add_tilt(const Word16 *a, Word16 *ap, Word16 gamma, Word16 m)
+{
+ Word16 i;
+ Word32 Amax, Atmp[M+2];
+ Word16 shift;
+
+
+
+
+ Amax = L_mult( 16384, a[0] );
+ FOR (i = 1; i <= m; i++)
+ {
+ Atmp[i] = L_sub( L_mult(16384, a[i]), L_mult0(gamma, a[i-1]) );
+ move32();
+ Amax = L_max( Amax, L_abs( Atmp[i] ) );
+ }
+ Atmp[m+1] = L_negate( L_mult0(gamma, a[m]) );
+ move32();
+ Amax = L_max( Amax, L_abs( Atmp[m+1] ) );
+ shift = norm_l( Amax );
+ ap[0] = shl( a[0], sub(shift,1) );
+ move16();
+ FOR (i = 1; i <= m; i++)
+ {
+ ap[i] = round_fx( L_shl( Atmp[i], shift ) );
+ }
+ ap[m+1] = round_fx( L_shl( Atmp[m+1], shift ) );
+
+}
+
+void E_LPC_int_lpc_tcx(const Word16 lsp_old[], /* input : LSPs from past frame Q15 */
+ const Word16 lsp_new[], /* input : LSPs from present frame Q15 */
+ Word16 a[] /* output: interpolated LP coefficients Q12 */
+ )
+{
+ Word16 i, lsp[M];
+
+
+
+ FOR (i = 0; i < M; i++)
+ {
+ /*lsp[i] = lsp_old[i]*0.125f + lsp_new[i]*0.875f;*/
+ lsp[i] = round_fx(L_mac(L_mult(lsp_old[i],4096),lsp_new[i],28672));
+ }
+ E_LPC_f_lsp_a_conversion(lsp, a, M);
+
+
+ return;
+}
+
+static void lsp_reorder(
+ Word16 *lsp, /* (I/O): LSP vector (acos() domain) Q13*1.2732 */
+ Word16 min_dist, /* (I): minimum required distance Q13*1.2732 */
+ Word16 lpcorder /* (I): LPC order Q0 */
+)
+{
+ Word16 i;
+ Word16 lsp_min, lsp_max;
+
+
+ /* Verify the LSF ordering and minimum GAP */
+ lsp_min = min_dist;
+ move16();
+ FOR (i=0; i=0; --i)
+ {
+ lsp[i] = s_min(lsp[i], lsp_max);
+ move16();
+ lsp_max = sub(lsp[i], min_dist);
+ }
+ }
+
+}
+
+/* Approximate unweighting */
+Word16 E_LPC_lsp_unweight(
+ /* const */ Word16 lsp_w[], /* (I): weighted xSP Q15 */
+ Word16 lsp_uw[], /* (O): unweighted xSP Q15 */
+ Word16 lsf_uw[], /* (O): unweighted LSF Q1*1.28 */
+ Word16 inv_gamma, /* (I): inverse weighting factor Q14 */
+ Word16 lpcorder /* (I): prediction order Q0 */
+)
+{
+ Word16 lsp_w_orig[M], lsp_w_diff[M], mean, step; /* Q13*1.2732 */
+ const lsp_unw_triplet *unw_coeffs = NULL;
+ Word16 i;
+
+ step = 0; /* to avoid compilation warnings */
+
+
+ assert(lpcorder == 16);
+
+ /* Table selection */
+ IF (EQ_16(inv_gamma, GAMMA16k_INV))
+ {
+ unw_coeffs = p16_gamma0_94to1;
+ move16();
+ }
+ ELSE IF (EQ_16(inv_gamma, GAMMA1_INV))
+ {
+ unw_coeffs = p16_gamma0_92to1;
+ move16();
+ }
+ ELSE
+ {
+ assert(0);
+ }
+
+ /* step = M_PI/(float)(lpcorder+1); */
+ step = 1927;
+ move16();
+ mean = 0;
+ move16();
+
+ /* Apply acos() and get mean removed version */
+ FOR (i=0; i 0.01f*2^27/2^30 */
+ Word32 tmp_epsP;
+
+
+
+ mM1 = sub(m,1);
+
+ s = getScaleFactor32(r,add(m,1));
+ IF (s!=0)
+ {
+ scale_sig32(r,add(m,1),s); /* scale in-place */
+ }
+
+ g1 = r;
+ Copy32(r+1,g0,m);
+
+ /* compute g0[0]/g1[0], where g0[0] < g1[0] */
+ temp16 = negate(divide3232(g0[0], g1[0]));
+ reflCoeff[0] = temp16;
+ move16();
+ move32();
+ epsP[0] = r[0];
+
+
+ FOR (i=0; i= 0; specix++);*/
+ WHILE (mult(s,spec_r[specix]) >= 0) specix = add(specix, 1);
+
+ tmp = divide1616(spec_r[specix-1], sub(spec_r[specix-1],spec_r[specix] ) );
+ move16();
+ /*lsf[lsfix] = L_add(L_deposit_h(sub(specix,1)) , L_shl(L_deposit_l(tmp),1));*/ /*Q16*/
+ lsf[lsfix] = add(shl(sub(specix,1),7) , shr((tmp),8)); /*7Q8*/
+
+ lsfix++;
+
+ /*check for the next zero crossing*/
+ /*for (; s*spec_i[specix] >= 0; specix++);*/
+
+ WHILE (mult(s,spec_i[specix]) >= 0) specix = add(specix, 1);
+
+ tmp = divide1616(spec_i[specix-1], sub(spec_i[specix-1],spec_i[specix]) );
+ move16();
+ /*lsf[lsfix] = L_add(L_deposit_h(sub(specix,1)) , L_shl(L_deposit_l(tmp),1));*/ /*Q16*/
+ lsf[lsfix] = add(shl(sub(specix,1),7) , shr((tmp),8)); /*7Q8*/
+
+ lsfix++;
+
+ spec_r[speclen] = s;
+ move16();
+ spec_i[speclen] = s;
+ move16();
+
+ s = negate(s);
+ }
+
+ IF (LT_16(lsfix,16))
+ {
+ FOR(i=0; i<16; i++)
+ {
+ lsf[i] = old_lsf[i];
+ move16();
+ }
+ }
+
+ return;
+}
+
+void E_LPC_a_lsf_isf_conversion(Word16 *lpcCoeffs, Word16 *lsf, const Word16 *old_lsf, Word16 lpcOrder, Word8 lpcRep)
+{
+ Word32 RealFFT[128];
+ Word32 ImagFFT[128];
+ Word16 RealOut[130];
+ Word16 ImagOut[130];
+ Word32 *ptrReal;
+ Word32 *ptrImag;
+ Word16 n, i, j, step, scale;
+ const PWord16 *ptwiddle, *pwn17, *pwn17i;
+ PWord16 *pwn15, *pwn15i, tmpw15;
+ Word16 N = 256;
+ Word16 s[4];
+ Word32 L_tmp, L_tmp1, L_tmp3;
+ Word16 lpc[19];
+
+
+ /* half length FFT */
+ scale = add(norm_s(lpcCoeffs[0]),1)+5;
+ move16();
+
+ /*s = [sum(a) ((-1).^(1:length(a)))*a];*/
+ L_tmp = L_deposit_h(0);
+ FOR(j=0; j<=lpcOrder; j++)
+ {
+ L_tmp = L_mac(L_tmp, lpcCoeffs[j], 0x800);
+ }
+ /*s[1] = round_fx(L_tmp); move16();*/
+
+ L_tmp1 = L_deposit_h(0);
+ FOR(j=0; jv.re), lpc[2*j+1],ptwiddle->v.im),scale);
+ move32();
+ ptrImag[j*8] = L_shl(L_mac(L_mult(lpc[2*j+1],ptwiddle->v.re), lpc[2*j],ptwiddle->v.im),scale);
+ move32();
+ ptwiddle++;
+ }
+
+ ptrReal[j*8] = L_shl(L_mac(0,lpc[2*j],ptwiddle->v.re),scale);
+ move32();
+ ptrImag[j*8] = L_shl(L_mac(0, lpc[2*j],ptwiddle->v.im),scale);
+ move32();
+ ptwiddle++;
+ j++;
+ FOR(; j<16; j++)
+ {
+ ptrReal[j*8] = L_deposit_h(0);
+ ptrImag[j*8] = L_deposit_h(0);
+ ptwiddle++;
+ }
+
+ fft16(ptrReal, ptrImag, 8, 0);
+
+ ptrReal++;
+ ptrImag++;
+
+ }
+
+ /* pre-twiddle */
+ BASOP_getTables(NULL, &ptwiddle, &step, 128);
+ IF (lpcRep != 0)
+ {
+ pwn17i = &w19N[126];
+ pwn17 = w19N;
+ }
+ ELSE
+ {
+ pwn17i = &w18N[126];
+ pwn17 = w18N;
+ }
+
+ pwn15 = &tmpw15;
+ pwn15i = &tmpw15;
+
+ RealOut[0] = round_fx(2*L_add(RealFFT[0], ImagFFT[0]));
+ ImagOut[0] = 0;
+ move16();
+
+ RealOut[128] = 0;
+ move16();
+ ImagOut[128] = round_fx(L_sub(L_add(RealFFT[0],RealFFT[0]), L_add(ImagFFT[0], ImagFFT[0])));
+
+ ptwiddle += 8;
+ FOR(i=1; i<=N/2/4; i++)
+ {
+ Word16 ReAr = extract_h(L_add(RealFFT[i],RealFFT[N/2-i]));
+ Word16 ReBr = extract_h(L_sub(RealFFT[N/2-i], RealFFT[i]));
+ Word16 ImAr = extract_h(L_sub(ImagFFT[i], ImagFFT[N/2-i]));
+ Word16 ImBr = extract_h(L_add(ImagFFT[i], ImagFFT[N/2-i]));
+ BASOP_SATURATE_WARNING_OFF
+ tmpw15.v.re = mac_r(L_mult(ptwiddle->v.re, pwn17->v.re), ptwiddle->v.im, pwn17->v.im);
+ tmpw15.v.im = msu_r(L_mult(ptwiddle->v.re, pwn17->v.im), ptwiddle->v.im, pwn17->v.re);
+ BASOP_SATURATE_WARNING_ON
+ RealOut[i] = mac_r(L_msu(L_msu(L_mult(ReAr, pwn17->v.re),ImAr, pwn17->v.im), ReBr, pwn15->v.im), ImBr, pwn15->v.re);
+ move16();
+ ImagOut[i] = mac_r(L_mac(L_mac(L_mult(ReAr, pwn17->v.im), ImAr, pwn17->v.re), ReBr, pwn15->v.re), ImBr, pwn15->v.im);
+ move16();
+ BASOP_SATURATE_WARNING_OFF
+ tmpw15.v.re = msu_r(L_mult(ptwiddle->v.im, pwn17i->v.im), ptwiddle->v.re, pwn17i->v.re);
+ tmpw15.v.im = mac_r(L_mult(ptwiddle->v.re, pwn17i->v.im), ptwiddle->v.im, pwn17i->v.re);
+ BASOP_SATURATE_WARNING_ON
+ RealOut[N/2-i] = msu_r(L_mac(L_mac(L_mult(ReAr, pwn17i->v.re), ImAr, pwn17i->v.im), ImBr, pwn15i->v.re), ReBr, pwn15i->v.im);
+ move16();
+ ImagOut[N/2-i] = msu_r(L_msu(L_msu(L_mult(ReAr, pwn17i->v.im), ImAr, pwn17i->v.re), ReBr, pwn15i->v.re), ImBr, pwn15i->v.im);
+ move16();
+
+ ptwiddle += 8;
+ pwn17++;
+ pwn17i--;
+ }
+
+ ptwiddle -= 16;
+ /*change real with imaginary for ptwiddle*/
+ FOR(; iv.im, pwn17->v.re), ptwiddle->v.re, pwn17->v.im);
+ tmpw15.v.im = msu_r(L_mult(ptwiddle->v.im, pwn17->v.im), ptwiddle->v.re, pwn17->v.re);
+ BASOP_SATURATE_WARNING_ON
+ RealOut[i] = mac_r(L_msu(L_msu(L_mult(ReAr, pwn17->v.re),ImAr, pwn17->v.im), ReBr, pwn15->v.im), ImBr, pwn15->v.re);
+ move16();
+ ImagOut[i] = mac_r(L_mac(L_mac(L_mult(ReAr, pwn17->v.im), ImAr, pwn17->v.re), ReBr, pwn15->v.re), ImBr, pwn15->v.im);
+ move16();
+ BASOP_SATURATE_WARNING_OFF
+ tmpw15.v.re = msu_r(L_mult(ptwiddle->v.re, pwn17i->v.im), ptwiddle->v.im, pwn17i->v.re);
+ tmpw15.v.im = mac_r(L_mult(ptwiddle->v.im, pwn17i->v.im), ptwiddle->v.re, pwn17i->v.re);
+ BASOP_SATURATE_WARNING_ON
+ RealOut[N/2-i] = msu_r(L_mac(L_mac(L_mult(ReAr, pwn17i->v.re), ImAr, pwn17i->v.im), ImBr, pwn15i->v.re), ReBr, pwn15i->v.im);
+ move16();
+ ImagOut[N/2-i] = msu_r(L_msu(L_msu(L_mult(ReAr, pwn17i->v.im), ImAr, pwn17i->v.re), ReBr, pwn15i->v.re), ImBr, pwn15i->v.im);
+ move16();
+
+ ptwiddle -= 8;
+ pwn17++;
+ pwn17i--;
+ }
+ ptwiddle += 0;
+ {
+ Word16 ReAr = extract_h(L_add(RealFFT[i],RealFFT[N/2-i]));
+ Word16 ReBr = extract_h(L_sub(RealFFT[N/2-i], RealFFT[i]));
+ Word16 ImAr = extract_h(L_sub(ImagFFT[i], ImagFFT[N/2-i]));
+ Word16 ImBr = extract_h((L_negate(L_add(ImagFFT[i], ImagFFT[N/2-i]))));
+ BASOP_SATURATE_WARNING_OFF
+ tmpw15.v.re = mac_r(L_mult(ptwiddle->v.im, pwn17->v.re), ptwiddle->v.re, pwn17->v.im);
+ tmpw15.v.im = msu_r(L_mult(ptwiddle->v.im, pwn17->v.im), ptwiddle->v.re, pwn17->v.re);
+ BASOP_SATURATE_WARNING_ON
+ RealOut[i] = msu_r(L_msu(L_msu(L_mult(ReAr, pwn17->v.re), ImAr, pwn17->v.im), ReBr, pwn15->v.im), ImBr, pwn15->v.re);
+ move16();
+ ImagOut[i] = msu_r(L_mac(L_mac(L_mult(ReAr, pwn17->v.im), ImAr, pwn17->v.re), ReBr, pwn15->v.re), ImBr, pwn15->v.im);
+ move16();
+ }
+
+ spec2isf(RealOut, ImagOut, 128, lsf, old_lsf);
+ IF (lpcRep == 0)
+ {
+ lsf[lpcOrder - 1] = shl(lpcCoeffs[lpcOrder], add(norm_s(lpcCoeffs[0]),1));
+ move16(); /* From Qx to Q15 with saturation */
+ lsf[lpcOrder - 1] = xsp_to_xsf(lsf[lpcOrder - 1]);
+ move16();
+ lsf[lpcOrder - 1] = shr(lsf[lpcOrder - 1], 1);
+ move16();
+ }
+
+}
+
diff --git a/lib_com/lsf_dec_bfi_fx.c b/lib_com/lsf_dec_bfi_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..5c4796700a848a7cd603b6f368ab7393877bf2e1
--- /dev/null
+++ b/lib_com/lsf_dec_bfi_fx.c
@@ -0,0 +1,301 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+
+#include
+#include
+#include
+#include "stl.h"
+#include "basop_util.h"
+#include "rom_com_fx.h"
+#include "cnst_fx.h"
+#include "prot_fx.h"
+
+
+/*---------------------------------------------------------------------*
+* routine: lsf_dec_bfi()
+*
+* Estimate the LSFs in case of FER
+* Bad frame, all active speech coders
+*---------------------------------------------------------------------*/
+void lsf_dec_bfi(
+ const Word16 codec_mode, /* i: : codec mode: MODE1 | MODE2 */
+ Word16*lsf, /*!< o : 14Q1*1.28 quantized ISFs */
+ const Word16*lsfold, /*!< i : 14Q1*1.28 past quantized ISF */
+ Word16*lsf_adaptive_mean, /*!< i : 14Q1*1.28 ISF adaptive mean, updated when BFI==0 */
+ const Word16 lsfBase[], /* i : base for differential lsf coding */
+ Word16*mem_MA, /*!< i/o: 14Q1*1.28 quantizer memory for MA model */
+ Word16*mem_AR, /*!< i/o: 14Q1*1.28 quantizer memory for MA model */
+ Word16 stab_fac, /*!< i : ISF stability factor (shifted right by 1) */
+ const Word16 last_coder_type, /*!< i : coding type in last good received fr. */
+ Word16 L_frame,
+ const Word16 last_good, /*!< i : last good received frame */
+ const Word16 nbLostCmpt, /*!< i : counter of consecutive bad frames */
+ Word8 plcBackgroundNoiseUpdated,
+ Word16 *lsf_q_cng, /* o : quantized ISFs for background noise (14Q1*1.28) */
+ Word16 *lsf_cng,
+ Word16 *old_lsf_q_cng, /* o : old quantized ISFs for background noise */
+ const Word16 Last_GSC_pit_band_idx,
+ const Word16 Opt_AMR_WB /* i : IO flag */
+ , const Word8 tcxonly
+ ,const short MODE1_bwidth /* i: coded bandwidth */
+)
+{
+ Word16 i;
+ Word16 alpha;
+ Word32 tmp;
+ Word16 lsf_mean[M];
+ const Word16* pt_meansForFading;
+ const Word16* pt_meansForMemUpdate;
+ Word16 beta;
+ Word16 gap;
+
+ IF (EQ_16(codec_mode,MODE1))
+ {
+ pt_meansForMemUpdate = lsf_mean;
+ /* Update inital guess to something stable, with proper sampling frequency and format (ISF/LSF)*/
+ IF ( Opt_AMR_WB)
+ {
+ pt_meansForFading = Mean_isf_wb;
+ }
+ ELSE
+ {
+ /* 12.8kHz ACELP sampling */
+ IF( EQ_16(L_frame,L_FRAME))
+ {
+ pt_meansForFading = GEWB_Ave_fx;
+
+ if (EQ_16(MODE1_bwidth,NB))
+ {
+ pt_meansForFading = GENB_Ave_fx;
+ }
+ }
+ /* 16kHz ACELP sampling */
+ ELSE
+ {
+ pt_meansForFading = GEWB2_Ave_fx;
+ }
+ }
+ }
+ ELSE
+ {
+ pt_meansForFading = pt_meansForMemUpdate = lsfBase;
+ test();
+ if (lsf_cng != NULL && plcBackgroundNoiseUpdated)
+ {
+ pt_meansForFading = lsf_cng;
+ }
+ }
+ IF( LE_16(nbLostCmpt, 3))
+ {
+ test();
+ test();
+ IF( (EQ_16(last_coder_type, UNVOICED))) /* Clear unvoiced last good frame */
+ {
+ move16();
+ alpha = _ALPHA_UU_FX;
+ }
+ ELSE IF( EQ_16(last_coder_type,AUDIO)||EQ_16(last_good,INACTIVE_CLAS))
+ {
+ alpha = 32604/*0.995f Q15*/;
+ move16();
+ test();
+ if( Last_GSC_pit_band_idx > 0 && GT_16(nbLostCmpt, 1))
+ {
+ alpha = 26214/*0.8f Q15*/;
+ move16();
+ }
+ }
+ ELSE IF( EQ_16(last_good,UNVOICED_CLAS))
+ {
+ IF( LE_16(nbLostCmpt,1))
+ {
+ /* If stable, do not flatten the spectrum in the 1st erased frame */
+ alpha = add(mult(stab_fac, 32768 - _ALPHA_U_FX_X_2), _ALPHA_U_FX_X_2);
+ }
+ ELSE IF(EQ_16(nbLostCmpt,2))
+ {
+ alpha = sub(_ALPHA_U_FX_X_2,shr(_ALPHA_U_FX,1)); /* 0.6 */
+ }
+ ELSE
+ {
+ alpha = _ALPHA_U_FX;
+ move16(); /* go rapidly to CNG spectrum */
+ }
+ }
+ ELSE IF( EQ_16(last_good ,UNVOICED_TRANSITION))
+ {
+ alpha = _ALPHA_UT_FX;
+ move16();
+ }
+ ELSE IF( (EQ_16(last_good,VOICED_CLAS))||(EQ_16(last_good,ONSET)))
+ {
+ /* clearly voiced - mild convergence to the CNG spectrum for the first 3 erased frames */
+ move16();
+ alpha = _ALPHA_V_FX;
+ }
+ ELSE IF( EQ_16(last_good ,SIN_ONSET))
+ {
+ alpha = _ALPHA_S_FX;
+ move16();
+ }
+ ELSE
+ {
+ alpha = _ALPHA_VT_FX; /* rapid convergence to the CNG spectrum (long erasure, ONSETS) */
+ }
+ }
+ ELSE
+ {
+ Word16 exp = 15;
+ alpha = Inv16(nbLostCmpt, &exp); /*1.f/bfi_cnt;*/
+ alpha = shl(alpha,exp);
+ }
+ IF(EQ_16(codec_mode,MODE1))
+ {
+ beta = BETA_FEC_FX;
+ move16();
+ }
+ ELSE
+ {
+ beta = 8192/*0.25f Q15*/;
+ move16();
+ if (plcBackgroundNoiseUpdated)
+ {
+ beta = 0/*0.f Q15*/;
+ move16();
+ }
+ }
+ FOR (i=0; i
+#include
+#include "cnst_fx.h"
+#include "rom_com_fx.h"
+#include "prot_fx.h"
+#include "stl.h"
+#include "basop_util.h"
+#include "prot_fx.h"
+#include "options.h"
+
+#define swap(x,y,type) {type u__p; u__p=x; x=y; y=u__p;}
+
+extern const Word16 tbl_mid_gen_wb_5b_fx[];
+extern const Word16 tbl_mid_unv_wb_5b_fx[];
+
+
+
+
+void midlsf_dec(
+ const Word16 qlsf0[], /* i: quantized lsf coefficients (3Q12) */
+ const Word16 qlsf1[], /* i: quantized lsf coefficients (3Q12) */
+ Word16 idx, /* i: codebook index */
+ Word16 qlsf[], /* o: decoded lsf coefficients (3Q12) */
+ Word16 coder_type,
+ Word16 *mid_lsf_int,
+ Word16 prev_bfi,
+ Word16 safety_net)
+{
+ const Word16 *ratio=NULL;
+ Word16 j;
+ Word32 L_tmp;
+ Word16 bad_spacing = 0;
+
+ move16();
+ /* Select codebook */
+ IF ( EQ_16(coder_type, UNVOICED))
+ {
+ ratio = tbl_mid_unv_wb_5b_fx;
+ }
+ ELSE
+ {
+ ratio = tbl_mid_gen_wb_5b_fx;
+ }
+ FOR (j=0; jQ(x2.56+14)*/
+ L_tmp = L_mac(L_tmp, ratio[idx*M+j], qlsf1[j]); /*Q(x2.56+14)*/
+ qlsf[j] = round_fx(L_shl(L_tmp,2)); /*Q(x2.56)*/
+ }
+
+
+ IF(mid_lsf_int != NULL) /*at the decoder*/
+ {
+ /* check for incorrect LSF ordering */
+ IF ( EQ_16(*mid_lsf_int, 1))
+ {
+ FOR (j=1; j 0 && LT_16(j, M)&<_16(qlsf[j],add(qlsf[j-1],LSF_GAP_MID_FX)))
+ {
+ qlsf[j] = add(qlsf[j-1], LSF_GAP_MID_FX);
+ move16();
+ }
+
+ }
+ }
+ ELSE
+ {
+ /* otherwise, use regular LSF spacing and ordering as in the encoder */
+ FOR (j=0; j 0 && LT_16(j, M)&<_16(qlsf[j],add(qlsf[j-1],LSF_GAP_MID_FX)))
+ {
+ qlsf[j] = add(qlsf[j-1], LSF_GAP_MID_FX);
+ move16();
+ }
+ }
+ }
+ if ( prev_bfi )
+ {
+ /* continue redoing mid-LSF interpolation with 0.4 in order not to propagate the error */
+ *mid_lsf_int = 1;
+ move16();
+ }
+ if ( safety_net )
+ {
+ /* safety-net encountered -> stop redoing mid-LSF interpolation with 0.4 */
+ *mid_lsf_int = 0;
+ move16();
+ }
+ }
+ ELSE
+ {
+ /* use regular LSF spacing */
+ FOR (j=0; j 0 && LT_16(j, M)&<_16(qlsf[j],add(qlsf[j-1],LSF_GAP_MID_FX)))
+ {
+ qlsf[j] = add(qlsf[j-1], LSF_GAP_MID_FX);
+ move16();
+ }
+ }
+ }
+
+ return;
+}
+Word16 lsf_ind_is_active(
+ const Word16 lsf_q_ind[],
+ const Word16 means[],
+ Word16 narrowband,
+ Word16 cdk
+)
+{
+ Word16 lsf[2], min_distance;
+
+ lsf[0] = add(lsf_q_ind[0], means[0]);
+ move16();
+ lsf[1] = add(lsf_q_ind[1], means[1]);
+ move16();
+
+ min_distance = lsf[0];
+ move16();
+ min_distance = s_min(min_distance, sub(lsf[1], lsf[0]));
+
+ assert(narrowband == 0 || narrowband == 1);
+ assert(cdk == 0 || cdk == 1);
+
+ return sub(min_distance, min_distance_thr[narrowband][cdk]) < 0;
+}
+
diff --git a/lib_com/lsf_tools_fx.c b/lib_com/lsf_tools_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..f5d593f4479442b2edd35557c1e09e8c07e21437
--- /dev/null
+++ b/lib_com/lsf_tools_fx.c
@@ -0,0 +1,3426 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include
+#include
+#include "options.h" /* Compilation switches */
+#include "stl.h"
+#include "basop_util.h"
+#include "rom_com_fx.h"
+#include "cnst_fx.h"
+#include "prot_fx.h"
+#include "rom_com_fx.h" /* Static table prototypes */
+
+
+
+#define NC_MAX 8
+#define GUESS_TBL_SZ 256
+
+#define depack_4_values(cbp, val0, val1, val2, val3) \
+ val0 = shr((cbp)[0], 4); \
+ val1 = shr((cbp)[1], 4); \
+ val2 = shr((cbp)[2], 4); \
+ val3 = add(add(shr(lshl((cbp)[2],12),4),lshr(lshl((cbp)[1],12),8)),s_and((cbp)[0],0xF));
+
+/*-------------------------------------------------------------------*
+ * Local constants
+ *-------------------------------------------------------------------*/
+
+#define NC ( M/2)
+#define NC16k ( M16k/2)
+
+#define SPC 0.0234952f
+#define SPC_plus SPC * 1.001f
+#define ALPHA_SQ ( ( 0.5f / PI2) * ( 0.5f / PI2))
+
+/*-------------------------------------------------------------------*
+ * Local functions
+ *-------------------------------------------------------------------*/
+Word16 root_search_fx( Word16 low, Word16 high, Word32 *v_low, Word32 *coef,Word16 order);
+Word32 calc_weight( Word16 delta1,Word16 delta2,Word16 *n1 );
+Word32 polynomial_eval_fx( Word16 f, Word32 *coef,Word16 order);
+void E_LPC_isf_isp_conversion(const Word16 isf[], Word16 isp[], const Word16 m);
+void E_LPC_lsp_lsf_conversion(const Word16 lsp[],Word16 lsf[],const Word16 m);
+Word16 E_LPC_f_lsp_pol_get(const Word16 lsp[], Word32 f[], const Word16 n, const Word16 past_Ovf, const Word16 isMODE1);
+
+static Word16 chebyshev(Word16 x, Word32 *f, Word16 n, Word16 shift)
+{
+
+ Word16 cheb;
+ Word32 t0, b1, b2;
+
+ cheb = norm_s(x);
+ if (cheb)
+ {
+ x = shl(x,1);
+ }
+ t0 = Mpy_32_16_1(*f++, x); /* t0 = x*b2 */
+ if (!cheb)
+ t0 = L_shl(t0, 1); /* t0 = 2*x*b2 */
+ b1 = L_add(t0, *f++); /* b1 = 2*x*b2 + f[1] */
+
+ /* i = 2 */
+ t0 = Mpy_32_16_1(b1, x); /* t0 = x*b1 */
+ if (!cheb)
+ t0 = L_shl(t0, 1); /* t0 = 2*x*b1 */
+ b2 = L_add(t0, *f++); /* b0 = 2*x*b1 - b2 + f[i] */
+
+ /* i = 3 */
+ t0 = Mpy_32_16_1(b2, x); /* t0 = x*b1 */
+ if (!cheb)
+ t0 = L_shl(t0, 1); /* t0 = 2*x*b1 */
+ t0 = L_sub(t0, b1); /* t0 = 2*x*b1 - b2 */
+ b1 = L_add(t0, *f++); /* b0 = 2*x*b1 - b2 + f[i] */
+
+ /* i = 4 */
+ t0 = Mpy_32_16_1(b1, x); /* t0 = x*b1 */
+ if (!cheb)
+ t0 = L_shl(t0, 1); /* t0 = 2*x*b1 */
+ t0 = L_sub(t0, b2); /* t0 = 2*x*b1 - b2 */
+
+ /* If the LP order is greater than 10 */
+ IF(GT_16(n, 5))
+ {
+ b2 = L_add(t0, *f++); /* b0 = 2*x*b1 - b2 + f[i] */
+ /* i = 5 */
+ t0 = Mpy_32_16_1(b2, x); /* t0 = x*b1 */
+ if (!cheb)
+ t0 = L_shl(t0, 1); /* t0 = 2*x*b1 */
+ t0 = L_sub(t0, b1); /* t0 = 2*x*b1 - b2 */
+ b1 = L_add(t0, *f++); /* b0 = 2*x*b1 - b2 + f[i] */
+
+ /* i = 6 */
+ t0 = Mpy_32_16_1(b1, x); /* t0 = x*b1 */
+ if (!cheb)
+ t0 = L_shl(t0, 1); /* t0 = 2*x*b1 */
+ t0 = L_sub(t0, b2); /* t0 = 2*x*b1 - b2 */
+ }
+ /* IF (sub(n,8) == 0) */
+ IF (n == 8)
+ {
+ b2 = L_add(t0, *f++); /* b0 = 2*x*b1 - b2 + f[i] */
+ /* i = 7 */
+ t0 = Mpy_32_16_1(b2, x); /* t0 = x*b1 */
+ if (!cheb)
+ t0 = L_shl(t0, 1); /* t0 = 2*x*b1 */
+ t0 = L_sub(t0, b1); /* t0 = 2*x*b1 - b2 */
+ /*b1 = L_add(b2,0);*/
+ }
+ ELSE
+ {
+ b2 = b1;
+ move32();
+ }
+
+ t0/*b2*/ = L_add(t0, *f++); /* b0 = 2*x*b1 - b2 + f[i] */
+
+ t0 = Mpy_32_16_1(t0/*b2*/, x);/* t0 = x*b1 */
+ if (cheb)
+ t0 = L_shr(t0,1);
+ t0 = L_sub(t0, /*b1*/b2); /* t0 = x*b1 - b2 */
+ t0 = L_add(t0, *f++); /* t0 = x*b1 - b2 + 0.5*f[n] */
+
+
+ BASOP_SATURATE_WARNING_OFF
+ t0 = L_shl(t0, shift); /* Qx to Q30 with saturation */
+ cheb = round_fx(t0); /* Result in Q14 */
+ cheb = s_max(-32767,cheb); /* to avoid saturation */
+ BASOP_SATURATE_WARNING_ON
+ return (cheb);
+}
+
+void E_LPC_a_isp_conversion(const Word16 a[], Word16 isp[], const Word16 old_isp[], const Word16 m)
+{
+ Word16 i, nf, ip, order, nc;
+ Word16 xlow, ylow, xhigh, yhigh;
+ Word16 x, y, tmp, exp;
+ Word32 f[2][NC_MAX+1];
+ Word32 t0, t1;
+ Word16 scale=1024;
+
+
+ /*-------------------------------------------------------------*
+ * find the sum and diff polynomials F1(z) and F2(z)
+ * F1(z) = [A(z) + z^M A(z^-1)]
+ * F2(z) = [A(z) - z^M A(z^-1)]/(1-z^-2)
+ *
+ * for (i=0; i 1; i--)
+ {
+ /* f2[i] -= f2[i-2]; */
+ f2[i] = L_sub(f2[i], f2[i - 2]);
+ move32();
+ }
+
+ /*----------------------------------------------------------*
+ * Scale F1(z) by (1+isp[m-1]) and F2(z) by (1-isp[m-1]) *
+ *----------------------------------------------------------*/
+
+ FOR (i = 0; i < nc; i++)
+ {
+ /* f1[i] *= (1.0 + isp[m-1]); */
+ f1[i] = Madd_32_16(f1[i], f1[i], isp[m - 1]);
+ move32();
+
+ /* f2[i] *= (1.0 - isp[m-1]); */
+ f2[i] = Msub_32_16(f2[i], f2[i], isp[m - 1]);
+ move32();
+ }
+
+ /*-----------------------------------------------------*
+ * A(z) = (F1(z)+F2(z))/2 *
+ * F1(z) is symmetric and F2(z) is antisymmetric *
+ *-----------------------------------------------------*/
+
+ /* Maximum LPC */
+ tmax = L_deposit_l(1);
+ FOR (i = 1; i < nc; i++)
+ {
+ t0 = L_add(f1[i], f2[i]);
+ tmax = L_max( tmax, L_abs(t0) );
+ t0 = L_sub(f1[i], f2[i]);
+ tmax = L_max( tmax, L_abs(t0) );
+ }
+ q = s_min( norm_l(tmax), 6 );
+
+ DO
+ {
+
+ /* a[0] = 1.0 */
+ a[0] = shl(256,q);
+ move16();
+ j = sub(m, 1);
+ FOR (i = 1; i < nc; i++)
+ {
+ /* a[i] = 0.5*(f1[i] + f2[i]) */
+ t0 = L_add(f1[i], f2[i]); /* f1[i] + f2[i] */
+ t0 = L_shl(t0, q);
+ a[i] = round_fx(t0); /* from Q23 to Q12 and * 0.5 */
+
+ /* a[j] = 0.5*(f1[i] - f2[i]) */
+ t0 = L_sub(f1[i], f2[i]); /* f1[i] - f2[i] */
+ t0 = L_shl(t0, q);
+ a[j] = round_fx(t0); /* from Q23 to Q12 and * 0.5 */
+
+ j = sub(j,1);
+ }
+
+ /* a[NC] = 0.5*f1[NC]*(1.0 + isp[m-1]) */
+ t0 = Madd_32_16(f1[nc], f1[nc], isp[m - 1]);
+
+ BASOP_SATURATE_WARNING_OFF /*overflow handling in loop expression*/
+ t0 = L_shl(t0, q);
+ t0n = L_sub(t0 , 0x7FFFFFFF); /*check for positive overflow*/
+ t0p = L_sub(t0, 0x80000000); /*check for negative overflow*/
+ BASOP_SATURATE_WARNING_ON
+
+ q = sub(q,1); /*decrease q in case of overflow*/
+ } WHILE(t0n == 0 || t0p == 0); /*in case of overflow, recalculate coefficients*/
+
+ a[nc] = round_fx(t0); /* from Q23 to Q12 and * 0.5 */
+
+ /* a[m] = isp[m-1] */
+ t0 = L_mult(a[0], isp[m - 1]); /* from Q15 to Q12 */
+ a[m] = round_fx(t0);
+
+
+ return;
+}
+
+/*===================================================================*/
+/* FUNCTION : lpc2lsp_fx () */
+/*-------------------------------------------------------------------*/
+/* PURPOSE : Convert LPC coefficients to LSP coefficients */
+/*-------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* */
+/* _ (Word32 []) a : LPC coefficients, Q27 */
+/* _ (Word16 []) old_freq: Previous frame LSP coefficients, Q15 */
+/* _ (Word16 []) order: LPC order */
+/*-------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16 []) freq: LSP coefficients, Q15 */
+/*-------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ None */
+/*-------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ (Word16) flag: 1 means all 10 LSPs are found, 0 otherwise */
+/*===================================================================*/
+Word16 lpc2lsp_fx(
+ Word32* a,
+ Word16* freq,
+ Word16* old_freq,
+ Word16 order
+)
+{
+ Word16 i;
+ Word16 rt, low, high, prev_rt, rc;
+ Word32 p[11], q[11]; /* Q26 */
+ Word32 Ltemp, v_low;
+ Word32 Lacc;
+ Word16 tfreq[21];
+
+ /* First construct the P,Q polynomial */
+ /* p[0] = q[0] = 1 */
+ /* p[i] = -lpcCoeff[i] - lpcCoeff[11-i] - p[i-1] ( 1<=i<=5)*/
+ /* q[i] = -lpcCoeff[i] + lpcCoeff[11-i] + q[i-1] ( 1<=i<=5)*/
+ Ltemp = L_deposit_h( 0x400 ); /* Ltemp is 1.0 in Q26 */
+
+ p[0] = Ltemp;
+ move32();
+ q[0] = Ltemp;
+ move32();
+
+ FOR ( i = 1; i < ( order / 2 ) + 1; i++ )
+ {
+ Lacc = a[order - i];
+ move32();/* Q27 */
+ Lacc = L_sub( Lacc, a[i - 1] ); /* Lacc=-lpcCoeff[i-1] + lpcCoeff[order-i]//Q27 */
+ q[i] = L_add( L_shr( Lacc, 1 ), q[i - 1] );
+ move32();/* Q26 */
+
+ Lacc = L_add( Lacc, L_shl( a[i - 1], 1 ) );/* Lacc=lpcCoeff[i-1] + lpcCoeff[order-i]//Q27 */
+
+ p[i] = L_sub( L_negate( L_shr( Lacc, 1 ) ), p[i - 1] );
+ move32();/* Q26 */
+ }
+
+ /* Search roots of the P and Q polynomials */
+
+ v_low = polynomial_eval_fx( 0, p, order ); /* Q25 */
+ move16();
+ move16();
+ move16();
+ move16();
+ move16();
+ move16();
+ low = 0;
+ high = 8;
+ prev_rt = 0;
+ rc = 0; /* root counter */
+ FOR ( i = 0; i < 32; i++ )
+ {
+ rt = root_search_fx( low, high, &v_low, p, order );
+ low = high;
+ move16();
+ high = add( high, 8 );
+
+ IF( GE_16( rt, prev_rt ))
+ {
+ tfreq[rc] = rt;
+ move16();
+ rc = add( rc, 2 );
+ }
+ prev_rt = add( rt, 6 );
+ } /* End for P roots */
+
+ tfreq[rc] = 0x3f80;
+ move16(); /* Set a high enough value as fake root for Q search */
+
+ IF ( LT_16( rc, order ))
+ {
+ /* lost P root */
+ /* copy from previous LSP and return */
+ FOR ( i = 0; i < order; i++ )
+ {
+ move16();
+ freq[i] = old_freq[i];
+ }
+ return ( 0 );
+ }
+ ELSE
+ {
+ /* Search for Q roots between P roots */
+ v_low = L_deposit_h( 0x800 ); /* Init a positive value for v_low */
+ rc = 1;
+ move16();
+ FOR ( i = 0; i < order / 2; i++ )
+ {
+ low = shr( tfreq[rc - 1], 6 );
+ high = add( shr( tfreq[rc + 1], 6 ), 1 );
+ rt = root_search_fx( low, high, &v_low, q, order );
+
+ IF ( rt < 0 )
+ {
+ /* No Q root in this interval */
+ /* copy from previous LSP and return */
+ FOR ( i = 0; i < order; i++ )
+ {
+ move16();
+ freq[i] = old_freq[i];
+ }
+ return ( 0 );
+ }
+ ELSE
+ {
+ move16();
+ tfreq[rc] = rt;
+ rc = add( rc, 2 );
+ } /* end else, find Q root */
+ } /* end for */
+ } /* end else */
+
+ FOR ( i = 0; i < order; i++ )
+ {
+ freq[i] = tfreq[i];
+ move16();
+ }
+
+ return ( 1 );
+}
+
+/*===================================================================*/
+/* FUNCTION : lsp2lpc_fx () */
+/*-------------------------------------------------------------------*/
+/* PURPOSE : Convert LSP coefficients to LPC coefficients */
+/*-------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* */
+/* _ (Word16 []) freq: LSP coefficients, Q15 */
+/* _ (Word16 []) prev_a : previous frame LPC coefficients, Q12 */
+/* _ (Word16 []) order : LPC order */
+/*-------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16 []) a : LPC coefficients, Q12 */
+/*-------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ None */
+/*-------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*===================================================================*/
+void lsp2lpc_fx(
+ Word16 *a,
+ Word16 *freq,
+ Word16 *prev_a,
+ Word16 order
+)
+{
+ Word16 i;
+ Word32 pq[ LPC_SHB_ORDER ] ;
+ Word32 p[ LPC_SHB_ORDER ], q[ LPC_SHB_ORDER ];
+ Word32 Ltemp;
+ Word32 Lacc;
+ Word16 tmp_pci[M+1];
+ Word16 giOverflow;
+
+
+ FOR ( i = 0; i < order; i++ )
+ {
+ tmp_pci[i]=prev_a[i];
+ move16();
+ }
+
+ compute_poly_product_fx( freq, pq, order );
+ /*This change is to get funtionality if L_sub_sat*/
+ giOverflow = 0 ;
+ move16(); /* clear overflow flag */
+ Overflow = 0;
+ move16();
+ FOR ( i=0; i < order/2; i++ )
+ {
+ Ltemp = L_add( pq[ i ], pq[ i + 1 ] );
+ giOverflow = ( Word16 )Overflow;
+ move16();
+ IF ( EQ_16(giOverflow,1))
+ {
+ BREAK;
+ }
+
+ p[ i ] = Ltemp ;
+ move32();
+ }
+
+ IF ( EQ_16(giOverflow,1))
+ {
+ FOR (i=0; i < order; i++ )
+ {
+ a[i] = mult_r( prev_a[i], pwAlpha[i] );
+ move16();
+ }
+ return;
+ }
+
+ compute_poly_product_fx( freq+1, pq, order );
+
+
+ giOverflow = 0;
+ move16();
+ Overflow = 0;
+ move16();
+
+ FOR ( i=0; i < order/2; i++ )
+ {
+ Ltemp = L_sub( pq[ i+1 ], pq[i] );
+ giOverflow = ( Word16 ) Overflow;
+ move16();
+ IF ( EQ_16(giOverflow,1))
+ {
+ BREAK;
+ }
+
+ q[i] = Ltemp;
+ move32();
+ }
+
+ IF ( EQ_16(giOverflow,1))
+ {
+ FOR (i = 0; i < order; i++ )
+ {
+ a[i] = mult_r( prev_a[i], pwAlpha[i] );
+ move16();
+ }
+ }
+ ELSE
+ {
+ FOR (i = 0; i < order/2; i++ )
+ {
+ Overflow = 0;
+ move16();
+ Lacc = L_add( p[i], q[i] ); /* p[i], q[i] in Q24 */
+ if ( Overflow )
+ {
+ giOverflow = 1;
+ move16();
+ }
+
+ Lacc = L_negate( Lacc ); /* Lacc=-(p[i]-q[i])/2 in Q25 */
+ Overflow = 0;
+ move16();
+ Lacc = L_add( L_shl( Lacc, 3 ), 0x08000 ); /* rounding */
+ if ( Overflow )
+ {
+ giOverflow = 1;
+ move16();
+ }
+
+ a[i] = extract_h( Lacc ); /* a[i] in Q12 */
+
+ IF ( EQ_16(giOverflow,1))
+ {
+ BREAK;
+ }
+
+ }
+ FOR ( i=0; i < order/2; i++ )
+ {
+ Overflow = 0;
+ move16();
+ Lacc = L_sub( q[i], p[i] ); /* p[i], q[i] in Q24 */
+ if( Overflow )
+ {
+ giOverflow = 1;
+ move16();
+ }
+ Overflow = 0;
+ move16();
+ Lacc = L_add( L_shl( Lacc, 3 ), 0x08000); /* rounding */
+ if ( Overflow )
+ {
+ giOverflow = 1;
+ move16();
+ }
+
+ a[ order-1-i ] = extract_h( Lacc );
+
+
+ IF ( EQ_16(giOverflow,1))
+ {
+ BREAK;
+ }
+
+ }
+ }
+
+
+ IF ( EQ_16(giOverflow,1))
+ {
+ FOR ( i = 0; i < order; i++ )
+ {
+ a[i] = mult_r( tmp_pci[i], pwAlpha[i] );
+ move16();
+ }
+ }
+
+}
+
+/*
+ * E_LPC_f_lsp_pol_get
+ *
+ * Parameters:
+ * lsp/isp I: Line spectral pairs (cosine domaine) Q15
+ * f O: the coefficients of F1 or F2 Q23
+ * n I: no of coefficients (m/2)
+ * == NC for F1(z); == NC-1 for F2(z)
+ * fact I: scaling factor
+ *
+ *-----------------------------------------------------------*
+ * procedure E_LPC_f_lsp_pol_get: *
+ * ~~~~~~~~~~~ *
+ * Find the polynomial F1(z) or F2(z) from the LSPs. *
+ * This is performed by expanding the product polynomials: *
+ * *
+ * F1(z) = product ( 1 - 2 LSF_i z^-1 + z^-2 ) *
+ * i=0,2,4,6,8 *
+ * F2(z) = product ( 1 - 2 LSF_i z^-1 + z^-2 ) *
+ * i=1,3,5,7,9 *
+ * *
+ * where LSP_i are the LSPs in the cosine domain. *
+ * *
+ *-----------------------------------------------------------*
+ * R.A.Salami October 1990 *
+ *-----------------------------------------------------------*
+ */
+Word16 E_LPC_f_lsp_pol_get(const Word16 lsp[], Word32 f[], const Word16 n, const Word16 past_Ovf, const Word16 isMODE1)
+{
+ /* All computation in Q23 */
+ const Word16 *plsp;
+ Word16 i, j;
+ Word16 b;
+ Word32 b32;
+ Word16 Ovf = 0;
+ Word16 Q_out;
+ Word16 m2;
+
+
+ Q_out = 31-23;
+ move16();
+ Ovf = past_Ovf;
+ move16();
+
+ test();
+ if(past_Ovf && isMODE1) /* Currently this feature is implemented only in MODE1 */
+ {
+ /* In some NB cases, overflow where detectected
+ in f1 or f2 polynomial computation when it
+ happen we reduce the precision of the computing
+ to limit the risk of saturation*/
+ Q_out = add(Q_out, past_Ovf);
+ }
+ Overflow = 0;
+ move16();
+ plsp = lsp;
+ f[0] = L_shl(1, sub(31, Q_out));
+ move32();
+ /*b = -2.0f * *plsp;*/
+ b = *plsp;
+ move16();
+ m2 = shl(-2, sub(15, Q_out));
+ f[1] = L_mult(b, m2);
+ move32();
+
+ FOR (i = 2; i <= n; i++)
+ {
+ plsp += 2;
+ /*b = 2.0f * *plsp;*/
+ move16();
+ b = *plsp;
+ b32 = L_mult(b, m2);
+
+ /*f[i] = -b*f[i-1] + 2.0f*f[i-2];*/
+ move32();
+ f[i] = L_shl(L_sub(f[i-2], Mpy_32_16_1(f[i-1], b)),1);
+
+ FOR (j = i-1; j > 1; j--)
+ {
+ /*f[j] += b*f[j-1] + f[j-2];*/
+ move32();
+ f[j] = L_add(f[j], L_sub(f[j-2], L_shl(Mpy_32_16_1(f[j-1], b),1)));
+ }
+ move32();
+ f[1] = L_add(f[1], b32);
+ }
+
+
+ test();
+ IF (Overflow>0 && isMODE1)
+ {
+ /* If an overflow is detected, redo the computation with 1 bit less */
+ Ovf = add(Ovf,1);
+ Ovf = E_LPC_f_lsp_pol_get(lsp, f, n ,Ovf, isMODE1);
+ }
+ return Ovf;
+}
+
+void E_LPC_a_lsp_conversion(
+ const Word16 *a, /* input : LP filter coefficients (Qx) */
+ Word16 *lsp, /* output: Line spectral pairs (in the cosine domain)(0Q15) */
+ const Word16 *old_lsp, /* input : LSP vector from past frame (0Q15) */
+ const Word16 m /* input : length of the LP filter coefficients */
+)
+{
+ Word16 i, nf, ip, nc;
+ Word16 xlow, ylow, xhigh, yhigh;
+ Word16 x, y, tmp, exp;
+ Word32 f[2][NC_MAX+1];
+ Word32 t0, t1;
+ Word32 sum, diff;
+ Word16 scale;
+
+
+
+ nc = shr(m, 1);
+
+ scale = shl( 128, norm_s(a[0]) );
+
+ /*-------------------------------------------------------------*
+ * find the sum and diff polynomials F1(z) and F2(z) *
+ * F1(z) = [A(z) + z^11 A(z^-1)]/(1+z^-1) *
+ * F2(z) = [A(z) - z^11 A(z^-1)]/(1-z^-1) *
+ *-------------------------------------------------------------*/
+
+ f[0][0] = L_mult(a[0],scale); /*1.0f in Q23*/ move32();
+ f[1][0] = L_mult(a[0],scale); /*1.0f in Q23*/ move32();
+ FOR (i = 1; i < nc; i++)
+ {
+ t0 = L_mult(a[i],scale); /*Q23*/
+ sum = L_mac(t0, a[m+1-i],scale);
+ diff = L_msu(t0, a[m+1-i],scale);
+ f[0][i] = L_sub(sum,f[0][i-1]);
+ move32(); /*Q23*/
+ f[1][i] = L_add(diff,f[1][i-1]);
+ move32(); /*Q23*/
+ }
+ t1 = L_mult0(a[i],scale); /*Q23-1*/
+ sum = L_mac0(t1, a[m+1-i],scale);
+ diff = L_msu0(t1, a[m+1-i],scale);
+ f[0][nc] = L_sub(sum, L_shr(f[0][i-1],1));
+ move32(); /*Q23-1*/
+ f[1][nc] = L_add(diff,L_shr(f[1][i-1],1));
+ move32(); /*Q23-1*/
+
+ /* Precalculate difference to index 0 for index 2 */
+ f[0][2] = L_sub(f[0][2], f[0][0]);
+ move32();
+ f[1][2] = L_sub(f[1][2], f[1][0]);
+ move32();
+
+ /*---------------------------------------------------------------------*
+ * Find the LSPs (roots of F1(z) and F2(z) ) using the *
+ * Chebyshev polynomial evaluation. *
+ * The roots of F1(z) and F2(z) are alternatively searched. *
+ * We start by finding the first root of F1(z) then we switch *
+ * to F2(z) then back to F1(z) and so on until all roots are found. *
+ * *
+ * - Evaluate Chebyshev pol. at grid points and check for sign change.*
+ * - If sign change track the root by subdividing the interval *
+ * 4 times and ckecking sign change. *
+ *---------------------------------------------------------------------*/
+ nf = 0;
+ move16(); /* number of found frequencies */
+ ip = 0;
+ move16(); /* indicator for f1 or f2 */
+
+ xlow = Grid[0];
+ move16();
+ ylow = chebyshev(xlow, f[ip], nc, 8);
+
+ FOR (i = 1; i <= GRID100_POINTS; i++)
+ {
+ xhigh = xlow;
+ move16();
+ yhigh = ylow;
+ move16();
+ xlow = Grid[i];
+ move16();
+ ylow = chebyshev(xlow, f[ip], nc, 8);
+
+ IF (L_mult(ylow, yhigh) <= 0)
+ {
+ t0 = L_mult(xhigh, 0x4000);
+ /* divide 2 times the interval */
+ x = mac_r(t0, xlow, 0x4000); /* xmid = (xlow + xhigh)/2 */
+ y = chebyshev(x, f[ip], nc, 8);
+
+ IF (L_mult(ylow, y) <= 0)
+ {
+ yhigh = y;
+ move16();
+ xhigh = x;
+ move16();
+ y = ylow;
+ move16();
+ x = xlow;
+ move16();
+ /* 'xhigh' has changed, update 't0' */
+ t0 = L_mult(xhigh, 0x4000);
+ }
+ xlow = mac_r(t0, x, 0x4000); /* xmid = (xlow + xhigh)/2 */
+ ylow = chebyshev(xlow, f[ip], nc, 8);
+
+ IF (L_mult(y, ylow) <= 0)
+ {
+ yhigh = ylow;
+ move16();
+ xhigh = xlow;
+ move16();
+ ylow = y;
+ move16();
+ xlow = x;
+ move16();
+ }
+
+ /*--------------------------------------------------------*
+ * Linear interpolation
+ * xint = xlow - ylow*(xhigh-xlow)/(yhigh-ylow)
+ *--------------------------------------------------------*/
+ y = msu_r(L_mult(yhigh,0x4000), ylow,0x4000);
+
+ IF (y != 0)
+ {
+ x = sub(xhigh, xlow);
+ BASOP_SATURATE_WARNING_OFF
+ tmp = abs_s(y);
+ BASOP_SATURATE_WARNING_ON
+ exp = norm_s(tmp);
+ if (exp)
+ tmp = shl(tmp, exp);
+ tmp = div_s((Word16) 16383/2, tmp);
+ t0 = L_mult(x, tmp);
+ t0 = L_shr(t0, sub(20, exp));
+ tmp = extract_l(t0); /* y = (xhigh-xlow)/(yhigh-ylow) in Q11 */
+
+ /* Restore Sign */
+ if (y < 0)
+ tmp = negate(tmp);
+
+ t0 = L_mult(ylow, tmp); /* result in Q26 */
+ t0 = L_shr(t0, 11); /* result in Q15 */
+ xlow = sub(xlow, extract_l(t0));/* xint = xlow - ylow*y */
+ }
+ lsp[nf++] = xlow;
+ move16();
+
+ IF (GE_16(nf,m))
+ {
+ BREAK;
+ }
+
+ ip = s_xor(ip, 1);
+ ylow = chebyshev(xlow, f[ip], nc, 8);
+ }
+ }
+
+ /* Check if m roots found */
+ /* if not use the LSPs from previous frame */
+
+ IF (LT_16(nf,m))
+ {
+ FOR(i=0; i= 0; i--) /* Reverify the minimum LSF gap in the reverse direction */
+ {
+ if (GT_16(lsf[i], lsf_max))
+ {
+ lsf[i] = lsf_max;
+ move16();
+ }
+ lsf_max = sub(lsf[i], min_dist);
+ }
+ }
+}
+
+void space_lsfs_fx (
+ Word16* lsfs, /* i/o: Line spectral frequencies */
+ const Word16 order /* i : order of LP analysis */
+)
+{
+ Word16 delta; /* Q1.15 */
+ Word16 i, flag=1;
+
+ WHILE ( flag == 1 )
+ {
+ flag = 0;
+ move16();
+ FOR ( i = 0; i <= order; i++ )
+ {
+ IF( i == 0 )
+ {
+ delta = lsfs[0];
+ move16();
+ }
+ ELSE
+ {
+ IF( EQ_16(i,order))
+ {
+ delta = sub( HALF_POINT_FX, lsfs[i-1] );
+ move16();
+ }
+ ELSE
+ {
+ delta = sub( lsfs[i], lsfs[i-1] );
+ move16();
+ }
+ }
+ IF ( LT_16( delta, SPC_FX ))
+ {
+ flag = 1;
+ move16();
+ delta = sub( delta, SPC_PLUS_FX );
+
+ IF ( i == order )
+ {
+ lsfs[i - 1] = add( lsfs[i - 1], delta );
+ move16();
+ }
+ ELSE
+ {
+ IF ( i == 0 )
+ {
+ lsfs[i] = sub( lsfs[i], delta );
+ move16();
+ }
+ ELSE
+ {
+ delta = mult_r( delta, HALF_POINT_FX );
+ lsfs[i - 1] = add( lsfs[i - 1], delta );
+ move16();
+ lsfs[i] = sub( lsfs[i], delta );
+ move16();
+ }
+ }
+ }
+ }
+ }
+
+ return;
+}
+
+/*=================================================================== */
+/* FUNCTION : lsp_weights_fx () */
+/*------------------------------------------------------------------- */
+/* PURPOSE : This function computes the weights for the */
+/* given unquantized lsp vector */
+/*------------------------------------------------------------------- */
+/* INPUT ARGUMENTS :
+_ (Word16 []) lsp_nq_fx: input unquantized lsp vector */
+/* _(Word16 Order) FilterOrder */
+/*------------------------------------------------------------------- */
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16 []) w: weight vector Q(9-n_max) */
+
+/*------------------------------------------------------------------- */
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ None. */
+/*------------------------------------------------------------------- */
+/* RETURN ARGUMENTS : */
+/* _ None. */
+/*=================================================================== */
+
+void lsp_weights_fx(
+ Word16 lsp_nq_fx[],
+ Word16 w[],
+ Word16 Order,
+ Word16* Qout
+)
+{
+ Word16 lpcOrder =Order;
+
+ Word16 i, n1, tmp_loop;
+ Word16 norm[20];
+ Word32 Lsum1[20];
+ Word16 delta1, delta2, temp;
+ Word16 n_max =-32768;
+ move16();
+
+ temp = 0;
+ move16();
+
+ tmp_loop = sub( lpcOrder, 1 );
+ FOR ( i = 0; i < tmp_loop; i++ )
+ {
+ delta1 = sub( lsp_nq_fx[i], temp );
+ delta2 = sub( lsp_nq_fx[i + 1], lsp_nq_fx[i] );
+ Lsum1[i] = calc_weight( delta1, delta2, &n1 );
+ move32();/* Q( 26-n1) */
+ norm[i] = n1;
+ move16();
+
+ if (GT_16(norm[i],n_max))
+ {
+ n_max = norm[i];
+ move16();
+ }
+ temp = lsp_nq_fx[i];
+ move16();
+ }
+ delta1 = sub( lsp_nq_fx[i], temp );
+ delta2 = sub( 16384, lsp_nq_fx[i] );
+
+ Lsum1[i] = calc_weight( delta1, delta2, &n1 );
+ move32(); /* Q( 26-n1) */
+ norm[i] = n1;
+ move16();
+
+ if ( GT_16(norm[i], n_max))
+ {
+ n_max = norm[i];
+ move16();
+ }
+ FOR ( i = 0; i < lpcOrder; i++ )
+ {
+ w[i] = round_fx( L_shl( Lsum1[i], sub( norm[i], n_max + 1 ) ) ); /* Q( 9-n_max) */
+ }
+
+ IF ( lpcOrder != LPC_SHB_ORDER_WB )
+ {
+ w[3] = round_fx( L_shl( L_mult( w[3], 18022 ), 1 ) ); /* Q( 9-n_max) */
+ w[4] = round_fx( L_shl( L_mult( w[4], 18022 ), 1 ) ); /* Q( 9-n_max) */
+ }
+
+ *Qout = 9 - n_max;
+ move16();
+}
+
+/*
+ * E_LPC_isf_isp_conversion
+ *
+ * Parameters:
+ * isf I: isf[m] normalized (range: 0 <= val <= 0.5) 14Q1*1.28
+ * isp O: isp[m] (range: -1 <= val < 1) Q15
+ * m I: LPC order
+ *
+ * Function:
+ * Transformation isf to isp
+ *
+ * ISF are immitance spectral pair in frequency domain (0 to 6400).
+ * ISP are immitance spectral pair in cosine domain (-1 to 1).
+ *
+ * Returns:
+ * void
+ */
+void E_LPC_isf_isp_conversion(const Word16 isf[], Word16 isp[], const Word16 m)
+{
+ Word16 i;
+
+ assert( m==16 || m==10 );
+
+
+ FOR (i = 1; i < m; i++)
+ {
+ *isp++ = xsf_to_xsp(*isf++);
+ move16();
+ }
+ *isp = xsf_to_xsp(shl(*isf, 1));
+ move16();
+
+
+ return;
+}
+
+/*
+ * E_LPC_isp_isf_conversion
+ *
+ * Parameters:
+ * isp I: isp[m] (range: -1 <= val < 1) Q15
+ * isf O: isf[m] normalized (range: 0 <= val <= 6400) x1.28
+ * m I: LPC order
+ *
+ * Function:
+ * Transformation isp to isf
+ *
+ * ISP are immitance spectral pair in cosine domain (-1 to 1).
+ * ISF are immitance spectral pair in frequency domain (0 to 6400).
+ *
+ * Returns:
+ * energy of prediction error
+ */
+void E_LPC_isp_isf_conversion(const Word16 isp[], Word16 isf[], const Word16 m)
+{
+ Word16 i;
+
+ assert( m==16 || m==10 );
+
+
+
+ FOR (i = 0; i < m; i++)
+ {
+ isf[i] = xsp_to_xsf(isp[i]);
+ move16();
+ }
+
+ isf[m - 1] = shr(isf[m - 1], 1);
+ move16();
+
+
+ return;
+}
+
+
+Word16 xsf_to_xsp(Word16 lsf)
+{
+ /* lsp = cos(lsf * 3.1415/6400); */
+ return getCosWord16R2(lsf);
+}
+
+Word16 xsp_to_xsf(Word16 lsp)
+{
+ Word16 ind, tmp;
+ Word32 L_tmp;
+
+
+ /*------------------------------------------------------*
+ * find value in table that is just greater than lsp
+ *------------------------------------------------------*/
+
+ /* Retrieve Index Guess */
+ /* Based on lsp */
+ ind = mac_r(GUESS_TBL_SZ/2*65536-0x8000, lsp, GUESS_TBL_SZ/2);
+ ind = Ind_Guess[ind];
+ move16();
+
+ /* Correct Index so that */
+ /* cos_table_129[ind] > isp[i] */
+ tmp = sub(lsp, cos_table_129[ind]);
+ /*
+ 69%: (Final Index - Index Guess) is <= 1
+ 28%: (Final Index - Index Guess) is 2
+ 2%: (Final Index - Index Guess) is >= 3
+ <1%: ...
+ */
+ IF (tmp > 0) /* possible range 0 to -5 (-1-2-2) */
+ {
+ ind = sub(ind, 1);
+ tmp = sub(lsp, cos_table_129[ind]);
+
+ IF (tmp > 0)
+ {
+ ind = sub(ind, 2);
+ tmp = sub(lsp, cos_table_129[ind]);
+ if (tmp > 0)
+ {
+ ind = sub(ind, 2);
+ }
+ tmp = sub(lsp, cos_table_129[ind+1]);
+ if (tmp <= 0)
+ {
+ ind = add(ind, 1);
+ }
+ tmp = sub(lsp, cos_table_129[ind]);
+ }
+ }
+
+ /* acos(lsp)= ind*128 + (lsp-cos_table_129[ind]) * acos_slope[ind] / 2048 */
+ L_tmp = L_mac(1L<<11, tmp, acos_slope[ind]);
+ L_tmp = L_shr(L_tmp, 12); /* (lsp-cos_table_129[ind]) * acos_slope[ind]) >> 11 */
+ L_tmp = L_mac0(L_tmp, ind, 128);
+
+
+ return extract_l(L_tmp);
+}
+
+/*-------------------------------------------------------------------*
+ * a2rc()
+ *
+ * Convert from LPC to reflection coeff
+ *-------------------------------------------------------------------*/
+
+void a2rc_fx( const Word16* a, /* i: can be any Q */
+ Word16* refl, /* o: Q15 */
+ Word16 lpcorder
+ )
+
+{
+ Word16 f_fx[M];
+ Word16 km_fx;
+ Word32 L_tmp1, L_tmp2;
+ Word16 tmp;
+ Word16 denom_mant, exp;
+ Word32 new_mant;
+ Word16 temp;
+ Word16 m, j, n;
+ Word16 q, q_a, q_a2, One_Qx;
+ Word32 One_Qx2;
+ q = add( norm_s(a[-1]), 1 );
+ q_a = sub(15, q);
+ q_a2 = add(shl(q_a,1),1);
+ /* copy into internal vars so they can be changed */
+
+ FOR ( m = 0; m < lpcorder; m++ )
+ {
+ /* f_fx[m] = p_fx[m]; */
+ f_fx[m] = negate(a[m]);
+ move16();
+ }
+ One_Qx = shl(1,q_a);
+ One_Qx2 = L_shl(1, q_a2);
+ FOR ( m = lpcorder - 1; m >= 0; m-- )
+ {
+ km_fx = f_fx[m];
+ move16();
+
+ test();
+ IF ( LE_16( km_fx, negate(One_Qx))||GE_16(km_fx,One_Qx))
+ {
+ FOR ( j = 0; j < lpcorder; j++ )
+ {
+ refl[j] = 0;
+ move16();
+ }
+
+ return;
+ }
+
+ refl[m] = negate( km_fx );
+ move16();
+ L_tmp1 = One_Qx2; /* 1 in 2xq_a+1 */
+ move32();
+ L_tmp1 = L_msu( L_tmp1, km_fx, km_fx ); /* 1-km*km in Q25 */
+
+ /* new_mant = invert_dp(L_tmp1,4, &tmp_denom_exp,1); sum in Q61-Q25-n=Q36-n */
+ exp = norm_l( L_tmp1 );
+ tmp = extract_h( L_shl( L_tmp1, exp ) );
+ exp = sub( sub( 30, exp ), q_a2 );
+ IF ( tmp )
+ {
+ tmp = div_s( 16384, tmp ); /* 15+exp */
+ }
+ ELSE
+ {
+ tmp = 0;
+ }
+ new_mant = L_deposit_h( tmp );
+ temp = round_fx( L_shl( new_mant, 0 ) ); /* in Q14 */
+ denom_mant = temp;
+ move16();
+ L_tmp1 = L_mult( km_fx, denom_mant ); /* km*denom. Q12*Q14 = Q27 */
+ L_tmp1 = L_shl( L_tmp1, q ); /* change to Q31. simulation showed no overflow */
+ tmp = round_fx( L_tmp1 ); /* extract in Q15 */
+
+ FOR ( j = 0; j < m / 2; j++ )
+ {
+ n = sub( sub( m, ( Word16 )1 ), j );
+ L_tmp1 = L_mult( denom_mant, f_fx[j] ); /* denom*f[j]. Q15*Q12 = Q28 (floating with exp) */
+ L_tmp1 = L_mac( L_tmp1, tmp, f_fx[n] ); /* denom*f[j]+km*denom*f[n] in Q28 (floating with exp) */
+ L_tmp2 = L_mult( denom_mant,f_fx[n] ); /* denom*f[n]. Q15*Q12 = Q28 (floating with exp) */
+ L_tmp2 = L_mac( L_tmp2, tmp,f_fx[j] ); /* denom*f[n]+km*denom*f[j] in Q28 (floating with exp) */
+ L_tmp1 = L_shr( L_tmp1, exp ); /* bringing to true Q28 */
+ L_tmp2 = L_shr( L_tmp2, exp ); /* bringing to true Q28 */
+ f_fx[j] = round_fx( L_tmp1 ); /* extracting in q_a */
+ f_fx[n] = round_fx( L_tmp2 ); /* extracting in q_a */
+ }
+
+ IF ( m & 1 )
+ {
+ L_tmp1 = L_mult( denom_mant, f_fx[ j] ); /* denom*f[j]. Q15*Q12 = Q28 (floating with exp) */
+ L_tmp1 = L_mac( L_tmp1, tmp,f_fx[j] ); /* denom*f[j]+km*denom*f[j] in Q28 (floating with exp) */
+ L_tmp1 = L_shr( L_tmp1, exp ); /* bringing to true Q28 */
+ f_fx[j] = round_fx( L_tmp1 ); /* extracting in q_a */
+ }
+ }
+
+ FOR ( j = 0; j < lpcorder; j++ )
+ {
+ refl[j] = shl( refl[j], q );
+ move16();
+ }
+
+
+ return;
+}
+Word16 vq_dec_lvq_fx (
+ Word16 sf_flag, /* i : safety net flag */
+ Word16 x[], /* o : Decoded vector Q(x2.56)*/
+ Word16 indices[], /* i : Indices */
+ Word16 stages, /* i : Number of stages */
+ Word16 N, /* i : Vector dimension */
+ Word16 mode, /* (i): mode_lvq, or mode_lvq_p */
+ Word16 no_bits, /* (i): no. bits for lattice */
+ Word32 *p_offset_scale1,
+ Word32 *p_offset_scale2,
+ Word32 *p_offset_scale1_p,
+ Word32 *p_offset_scale2_p,
+ Word16 *p_no_scales,
+ Word16 *p_no_scales_p
+)
+{
+ Word16 x_lvq[M];
+ Word16 i, stagesm1;
+ Word16 pt_fx;
+ Word16 ber_flag;
+
+ /* clear vector */
+ set16_fx(x, 0, N);
+
+ /*-----------------------------------------------*
+ * add contribution of each stage
+ *-----------------------------------------------*/
+ stagesm1 = sub(stages,1);
+ IF (EQ_16(sf_flag,1))
+ {
+ FOR(i=0; i0)
+ {
+ n_stages = 2;
+ move16();
+ levels0[0] = CBsizes_fx[nbits0];
+ move16();
+ bits0[0] = nbits0;
+ move16();
+ bits0[1] = sub(cumleft,nbits0);
+
+ IF ( bits0[1] == 0 )
+ {
+ n_stages = sub(n_stages,1);
+ }
+ ELSE
+ {
+ levels0[1] = CBsizes_fx[sub(cumleft,nbits0)];
+ move16();
+ }
+ }
+ ELSE /* no bits for VQ stage */
+ {
+ n_stages = 0;
+ move16();
+ }
+
+ *stages0 = n_stages;
+ move16();
+ IF (bits_lvq > 0)
+ {
+ bits0[n_stages] = bits_lvq;
+ move16();
+ levels0[n_stages] = bits_lvq;
+ move16();/* this is number of bits, not levels */
+ *stages0 = add(n_stages,1);
+ move16();
+ }
+ }
+ ELSE
+ {
+ *stages0 = 0;
+ move16();
+ }
+
+ /*---------------------------------------------------*
+ * Calculate bit allocation for predictive quantizer
+ *---------------------------------------------------*/
+ IF ( GT_16(framemode_p, -1))
+ {
+ cumleft = BitsVQ_p_fx[framemode_p];
+ move16();
+ bits_lvq = sub(nBits, cumleft);
+ nbits0 = CBbits_p_fx[framemode_p];
+ move16();
+
+ IF (GT_16(nbits0,-1))
+ {
+ IF ( nbits0 > 0 )
+ {
+ IF ( EQ_16(framemode_p, 7))
+ {
+ /* for UNVOICED_WB only */
+ n_stages = 3;
+ move16();
+ FOR( i=0; i0)
+ {
+ levels1[1] = CBsizes_fx[nbits0];
+ move16();
+ bits1[1] = nbits0;
+ move16();
+ n_stages = 2;
+ move16();
+ }
+
+ levels1[n_stages] = bits_lvq;
+ move16();/* this is number of bits, not levels */
+ bits1[n_stages] = bits_lvq;
+ move16();
+ *stages1 = add(n_stages ,1);
+ }
+ }
+ ELSE
+ {
+ *stages1 = 1;
+ move16();
+ bits1[0] = bits_lvq;
+ move16();
+ levels1[0] = bits_lvq;
+ move16();
+ }
+ }
+ ELSE
+ {
+ }
+ }
+
+ return;
+}
+
+Word16 find_pred_mode(
+ const Word16 coder_type, /* i: coding type */
+ const Word16 bwidth, /* i: bandwidth index */
+ const Word32 int_fs, /* i: sampling frequency */
+ Word16 * p_mode_lvq, /* o: index of LSF codebooks in safety net mode */
+ Word16 * p_mode_lvq_p, /* o: index of LSF codebooks in predictive mode (AR or MA) */
+ Word32 core_brate) /* i: core bit rate */
+{
+ Word16 idx, predmode;
+
+ /* bwidth = 0(NB), 1 (WB), 2(WB2); line index in predmode_tab[][] */
+ idx = bwidth;
+ move16();
+ if (GT_16(idx, 1))
+ {
+ idx = 1;
+ }
+ IF (EQ_32(int_fs, INT_FS_16k))
+ {
+ /* WB2 is actually used if sampling frequency is 16kHz */
+ idx = 2;
+ move16();
+ }
+ ELSE
+ {
+ test();
+ test();
+ if ((GE_32(core_brate, GENERIC_MA_LIMIT))&&(EQ_16(coder_type,GENERIC))&&(EQ_16(idx,1)))
+ {
+ idx = 3;
+ move16();
+ }
+ }
+ predmode = predmode_tab[idx][coder_type];
+ move16();
+ IF (LE_16(idx, 2))
+ {
+ *p_mode_lvq = add(i_mult2(NO_CODING_MODES, idx), coder_type);
+ IF (predmode>0)
+ {
+ *p_mode_lvq_p = *p_mode_lvq;
+ move16();
+ }
+ ELSE
+ {
+ *p_mode_lvq_p = -1;
+ move16();
+ }
+ }
+ ELSE /* WB 12.8 with MA pred in GENERIC*/
+ {
+ *p_mode_lvq = add(NO_CODING_MODES, coder_type);
+ IF (EQ_16(coder_type, GENERIC))
+ {
+ *p_mode_lvq_p = 18;
+ move16();
+ }
+ ELSE
+ {
+ IF (predmode>0)
+ {
+ *p_mode_lvq_p = *p_mode_lvq;
+ }
+ ELSE
+ {
+ *p_mode_lvq_p = -1;
+ }
+ }
+ }
+
+
+
+ return predmode;
+}
+
+/*---------------------------------------------------------------------------*
+ * reorder_isf
+ *
+ * To make sure that the isfs are properly ordered and to keep a certain
+ * minimum distance between consecutive isfs.
+ *--------------------------------------------------------------------------*/
+void reorder_isf_fx(
+ Word16 *isf, /* i/o: ISFs in the frequency domain (0..0.5) */
+ const Word16 min_dist, /* i : minimum required distance */
+ const Word16 n, /* i : LPC order */
+ const Word16 fs /* i : sampling frequency */
+)
+{
+ Word16 i, isf_min;
+ Word16 isf_max;
+
+ isf_min = min_dist;
+ move16();
+
+ /*-----------------------------------------------------------------------*
+ * Verify the ISF ordering and minimum GAP
+ *-----------------------------------------------------------------------*/
+
+ FOR (i = 0; i < n - 1; i++)
+ {
+ if (LT_16(isf[i], isf_min))
+ {
+ isf[i] = isf_min;
+ move16();
+ }
+ isf_min = add(isf[i], min_dist);
+ }
+
+ /*-----------------------------------------------------------------------*
+ * Reverify the ISF ordering and minimum GAP in the reverse order (security)
+ *-----------------------------------------------------------------------*/
+
+ /*isf_max = sub(shr(fs,1), min_dist);*/
+ isf_max = sub(fs, min_dist); /* Fs already divide per 2 */
+
+ IF (GT_16(isf[n-2], isf_max)) /* If danger of unstable filter in case of resonance in HF */
+ {
+ FOR (i = sub(n, 2); i >= 0; i--) /* Reverify the minimum ISF gap in the reverse direction */
+ {
+ if (GT_16(isf[i], isf_max))
+ {
+ isf[i] = isf_max;
+ move16();
+ }
+ isf_max = sub(isf[i], min_dist);
+ }
+ }
+}
+
+/*========================================================================*/
+/* FUNCTION : lsf_stab_fx() */
+/*------------------------------------------------------------------------*/
+/* PURPOSE : Check LSF stability (distance between old LSFs and */
+/* current LSFs) */
+/*------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) Opt_AMR_WB : flag indicating AMR-WB IO mode */
+/* _ (Word16*) lsf : LSPs from past frame Q(x2.56) */
+/* _ (Word16*) lsfold : LSPs from past frame Q(x2.56) */
+/*------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/*------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/*------------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ (Word16) stab_fac_fx : LP filter stability Q15 */
+/*========================================================================*/
+Word16 lsf_stab_fx( /* o : LP filter stability Q15*/
+ const Word16 *lsf, /* i : LSF vector Q(x2.56)*/
+ const Word16 *lsfold, /* i : old LSF vector Q(x2.56)*/
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 L_frame /* i : frame length */
+)
+{
+ Word16 i, m;
+ Word32 L_tmp;
+ Word16 tmp, e;
+
+ /*-------------------------------------------------------------------*
+ * Check stability on lsf: distance between old lsf and current lsf
+ *-------------------------------------------------------------------*/
+ IF ( Opt_AMR_WB )
+ {
+ m = M-1;
+ move16();
+ tmp = sub(lsf[0], lsfold[0]);
+ L_tmp = L_mult(tmp, tmp); /* Q1 */
+ FOR (i = 1; i < m; i++)
+ {
+ tmp = sub(lsf[i], lsfold[i]);
+ L_tmp = L_mac(L_tmp, tmp, tmp); /* Q1 */
+ }
+ }
+ ELSE
+ {
+ m = M;
+ move16();
+ L_tmp = 0;
+ move32();
+ FOR (i = 0; i < m; i++)
+ {
+ tmp = sub(lsf[i], lsfold[i]);
+ L_tmp = L_mac(L_tmp, tmp, tmp); /* Q1 */
+ }
+ }
+
+ e = norm_l(L_tmp);
+ L_tmp = L_shl(L_tmp, e); /*Q(1+e)*/
+
+ IF( L_frame == L_FRAME16k)
+ {
+ /*stab_fac = (float)(1.25f - (tmp/625000.0f));*/
+ L_tmp = Mpy_32_16_1(L_tmp, 16777); /* 30-eQ(1+e)*-21Q36 = 30-21-eQ31-9+e */
+ }
+ ELSE
+ {
+ /* stab_fac = (float)(1.25f - (tmp1/400000.0f*2.56=1024000)) */
+ L_tmp = Mpy_32_16_1(L_tmp, 26214); /* 30-eQ(1+e)*-21Q36 = 30-21-eQ31-9+e */
+ }
+
+ e = sub(30-21-1,e);
+ tmp = round_fx(L_shl(L_tmp, e)); /*Q14*/
+
+ tmp = sub(20480, tmp); /* 1.25 - tmp in Q14 */
+ tmp = shl(tmp, 1); /* Q14 -> Q15 with saturation */
+
+ tmp = s_max(tmp, 0);
+
+ return tmp;
+}
+/*-------------------------------------------------------------------*
+ * lsp2isp()
+ *
+ * Convert LSPs to ISPs via predictor coefficients A[]
+ *-------------------------------------------------------------------*/
+
+void lsp2isp_fx(
+ const Word16 *lsp, /* i : LSP vector */
+ Word16 *isp, /* o : ISP filter coefficients */
+ Word16 *stable_isp, /* i/o: ISP filter coefficients */
+ const Word16 m /* i : order of LP analysis */
+)
+{
+ Word16 a[M+1];
+
+ /* LSP --> A */
+ /*lsp2a_stab( lsp, a, m );*/
+ E_LPC_f_lsp_a_conversion(lsp, a, m );
+
+ /* A --> ISP */
+ /*a2isp( a, isp, stable_isp, grid );*/
+ E_LPC_a_isp_conversion( a, isp, stable_isp, m);
+
+ /* Update to latest stable ISP */
+ Copy( isp, stable_isp, M );
+}
+/*-------------------------------------------------------------------*
+ * isp2lsp()
+ *
+ * Convert ISPs to LSPs via predictor coefficients A[]
+ *-------------------------------------------------------------------*/
+
+void isp2lsp_fx(
+ const Word16 *isp, /* i : LSP vector */
+ Word16 *lsp, /* o : ISP filter coefficients */
+ Word16 *stable_lsp, /* i/o: stable LSP filter coefficients */
+ const Word16 m /* i : order of LP analysis */
+)
+{
+ Word16 a[M+1];
+
+ /* ISP --> A */
+ /*isp2a( isp, a, m );*/
+ E_LPC_f_isp_a_conversion(isp, a, m );
+ /* A --> LSP */
+ /*a2lsp_stab( a, lsp, stable_lsp, grid );*/
+ E_LPC_a_lsp_conversion(a, lsp, stable_lsp, m );
+ /* Update to latest stable LSP */
+ Copy( lsp, stable_lsp, M );
+}
+
+/*-------------------------------------------------------------------*
+ * lsf2isf()
+ *
+ * Convert LSPs to ISPs
+ *-------------------------------------------------------------------*/
+
+void lsf2isf_fx(
+ const Word16 *lsf, /* i : LSF vector */
+ Word16 *isf, /* o : ISF vector */
+ Word16 *stable_isp, /* i/o: stable ISP filter coefficients */
+ const Word16 m /* i : order of LP analysis */
+)
+{
+ Word16 tmp_lsp[M];
+ Word16 tmp_isp[M];
+
+ /* LSF --> LSP */
+ /*lsf2lsp( lsf, tmp_lsp, m, int_fs );*/
+ E_LPC_lsf_lsp_conversion(lsf, tmp_lsp, m);
+
+ /* LSP --> ISP */
+ lsp2isp_fx( tmp_lsp, tmp_isp, stable_isp, m );
+
+ /* ISP --> ISF */
+ /*isp2isf( tmp_isp, isf, m, int_fs );*/
+ E_LPC_isp_isf_conversion(tmp_isp, isf, m);
+
+ return;
+}
+/*-------------------------------------------------------------------*
+ * isf2lsf()
+ *
+ * Convert ISFs to LSFs
+ *-------------------------------------------------------------------*/
+
+void isf2lsf_fx(
+ const Word16 *isf, /* i : ISF vector */
+ Word16 *lsf, /* o : LSF vector */
+ Word16 *stable_lsp /* i/o: stable LSP filter coefficients */
+)
+{
+ Word16 tmp_isp[M];
+ Word16 tmp_lsp[M];
+
+ /* ISF --> ISP */
+ /*isf2isp( isf, tmp_isp, m, int_fs );*/
+ E_LPC_isf_isp_conversion(isf, tmp_isp, M);
+ /* ISP --> LSP */
+ isp2lsp_fx( tmp_isp, tmp_lsp, stable_lsp, M);
+
+ /* LSP --> LSF */
+ /*lsp2lsf( tmp_lsp, lsf, m, int_fs );*/
+ E_LPC_lsp_lsf_conversion(tmp_lsp, lsf, M);
+ return;
+}
+/*==========================================================================*/
+/* FUNCTION : void lsp2lsf_fx () */
+/*--------------------------------------------------------------------------*/
+/* PURPOSE : */
+/* * Transformation of LSPs to LSFs */
+/* * LSP are line spectral pair in cosine domain (-1 to 1). */
+/* * LSF are line spectral frequencies (0 to fs/2). */
+/*--------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* Word16 lsp[] i : lsp[m] (range: -1<=val<1) Q15 */
+/* Word16 m i : LPC order Q0 */
+/*--------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* Word16 lsf[] o : lsf[m] normalized (range: 0.0<=val<=0.5) Q(x2.56)*/
+/*--------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/*--------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*--------------------------------------------------------------------------*/
+/* CALLED FROM : */
+/*==========================================================================*/
+void lsp2lsf_fx(
+ const Word16 lsp[], /* i : lsp[m] (range: -1<=val<1) Q15*/
+ Word16 lsf[], /* o : lsf[m] normalized (range: 0.0<=val<=0.5) Q(x2.56)*/
+ const Word16 m /* i : LPC order Q0*/
+ ,Word32 int_fs
+)
+{
+ Word16 i;
+ Word32 L_tmp;
+
+ FOR (i = 0; i < m; i++)
+ {
+ /*------------------------------------------------------*
+ * find value in table that is just greater than lsp[i]
+ *------------------------------------------------------*/
+
+ /* Retrieve Index Guess */
+ /* Based on lsp[i] */
+ L_tmp = sub_lsp2lsf_fx(lsp[i]);
+ IF(EQ_32(int_fs, INT_FS_16k_FX))
+ {
+ L_tmp = L_shr(L_mult0(extract_l(L_tmp),5),2);
+ }
+ lsf[i] = extract_l(L_tmp);
+ }
+}
+/*===========================================================================*/
+/* FUNCTION : lsf2lsp_fx() */
+/*---------------------------------------------------------------------------*/
+/* PURPOSE : Transformation of LSFs to LSPs */
+/* LSP are line spectral pairs in cosine domain (-1 to 1). */
+/* LSF are line spectral frequencies (0 to fs/2). */
+/*---------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16[]) lsf : lsf[m] normalized (range: 0.0<=val<=0.5) Q(x2.56) */
+/* _ (Word16) m : LPC order */
+/*---------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16*) lsp : lsp[m] (range: -1<=val<1) Q15 */
+/*---------------------------------------------------------------------------*/
+
+/*---------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*===========================================================================*/
+void lsf2lsp_fx(
+ const Word16 lsf[], /* i : lsf[m] normalized (range: 0.0<=val<=0.5) x2.56 */
+ Word16 lsp[], /* o : lsp[m] (range: -1<=val<1) Q15 */
+ const Word16 m /* i : LPC order Q0 */
+ , Word32 int_fs
+)
+{
+ Word16 i, ind, offset;
+ Word32 L_tmp;
+ Word16 c, ind2;
+ Word16 const add_prec = 4;
+ Word16 lsf_tmp;
+
+
+ /* 0.75 = (1<clip_var_fx[0];
+ move16();
+
+ FOR(i=0; imem_AR_fx[i];
+ move16();
+ mem_MA[i] = st_fx->mem_MA_fx[i];
+ move16();
+ lsp_new_bck[i] = lsp_new[i];
+ move16();
+ lsf_new_bck[i] = lsf_new[i];
+ move16();
+ lsp_mid_bck[i] = lsp_mid[i];
+ move16();
+ }
+
+ *mCb1 = st_fx->mCb1_fx;
+ move16();
+ *streaklimit = st_fx->streaklimit_fx;
+ move16();
+ *pstreaklen = st_fx->pstreaklen_fx;
+ move16();
+
+ FOR(i=0; iBin_E_fx[i];
+ move32();
+ }
+
+ FOR(i=0; i<(L_FFT/2); i++)
+ {
+ Bin_E_old[i]=st_fx->Bin_E_old_fx[i];
+ move32();
+ }
+
+ /* back-up memories */
+ FOR(i=0; iLPDmem.mem_syn[i];
+ move16();
+ }
+
+ *mem_w0_bck = st_fx->LPDmem.mem_w0;
+ move16();
+
+
+ *btilt_code_fx = LPDmem->tilt_code;
+ *gc_threshold_fx = LPDmem->gc_threshold;
+ Copy( st_fx->clip_var_fx, clip_var_bck_fx, 6 );
+ *next_force_sf_bck_fx = st_fx->next_force_safety_net_fx;
+
+
+ return;
+}
+
+void lsf_update_memory(
+ Word16 narrowband, /* i : narrowband flag */
+ const Word16 qlsf[], /* i : quantized lsf coefficients */
+ Word16 old_mem_MA[], /* i : MA memory */
+ Word16 mem_MA[], /* o : updated MA memory */
+ Word16 lpcorder /* i : LPC order */
+)
+{
+ Word16 i;
+
+ FOR (i=0; iclip_var_fx[0] = clip_var;
+ move16();
+
+ FOR(i=0; imem_AR_fx[i] = mem_AR[i];
+ move16();
+ st_fx->mem_MA_fx[i] = mem_MA[i];
+ move16();
+ lsp_new[i] = lsp_new_bck[i];
+ move16();
+ lsf_new[i] = lsf_new_bck[i];
+ move16();
+ lsp_mid[i] = lsp_mid_bck[i];
+ move16();
+ }
+
+ st_fx->mCb1_fx = mCb1;
+ move16();
+ st_fx->streaklimit_fx = streaklimit;
+ move16();
+ st_fx->pstreaklen_fx = pstreaklen;
+ move16();
+
+ FOR(i=0; iBin_E_fx[i] = Bin_E[i];
+ move16();
+ }
+
+ FOR(i=0; i<(L_FFT/2); i++)
+ {
+ st_fx->Bin_E_old_fx[i]=Bin_E_old[i];
+ move32();
+ }
+
+ /* restoring memories */
+ st_fx->LPDmem.mem_w0 = mem_w0_bck;
+ move16();
+
+ FOR(i=0; iLPDmem.mem_syn[i] = mem_syn_bck[i];
+ move16();
+ }
+
+ move16();
+ move32();
+ move16();
+ LPDmem->tilt_code = btilt_code_fx;
+ LPDmem->gc_threshold = gc_threshold_fx;
+ Copy( clip_var_bck_fx, st_fx->clip_var_fx, 6 );
+ st_fx->next_force_safety_net_fx = next_force_sf_bck_fx;
+
+ return;
+}
+
+/* Returns: codebook index */
+Word16 tcxlpc_get_cdk(
+ Word16 acelp_ext_mode /* (I) GC/VC indicator */
+)
+{
+ Word16 cdk;
+
+ move16();
+ cdk = 0;
+ if ( EQ_16(acelp_ext_mode, VOICED))
+ {
+ cdk = 1;
+ move16();
+ }
+
+ return cdk;
+}
+
+void msvq_dec
+(
+ const Word16 *const*cb, /* i : Codebook (indexed cb[*stages][levels][p]) (14Q1*1.28)*/
+ const Word16 dims[], /* i : Dimension of each codebook stage (NULL: full dim.) */
+ const Word16 offs[], /* i : Starting dimension of each codebook stage (NULL: 0) */
+ const Word16 stages,/* i : Number of stages */
+ const Word16 N, /* i : Vector dimension */
+ const Word16 maxN, /* i : Codebook dimension */
+ const Word16 Idx[], /* i : Indices */
+ Word16 *uq /* o : quantized vector (14Q1*1.28)*/
+)
+{
+ Word16 i,j,offset;
+ Word16 N34;
+ Word16 n, maxn, start;
+
+
+
+ set16_fx(uq, 0, N);
+
+ FOR ( i=0; i lsp[i] */
+ tmp = sub(lsp_i, cos_table_129[ind]);
+ /*
+ 69%: (Final Index - Index Guess) is <= 1
+ 28%: (Final Index - Index Guess) is 2
+ 2%: (Final Index - Index Guess) is >= 3
+ <1%: ...
+ */
+ IF (tmp > 0) /* possible range 0 to -5 (-1-2-2) */
+ {
+ ind = sub(ind, 1);
+ tmp = sub(lsp_i, cos_table_129[ind]);
+ IF (tmp > 0)
+ {
+ ind = sub(ind, 2);
+ tmp = sub(lsp_i, cos_table_129[ind]);
+ if (tmp > 0)
+ {
+ ind = sub(ind, 2);
+ }
+ tmp = sub(lsp_i, cos_table_129[ind+1]);
+ if (tmp <= 0)
+ {
+ ind = add(ind, 1);
+ }
+ tmp = sub(lsp_i, cos_table_129[ind]);
+ }
+ }
+
+ /* acos(lsp[i])= ind*128 + (lsp[i]-table[ind]) * acos_slope[ind] / 2048 */
+ L_tmp = L_mac(1L<<11, tmp, acos_slope[ind]);
+ L_tmp = L_shr(L_tmp, 12); /* (lsp[i]-table[ind]) * acos_slope[ind]) >> 11 */
+ L_tmp = L_mac0(L_tmp, ind, 128);
+
+ return L_tmp;
+}
+
+/*===================================================================*/
+/* FUNCTION : compute_poly_product_fx () */
+/*-------------------------------------------------------------------*/
+/* PURPOSE : Compute polynomial product for P(z) for LSP */
+/* to LPC conversion */
+/*-------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16[]) coef : LSP coefficients, Q15 */
+/* _ (Word16 []) order: LPC order */
+/*-------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word32[]) p : output sequence, Q24 */
+/* 1st entry is always 1.0, Q24 */
+/*-------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ None */
+/*-------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*===================================================================*/
+/* NOTE: */
+/* P(z)=(1+z^-1)*PI(j=1to(order/2)) (1 - 2*z^-1*cos(2*pi*w(2j-1)) + z^-2) */
+/* Q(z)=(1-z^-1)*PI(j=1to(order/2)) (1 - 2*z^-1*cos(2*pi*w(2j)) + z^-2) */
+/*===================================================================*/
+void compute_poly_product_fx(
+ Word16* coef, /* i : LSP coefficients, Q15 */
+ Word32* p, /* o : output sequence, Q24 */
+ Word16 order /* i : order */
+)
+{
+ Word16 i, len;
+ Word32 lspcos[LPC_SHB_ORDER];
+ Word32 p2[LPC_SHB_ORDER]; /* intermediate product, Q24*/
+ Word32* p_in, *p_out, *p_temp;
+
+ FOR ( i = 0; i < order / 2; i++ )
+ {
+ lspcos[i] = poscos_fx( coef[i * 2] );
+ move32(); /* lspcos =-cos(lsp) in Q30*/
+ }
+
+ /* Set up first polynomial for convolution (1 -2cos(w5) 1) */
+ /* First element of output is 1, all in Q24 */
+ p[0] = L_deposit_h( 0x100 ); /* 1.0 in Q24 */
+ p[2] = L_deposit_h( 0x100 ); /* 1.0 in Q24 */
+ p[1] = L_shr( lspcos[order / 2 - 1], 5 ); /* p2[1]=-2cos(w5), Q24 */
+ p2[0] = L_deposit_h( 0x100 ); /* 1.0 in Q24 */
+
+ len = 1;
+ move16();
+
+ len = 1;
+ p_in = p + 1; /* 2nd entry of input sequence */
+ p_out = p2 + 1; /* 2nd entry of output sequence */
+ FOR ( i = 0; i < ( order / 2 - 1 ); i++ )
+ {
+ lsp_convolve_fx( L_shr( lspcos[i], 5 ), p_in, p_out, len );
+
+ p_temp = p_in;
+ p_in = p_out;
+ p_out = p_temp; /* swap input/output buffer */
+ len = add( len, 1 );
+ }
+
+ /* if((order/2 - 1)%2 != 0) */
+ IF ( s_and( ( order / 2 - 1 ), 1 ) != 0 )
+ {
+ FOR ( i = 1; i <= order / 2; i++ )
+ {
+ p[i] = p_in[i - 1];
+ move32();
+ }
+ }
+
+}
+
+/*===================================================================*/
+/* FUNCTION : lsp_convolve_fx ( ) */
+/*-------------------------------------------------------------------*/
+/* PURPOSE : Convolution of LSP polynomial for LSP to LPC */
+/*-------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ ( Word32[]) p1 : 2nd entry of input sequence, Q24 */
+/* 1st entry is 1.0, Q24 */
+/* _ ( Word32) x : -2cos( w) in Q24 */
+/* _ ( Word16) len: length of output-2 */
+/*-------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ ( Word32[]) p2 : 2nd entry of output sequence, Q24 */
+/* 1st entry is 1.0, Q24 */
+/*-------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ None */
+/*-------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*===================================================================*/
+/* NOTE: Convolves ( 1 S 1) where S is the -2cos( w) value) with the */
+/* long sequence where the input long sequence on consecutive calls */
+/* is ( 1 X1 1), ( 1 X1 X2 X1), ( 1 X1 X2 X3 X2), ( 1 X1 X2 X3 X4 X3). */
+/* ( Since the sequence is symmetric, we only need to output one */
+/* entry beyond the center point for the next iteration). */
+/* The 1st entry of the convolution is 1, the 2nd is X1+S1, and */
+/* the rest have the form X( i-1) + X( i)*S + X( i+1). */
+/* Final output sequence is ( 1 X1 X2 X3 X4 X5 X4) */
+/*===================================================================*/
+void lsp_convolve_fx(
+ Word32 x,
+ Word32* p1,
+ Word32* p2,
+ Word16 len
+)
+{
+ Word16 i, d1h, d1l, d2h, d2l;
+ Word32 Ltemp;
+ Word32 Lacc;
+
+ d1h = extract_h( x ); /* d1h in Q8 */
+ d1l = extract_l( x ); /* d1l in Q24 */
+
+ Ltemp = L_add( x, p1[0] ); /* first output is p1[0]+x, Q24 */
+
+ p2[0] = Ltemp;
+ move32();
+ Ltemp = L_deposit_h( 0x100 ); /* Ltemp=1.0, Q24 */
+ FOR ( i = 0; i < len; i++ )
+ {
+ Ltemp = L_add( Ltemp, p1[i + 1] ); /* Ltemp2=p1[i-1]+p1[i+1], Q24 */
+ d2h = extract_h( p1[i] );
+ d2l = extract_l( p1[i] );
+
+ /* Lacc=L_mult_su( d1h,d2l); */
+ Lacc = L_mult0( d1h, ( UWord16 )d2l );
+ Lacc = L_mac0( Lacc, d2h, d1l );
+ Lacc = L_add( L_shr( Lacc, 16 ), L_shr( L_mult( d1h, d2h ), 1 ) );
+ /* Lacc=p1[i]* x, Q16 */
+ Lacc = L_add( L_shl( Lacc, 8 ), Ltemp ); /* Lacc=p1[i-1]+p1[i+1]+p1[i]*x, Q24 */
+
+ p2[i + 1] = Lacc;
+ move32();
+
+ Ltemp = p1[i];
+ move32();
+ } /* end for */
+
+ p2[i + 1] = p2[i - 1];
+ move32();
+}
+
+
+
+/*===================================================================*/
+/* FUNCTION : poscos_fx ( ) */
+/*-------------------------------------------------------------------*/
+/* PURPOSE : Compute cosine by approximation */
+/*-------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* */
+/* _ ( Word16) w: angle in radians/pi, Q14 ( 0<=w<=16384) */
+/*-------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ None */
+/*-------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ None */
+/*-------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ ( Word32) : -cos( w) in Q30 */
+/*===================================================================*/
+/* NOTE: This function uses 4 coefficients in the approx formula */
+/* Approx Formula: cos( w) = z + c1*z^3 + c2*z^5 + c3*z^7 + c4*z^9 */
+/* where z = pi/2 - w, c1=-.1666665668, c2=.8333025139E-2, */
+/* c3=-.198074182E-3, and c4=.2601903036E-5 */
+/*===================================================================*/
+
+
+Word32 poscos_fx( Word16 w )
+{
+ Word16 a, z, z2, z3, z5, z7, z9;
+ Word32 Ltemp;
+ Word32 Lacc;
+
+ IF ( w == 0 )
+ {
+ return ( 0xc0000004 ); /* -1.0 in Q30 */
+ }
+ ELSE
+ {
+ z = 0x2000;
+ move16(); /* z=0.5 in Q14 */
+ z = shl( sub( z, w ), 2 ); /* z = 0.5-w in Q16 */
+
+ a = 0x6488;
+ move16(); /* a=pi in Q13 */
+ z = mult_r( z, a ); /* z=pi*( 0.5-w), Q14 */
+ z2 = mult_r( z, z ); /* z2=z^2, Q13 */
+ z3 = round_fx( L_shl( L_mult0( z, z2 ), 0 ) ); /* z3=z^3, Q11 */
+ z5 = mult_r( z2, z3 ); /* z5=z^5, Q9 */
+ z7 = round_fx( L_shl( L_mult0( z2, z5 ), 0 ) ); /* z7=z^7, Q6 */
+ z9 = round_fx( L_shl( L_mult0( z2, z7 ), 0 ) ); /* z9=z^9, Q3 */
+
+ Lacc = L_mult( z9, cos_coef_new[0] ); /* Lacc=c4*z^9, Q31, c4 in Q28 */
+ Lacc = L_mac0( Lacc, z7, cos_coef_new[1] ); /* c3 in Q25 */
+ Ltemp = L_shl( L_mult( z3, cos_coef_new[3] ), 1 ); /* Ltemp=c1*z^3, Q31, c1 in Q17 */
+ Lacc = L_add( L_shr( Lacc, 1 ), Ltemp ); /* Lacc=c1*z^3+c3*z^7+c4*^z9, Q30 */
+ Lacc = L_add( Lacc, L_deposit_h( z ) );
+ Ltemp = L_mult( z5, cos_coef_new[2] ); /* Ltemp=-c2*z^5, Q29, cos_coef[2]=-c2 in Q19 */
+ Lacc = L_sub( Lacc, L_shl( Ltemp, 1 ) ); /* Lacc=cos( w) in Q30 */
+
+ return L_negate( Lacc ); /* return -cos( w), Q30 */
+ } /* end else */
+}
+/*===================================================================*/
+/* FUNCTION : root_search_fx ( ) */
+/*-------------------------------------------------------------------*/
+/* PURPOSE : Search root of the P or Q polynomial in a given */
+/* interval using binary search */
+/*-------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ ( Word16) low : Low index of the interval, Q9 ( 0-511) */
+/* _ ( Word16) high : High index of the interval, Q9 ( 0-511) */
+/* _ ( Word32 []) coef: polynomial coefficients, Q26 */
+/* _ ( Word16) order : LPC order */
+/*-------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ None */
+/*-------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ ( Word32) v_low: Polynomial value at low index, Q25 */
+/*-------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ ( Word16) root in Q15, or 0xffff if no root is found */
+/*===================================================================*/
+
+Word16 root_search_fx( Word16 low,
+ Word16 high,
+ Word32* v_low,
+ Word32* coef,
+ Word16 order
+ )
+{
+ Word16 f;
+ Word32 v_high, vh;
+ Word32 Ltemp, L_tmp1, L_tmp, Ltmp;
+ Word16 exp1, tmp;
+
+ v_high = polynomial_eval_fx( high, coef, order ); /* v_high has the value at high index */
+
+ IF ( v_high != 0 )
+ {
+ /* No exact root found */
+ test();
+ IF ( ( v_high ^ ( *v_low ) ) >= 0 )
+ {
+ /* No root in this interval ( low high] */
+ *v_low = v_high;
+ move32();
+ return ( -1 );
+ }
+ ELSE
+ {
+ /* there is a root in this interval */
+ /* Do binary search for root */
+ vh = v_high;
+ move16();
+
+ WHILE ( GE_16( sub( high, low ), 2 ))
+ {
+ /* high-low>=2 */
+ f = shr( add( high, low ), 1 ); /* f=( high+low)/2 */
+ Ltemp = polynomial_eval_fx( f, coef, order );
+ IF ( Ltemp == 0 )
+ {
+ *v_low = v_high;
+ move32();/* Set low value for next root search call */
+ return ( shl( f, 6 ) );
+ }
+ ELSE
+ {
+ test();
+ IF ( ( Ltemp ^ ( *v_low ) ) < 0 )
+ {
+ /* root between f & low */
+ high = f;
+ move16();
+ vh = Ltemp;
+ move32();
+ }
+ ELSE
+ {
+ *v_low = Ltemp;
+ move32();
+ low = f;
+ move16();
+ }
+ }
+ } /* end while */
+
+ /* do interpolation for root in between high and low */
+ /* Lacc=divide_dp( *v_low, L_sub( *v_low,vh),2,1); // Lacc in Q31 */
+ L_tmp = L_sub( *v_low, vh );
+
+ if ( LT_32( *v_low, vh ))
+ {
+ L_tmp = L_negate( L_tmp );
+ }
+
+ exp1 = norm_l( L_tmp );
+ L_tmp1 = L_shl( L_tmp, exp1 );
+ tmp = extract_h( L_tmp1 );
+ exp1 = sub(30 - 25, exp1);
+ tmp = div_s( 16384, tmp ); /* 15+exp1 */
+ Ltmp = Mult_32_16( *v_low, tmp ); /* 15+exp1+25-15 */
+ Ltemp = L_shl( Ltmp, ( 6 - exp1 ) ); /* Q31 */
+ if ( LT_32( *v_low, vh ))
+ {
+ Ltemp = L_negate( Ltemp );
+ }
+ Ltemp = L_shr( Ltemp, 9 ); /* Ltemp =quotient*1.0 in Q31 */
+
+ *v_low = v_high;
+ move16();
+ return ( add( round_fx( Ltemp ), shl( low, 6 ) ) );
+ } /* end else ( root in interval) */
+ } /* end else ( exact root at high) */
+
+ /* find the exact root */
+ *v_low = v_high;
+ move32(); /* Set low value for next root search call */
+ return ( shl( high, 6 ) ); /* return exact root at high in Q15 */
+}
+
+/*===================================================================*/
+/* FUNCTION : calc_weight( ) */
+/*-------------------------------------------------------------------*/
+/* PURPOSE : This function computes the weight given delta1
+and delta2 */
+/*-------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) delta1: (Q15) */
+/* _ (Word16) delta2: (Q15) */
+/*-------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16 *) n1: o/p weight is Q(31-n1) */
+/*-------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ None. */
+/*-------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ (Word32) Lsum1: computed weight Q(31-n1) */
+/* (alpha/(sqrt(delta1*delta2)) */
+/*===================================================================*/
+
+Word32 calc_weight(
+ Word16 delta1,
+ Word16 delta2,
+ Word16* n1
+)
+{
+ Word16 n;
+ Word32 L_tmp;
+ Word16 alpha=0x4F94;
+ move16(); /* ( 0.5*250/( 2*pi)) in Q10*/
+
+ L_tmp = L_mult0( delta1, delta2 ); /* Q30 */
+ n = norm_l( L_tmp );
+ L_tmp = L_shl( L_tmp, n );
+ n = sub(1, n);
+ L_tmp = Isqrt_lc( L_tmp, &n ); /* Q( 31-n)*/
+
+ L_tmp = Mult_32_16( L_tmp, alpha ); /* Q( 26-n) */
+
+ *n1 = n;
+ move16();
+
+ return L_tmp;
+}
+
+/*===================================================================*/
+/* FUNCTION : polynomial_eval_fx ( ) */
+/*-------------------------------------------------------------------*/
+/* PURPOSE : Evaluate P or Q polynomial at given frequency */
+/*-------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (Word16) f : frequency used as index for cosine table lookup */
+/* Q9 */
+/* _ (Word32 []) coef: polynomial coefficients, Q26 */
+/* _ (Word16 []) order: LPC order */
+/*-------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ None */
+/*-------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ None */
+/*-------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ (Word32) polynomial value at given frequency f, Q25 */
+/*===================================================================*/
+/* Note: This function uses 512 entry cosine table cos_table[], Q15 */
+/*===================================================================*/
+/* if (K = order/2) */
+/* P(w)=cos(Kw)+p[1]*cos((K-1)w)+p[2]*cos((K-2)w)+...+p[(K-1)]*cos(w)+p[K]/2 */
+/* Q(w)=cos(Kw)+q[1]*cos((K-1)w)+q[2]*cos((K-2)w)+...+q[(K-1)]*cos(w)+q[K]/2 */
+/*===================================================================*/
+
+/* 40-32 bit conversion */
+Word32 polynomial_eval_fx( Word16 f,
+ Word32* coef,
+ Word16 order
+ )
+{
+ Word16 i, idx;
+ Word16 dh, dl, coslut;
+ Word32 Ltemp, L_tmp1, L_tmp;
+ Word32 Lacc;
+ idx = f;
+ move16();
+ dh = extract_h( coef[order / 2] ); /* Q10 */
+ dl = extract_l( coef[order / 2] ); /* Q16 */
+
+ coslut = 0x4000;
+ move16(); /* coslut=0.5 in Q15 */
+ Ltemp = L_mult0( coslut, dh ); /* Ltemp=MSW, coef[5]/2 in Q25 */
+
+ Lacc = L_mult0( coslut, dl ); /* Lacc=LSW, coef[5]/2 in Q41 //Q31 */
+ Lacc = L_shr( Lacc, 1 ); /* Q30 */
+ FOR ( i = ( order / 2 ) - 1; i > 0; i-- )
+ {
+ coslut = cos_table[idx];
+ move16(); /* coslut=cos( ( ( order/2)-i)f), Q15 */
+ dh = extract_h( coef[i] );/* Q10 */
+ dl = extract_l( coef[i] );/* Q16 */
+
+ Ltemp = L_add( Ltemp, L_mult0( dh, coslut ) ); /* Q25 */
+ IF ( dl < 0 )
+ {
+ L_tmp1 = L_shl( L_add( 65536, dl ), 14 );
+ L_tmp = Mult_32_16( L_tmp1, coslut );
+ Lacc = L_add( Lacc, L_tmp );
+ }
+ ELSE
+ {
+ Lacc = L_add( Lacc, L_shr( L_mult0( coslut, dl ), 1 ) );/* Q30 */
+ }
+
+ idx += f;
+ if ( GE_16(idx, 512)) idx=sub(idx, 512); /* modulo of 512 */
+ }
+
+ coslut = cos_table[idx];
+ move16(); /* coslut=cos( 5f), Q15 */
+ Ltemp = L_add( Ltemp, L_mult0( 0x400, coslut ) ); /* coef[0]=1.0, Q25 */
+
+ return ( L_add( Ltemp, L_shr( Lacc, 15 ) ) ); /* Q25 */
+}
+
+/*----------------------------------------------------------------------------------*
+* v_sort:
+*
+* This is very fast with almost ordered vectors. The first 15 ISF values
+* are almost always sorted.
+*----------------------------------------------------------------------------------*/
+void v_sort(
+ Word16 *r, /* i/o: Vector to be sorted in place */
+ const Word16 lo, /* i : Low limit of sorting range */
+ const Word16 up /* I : High limit of sorting range */
+)
+{
+ Word16 i, j;
+ Word16 tempr;
+
+
+ FOR (i=sub(up, 1); i>=lo; i--)
+ {
+ tempr = r[i];
+ move16();
+ FOR (j=i; j cos(pi/2) = 0.
+ *---------------------------------------------------------------------*/
+
+ FOR (i = 1; i <= iuni; i++)
+ {
+ Mpy_32_16_ss(R[0], x[i-1], &mh, &ml);
+ r0 = L_add(R[1], mh);
+
+ Mpy_32_16_ss(S[0], x[i-1], &mh, &ml);
+ s0 = L_add(S[1], mh);
+
+
+ FOR (j = 2; j <= NC; j++)
+ {
+ Mpy_32_16_ss(r0, x[i-1], &mh, &ml);
+ r0 = L_add(R[j], mh);
+
+ Mpy_32_16_ss(s0, x[i-1], &mh, &ml);
+ s0 = L_add(S[j], mh);
+ }
+
+ G[i] = inv_pow(r0, s0, x[i-1]);
+ move32();
+ }
+
+ /*---------------------------------------------------------------------*
+ * Power spectrum at points other than x = -1, 0, and 1 and unique
+ * points is computed using the anti-symmetry of the grid relative
+ * to the midpoint x = 0 in order to reduce looping.
+ *---------------------------------------------------------------------*/
+
+ FOR ( ; i < imid; i++)
+ {
+ x2 = mult_r(x[i-1], x[i-1]);
+
+ Mpy_32_16_ss(R[0], x2, &mh, &ml);
+ re = L_add(R[2], mh);
+ Mpy_32_16_ss(R[1], x2, &mh, &ml);
+ ro = L_add(R[3], mh);
+
+ Mpy_32_16_ss(S[0], x2, &mh, &ml);
+ se = L_add(S[2], mh);
+ Mpy_32_16_ss(S[1], x2, &mh, &ml);
+ so = L_add(S[3], mh);
+
+ FOR (j = 4; j < NC; j+=2)
+ {
+ Mpy_32_16_ss(re, x2, &mh, &ml);
+ re = L_add(R[j], mh);
+ Mpy_32_16_ss(ro, x2, &mh, &ml);
+ ro = L_add(R[j+1], mh);
+ Mpy_32_16_ss(se, x2, &mh, &ml);
+ se = L_add(S[j], mh);
+ Mpy_32_16_ss(so, x2, &mh, &ml);
+ so = L_add(S[j+1], mh);
+ }
+
+ Mpy_32_16_ss(re, x2, &mh, &ml);
+ L_tmp = L_add(R[j], mh);
+ Mpy_32_16_ss(ro, x[i-1], &mh, &ml);
+ re = L_add(L_tmp, mh);
+ ro = L_sub(L_tmp, mh);
+
+ Mpy_32_16_ss(se, x2, &mh, &ml);
+ L_tmp = L_add(S[j], mh);
+ Mpy_32_16_ss(so, x[i-1], &mh, &ml);
+ se = L_add(L_tmp, mh);
+ so = L_sub(L_tmp, mh);
+
+ G[i] = inv_pow(re, se, x[i-1]);
+ move32();
+ G[N-i-1] = inv_pow(so, ro, x[i-1]);
+ move32();
+ }
+
+ return;
+}
+
+static Word32 b_inv_sq(
+ const Word32 in32, /* i : Input not normalized to inverse */
+ const Word16 exp_in /* i : input current exponent */
+)
+{
+ Word16 m_den, exp_den;
+ Word16 div_out;
+ Word32 Ltmp;
+
+ exp_den = norm_l(in32);
+ m_den = extract_h(L_shl(in32, exp_den));
+ exp_den = add(sub(30,exp_den),sub(16,exp_in));
+
+ m_den = mult_r(m_den, m_den);
+ exp_den = shl(exp_den,1);
+
+ div_out = div_s(8192,m_den);
+ Ltmp = L_shl(div_out, add(sub(30-13, exp_den),15)); /*Q15*/
+
+ return Ltmp;
+}
+
+static Word32 inv_pow(
+ const Word32 re,
+ const Word32 se,
+ const Word16 x
+)
+{
+ Word16 exp1, exp2;
+ Word16 tmp;
+ Word32 L_tmp;
+ Word32 mh;
+ UWord16 ml;
+ Word32 r0, s0;
+
+ IF(re==0)
+ {
+ exp1 = 30;
+ move16();
+ r0 = L_deposit_l(0);
+ }
+ ELSE
+ {
+ exp1 = norm_l(re);
+ tmp = extract_h(L_shl(re, exp1));
+ L_tmp = L_shr(L_mult(tmp, tmp), 1);
+ Mpy_32_16_ss(L_tmp, x, &mh, &ml);
+ r0 = L_add(L_tmp, mh);
+ }
+
+ IF(se==0)
+ {
+ exp2 = 30;
+ move16();
+ s0 = L_deposit_l(0);
+ }
+ ELSE
+ {
+ exp2 = norm_l(se);
+ tmp = extract_h(L_shl(se, exp2));
+ L_tmp = L_shr(L_mult(tmp, tmp), 1);
+ Mpy_32_16_ss(L_tmp, x, &mh, &ml);
+ s0 = L_sub(L_tmp, mh);
+ }
+
+ IF(exp1 > exp2)
+ {
+ exp1 = shl(sub(exp1, exp2), 1);
+ r0 = L_shr(r0, exp1);
+
+ exp2 = add(add(exp2, exp2), 8);
+ }
+ ELSE
+ {
+ exp2 = shl(sub(exp2, exp1), 1);
+ s0 = L_shr(s0, exp2);
+
+ exp2 = add(add(exp1, exp1), 8);
+ }
+
+ r0 = L_add(r0, s0);
+ exp1 = norm_l(r0);
+ L_tmp = L_shl(r0, exp1);
+ tmp = extract_h(L_tmp);
+ IF(tmp==0)
+ {
+ return MAX_32;
+ }
+ tmp = div_s((Word16)((1<<14)-1), tmp);
+ exp1 = add(exp1, exp2);
+ L_tmp = L_shr(tmp, sub(31, exp1)); /* result in Q15 */
+
+ return(L_tmp);
+}
+
+
+/*---------------------------------------------------------------------*
+ * spectautocorr()
+ *
+ * Computes the autocorrelation r[j] for j = 0, 1, ..., M from
+ * the power spectrum P(w) by using rectangle rule to approximate
+ * the integral
+ *
+ * 1 pi
+ * r[j] = --- I P(w) cos(j*w) dw.
+ * 2*pi -pi
+ *
+ * It is sufficient to evaluate the integrand only from w = 0 to
+ * w = pi due to the symmetry P(-w) = P(w). We can further
+ * employ the relation
+ *
+ * cos(j*(pi - w)) = (-1)^j cos(j*w)
+ *
+ * to use symmetries relative to w = pi/2.
+ *
+ * When applying the rectangle rule, it is useful to separate w = 0,
+ * w = pi/2, and w = pi. By using a frequency grid of N points, we
+ * can express the rectangle rule as
+ *
+ * r[j] = G[0] + 2*a*G[(N-1)/2] + b*G[N-1]
+ *
+ * M
+ * + 2 sum (G[i] - G[N-i-1]) cos(j*x[i])
+ * i=1
+ *
+ * where G[i] is the power spectrum at the grid point cos(i*pi/N)
+ * and M = (N-1)/2 - 1 is the number of the grid points in the
+ * interval(0, pi/2).
+ *
+ * The coefficients
+ *
+ * b = (-1)^j
+ * a = (1 + (-1)^(j+1))(-1)^floor(j/2)
+ *
+ * follow from the properties of cosine. The computation further
+ * uses the recursion
+ *
+ * cos(j*w) = 2*cos(w)*cos((j-1)*w) - cos((j-2)*w)
+ *
+ * Note that the autocorrelation can be scaled for convenience,
+ * because this scaling has no impact on the LP coefficients to be
+ * calculated from the autocorrelation. The expression of r[j] thus
+ * omits the division by N.
+ *
+ * See the powerspect function on the definition of the grid.
+ *
+ * References
+ * J. Makhoul, "Spectral linear prediction: properties and
+ * applications," IEEE Trans. on Acoustics, Speech and Signal
+ * Processing, Vol. 23, No. 3, pp.283-296, June 1975
+ *---------------------------------------------------------------------*/
+
+static void spectautocorr_fx(
+ const Word16 x[], /* i: Grid points x[0:m-1] */
+ const Word16 N, /* i: Number of grid points */
+ const Word32 G[], /* i: Power spectrum G[0:N-1] */
+ Word16 rh[], /* o: Autocorrelation r[0:M] */
+ Word16 rl[] /* o: Autocorrelation r[0:M] */
+)
+{
+ Word16 c[M+1]; /* c[j] = cos(j*w) */
+ Word32 gp, gn;
+ Word16 i, j;
+ Word16 imid;
+ Word32 mh;
+ UWord16 ml;
+ Word32 r[M+1];
+ Word16 exp0;
+
+ /*---------------------------------------------------------------------*
+ * The mid point of the cosine table x of m entries assuming an odd m.
+ * Only the entries x[0] = cos(pi/m), x[1] = cos(2*pi/m), ...,
+ * x[imid-1] = cos((imid-1)*pi/m) need to be stored due to trivial
+ * cos(0), cos(pi/2), cos(pi), and symmetry relative to pi/2.
+ * Here m = 51.
+ *---------------------------------------------------------------------*/
+
+ imid = (N - 1)/2;
+ move16();
+
+ /*---------------------------------------------------------------------*
+ * Autocorrelation r[j] at zero lag j = 0 for the upper half of the
+ * unit circle, but excluding the points x = cos(0) and x = cos(pi).
+ *---------------------------------------------------------------------*/
+
+ r[0] = G[1];
+ move32();
+ FOR (i = 2; i < N-1; i++)
+ {
+ r[0] = L_add(r[0], G[i]);
+ move32();
+ }
+
+ /*---------------------------------------------------------------------*
+ * Initialize the autocorrelation r[j] at lags greater than zero
+ * by adding the midpoint x = cos(pi/2) = 0.
+ *---------------------------------------------------------------------*/
+
+ r[1] = L_deposit_l(0);
+ r[2] = -G[imid];
+ move32();
+
+ FOR (i = 3; i < M; i+=2)
+ {
+ r[i] = L_deposit_l(0);
+ r[i+1] = -r[i-1];
+ move32();
+ }
+
+ /*---------------------------------------------------------------------*
+ * Autocorrelation r[j] at lags j = 1, 2, ..., M. The computation
+ * employes the relation cos(j*(pi - w)) = (-1)^j cos(j*w) and
+ * cos(j*w) = 2*cos(w)*cos((j-1)*w) - cos((j-2)*w) for obtaining
+ * the cosine c[j] = cos(j*w).
+ *---------------------------------------------------------------------*/
+
+ c[0] = (Word16)32767;
+ move16(); /* 1.0 in Q15 */
+ FOR (i = 1; i < imid; i++)
+ {
+ gp = L_add(G[i], G[N-i-1]);
+ gn = L_sub(G[i], G[N-i-1]);
+
+ /*r[1] = L_mac(r[1], x[i-1], gn);*/
+ Mpy_32_16_ss(gn, x[i-1], &mh, &ml);
+ r[1] = L_add(r[1], mh);
+ move32();
+ c[1] = x[i-1];
+ move16();
+
+ FOR (j = 2; j < M; j+=2)
+ {
+ c[j] = mult_r(c[j-1], x[i-1]);
+ move16();
+ c[j] = add(c[j], sub(c[j], c[j-2]));
+ move16();
+
+ /*r[j] = L_mac(r[j], c[j], gp);*/
+ Mpy_32_16_ss(gp, c[j], &mh, &ml);
+ r[j] = L_add(r[j], mh);
+ move32();
+
+ c[j+1] = mult_r(c[j], x[i-1]);
+ move16();
+ c[j+1] = add(c[j+1], sub(c[j+1], c[j-1]));
+ move16();
+
+ /*r[j+1] = L_mac(r[j+1], c[j+1], gn);*/
+ Mpy_32_16_ss(gn, c[j+1], &mh, &ml);
+ r[j+1] = L_add(r[j+1], mh);
+ move32();
+ }
+ c[j] = mult_r(c[j-1], x[i-1]);
+ move16();
+ c[j] = add(c[j], sub(c[j], c[j-2]));
+ move16();
+
+ Mpy_32_16_ss(gp, c[j], &mh, &ml);
+ r[j] = L_add(r[j], mh);
+ move32();
+ }
+
+ /*---------------------------------------------------------------------*
+ * Add the endpoints x = cos(0) = 1 and x = cos(pi) = -1 as
+ * well as the lower half of the unit circle.
+ *---------------------------------------------------------------------*/
+ gp = L_shr(L_add(G[0], G[N-1]), 1);
+ gn = L_shr(L_sub(G[0], G[N-1]), 1);
+
+ r[0]= L_add(r[0], gp);
+ move32();
+ exp0 = norm_l(r[0]);
+ L_Extract(L_shl(r[0], exp0), &rh[0], &rl[0]);
+
+ FOR (j = 1; j < M; j+=2)
+ {
+ L_Extract(L_shl(L_add(r[j], gn), exp0), &rh[j], &rl[j]);
+ L_Extract(L_shl(L_add(r[j+1], gp), exp0), &rh[j+1], &rl[j+1]);
+ }
+
+ return;
+}
+
+/*---------------------------------------------------------------------*
+ * zeros2poly()
+ *
+ * Computes the coefficients of the polynomials
+ *
+ * R(x) = prod (x - x[i]),
+ * i = 0,2,4,...
+ *
+ * S(x) = prod (x - x[i]),
+ * i = 1,3,5,...
+ *
+ * when their zeros x[i] are given for i = 0, 1, ..., n-1. The
+ * routine assumes n = 1 or even n greater than or equal to 4.
+ *
+ * The polynomial coefficients are returned in R[0:n/2-1] and
+ * S[0:n/2-1]. The leading coefficients are in R[0] and S[0].
+ *---------------------------------------------------------------------*/
+static void zeros2poly_fx(
+ Word16 x[], /* i: Q15 Zeros of R(x) and S(x) */
+ Word32 R[], /* o: Q22 Coefficients of R(x) */
+ Word32 S[] /* o: Q22 Coefficients of S(x) */
+)
+{
+ Word16 xr, xs;
+ Word16 i, j;
+ Word32 mh;
+ UWord16 ml;
+
+ R[0] = (1<<27)-1;
+ move32();
+ S[0] = (1<<27)-1;
+ move32();
+ R[1] = L_msu(0, x[0], 1<<11);
+ move32();
+ S[1] = L_msu(0, x[1], 1<<11);
+ move32();
+
+ FOR (i = 2; i <= NC; i++)
+ {
+ xr = negate(x[2*i-2]);
+ xs = negate(x[2*i-1]);
+
+ Mpy_32_16_ss(R[i-1], xr, &R[i], &ml);
+ Mpy_32_16_ss(S[i-1], xs, &S[i], &ml);
+
+ FOR (j = i-1; j > 0; j--)
+ {
+ Mpy_32_16_ss(R[j-1], xr, &mh, &ml);
+ R[j] = L_add(R[j], mh);
+ Mpy_32_16_ss(S[j-1], xs, &mh, &ml);
+ S[j] = L_add(S[j], mh);
+ }
+ }
+
+ return;
+}
+
+/*---------------------------------------------------------------------*
+ * polydecomp()
+ *
+ * Computes the coefficients of the symmetric and antisymmetric
+ * polynomials P(z) and Q(z) that define the line spectrum pair
+ * decomposition of a given polynomial A(z) of order n. For even n,
+ *
+ * P(z) = [A(z) + z^(n+1) A(1/z)]/(1/z + 1),
+ * Q(z) = [A(z) - z^(n+1) A(1/z)]/(1/z - 1),
+ *
+ * These polynomials are then expressed in their direct form,
+ * respectively, R(x) and S(x), on the real axis x = cos w using
+ * explicit Chebyshev polynomials of the first kind.
+ *
+ * The coefficients of the polynomials R(x) and S(x) are returned
+ * in R[0:n/2] and S[0:n/2] for the given linear prediction
+ * coefficients A[0:n/2]. Note that R(x) and S(x) are formed in
+ * place such that P(z) is stored in the same array than R(x),
+ * and Q(z) is stored in the same array than S(x).
+ *
+ * The routines assumes n = 16.
+ *---------------------------------------------------------------------*/
+
+static void polydecomp_fx(
+ Word16 A[], /* i: Q12 linear prediction coefficients */
+ Word32 R[], /* o: Q20 coefficients of R(x) */
+ Word32 S[] /* o: Q20 coefficients of S(x) */
+)
+{
+ Word16 scale;
+ Word16 i;
+ Word32 Ltmp1, Ltmp2;
+
+ scale = shl((1<<5), norm_s(A[0]));
+
+ R[0] = (1<<20)-1;
+ move32(); /* Q20 */
+ S[0] = (1<<20)-1;
+ move32();
+
+ FOR(i=0; i AMRWB_1825 */
+ 0x06, /* AMRWB_2305 -> AMRWB_1825 */
+ 0x04, /* AMRWB_2385 */
+ 0x07, /* invalid request -> none */
+ 0x07, /* invalid request -> none */
+ 0x07, /* invalid request -> none */
+ 0x07, /* invalid request -> none */
+ 0x07, /* invalid request -> none */
+ 0x07, /* invalid request -> none */
+ 0x07 /* invalid request -> none */
+};
+
+/* 3 bit to 4 bit AMR-WB CMR remapping table */
+static const Word16 amrwb_4bit_cmr[8] =
+{
+ 0x00, /* AMRWB_660 */
+ 0x01, /* AMRWB_885 */
+ 0x02, /* AMRWB_1265 */
+ 0x04, /* AMRWB_1585 */
+ 0x08, /* AMRWB_2385 */
+ 0x03, /* AMRWB_1425 */
+ 0x05, /* AMRWB_1825 */
+ 0x0f /* invalid */
+};
diff --git a/lib_com/modif_fs_fx.c b/lib_com/modif_fs_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..e0929578f786590ca7871143f06fc337d4da2aaf
--- /dev/null
+++ b/lib_com/modif_fs_fx.c
@@ -0,0 +1,1297 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include
+#include "rom_enc_fx.h" /* prototypes */
+#include "stl.h"
+
+#include "basop_util.h"
+
+/*-----------------------------------------------------------------*
+ * Local functions
+ *-----------------------------------------------------------------*/
+
+
+
+/*==============================================================================*/
+/* FUNCTION : modify_Fs_fx ( ) */
+/*------------------------------------------------------------------------------*/
+/* PURPOSE : Modify sampling freq by interpolation */
+/*------------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* const Word16 sigIn_fx[] signal to decimate Q_syn2-1 */
+/* const Word16 lg length of input */
+/* const Word16 fin frequency of input Q0 */
+/* const Word16 fout frequency of output Q0 */
+/*------------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* Word16 sigOut_fx[] decimated signal Q_syn2-1 */
+/*------------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* Word16 mem_fx[] filter memory Q_syn2-1 */
+/*------------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None. */
+/*------------------------------------------------------------------------------*/
+/* CALLED FROM : TX/RX */
+/*==============================================================================*/
+Word16 modify_Fs_fx( /* o : length of output Q0 */
+ const Word16 sigIn_fx[], /* i : signal to decimate Q0 */
+ Word16 lg, /* i : length of input Q0 */
+ const Word32 fin, /* i : frequency of input Q0 */
+ Word16 sigOut_fx[], /* o : decimated signal Q0 */
+ const Word32 fout, /* i : frequency of output Q0 */
+ Word16 mem_fx[] /* i/o: filter memory Q0 */
+ ,const Word16 nblp /* i : flag indicating if NB low-pass is applied */
+)
+{
+ Word16 i;
+
+ Word16 lg_out, fac_num, fac_den, filt_len, frac, temp_n, mem_len;
+ Word16 num_den;
+ Word16 datastep, fracstep;
+ Word16 *sigIn_ptr, *sigPtr;
+ Word16 signal_tab_fx[3*L_FILT_MAX + L_FRAME48k], *signal_fx, *signal_ana_fx; /* 3* as 2* for memory and 1* for future prediction */
+ Word16 A_fx[M+1], r_fx_h[M+1], r_fx_l[M+1];
+ Word16 mem_len_ana;
+ Word16 plus_sample_in;
+ Word16 j;
+ Word16 mu_preemph_fx;
+ Word16 mem_preemph_fx;
+ Word16 Q_r;
+ Word16 mem_lev_fx[18];
+ Word32 t0, t1, t2, L_tmp; /* temporary variables */
+ Word32 LepsP[M+1];
+ Word16 flag_low_order = 0;
+ Word16 filt_len_tmp;
+
+ const Resampling_cfg_fx *cfg_ptr_fx;
+
+ /*-------------------------------------------------------------------*
+ * Find the resampling configuration
+ *-------------------------------------------------------------------*/
+
+ /* check if fin and fout are the same */
+ IF (EQ_32(fin,fout))
+ {
+ /* just copy the signal_fx and quit */
+ Copy(sigIn_fx, sigOut_fx, lg);
+
+ return lg;
+ }
+ ELSE
+ {
+ /* find the resampling configuration in the lookup table */
+ cfg_ptr_fx = &resampling_cfg_tbl_fx[0];
+ WHILE ( (cfg_ptr_fx->fin_fx != 0) && !(EQ_32(cfg_ptr_fx->fin_fx,fin)&&EQ_32(cfg_ptr_fx->fout_fx,fout)))
+ {
+ test();
+ test();
+ cfg_ptr_fx++;
+ }
+
+
+ /* find config with NB 4kHz low-pass */
+ test();
+ test();
+ IF ( nblp && (GT_32(fin, 8000))&&(EQ_32(fout,12800)))
+ {
+ flag_low_order = 1;
+ move16();
+ cfg_ptr_fx++;
+ WHILE ( (cfg_ptr_fx->fin_fx != 0) && !( (EQ_32(cfg_ptr_fx->fin_fx, fin))&&(EQ_32(cfg_ptr_fx->fout_fx,fout))))
+ {
+ test();
+ test();
+ cfg_ptr_fx++;
+ }
+ }
+
+ /*-------------------------------------------------------------------*
+ * Retrieve and/or calculate the resampling parameters
+ *-------------------------------------------------------------------*/
+ fac_num = cfg_ptr_fx->fac_num_fx;
+ move16();/*Q0*/
+ fac_den = cfg_ptr_fx->fac_den_fx;
+ move16();
+
+ IF(GE_16(lg,L_FRAME))
+ {
+ lg_out = cfg_ptr_fx->lg_out ;
+ move16();
+ }
+ ELSE
+ {
+ lg_out = idiv1616(i_mult2(lg, fac_num), fac_den);
+ }
+ filt_len = cfg_ptr_fx->filt_len_fx;
+ move16();
+ plus_sample_in = 0;
+ move16();/*default, regular delay*/
+ frac = 0;
+ move16();
+
+ test();
+ IF ( (EQ_32(fin, 8000))&&(EQ_32(fout,12800)))
+ {
+ plus_sample_in = 7;
+ move16();
+ frac = 4;
+ move16();
+ }
+
+ mem_len = shl(filt_len,1);
+ signal_fx = signal_tab_fx+2*L_FILT_MAX + sub(L_FRAME48k, add(mem_len, lg));
+ signal_ana_fx = signal_fx;
+ mem_len_ana = mem_len;
+ move16();
+ }
+
+
+ /*-------------------------------------------------------------------*
+ * Resample
+ *-------------------------------------------------------------------*/
+ /* append filter memory */
+ Copy(mem_fx, signal_fx, mem_len);
+
+ sigPtr = signal_fx + mem_len;
+ Copy(sigIn_fx, sigPtr, lg);
+
+ IF(plus_sample_in > 0)
+ {
+ autocorr_fx( signal_ana_fx+mem_len_ana+lg-LEN_WIN_SSS, 1, r_fx_h, r_fx_l, &Q_r, LEN_WIN_SSS, wind_sss_fx, 0, 0 );
+
+
+ t1 = L_Comp(r_fx_h[1], r_fx_l[1]); /* R[1] in Q31 */
+ t2 = L_abs(t1); /* abs R[1] */
+ t0 = L_deposit_l(0);
+ IF (r_fx_h[0] != 0)
+ {
+ t0 = Div_32(t2, r_fx_h[0], r_fx_l[0]); /* R[1]/R[0] in Q31 */
+ }
+ if (t1 < 0)
+ {
+ t0 = L_negate(t0); /* R[1]/R[0] */
+ }
+
+
+
+ mu_preemph_fx = extract_h(t0); /*r_fx[1] / r_fx[0]; */
+ mem_preemph_fx = signal_ana_fx[mem_len_ana+lg-LEN_WIN_SSS - 1];
+ move16();
+ preemph_fx(signal_ana_fx+mem_len_ana+lg-LEN_WIN_SSS, mu_preemph_fx, LEN_WIN_SSS, &mem_preemph_fx);
+
+
+ /* Autocorrelations */
+ autocorr_fx( signal_ana_fx+mem_len_ana+lg-LEN_WIN_SSS, M, r_fx_h, r_fx_l, &Q_r,
+ LEN_WIN_SSS, wind_sss_fx, 0, 0 );
+
+ /* Lag windowing */
+ lag_wind( r_fx_h, r_fx_l, M, fin, LAGW_STRONG );
+
+ /* Levinson-Durbin */
+ set16_fx(mem_lev_fx, 0, 18 );
+ E_LPC_lev_dur(r_fx_h, r_fx_l, A_fx, LepsP, M, NULL);
+
+ Copy_Scale_sig( A_fx, A_fx, M+1, sub(norm_s(A_fx[0]),2) );
+
+ FOR (i=0; ifilter_fx, frac, fac_num, filt_len_tmp ));
+
+ frac = add(frac,fracstep);
+
+ j = sub(fac_num, frac);
+ if (j < 0)
+ {
+ frac = sub(frac,fac_num);
+ }
+ sigIn_ptr += add(lshr(j, 15), datastep);
+ }
+ /* rescaling */
+ test();
+ IF ((GT_16(fac_num,fac_den))==((cfg_ptr_fx->flags_fx&RS_INV_FAC)!=0))
+ {
+ IF(LT_16(fac_num, fac_den))
+ {
+ num_den = div_s(fac_num,fac_den);/*Q15*/
+ test();
+ IF( GT_32(fin, 16000)&&EQ_16(lg_out,512))
+ {
+
+ FOR( i=0; iflags_fx&RS_INV_FAC)!=0))
+ {
+ FOR( i=0; i Q(-QSR) */
+ }
+
+ /* length of the interpolated signal */
+ /*lg_out = (short)(lg * fout / fin); */
+
+ /* cc[x][3]*s*s*s + cc[x][2]*s*s + cc[x][1]*s + cc[x][0]; indexes relatives of s : -1 0 1 2 */
+ /* d : cc[x][0] = s[0] */
+ /* b : cc[x][2] =(s[-1]+s[1])/2-s[0] */
+ /* a : cc[x][3] = (s[-1]+s[2]-s[0]-s[1]-4*cc[x][2]) / 6 */
+ /* c : cc[x][1] = s[1]-s[0]-cc[x][3]-cc[x][2] */
+
+ /* coef inits using memory (indexes < 0) */
+ /* cc[2][] : indexes -2 -1 0 1 */
+ cptr = &(cc[2][0]);
+ cptr[0] = mult_r(sigin_sr[-1], 10923);
+ move16(); /* sigIn[-1]/3 */
+ cptr[2] = sub(shr(add(sigin_sr[-2], sigin_sr[0]), 1), sigin_sr[-1]);
+ move16(); /* (sigIn[-2]+sigIn[0])/2-sigIn[-1]; */
+ cptr[3] = sub(mult_r(sub(add(sigin_sr[-2], sigin_sr[1]), add(sigin_sr[-1], sigin_sr[0])), 5461), mult_r(cptr[2],21845));
+ move16(); /*(sigIn[-2]+sigIn[1]-sigIn[-1]-sigIn[0]) / 6 - 4/6*cc[2][2]);*/
+ cptr[1] = sub(sub(sigin_sr[0], sigin_sr[-1]), add(cptr[3], cptr[2]));
+ move16();
+
+ /* cc[3][] : indexes -1 0 1 2 */
+ cptr = &(cc[3][0]);
+ cptr[0] = mult_r(sigin_sr[0], 10923);
+ move16();/* sigIn[-1]/3 */
+ cptr[2] = sub(shr(add(sigin_sr[-1], sigin_sr[1]), 1), sigin_sr[0]);
+ move16(); /* (sigIn[-1]+sigIn[1])/2-sigIn[0]; */
+ cptr[3] = sub(mult_r(sub(add(sigin_sr[-1], sigin_sr[2]), add(sigin_sr[0], sigin_sr[1])), 5461), mult_r(cptr[2],21845));
+ move16(); /*(sigIn[-2]+sigIn[1]-sigIn[-1]-sigIn[0]) / 6 - 4/6*cc[2][2]);*/
+ cptr[1] = sub(sub(sigin_sr[1], sigin_sr[0]), add(cptr[3], cptr[2]));
+ move16();
+
+ sigOutptr = sigOut;
+ cind = -1;
+ move16();
+ move16(); /* for the move */
+ IF( EQ_32(fin, 12800))
+ {
+ if( EQ_32(fout, 8000))
+ {
+ cind = 0;
+ move16();
+ }
+ if( EQ_32(fout, 16000))
+ {
+ cind = 1;
+ move16();
+ }
+ if( EQ_32(fout, 32000))
+ {
+ cind = 2;
+ move16();
+ }
+ if( EQ_32(fout, 48000))
+ {
+ cind = 3;
+ move16();
+ }
+ }
+ IF( EQ_32(fin, 16000))
+ {
+ if( EQ_32(fout, 12800))
+ {
+ cind = 4;
+ move16();
+ }
+ if( EQ_32(fout, 32000))
+ {
+ cind = 5;
+ move16();
+ }
+ if( EQ_32(fout, 48000))
+ {
+ cind = 6;
+ move16();
+ }
+
+ }
+ ctptr = &(ct2_fx[cind][0]);
+ lg_out = mult_r(shl(lg,2),ctptr[13]);
+ *delayout = ctptr[9];
+ move16();
+
+ if( EQ_16(ctptr[12], 15))
+ {
+ cu = cu15_fx;
+ move16();/*pointer*/
+ }
+
+ if( EQ_16(ctptr[12],4))
+ {
+ cu = cu4_fx;
+ move16();/*pointer*/
+ }
+
+ k2d = sub(ctptr[12], 1); /* shift of index in cu with respect to the next sample (ex 1.25 -> 0.25 ) */
+ fk1 = shl(k2d, 1);
+ k3d = sub(fk1, 1); /* to compurte index in cu with respect to the last sample with - sign (ex 1.25 -> -0.75 ) */
+
+ kk = 0;
+ move16();
+ i = 0;
+ move16();
+
+ lim = sub(lg, ctptr[11]);
+ lim2 = sub(lg, 3);
+ lim3 = ctptr[10];
+ move16();
+ WHILE(LT_16(i, lim2))
+ {
+ if(GE_16(i, lim))
+ {
+ lim3 = sub(ctptr[11], 3); /* last, incomplete period*/
+ }
+ *sigOutptr++ = sigIn[i];
+ move16();
+ FOR(k = 0; k < lim3; k++)
+ {
+ cptr = &(cc[kk][0]);
+ cptr[0] = mult_r(sigin_sr[i+1], 10923);
+ move16();/* sigIn[-1]/3 */
+ cptr[2] = sub(shr(add(sigin_sr[i], sigin_sr[i+2]), 1), sigin_sr[i+1]);
+ move16(); /* (sigIn[-1]+sigIn[1])/2-sigIn[0]; */
+ cptr[3] = sub(mult_r(sub(add(sigin_sr[i], sigin_sr[i+3]), add(sigin_sr[i+1], sigin_sr[i+2])), 5461), mult_r(cptr[2],21845));
+ move16(); /*(sigIn[-1]+sigIn[1]-sigIn[0]-sigIn[1]) / 6 - 4/6*cc[3][2]);*/
+ cptr[1] = sub(sub(sigin_sr[i+2], sigin_sr[i+1]), add(cptr[3], cptr[2]));
+ move16();
+ i = add(i,1);
+
+ i2 = sub(kk, 2);
+ i1 = sub(kk, 1);
+ if( i1 < 0 )
+ {
+ i1 = add(i1, 4);
+ }
+
+ if( i2 < 0 )
+ {
+ i2 = add(i2, 4);
+ }
+ inc = ctptr[8];
+ move16();
+ FOR(k1 = ctptr[k]; k1 < fk1; k1 += inc)
+ {
+ k2 = sub(k1, k2d);
+ k3 = sub(k3d, k1);
+ cptr = &(cc[i2][0]);
+ uptr = &(cu[k1][0]);
+ vv32 = L_mult( 8192, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++); /* Q13*Q(-QSR) -> Q(13-QSR+1) 32 bits*/
+ cptr = &(cc[i1][0]);
+ uptr = &(cu[k2][0]);
+ vv32 = L_mac(vv32, 8192, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++);
+ cptr = &(cc[kk][0]);
+ uptr = &(cu[k3][0]);
+ vv32 = L_mac(vv32, 8192, *cptr++);
+ vv32 = L_msu(vv32, *uptr++, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++);
+ vv32 = L_msu(vv32, *uptr++, *cptr++);
+ vv32 = L_shl(vv32, (QSR+2)); /* Q(13-QSR+1) -> Q16 */
+ *sigOutptr++ = round_fx(vv32); /* Q16 -> Q0*/
+ }
+
+ kk = add(kk, 1);
+ if( EQ_16(kk, 4))
+ {
+ kk = 0;
+ move16();
+ }
+ }
+ }
+
+
+ kk = sub(kk, 1);
+ if( kk < 0 )
+ {
+ kk = 3;
+ move16();
+ }
+
+ if( EQ_16(ctptr[10], 1))
+ {
+ *sigOutptr++ = sigIn[i];
+ move16();
+ }
+
+ FOR(k1 = ctptr[k]; k1 < fk1; k1 += inc)
+ {
+ k2 = sub(k1, k2d);
+
+ cptr = &(cc[kk][0]);
+ uptr = &(cu[k2][0]);
+ vv32 = L_mult( 8192, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++); /* Q13*Q(-QSR) -> Q(13-QSR+1) 32 bits*/
+ vv32 = L_shl(vv32, (QSR+2)); /* Q(13-QSR+1) -> Q16 */
+ *sigOutptr++ = i_mult(round_fx(vv32), 3);
+ move16();/* Q16 -> Q0*/
+ }
+
+ if( LT_16(ctptr[10], 3))
+ {
+ *sigOutptr++ = sigIn[add(i, 1)];
+ move16();
+ }
+
+ FOR( k1 = ctptr[add(k, 1)]; k1 < fk1; k1 += inc )
+ {
+ cptr = &(cc[kk][0]);
+ uptr = &(cu[k1][0]);
+ vv32 = L_mult( 8192, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++);
+ vv32 = L_mac(vv32, *uptr++, *cptr++); /* Q13*Q(-QSR) -> Q(13-QSR+1) 32 bits*/
+ vv32 = L_shl(vv32, (QSR+2)); /* Q(13-QSR+1) -> Q16 */
+ *sigOutptr++ = i_mult(round_fx(vv32), 3);
+ move16();/* Q16 -> Q0*/
+ }
+
+ if( EQ_16(ctptr[10], 1))
+ {
+ *sigOutptr = sigIn[add(i, 2)];
+ move16();
+ }
+ }
+
+ free(sigin_sr_tab);
+
+ return lg_out;
+}
+
+/*====================================================================*/
+/* FUNCTION : Decimate_allpass_steep_fx1 () */
+/*-------------------------------------------------------------------*/
+/* PURPOSE : decimation by a factor 2 */
+/*-------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* _ (const Word16 *) in_fx : input speech, Q0 */
+/* _ (Word16 []) state_fx: Stateinfo, Q0 */
+/* Size: 2*ALLPASSSECTIONS_STEEP+1 */
+/* _ (Word16) N: Number of Input samples */
+/* _ (Word16 []) out_fx :Output arry of size N/2 Q0 */
+/*-------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16 []) out_fx : output-signal, Q0 */
+/* _ (Word16 []) state_fx:gets updated, Q0 */
+/*-------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/*-------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : _ None. */
+/*===================================================================*/
+
+
+void Decimate_allpass_steep_fx( const Word16 *in_fx,
+ Word16 state_fx[], /* array of size: 2*ALLPASSSECTIONS_STEEP+1 */
+ Word16 N, /* number of input samples */
+ Word16 out_fx[]) /* array of size N/2 */
+{
+
+ Word16 k;
+ Word16 temp[ ALLPASSSECTIONS_STEEP ];
+ Word32 Lacc, Lacc1;
+ Word16 temp1, temp2;
+ Word16 sum = 0;
+ move16();
+
+ /*upper allpass filter chain */
+
+
+ FOR ( k = 0; k < N/2; k++ )
+ {
+
+ Lacc = L_deposit_h( state_fx[0] ); /* Q(16+x) */
+ Lacc = L_mac( Lacc, AP1_STEEP_FX[0], in_fx[2*k] ); /* Q(16+x) */
+ Lacc1 = L_deposit_h( in_fx[2*k] ); /* Q16+Qx */
+ temp1 = extract_h( Lacc ); /* Qx */
+ Lacc1 = L_msu( Lacc1, AP1_STEEP_FX[0], temp1 ); /* Q16+Qx */
+
+ state_fx[0] = extract_h( Lacc1 ); /* Qx */
+ temp[0] = temp1;
+ move16();
+
+ Lacc1 = L_deposit_h( state_fx[1] ); /* Q16+Qx */
+ Lacc1 = ( L_mac( Lacc1, AP1_STEEP_FX[1], temp1 )); /* Q16+Qx */
+
+ temp2 = extract_h( Lacc1 ); /* Qx */
+ Lacc = L_msu( Lacc, AP1_STEEP_FX[1], temp2 ); /* Q16+Qx */
+ state_fx[1] = extract_h(Lacc); /* Qx */
+ temp[1] = temp2;
+ move16();
+
+
+ Lacc = L_deposit_h( state_fx[ ALLPASSSECTIONS_STEEP-1 ] ); /* Q(16+x) */
+ out_fx[ k ] = extract_h( L_mac( Lacc, AP1_STEEP_FX[ ALLPASSSECTIONS_STEEP-1 ], temp2 )); /* Qx format */
+ state_fx[ ALLPASSSECTIONS_STEEP-1 ] = extract_h( L_msu ( Lacc1, AP1_STEEP_FX[ ALLPASSSECTIONS_STEEP-1 ], out_fx[k] )); /* Qx */
+
+ }
+
+ /* lower allpass filter chain */
+
+ Lacc = L_deposit_h( state_fx[ ALLPASSSECTIONS_STEEP ] ); /* Q(16+x) */
+ Lacc = L_mac( Lacc, AP2_STEEP_FX[0], state_fx[2*ALLPASSSECTIONS_STEEP] ); /*Q(16+x) */
+ Lacc1 = L_deposit_h( state_fx[2*ALLPASSSECTIONS_STEEP] ); /* Q(16+x) */
+ temp1 = extract_h( Lacc ); /* Qx */
+ Lacc1 = L_msu( Lacc1, AP2_STEEP_FX[0], temp1 ); /* Q(16+x) */
+
+ state_fx[ ALLPASSSECTIONS_STEEP ] = extract_h( Lacc1 );
+ temp[0] = temp1;
+ move16();
+
+ Lacc1 = L_deposit_h( state_fx[ ALLPASSSECTIONS_STEEP+1 ] ); /* Q(16+x) */
+ Lacc1 = L_mac( Lacc1, AP2_STEEP_FX[1], temp1 ); /* Q(16+x) */
+ temp2 = extract_h( Lacc1 ); /* Qx */
+ temp[1] = temp2;
+ move16();
+ Lacc = L_msu( Lacc, AP2_STEEP_FX[1], temp2 ); /* Q(16+x) */
+ state_fx[ALLPASSSECTIONS_STEEP+1] = extract_h( Lacc ); /* Qx */
+
+
+ Lacc = L_deposit_h( state_fx[2*ALLPASSSECTIONS_STEEP-1] ); /* Q(16+x) */
+ Lacc = L_mac( Lacc, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP-1], temp2 ); /* Q(16+x) temp[ALLPASSSECTIONS_STEEP-1] */
+ temp[2] = extract_h( Lacc ); /* temp[2] in Qx */
+ Lacc1 = L_msu( Lacc1, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP-1], temp[2] ); /* Q(16+x) */
+ state_fx[ 2*ALLPASSSECTIONS_STEEP-1 ] = extract_h( Lacc1 ); /* Qx */
+
+ sum = mult_r( out_fx[0], 16384 ); /* Qx */
+ out_fx[0] = add( sum, mult_r(temp[ALLPASSSECTIONS_STEEP-1], 16384 )); /* Qx */ move16();
+
+
+ FOR ( k = 1; k < N/2; k++)
+ {
+
+
+ Lacc = L_deposit_h( state_fx[ ALLPASSSECTIONS_STEEP ] ); /* Q(16+x) */
+ Lacc = L_mac(Lacc, AP2_STEEP_FX[0], in_fx[2*k-1] ); /* Q(16+x):temp[0] */
+ Lacc1 = L_deposit_h( in_fx[ 2*k-1 ] ); /* Q(16+x) */
+ temp1 = extract_h( Lacc ); /* Qx */
+ Lacc1 = L_msu( Lacc1, AP2_STEEP_FX[0], temp1 ); /* Q(16+x) */
+
+ state_fx[ALLPASSSECTIONS_STEEP] = extract_h( Lacc1 ); /* Qx */
+ temp[0] = temp1;
+ move16();
+
+
+ Lacc1 = L_deposit_h( state_fx[ ALLPASSSECTIONS_STEEP+1 ] ); /* Q(16+x) */
+ Lacc1 = L_mac(Lacc1,AP2_STEEP_FX[1],temp1); /* Q(16+x) */
+ temp2 = extract_h( Lacc1 ); /* Qx */
+ temp[1] = temp2;
+ move16();
+ Lacc = L_msu(Lacc,AP2_STEEP_FX[1],temp2); /* Q(16+x) */
+ state_fx[ALLPASSSECTIONS_STEEP+1]= extract_h(Lacc); /* Qx */
+
+
+ Lacc = L_deposit_h( state_fx[2*ALLPASSSECTIONS_STEEP-1] ); /* Q(16+x) */
+ Lacc = L_mac( Lacc, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP-1], temp[1] ); /* Q(16+x) temp[ALLPASSSECTIONS_STEEP-1] */
+ temp[2] = extract_h( Lacc ); /*temp[2] in Qx */
+ Lacc1 = L_msu( Lacc1, AP2_STEEP_FX[ALLPASSSECTIONS_STEEP-1], temp[2] ); /* Q(16+x) */
+ state_fx[2*ALLPASSSECTIONS_STEEP-1] = extract_h( Lacc1 ); /* Qx */
+
+
+
+ sum = mult_r( out_fx[k], 16384 ); /* Qx */
+ out_fx[k] = add( sum, mult_r( temp[ALLPASSSECTIONS_STEEP-1], 16384 ) );
+ move16(); /* Qx */
+
+ }
+
+ /* z^(-1) */
+
+ state_fx[ 2*ALLPASSSECTIONS_STEEP ] = in_fx[ N-1 ];
+ move16(); /* Qx */
+
+}
+
+
+
+void Interpolate_allpass_steep_fx(const Word16 *in_fx,
+ Word16 state_fx[], /* array of size: 2*ALLPASSSECTIONS_STEEP+1 */
+ Word16 N, /* number of input samples */
+ Word16 out_fx[]) /* array of size 2*N */
+
+
+{
+
+ Word16 k;
+ Word32 Lacc=0, Lacc1=0;
+ Word16 temp1, temp2;
+
+ /*** State in Q0,in_fx Q0, AP1_STEEP in Q15 AP2_STEEP in Q15 OP in Q0 ************/
+ /*upper allpass filter chain */
+
+ FOR (k=0; k 0);
+
+ mem_fx_11 = mem_fx[11];
+ move16();
+ mem_fx_7 = mem_fx[7];
+ move16();
+ mem_fx_3 = mem_fx[3];
+ move16();
+ FOR (i = 0; i < loop_len; i++ )
+ {
+ /* Lower branch */
+ /*Vl0 = mem[8] + filt_coeff[6] * (*in - mem[9]);
+ Vl1 = mem[9] + filt_coeff[7] * (Vl0 - mem[10]);
+ mem[11] = mem[10] + filt_coeff[8] * (Vl1 - mem[11]); */
+ tmp = mult_r(filt_coeff_fx[6], sub(*in++, mem_fx[9]));
+ if (i == 0)
+ {
+ Vl0 = add(mem_fx[8] , tmp);
+ }
+ if (i != 0)
+ {
+ Vl0 = add(*(in-4) , tmp);
+ }
+ Vl1 = add(mem_fx[9] , mult_r(filt_coeff_fx[7], sub(Vl0, mem_fx[10])));
+ mem_fx_11 = add(mem_fx[10], mult_r(filt_coeff_fx[8], sub(Vl1, mem_fx_11)));
+
+ /* mem[8] = *in++;
+ mem[9] = Vl0;
+ mem[10] = Vl1;
+ *out1 = mem[11]; */
+
+ mem_fx[9] = Vl0;
+ move16();
+ mem_fx[10] = Vl1;
+ move16();
+
+ /* Middle branch */
+ /* Vm0 = mem[4] + filt_coeff[3] * (*in - mem[5]);
+ Vm1 = mem[5] + filt_coeff[4] * (Vm0-mem[6]);
+ mem[7] = mem[6] + filt_coeff[5] * (Vm1-mem[7]); */
+ tmp = mult_r(filt_coeff_fx[3], sub(*in++, mem_fx[5]));
+ if (i == 0)
+ {
+ Vm0 = add(mem_fx[4] , tmp);
+ }
+ if (i != 0)
+ {
+ Vm0 = add(*(in-4), tmp);
+ }
+ Vm1 = add(mem_fx[5] , mult_r(filt_coeff_fx[4], sub(Vm0, mem_fx[6])));
+ mem_fx_7 = add(mem_fx[6], mult_r(filt_coeff_fx[5], sub(Vm1, mem_fx_7)));
+
+ mem_fx[5] = Vm0;
+ move16();
+ mem_fx[6] = Vm1;
+ move16();
+ out = add(mem_fx_11, mem_fx_7);
+
+ /* Upper branch */
+ /* Vu0 = mem[0] + filt_coeff[0] * ( *in - mem[1] );
+ Vu1 = mem[1] + filt_coeff[1] * ( Vu0 - mem[2] );
+ mem[3] = mem[2] + filt_coeff[2] * ( Vu1 - mem[3] ); */
+ tmp = mult_r(filt_coeff_fx[0], sub(*in++, mem_fx[1]));
+ if (i == 0)
+ {
+ Vu0 = add(mem_fx[0] , tmp);
+ }
+ if (i != 0)
+ {
+ Vu0 = add(*(in-4), tmp);
+ }
+ Vu1 = add(mem_fx[1] , mult_r(filt_coeff_fx[1], sub(Vu0, mem_fx[2])));
+ mem_fx_3 = add(mem_fx[2] , mult_r(filt_coeff_fx[2], sub(Vu1, mem_fx_3)));
+
+ mem_fx[1] = Vu0;
+ move16();
+ mem_fx[2] = Vu1;
+ move16();
+ *out1++ = add(out, mem_fx_3);
+ move16();
+ }
+ mem_fx[8] = *(in-3);
+ move16();
+ mem_fx[4] = *(in-2);
+ move16();
+ mem_fx[0] = *(in-1);
+ move16();
+ mem_fx[11] = mem_fx_11;
+ move16();
+ mem_fx[7] = mem_fx_7;
+ move16();
+ mem_fx[3] = mem_fx_3;
+ move16();
+
+ Scale_sig(mem_fx, 12, negate(sc));
+ Scale_sig(out_fx, loop_len, negate(sc));
+ Scale_sig(lp_mem_fx, 6, negate(sc));
+ return;
+}
+
+
+/*-------------------------------------------------------------------*
+ * retro_interp4_5_fx()
+ *
+ *
+ *-------------------------------------------------------------------*/
+
+void retro_interp4_5_fx(
+ const Word16 *syn_fx,
+ Word16 *pst_old_syn_fx
+)
+{
+ Word16 *pf5, *pf4;
+ Word16 c;
+
+ /* resample st->pst_old_syn in a reverse way to preserve time-alignment */
+ pf4 = (Word16*) &pst_old_syn_fx[58];
+ pf5 = (Word16*) pst_old_syn_fx;
+ FOR (c=0; c<57; c++)
+ {
+ *pf5++ = pf4[0];
+ move16();
+ /* *pf5++ = 0.2f * pf4[0] + 0.8f * pf4[1]; */
+ *pf5++ = mac_r(L_mult(6554, pf4[0]), 26214, pf4[1]);
+ move16();
+ /* *pf5++ = 0.4f * pf4[1] + 0.6f * pf4[2]; */
+ *pf5++ = mac_r(L_mult(13107, pf4[1]), 19661, pf4[2]);
+ move16();
+ /* *pf5++ = 0.6f * pf4[2] + 0.4f * pf4[3]; */
+ *pf5++ = mac_r(L_mult(19661, pf4[2]), 13107, pf4[3]);
+ move16();
+ /* *pf5++ = 0.8f * pf4[3] + 0.2f * pf4[4]; */
+ *pf5++ = mac_r(L_mult(26214, pf4[3]), 6554, pf4[4]);
+ move16();
+ pf4+=4;
+ }
+ *pf5++ = pf4[0];
+ move16();
+ /* *pf5++ = 0.2f * pf4[0] + 0.8f * pf4[1]; */
+ *pf5++ = mac_r(L_mult(6554, pf4[0]), 26214, pf4[1]);
+ move16();
+ /* *pf5++ = 0.4f * pf4[1] + 0.6f * pf4[2]; */
+ *pf5++ = mac_r(L_mult(13107, pf4[1]), 19661, pf4[2]);
+ move16();
+ /* *pf5++ = 0.6f * pf4[2] + 0.4f * pf4[3]; */
+ *pf5++ = mac_r(L_mult(19661, pf4[2]), 13107, pf4[3]);
+ move16();
+ /* *pf5++ = 0.8f * pf4[3] + 0.2f * syn[0]; */
+ *pf5++ = mac_r(L_mult(26214, pf4[3]), 6554, syn_fx[0]);
+ move16();
+ /* all samples processed: NBPSF_PIT_MAX = 290 = (58*5) */
+
+ return;
+}
+
+
+/*-------------------------------------------------------------------*
+ * retro_interp5_4_fx()
+ *
+ *
+ *-------------------------------------------------------------------*/
+
+void retro_interp5_4_fx( Word16 *pst_old_syn_fx )
+{
+ Word16 *pf5, *pf4;
+ Word16 c;
+
+ /* resample st->pst_old_syn in a reverse way to preserve time-alignment */
+ pf4 = (Word16*) &pst_old_syn_fx[NBPSF_PIT_MAX-1];
+ pf5 = pf4;
+ FOR (c=0; c<58; c++)
+ {
+ /* *pf4-- = 0.75f * pf5[0] + 0.25f * pf5[-1]; */
+ *pf4-- = mac_r(L_mult(24576, pf5[0]), 8192, pf5[-1]);
+ move16();
+ /* *pf4-- = 0.50f * pf5[-1] + 0.50f * pf5[-2]; */
+ *pf4-- = mac_r(L_mult(16384, pf5[-1]), 16384, pf5[-2]);
+ move16();
+ /* *pf4-- = 0.25f * pf5[-2] + 0.75f * pf5[-3]; */
+ *pf4-- = mac_r(L_mult(8192, pf5[-2]), 24576, pf5[-3]);
+ move16();
+ *pf4-- = pf5[-4];
+ move16();
+ pf5-=5;
+ }
+ /* all samples processed: NBPSF_PIT_MAX = 290 = (58*5) */
+
+ return;
+}
+
diff --git a/lib_com/mslvq_com_fx.c b/lib_com/mslvq_com_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..473d67a7a34b99b8f353f78e635030bfbb57c8a3
--- /dev/null
+++ b/lib_com/mslvq_com_fx.c
@@ -0,0 +1,850 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "prot_fx.h"
+#include "rom_com_fx.h"
+#include "cnst_fx.h"
+#include "stl.h"
+
+/*-----------------------------------------------------------------*
+ * Local functions
+ *-----------------------------------------------------------------*/
+
+static void make_offset_scale_fx( Word16 j, const Word32 tab_no_cv[], const Word16 no_ld[],
+ Word16 no_scl, Word32 offset_scale[][MAX_NO_SCALES+1]);
+static void init_offset_fx( Word32 offset_scale1[][MAX_NO_SCALES+1], Word32 offset_scale2[][MAX_NO_SCALES+1],
+ Word32 offset_scale1_p[][MAX_NO_SCALES+1], Word32 offset_scale2_p[][MAX_NO_SCALES+1],
+ Word16 no_scales[][2], Word16 no_scales_p[][2]);
+static void decode_comb_fx(Word32 index,Word16 *cv,Word16 idx_lead);
+static void decode_sign_pc1_fx( Word16 *c, Word16 idx_sign, Word16 parity );
+static void put_value_fx(Word16 *cv, Word16 *p, Word16 val, Word16 dim, Word16 no_new_val);
+static void decode_leaders_fx(Word16 index, Word16 idx_lead, Word16 *cv );
+static void idx2c_fx(Word16 n, Word16 *p, Word16 k, Word16 val );
+static void divide_64_32_fx(Word16 *xs,Word32 y, Word32 *result, Word32 *rem);
+static Word16
+decode_indexes_fx(Word16 * index,Word16 no_bits,const Word16 * p_scales, Word16 * p_no_scales,
+ Word32 * p_offset_scale1, Word32 * p_offset_scale2,Word16 * x_lvq,Word16 mode_glb, Word16 *scales);
+static Word32 divide_32_32_fx(Word32 y, Word32 x, Word32 * rem);
+static Word16 divide_16_16_fx(Word16 y, Word16 x, Word16 *rem);
+
+/* used in CNG-LP coding */
+void permute_fx(
+ Word16 *pTmp1, /* i/o: vector whose components are to be permuted */
+ const Word16 *perm /* i : permutation info (indexes that should be interchanged), max two perms */
+)
+{
+ Word16 p1, p2;
+ Word16 tmp;
+
+ p1 = perm[0];
+ move16();
+ p2 = perm[1];
+ move16();
+ tmp = pTmp1[p1];
+ move16();
+ pTmp1[p1] = pTmp1[p2];
+ move16();
+ move16();
+ pTmp1[p2] = tmp;
+ move16();
+ p1 = perm[2];
+ move16();
+
+ IF ( GT_16(p1, -1) )
+ {
+ p2 = perm[3];
+ move16();
+ tmp = pTmp1[p1];
+ move16();
+ pTmp1[p1] = pTmp1[p2];
+ move16();
+ move16();
+ pTmp1[p2] = tmp;
+ move16();
+ }
+
+ return;
+}
+
+
+void init_lvq_fx(
+ Word32 offset_scale1[][MAX_NO_SCALES+1], /* o: lattice truncation index offset for the first LSF subvector - safety net structures*/
+ Word32 offset_scale2[][MAX_NO_SCALES+1], /* o: lattice truncation index offset for the second LSF subvector - safety net structures*/
+ Word32 offset_scale1_p[][MAX_NO_SCALES+1], /* o: lattice truncation index offset for the first LSF subvector - predictive structures*/
+ Word32 offset_scale2_p[][MAX_NO_SCALES+1], /* o: lattice truncation index offset for the second LSF subvector - predictive structures*/
+ Word16 no_scales[][2], /* o: number of truncations for each LSF subvector at each MSLVQ structure - safety net */
+ Word16 no_scales_p[][2] /* o: number of truncations for each LSF subvector at each MSLVQ structure - predictive */
+)
+{
+ Word16 i, j;
+ /* safety-net mode */
+ FOR(i=0; i0))
+ {
+ j++;
+ }
+ no_scales[i][0] = j;
+ move16();
+ j = MAX_NO_SCALES;
+ move16();
+ test();
+ WHILE ((LT_16(j,shl(MAX_NO_SCALES,1)))&&(no_lead_fx[i][j]>0))
+ {
+ j++;
+ }
+ no_scales[i][1] = sub(j, MAX_NO_SCALES);
+ move16();
+ }
+ /* predictive mode */
+ FOR(i=0; i0))
+ {
+ j++;
+ }
+ no_scales_p[i][0] = j;
+ move16();
+ j = MAX_NO_SCALES;
+ move16();
+ WHILE ((LT_16(j, shl(MAX_NO_SCALES,1)))&&(no_lead_p_fx[i][j]>0))
+ {
+ j++;
+ }
+ no_scales_p[i][1] = sub(j,MAX_NO_SCALES);
+ move16();
+ }
+ /* index offsets for each truncation */
+ init_offset_fx( offset_scale1, offset_scale2, offset_scale1_p, offset_scale2_p, no_scales, no_scales_p );
+}
+
+/* make_offset_scale_fx() - calculates scale offset values for a particular MSLVQ structure */
+static
+void make_offset_scale_fx(
+ Word16 j, /* i: MSLVQ structure index */
+ const Word32 tab_no_cv[], /* i: cummulated number of codevectors in each leader class */
+ const Word16 no_ld[], /* i: number of leaders in each truncation for the MSLVQ structure j*/
+ Word16 no_scl, /* i: number of truncations in the MSLVQ structure j */
+ Word32 offset_scale[][MAX_NO_SCALES+1]/* o: offset values */
+)
+{
+ Word16 i;
+
+ offset_scale[j][0] = L_deposit_l(1);
+ FOR( i=1; i<=no_scl; i++ )
+ {
+ offset_scale[j][i] = L_add(offset_scale[j][sub(i,1)], tab_no_cv[no_ld[sub(i,1)]]);
+ move32();
+ }
+
+ return;
+}
+
+void init_offset_fx(
+ Word32 offset_scale1[][MAX_NO_SCALES+1], /* o: lattice truncation index offset for the first LSF subvector - safety net structures*/
+ Word32 offset_scale2[][MAX_NO_SCALES+1], /* o: lattice truncation index offset for the second LSF subvector - safety net structures*/
+ Word32 offset_scale1_p[][MAX_NO_SCALES+1],/* o: lattice truncation index offset for the first LSF subvector - predictive structures*/
+ Word32 offset_scale2_p[][MAX_NO_SCALES+1],/* o: lattice truncation index offset for the second LSF subvector - predictive structures*/
+ Word16 no_scales[][2], /* i: number of truncations for each LSF subvector at each MSLVQ structure - safety net */
+ Word16 no_scales_p[][2] /* i: number of truncations for each LSF subvector at each MSLVQ structure - predictive */
+)
+{
+ Word16 j;
+ /* safety-net */
+ FOR( j=0; j 0 )
+ {
+ divide_64_32_fx( index, p_offset_scale2[tmp+ p_no_scales[add(shl(mode_glb,1),1)]], &index1, &index2 );
+ }
+ ELSE
+ {
+ index1 = L_deposit_l(index[0]); /* this is for very low bitrates, so there is no loss in truncation */
+ index2 = L_deposit_l(0);
+ }
+ IF ( index1 == 0 )
+ {
+ FOR( i=0; i 0)
+ {
+ /*if (idx_sign % 2) */
+ IF(s_and(idx_sign,1))
+ {
+ c[i] = negate(c[i]);
+ move16();
+ cnt_neg = negate(cnt_neg);
+ move16();
+ }
+ idx_sign = shr(idx_sign,1); /* >>= 1; */
+ }
+ }
+
+ IF ( LT_16(len, LATTICE_DIM))
+ {
+ IF (NE_16(cnt_neg, parity))
+ {
+ c[len] = negate(c[len]);
+ move16();
+ }
+ }
+
+ return;
+}
+
+
+static void decode_leaders_fx(
+ Word16 index, /* i : index to be decoded */
+ Word16 idx_lead, /* i : leader class index */
+ Word16 *cv /* o : decoded codevector Q1*/
+)
+{
+ Word16 i, no_vals_loc, no_vals_last, p[LATTICE_DIM], dim_loc, n_crt;
+ Word16 index1;
+ Word16 val_crt;
+
+ no_vals_loc = no_vals_fx[idx_lead];
+ move16();
+ val_crt = vals_fx[idx_lead][no_vals_loc-1];
+ move16(); /*Q1 */
+ no_vals_last = no_vals_ind_fx[idx_lead][no_vals_loc-1];
+ move16();
+
+ FOR( i=0; i= 0)
+ {
+ result = L_add(result,1);
+ t = L_add(L_tmp, 0);
+ }
+ }
+ *rem = t;
+ move32();
+ }
+ return result;
+}
+
+/* divide_32_32_fx() :Division reminder for Word16 - rem is the reminder of the division between y and x. */
+static Word16 divide_16_16_fx(Word16 y, /* i */
+ Word16 x, /* i */
+ Word16 *rem /* o */
+ )
+{
+ Word16 result, t, tmp;
+ Word16 i, ny, nx, nyx;
+
+
+ IF (LT_32(y, x))
+ {
+ result = 0;
+ move16();
+ *rem = y;
+ move16();
+ }
+ ELSE
+ {
+
+ result = 0;
+ move16();
+ IF (y==0)
+ {
+ ny = 0;
+ move16();
+ }
+ ELSE
+ {
+ ny = sub(15, norm_s(y));
+ }
+ IF (x==0)
+ {
+ nx = 0;
+ move16();
+ }
+ ELSE
+ {
+ nx = sub(15, norm_s(x));
+ }
+
+ nyx = sub(ny,nx);
+
+ t = s_and(shr(y, add(nyx,1)),sub(shl(1,sub(nx,1)),1));
+ FOR(i=0; i<=nyx; i++)
+ {
+ t = add(shl(t,1), s_and(shr(y,sub(nyx,i)),1)); /* L_and(y,L_shl(1, sub(nyx,i)))); */
+ result = shl(result,1);
+ tmp = sub(t,x);
+ IF(tmp >= 0)
+ {
+ result = add(result,1);
+ t = tmp;
+ move16();
+ }
+ }
+ *rem = t;
+ move16();
+ }
+ return result;
+}
+
+static void divide_64_32_fx(
+ Word16 *xs, /* i : denominator as array of two int32 */
+ Word32 y, /* i : nominator on 32 bits */
+ Word32 *result, /* o : integer division result on 32 bits */
+ Word32 *rem /* o : integer division reminder on 32 bits */
+)
+{
+ Word16 nb_x1;
+ Word32 r, x_tmp, x[2], q, q1;
+
+ x[0] = L_add(L_add(L_shl(L_deposit_l(s_and(xs[2],1)),2*LEN_INDICE),L_shl(L_deposit_l(xs[1]), LEN_INDICE)),L_deposit_l(xs[0]));
+ move32();
+ x[1] = L_shr(L_deposit_l(xs[2]),1);
+ move32();
+
+ /*x[0] = (((xs[2])&(1)<<(LEN_INDICE*2)) + (xs[1]<>1; */
+
+ IF (x[1] ==0)
+ {
+ nb_x1 = 0;
+ move16();
+ }
+ ELSE
+ {
+ nb_x1 = sub(31, norm_l(x[1])); /*get_no_bits_fx(x[1]); */
+ }
+ /* take the first 31 bits */
+ IF ( nb_x1 > 0 )
+ {
+ x_tmp = L_add(L_shl(x[1],sub(31,nb_x1)),L_shr(x[0], nb_x1));
+ /* x_tmp = (x[1]<<(32-nb_x1)) + (x[0]>>nb_x1); */
+
+ q = divide_32_32_fx(x_tmp,y, &r); /* q = x_tmp/y, reminder r */
+ r = L_add(L_shl(r, nb_x1), L_and(x[0],L_deposit_l(sub(shl(1,nb_x1),1)))); /* this is the first reminder */
+ /* r = (r<Q27 */
+ L_tmp = L_shr_r(L_tmp,11); /* Q16 */
+ frac = L_Extract_lc(L_tmp,&exp);
+ frac = extract_l(Pow2(14,frac));
+ G[i*5+k] = round_fx(L_shl(L_mult(frac,UVG2CB1[iG2[i]][k]),exp-sc)); /* Q0 */
+ }
+ ELSE IF (EQ_16(i,1))
+ {
+ L_tmp = L_mult(UVG1CB[iG1][i],27213); /* Q(13+13+1)->Q27 */
+ L_tmp = L_shr_r(L_tmp,11); /* Q16 */
+ frac = L_Extract_lc(L_tmp,&exp);
+ frac = extract_l(Pow2(14,frac));
+ G[i*5+k] = round_fx(L_shl(L_mult(frac,UVG2CB2[iG2[i]][k]),exp-sc)); /* Q0 */
+ }
+ }
+ }
+ return Q_gain;
+}
+
+/*===================================================================*/
+/* FUNCTION : generate_nelp_excitation_fx */
+/*-------------------------------------------------------------------*/
+/* PURPOSE : This function computes the random
+ excitation scaled by gain */
+/*-------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+
+/* _ (Word16*) Gains : Gain vector (Q_exc) */
+/* _ (Word16) gain_fac : gain factor (Q14) */
+/*-------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* _ (Word16*) seed : Random seed (Q0) */
+/* _ (Word16*) output : excitation output (Q_exc) */
+/*-------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/* _ None. */
+/*-------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None. */
+/*===================================================================*/
+void generate_nelp_excitation_fx(
+ Word16 *seed, /* i/o: random number seed */
+ Word16 *Gains, /* i : excitation gains Q_exc*/
+ Word16 *output, /* o : excitation output */
+ Word16 gain_fac /* i : gain factor */
+)
+{
+ Word16 i, len, j;
+ Word16 tmp[31], tmp1[31], tmpf, L16;
+ Word16 k1, k2, I[31], tmpi;
+ Word32 L32;
+ Word16 cnt;
+
+ FOR (i=0; i<10; i++)
+ {
+ IF (EQ_16(i,9))
+ {
+ len=31;
+ move16();
+ cnt=8;
+ move16();
+ }
+ ELSE
+ {
+ len=25;
+ move16();
+ cnt=6;
+ move16();
+ }
+
+ FOR (j=0; j
+#include "prot_fx.h"
+
+/********************************/
+/* Helper functions */
+/********************************/
+
+/** Put nBits long encoded value from *pStream into bitstream. Using the function EncodeValue for encoding. */
+static Word16 PutIntoBitstream(Word16 const ** pStream, TEncodeValue EncodeValue, Word16 index, Encoder_State_fx *st_fx, Word16 nBits)
+{
+ Word16 value;
+ Word16 codedValue;
+
+ move16();
+ value = *(*pStream)++;
+ codedValue = EncodeValue(value, index);
+
+ push_next_indice_fx(st_fx, codedValue, nBits);
+
+ return value;
+}
+
+
+/** Get nBits long value from bitstream into *pStream. */
+static Word16 GetFromBitstream(Decoder_State_fx *st, TDecodeValue DecodeValue, Word16 index, Word16 nFixedBits, Word16 ** pStream)
+{
+ Word16 value;
+
+ move16();
+ move16();
+ value = 0;
+
+ IF (DecodeValue != NULL)
+ {
+ DecodeValue(st, index, &value);
+ }
+ ELSE
+ {
+ value = get_next_indice_fx(st, nFixedBits);
+ }
+ move16();
+ *(*pStream)++ = value;
+
+ return value;
+}
+
+static Word16 FixedWidthEncoding(Word16 value, Word16 index)
+{
+ (void)index;
+ return value;
+}
+
+/********************************/
+/* Interface functions */
+/********************************/
+
+void GetParameters(ParamsBitMap const * paramsBitMap, Word16 nArrayLength, void const * pParameter, Word16 ** pStream, Word16 * pnSize, Word16 * pnBits)
+{
+ Word16 index;
+ Word16 iParam, nParams;
+ Word16 value;
+ void const * pSubStruct;
+
+
+ assert((paramsBitMap != NULL) && (nArrayLength > 0) && (pParameter != NULL) && (pStream != NULL) && (pnSize != NULL) && (pnBits != NULL));
+
+ move16();
+ nParams = paramsBitMap->nParams;
+
+ FOR (index = 0; index < nArrayLength; index++)
+ {
+
+ FOR (iParam = 0; iParam < nParams; iParam++)
+ {
+ ParamBitMap const * param;
+
+ move16();
+ param = & paramsBitMap->params[iParam];
+
+ pSubStruct = param->GetParamValue(pParameter, index, &value);
+ /* If a function for encoding/decoding value is defined than it should take care of 0 */
+ IF ( s_or(param->fZeroAllowed != 0, param->EncodeValue != NULL) )
+ {
+ move16();
+ *(*pStream)++ = value;
+ }
+ ELSE
+ {
+ move16();
+ *(*pStream)++ = sub(value, 1);
+ }
+
+ move16();
+ *pnSize = add(*pnSize, 1);
+
+ IF (param->nBits != 0)
+ {
+ move16();
+ *pnBits = add(*pnBits, param->nBits);
+ }
+ ELSE
+ {
+ move16();
+ *pnBits = add(*pnBits, param->GetNumberOfBits(value, index));
+ }
+
+ IF ( s_and(param->pSubParamBitMap != NULL, value > 0) )
+ {
+ const void *pointer;
+
+ move16();
+ pointer = pParameter;
+ if (pSubStruct != NULL)
+ {
+ move16();
+ pointer = pSubStruct;
+ }
+ GetParameters(param->pSubParamBitMap, value, pointer, pStream, pnSize, pnBits);
+ }
+ }
+ }
+
+}
+
+void SetParameters(ParamsBitMap const * paramsBitMap, Word16 nArrayLength, void * pParameter, Word16 const ** pStream, Word16 * pnSize)
+{
+ Word16 index;
+ Word16 iParam, nParams;
+ Word16 value;
+ void * pSubStruct;
+ void * pTmp;
+ assert((paramsBitMap != NULL) && (nArrayLength > 0) && (pParameter != NULL) && (pStream != NULL) && (pnSize != NULL));
+ nParams = paramsBitMap->nParams;
+
+ FOR (index = 0; index < nArrayLength; index++)
+ {
+ FOR (iParam = 0; iParam < nParams; iParam++)
+ {
+ ParamBitMap const *param;
+ /* If a function for encoding/decoding value is defined than it should take care of 0 */
+
+ move16();
+ param = ¶msBitMap->params[iParam];
+
+ move16();
+ value = 1;
+ if ( s_or(param->fZeroAllowed!=0, param->EncodeValue != NULL) )
+ {
+ move16();
+ value = 0;
+ }
+ value = add(value, *(*pStream)++);
+
+ pSubStruct = param->SetParamValue(pParameter, index, value);
+ move16();
+ *pnSize = add(*pnSize, 1);
+
+ IF ( s_and(param->pSubParamBitMap != NULL, value > 0) )
+ {
+ pTmp = pParameter;
+ if(pSubStruct != NULL) pTmp = pSubStruct;
+ SetParameters(param->pSubParamBitMap, value, pTmp, pStream, pnSize);
+ }
+ }
+ }
+
+}
+
+void WriteToBitstream(ParamsBitMap const * paramsBitMap, Word16 nArrayLength, Word16 const ** pStream, Word16 * pnSize, Encoder_State_fx *st, Word16 * pnBits)
+{
+ Word16 index;
+ Word16 iParam, nParams;
+ assert((paramsBitMap != NULL) && (nArrayLength > 0) && (pStream != NULL) && (pnSize != NULL) && (st != NULL) && (pnBits != NULL));
+ nParams = paramsBitMap->nParams;
+
+ FOR (index = 0; index < nArrayLength; index++)
+ {
+
+ FOR (iParam = 0; iParam < nParams; iParam++)
+ {
+ ParamBitMap const *param;
+ Word16 nBits;
+ /* If a function for encoding/decoding value is defined than it should take care of 0 */
+ Word16 fShiftValue;
+ TEncodeValue EncodeValue;
+ Word16 value;
+
+ move16();
+ param = ¶msBitMap->params[iParam];
+
+ move16();
+ nBits = param->nBits;
+ IF (param->nBits == 0)
+ {
+ nBits = param->GetNumberOfBits(**pStream, index);
+ }
+
+ test();
+ test();
+ fShiftValue = s_and(param->fZeroAllowed==0, param->EncodeValue == NULL);
+ move16();
+ EncodeValue = param->EncodeValue;
+ if (param->EncodeValue == NULL)
+ {
+ move16();
+ EncodeValue = &FixedWidthEncoding;
+ }
+ value = PutIntoBitstream(pStream, EncodeValue, index, st, nBits);
+ if (fShiftValue)
+ {
+ value = add(value, 1);
+ }
+
+ move16();
+ *pnSize = add(*pnSize, 1);
+ move16();
+ *pnBits = add(*pnBits, nBits);
+
+ IF ((param->pSubParamBitMap != NULL) && (value > 0))
+ {
+ WriteToBitstream(param->pSubParamBitMap, value, pStream, pnSize, st, pnBits);
+ }
+
+ }
+ }
+}
+
+void ReadFromBitstream(ParamsBitMap const * paramsBitMap, Word16 nArrayLength, Decoder_State_fx *st, Word16 ** pStream, Word16 * pnSize)
+{
+ Word16 index;
+ Word16 iParam, nParams;
+ Word16 fShiftValue;
+ Word16 value;
+ assert((paramsBitMap != NULL) && (nArrayLength > 0) && (pStream != NULL) && (pnSize != NULL) && (st != NULL));
+ move16();
+ nParams = paramsBitMap->nParams;
+
+ FOR (index = 0; index < nArrayLength; index++)
+ {
+
+ FOR (iParam = 0; iParam < nParams; iParam++)
+ {
+ ParamBitMap const * param;
+
+
+ /* If a function for encoding/decoding value is defined than it should take care of 0 */
+ move16();
+ param = & paramsBitMap->params[iParam];
+
+ test();
+ test();
+ fShiftValue = s_and(param->fZeroAllowed==0, param->EncodeValue == NULL);
+ value = GetFromBitstream(st, param->DecodeValue, index, param->nBits, pStream);
+ if (fShiftValue)
+ {
+ move16();
+ value = add(value, 1);
+ }
+
+ IF ((param->pSubParamBitMap != NULL) && (value > 0))
+ {
+
+ ReadFromBitstream(param->pSubParamBitMap, value, st, pStream, pnSize);
+ }
+ }
+ }
+ move16();
+ *pnSize = add(*pnSize, i_mult(nParams, nArrayLength));
+
+}
diff --git a/lib_com/phase_dispersion.c b/lib_com/phase_dispersion.c
new file mode 100644
index 0000000000000000000000000000000000000000..f2a5f67e91703f85fcbe39b2b32684d266d71b27
--- /dev/null
+++ b/lib_com/phase_dispersion.c
@@ -0,0 +1,177 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+
+#include
+#include "options.h" /* EV-VBR compilation switches */
+#include "prot_fx.h"
+#include "basop_util.h"
+#include "stl.h" /* Weighted mops computation related code */
+
+/*-----------------------------------------------------------------------*
+ * phase_dispersion:
+ *
+ * post-processing to enhance noise at low bit rate.
+ *-----------------------------------------------------------------------*/
+
+void phase_dispersion(
+ const Word32 gain_code, /* i : gain of code 15Q16 */
+ const Word16 gain_pit, /* i : gain of pitch Q14 */
+ Word16 code[], /* i/o: code vector */
+ Word16 *code_exp, /* i/o: exponent of code */
+ const Word16 mode, /* i : level, 0=hi, 1=lo, 2=off */
+ Word32 *prev_gain_code, /* i/o: static memory 15Q16 */
+ Word16 prev_gain_pit[], /* i/o: static memory Q14, size=6 */
+ Word16 *prev_state, /* i/o: static memory Q0 */
+ Word16 L_subfr /* i : subframe length [40,64,80]*/
+)
+{
+ Word16 i, j, state, scale2;
+ Word32 x32[2*L_SUBFR];
+ Word16 *code_real, *code_imag;
+ const Word16 *h_real, *h_imag;
+
+
+
+ move16();
+ state = 2;
+
+ if ( LT_16(gain_pit,14746/*0.9f Q14*/))
+ {
+ move16();
+ state = 1;
+ }
+ if ( LT_16(gain_pit, 9830/*0.6f Q14*/))
+ {
+ move16();
+ state = 0;
+ }
+
+ FOR (i=5; i>0; i--)
+ {
+ move16();
+ prev_gain_pit[i] = prev_gain_pit[i-1];
+ }
+ move16();
+ prev_gain_pit[0] = gain_pit;
+
+
+ IF ( GT_32(gain_code, L_add(*prev_gain_code, L_shl(*prev_gain_code,1))))
+ {
+ if (LT_16(state,2))
+ {
+ state = add(state, 1);
+ }
+ }
+ ELSE
+ {
+ j=0;
+ FOR (i=0; i<6; i++)
+ {
+
+ if ( LT_32(prev_gain_pit[i], 9830/*0.6f Q14*/))
+ {
+ j = add(j,1);
+ }
+ }
+
+ if (GT_16(j,2))
+ {
+ move16();
+ state = 0;
+ }
+
+ if ( GT_16(sub(state, *prev_state),1))
+ {
+ state = sub(state,1);
+ }
+ }
+
+ move32();
+ move16();
+ *prev_gain_code = gain_code;
+ *prev_state = state;
+
+ /*-----------------------------------------------------------------*
+ * circular convolution
+ *-----------------------------------------------------------------*/
+
+ state = add(state, mode); /* level of dispersion */
+ j = *code_exp;
+ move16();
+ IF( LT_16(state,2))
+ {
+ FOR(i=0; i 0)
+ {
+ frac = sub(frac,UP_SAMP);
+ x0--;
+ }
+
+ l = add(UP_SAMP-1, frac);
+ FOR (j = T0; j < L_SUBFR+1; j++)
+ {
+ k = l;
+ move16();
+ L_sum = L_mult(x0[0], win[k]);
+ FOR (i = 1; i < 2 * L_INTERPOL2; i++)
+ {
+ /*
+ * Here, additions with UP_SAMP are not counted
+ ki* because, the window could easily be modified
+ * so that the values needed are contiguous.
+ */
+ k += UP_SAMP;
+ L_sum = L_mac(L_sum, x0[i], win[k]); /*Q1 */
+ }
+ L_sum = L_shl(L_sum, 1); /*Q0h */
+
+ excO[j] = round_fx(L_sum);
+
+ x0++;
+ }
+ FOR (i = T0; i < L_SUBFR; i++)
+ {
+ exc[i+i_subfr] = add(exc[i+i_subfr], mult_r(PIT_SHARP_fx, excO[i]));
+ move16();
+ }
+ }
+
+ return;
+
+}
diff --git a/lib_com/preemph_fx.c b/lib_com/preemph_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..b667eeca159b8cbdae843feef33730deec414d95
--- /dev/null
+++ b/lib_com/preemph_fx.c
@@ -0,0 +1,136 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+
+/*-------------------------------------------------------------*
+ * preemph_copy_fx()
+ *
+ * Preemphasis: filtering through 1 - mu z^-1
+ *-------------------------------------------------------------*/
+void preemph_copy_fx(
+ const Word16 x[], /* i : input signal Qx */
+ Word16 y[], /* o : output signal Qx */
+ const Word16 mu, /* i : preemphasis coefficient Q15 */
+ const Word16 lg, /* i : vector size Q0 */
+ Word16 *mem /* i/o: memory (x[-1]) Qx */
+)
+{
+ Word16 i, temp;
+
+ temp = x[lg - 1];
+ move16();
+ FOR (i = sub(lg, 1); i > 0; i--)
+ {
+ y[i] = msu_r(L_deposit_h(x[i]), x[i - 1], mu);
+ move16();
+ }
+ y[0] = msu_r(L_deposit_h(x[0]), *mem, mu);
+ move16();
+
+ *mem = temp;
+ move16();
+}
+
+/*
+ * E_UTIL_f_preemph2
+ *
+ * Parameters:
+ * shift I: scale output
+ * signal I/O: signal Qx/Qx+shift
+ * mu I: preemphasis factor Q15
+ * L I: vector size
+ * mem I/O: memory (x[-1])
+ *
+ * Function:
+ * Filtering through 1 - mu z^-1
+ *
+ * Returns:
+ * void
+ */
+void E_UTIL_f_preemph2(Word16 shift, Word16 *signal, const Word16 mu, const Word16 lg, Word16 *mem)
+{
+ Word16 i, temp;
+ Word32 L_tmp;
+
+ temp = signal[lg - 1];
+ move16();
+
+ FOR (i = sub(lg, 1); i > 0; i--)
+ {
+ L_tmp = L_mult(signal[i], 16384);
+ L_tmp = L_msu0(L_tmp, signal[i - 1], mu);
+ L_tmp = L_shl(L_tmp, add(shift,1));
+ signal[i] = round_fx(L_tmp);
+ }
+
+ L_tmp = L_mult(signal[0], 16384);
+ L_tmp = L_msu0(L_tmp, *mem, mu);
+ L_tmp = L_shl(L_tmp, add(shift,1));
+ signal[0] = round_fx(L_tmp);
+
+ *mem = temp;
+ move16();
+
+ return;
+}
+
+
+Word16 E_UTIL_f_preemph3(Word16 *signal, const Word16 mu, const Word16 lg, Word16 *mem, Word16 bits)
+{
+ Word16 i, QVal, mus, tmp_fixed, Q_new;
+ Word32 L_tmp, L_maxloc;
+
+
+
+ QVal = shl(1, sub(15,bits));
+ mus = shr(mu, bits);
+
+ L_tmp = L_mult(signal[0], QVal);
+ L_tmp = L_msu(L_tmp, *mem, mus);
+ L_maxloc = L_abs(L_tmp);
+
+ FOR (i = 1; i < lg; i++)
+ {
+ L_tmp = L_mult(signal[i], QVal);
+ L_tmp = L_msu(L_tmp, signal[i - 1], mus);
+ L_tmp = L_abs(L_tmp);
+ L_maxloc = L_max(L_tmp, L_maxloc);
+ }
+
+ tmp_fixed = extract_h(L_maxloc);
+
+ Q_new = Q_MAX;
+ move16();
+ IF (tmp_fixed != 0)
+ {
+ Q_new = sub(norm_s(tmp_fixed), bits);
+ Q_new = s_max(Q_new, 0);
+ Q_new = s_min(Q_new, Q_MAX);
+ }
+
+ tmp_fixed = signal[lg - 1];
+ move16();
+
+ FOR (i = sub(lg,1); i > 0; i--)
+ {
+ L_tmp = L_mult(signal[i], QVal);
+ L_tmp = L_msu(L_tmp, signal[i - 1], mus);
+ L_tmp = L_shl(L_tmp, Q_new);
+ signal[i] = round_fx(L_tmp);
+ }
+
+ L_tmp = L_mult(signal[0], QVal);
+ L_tmp = L_msu(L_tmp, *mem, mus);
+ L_tmp = L_shl(L_tmp, Q_new);
+ signal[0] = round_fx(L_tmp);
+
+ *mem = tmp_fixed;
+ move16();
+
+ return Q_new;
+}
+
diff --git a/lib_com/prot_fx.h b/lib_com/prot_fx.h
new file mode 100644
index 0000000000000000000000000000000000000000..ef9867907d52fa96a83ffb9f28e3d5dd9a365105
--- /dev/null
+++ b/lib_com/prot_fx.h
@@ -0,0 +1,11084 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#ifndef PROT_COM_FX_H
+#define PROT_COM_FX_H
+#include
+#include "options.h" /* Compilation switches */
+#include "rom_com_fx.h" /* Compilation switches */
+#include "typedefs.h"
+#include "stat_dec_fx.h"
+#include "stat_enc_fx.h"
+#include "stat_com.h"
+#include "cnst_fx.h"
+#include "basop_util.h"
+#include "complex_basop.h"
+/*----------------------------------------------------------------------------------*
+ * Prototypes of global macros
+ *----------------------------------------------------------------------------------*/
+
+void reset_preecho_dec_fx (
+ Decoder_State_fx *st_fx /* i/o: decoder state structure */
+);
+
+void preecho_sb_fx(
+ const Word32 brate, /* i Q0 : core bit-rate */
+ Word32 *wtda_audio_fx, /* i q_sig32 : imdct signal */
+ Word16 q_sig32, /* i Q value for wtda_audio_fx */
+ Word16 *rec_sig_fx, /* i q_sig16 : reconstructed signal, output of the imdct transform */
+ Word16 q_sig16, /* i Q value for rec_sig_fx and imdct_mem_fx */
+ const Word16 framelength, /* i Q0 : frame length */
+ Word16 *memfilt_lb_fx, /* i/o Q0 : memory */
+ Word32 *mean_prev_hb_fx, /* i/o Q0 : memory */
+ Word16 *smoothmem_fx, /* i/o Q15 : memory */
+ Word32 *mean_prev_fx, /* i/o Q0 : memory */
+ Word32 *mean_prev_nc_fx, /* i/o Q0 : memory */
+ Word16 *wmold_hb_fx, /* i/o Q15 : memory */
+ Word16 *prevflag, /* i/o Q0 : flag */
+ Word16 *pastpre, /* i/o Q0 : flag */
+ const Word16 bwidth /* i Q0 : bandwidth */
+);
+
+void calc_normal_length_fx_32(
+ const Word16 core, /* i : core : Q0 */
+ const Word32 *sp, /* i : input signal : Q12 */
+ const Word16 mode, /* i : input mode : Q0 */
+ const Word16 extl, /* i : extension layer : Q0 */
+ Word16 *L_swb_norm, /* o : normalize length : Q0 */
+ Word16 *prev_L_swb_norm /*i/o : last normalize length : Q0 */
+);
+
+void calc_norm_envelop_fx_32(
+ const Word32 SWB_signal_fx[], /* i : SWB spectrum : Q12 */
+ Word32 *envelope_fx, /* o : normalized envelope : Q16 */
+ const Word16 L_swb_norm, /* i : length of envelope : Q0 */
+ const Word16 SWB_flength, /* i : Length of input/output : Q0 */
+ const Word16 st_offset /* i : offset : Q0 */
+);
+
+void push_indice_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 id, /* i : ID of the indice */
+ UWord16 value, /* i : value of the quantized indice */
+ Word16 nb_bits /* i : number of bits used to quantize the indice */
+);
+
+void push_next_indice_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ UWord16 value, /* i : value of the quantized indice */
+ Word16 nb_bits /* i : number of bits used to quantize the indice */
+);
+
+void push_next_bits_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 bits[], /* i : bit buffer to pack, sequence of single bits */
+ Word16 nb_bits /* i : number of bits to pack */
+);
+void get_NextCoderType_fx(
+ UWord8 *bitsteam, /* i : bitstream */
+ Word16 *next_coder_type /* o : next coder type */
+);
+void evs_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 input_sp[], /* i : input signal */
+ const Word16 n_samples /* i : number of input samples */
+);
+
+void io_ini_enc_fx(
+ const int argc, /* i : command line arguments number */
+ char *argv[], /* i : command line arguments */
+ FILE **f_input, /* o : input signal file */
+ FILE **f_stream, /* o : output bitstream file */
+ FILE **f_rate, /* o : bitrate switching profile (0 if N/A) */
+ FILE **f_bwidth, /* o : bandwidth switching profile (0 if N/A) */
+ FILE **f_rf, /* o : channel aware config profile (0 if N/A) */
+ Word16 *quietMode, /* o : limit printouts */
+ Word16 *noDelayCmp, /* o : turn off delay compensation */
+ Encoder_State_fx *st /* o : state structure */
+);
+
+void read_next_rfparam_fx(
+ Word16* rf_fec_offset, /* o: rf offset */
+ Word16* rf_fec_indicator, /* o: rf FEC indicator */
+ FILE* f_rf /* i: file pointer to read parameters */
+);
+
+void read_next_brate_fx(
+ Word32 *total_brate, /* i/o: total bitrate */
+ const Word32 last_total_brate, /* i : last total bitrate */
+ FILE *f_rate, /* i : bitrate switching profile (0 if N/A) */
+ Word32 input_Fs, /* i : input sampling frequency */
+ Word16 *Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ Word16 *Opt_SC_VBR, /* i/o: SC-VBR flag */
+ Word16 *codec_mode /* i/o: MODE1 or MODE2 */
+);
+
+
+void read_next_bwidth_fx(
+ Word16 *max_bwidth, /* i/o: maximum encoded bandwidth */
+ FILE *f_bwidth, /* i : bandwidth switching profile (0 if N/A) */
+ Word32 *bwidth_profile_cnt, /* i/o: counter of frames for bandwidth switching profile file */
+ Word32 input_Fs /* i : input sampling frequency */
+);
+
+UWord16 get_next_indice_fx( /* o : value of the indice */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 nb_bits /* i : number of bits that were used to quantize the indice */
+);
+
+UWord16 get_next_indice_1_fx( /* o : value of the indice */
+ Decoder_State_fx *st_fx /* i/o: decoder state structure */
+);
+
+void get_next_indice_tmp_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 nb_bits /* i : number of bits that were used to quantize the indice */
+);
+
+
+UWord16 get_indice_fx( /* o : value of the indice */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 pos, /* i : absolute position in the bitstream */
+ Word16 nb_bits /* i : number of bits that were used to quantize the indice */
+);
+
+UWord16 get_indice_1_fx( /* o : value of the indice */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 pos /* i : absolute position in the bitstream */
+);
+
+void reset_indices_enc_fx(
+ Encoder_State_fx *st_fx /* i/o: encoder state structure */
+);
+
+
+void reset_indices_dec_fx(
+ Decoder_State_fx *st_fx /* i/o: decoder state structure */
+);
+
+void write_indices_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ FILE *file /* i : output bitstream file */
+ , UWord8 *pFrame, /* i: byte array with bit packet and byte aligned coded speech data */
+ Word16 pFrame_size /* i: size of the binary encoded access unit [bits] */
+);
+
+Word16 read_indices_fx( /* o : 1 = OK, 0 = something wrong */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ FILE *file, /* i : bitstream file */
+ Word16 rew_flag /* i : rewind flag (rewind file after reading) */
+);
+
+Word16 read_indices_mime( /* o : 1 = reading OK, 0 = problem */
+ Decoder_State_fx *st, /* i/o: decoder state structure */
+ FILE *file, /* i : bitstream file */
+ Word16 rew_flag /* i : rewind flag (rewind file after reading)*/
+);
+
+void indices_to_serial(
+ const Encoder_State_fx *st_fx, /* i: encoder state structure */
+ UWord8 *pFrame, /* o: byte array with bit packet and byte aligned coded speech data */
+ Word16 *pFrame_size /* i: size of the binary encoded access unit [bits] */
+);
+
+void indices_to_serial_generic(
+ const Indice_fx *ind_list, /* i: indices list */
+ const Word16 num_indices, /* i: number of indices to write */
+ UWord8 *pFrame, /* o: byte array with bit packet and byte aligned coded speech data */
+ Word16 *pFrame_size /* i/o: number of bits in the binary encoded access unit [bits] */
+);
+
+void evs_dec_previewFrame(
+ UWord8 *bitstream, /* i : bitstream pointer */
+ Word16 bitstreamSize, /* i : bitstream size */
+ Word16 *partialCopyFrameType, /* o : frame type of the partial copy */
+ Word16 *partialCopyOffset /* o : offset of the partial copy relative to the primary copy */
+);
+
+void read_indices_from_djb_fx(
+ Decoder_State_fx *st, /* i/o: decoder state structure */
+ UWord8 *pt_stream, /* i : bitstream file */
+ Word16 nbits /* i : number of bits */
+ , Word16 isAMRWB_IOmode
+ , Word16 core_mode
+ , Word16 qbit
+ ,Word16 partialframe /* i : partial frame information */
+ ,Word16 next_coder_type /* i : next coder type information */
+);
+
+void reset_rf_indices(
+ Encoder_State_fx *st /* i: state structure - contains partial RF indices */
+);
+
+void getPartialCopyInfo(
+ Decoder_State_fx *st, /* i : decoder state structure */
+ Word16 *coder_type,
+ Word16 *sharpFlag
+);
+
+void get_rfFlag(
+ Decoder_State_fx *st, /* i : decoder state structure */
+ Word16 *rf_flag, /* o : check for the RF flag */
+ Word16 *nBits,
+ Word16 *ind
+);
+
+void get_rfFrameType(
+ Decoder_State_fx *st, /* i : decoder state structure */
+ Word16 *rf_frame_type /* o : RF frame type */
+);
+
+void get_rf_fec_offset(
+ Decoder_State_fx *st, /* i : decoder state structure */
+ Word16 *rf_fec_offset /* o : RF fec offset */
+);
+
+void get_rfTargetBits(
+ Word16 rf_frame_type, /* i : RF frame type */
+ Word16 *rf_target_bits /* o : Number of RF target bits */
+);
+
+
+Word16 BRATE2IDX_fx(Word32 brate);
+Word16 BRATE2IDX16k_fx(Word32 brate);
+
+Word32 BIT_ALLOC_IDX_fx(Word32 brate, Word16 ctype, Word16 sfrm, Word16 tc);
+Word32 BIT_ALLOC_IDX_16KHZ_fx(Word32 brate, Word16 ctype, Word16 sfrm, Word16 tc);
+
+void save_old_syn_fx(
+ const Word16 L_frame, /* i : frame length */
+ const Word16 syn[], /* i : ACELP synthesis */
+ Word16 old_syn[], /* o : old synthesis buffer */
+ Word16 old_syn_mem[], /* i/o: old synthesis buffer memory */
+ const Word16 preemph_fac, /* i : preemphasis factor */
+ Word16 *mem_deemph /* i/o: deemphasis filter memory */
+);
+
+void evs_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o : Decoder state structure */
+ Word16 output_sp[], /* o : output synthesis signal */
+ frameMode_fx frameMode /* i : Decoder frame mode */
+);
+
+Word16 decodeVoip(
+ Decoder_State_fx *st_fx,
+ FILE *f_stream,
+ FILE *f_synth,
+#ifdef SUPPORT_JBM_TRACEFILE
+ const char *jbmTraceFileName,
+#endif
+ const char *jbmFECoffsetFileName, /* : Output file for Optimum FEC offset */
+ const Word16 quietMode
+);
+
+
+void io_ini_dec_fx(
+ const int argc, /* i : command line arguments number */
+ char *argv[], /* i : command line arguments */
+ FILE **f_stream, /* o : input bitstream file */
+ FILE **f_synth, /* o : output synthesis file */
+ Word16 *quietMode, /* o : limited printouts */
+ Word16 *noDelayCmp, /* o : turn off delay compensation */
+ Decoder_State_fx *st_fx, /* o : Decoder static variables structure */
+#ifdef SUPPORT_JBM_TRACEFILE
+ char **jbmTraceFileName, /* o : VOIP tracefilename */
+#endif
+ char **jbmFECoffsetFileName /* o : Output file for Optimum FEC offset */
+);
+Word16 deindex_lvq_cng_fx(
+ Word16 *index, /* i : index to be decoded, as an array of 3 short */
+ Word16 *x_lvq, /* o : decoded codevector Q9*/
+ Word16 idx_cv, /* i : relative mode_lvq, wrt START_CNG */
+ Word16 no_bits, /* i : number of bits for lattice */
+ Word32 * p_offset_scale1,
+ Word32 * p_offset_scale2,
+ Word16 * p_no_scales
+);
+
+void CNG_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: State structure */
+ const Word16 L_frame, /* i : length of the frame Q0 */
+ Word16 Aq[], /* o : LP coefficients Q12 */
+ const Word32 core_brate, /* i : core bitrate Q0 */
+ Word16 *lsp_new, /* i/o: current frame LSPs Q15 */
+ Word16 *lsf_new, /* i/o: current frame LSFs Qlog2(2.56) */
+ Word16 *allow_cn_step /* o : allow CN step Q0 */
+ ,Word16 *sid_bw /* o : 0-NB/WB, 1-SWB SID */
+ ,Word32 *q_env
+);
+
+void swb_CNG_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: State structure */
+ const Word16 *synth_fx, /* i : ACELP core synthesis at 32kHz */
+ Word16 *shb_synth_fx, /* o : high-band CNG synthesis */
+ const Word16 sid_bw, /* i : 0-NB/WB, 1-SWB SID */
+ const Word16 Qsyn /* i : Q value of ACELP core synthesis */
+);
+
+void CNG_reset_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ LPD_state *mem, /* i/o: acelp memories */
+ Word16 *pitch_buf, /* o : floating pitch for each subframe */
+ Word16 *voice_factors /* o : voicing factors */
+ ,Word16 VBR_cng_reset_flag
+);
+
+void CNG_reset_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 *pitch_buf, /* o : floating pitch for each subframe */
+ Word16 *voice_factors /* o : voicing factors */
+);
+
+void CNG_exc_fx(
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 L_frame, /* i : length of the frame */
+ Word32 *Enew, /* i/o: decoded SID energy Q6 */
+ Word16 *seed, /* i/o: random generator seed */
+ Word16 exc[], /* o : current non-enhanced excitation Q_new */
+ Word16 exc2[], /* o : current enhanced excitation Q_new */
+ Word32 *lp_ener, /* i/o: LP filtered E */
+ const Word32 last_core_brate, /* i : previous frame core bitrate */
+ Word16 *first_CNG, /* i/o: first CNG frame flag for energy init. */
+ Word16 *cng_ener_seed, /* i/o: random generator seed for CNG energy */
+ Word16 bwe_exc[], /* o : excitation for SWB TBE */
+ const Word16 allow_cn_step, /* i : allow CN step */
+ Word16 *last_allow_cn_step, /* i/o: last allow step */
+ const Word16 OldQ_exc, /* i : Old excitation scaling */
+ const Word16 Q_exc, /* i : excitation scaling */
+ const Word16 num_ho /* i : number of selected hangover frames */
+ ,Word32 q_env[]
+ ,Word32 *lp_env
+ ,Word32 *old_env
+ ,Word16 *exc_mem
+ ,Word16 *exc_mem1
+ ,Word16 *sid_bw
+ ,Word16 *cng_ener_seed1
+ ,Word16 exc3[]
+ ,Word16 Opt_AMR_WB
+);
+
+void CNG_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: State structure */
+ const Word16 L_frame, /* i : length of the frame Q0 */
+ Word16 Aq[], /* o : LP coefficients Q12 */
+ const Word16 *speech, /* i : pointer to current frame input speech buffer Q_new */
+ Word32 L_enr, /* i : residual energy from Levinson-Durbin Q6 */
+ Word16 *lsp_new, /* i/o: current frame ISPs Q15 */
+ Word16 *lsf_new, /* i/o: current frame ISFs Qlog2(2.56) */
+ Word16 *allow_cn_step, /* o : allow CN step Q0 */
+ Word16 burst_ho_cnt, /* i : hangover frames at end of speech burst Q0 */
+ Word16 Q_new /* i : Q value of speech */
+ ,Word32 *q_env
+ ,Word16 *sid_bw
+ ,Word16 *exc_mem2
+);
+
+void swb_CNG_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: State structure */
+ const Word16 *shb_speech_fx, /* i : SHB target signal (6-14kHz) at 16kHz */
+ const Word16 *syn_12k8_16k_fx /* i : ACELP core synthesis at 12.8kHz or 16kHz */
+);
+
+void cng_params_upd_fx(
+ const Word16 lsp_new[], /* i : LSP parameters Q15 */
+ const Word16 exc2[], /* i : current enhanced excitation Q_exc */
+ const Word16 L_frame, /* i : frame length Q0 */
+ Word16 *ho_circ_ptr, /* i/o: pointer for CNG averaging buffers Q0 */
+ Word32 ho_ener_circ[], /* o : energy buffer for CNG averaging Q6 */
+ Word16 *ho_circ_size, /* i/o: size of DTX hangover history buffer for averaging Q0 */
+ Word16 ho_lsp_circ[], /* o : old LSP buffer for CNG averaging Q15 */
+ const Word16 Q_exc, /* i : Q value of excitation */
+ const Word16 enc_dec_flag, /* i : Flag indicating encoder or decoder (ENC,DEC) */
+ Word32 ho_env_circ[], /* i/o: Envelope buffer */
+ Word16 *cng_buf_cnt, /* i/o: Counter of postponed FFT-processing instances */
+ Word16 cng_exc2_buf[], /* i/o: Excitation buffer Q_exc */
+ Word16 cng_Qexc_buf[], /* i/o: Q_exc buffer Q0 */
+ Word32 cng_brate_buf[], /* i/o: last_active_brate buffer Q0 */
+ const Word32 last_active_brate /* i : Last active bit rate Q0 */
+);
+
+void cng_params_postupd_fx(
+ const Word16 ho_circ_ptr, /* i : pointer for CNG averaging buffers Q0 */
+ Word16 *cng_buf_cnt, /* i/o: counter for CNG store buffers Q0 */
+ const Word16 *const cng_exc2_buf, /* i : Excitation buffer Q_exc */
+ const Word16 *const cng_Qexc_buf, /* i : Q_exc buffer Q0 */
+ const Word32 *const cng_brate_buf, /* i : bit rate buffer Q0 */
+ Word32 ho_env_circ[] /* i/o: Envelope buffer */
+);
+Word32 get_delay_fx( /* o : delay value in ms */
+ const Word16 what_delay, /* i : what delay? (ENC or DEC) */
+ const Word32 io_fs /* i : input/output sampling frequency */
+);
+
+
+void signalling_enc_fx(
+ Encoder_State_fx *st_fx, /* i : encoder state structure */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 sharpFlag /* i : formant sharpening flag */
+);
+
+Word16 signalling_mode1_tcx20_enc(
+ Encoder_State_fx *st, /* i : encoder state structure */
+ Word16 push
+);
+
+void signalling_enc_rf(
+ Encoder_State_fx *st /* i : encoder state structure */
+);
+
+void decision_matrix_core_dec(
+ Decoder_State_fx *st /* i/o: decoder state structure */
+);
+
+void decision_matrix_enc_fx(
+ Encoder_State_fx *st_fx, /* i : encoder state structure */
+ const Word16 sp_aud_decision1, /* i : 1st stage speech/music classification */
+ const Word16 sp_aud_decision2, /* i : 2nd stage speech/music classification */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 vad_flag,
+ Word16 *hq_core_type /* o : HQ core_fx type */
+);
+
+void decision_matrix_dec_fx(
+ Decoder_State_fx *st, /* i/o: decoder state structure */
+ Word16 *coder_type, /* o : coder type */
+ Word16 *sharpFlag, /* o : formant sharpening flag */
+ Word16 *hq_core_type, /* o : HQ core type */
+ Word16 *core_switching_flag /* o : ACELP->HQ switching frame flag */
+);
+
+void init_gp_clip_fx(
+ Word16 mem[] /* o : memory of gain of pitch clipping algorithm */
+);
+
+void gp_clip_test_isf_fx(
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 isf[], /* i : isf values (in frequency domain) */
+ Word16 mem[], /* i/o: memory of gain of pitch clipping algorithm */
+ const Word16 Opt_AMR_WB /* i : flag indicating AMR-WB IO mode */
+);
+
+void pitch_ol_init_fx(
+ Word16 *old_thres, /* o : threshold for reinforcement of past pitch influence */
+ Word16 *old_pitch, /* o : pitch of the 2nd half-frame of previous frame */
+ Word16 *delta_pit, /* o : pitch evolution extrapolation */
+ Word16 *old_corr /* o : correlation */
+);
+
+void noise_est_down_fx(
+ const Word32 fr_bands[], /* i : per band input energy (contains 2 vectors) */
+ Word32 bckr[], /* i/o: per band background noise energy estimate */
+ Word32 tmpN[], /* o : temporary noise update */
+ Word32 enr[], /* o : averaged energy over both subframes */
+ const Word16 min_band, /* i : minimum critical band */
+ const Word16 max_band, /* i : maximum critical band */
+ Word16 *totalNoise, /* o : noise estimate over all critical bands */
+ Word16 Etot, /* i : Energy of current frame */
+ Word16 *Etot_last, /* i/o: Energy of last frame Q8 */
+ Word16 *Etot_v_h2, /* i/o: Energy variations of noise frames Q8 */
+ Word16 Q_new,
+ const Word32 e_min /* i : minimum energy scaled Q_new + QSCALE */
+);
+
+void wb_vad_init_fx(
+ Word16 *nb_active_frames, /* o : nb of consecutive active speech frames */
+ Word16 *hangover_cnt,
+ Word16 *lp_speech, /* o : long-term active speech level */
+ Word16 *nb_active_frames_he, /* o : nb of consecutive active speech frames */
+ Word16 *hangover_cnt_he,
+ Word16 *bcg_flux, /* o : background noise fluctuation */
+ Word16 *soft_hangover, /* o : soft hangover counter */
+ Word16 *voiced_burst, /* o : consecutive voiced speech counter */
+ Word16 *bcg_flux_init, /* o : initialization period for noise fluctuation estimation */
+ Word16 *nb_active_frames_he1, /* o : nb of consecutive active speech frames 1 */
+ Word16 *hangover_cnt_he1,
+ Word32 *L_vad_flag_reg_H,
+ Word32 *L_vad_flag_reg_L,
+ Word32 *L_vad_prim_reg,
+ Word16 *vad_flag_cnt_50,
+ Word16 *vad_prim_cnt_16,
+ Word16 *hangover_cnt_dtx,
+ Word16 *hangover_cnt_music
+);
+
+Word16 wb_vad_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 fr_bands[], /* i : per band input energy (contains 2 vectors) Q_new+QSCALE*/
+ Word16 *localVAD,
+ Word16 *noisy_speech_HO, /* o : SC-VBR noisy speech HO flag */
+ Word16 *clean_speech_HO, /* o : SC-VBR clean speech HO flag */
+ Word16 *NB_speech_HO, /* o : SC-VBR NB speech HO flag */
+ Word16 *snr_sum_he, /* o : Output snr_sum as weighted spectral measure */
+ Word16 *localVAD_HE_SAD, /* o : HE_SAD decision without hangovers */
+ Word8 *flag_noisy_speech_snr, /* o : */
+ const Word16 Q_new /* i : scaling factor Q0 */
+);
+
+
+void dtx_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 vad, /* i : vad flag */
+ const Word16 speech[], /* i : Pointer to the speech frame */
+ Word16 Q_speech /* i : Q factor for speech */
+
+);
+
+void dtx_hangover_control_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 lsp_new_fx[M] /* i : current frame LSPs */
+);
+
+Word16 dtx_hangover_addition_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 localVAD, /* i Q0 */
+ const Word16 vad_flag, /* i Q0 */
+ const Word16 lp_snr, /* i Q8 */
+ const Word16 cldfb_subtraction, /* i Q0 */
+ Word16 *vad_hover_flag_ptr
+);
+
+void noise_est_init_fx(
+ Word16 *totalNoise, /* o : noise estimate over all critical bands */
+ Word16 *first_noise_updt, /* o : noise update initialization flag */
+ Word32 bckr[], /* o : per band background noise energy estimate */
+ Word32 enrO[], /* o : per band old input energy */
+ Word32 ave_enr[], /* o : per band long-term average energies */
+ Word16 *pitO, /* o : open-loop pitch values from preceed. frame */
+ Word16 *aEn, /* o : noise adaptation hangover counter */
+ Word16 *st_harm_cor_cnt, /* i/o: 1st harm correlation timer */
+ Word16 *bg_cnt, /* i/o: pause burst length counter */
+ Word16 *lt_tn_track, /* Q15 */
+ Word16 *lt_tn_dist, /* Q8 */
+ Word16 *lt_Ellp_dist, /* Etot low lp same domain as *Etot_l_lp, Q8 */
+ Word16 *lt_haco_ev, /* Q15 */
+ Word16 *low_tn_track_cnt /* Q0 */
+ ,Word16 *Etot_st_est, /* Q8: Short term Etot Estimate for variance calc */
+ Word16 *Etot_sq_st_est /* Q2 : Short term Etot^2 Estimate for variance calc */
+
+);
+
+
+void noise_est_pre_fx(
+ const Word16 Etot, /* i : Energy of current frame */
+ const Word16 ini_frame_fx, /* i : Frame number (init) */
+ Word16 *Etot_l, /* i/o: Track energy from below */ /*Q8 */
+ Word16 *Etot_h, /* i/o: Track energy from above */ /*Q8 */
+ Word16 *Etot_l_lp, /* i/o: Smoothed low energy */ /*Q8 */
+ Word16 *Etot_last, /* i/o: Energy of last frame */ /*Q8 */
+ Word16 *Etot_v_h2, /* i/o: Energy variations */ /*Q8*/
+ Word16 *sign_dyn_lp, /* i/o: Smoother signal dynamics */ /*Q8*/
+ Word16 harm_cor_cnt, /* i : correlation counter */
+ Word16 *Etot_lp /* i/o: Smoothed energy */
+);
+
+void Preemph_scaled(
+ Word16 new_speech[], /* i : Speech to scale already on 14 bits*/
+ Word16 *Q_new, /* o : Scaling factor */
+ Word16 *mem_preemph, /* i/o: Preemph memory */
+ Word16 *Q_max, /* i/o: Q_new limitation */
+ const Word16 Preemph_factor, /* i : Preemphasis factor Q15 */
+ const Word16 bits, /* i : Bit to remove from the output to (15-bits)*/
+ const Word16 bit1, /* i : Limit the output scaling to ((15-bits)-bit1) bits */
+ const Word16 L_Q_mem, /* i : Number of old scaling to take into account */
+ const Word16 Lframe, /* i : Frame length */
+ const Word16 last_coder_type, /* i : coder_type */
+ const Word16 Search_scaling /* i : enable the search of a proper scaling factor*/
+);
+Word32 Scale_mem_pre_proc( /* o : Min energy scaled */
+ Word16 ini_frame_fx, /* i : Frame number */
+ Word16 Q_exp, /* i : Diff scaling factor */
+ Word16 *Q_new, /* i/o: Absolute scaling factor */
+ Word16 *old_speech, /* i/o: Speech memory */
+ Word16 *mem_wsp, /* i/o: wsp vector memory */
+ Word32 *enrO, /* i/o: Enr mem */
+ Word32 *bckr, /* i/o: Back ground_fx ener mem */
+ Word32 *ave_enr, /* i/o: Ave_enr mem */
+ Word32 *ave_enr2, /* i/o: Ave_enr2 mem */
+ Word32 *st_fr_bands1, /* i/o: spectrum per critical bands of the previous frame */
+ Word32 *st_fr_bands2, /* i/o: spectrum per critical bands 2 frames ago */
+ Word32 *st_Bin_E_old
+);
+void Scale_mem_enc(
+ Word16 Q_exp, /* i : Diff scaling factor */
+ Word16 *old_speech16k, /* i/o: Speech memory */
+ Word16 *old_exc, /* i/o: excitation memory */
+ Word16 *old_bwe_exc, /* i/o: BWE excitation memory */
+ Word16 *mem_w0, /* i/o: target vector memory */
+ Word16 *mem_syn, /* i/o: synthesis memory */
+ Word16 *mem_syn2, /* i/o: synthesis memory */
+ Word16 *mem_deemp_preQ_fx, /*i/o: deemphasis memory for the high rate celp codec */
+ Word16 *last_exc_dct_in,
+ Word16 *old_input_lp
+);
+
+void SetModeIndex(
+ Encoder_State_fx *st,
+ Word32 total_brate,
+ Word16 bwidth,
+ const Word16 shift
+);
+
+void init_encoder_fx(
+ Encoder_State_fx *st_fx /* i/o: Encoder static variables structure */
+);
+
+void destroy_encoder_fx( Encoder_State_fx *st_fx );
+
+void analysisCldfbEncoder_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 *timeIn,
+ Word32 realBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX],
+ Word32 imagBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX],
+ Word16 realBuffer16[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX],
+ Word16 imagBuffer16[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX],
+ Word32 enerBuffSum[CLDFB_NO_CHANNELS_MAX],
+ Word16 *enerBuffSum_exp,
+ CLDFB_SCALE_FACTOR * scale
+);
+
+void cldfb_save_memory (HANDLE_CLDFB_FILTER_BANK hs); /* i/o: cldfb handle */
+void cldfb_restore_memory (HANDLE_CLDFB_FILTER_BANK hs); /* i/o: cldfb handle */
+void cldfb_reset_memory (HANDLE_CLDFB_FILTER_BANK hs); /* i/o: cldfb handle */
+
+Word16 gp_clip_fx(
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 *voicing, /* i : normalized correlations (from OL pitch) */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 coder_type, /* i : type of coder */
+ const Word16 xn[], /* i : target vector */
+ Word16 mem[], /* i/o: memory of gain of pitch clipping algorithm */
+ const Word16 Q_new /* i : scaling factor */
+);
+
+void init_decoder_fx(
+ Decoder_State_fx *st_fx /* o: Decoder static variables structure */
+);
+
+void destroy_decoder(
+ Decoder_State_fx *st_fx /* o: Decoder static variables structure */
+);
+Word16 Enr_1_Az_fx( /* o : impulse response energy Q3 */
+ const Word16 Aq[], /* i : LP filter coefs Qx based on the fact that Aq[0] == 1.0 */
+ const Word16 len /* i : impulse response length Q0 */
+);
+void FEC_scale_syn_fx(
+ const Word16 L_frame, /* i : length of the frame */
+ Word16 *update_flg, /* o: flag indicating re-synthesis after scaling*/
+ Word16 clas, /* i/o: frame classification */
+ const Word16 last_good, /* i: last good frame classification */
+ Word16 *synth, /* i/o: synthesized speech at Fs = 12k8 Hz */
+ const Word16 *pitch, /* i: pitch values for each subframe */
+ Word32 L_enr_old, /* i: energy at the end of previous frame */
+ Word32 L_enr_q, /* i: transmitted energy for current frame */
+ const Word16 coder_type, /* i: coder type */
+ const Word16 LSF_Q_prediction, /* i : LSF prediction mode */
+ Word16 *scaling_flag, /* i/o: flag to indicate energy control of syn */
+ Word32 *lp_ener_FEC_av, /* i/o: averaged voiced signal energy */
+ Word32 *lp_ener_FEC_max, /* i/o: averaged voiced signal energy */
+ const Word16 bfi, /* i: current frame BFI */
+ const Word32 total_brate, /* i: total bitrate */
+ const Word16 prev_bfi, /* i: previous frame BFI */
+ const Word32 last_core_brate, /* i: previous frame core bitrate */
+ Word16 *exc, /* i/o: excitation signal without enhancement */
+ Word16 *exc2, /* i/o: excitation signal with enhancement */
+ Word16 Aq[], /* i/o: LP filter coefs (can be modified if BR) */
+ Word16 *old_enr_LP, /* i/o: LP filter E of last good voiced frame */
+ const Word16 *mem_tmp, /* i: temp. initial synthesis filter states */
+ Word16 *mem_syn, /* o: initial synthesis filter states */
+ Word16 Q_exc,
+ Word16 Q_syn
+ , Word16 avoid_lpc_burst_on_recovery /* i : if true the excitation energy is limited if LP has big gain */
+ , Word16 force_scaling /* i: force scaling */
+);
+
+void improv_amr_wb_gs_fx(
+ const Word16 clas, /* i : signal frame class */
+ const Word16 coder_type, /* i : coder type */
+ const Word32 core_brate, /* i : bitrate allocated to the core */
+ Word16 *seed_tcx, /* i/o: Seed used for noise generation */
+ Word16 *old_Aq_fx, /* i/o: old LPC filter coefficient */
+ Word16 *mem_syn2_fx, /* i/o: synthesis memory */
+ const Word16 lt_voice_fac_fx, /* i/o: long term voice factor Q15 */
+ const Word16 locattack, /* i : Flag for a detected attack */
+ Word16 *Aq_fx, /* i/o: Decoded LP filter coefficient */
+ Word16 *exc2_fx, /* i/o: Decoded complete excitation */
+ const Word16 Q_exc2, /* i : Exponent of Exc2 */
+ Word16 *mem_tmp_fx, /* i/o: synthesis temporary memory */
+ Word16 *syn_fx, /* o: Decoded synthesis to be updated */
+ const Word16 Q_syn, /* i : Synthesis scaling Q0 */
+ const Word16 *pitch_buf_fx, /* i : Decoded pitch buffer */
+ const Word16 Last_ener_fx, /* i : Last energy (Q8) */
+ const Word16 rate_switching_reset, /* i : rate switching reset flag */
+ const Word16 last_coder_type_fx /* i : Last coder_type */
+);
+
+void FEC_pitch_estim_fx(
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 last_core, /* i : last core */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 clas, /* i : current frame classification */
+ const Word16 last_good, /* i : last good clas information */
+ const Word16 pitch_buf[], /* i : Floating pitch for each subframe */
+ const Word32 old_pitch_buf[], /* i : buffer of old subframe pitch values 15Q16 */
+ Word16 *bfi_pitch, /* i/o: update of the estimated pitch for FEC */
+ Word16 *bfi_pitch_frame, /* o : frame length when pitch was updated */
+ Word16 *upd_cnt, /* i/o: update counter */
+ const Word16 coder_type /* i : coder_type */
+);
+
+Word16 div_s_ss( /* o: result of division (Word16 Q0) */
+ const Word16 n, /* i: numerator (Word16 Q0 */
+ const Word16 d /* i: denominator (Word16 Q0) */
+);
+
+Word16 detect_transient_fx(
+ const Word16 *in_fx, /*Q_new */
+ /*Encoder_State *st, */
+ const Word16 L,
+ const Word16 coder_type, /* i : coder type */
+ Word16 Q_new,
+ Encoder_State_fx *st_fx
+);
+
+Word16 detect_transient_fx32( /* o : transient flag */
+ const Word32* in_fx, /* i : input signal */
+ Encoder_State_fx *st_fx, /* i/o: Encoder state structure */
+ const Word16 L, /* i : length (32 or 48kHz) */
+ const Word16 coder_type /* i : coder type */
+);
+
+void ar_encoder_start_fx( PARCODEC_FX arInst, PBITSTREAM_FX bsInst, Word32 max_bits );
+void ar_encoder_done_fx( PARCODEC_FX arInst );
+void ar_decoder_start_fx( PARCODEC_FX arInst, PBITSTREAM_FX bsInst );
+void ar_decoder_done_fx( PARCODEC_FX arInst );
+
+void srt_vec_ind_fx (const Word32 *linear, Word32 *srt, Word16 *I, Word16 length);
+Word32 ar_div(Word32 num, Word32 denum);
+
+Word16 GetScale_fx( Word16 blen, Word32 bits_fx, Word32 *surplus_fx);
+Word32 encode_position_ari_fx(PARCODEC_FX parenc, Word16* quants, Word16 size, Word32* est_bits_frame_fx);
+Word32 encode_magnitude_usq_fx(ARCODEC_FX* parenc, Word16* magn, Word16 size, Word16 npulses, Word16 nzpos, Word32* est_frame_bits_fx);
+Word32 encode_magnitude_tcq_fx(ARCODEC_FX* parenc, Word16* magn, Word16 size, Word16 npulses, Word16 nzpos, Word32* savedstates, Word32* est_frame_bits_fx);
+Word32 GetISCScale_fx( Word32 *quants_fx, Word16 size, Word32 bits_fx, Word16 *magn_fx, Word32 *qscale_fx, Word32 *surplus_fx, Word16 *pulses, Word32* savedstates, Word32 noTCQ, Word16 *nzpout
+ , Word16 *bcount, Word32 *abuffer, Word16 *mbuffer, Word32 *sbuffer );
+Word32 encode_signs_fx(ARCODEC_FX* parenc, Word16* magn, Word16 size, Word16 npos, Word32* est_frame_bits_fx);
+
+void decode_position_ari_fx(PARCODEC_FX pardec, Word16 size, Word16 npulses, Word16* nz, Word16* position);
+void decode_magnitude_usq_fx(ARCODEC_FX* pardec, Word16 size, Word16 npulses, Word16 nzpos, Word16* positions, Word16* out);
+void decode_mangitude_tcq_fx(ARCODEC_FX* pardec, Word16 size, Word16 npulses, Word16 nzpos, Word16* positions, Word16* out, Word32* surplus_fx);
+void decode_signs_fx(ARCODEC_FX* pardec, Word16 size, Word16* out);
+
+void tcq_core_LR_enc_fx(
+ Encoder_State_fx* st_fx,
+ Word16 inp_vector_fx[],
+ const Word32 coefs_norm_fx[],
+ Word32 coefs_quant_fx[],
+ const Word16 bit_budget, /* number of bits */
+ const Word16 nb_sfm,
+ const Word16 *sfm_start,
+ const Word16 *sfm_end,
+ const Word16 *sfmsize,
+ Word32 *R_fx,
+ Word16 *npulses,
+ Word16 *k_sort,
+ const Word16 *p2a_flags,
+ const Word16 p2a_bands,
+ const Word16 *last_bitalloc,
+ const Word16 input_frame,
+ const Word16 adjustFlag,
+ const Word16 is_transient
+);
+
+void tcq_core_LR_dec_fx(
+ Decoder_State_fx *st_fx,
+ Word16 *inp_vector_fx,
+ const Word16 bit_budget,
+ const Word16 bands,
+ const Word16 *band_start,
+ const Word16 *band_width,
+ Word32 *Rk_fx,
+ Word16 *npulses,
+ Word16 *k_sort,
+ const Word16 *p2a_flags,
+ const Word16 p2a_bands,
+ const Word16 *last_bitalloc,
+ const Word16 input_frame,
+ const Word16 adjustFlag,
+ const Word16 *is_transient
+);
+
+void TCQLSB_fx(
+ Word16 bcount,
+ Word32 *abuffer_fx,
+ Word16 *mbuffer_fx,
+ Word32 *sbuffer_fx,
+ Word16 *dpath
+);
+
+void TCQLSBdec_fx(
+ Word16 *dpath,
+ Word16 *mbuffer,
+ Word16 bcount
+);
+
+void RestoreTCQ_fx(
+ Word16 * magn,
+ Word16 size,
+ Word16 *bcount,
+ Word16 *mbuffer
+);
+
+void RestoreTCQdec_fx(
+ Word16 * magn,
+ Word16 size,
+ Word16 *bcount,
+ Word16 *mbuffer
+);
+
+void InitLSBTCQ_fx(
+ Word16 *bcount
+);
+
+void SaveTCQdata_fx(
+ PARCODEC_FX arInst,
+ Word16 *dpath,
+ Word16 bcount
+);
+
+void LoadTCQdata_fx(
+ PARCODEC_FX arInst,
+ Word16 *dpath,
+ Word16 bcount
+);
+
+void bit_allocation_second_fx(
+ Word32 *Rk,
+ Word32 *Rk_sort,
+ Word16 BANDS,
+ const Word16 *band_width,
+ Word16 *k_sort,
+ Word16 *k_num,
+ const Word16 *p2a_flags,
+ const Word16 p2a_bands,
+ const Word16 *last_bitalloc,
+ const Word16 input_frame
+);
+
+void window_ola_fx(
+ Word32 *ImdctOut,
+ Word16 *auOut,
+ Word16 *Q_sig,
+ Word16 *OldauOut,
+ Word16 *Q_old,
+ const Word16 L,
+ const Word16 right_mode,
+ const Word16 left_mode,
+ const Word16 old_bfi,
+ const Word16 oldHqVoicing,
+ Word16 *oldgapsynth
+);
+
+void tcx_get_windows_mode1(
+ Word16 left_mode, /* i: overlap mode of left window half */
+ Word16 right_mode, /* i: overlap mode of right window half */
+ Word16 *left_win, /* o: left overlap window */
+ Word16 *right_win, /* o: right overlap window */
+ Word16 *left_win_int, /* o: left overlap window */
+ Word16 *right_win_int, /* o: right overlap window */
+ Word16 const L
+);
+
+void sinq_fx(
+ const Word16 tmp, /* i : sinus factor cos(tmp*i+phi) Q15*/
+ const Word16 phi, /* i : sinus phase cos(tmp*i+phi) Q15*/
+ const Word16 N, /* i : size of output */
+ Word16 x[] /* o : output vector Q15*/
+);
+
+Word16 FEC_phase_matching_fx(
+ Decoder_State_fx *st_fx, /* i : Decoder State */
+ Word32 *ImdctOut_fx, /* i : input */
+ Word16 *auOut_fx, /* o : output audio */
+ Word16 *OldauOut_fx,
+ Word16 OldauOut_pha_fx[2][N_LEAD_NB]
+);
+
+void FEC_phase_matching_nextgood_fx(
+ const Word32 *ImdctOut_fx, /* i : input */
+ Word16 *auOut_fx, /* o : output audio */
+ Word16 *OldauOut_fx, /* i/o: audio from previous frame */
+ Word16 OldauOut_pha_fx[2][N_LEAD_NB],
+ Word16 mean_en_high_fx /* Q5 */
+);
+
+void FEC_phase_matching_burst_fx(
+ const Word32 *ImdctOut_fx, /* i : input */
+ Word16 *auOut_fx, /* o : output audio */
+ Word16 *OldauOut_fx, /* i/o: audio from previous frame */
+ Word16 OldauOut_pha_fx[2][N_LEAD_NB],
+ Word16 *prev_oldauOut_fx /* i : OldauOut from previous frame */
+);
+
+void Repetition_smoothing_nextgood_fx(
+ const Word32 *ImdctOut_fx, /* i : input */
+ Word16 *auOut_fx, /* o : output audio */
+ Word32 *OldImdctOut_fx, /* i : input */
+ Word16 *OldauOut_fx, /* i/o: audio from previous frame */
+ Word16 cur_data_use_flag, /* i : current imdct data use flag */
+ Word16 overlap_time
+);
+
+Word16 Repetition_smoothing_fx(
+ const Word32 *ImdctOut_fx, /* i : input */
+ Word16 *auOut_fx, /* o : output audio */
+ Word32 *OldImdctOut_fx, /* i/o: audio from previous frame */
+ Word16 *OldauOut_fx, /* i/o: audio from previous frame */
+ const Word16 L, /* i : length */
+ Word16 *prev_oldauOut_fx, /* i/o: IMDCT output from previous old frame */
+ Word16 overlap_time /* i : overlapping time */
+);
+
+void time_domain_FEC_HQ_fx(
+ Decoder_State_fx *st_fx, /* i : Decoder State */
+ Word32 *wtda_audio_fx, /* i : input */
+ Word16 *out_fx, /* o : output audio */
+ Word16 mean_en_high_fx, /* i : transient flag */
+ const Word16 output_frame,
+ Word16 *Q_synth
+);
+
+void common_overlapping_fx(
+ Word16 *auOut_fx, /* i : Input */
+ Word16 *ImdctOutWin_fx, /* o : Output */
+ Word16 *OldauOut_fx, /* i : Window */
+ Word16 end1, /* i : Decay */
+ Word16 offset1,
+ Word16 start2,
+ Word16 end2,
+ Word16 offset_i2,
+ Word16 offset2
+);
+
+void Smoothing_vector_scaledown_NB_fx(
+ const Word16 OldauOutnoWin_fx[], /* i : Input vector 1 */
+ const Word16 ImdctOutWin_fx[], /* i : Input vector 2 */
+ const Word16 SmoothingWin_fx[], /* i : Smoothing window */
+ Word16 auOut_fx[], /* o : Output vector that contains vector 1 .* vector 2*/
+ const Word16 ol_size /* i : Overlap size */
+);
+
+void Scaledown_fx(
+ Word16 x[], /* i : Input vector */
+ Word16 y[], /* o : Output vector that contains vector 1 .* vector 2*/
+ Word16 scale_v,
+ const Word16 N /* i : Overlap size */
+);
+
+void Smoothing_vector_NB_fx(
+ const Word16 OldauOutnoWin_fx[], /* i : Input vector 1 */
+ const Word16 ImdctOutWin_fx[], /* i : Input vector 2 */
+ const Word16 SmoothingWin_fx[], /* i : Smoothing window */
+ Word16 auOut_fx[], /* o : Output vector that contains vector 1 .* vector 2 */
+ const Word16 ol_size /* i : Overlap size */
+);
+
+void Windowing_1st_NB_fx(
+ Word16 *ImdctOutWin_fx, /* o : Output */
+ const Word32 *ImdctOut_fx, /* i : Input */
+ const Word16 *win_fx, /* i : Window */
+ const Word16 *smoothingWin_fx, /* i : Smoothing Window */
+ Word16 smoothing_flag /* i : 1=Smoothing window, 0=Original window */
+);
+
+void Windowing_2nd_NB_fx(
+ Word16 *ImdctOutWin_fx, /* o : Output */
+ const Word32 *ImdctOut_fx, /* i : Input */
+ const Word16 *win_fx /* i : Window */
+);
+
+void Next_good_after_burst_erasures_fx(
+ const Word32 *ImdctOut_fx,
+ Word16 *auOut_fx,
+ Word16 *OldauOut_fx,
+ const Word16 ol_size
+);
+
+void subband_gain_bits_fx(
+ const Word16 *Rk, /* i : bit allocation per band Q3 */
+ const Word16 N, /* i : number of bands */
+ Word16 *bits, /* o : gain bits per band */
+ const Word16 *sfmsize /* i : Size of bands */
+);
+
+Word16 assign_gain_bits_fx( /* o : Number of assigned gain bits */
+ const Word16 core, /* i : HQ core */
+ const Word16 BANDS, /* i : Number of bands */
+ const Word16 *band_width, /* i : Sub band bandwidth */
+ Word16 *Rk, /* i/o: Bit allocation/Adjusted bit alloc. Q3 */
+ Word16 *gain_bits_array, /* o : Assigned gain bits */
+ Word16 *Rcalc /* o : Bit budget for shape quantizer Q3 */
+);
+
+void apply_gain_fx(
+ const Word16 *ord, /* i : Indices for energy order */
+ const Word16 *band_start, /* i : Sub band start indices */
+ const Word16 *band_end, /* i : Sub band end indices */
+ const Word16 num_sfm, /* i : Number of bands */
+ const Word16 *gains, /* i : Band gain vector Q12 */
+ Word16 *xq /* i/o: Float synthesis / Gain adjusted synth Q15/Q12 */
+);
+
+void fine_gain_pred_fx(
+ const Word16 *sfm_start, /* i : Sub band start indices */
+ const Word16 *sfm_end, /* i : Sub band end indices */
+ const Word16 *sfm_size, /* i : Sub band bandwidths */
+ const Word16 *i_sort, /* i : Energy sorting indices */
+ const Word16 *K, /* i : Number of pulses per band */
+ const Word16 *maxpulse, /* i : Maximum pulse per band */
+ const Word16 *R, /* i : Bits per sub band Q3 */
+ const Word16 num_sfm, /* i : Number of sub bands */
+ Word16 *xq, /* i/o: Quantized vector /quantized vector with finegain adj Q15*/
+ Word16 *y, /* i/o: Quantized vector (int) */
+ Word16 *fg_pred, /* o : Predicted fine gains Q12 */
+ const Word16 core /* i : Core */
+);
+
+void fine_gain_quant_fx(
+ Encoder_State_fx *st_fx,
+ const Word16 *ord, /* i : Indices for energy order */
+ const Word16 num_sfm, /* i : Number of bands */
+ const Word16 *gain_bits, /* i : Gain adjustment bits per sub band */
+ Word16 *fg_pred, /* i/o: Predicted gains / Corrected gains Q12 */
+ const Word16 *gopt /* i : Optimal gains Q12 */
+);
+
+void fine_gain_dec_fx
+(
+ Decoder_State_fx *st,
+ const Word16 *ord, /* i : Indices for energy order */
+ const Word16 num_sfm, /* i : Number of bands */
+ const Word16 *gain_bits, /* i : Gain adjustment bits per sub band */
+ Word16 *fg_pred /* i/o: Predicted gains / Corrected gains */
+);
+
+void get_max_pulses_fx(
+ const Word16 *band_start, /* i : Sub band start indices */
+ const Word16 *band_end, /* i : Sub band end indices */
+ const Word16 *k_sort, /* i : Indices for sorting by energy */
+ const Word16 *npulses, /* i : Pulses per sub band */
+ const Word16 BANDS, /* i : Number of bands */
+ Word16 *inp_vector, /* i/o: Encoded shape vectors (int)*/
+ Word16 *maxpulse /* o : Maximum pulse height per band */
+);
+
+Word16 pvq_core_enc_fx(
+ Encoder_State_fx *st_fx,
+ Word16 coefs_norm[],
+ Word16 coefs_quant[],
+ Word16 *Q_coefs,
+ Word16 bits_tot, /* total number of bits */
+ Word16 nb_sfm,
+ const Word16 *sfm_start,
+ const Word16 *sfm_end,
+ const Word16 *sfmsize,
+ Word16 *R, /* Q3 */
+ Word16 *Rs,
+ Word16 *npulses,
+ Word16 *maxpulse,
+ const Word16 core
+);
+
+void pvq_encode_frame_fx(
+ Encoder_State_fx *st_fx,
+ const Word16 *coefs_norm, /* i : normalized coefficients to encode */
+ Word16 Q_coefs,
+ Word16 *coefs_quant, /* o : quantized coefficients */
+ Word16 *gopt, /* o : optimal shape gains */
+ Word16 *npulses, /* o : number of pulses per band */
+ Word16 *pulse_vector, /* o : non-normalized pulse shapes */
+ const Word16 *sfm_start, /* i : indices of first coefficients in the bands */
+ const Word16 *sfm_end, /* i : indices of last coefficients in the bands */
+ const Word16 *sfmsize, /* i : band sizes */
+ const Word16 nb_sfm, /* i : total number of bands */
+ const Word16 *R, /* i : bitallocation per band */
+ const Word16 pvq_bits, /* i : number of bits avaiable */
+ const Word16 core /* i : core */
+);
+
+
+void encode_energies_fx(
+ Encoder_State_fx *st_fx,
+ const Word16 *coefs,
+ const Word16 Q_coefs,
+ Word16 Np,
+ Word16 *dim_part,
+ Word32 *E_part, /* 32-bit Q15 */
+ Word16 *bits_part,
+ Word16 *g_part, /* Q15 */
+ Word16 qband,
+ Word16 *bits_left,
+ Word32 enr, /* 32-bit Q15 */
+ Word16 dim,
+ const Word16 strict_bits
+);
+
+Word16 pvq_core_dec_fx(
+ Decoder_State_fx *st_fx,
+ const Word16 *sfm_start,
+ const Word16 *sfm_end,
+ const Word16 *sfmsize,
+ Word16 coefs_quant[], /* o : output MDCT */
+ Word16 *Q_coefs,
+ Word16 bits_tot,
+ Word16 nb_sfm,
+ Word16 *R,
+ Word16 *Rs,
+ Word16 *npulses,
+ Word16 *maxpulse,
+ const Word16 core
+);
+
+void pvq_decode_frame_fx(
+ Decoder_State_fx *st_fx,
+ Word16 *coefs_quant, /* o : quantized coefficients */
+ Word16 *npulses, /* o : number of pulses per band */
+ Word16 *pulse_vector, /* o : non-normalized pulse shapes */
+ const Word16 *sfm_start, /* i : indices of first coefficients in the bands */
+ const Word16 *sfm_end, /* i : indices of last coefficients in the bands */
+ const Word16 *sfmsize, /* i : band sizes */
+ const Word16 nb_sfm, /* i : total number of bands */
+ const Word16 *R, /* i : bitallocation per band */
+ const Word16 pvq_bits, /* i : number of bits avaiable */
+ const Word16 core /* i : core */
+);
+
+void decode_energies_fx(
+ Decoder_State_fx *st_fx,
+ Word16 Np,
+ Word16 *dim_part,
+ Word16 *bits_part,
+ Word16 *g_part, /* Q15 */
+ Word16 qband,
+ Word16 *bits_left,
+ Word16 dim,
+ const Word16 strict_bits
+);
+
+Word16 atan2_fx(
+ const Word32,
+ const Word32
+);
+
+void srt_vec_ind16_fx (
+ const Word16 *linear, /* linear input */
+ Word16 *srt, /* sorted output*/
+ Word16 *I, /* index for sorted output */
+ Word16 length
+);
+
+
+PvqEntry_fx mpvq_encode_vec_fx( /* o : leading_sign_index, index, size, k_val */
+ const Word16* vec_in, /* i : signed pulse train */
+ Word16 dim_in, /* i : dimension */
+ Word16 k_val_local /* i : nb unit pulses */
+);
+
+PvqEntry_fx get_size_mpvq_calc_offset_fx( /* o : size, dim, k_val */
+ Word16 dim_in, /* i : dimension */
+ Word16 k_val_in, /* i : nb unit pulses */
+ UWord32* h_mem /* o : offsets */
+);
+
+void mpvq_decode_vec_fx( /* o : void */
+ const PvqEntry_fx* entry, /* i : sign_ind, index, dim, k_val */
+ UWord32* h_mem, /* i : A/U offsets */
+ Word16* vec_out /* o : pulse train */
+);
+
+void rc_enc_init_fx(
+ Encoder_State_fx *st_fx, /* i/o: Encoder state */
+ Word16 tot_bits /* i : Total bit budget */
+);
+
+void rc_encode_fx(
+ Encoder_State_fx *st_fx, /* i/o: Encoder state */
+ UWord32 cum_freq, /* i : Cumulative frequency up to symbol */
+ UWord32 sym_freq, /* i : Symbol probability */
+ UWord32 tot /* i : Total cumulative frequency */
+);
+
+void rc_enc_uniform_fx(
+ Encoder_State_fx *st_fx, /* i/o: Encoder state */
+ UWord32 value, /* i : Value to encode */
+ UWord32 tot /* i : Maximum value */
+);
+
+void rc_enc_bits_fx(
+ Encoder_State_fx *st_fx, /* i/o: Encoder state */
+ UWord32 value, /* i : Value to encode */
+ Word16 bits /* i : Number of bits used */
+);
+
+void rc_enc_finish_fx(
+ Encoder_State_fx *st_fx /* i/o: Encoder state */
+);
+
+Word16 rc_get_bits2_fx( /* o: Number of bits needed */
+ const Word16 N, /* i: Number of bits currently used */
+ const UWord32 range /* i: Range of range coder */
+);
+
+
+void rangeCoderFinalizationFBits_fx(
+ Word16 Brc,
+ UWord32 INTrc,
+ Word16 *FBits
+);
+
+void conservativeL1Norm_fx(
+ Word16 L,
+ Word16 Qvec,
+ Word16 Fcons,
+ Word16 Qavail,
+ Word16 Qreserv,
+ Word16 Dspec,
+ Word16 *Dvec,
+ Word16 *Qspare,
+ Word16 *Qreservplus,
+ Word16 *Dspecplus
+);
+
+void bandBitsAdjustment_fx(
+ Word16 Brc,
+ UWord32 INTrc,
+ Word16 Bavail,
+ Word16 Nbands,
+ Word16 D,
+ Word16 L,
+ Word16 Bband,
+ Word16 Breserv,
+ Word16 *Bband_adj,
+ Word16 *Brem,
+ Word16 *Breservplus
+);
+
+
+UWord32 rc_decode_fx( /* o : Decoded cumulative frequency */
+ Decoder_State_fx *st_fx, /* i/o: Decoder State */
+ UWord32 tot /* i : Total cumulative frequency */
+);
+
+void rc_dec_update_fx(
+ Decoder_State_fx *st_fx, /* i/o: Decoder State */
+ UWord32 cum_freq, /* i : Cumulative frequency */
+ UWord32 sym_freq /* i : Symbol frequency */
+);
+
+UWord32 rc_dec_uniform_fx( /* i : Decoded value */
+ Decoder_State_fx *st_fx, /* i/o: Decoder State */
+ UWord32 tot /* i : Maximum value */
+);
+
+void rc_dec_init_fx(
+ Decoder_State_fx *st_fx, /* i/o: Decoder State */
+ Word16 tot_bits /* i : Total bit budget */
+);
+
+Word32 rc_dec_bits_fx( /* i : Decoded value */
+ Decoder_State_fx *st_fx, /* i/o: Decoder State */
+ Word16 bits /* i : Number of bits */
+);
+
+void rc_dec_finish_fx(
+ Decoder_State_fx *st_fx
+);
+
+UWord32 UL_inverse(
+ const UWord32 UL_val,
+ Word16 *exp
+);
+
+UWord32 UL_div(
+ const UWord32 UL_num,
+ const UWord32 UL_den
+);
+
+void hq_core_enc_fx(
+ Encoder_State_fx *st_fx,
+ const Word16 *audio, /* i : input audio signal Q0 */
+ const Word16 input_frame_orig,/* i : frame length */
+ const Word16 hq_core_type, /* i : HQ core type */
+ const Word16 Voicing_flag
+);
+
+void normalizecoefs_fx(
+ Word32 *coefs, /* i : Input vector (Q12) */
+ const Word16 *ynrm, /* i : quantization indices for norms */
+ const Word16 num_bands, /* i : Number of bands */
+ const Word16 *band_start, /* i : Start of bands */
+ const Word16 *band_end, /* i : End of bands */
+ Word16 *coefs_norm /* o : Normalized output vector (Q12) */
+);
+
+void calc_norm_fx(
+ const Word32 *L_x, /* i : Input vector. Qx */
+ const Word16 qx, /* i : Q value of input */
+ Word16 *norm, /* o : Quantization indices for norms Q0 */
+ Word16 *normlg, /* o : Quantized norms in log2 Q0 */
+ const Word16 start_band, /* i : Indice of band to start coding Q0 */
+ const Word16 num_bands, /* i : Number of bands Q0 */
+ const Word16 *band_len, /* i : Length of bands Q0 */
+ const Word16 *band_start /* i : Start of bands Q0 */
+);
+
+void diff_envelope_coding_fx(
+ const Word16 is_transient, /* i : transient indicator Q0 */
+ const Word16 num_env_bands, /* i : number of envelope bands to code Q0 */
+ const Word16 start_norm, /* i : start of envelope coding Q0 */
+ Word16 *ynrm, /* i/o: quantization indices for norms Q0 */
+ Word16 *normqlg2, /* i/o: quantized norms Q0 */
+ Word16 *difidx /* o : differential code Q0 */
+);
+
+void reordernorm_fx(
+ const Word16 *ynrm, /* i : quantization indices for norms Q0 */
+ const Word16 *normqlg2, /* i : quantized norms Q0 */
+ Word16 *idxbuf, /* o : reordered quantization indices Q0 */
+ Word16 *normbuf, /* o : reordered quantized norms Q0 */
+ const Word16 nb_sfm /* i : number of bands Q0 */
+);
+
+void hq_hr_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure fx */
+ Word32 *t_audio, /* i/o: transform-domain coefficients Q12? */
+ const Word16 length, /* i : length of spectrum Q0 */
+ Word16 *num_bits, /* i : number of available bits Q0 */
+ const Word16 is_transient /* i : transient flag Q0 */
+);
+
+Word16 hq_classifier_enc_fx( /* o : Consumed bits Q0 */
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 length, /* i : Frame length Q0 */
+ const Word32 *coefs, /* i : Spectral coefficients Q12 */
+ const Word16 is_transient, /* i : Transient flag Q0 */
+ Word16 *Npeaks, /* o : Number of identified peaks Q0 */
+ Word16 *peaks, /* o : Peak indices Q0 */
+ Word32 *pe_gains, /* o : Peak gains Q12 */
+ Word32 *nf_gains, /* o : Noise-fill gains Q12 */
+ Word16 *hqswb_clas /* o : HQ class Q0 */
+);
+
+void hvq_classifier_fx(
+ const Word32 *input, /* i : input signal Q12 */
+ Word16 *prev_Npeaks, /* i/o: Peak number memory Q0 */
+ Word16 *prev_peaks, /* i/o: Peak indices memory Q0 */
+ Word16 *hqswb_clas, /* i/o: HQ class Q0 */
+ Word16 *Npeaks, /* o : Number of peaks Q0 */
+ Word16 *peaks, /* o : Peak indices Q0 */
+ const Word32 L_core_brate, /* i : Core bit-rate Q0 */
+ const Word16 last_core, /* i : Last core used Q0 */
+ Word32 *L_nf_gains, /* o : Noisefloor gains Q12 */
+ Word16 *hvq_hangover, /* i/o: Mode-switch hangover Q0 */
+ Word32 *L_pe_gains /* o : peak gains Q12 */
+);
+
+void limit_band_noise_level_calc_fx(
+ const Word16 *wnorm, /* i : reordered norm of sub-vectors */
+ Word16 *limit, /* o : highest band of bit allocation */
+ const Word32 core_brate, /* i : bit rate */
+ Word16 *noise_level /* o : noise level Q15 */
+);
+
+Word16 BitAllocWB_fx( /* o : t Q0*/
+ Word16 *y, /* i : norm of sub-vectors Q0*/
+ Word16 B, /* i : number of available bits Q0*/
+ Word16 N, /* i : number of sub-vectors Q0*/
+ Word16 *R, /* o : bit-allocation indicator Q0*/
+ Word16 *Rsubband_fx /* o : sub-band bit-allocation vector Q3*/
+);
+
+void hq_wb_nf_bwe_fx(
+ const Word16 *coeff_fx, /* i : coded/noisefilled normalized spectrum */
+ const Word16 is_transient,
+ const Word16 prev_bfi, /* i : previous bad frame indicator */
+ const Word32 *L_normq_v,
+ const Word16 num_sfm, /* i : Number of subbands */
+ const Word16 *sfm_start, /* i : Subband start coefficient */
+ const Word16 *sfm_end, /* i : Subband end coefficient */
+ const Word16 *sfmsize, /* i : Subband band width */
+ const Word16 last_sfm, /* i : last coded subband */
+ const Word16 *R, /* i : bit allocation */
+ const Word16 prev_is_transient, /* i : previous transient flag */
+ Word32 *prev_normq_fx, /* i/o: previous norms */
+ Word32 *prev_env_fx, /* i/o: previous noise envelopes */
+ Word16 *bwe_seed, /* i/o: random seed for generating BWE input */
+ Word32 *prev_coeff_out_fx, /* i/o: decoded spectrum in previous frame */
+ Word16 *prev_R, /* i/o: bit allocation info. in previous frame */
+ Word32 *L_coeff_out, /* o : coded/noisefilled spectrum */
+ Word16 *prev_env_Q
+);
+
+void harm_bwe_fine_fx(
+ const Word16 *R, /* i : bit allocation */
+ const Word16 last_sfm, /* i : last coded subband */
+ const Word16 high_sfm, /* i : higher transition band to BWE */
+ const Word16 num_sfm, /* i : total number of bands */
+ const Word16 *norm, /* i : quantization indices for norms */
+ const Word16 *sfm_start, /* i : Subband start coefficient */
+ const Word16 *sfm_end, /* i : Subband end coefficient */
+ Word16 *prev_L_swb_norm, /* i/o: last normalize length */
+ Word16 *coeff, /* i/o: coded/noisefilled normalized spectrum */
+ Word32 *coeff_out, /* o : coded/noisefilled spectrum */
+ Word16 *coeff_fine /* o : BWE fine structure */
+);
+
+void harm_bwe_fx(
+ const Word16 *coeff_fine, /* i : fine structure for BWE */
+ const Word16 *coeff, /* i : coded/noisefilled normalized spectrum */
+ const Word16 num_sfm, /* i : Number of subbands */
+ const Word16 *sfm_start, /* i : Subband start coefficient */
+ const Word16 *sfm_end, /* i : Subband end coefficient */
+ const Word16 last_sfm, /* i : last coded subband */
+ const Word16 *R, /* i : bit allocation */
+ const Word16 prev_hq_mode, /* i : previous hq mode */
+ Word16 *norm, /* i/o: quantization indices for norms */
+ Word16 *noise_level, /* i/o: noise levels for harmonic modes */
+ Word16 *prev_noise_level, /* i/o: noise factor in previous frame */
+ Word16 *bwe_seed, /* i/o: random seed for generating BWE input */
+ Word32 *coeff_out /* o : coded/noisefilled spectrum */
+);
+
+void hq_generic_encoding_fx(
+ const Word32 *coefs_fx, /* i : MDCT coefficients of weighted original */
+ Word16 *hq_generic_fenv_fx, /* i/o: energy of SWB envelope */
+ const Word16 hq_generic_offset, /* i : frequency offset for extracting energy */
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 *hq_generic_exc_clas /* o : bwe excitation class */
+);
+
+void hq_generic_fine_fx(
+ Word16 *coeff, /* i : coded/noisefilled normalized spectrum */
+ const Word16 last_sfm, /* i : Last coded band */
+ const Word16 *sfm_start, /* i : Subband start coefficient */
+ const Word16 *sfm_end, /* i : Subband end coefficient */
+ Word16 *bwe_seed, /* i/o: random seed for generating BWE input */
+ Word16 *coeff_out1 /* o : HQ Generic input */
+);
+
+void hq_bwe_fx(
+ const Word16 HQ_mode, /* i : HQ mode */
+ Word32 *coeff_out1, /* i/o: BWE input & temporary buffer */
+ const Word16 *hq_generic_fenv, /* i : SWB frequency envelopes */
+ Word32 *coeff_out, /* o : SWB signal in MDCT domain */
+ const Word16 hq_generic_offset, /* i : frequency offset for representing hq generic bwe*/
+ Word16 *prev_L_swb_norm, /*i/o : last normalize length */
+ const Word16 hq_generic_exc_clas,/* i : bwe excitation class */
+ const Word16 *sfm_end, /* i : End of bands */
+ const Word16 num_sfm,
+ const Word16 num_env_bands,
+ const Word16 *R
+);
+
+void hq_generic_decoding_fx(
+ const Word16 HQ_mode, /* i : HQ mode */
+ Word32 *coeff_out1_fx, /* i/o: BWE input & temporary buffer */
+ const Word16 *hq_generic_fenv_fx, /* i : SWB frequency envelopes */
+ Word32 *coeff_out_fx, /* o : SWB signal in MDCT domain */
+ const Word16 hq_generic_offset, /* i : frequency offset for representing hq generic*/
+ Word16 *prev_L_swb_norm, /* i/o: last normalize length */
+ const Word16 hq_generic_exc_clas, /* i : bwe excitation class */
+ const Word16 *R
+);
+
+
+void map_hq_generic_fenv_norm_fx(
+ const Word16 hqswb_clas,
+ const Word16 *hq_generic_fenv, /* Q1, frequency-domain BWE envelope */
+ Word16 *ynrm,
+ Word16 *normqlg2,
+ const Word16 num_env_bands,
+ const Word16 nb_sfm,
+ const Word16 hq_generic_offset
+);
+
+Word16 get_nor_delta_hf_fx(
+ Decoder_State_fx *st,
+ Word16 *ynrm,
+ Word16 *Rsubband, /* Q3 */
+ const Word16 num_env_bands,
+ const Word16 nb_sfm,
+ const Word16 core_sfm
+);
+
+Word16 calc_nor_delta_hf_fx(
+ Encoder_State_fx *st,
+ const Word32 *t_audio,
+ Word16 *ynrm,
+ Word16 *Rsubband,
+ const Word16 num_env_bands,
+ const Word16 nb_sfm,
+ const Word16 *sfmsize,
+ const Word16 *sfm_start,
+ const Word16 core_sfm
+);
+
+void HQ_FEC_processing_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word32 *t_audio_q_fx, /* o : MDCT coeffs. (for synthesis) Q12 */
+ Word16 is_transient, /* i : Old flag for transient */
+ Word32 ynrm_values_fx[][MAX_PGF], /* i : Old average Norm values for each group of bands Q12 */
+ Word32 r_p_values_fx[][MAX_ROW], /* i : Computed y-intercept and slope by Regression Q5 */
+ Word16 num_Sb, /* i : Number of sub-band group */
+ Word16 nb_sfm, /* i : Number of sub-band */
+ Word16 *Num_bands_p, /* i : Number of coeffs. for each sub-band */
+ Word16 output_frame, /* i : Frame size */
+ const Word16 *sfm_start, /* i : Start of bands */
+ const Word16 *sfm_end /* i : End of bands */
+);
+
+void HQ_FEC_Mem_update_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word32 *t_audio_q_fx, /*Q12*/
+ Word32 *normq_fx, /*Q14*/
+ Word16 *ynrm,
+ Word16 *Num_bands_p,
+ Word16 is_transient,
+ Word16 hqswb_clas,
+ Word16 c_switching_flag,
+ Word16 nb_sfm,
+ Word16 num_Sb,
+ Word16 *mean_en_high_fx, /*Q5*/
+ Word16 hq_core_type, /* i : normal or low-rate MDCT(HQ) core */
+ Word16 output_frame
+);
+
+Word16 BitAllocF_fx (
+ Word16 *y, /* i : norm of sub-vectors :Q0 */
+ Word32 bit_rate, /* i : bitrate :Q0 */
+ Word16 B, /* i : number of available bits :Q0 */
+ Word16 N, /* i : number of sub-vectors :Q0 */
+ Word16 *R, /* o : bit-allocation indicator :Q0 */
+ Word16 *Rsubband_fx, /* o : sub-band bit-allocation vector :Q3 */
+ const Word16 hqswb_clas, /* i : hq swb class */
+ const Word16 num_env_bands /* i : Number sub bands to be encoded for HQ_SWB_BWE */
+);
+
+void hq_bit_allocation_fx(
+ const Word32 core_brate, /* i : Core bit-rate */
+ const Word16 length, /* i : Frame length */
+ const Word16 hqswb_clas, /* i : HQ class */
+ Word16 *num_bits, /* i/o: Remaining bit budget */
+ const Word16 *normqlg2, /* i : Quantized norms */
+ const Word16 nb_sfm, /* i : Number sub bands to be encoded */
+ const Word16 *sfmsize, /* i : Sub band bandwidths */
+ Word16 *noise_level, /* o : HVQ noise level */
+ Word16 *R, /* o : Bit allocation per sub band */
+ Word16 *Rsubband, /* o : Fractional bit allocation */
+ Word16 *sum, /* o : Sum of allocated shape bits */
+ Word16 *core_sfm, /* o : Last coded band in core */
+ const Word16 num_env_bands /* i : Number sub bands to be encoded for HQ_SWB_BWE */
+);
+
+void hvq_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 num_bits, /* i : Number of available bits */
+ const Word32 core_brate, /* i : Core bit-rate */
+ const Word16 *ynrm, /* i : Envelope coefficients */
+ Word16 *R, /* i/o: Bit allocation/updated bit allocation */
+ Word16 *noise_level, /* o : Noise level in Q15 */
+ Word16 *peak_idx, /* o : Peak position vector */
+ Word16 *Npeaks, /* o : Total number of peaks */
+ Word32 *coefsq_norm, /* o : Output vector in Q12 */
+ const Word16 core
+);
+
+void peak_vq_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word32 *coefs_out, /* o : Output coefficient vector Q12 */
+ const Word16 brate, /* i : Core bitrate */
+ const Word16 num_bits, /* i : Number of bits for HVQ */
+ const Word16 *ynrm, /* i : Envelope coefficients */
+ Word16 *R, /* i/o: Bit allocation/updated bit allocation */
+ Word16 *vq_peak_idx, /* o : Peak position vector */
+ Word16 *Npeaks, /* o : Number of peaks */
+ const Word16 core
+);
+
+void hq_pred_hb_bws_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 *ynrm, /* i : norm quantization index vector */
+ const Word16 length, /* i : frame length */
+ const Word16 hqswb_clas, /* i : HQ SWB class */
+ const Word16 *SWB_fenv /* i : SWB frequency envelopes Q1 */
+);
+void hq_core_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure fx */
+ Word16 synth[], /* o : output synthesis */
+ Word16 *Q_synth, /* o : Q value of synth */
+ const Word16 output_frame, /* i : output frame length */
+ const Word16 hq_core_type, /* i : HQ core type */
+ const Word16 core_switching_flag /* i : ACELP->HQ switching frame flag */
+);
+
+void hq_hr_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure fx */
+ Word32 *L_coefsq, /* o : transform-domain coefficients Q12 */
+ const Word16 length, /* i : frame length Q0 */
+ Word16 num_bits, /* i : number of available bits Q0 */
+ Word16 *ynrm, /* o : norm quantization index vector Q0 */
+ Word16 *is_transient, /* o : transient flag Q0 */
+ Word16 *hqswb_clas, /* o : HQ SWB class Q0 */
+ Word16 *SWB_fenv /* o : SWB frequency envelopes Q1 */
+);
+
+void dequantize_norms_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 start_norm, /* i : First SDE encoded norm */
+ const Word16 num_sfm, /* i : Number of norms */
+ const Word16 is_transient, /* i : Transient flag */
+ Word16 *ynrm, /* o : Decoded norm indices */
+ Word16 *normqlg2 /* o : Log2 of decoded norms */
+);
+
+void huff_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 N, /* i : Number of codewords to decode */
+ const Word16 buffer_len, /* i : Number of bits to read */
+ const Word16 num_lengths, /* i : Number of different huffman codeword lengths */
+ const Word16 *thres, /* i : Threshold of first codeword of each length */
+ const Word16 *offset, /* i : Offset for first codeword */
+ const Word16 *huff_tab, /* i : Huffman table order by codeword lengths */
+ Word16 *index /* o : Decoded index */
+);
+
+Word16 hq_classifier_dec_fx( /* o : Consumed bits Q0 */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 core_brate, /* i : Core bit rate Q0 */
+ const Word16 length, /* i : Frame length Q0 */
+ Word16 *is_transient, /* o : Transient flag Q0 */
+ Word16 *hqswb_clas /* o : HQ class Q0 */
+);
+
+void hq_configure_bfi_fx(
+ Word16 *nb_sfm, /* o : Number of sub bands Q0 */
+ Word16 *num_Sb, /* o : Number of FEC sub bands ? Q0 */
+ Word16 *num_bands_p, /* o : FEC sub bands Q0 */
+ Word16 const **sfmsize, /* o : Subband bandwidths */
+ Word16 const **sfm_start, /* o : Subband start coefficients */
+ Word16 const **sfm_end /* o : Subband end coefficients */
+);
+
+void hq_swb_harmonic_calc_norm_envelop_fx(
+ Word32 *L_SWB_signal, /* i : input signal Q=12*/
+ Word32 *L_envelope, /* o : output envelope Q=12*/
+ Word16 L_swb_norm, /* i : length of normaliztion */
+ Word16 SWB_flength /* i : length of input signal */
+);
+
+Word16 build_nf_codebook_fx( /* o : Number of coefficients in nf codebook */
+ const Word16 flag_32K_env_ho, /* i : Envelope attenuation hangover flag */
+ const Word16 *coeff, /* i : Coded spectral coefficients */
+ const Word16 *sfm_start, /* i : Subband start indices */
+ const Word16 *sfmsize, /* i : Subband widths */
+ const Word16 *sfm_end, /* i : Subband end indices */
+ const Word16 last_sfm, /* i : Last coded band */
+ const Word16 *R, /* i : Per-band bit allocation */
+ Word16 *CodeBook, /* o : Noise-fill codebook */
+ Word16 *CodeBook_mod /* o : Densified noise-fill codebook */
+);
+
+Word16 find_last_band_fx( /* o : index of last band */
+ const Word16 *bitalloc, /* i : bit allocation */
+ const Word16 nb_sfm /* i : number of possibly coded bands */
+);
+
+void apply_noisefill_HQ_fx(
+ const Word16 *R, /* i : bit allocation */
+ const Word16 length, /* i : input frame length */
+ const Word16 flag_32K_env_ho,/* i : envelope stability hangover flag*/
+ const Word32 L_core_brate, /* i : core bit rate */
+ const Word16 last_sfm, /* i : last coded subband */
+ const Word16 *CodeBook, /* i : Noise-fill codebook */
+ const Word16 *CodeBook_mod, /* i : Densified noise-fill codebook */
+ const Word16 cb_size, /* i : Codebook length */
+ const Word16 *sfm_start, /* i : Subband start coefficient */
+ const Word16 *sfm_end, /* i : Subband end coefficient */
+ const Word16 *sfmsize, /* i : Subband band width */
+ Word16 *coeff /* i/o: coded/noisefilled spectrum */
+);
+
+void hvq_bwe_fine_fx(
+ const Word16 last_sfm, /* i : last coded subband */
+ const Word16 num_sfm, /* i : total number of bands */
+ const Word16 *sfm_end, /* i : Subband end coefficient */
+ const Word16 *peak_idx, /* i : Peak index */
+ const Word16 Npeaks, /* i : Number of peaks */
+ Word16 *peak_pos, /* o : Peak positions */
+ Word16 *prev_L_swb_norm, /* i/o: last normalize length */
+ Word32 *L_coeff, /* i/o: coded/noisefilled normalized spectrum */
+ Word16 *bwe_peaks, /* o : Positions of peaks in BWE */
+ Word16 *coeff_fine /* o : HVQ BWE fine structure */
+);
+
+void hq_fold_bwe_fx(
+ const Word16 last_sfm, /* i : last coded subband Q0 */
+ const Word16 *sfm_end, /* i : Subband end coefficient Q0 */
+ const Word16 num_sfm, /* i : Number of subbands Q0 */
+ Word16 *coeff /* i/o: coded/noisefilled normalized spectrum Q12 */
+);
+
+void apply_nf_gain_fx(
+ const Word16 nf_idx, /* i : noise fill gain index Q0 */
+ const Word16 last_sfm, /* i : last coded subband Q0 */
+ const Word16 *R, /* i : bit allocation Q0 */
+ const Word16 *sfm_start, /* i : Subband start coefficient Q0 */
+ const Word16 *sfm_end, /* i : Subband end coefficient Q0 */
+ Word16 *coeff /* i/o: coded/noisefilled normalized spectrum Q12 */
+);
+
+void logqnorm_fx(
+ const Word32 *x, /* i : coefficient vector Qx */
+ const Word16 qx, /* i : Q value of input */
+ Word16 *k, /* o : index Q0 */
+ const Word16 L, /* i : codebook length Q0 */
+ const Word16 N, /* i : sub-vector size Q0 */
+ const Word16 hvq_flag /* i : HVQ flag Q0 */
+);
+
+void logqnorm_2_fx(
+ const Word32 *env_fl, /* o : index */
+ const Word16 L, /* i : codebook length */
+ const Word16 n_env_band, /* i : sub-vector size */
+ const Word16 nb_sfm, /* i : sub-vector size */
+ Word16 *ynrm,
+ Word16 *normqlg2,
+ const Word32 *thren /* i : quantization thresholds */
+);
+
+void hvq_bwe_fx(
+ const Word32 *coeff,
+ const Word16 *coeff_fine, /* i : coded/noisefilled normalized spectrum Qin */
+ const Word16 *sfm_start, /* i : Subband start coefficient Q0 */
+ const Word16 *sfm_end, /* i : Subband end coefficient Q0 */
+ const Word16 *sfm_len, /* i : Subband length Q0 */
+ const Word16 last_sfm, /* i : last coded subband Q0 */
+ const Word16 prev_hq_mode, /* i : previous hq mode Q0 */
+ const Word16 *bwe_peaks, /* i : HVQ bwe peaks Q0 */
+ const Word16 bin_th, /* i : HVQ transition bin Q0 */
+ const Word16 num_sfm, /* i : Number of bands Q0 */
+ const Word32 core_brate, /* i : Core bit-rate Q0 */
+ const Word16 *R, /* i : Bit allocation */
+ Word16 *norm, /* i/o: quantization indices for norms Q0 */
+ Word16 *noise_level, /* i/o: noise levels for harmonic modes Q15 */
+ Word16 *prev_noise_level, /* i/o: noise factor in previous frame Q15 */
+ Word16 *bwe_seed, /* i/o: random seed for generating BWE input Q0 */
+ Word32 *L_coeff_out, /* o : coded/noisefilled spectrum Qout*/
+ const Word16 qin,
+ const Word16 qout
+);
+
+void hvq_concat_bands_fx
+(
+ const Word16 pvq_bands, /* i : Number of bands in concatenated PVQ target */
+ const Word16 *sel_bnds, /* i : Array of selected high bands */
+ const Word16 n_sel_bnds, /* i : Number of selected high bands */
+ Word16 *hvq_band_start, /* i : Band start indices */
+ Word16 *hvq_band_width, /* i : Band widths */
+ Word16 *hvq_band_end /* i : Band end indices */
+);
+
+void noise_mix_fx(
+ const Word16 *coeff_fine, /* i : normalized fine structure spectrum Qin */
+ const Word32 L_E, /* i : normalization factor Q17 */
+ const Word32 L_normq, /* i : quantized norm Q14 */
+ Word16 *seed, /* i/o: random seed Q0 */
+ const Word16 istart, /* i : start coefficient Q0 */
+ const Word16 iend, /* i : end coefficient Q0 */
+ const Word16 noise_level, /* i : noise_level Q0 */
+ Word32 *L_coeff_out, /* o : noisemixed spectrum Qout */
+ const Word16 qin,
+ const Word16 qout
+);
+
+Word16 noise_adjust_fx( /* o : index of noise attenuation Q0 */
+ const Word16 *coeffs_norm, /* i : normalized coefficients Qx */
+ const Word16 qx, /* i : Q value of coeffs_norm */
+ const Word16 *bitalloc, /* i : bit allocation Q0 */
+ const Word16 *sfm_start, /* i : band start Q0 */
+ const Word16 *sfm_end, /* i : band end Q0 */
+ const Word16 core_sfm /* i : index of the end band for core Q0 */
+);
+
+Word16 peak_vq_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 *coefs, /* i : Input coefficient vector Q14 */
+ Word32 *coefs_out, /* o : Quantized output vector Q14 */
+ const Word32 brate, /* i : Core bitrate */
+ const Word16 num_bits, /* i : Number of bits for HVQ */
+ const Word16 vq_peaks, /* i : Number of identified peaks */
+ const Word16 *ynrm, /* i : Envelope coefficients */
+ Word16 *R, /* i/o: Bit allocation/updated bit allocation */
+ Word16 *vq_peak_idx, /* i : Peak index vector */
+ Word32 *nf_gains /* i : Estimated noise floor gains Q14 */
+);
+
+Word16 hvq_enc_fx( /* o : Consumed bits */
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 brate, /* i : Total bit rate */
+ const Word16 hvq_bits, /* i : HVQ bit budget */
+ const Word16 Npeaks, /* i : Number of peaks */
+ const Word16 *ynrm, /* i : Envelope coefficients */
+ Word16 *R, /* i/o: Bit allocation/updated bit allocation */
+ Word16 *peaks, /* i : Peak pos. / Encoded peak pos. */
+ Word32 *nf_gains, /* i/o: Noise fill gains / Quant. nf gains */
+ Word16 *noise_level, /* o : Quantized noise level */
+ const Word32 *pe_gains, /* i : Peak gains */
+ const Word32 *coefs, /* i : spectrum coefficients in Q14 */
+ Word32 *coefs_out /* o : encoded spectrum coefficients in Q14 */
+);
+
+void enforce_zero_for_min_envelope_fx(
+ const Word16 hqswb_clas, /* i : HQ coding mode Q0 */
+ const Word16 *ynrm, /* i : Envelope indices Q0 */
+ Word32 *L_coefsq, /* i/o: Quantized spectrum/zeroed spectrum Q12 */
+ const Word16 nb_sfm, /* i : Number of coded sub bands Q0 */
+ const Word16 *sfm_start, /* i : Sub band start indices Q0 */
+ const Word16 *sfm_end /* i : Sub band end indices Q0 */
+);
+
+void apply_envelope_fx(
+ const Word16 *coeff, /* i : Coded/noisefilled normalized spectrum Q12 */
+ const Word16 *norm, /* i : Envelope */
+ const Word16 *norm_adj, /* i : Envelope adjustment Q15 */
+ const Word16 num_sfm, /* i : Total number of bands */
+ const Word16 last_sfm, /* i : Last coded band */
+ const Word16 HQ_mode, /* i : HQ mode */
+ const Word16 length, /* i : Frame length */
+ const Word16 *sfm_start, /* i : Sub band start indices */
+ const Word16 *sfm_end, /* i : Sub band end indices */
+ Word32 *normq_v, /* o : Envelope with adjustment Q14 */
+ Word32 *coeff_out, /* o : coded/noisefilled spectrum */
+ const Word16 *coeff1, /* i : coded/noisefilled spectrum Q12 */
+ Word32 *coeff_out1 /* o : coded/noisefilled spectrum Q12 */
+);
+
+void bitalloc_fx (
+ Word16 *y, /* i : reordered norm of sub-vectors Q0 */
+ Word16 *idx, /* i : reordered sub-vector indices Q0 */
+ Word16 sum, /* i : number of available bits Q0 */
+ Word16 N, /* i : number of norms Q0 */
+ Word16 K, /* i : maximum number of bits per dimension Q0 */
+ Word16 *r, /* o : bit-allacation vector Q0 */
+ const Word16 *sfmsize, /* i : band length Q0 */
+ const Word16 hqswb_clas /* i : signal classification flag Q0 */
+);
+
+void bitallocsum_fx(
+ Word16 *R, /* i : bit-allocation vector Q0 */
+ const Word16 nb_sfm, /* i : number of sub-vectors Q0 */
+ Word16 *sum, /* o : total number of bits allocated Q0 */
+ Word16 *Rsubband, /* o : rate per subband Q3 */
+ const Word16 v, /* i : bit rate Q0 */
+ const Word16 length, /* i : length of spectrum (32 or 48 kHz samplerate) Q0 */
+ const Word16 *sfmsize /* i : band length Q0 */
+);
+
+void env_adj_fx
+(
+ const Word16 *pulses, /* i : number of pulses per band Q0 */
+ const Word16 length, /* i : length of spectrum Q0 */
+ const Word16 last_sfm, /* i : index of the last band Q0 */
+ Word16 *adj, /* o : adjustment factors for the envelope Q15 */
+ const Word16 env_stab, /* i : envelope stability Q15 */
+ const Word16 *sfmsize /* i : subband sizes Q0 */
+);
+
+Word16 env_stability_fx( /* in Q15 */
+ const Word16 *ynrm, /*i: Norm vector for current frame */
+ const Word16 nb_sfm, /*i: Number of sub-bands */
+ Word16 *mem_norm, /*i/o: Norm vector memory from past frame */
+ Word16 *mem_env_delta /*i/o: Envelope stability memory for smoothing in Q11 */
+);
+
+Word16 env_stab_smo_fx( /* Q0 */
+ Word16 env_stab, /*i : env_stab value Q15 */
+ Word16 *env_stab_state_p, /*i/o: env_stab state probabilities Q15 */
+ Word16 *ho_cnt /*i/o: hangover counter for speech state */
+);
+
+void env_stab_transient_detect_fx(
+ const Word16 is_transient, /* i: Transient flag */
+ const Word16 length, /* i : Length of spectrum (32 or 48 kHz) */
+ const Word16 norm[], /* i : quantization indices for norms */
+ Word16 *no_att_hangover, /* i/o: Frame counter for attenuation hangover (Q0) */
+ Word32 *L_energy_lt, /* i/o: Long-term energy measure for transient detection (Q13) */
+ const Word16 HQ_mode, /* i : HQ coding mode */
+ const Word16 bin_th, /* i : HVQ cross-over frequency bin */
+ const Word32 *L_coeff, /* i : Coded spectral coefficients */
+ const Word16 Qcoeff /* i : Q of coded spectral coefficients */
+);
+
+void hq_configure_fx(
+ const Word16 length, /* i : Frame length Q0 */
+ const Word16 hqswb_clas, /* i : HQ SWB class Q0 */
+ const Word32 core_brate, /* i : Codec bitrate Q0 */
+ Word16 *num_sfm, /* o : Total number of subbands Q0 */
+ Word16 *nb_sfm, /* o : Total number of coded bands Q0 */
+ Word16 *start_norm, /* o : First norm to be SDE encoded Q0 */
+ Word16 *num_env_bands, /* o : Number coded envelope bands Q0 */
+ Word16 *numnrmibits, /* o : Number of bits in fall-back norm encoding Q0 */
+ Word16 *hq_generic_offset, /* o : Freq offset for HQ GENERIC Q0 */
+ Word16 const **sfmsize, /* o : Subband bandwidths Q0 */
+ Word16 const **sfm_start, /* o : Subband start coefficients Q0 */
+ Word16 const **sfm_end /* o : Subband end coefficients Q0 */
+);
+
+Word16 hvq_pvq_bitalloc_fx(
+ Word16 num_bits, /* i/o: Number of available bits (including gain bits) */
+ const Word32 brate, /* i : bitrate */
+ const Word16 bwidth_fx, /* i : Encoded bandwidth */
+ const Word16 *ynrm, /* i : Envelope coefficients */
+ const Word32 manE_peak, /* i : Peak energy mantissa */
+ const Word16 expE_peak, /* i : Peak energy exponent */
+ Word16 *Rk, /* o : bit allocation for concatenated vector */
+ Word16 *R, /* i/o: Global bit allocation */
+ Word16 *sel_bands, /* o : Selected bands for encoding */
+ Word16 *n_sel_bands /* o : No. of selected bands for encoding */
+);
+
+void disf_ns_28b_fx(
+ Word16 *indice,
+ Word16 *isf_q
+);
+
+void isf_enc_amr_wb_fx(
+ Encoder_State_fx *st, /* i/o: state structure */
+ Word16 *isf_new, /* o : quantized ISF vector */
+ Word16 *isp_new, /* i/o: ISP vector to quantize/quantized */
+ Word16 *Aq, /* o : quantized A(z) for 4 subframes */
+ Word16 *stab_fac /* o : ISF stability factor */
+);
+
+void pvq_encode_fx(
+ Encoder_State_fx *st_fx,
+ const Word16 *x, /* i: vector to quantize Q15-3=>Q12 */
+ Word16 *y, /* o: raw pulses (non-scaled short) Q0 */
+ Word16 *xq, /* o: quantized vector Q15 */
+ Word32 *L_xq, /* o: quantized vector Q31 */
+ const Word16 pulses, /* i: number of allocated pulses */
+ const Word16 dim, /* i: Length of vector */
+ const Word16 neg_gain /* i: - Gain use - negative gain in Q15 0 ..1 */
+);
+
+void pvq_decode_fx(
+ Decoder_State_fx *st_fx,
+ Word16 *xq, /* o: decoded vector (Q15) */
+ Word16 *y, /* o: decoded vector (non-scaled int) */
+ const Word16 k_val, /* i: number of allocated pulses */
+ const Word16 dim, /* i: Length of vector */
+ const Word16 neg_gain /* i: Gain (negated to fit 1.0 in Q15 as -1.0) */
+);
+
+UWord32 intLimCDivPos_fx(
+ UWord32 NUM,
+ Word16 DEN
+);
+
+Word32 intLimCDivSigned_fx(
+ Word32 NUM,
+ Word16 DEN
+);
+
+Word16 shrtCDivSignedApprox(
+ const Word16 num,
+ const Word16 den
+);
+void de_interleave_spectrum_fx(
+ Word32 *coefs, /* i/o: input and output coefficients Q? */
+ const Word16 length /* i : length of spectrum Q0 */
+);
+
+void interleave_spectrum_fx(
+ Word32 *coefs, /* i/o: input and output coefficients Q? */
+ const Word16 length /* i : length of spectrum Q0 */
+);
+
+void recovernorm_fx(
+ Word16 *idxbuf, /* i : reordered quantization indices */
+ Word16 *ynrm, /* o : recovered quantization indices */
+ Word16 *normqlg2, /* o : recovered quantized norms */
+ Word16 nb_sfm /* i : number of SFMs */
+);
+
+void map_quant_weight_fx(
+ const Word16 normqlg2[], /* i : quantized norms */
+ Word16 wnorm[], /* o : weighted norm */
+ const Word16 is_transient /* i : transient flag */
+);
+
+void fill_spectrum_fx(
+ Word16 *coeff, /* i/o: normalized MLT spectrum / nf spectrum Q12 */
+ Word32 *L_coeff_out, /* i/o: Noisefilled MLT spectrum Q12 */
+ const Word16 *R, /* i : number of pulses per band Q0 */
+ const Word16 is_transient, /* i : transient flag Q0 */
+ Word16 norm[], /* i : quantization indices for norms Q0 */
+ const Word16 *hq_generic_fenv, /* i : HQ GENERIC envelope Q1 */
+ const Word16 hq_generic_offset, /* i : HQ GENERIC offset Q0 */
+ const Word16 nf_idx, /* i : noise fill index Q0 */
+ const Word16 length, /* i : Length of spectrum (32 or 48 kHz) Q0 */
+ const Word16 env_stab, /* i : Envelope stability measure [0..1] Q15 */
+ Word16 *no_att_hangover, /* i/o: Frame counter for attenuation hangover Q0 */
+ Word32 *L_energy_lt, /* i/o: Long-term energy measure for transient detection Q13 */
+ Word16 *bwe_seed, /* i/o: random seed for generating BWE input Q0 */
+ const Word16 hq_generic_exc_clas, /* i : BWE excitation class Q0 */
+ const Word16 core_sfm, /* i : index of the end band for core Q0 */
+ const Word16 HQ_mode, /* i : HQ mode Q0 */
+ Word16 noise_level[], /* i : noise levels for harmonic modes Q15 */
+ const Word32 L_core_brate, /* i : target bit-rate Q0 */
+ Word16 prev_noise_level[], /* i/o: noise factor in previous frame Q15 */
+ Word16 *prev_R, /* i/o: bit allocation info. in previous frame Q0 */
+ Word32 *prev_coeff_out, /* i/o: decoded spectrum in previous frame Q12 */
+ const Word16 *peak_idx, /* i : peak indices for hvq Q0 */
+ const Word16 Npeaks, /* i : number of peaks in hvq Q0 */
+ const Word16 *npulses, /* i : number of pulses per band Q0 */
+ const Word16 prev_is_transient, /* i : previous transient flag Q0 */
+ Word32 *prev_normq, /* i/o: previous norms Q14 */
+ Word32 *prev_env, /* i/o: previous noise envelopes Q(prev_env_Q) */
+ const Word16 prev_bfi, /* i : previous bad frame indicator Q0 */
+ const Word16 *sfmsize, /* i : Length of bands Q0 */
+ const Word16 *sfm_start, /* i : Start of bands Q0 */
+ const Word16 *sfm_end, /* i : End of bands Q0 */
+ Word16 *prev_L_swb_norm, /* i/o: HVQ/Harmonic mode normalization length Q0 */
+ const Word16 prev_hq_mode, /* i : Previous HQ mode Q0 */
+ const Word16 num_sfm, /* i : Total number of bands Q0 */
+ Word16 *prev_env_Q,
+ const Word16 num_env_bands
+);
+
+Word16 FEC_pos_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 last_good, /* i : last good classfication */
+ Word16 *last_pulse_pos, /* o : last glotal pulse position in the lost ACB */
+ Word16 *clas, /* o : decoded classification */
+ Word32 *enr_q, /* o : decoded energy in Q0 */
+ const Word32 core_brate /* i : decoded bitrate */
+);
+
+void pit16k_Q_dec_fx(
+ const Word16 pitch_index, /* i : pitch index */
+ const Word16 nBits, /* i : # of Q bits */
+ const Word16 limit_flag, /* i : restrained(0) or extended(1) limits */
+ Word16 *T0, /* o : integer pitch lag */
+ Word16 *T0_frac, /* o : pitch fraction */
+ Word16 *T0_min, /* i/o: delta search min */
+ Word16 *T0_max /* i/o: delta search max */
+ ,Word16 *BER_detect /* o : BER detect flag */
+);
+
+Word16 frame_ener_fx(
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 clas, /* i : frame classification */
+ const Word16 *synth, /* i : synthesized speech at Fs = 12k8 Hz Q_new */
+ const Word16 pitch, /* i : pitch period Q0 */
+ Word32 *enr_q, /* o : pitch-synchronous or half_frame energy Q0 */
+ const Word16 offset, /* i : speech pointer offset (0 or L_FRAME) */
+ const Word16 Q_new, /* i : Scaling factor */
+ Word16 shift, /* i : Shift need to obtain 12 bits vectors */
+ const Word16 enc /* i : Encoder/decoder */
+);
+
+Word16 frame_energy_fx( /* o : Frame erergy in Q8 */
+ Word16 L_frame,
+ const Word16 *pitch, /* i : pitch values for each subframe Q6 */
+ const Word16 *speech, /* i : pointer to speech signal for E computation Q_syn*/
+ const Word16 lp_speech, /* i : long term active speech energy average Q8 */
+ Word16 *frame_ener, /* o : pitch-synchronous energy at frame end Q8 */
+ const Word16 Q_syn /* i : Synthesis scaling */
+);
+
+void int_lsp_fx(
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 lsp_old[], /* i : LSPs from past frame */
+ const Word16 lsp_new[], /* i : LSPs from present frame */
+ Word16 *Aq, /* o : LP coefficients in both subframes */
+ const Word16 m, /* i : order of LP filter */
+ const Word16 *int_coeffs, /* i : interpolation coefficients */
+ const Word16 Opt_AMR_WB /* i : flag indicating AMR-WB IO mode */
+);
+
+void reorder_isf_fx(
+ Word16 *isf, /* i/o: ISFs in the frequency domain (0..0.5) */
+ const Word16 min_dist, /* i : minimum required distance */
+ const Word16 n, /* i : LPC order */
+ const Word16 fs /* i : sampling frequency */
+);
+
+void reorder_lsf_fx(
+ Word16 *lsf, /* i/o: LSFs in the frequency domain (0..0.5) Q(x2.56)*/
+ const Word16 min_dist, /* i : minimum required distance x2.56*/
+ const Word16 n, /* i : LPC order */
+ const Word32 fs /* i : sampling frequency */
+);
+
+Word16 FEC_synchro_exc_fx( /* o : do_WI flag */
+ const Word16 L_frame, /* i : length of the frame */
+ Word16 *exc, /* i/o: exc vector to modify */
+ const Word16 desire_puls_pos, /* i : Pulse position send by the encoder */
+ const Word16 true_puls_pos, /* i : Present pulse location */
+ const Word16 Old_pitch /* i : Pitch use to create temporary adaptive codebook */
+);
+
+Word16 findpulse_fx( /* o : pulse position */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 res[], /* i : Residual signal <12 bits */
+ const Word16 T0, /* i : Pitch estimation Q0 */
+ const Word16 enc, /* i : enc = 1 -> encoder side; enc = 0 -> decoder side */
+ Word16 *sign /* i/o: sign of the maximum */
+);
+
+void FEC_exc_estim_fx(
+ Decoder_State_fx *st_fx, /* i/o: Decoder static memory */
+ const Word16 L_frame, /* i : length of the frame */
+ Word16 *exc, /* o : pointer to excitation buffer (with past) */
+ Word16 *exc2, /* o : total excitation (for synthesis) */
+ Word16 dct_exc_tmp[], /* o : GSC excitation in DCT domain */
+ Word16 *pitch_buf, /* o : Floating pitch for each subframe */
+ Word16 *voice_factors, /* o : voicing factors */
+ Word16 *tmp_tc, /* o : FEC pitch Q6 */
+ Word16 *bwe_exc, /* o : excitation for SWB TBE */
+ Word16 *lsf_new, /* i : ISFs at the end of the frame */
+ Word16 *Q_exc,
+ Word16 *tmp_noise /* o : long-term noise energy Q0 */
+);
+
+void FEC_lsf2lsp_interp(
+ Decoder_State_fx *st, /* i/o: Decoder static memory */
+ const Word16 L_frame, /* i : length of the frame */
+ Word16 *Aq, /* o : calculated A(z) for 4 subframes */
+ Word16 *lsf, /* o : estimated LSF vector */
+ Word16 *lsp /* o : estimated LSP vector */
+);
+void FEC_lsf_estim_enc_fx(
+ Encoder_State_fx *st_fx, /* i : Encoder static memory */
+ const Word16 L_frame, /* i : length of the frame */
+ Word16 *lsf /* o : estimated LSF vector */
+);
+
+void FEC_clas_estim_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state handle */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */ /*A*/
+ const Word16 L_frame, /* i : length of the frame */
+ Word16 *clas, /* i/o: frame classification */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 *pitch, /* i : pitch values for each subframe (Q6) */
+ Word16 *syn, /* i : synthesis buffer */
+ Word16 *lp_speech, /* i/o: long term active speech energy average Q8 */
+ Word16 *decision_hyst, /* i/o: hysteresis of the music/speech decision */ /*A*/
+ Word16 *UV_cnt, /* i/o: number of consecutives frames classified as UV */ /*A*/
+ Word16 *LT_UV_cnt, /* i/o: long term consecutives frames classified as UV */ /*A*/
+ Word16 *Last_ener, /* i/o: last_energy frame */ /*A*/
+ Word16 *locattack, /* i/o: detection of attack (mainly to localized speech burst) */ /*A*/
+ Word16 *lt_diff_etot, /* i/o: long-term total energy variation */ /*A*/
+ Word16 *amr_io_class, /* i/o: classification for AMR-WB IO mode */ /*A*/
+ const Word32 bitrate, /* i : Decoded bitrate */ /*A*/
+ Word16 Q_syn, /* i : Synthesis scaling */
+ Word16 *class_para, /* o : classification para. fmerit1 */ /*A*/
+ Word16 *mem_syn_clas_estim, /* i/o: memory of the synthesis signal for frame class estimation */
+ Word16 *Q_mem_syn, /*i/o : exponent for memory of synthesis signal for frame class estimation */ /*B*/
+ Word16 LTP_Gain, /* i : LTP gain is 0..0.6 or negative Q15*/ /*B*/
+ Word16 mode, /* i : signal classifier mode *//*B*/
+ Word16 bfi, /* i : bad frame indicator *//*B*/
+ Word32 last_core_brate /* i : bitrate of previous frame */
+);
+
+void non_linearity_fx(
+ const Word16 input[], /* i : input signal Q_inp */
+ Word32 output[], /* o : output signal 2*Q_inp */
+ const Word16 length, /* i : input length */
+ Word32 *prev_scale, /* i/o: memory Q30 */
+ Word16 Q_inp,
+ Word16 coder_type, /* i : Coder Type */
+ Word16 *voice_factors, /* i : Voice Factors */
+ const Word16 L_frame /* i : ACELP frame length */
+);
+
+void stat_noise_uv_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: Decoder static memory */
+ const Word16 coder_type, /* i : coding type */
+ Word16 *lsp_new, /* i : end-frame LSP vector */
+ Word16 *lsp_mid, /* i : mid-frame LSP vector */
+ Word16 *Aq, /* o : A(z) quantized for the 4 subframes */
+ Word16 *exc2 /* i/o: excitation buffer */
+);
+
+void stat_noise_uv_mod_fx(
+ const Word16 coder_type, /* i : Coder type */
+ Word16 noisiness, /* i : noisiness parameter */
+ const Word16 *lsp_old, /* i : old LSP vector at 4th sfr */
+ const Word16 *lsp_new, /* i : LSP vector at 4th sfr */
+ const Word16 *lsp_mid, /* i : LSP vector at 2nd sfr */
+ Word16 *Aq, /* o : A(z) quantized for the 4 subframes */
+ Word16 *exc2, /* i/o: excitation buffer */
+ Word16 Q_exc, /* i : Q of exc2 excitation buffer [11..-1] expected */
+ const Word16 bfi , /* i : Bad frame indicator */
+ Word32 *ge_sm, /* i/o: smoothed excitation gain */
+ Word16 *uv_count, /* i/o: unvoiced counter */
+ Word16 *act_count, /* i/o: activation counter */
+ Word16 lspold_s[], /* i/o: old LSP */
+ Word16 *noimix_seed, /* i/o: mixture seed */
+ Word16 *st_min_alpha, /* i/o: minimum alpha */
+ Word16 *exc_pe, /* i/o: scale Q_stat_noise */
+ const Word32 bitrate, /* i : core bitrate */
+ const Word16 bwidth_fx, /* i : input bandwidth */
+ Word16 *Q_stat_noise, /* i/o: noise scaling */
+ Word16 *Q_stat_noise_ge /* i/o: noise scaling */
+);
+
+/* Just call preemph_copy_fx(), it does the same thing and that saves PROM */
+#define preemph_fx(signal,mu,L,mem) preemph_copy_fx((signal),(signal),(mu),(L),(mem))
+
+void preemph_copy_fx(
+ const Word16 x[], /* i : input signal Qx */
+ Word16 y[], /* o : output signal Qx */
+ const Word16 mu, /* i : preemphasis coefficient Q15 */
+ const Word16 lg, /* i : vector size Q0 */
+ Word16 *mem /* i/o: memory (x[-1]) Qx */
+);
+
+Word16 vquant_fx( /* o: index of the winning codevector */
+ Word16 x[], /* i: vector to quantize Q13 */
+ const Word16 x_mean[], /* i: vector mean to subtract (0 if none)Q13*/
+ Word16 xq[], /* o: quantized vector Q13 */
+ const Word16 cb[], /* i: codebook Q13 */
+ const Word16 dim, /* i: dimension of codebook vectors */
+ const Word16 cbsize /* i: codebook size */
+);
+
+Word16 w_vquant_fx(
+ Word16 x[], /* i: vector to quantize in Q10 */
+ Word16 Qx,
+ const Word16 weights[], /* i: error weights in Q0 */
+ Word16 xq[], /* o: quantized vector in Q15 */
+ const Word16 cb[], /* i: codebook in Q15 */
+ const Word16 cbsize, /* i: codebook size */
+ const Word16 rev_vect /* i: reverse codebook vectors */
+);
+
+void Vr_subt(
+ const Word16 x1[], /* i : Input vector 1 */
+ const Word16 x2[], /* i : Input vector 2 */
+ Word16 y[], /* o : Output vector that contains vector 1 - vector 2 */
+ Word16 N /* i : Vector lenght */
+);
+
+Word16 gsc_gainQ_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 y_gain4[], /* i : Energy per band Q13 */
+ Word16 y_gainQ[], /* o : quantized energy per band Q13 */
+ const Word32 core_brate, /* i : Core rate */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 bwidth /* i : input signal bandwidth */
+);
+
+Word16 emaximum_fx( /* o : return index with max energy value in vector Q0 */
+ const Word16 Qvec, /* i : Q of input vector Q0 */
+ const Word16 *vec, /* i : input vector Qx */
+ const Word16 lvec, /* i : length of input vector Q0 */
+ Word32 *ener_max /* o : maximum energy value Q0 */
+);
+
+void set16_fx(
+ Word16 y[], /* i/o: Vector to set */
+ const Word16 a, /* i : Value to set the vector to */
+ const Word16 N /* i : Lenght of the vector */
+);
+
+void set32_fx(
+ Word32 y[], /* i/o: Vector to set */
+ const Word32 a, /* i : Value to set the vector to */
+ const Word16 N /* i : Lenght of the vector */
+);
+
+void Copy(
+ const Word16 x[], /* i : input vector */
+ Word16 y[], /* o : output vector */
+ const Word16 L /* i : vector length */
+);
+
+void Copy32(
+ const Word32 x[], /* i : input vector */
+ Word32 y[], /* o : output vector */
+ const Word16 L /* i : vector length */
+);
+
+void Scale_sig32(
+ Word32 x[], /* i/o: signal to scale Qx */
+ const Word16 lg, /* i : size of x[] Q0 */
+ const Word16 exp0 /* i : exponent: x = round(x << exp) Qx ?exp */
+);
+
+void Copy_Scale_sig(
+ const Word16 x[], /* i : signal to scale input Qx */
+ Word16 y[], /* o : scaled signal output Qx */
+ const Word16 lg, /* i : size of x[] Q0 */
+ const Word16 exp0 /* i : exponent: x = round(x << exp) Qx ?exp */
+);
+
+void Copy_Scale_sig_16_32(
+ const Word16 x[], /* i : signal to scale input Qx */
+ Word32 y[], /* o : scaled signal output Qx */
+ const Word16 lg, /* i : size of x[] Q0 */
+ const Word16 exp0 /* i : exponent: x = round(x << exp) Qx ?exp */
+);
+
+void Copy_Scale_sig_32_16(
+ const Word32 x[], /* i : signal to scale input Qx */
+ Word16 y[], /* o : scaled signal output Qx */
+ const Word16 lg, /* i : size of x[] Q0 */
+ const Word16 exp0 /* i : exponent: x = round(x << exp) Qx ?exp */
+);
+
+void init_lvq_fx(
+ Word32 offset_scale1[][MAX_NO_SCALES+1],
+ Word32 offset_scale2[][MAX_NO_SCALES+1],
+ Word32 offset_scale1_p[][MAX_NO_SCALES+1],
+ Word32 offset_scale2_p[][MAX_NO_SCALES+1],
+ Word16 no_scales[][2],
+ Word16 no_scales_p[][2]
+);
+
+void hf_synth_reset_fx(
+ Word16 *seed2, /* i/o: random seed for HF noise gen */
+ Word16 mem_hf[], /* o : HF band-pass filter memory */
+ Word16 mem_syn_hf[], /* o : HF synthesis memory */
+ Word16 mem_hp400[], /* o : memory of hp 400 Hz filter */
+ Word16 mem_hp_interp[], /* o : interpol. memory */
+ Word16 delay_syn_hf[] /* o : HF synthesis memory */
+);
+
+void hf_synth_init_fx(
+ Word16 mem_hp400[], /* o : 400 Hz high pass filter memory initialization */
+ Word16 mem_hf[] /* o : band pass 6kHz to 7kHz FIR filter initialization */
+);
+
+Word16 Random( /* o : output random value */
+ Word16 *seed /* i/o: random seed */
+);
+
+Word16 own_random2_fx( /* o : output random value */
+ Word16 seed /* i : random seed */
+);
+
+void Random_Fill(
+ Word16 *seed, /* i/o: random seed */
+ Word16 n, /* i : number of values */
+ Word16 *y, /* o : output values */
+ Word16 scaling /* i : scaling of values */
+);
+
+void iDiv_and_mod_32(
+ const Word32 Numer, /* i : 32 bits numerator */
+ const Word16 Denom, /* i : 16 bits denominator */
+ Word32 * Int_quotient, /* o : integer result of the division (int)(num/den) */
+ Word32 * Int_mod, /* o : modulo result of the division num-((int)(num/den)*den)*/
+ const Word16 rshift /* i : 0 if no right shift / 1 if the denom is right shifted by 1*/
+);
+
+void lsf2lsp_fx(
+ const Word16 lsf[], /* i : lsf[m] normalized (range: 0.0<=val<=0.5) x2.56 */
+ Word16 lsp[], /* o : lsp[m] (range: -1<=val<1) Q15 */
+ const Word16 m, /* i : LPC order Q0 */
+ Word32 int_fs
+);
+
+void bass_psfilter_init_fx(
+ Word16 old_syn[], /* o : Old synthesis buffer 1 */
+ Word16 *mem_deemph_err, /* o : Error deemphasis memory */
+ Word16 *lp_ener /* o : long_term error signal energy */
+);
+
+void decod_gen_voic_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder static memory */
+ const Word16 L_frame_fx, /* i : length of the frame */
+ const Word16 sharpFlag_fx, /* i : formant sharpening flag */
+ const Word16 *Aq_fx, /* i : LP filter coefficient */
+ const Word16 coder_type_fx, /* i : coding type */
+ const Word16 Es_pred_fx, /* i : predicted scaled innov. energy */
+ const Word16 do_WI_fx, /* i : do interpolation after a FER */
+ Word16 *pitch_buf_fx, /* o : floating pitch values for each subframe */
+ Word16 *voice_factors_fx, /* o : voicing factors */
+ Word16 *exc_fx, /* i/o: adapt. excitation exc */
+ Word16 *exc2_fx, /* i/o: adapt. excitation/total exc */
+ Word16 *bwe_exc_fx, /* o : excitation for SWB TBE */
+ Word16 *unbits, /* number of unused bits */
+ Word16* gain_buf /*Q14*/
+);
+
+Word16 tc_classif_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 L_frame /* i : length of the frame */
+);
+
+void transition_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 tc_subfr, /* i : TC subframe index */
+ Word16 *Jopt_flag, /* i : joint optimization flag */
+ Word16 *exc, /* o : excitation signal */
+ Word16 *T0, /* o : close loop integer pitch */
+ Word16 *T0_frac, /* o : close loop fractional part of the pitch */
+ Word16 *T0_min, /* i/o: delta search min for sf 2 & 4 */
+ Word16 *T0_max, /* i/o: delta search max for sf 2 & 4 */
+ Word16 **pt_pitch, /* o : floating pitch values */
+ Word16 *position, /* i/o: first glottal impulse position in frame */
+ Word16 *bwe_exc, /* o : excitation for SWB TBE */
+ Word16 *Q_exc /*i/o : scaling of excitation */
+);
+
+void decod_tran_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder static memory */
+ const Word16 L_frame_fx, /* i : length of the frame */
+ const Word16 tc_subfr_fx, /* i : TC subframe index */
+ const Word16 *Aq_fx, /* i : LP filter coefficient */
+ const Word16 coder_type_fx, /* i : coding type */
+ const Word16 Es_pred_fx, /* i : predicted scaled innov. energy */
+ Word16 *pitch_buf_fx, /* o : floating pitch values for each subframe */
+ Word16 *voice_factors_fx, /* o : voicing factors */
+ Word16 *exc_fx, /* i/o: adapt. excitation exc */
+ Word16 *exc2_fx, /* i/o: adapt. excitation/total exc */
+ Word16 *bwe_exc_fx, /* i/o: excitation for SWB TBE */
+ Word16 *unbits, /* i/o: number of unused bits */
+ const Word16 sharpFlag, /* i : formant sharpening flag */
+ Word16 *gain_buf /*Q14*/
+);
+
+void interp_code_4over2_fx(
+ const Word16 inp_code_fx[], /* i : input vector Qx */
+ Word16 interp_code_fx[], /* o : output vector Qx */
+ const Word16 inp_length /* i : length of input vector */
+);
+
+void pred_lt4_tc_fx(
+ Word16 exc[], /* i/o: excitation buffer */
+ const Word16 T0, /* i : integer pitch lag */
+ Word16 frac, /* i: fraction of lag */
+ const Word16 *win, /* i : interpolation window */
+ const Word16 imp_pos, /* i : glottal impulse position */
+ const Word16 i_subfr /* i : subframe index */
+);
+
+void gaus_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder static memory */
+ const Word32 core_brate, /* i */ /*1 : core bitrate */
+ const Word16 i_subfr, /* i */ /*2 : subframe index */
+ Word16 *code, /* o */ /*3 : unvoiced excitation Q12 */
+ Word32 *L_norm_gain_code, /* o */ /*4 : gain of normalized gaussian excitation Q16 */
+ Word16 *lp_gainp, /* i/o */ /*5 : lp filtered pitch gain(FER) Q14 */
+ Word16 *lp_gainc, /* i/o */ /*6 : lp filtered code gain (FER) Q3 */
+ Word16 *inv_gain_inov, /* o */ /*7 : unscaled innovation gain Q12 */
+ Word16 *tilt_code, /* o */ /*8 : synthesis excitation spectrum tilt Q15 */
+ Word16 *voice_fac, /* o */ /*9 : estimated voicing factor Q15 */
+ Word16 *gain_pit, /* o */ /*10 : pitch gain Q14 */
+ Word16 *pt_pitch_1, /* o */ /*11 : floating pitch buffer Q6 */
+ Word16 *exc, /* o */ /*12 : excitation signal frame */
+ Word32 *L_gain_code, /* o */ /*13 : gain of the gaussian excitation Q16 */
+ Word16 *exc2, /* o */ /*14 : Scaled excitation signal frame */
+ Word16 *bwe_exc_fx,
+ Word16 *sQ_exc, /* i/o */ /*15 : Excitation scaling factor (Decoder state) */
+ Word16 *sQsubfr /* i/o */ /*16 : Past excitation scaling factors (Decoder State) */
+);
+
+void decod_unvoiced_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder static memory */
+ const Word16 *Aq_fx, /* Q12 i : LP filter coefficient */
+ const Word16 coder_type_fx, /* Q0 i : coding type */
+ Word16 *tmp_noise_fx, /* Q5 o : long term temporary noise energy */
+ Word16 *pitch_buf_fx, /* Q6 o : floating pitch values for each subframe */
+ Word16 *voice_factors_fx, /* Q15 o : voicing factors */
+ Word16 *exc_fx, /* Q_X o : adapt. excitation exc */
+ Word16 *exc2_fx, /* Q_X o : adapt. excitation/total exc */
+ Word16 *bwe_exc_fx, /* Q_X i/o: excitation for SWB TBE */
+ Word16 *gain_buf
+);
+
+Word32 gain_dec_gaus_fx( /* o : quantized codebook gain Q16 */
+ Word16 index, /* i : quantization index */
+ const Word16 bits, /* i : number of bits to quantize */
+ const Word16 lowBound, /* i : lower bound of quantizer (dB) */
+ const Word16 topBound, /* i : upper bound of quantizer (dB) */
+ const Word16 inv_gain_inov, /* o : unscaled innovation gain Q12 */
+ Word32 *L_norm_gain_code /* o : gain of normalized gaussian excitation Q16 */
+);
+
+void AVQ_demuxdec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 xriq[], /* o: decoded subvectors [0..8*Nsv-1] */
+ Word16 *nb_bits, /* i/o: number of allocated bits */
+ const Word16 Nsv, /* i: number of subvectors */
+ Word16 nq_out[] /* i/o: AVQ nq index */
+);
+
+void re8_decode_base_index_fx(Word16 n, UWord16 I, Word16 *x);
+
+void re8_k2y_fx(
+ const Word16 *k, /* i : Voronoi index k[0..7] */
+ const Word16 m, /* i : Voronoi modulo (m = 2^r = 1<=2) */
+ Word16 *y /* o : 8-dimensional point y[0..7] in RE8 */
+);
+
+void re8_vor_fx(
+ const Word16 y[], /* i : point in RE8 (8-dimensional integer vector) */
+ Word16 *n, /* o : codebook number n=0,2,3,4,... (scalar integer) */
+ Word16 k[], /* o : Voronoi index (integer vector of dimension 8) used only if n>4*/
+ Word16 c[], /* o : codevector in Q0, Q2, Q3, or Q4 if n<=4, y=c */
+ Word16 *ka /* o : identifier of absolute leader (to index c) */
+);
+
+void re8_cod_fx(
+ Word16 x[], /* i : point in RE8 (8-dimensional integer vector) */
+ Word16 *n, /* i : codebook number (*n is an integer defined in {0,2,3,4,..,n_max}) */
+ UWord16 *I, /* o : index of c (pointer to unsigned 16-bit word) */
+ Word16 k[] /* o : index of v (8-dimensional vector of binary indices) = Voronoi index */
+);
+
+void re8_PPV_fx(
+ const Word32 x[], /* i : point in R^8Q15 */
+ Word16 y[] /* o : point in RE8 (8-dimensional integer vector) */
+);
+
+void re8_dec_fx(
+ Word16 n, /* i : codebook number (*n is an integer defined in {0,2,3,4,..,n_max}) */
+ const UWord16 I, /* i : index of c (pointer to unsigned 16-bit word) */
+ const Word16 k[], /* i : index of v (8-dimensional vector of binary indices) = Voronoi index */
+ Word16 y[] /* o : point in RE8 (8-dimensional integer vector) */
+);
+
+void gain_dec_SQ_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 i_subfr, /* i : subframe number */
+ const Word16 tc_subfr, /* i : TC subframe index */
+ const Word16 *code, /* i : algebraic code excitation Q12*/
+ const Word16 Es_pred, /* i : predicted scaled innov. energy Q8 */
+ Word16 *gain_pit, /* o : Quantized pitch gain Q14*/
+ Word32 *gain_code, /* o : Quantized codeebook gain Q16*/
+ Word16 *gain_inov, /* o : unscaled innovation gain Q12*/
+ Word32 *norm_gain_code /* o : norm. gain of the codebook excitation Q16*/
+);
+
+void gain_dec_amr_wb_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ Word16 *gain_pit, /* o : Quantized pitch gain */
+ Word32 *gain_code, /* o : Quantized codeebook gain */
+ Word16 *past_qua_en, /* i/o: gain quantization memory (4 words) */
+ Word16 *gain_inov, /* o : unscaled innovation gain */
+ const Word16 *code, /* i : algebraic code excitation */
+ Word32 *norm_gain_code /* o : norm. gain of the codebook excitation */
+);
+
+void isf_dec_amr_wb_fx(
+ Decoder_State_fx *st, /* i/o: State structure */
+ Word16 *Aq, /* o : quantized A(z) for 4 subframes */
+ Word16 *isf_new, /* o : de-quantized ISF vector */
+ Word16 *isp_new /* o : de-quantized ISP vector */
+);
+
+void syn_output_fx(
+ const Word16 codec_mode, /* i : MODE1 or MODE2 */
+ Word16 *synth, /* i/o: float synthesis signal */
+ const Word16 output_frame, /* i : output frame length */
+ Word16 *synth_out, /* o : integer 16 bits synthesis signal */
+ const Word16 Q_syn2 /* i : Synthesis scaling factor */
+);
+
+void amr_wb_dec_fx(
+ Word16 output_sp[], /* o : synthesis output */
+ Decoder_State_fx *st_fx /* o : Decoder static variables structure */
+);
+
+void decod_amr_wb_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder static memory */
+ const Word16 *Aq_fx, /* i : LP filter coefficients */
+ Word16 *pitch_buf_fx, /* o : floating pitch values for each subframe */
+ Word16 *exc_fx, /* i/o: adapt. excitation exc */
+ Word16 *exc2_fx, /* i/o: adapt. excitation/total exc */
+ Word16 hf_gain_fx[NB_SUBFR], /* o : decoded HF gain */
+ Word16 *voice_factors_fx, /* o : voicing factors */
+ Word16 *gain_buf /*Q14*/
+);
+
+void disf_2s_46b_fx(
+ Word16 *indice, /* i : quantized indices (use indice[0] = -1 in the decoder) */
+ Word16 *isf_q, /* o : quantized ISFs in the cosine domain */
+ Word16 *mem_AR, /* o : quantizer memory for AR model */
+ Word16 *mem_MA, /* i/o: quantizer memory for MA model */
+ const Word16 enc_dec /* i : encoder (0), decoder (1) G722.2 FER */
+);
+
+void disf_2s_36b_fx(
+ Word16 *indice, /* i : quantized indices (use indice[0] = -1 in the decoder) */
+ Word16 *isf_q, /* o : quantized ISFs in the cosine domain */
+ Word16 *mem_AR, /* i/o: quantizer memory for AR model */
+ Word16 *mem_MA, /* i/o: quantizer memory for MA model */
+ const Word16 enc_dec /* i : encoder (0), decoder (1) G722.2 FER */
+);
+
+void transf_cdbk_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 harm_flag_acelp,/* i : harmonic flag for higher rates ACELP */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 tc_subfr, /* i : TC subframe index */
+ const Word16 Es_pred, /* i : predicited scaled innovation energy (Q8) */
+ const Word32 gain_code, /* i : innovative excitation gain (Q16) */
+ Word16 *mem_preemp, /* i/o: dequantizer preemhasis memory */
+ Word16 *gain_preQ, /* o : prequantizer excitation gain (Q2) */
+ Word32 *norm_gain_preQ,/* o : normalized prequantizer excitation gain (Q16) */
+ Word16 code_preQ[], /* o : prequantizer excitation (Q8) */
+ Word16 *unbits /* o : number of AVQ unused bits */
+);
+
+void gain_enc_SQ_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 tc_subfr, /* i : TC subframe index */
+ const Word16 *xn, /* i : target vector Q_xn */
+ const Word16 *yy1, /* i : zero-memory filtered adaptive excitation Q_xn */
+ const Word16 *y2, /* i : zero-memory filtered algebraic codebook excitation Q9 */
+ const Word16 *code, /* i : algebraic excitation Q9 */
+ const Word16 Es_pred, /* i : predicted scaled innovation energy Q8 */
+ Word16 *gain_pit, /* o : quantized pitch gain Q14 */
+ Word32 *gain_code, /* o : quantized codebook gain Q16 */
+ Word16 *gain_inov, /* o : gain of the innovation (used for normalization) Q12 */
+ Word32 *norm_gain_code, /* o : norm. gain of the codebook excitation Q16 */
+ Word16 *g_corr, /* i/o: correlations , -2,, -2 and 2 */
+ const Word16 clip_gain, /* i : gain pitch clipping flag (1 = clipping) */
+ const Word16 Q_xn /* i : xn and y1 scaling */
+);
+
+void AVQ_cod_fx( /* o: comfort noise gain factor */
+ const Word16 xri[], /* i: vector to quantize */
+ Word16 xriq[], /* o: quantized normalized vector (assuming the bit budget is enough) */
+ const Word16 NB_BITS, /* i: number of allocated bits */
+ const Word16 Nsv, /* i: number of subvectors (lg=Nsv*8) */
+ const Word16 Q_in /* i: Scaling input */
+);
+
+void AVQ_encmux_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 extl, /* i : extension layer */
+ Word16 xriq[], /* i/o: rounded subvectors [0..8*Nsv-1] followed
+ by rounded bit allocations [8*Nsv..8*Nsv+Nsv-1] */
+ Word16 *nb_bits, /* i/o: number of allocated bits */
+ const Word16 Nsv, /* i: number of subvectors */
+ Word16 nq_out[] /* o : AVQ nq index */
+);
+
+Word32 Dot_product( /* o : Sum */
+ const Word16 x[], /* i : 12bits: x vector */
+ const Word16 y[], /* i : 12bits: y vector */
+ const Word16 lg /* i : vector length */
+);
+
+Word16 usquant_fx( /* o: index of the winning codeword */
+ const Word16 x, /* i: scalar value to quantize Qx*/
+ Word16 *xq, /* o: quantized value Qx*/
+ const Word16 qlow, /* i: lowest codebook entry (index 0) Qx*/
+ const Word16 delta, /* i: quantization step Qx-1*/
+ const Word16 cbsize /* i: codebook size */
+);
+
+Word16 gain_quant_fx( /* o: quantization index */
+ Word32 *gain, /* i/o: quantized gain */
+ Word16 *gain16,
+ const Word16 c_min, /* i: log10 of lower limit in Q14 */
+ const Word16 c_max, /* i: log10 of upper limit in Q13 */
+ const Word16 bits, /* i: number of bits to quantize */
+ Word16 *expg
+);
+
+void gain_enc_mless_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 tc_subfr, /* i : TC subframe index */
+ const Word16 *xn, /* i : target vector */
+ const Word16 *y1, /* i : zero-memory filtered adaptive excitation */
+ const Word16 Q_xn, /* i : xn and y1 scaling */
+ const Word16 *y2, /* i : zero-memory filtered algebraic codebook excitation */
+ const Word16 *code, /* i : algebraic excitation */
+ const Word16 Es_pred, /* i : predicted scaled innovation energy */
+ Word16 *gain_pit, /* o : quantized pitch gain */
+ Word32 *gain_code, /* o : quantized codebook gain */
+ Word16 *gain_inov, /* o : gain of the innovation (used for normalization) */
+ Word32 *norm_gain_code, /* o : norm. gain of the codebook excitation */
+ Word16 *g_corr, /* i/o: correlations , -2,, -2 and 2 */
+ const Word16 clip_gain /* i : gain pitch clipping flag (1 = clipping) */
+);
+
+Word16 gain_enc_gaus_fx( /* o : Return index of quantization */
+ Word32 *gain, /* i/o: Code gain to quantize */
+ const Word16 bits, /* i : number of bits to quantize */
+ const Word16 lowBound, /* i : lower bound of quantizer (dB) Q8 */
+ const Word16 stepSize, /* i : Step size choice Q14 */
+ const Word16 inv_stepSize /* i : Step size choice Q15 */
+);
+
+void gain_enc_tc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 tc_subfr, /* i : TC subframe index */
+ const Word16 xn_fx[], /* i : target vector */
+ const Word16 y2_fx[], /* i : zero-memory filtered algebraic codebook excitation */
+ const Word16 code_fx[], /* i : algebraic excitation */
+ const Word16 Es_pred_fx, /* i : predicted scaled innovation energy */
+ Word16 *gain_pit_fx, /* o : Pitch gain / Quantized pitch gain */
+ Word32 *gain_code_fx, /* o : quantized codebook gain */
+ Word16 *gain_inov_fx, /* o : innovation gain */
+ Word32 *norm_gain_code_fx, /* o : norm. gain of the codebook excitation */
+ const Word16 Q_xn /* i : xn and y1 scaling Q0 */
+);
+
+Word16 gaus_encode_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 *h1, /* i : weighted filter input response */
+ const Word16 *xn, /* i : target vector */
+ Word16 *exc, /* o : pointer to excitation signal frame */
+ Word16 *mem_w0, /* o : weighting filter denominator memory */
+ Word16 *clip_gain, /* o : memory of gain of pitch clipping algorithm */
+ Word16 *tilt_code, /* o : synthesis excitation spectrum tilt */
+ Word16 *code, /* o : algebraic excitation Q9 */
+ Word32 *gain_code, /* o : Code gain. Q16 */
+ Word16 *y2, /* o : zero-memory filtered adaptive excitation Q9 */
+ Word16 *gain_inov, /* o : innovation gain Q12 */
+ Word16 *voice_fac, /* o : voicing factor Q15 */
+ Word16 *gain_pit, /* o : adaptive excitation gain Q14 */
+ const Word16 Q_new, /* i : scaling factor */
+ const Word16 shift, /* i : scaling factor */
+ Word32 *norm_gain_code, /* o : normalized innovative cb. gain Q16 */
+ const Word32 core_brate /* i : core bitrate */
+);
+
+void encod_unvoiced_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ LPD_state *mem, /* i/o: acelp memories */
+ const Word16 *speech_fx, /* i : Input speech */
+ const Word16 Aw_fx[], /* i : weighted A(z) unquantized for subframes */
+ const Word16 *Aq_fx, /* i : 12k8 Lp coefficient */
+ const Word16 vad_flag_fx,
+ const Word16 *res_fx, /* i : residual signal */
+ Word16 *syn_fx, /* o : core synthesis */
+ Word16 *tmp_noise_fx, /* o : long-term noise energy */
+ Word16 *exc_fx, /* i/o: current non-enhanced excitation */
+ Word16 *pitch_buf_fx, /* o : floating pitch values for each subframe */
+ Word16 *voice_factors_fx, /* o : voicing factors */
+ Word16 *bwe_exc_fx, /* i/o: excitation for SWB TBE */
+ const Word16 Q_new,
+ const Word16 shift
+);
+
+void transf_cdbk_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 extl, /* i : extension layer */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 harm_flag_acelp, /* i : harmonic flag for higher rates ACELP */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 tc_subfr, /* i : TC subframe index */
+ Word16 cn[], /* i/o: target vector in residual domain */
+ Word16 exc[], /* i/o: pointer to excitation signal frame */
+ const Word16 *p_Aq, /* i : 12k8 Lp coefficient */
+ const Word16 Ap[], /* i : weighted LP filter coefficients */
+ const Word16 h1[], /* i : weighted filter input response */
+ Word16 xn[], /* i/o: target vector */
+ Word16 xn2[], /* i/o: target vector for innovation search */
+ Word16 y1[], /* i/o: zero-memory filtered adaptive excitation */
+ const Word16 y2[], /* i : zero-memory filtered innovative excitation */
+ const Word16 Es_pred, /* i : predicited scaled innovation energy */
+ Word16 *gain_pit, /* i/o: adaptive excitation gain */
+ const Word32 gain_code, /* i : innovative excitation gain */
+ Word16 g_corr[], /* o : ACELP correlation values */
+ const Word16 clip_gain, /* i : adaptive gain clipping flag */
+ Word16 *mem_deemp, /* i/o: prequantizer deemhasis memory */
+ Word16 *mem_preemp, /* i/o: prequantizer preemhasis memory */
+ Word16 *gain_preQ, /* o : prequantizer excitation gain */
+ Word16 code_preQ[], /* o : prequantizer excitation */
+ Word16 *unbits, /* o : number of AVQ unused bits */
+ const Word16 Q_new, /* i : Current frame scaling */
+ const Word16 shift /* i : shifting applied to y1, xn,... */
+);
+
+Word16 encod_tran_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ LPD_state *mem, /* i/o: acelp memories */
+ const Word16 L_frame_fx, /* i : length of the frame */
+ const Word16 speech_fx[], /* i : input speech */
+ const Word16 Aw_fx[], /* i : weighted A(z) unquantized for subframes */
+ const Word16 Aq_fx[], /* i : 12k8 Lp coefficient */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 Es_pred_fx, /* i : predicted scaled innov. energy */
+ const Word16 T_op_fx[], /* i : open loop pitch */
+ const Word16 voicing_fx[], /* i : voicing */
+ const Word16 *res_fx, /* i : residual signal */
+ Word16 *syn_fx, /* i/o: core synthesis */
+ Word16 *exc_fx, /* i/o: current non-enhanced excitation */
+ Word16 *exc2_fx, /* i/o: current enhanced excitation */
+ Word16 *pitch_buf_fx, /* i/o: floating pitch values for each subframe */
+ Word16 *voice_factors, /* o : voicing factors */
+ Word16 *bwe_exc_fx, /* i/o: excitation for SWB TBE */
+ const Word16 gsc_attack_flag, /* i : Flag to indicate when an audio attack is deal with TM */
+ Word16 *unbits, /* i/o: number of unused bits */
+ Word16 sharpFlag, /* o : formant sharpening flag */
+ const Word16 shift, /* i : Scaling to get 12 bits */
+ const Word16 Q_new /* i : Input scaling */
+);
+
+Word16 est_tilt_fx( /* o : tilt of the code Q15 */
+ const Word16 *exc, /* i : adaptive excitation vector Qx */
+ const Word16 gain_pit, /* i : adaptive gain Q14 */
+ const Word16 *code, /* i : algebraic exctitation vector Q9 */
+ const Word32 gain_code, /* i : algebraic code gain Q16 */
+ Word16 *voice_fac, /* o : voicing factor Q15 */
+ const Word16 Q_exc /* i : Scaling factor of excitation Q0 */
+);
+
+Word16 Est_tilt2( /* o : tilt of the code */
+ const Word16 *exc, /* i : adaptive excitation vector Qx */
+ const Word16 gain_pit, /* i : adaptive gain Q14 */
+ const Word16 *code, /* i : algebraic exctitation vector Q9 */
+ const Word32 gain_code, /* i : algebraic code gain Q16 */
+ Word16 *voice_fac, /* o : voicing factor Q15 */
+ const Word16 Q_exc /* i : Scaling factor of excitation Q0 */
+);
+
+void transition_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 i_subfr, /* i : subframe index */
+ Word16 *tc_subfr, /* i/o: TC subframe index */
+ Word16 *Jopt_flag, /* i : joint optimization flag */
+ Word16 *position, /* i/o: maximum of residual signal index */
+ const Word16 voicing_fx[], /* i : normalized correlations (from OL pitch) Q15*/
+ const Word16 T_op_fx[], /* i : open loop pitch estimates in current frame Q0*/
+ Word16 *T0, /* i/o: close loop integer pitch Q0*/
+ Word16 *T0_frac, /* i/o: close loop fractional part of the pitch Q0*/
+ Word16 *T0_min, /* i/o: lower limit for close-loop search Q0*/
+ Word16 *T0_max, /* i/o: higher limit for close-loop search Q0*/
+ Word16 *exc_fx, /* i/o: pointer to excitation signal frame Q_new*/
+ Word16 *y1_fx, /* o : zero-memory filtered adaptive excitation Q_new-1+shift*/
+ const Word16 *res_fx, /* i : pointer to the LP residual signal frame Q_new*/
+ const Word16 *h1_fx, /* i : weighted filter input response Q(14+shift)*/
+ const Word16 *xn_fx, /* i : target vector Q_new-1+shift*/
+ Word16 *xn2_fx, /* o : target vector for innovation search Q_new-1+shift*/
+ Word16 *gp_cl_fx, /* i/o: memory of gain of pitch clipping algorithm */
+ Word16 *gain_pit_fx, /* o : adaptive excitation gain Q14*/
+ Word16 *g_corr_fx, /* o : ACELP correlation values */
+ Word16 *clip_gain, /* i/o: adaptive gain clipping flag */
+ Word16 **pt_pitch_fx, /* o : floating pitch values */
+ Word16 *bwe_exc_fx, /* o : excitation for SWB TBE Q_new*/
+ Word16 Q_new, /* i : Current scaling */
+ Word16 shift /* i : downscaling needs for 12 bits convolutions */
+);
+
+Word16 abs_pit_enc_fx( /* o : pitch index */
+ const Word16 fr_steps, /* i : fractional resolution steps (2 or 4) for shortest pitches*/
+ const Word16 limit_flag, /* i : restrained(0) or extended(1) limits */
+ const Word16 T0, /* i : integer pitch lag */
+ const Word16 T0_frac /* i : pitch fraction */
+);
+
+Word16 delta_pit_enc_fx( /* o : pitch index */
+ const Word16 fr_steps, /* i : fractional resolution steps (2 or 4)*/
+ const Word16 T0, /* i : integer pitch lag */
+ const Word16 T0_frac, /* i : pitch fraction */
+ const Word16 T0_min /* i : delta search min */
+);
+
+void set_impulse_fx(
+ const Word16 xn_fx[], /* i : target signal */
+ const Word16 h_orig_fx[], /* i : impulse response of weighted synthesis filter */
+ Word16 exc_fx[], /* o : adaptive codebook excitation */
+ Word16 yy1_fx[], /* o : filtered adaptive codebook excitation */
+ Word16 *imp_shape, /* o : adaptive codebook index */
+ Word16 *imp_pos, /* o : position of the glotal impulse center index */
+ Word32 *gain_trans_fx, /* o : transition gain Q7 */
+ Word16 Q_new /* i : Current scaling */
+);
+
+void pit16k_Q_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 nBits, /* i : # of Q bits */
+ const Word16 limit_flag, /* i : restrained(0) or extended(1) Q limits */
+ const Word16 T0, /* i : integer pitch lag */
+ const Word16 T0_frac, /* i : pitch fraction */
+ Word16 *T0_min, /* i/o: delta search min */
+ Word16 *T0_max /* o : delta search max */
+);
+
+void gain_enc_amr_wb_fx(
+ Encoder_State_fx *st, /* i/o: encoder state structure */
+ const Word16 *xn, /* i : target vector */
+ const Word16 Q_xn, /* i : xn and yy1 format Q0 */
+ const Word16 *yy1, /* i : zero-memory filtered adaptive excitation */
+ const Word16 *y2, /* i : zero-memory filtered algebraic codebook excitation */
+ const Word16 *code, /* i : algebraic excitation */
+ const Word32 core_brate, /* i : core bitrate */
+ Word16 *gain_pit, /* i/o: pitch gain / Quantized pitch gain */
+ Word32 *gain_code, /* o : quantized codebook gain */
+ Word16 *gain_inov, /* o : gain of the innovation (used for normalization) */
+ Word32 *norm_gain_code, /* o : norm. gain of the codebook excitation */
+ Word16 *g_coeff, /* i/o: correlations , -2,, -2 and 2 */
+ const Word16 clip_gain, /* i : gain pitch clipping flag (1 = clipping) */
+ Word16 *past_qua_en /* i/o: gain quantization memory (4 words) */
+);
+
+void gain_enc_lbr_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 *xn, /* i : target vector Q_xn*/
+ const Word16 *y1, /* i : zero-memory filtered adaptive excitation Q_xn*/
+ const Word16 Q_xn, /* i : xn and y1 format */
+ const Word16 *y2, /* i : zero-memory filtered algebraic codebook excitation Q9*/
+ const Word16 *code, /* i : algebraic excitation Q9*/
+ Word16 *gain_pit, /* o : quantized pitch gain Q14*/
+ Word32 *gain_code, /* o : quantized codebook gain Q16*/
+ Word16 *gain_inov, /* o : gain of the innovation (used for normalization) Q12*/
+ Word32 *norm_gain_code, /* o : norm. gain of the codebook excitation Q16*/
+ Word16 *g_corr, /* i/o: correlations , -2,, -2 and 2 mant/exp*/
+ Word32 gc_mem[], /* i/o: gain_code from previous subframes */
+ Word16 gp_mem[], /* i/o: gain_pitch from previous subframes */
+ const Word16 clip_gain /* i : gain pitch clipping flag (1 = clipping) */
+);
+
+void gp_clip_test_gain_pit_fx(
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 gain_pit, /* i : gain of quantized pitch Q14 */
+ Word16 mem[] /* i/o: memory of gain of pitch clipping algorithm */
+);
+
+void gp_clip_test_lsf_fx(
+ const Word16 lsf[], /* i : lsf values (in frequency domain) */
+ Word16 mem[], /* i/o: memory of gain of pitch clipping algorithm */
+ const Word16 Opt_AMR_WB /* i : flag indicating AMR-WB IO mode */
+);
+
+Word16 inov_encode_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 last_L_frame, /* i : length of the last frame */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 bwidth, /* i : input signal bandwidth */
+ const Word16 sharpFlag, /* i : formant sharpening flag */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 tc_subfr, /* i : TC subframe index */
+ const Word16 *p_Aq, /* i : LP filter coefficients Q12*/
+ const Word16 gain_pit, /* i : adaptive excitation gain Q14*/
+ Word16 *cn, /* i/o: target vector in residual domain Q_new*/
+ const Word16 *exc, /* i : pointer to excitation signal frame Q_new*/
+ Word16 *h2, /* i/o: weighted filter input response Q12*/
+ const Word16 tilt_code, /* i : tilt of the excitation of previous subframe Q15*/
+ const Word16 pt_pitch, /* i : pointer to current subframe fractional pitch Q6*/
+ const Word16 *xn2, /* i : target vector for innovation search Q_new-1+shift*/
+ Word16 *code, /* o : algebraic excitation Q9*/
+ Word16 *y2, /* o : zero-memory filtered algebraic excitation Q9*/
+ Word16 *unbits, /* o : number of unused bits for PI */
+ Word16 shift
+);
+
+Word32 sum2_fx( /* o : sum of all squared vector elements Q(2x+1)*/
+ const Word16 *vec, /* i : input vector Qx*/
+ const Word16 lvec /* i : length of input vector */
+);
+
+Word32 sum2_fx_mod( /* o : sum of all squared vector elements Q(2x+1)*/
+ const Word16 *vec, /* i : input vector Qx*/
+ const Word16 lvec /* i : length of input vector */
+);
+
+Word16 usdequant_fx( /* Qx*/
+ const Word16 idx, /* i: quantizer index Q0*/
+ const Word16 qlow, /* i: lowest codebook entry (index 0) Qx*/
+ const Word16 delta /* i: quantization step Qy*/
+);
+
+Word16 gain_dequant_fx( /* o: decoded gain */
+ Word16 index, /* i: quantization index */
+ const Word16 min, /* i: value of lower limit */
+ const Word16 max, /* i: value of upper limit */
+ const Word16 bits, /* i: number of bits to dequantize */
+ Word16 *expg
+);
+
+void Es_pred_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 *Es_pred, /* o : predicited scaled innovation energy Q8*/
+ const Word16 coder_type, /* i : coder type */
+ const Word32 core_brate /* i : core bitrate */
+);
+
+void gain_dec_tc_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 core_brate_fx, /* i : core bitrate */
+ const Word16 *code_fx, /* i : algebraic code excitation */
+ const Word16 L_frame_fx, /* i : length of the frame */
+ const Word16 i_subfr_fx, /* i : subframe number */
+ const Word16 tc_subfr_fx, /* i : TC subframe index */
+ const Word16 Es_pred_fx, /* i : predicted scaled innov. energy */
+ Word16 *gain_pit_fx, /* o : pitch gain */
+ Word32 *gain_code_fx, /* o : Quantized codeebook gain */
+ Word16 *gain_inov_fx, /* o : unscaled innovation gain */
+ Word32 *norm_gain_code_fx /* o : norm. gain of the codebook excit. */
+);
+
+void gain_dec_mless_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 core_brate_fx, /* i : core bitrate */
+ const Word16 L_frame_fx, /* i : length of the frame */
+ const Word16 coder_type_fx, /* i : coding type */
+ const Word16 i_subfr_fx, /* i : subframe number */
+ const Word16 tc_subfr_fx, /* i : TC subframe index */
+ const Word16 *code_fx, /* i : algebraic code excitation */
+ const Word16 Es_pred_fx, /* i : predicted scaled innov. energy */
+ Word16 *gain_pit_fx, /* o : Quantized pitch gain Q14*/
+ Word32 *gain_code_fx, /* o : Quantized codeebook gain Q16*/
+ Word16 *gain_inov_fx, /* o : unscaled innovation gain Q12*/
+ Word32 *norm_gain_code_fx /* o : norm. gain of the codebook excitation Q16*/
+);
+
+void pre_echo_att_fx(
+ Word32 *Last_frame_ener_fx, /* i/o: Energy of the last frame 2*Q_new+1*/
+ Word16 *exc_fx, /* i/o: Excitation of the current frame Q_new*/
+ const Word16 gsc_attack_flag_fx, /* i : flag signalling attack encoded by AC mode (GSC) */
+ const Word16 Q_new
+ ,const Word16 last_coder_type_fx /* i : Last coding mode */
+);
+
+void gain_dec_lbr_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 *code_fx, /* i : algebraic excitation Q12*/
+ Word16 *gain_pit_fx, /* o : quantized pitch gain Q14*/
+ Word32 *gain_code_fx, /* o : quantized codebook gain Q16*/
+ Word16 *gain_inov_fx, /* o : gain of the innovation (used for normalization) Q12*/
+ Word32 *norm_gain_code_fx, /* o : norm. gain of the codebook excitation Q16*/
+ Word32 gc_mem[], /* i/o: gain_code from previous subframes */
+ Word16 gp_mem[] /* i/o: gain_pitch from previous subframes */
+);
+
+void lp_gain_updt_fx(
+ const Word16 i_subfr, /* i : subframe number Q0 */
+ const Word16 gain_pit, /* i : Decoded gain pitch Q14 */
+ const Word32 norm_gain_code, /* i : Normalised gain code Q16 */
+ Word16 *lp_gainp, /* i/o: LP-filtered pitch gain(FEC) Q14 */
+ Word16 *lp_gainc, /* i/o: LP-filtered code gain (FEC) Q3 */
+ const Word16 L_frame /* i : length of the frame */
+);
+
+void pit_Q_dec_fx(
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 pitch_index, /* i : pitch index */
+ const Word16 nBits, /* i : # of Q bits */
+ const Word16 delta, /* i : Half the CL searched interval */
+ const Word16 pit_flag, /* i : absolute(0) or delta(1) pitch Q */
+ const Word16 limit_flag, /* i : restrained(0) or extended(1) Q limits */
+ Word16 *T0, /* o : integer pitch lag */
+ Word16 *T0_frac, /* o : pitch fraction */
+ Word16 *T0_min, /* i/o: delta search min */
+ Word16 *T0_max /* i/o: delta search max */
+ ,Word16 *BER_detect /* o : BER detect flag */
+);
+
+void abs_pit_dec_fx(
+ const Word16 fr_steps, /* i: fractional resolution steps (0, 2, 4) */
+ Word16 pitch_index, /* i: pitch index */
+ const Word16 limit_flag, /* i : restrained(0) or extended(1) limits */
+ Word16 *T0, /* o: integer pitch lag */
+ Word16 *T0_frac /* o: pitch fraction */
+);
+
+void limit_T0_fx(
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 delta, /* i : Half the close-loop searched interval */
+ const Word16 pit_flag, /* i : selecting absolute(0) or delta(1) pitch quantization */
+ const Word16 limit_flag, /* i : flag for Q limits (0=restrained, 1=extended) */
+ const Word16 T0, /* i : rough pitch estimate around which the search is done */
+ const Word16 T0_frac, /* i : pitch estimate fractional part */
+ Word16 *T0_min, /* o : lower pitch limit */
+ Word16 *T0_max /* o : higher pitch limit */
+);
+
+void delta_pit_dec_fx(
+ const Word16 fr_steps, /* i : fractional resolution steps (0, 2, 4) */
+ const Word16 pitch_index, /* i : pitch index */
+ Word16 *T0, /* o : integer pitch lag */
+ Word16 *T0_frac, /* o : pitch fraction */
+ const Word16 T0_min /* i : delta search min */
+);
+
+Word16 pit_decode_fx( /* o : floating pitch value */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 L_frame, /* i : length of the frame */
+ Word16 i_subfr, /* i : subframe index */
+ const Word16 coder_type, /* i : coding type */
+ Word16 *limit_flag, /* i/o: restrained(0) or extended(1) Q limits */
+ Word16 *T0, /* o : close loop integer pitch */
+ Word16 *T0_frac, /* o : close loop fractional part of the pitch */
+ Word16 *T0_min, /* i/o: delta search min for sf 2 & 4 */
+ Word16 *T0_max, /* i/o: delta search max for sf 2 & 4 */
+ const Word16 L_subfr /* i : subframe length */
+);
+
+void pred_lt4(
+ const Word16 excI[], /* in: excitation buffer */
+ Word16 excO[], /* out: excitation buffer */
+ Word16 T0, /* input : integer pitch lag */
+ Word16 frac, /* input : fraction of lag */
+ Word16 L_subfr, /* input : subframe size */
+ const Word16 *win, /* i : interpolation window */
+ const Word16 nb_coef, /* i : nb of filter coef */
+ const Word16 up_sample /* i : up_sample */
+);
+
+void lp_filt_exc_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 codec_type, /* i : coder type */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 L_subfr, /* i : subframe size */
+ const Word16 L_frame, /* i : frame size */
+ Word16 lp_flag, /* i : operation mode signalling */
+ Word16 *exc
+);
+
+void inov_decode_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 sharpFlag, /* i : formant sharpening flag */
+ const Word16 i_subfr, /* i : subframe index */
+ const Word16 tc_subfr, /* i : TC subframe index */
+ const Word16 *p_Aq, /* i : LP filter coefficients Q12 */
+ const Word16 tilt_code, /* i : tilt of the excitation of previous subframe Q15 */
+ const Word16 pt_pitch, /* i : pointer to current subframe fractional pitch Q6*/
+ Word16 *code /* o : algebraic excitation */
+);
+
+void dec_acelp_1t64_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 code[] /* o: algebraic (fixed) codebook excitation Q12*/
+);
+
+void dec_acelp_2t32_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 code[] /* o: algebraic (fixed) codebook excitation */
+);
+
+void dec_acelp_4t64_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 nbbits, /* i : number of bits per codebook */
+ Word16 code[], /* o : algebraic (fixed) codebook excitation Q9*/
+ const Word16 Opt_AMR_WB
+);
+
+void weight_a_lc_fx(
+ const Word16 a[], /* i: LP filter coefficients Q12 */
+ Word16 ap[], /* o: weighted LP filter coefficients Q12 */
+ const Word16 *gammatbl, /* i: weighting factor Q15 */
+ const Word16 m /* i: order of LP filter Q0 */
+);
+
+void weight_a_fx(
+ const Word16 a[], /* i: LP filter coefficients Q12 */
+ Word16 ap[], /* o: weighted LP filter coefficients Q12 */
+ const Word16 gamma, /* i: weighting factor Q15 */
+ const Word16 m /* i: order of LP filter Q0 */
+);
+
+void Residu3_lc_fx(
+ const Word16 a[], /* i : prediction coefficients Q12 */
+ const Word16 m, /* i : order of LP filter Q0 */
+ const Word16 x[], /* i : input signal (usually speech) Qx */
+ Word16 y[], /* o : output signal (usually residual) Qx */
+ const Word16 lg, /* i : vector size Q0 */
+ const Word16 shift /* i : 0=residu2, 1=residu */
+);
+
+void Residu3_10_fx(
+ const Word16 a[], /* i : prediction coefficients Q12 */
+ const Word16 x[], /* i : input signal (usually speech) Qx */
+ /* (note that values x[-10..-1] are needed) */
+ Word16 y[], /* o : output signal (usually residual) Qx */
+ const Word16 lg, /* i : vector size Q0 */
+ const Word16 shift /* i : 0=residu2, 1=residu */
+);
+
+void Residu3_fx(
+ const Word16 a[], /* i : prediction coefficients Q12 */
+ const Word16 x[], /* i : input signal (usually speech) Qx */
+ /* (note that values x[-M..-1] are needed) */
+ Word16 y[], /* o : output signal (usually residual) Qx */
+ const Word16 lg, /* i : vector size Q0 */
+ const Word16 shift /* i : 0=residu2, 1=residu */
+);
+
+void pre_exc_fx(
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 *speech, /* i : input speech Q_new-1*/
+ const Word16 *p_Aq, /* i : 12k8 Lp coefficient Q12*/
+ const Word16 *p_A, /* i : unquantized A(q) filter with bandwidth expansion Q12*/
+ const Word16 coder_type, /* i : coding type */
+ const Word16 i_subfr, /* i : current sub frame indicator */
+ Word16 *Ap, /* o : weighted LP filter coefficients Q12*/
+ const Word16 *res, /* i : residual signal Q_new*/
+ Word16 *exc, /* o : excitation signal Q_new*/
+ Word16 *h1, /* o : impulse response of weighted synthesis filter Q(14+shift)*/
+ Word16 *h2, /* o : impulse response of weighted synthesis filter Q(12+shift), for codebook search*/
+ Word16 *xn, /* o : close-loop Pitch search target vector Q_new-1+shift*/
+ Word16 *cn, /* o : target vector in residual domain Q_new*/
+ Word16 *mem_syn, /* i/o: memory of the synthesis filter Q_new-1*/
+ Word16 *mem_w0, /* i/o: weighting filter denominator memory Q_new-1*/
+ const Word16 L_subfr, /* i : subframe length */
+ Word16 shift
+);
+
+void encod_audio_fx(
+ Encoder_State_fx *st_fx, /* i/o: State structure */
+ LPD_state *mem, /* i/o: acelp memories */
+ const Word16 speech[], /* i : input speech Q_new */
+ const Word16 Aw_fx[], /* i : weighted A(z) unquantized for subframes */
+ const Word16 Aq_fx[], /* i : 12k8 Lp coefficient */
+ const Word16 T_op[], /* i : open loop pitch */
+ const Word16 voicing[], /* i : voicing Q15 */
+ const Word16 *res, /* i : residual signal Q_new */
+ Word16 *synth, /* i/o: core synthesis Q-1 */
+ Word16 *exc, /* i/o: current non-enhanced excitation Q_new */
+ Word16 *pitch_buf, /* i/o: floating pitch values for each subframe Q6 */
+ Word16 *voice_factors, /* o : voicing factors Q15 */
+ Word16 *bwe_exc, /* o : excitation for SWB TBE Q0 */
+ const Word16 gsc_attack_flag, /* i : Flag that point to an attack coded with AC mode (GSC) */
+ const Word16 coder_type, /* i : coding type */
+ Word16 *lsf_new, /* i : current frame ISF vector */
+ Word16 *tmp_noise, /* o : noise energy */
+ Word16 Q_new,
+ Word16 shift
+);
+
+Word16 pit_encode_fx( /* o : Fractional pitch for each subframe */
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 coder_type, /* i : coding type */
+ Word16 *limit_flag, /* i/o: restrained(0) or extended(1) Q limits */
+ const Word16 i_subfr, /* i : subframe index */
+ Word16 *exc, /* i/o: pointer to excitation signal frame */
+ const Word16 L_subfr, /* i : subframe length */
+ const Word16 *T_op, /* i : open loop pitch estimates in current frame */
+ Word16 *T0_min, /* i/o: lower limit for close-loop search */
+ Word16 *T0_max, /* i/o: higher limit for close-loop search */
+ Word16 *T0, /* i/o: close loop integer pitch */
+ Word16 *T0_frac, /* i/o: close loop fractional part of the pitch */
+ const Word16 *h1, /* i : weighted filter input response */
+ const Word16 *xn /* i : target vector */
+);
+
+Word32 dotp_fx( /* o : dot product of x[] and y[] */
+ const Word16 x[], /* i : vector x[] */
+ const Word16 y[], /* i : vector y[] */
+ const Word16 n, /* i : vector length */
+ Word16 * exp /* (o) : exponent of result (0..+30) */
+);
+
+Word32 syn_kern_16(
+ Word32 L_tmp,
+ const Word16 a[],
+ const Word16 y[]
+);
+
+void syn_filt_s_lc_fx(
+ const Word16 shift, /* i : scaling to apply Q0 */
+ const Word16 a[], /* i : LP filter coefficients Q12 */
+ const Word16 x[], /* i : input signal Qx */
+ Word16 y[], /* o : output signal Qx-s */
+ const Word16 lg /* i : size of filtering Q0 */
+);
+
+void acelp_2t32_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 dn[], /* i : corr. between target and h[]. */
+ const Word16 h[], /* i : impulse response of weighted synthesis filter */
+ Word16 code[], /* o : algebraic (fixed) codebook excitation */
+ Word16 y[] /* o : filtered fixed codebook excitation */
+);
+
+Word16 acelp_4t64_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 dn[], /* i : corr. between target and h[]. */
+ const Word16 cn[], /* i : residual after long term prediction Q_new*/
+ const Word16 H[], /* i : impulse response of weighted synthesis filter Q12*/
+ Word16 R[], /* i : autocorrelation values */
+ const Word16 acelpautoc, /* i : autocorrealtion flag */
+ Word16 code[], /* o : algebraic (fixed) codebook excitation Q9*/
+ Word16 y[], /* o : filtered fixed codebook excitation Q9*/
+ Word16 nbbits, /* i : number of bits per codebook */
+ const Word16 cmpl_flag, /* i : coomplexity reduction flag */
+ const Word16 Opt_AMR_WB /* i : flag indicating AMR-WB IO mode */
+);
+
+void acelp_1t64_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 dn[], /* i : corr. between target and h[]. */
+ const Word16 h[], /* i : impulse response of weighted synthesis filter */
+ Word16 code[], /* o : algebraic (fixed) codebook excitation */
+ Word16 y[] /* o : filtered fixed codebook excitation */
+);
+
+void cb_shape_fx(
+ const Word16 preemphFlag, /* i : flag for pre-emphasis */
+ const Word16 pitchFlag, /* i : flag for pitch sharpening */
+ const Word16 scramblingFlag, /* i : flag for phase scrambling */
+ const Word16 sharpFlag, /* i : flag for formant sharpening */
+ const Word16 formantTiltFlag, /* i : flag for formant tilt */
+ const Word16 g1, /* i : formant sharpening numerator weighting */
+ const Word16 g2, /* i : formant sharpening denominator weighting */
+ const Word16 *p_Aq, /* i : LP filter coefficients */
+ Word16 *code, /* i/o: signal to shape */
+ const Word16 tilt_code, /* i : tilt of code */
+ const Word16 pt_pitch, /* i : pointer to current subframe fractional pitch */
+ const Word16 shift
+);
+
+void corr_xh_fx(
+ const Word16 x[], /* i : target signal */
+ Word16 dn[], /* o : correlation between x[] and h[] */
+ const Word16 h[] /* i : impulse response (of weighted synthesis filter) */
+);
+
+void corr_xh_jopt_fx(
+ const Word16 h[], /* i : impulse response of weighted synthesis filter Q12 */
+ const Word16 x[], /* i : target vector Q0 */
+ Word16 dn[], /* o : correlation between target and h[] Q12 */
+ Word16 gain, /* i : Unquantized ACB gain Q14 */
+ Word16 clip, /* i : clip Q0 */
+ Word16 shift /* i : scaling of x Q0 */
+);
+
+void enhancer_fx(
+ const Word32 core_brate, /* i : decoder bitrate */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 i_subfr, /* i : subframe number */
+ const Word16 L_frame, /* i : frame size */
+ const Word16 voice_fac, /* i : subframe voicing estimation Q15 */
+ const Word16 stab_fac, /* i : LP filter stablility measure Q15 */
+ Word32 norm_gain_code,/* i : normalised innovative cb. gain Q16 */
+ const Word16 gain_inov, /* i : gain of the unscaled innovation Q12 */
+ Word32 *gc_threshold, /* i/o: gain code threshold Q16 */
+ Word16 *code, /* i/o: innovation Q12 */
+ Word16 *exc2, /* i/o: adapt. excitation/total exc. Q_exc*/
+ const Word16 gain_pit, /* i : quantized pitch gain Q14 */
+ struct dispMem_fx *dm_fx, /* i/o: phase dispersion algorithm memory */
+ const Word16 Q_exc /* i : Q of the excitation */
+);
+
+Word16 Rescale_exc(
+ Word16 dct_post_old_exc_fx[], /* i/o: Music post processing memory */
+ Word16 exc[], /* i/o: excitation to rescale Q_exc */
+ Word16 bwe_exc[],
+ Word16 *last_exc_dct_in,
+ Word16 lg, /* i : frame size */
+ Word16 lg32,
+ Word32 L_gain_code, /* i : decoded codebook gain Q16 */
+ Word16 *sQ_exc, /* i/o: Excitation scaling factor */
+ Word16 *sQsubfr, /* i/o: Past excitation scaling factors */
+ Word16 exc2[], /* o : local excitation vector */
+ Word16 i_subfr, /* i : subframe number */
+ const Word16 coder_type
+);
+
+void Prep_music_postP_fx(
+ Word16 exc_buffer_in[], /* i/o: excitation buffer Q_exc*/
+ Word16 dct_buffer_out[], /* o : DCT output buffer (qdct)*/
+ Word16 filt_lfE[], /* i/o: long term spectrum energy Q15 */
+ const Word16 last_core, /* i : last core */
+ const Word16 *pitch_buf, /* i : current frame pitch information Q6*/
+ Word16 *LDm_enh_lp_gbin, /* o : smoothed suppression gain, per bin FFT Q15*/
+ const Word16 Q_exc, /* i : excitation scaling */
+ Word16 *qdct /* o : Scaling factor of dct coefficient */
+);
+
+void Post_music_postP_fx(
+ Word16 dct_buffer_in[], /* i/o: excitation buffer */
+ Word16 *exc2, /* i/o: Current excitation to be overwriten */
+ const Word16 *mem_tmp, /* i : previous frame synthesis memory */
+ Word16 *st_mem_syn2, /* i/o: current frame synthesis memory */
+ const Word16 *Aq, /* i : LPC filter coefficients */
+ Word16 *syn, /* i/o: 12k8 synthesis */
+ Word16 *Q_exc, /* i : excitation scaling */
+ Word16 *prev_Q_syn, /* i : previsous frame synthesis scaling */
+ Word16 *Q_syn, /* i : Current frame synthesis scaling */
+ Word16 *mem_syn_clas_estim_fx, /* i : old 12k8 synthesis used for frame classification*/
+ const Word16 IsIO, /* i: Flag to indicate IO mode */
+ Word16 *mem_deemph, /* i/o: speech deemph filter memory */
+ Word16 *st_pst_old_syn_fx, /* i/o: psfiler */
+ Word16 *st_pst_mem_deemp_err_fx, /* i/o: psfiler */
+ Word16 *mem_agc,
+ PFSTAT *pf_stat, /* i/o: All memories related to NB post filter */
+ const Word16 *tmp_buffer /* tmp_buffer in Q-1 */
+ ,Word16 *mem_tmp2 /* Temporary memory used with scale_syn */
+);
+
+void unscale_AGC(
+ const Word16 x[],
+ const Word16 Qx,
+ Word16 y[],
+ Word16 mem[],
+ const Word16 n
+);
+
+void LD_music_post_filter_fx(
+ const Word16 dtc_in[], /* i : input synthesis Qdct */
+ Word16 dtc_out[], /* o : output synthesis Qdct */
+ const Word32 core_brate, /* i : core bitrate Q0 */
+ Word16 *last_music_flag, /* i/o : Previous music detection ouptut Q0 */
+ Word16 *thresh, /* i/o : Detection thresold Q0 */
+ Word16 *nb_thr_1, /* i/o : Number of consecutives frames of level 1 Q0 */
+ Word16 *nb_thr_3, /* i/o : Number of consecutives frames of level 3 Q0 */
+ Word16 *lt_diff_etot, /* i/o : Long term total energy variation Q8 */
+ Word16 *mem_etot, /* i/o : Total energy memory Q8 */
+ const Word16 min_ns_gain, /* i : minimum gain for inter-harm noise red. Q15 */
+ Word32 bckr[], /* i/o : per band bckgnd. noise energy estimate */
+ Word32 lf_EO[], /* i/o : old per bin E for previous half frame 2*Qdct+10 */
+ Word16 lp_gbin[], /* i/o : smoothed suppression gain, per FFT bin Q15 */
+ Word16 *filt_lfE, /* i : post filter weighting coefficient Q15 */
+ Word16 *last_nonfull_music, /* i : Number of frames sinces la "speech like" frame Q0*/
+ Word16 *Old_ener_Q, /* i/o : Old energy scaling factor */
+ const Word16 coder_type, /* i : Coder type : -1 in case of IO Q0 */
+ const Word16 Last_coder_type, /* i : input scaling Q0 */
+ const Word16 Qdct /* i : input scaling Q0 */
+);
+
+void Rescale_mem(
+ const Word16 Q_exc, /* i : current excitation scaling (>=0) */
+ Word16 *prev_Q_syn, /* i/o : scaling factor of previous frame */
+ Word16 *Q_syn, /* i/o : scaling factor of frame */
+ Word16 *mem_syn2, /* i/o : modified synthesis memory */
+ Word16 *mem_syn_clas_estim_fx, /* i/o : old 12k8 core memory for classification */
+ const Word16 MaxScaling, /* i: Minimal difference between excitation scaling and synthesis scaling */
+ Word16 *mem_deemph, /* i/o: speech deemph filter memory */
+ Word16 *pst_old_syn, /* i/o: psfiler */
+ Word16 *pst_mem_deemp_err, /* i/o: psfiler */
+ Word16 *mem_agc,
+ PFSTAT *pf_stat, /* i/o: All memories related to NB post filter */
+ const Word16 Vad_flag,
+ const Word16 Cna_flag,
+ const Word16 *tmp_buffer /* tmp_buffer in Q-1 */
+);
+
+void Scale_sig(
+ Word16 x[], /* i/o: signal to scale Qx */
+ const Word16 lg, /* i : size of x[] Q0 */
+ const Word16 exp0 /* i : exponent: x = round(x << exp) Qx ?exp */
+);
+
+void isf2lsf_fx(
+ const Word16 *isf, /* i : ISF vector */
+ Word16 *lsf, /* o : LSF vector */
+ Word16 *stable_lsp /* i/o: stable LSP filter coefficients */
+);
+
+void isp2lsp_fx(
+ const Word16 *isp, /* i : LSP vector */
+ Word16 *lsp, /* o : ISP filter coefficients */
+ Word16 *stable_lsp, /* i/o: stable LSP filter coefficients */
+ const Word16 m /* i : order of LP analysis */
+);
+
+void lsf2isf_fx(
+ const Word16 *lsf, /* i : LSF vector */
+ Word16 *isf, /* o : ISF vector */
+ Word16 *stable_isp, /* i/o: stable ISP filter coefficients */
+ const Word16 m /* i : order of LP analysis */
+);
+
+void lsp2isp_fx(
+ const Word16 *lsp, /* i : LSP vector */
+ Word16 *isp, /* o : ISP filter coefficients */
+ Word16 *stable_isp, /* i/o: ISP filter coefficients */
+ const Word16 m /* i : order of LP analysis */
+);
+
+void updt_IO_switch_dec_fx(
+ const Word16 output_frame, /* i : output frame length */
+ Decoder_State_fx *st_fx /* o : Decoder static variables structure */
+);
+
+void prep_tbe_exc_fx(
+ const Word16 L_frame_fx, /* i : length of the frame */
+ const Word16 i_subfr_fx, /* i : subframe index */
+ const Word16 gain_pit_fx, /* i : Pitch gain Q14*/
+ const Word32 gain_code_fx, /* i : algebraic codebook gain 16+Q_exc*/
+ const Word16 code_fx[], /* i : algebraic excitation Q9*/
+ const Word16 voice_fac_fx, /* i : voicing factor Q15*/
+ Word16 *voice_factors_fx, /* o : TBE voicing factor Q15*/
+ Word16 bwe_exc_fx[], /* i/o: excitation for TBE Q_exc*/
+ const Word16 gain_preQ_fx, /* i : prequantizer excitation gain */
+ const Word16 code_preQ_fx[], /* i : prequantizer excitation */
+ const Word16 Q_exc, /* i : Excitation, bwe_exc Q-factor */
+ Word16 T0, /* i : integer pitch variables Q0 */
+ Word16 T0_frac, /* i : Fractional pitch variables Q0*/
+ const Word16 coder_type, /* i : coding type */
+ Word32 core_brate /* i :core bitrate */
+);
+
+void interp_code_5over2_fx(
+ const Word16 inp_code[], /* i : input vector */
+ Word16 interp_code[], /* o : output vector */
+ const Word16 inp_length /* i : length of input vector */
+);
+
+void lsp2lsf_fx(
+ const Word16 lsp[], /* i : lsp[m] (range: -1<=val<1) Q15*/
+ Word16 lsf[], /* o : lsf[m] normalized (range: 0.0<=val<=0.5) Q(x2.56)*/
+ const Word16 m, /* i : LPC order Q0*/
+ Word32 int_fs
+);
+
+void lsf_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 coder_type, /* i : coding type */
+ Word16 *lsf_new, /* o : quantized LSF vector */
+ Word16 *lsp_new, /* i/o: LSP vector to quantize/quantized */
+ Word16 *lsp_mid, /* i/o : mid-frame LSP vector */
+ Word16 *Aq, /* o : quantized A(z) for 4 subframes */
+ Word16 *stab_fac, /* o : LSF stability factor */
+ const Word16 Nb_ACELP_frames,
+ const Word16 Q_new
+);
+
+void lsf_mid_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 int_fs, /* i : internal (ACELP) sampling frequency */
+ Word16 qlsp0[], /* i : quantized LSPs from frame beginning Q15*/
+ Word16 qlsp1[], /* i : quantized LSPs from frame endSQ15*/
+ Word16 coder_type, /* i : Coder type */
+ Word16 qlsp[], /* o : quantized LSPs Q15*/
+ const Word32 core_brate, /* i : core bitrate */
+ Word16 ppp_mode,
+ Word16 nelp_mode,
+ Word16 prev_bfi,
+ Word16 *mid_lsf_int,
+ Word16 safety_net
+);
+
+Word16 lsf_stab_fx( /* o : LP filter stability Q15*/
+ const Word16 *lsf, /* i : LSF vector Q(x2.56)*/
+ const Word16 *lsfold, /* i : old LSF vector Q(x2.56)*/
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 L_frame /* i : frame length */
+);
+
+void lsf_allocate_fx(
+ const Word16 nBits, /* i : Number of bits to use for quantization */
+ const Word16 framemode, /* i : ISF quantizer mode */
+ const Word16 framemode_p, /* i : ISF quantizer mode predmode (mode_lvq_p) */
+ Word16 *stages0, /* o : Number of stages for safety-net quantizer */
+ Word16 *stages1, /* o : Number of stages for predictive quantizer */
+ Word16 levels0[], /* o : Number of vectors for each stage for SFNET */
+ Word16 levels1[], /* o : Number of vectors for each stage for pred */
+ Word16 bits0[], /* o : Number of bits for each stage safety net */
+ Word16 bits1[] /* o : Number of bits for each stage pred */
+);
+Word16 vq_dec_lvq_fx (
+ Word16 sf_flag, /* i : safety net flag */
+ Word16 x[], /* o : Decoded vector Q(x2.56)*/
+ Word16 indices[], /* i : Indices */
+ Word16 stages, /* i : Number of stages */
+ Word16 N, /* i : Vector dimension */
+ Word16 mode, /* (i): mode_lvq, or mode_lvq_p */
+ Word16 no_bits, /* (i): no. bits for lattice */
+ Word32 *p_offset_scale1,
+ Word32 *p_offset_scale2,
+ Word32 *p_offset_scale1_p,
+ Word32 *p_offset_scale2_p,
+ Word16 *p_no_scales,
+ Word16 *p_no_scales_p
+);
+
+Word16 qlsf_ARSN_tcvq_Dec_16k_fx (
+ Word16 *y_fx, /* o : Quantized LSF vector */
+ Word16 *indice, /* i : Indices */
+ const Word16 nBits /* i : number of bits */
+);
+
+void tcvq_Dec_fx(Word16 *ind,
+ /*float *d_out, */
+ Word16 *d_out_fx,
+ Word16 safety_net
+ );
+
+Word32 qlsf_ARSN_tcvq_Enc_16k_fx(
+ const Word16 *x_fx, /* i : Vector to be encoded x2.65 */
+ Word16 *y_fx, /* o : Quantized LSF vector x2.65 */
+ Word16 *indice, /* o : Indices */
+ const Word16 *w_fx, /* i : LSF Weights Q10 */
+ const Word16 nBits, /* i : number of bits */
+ Word16 safety_net /* i : safety_net flag */
+);
+
+void Vr_add(
+ const Word16 *in1, /* i : Input vector 1 */
+ const Word16 *in2, /* i : Input vector 2 */
+ Word16 *out, /* o : Output vector that contains vector 1 + vector 2 */
+ Word16 Len /* i : Vector lenght */
+);
+
+void Vr_subt(
+ const Word16 *in1, /* i : Input vector 1 */
+ const Word16 *in2, /* i : Input vector 2 */
+ Word16 *out, /* o : Output vector that contains vector 1 + vector 2 */
+ Word16 Len /* i : Vector lenght */
+);
+
+void index_lvq_fx (
+ Word16 *quant, /* i : codevector to be indexed (2 8-dim subvectors) Q13*/
+ Word16 *idx_lead, /* i : leader class index for each subvector */
+ Word16 *idx_scale, /* i : scale index for each subvector */
+ Word16 mode, /* i : integer signalling the quantizer structure for the current bitrate */
+ Word16 *index, /* o : encoded index (represented on 3 short each with 15 bits ) */
+ Word32 * p_offset_scale1,
+ Word32 * p_offset_scale2,
+ Word16 * p_no_scales
+);
+
+void multiply32_32_64_fx(
+ Word32 x,
+ Word32 y,
+ Word32 *res
+);
+
+void permute_fx(
+ Word16 *pTmp1, /* i/o: vector whose components are to be permuted */
+ const Word16 *perm /* i : permutation info (indexes that should be interchanged), max two perms */
+);
+
+Word32 mslvq_fx (
+ Word16 *pTmp, /* i : M-dimensional input vector */
+ Word16 *quant, /* o : quantized vector */
+ Word16 *cv_out, /* o : corresponding 8-dim lattice codevectors (without the scaling) */
+ Word16 *idx_lead, /* o : leader index for each 8-dim subvector */
+ Word16 *idx_scale, /* o : scale index for each subvector */
+ Word16 *w, /* i : weights for LSF quantization */
+ Word16 mode, /* i : number indicating the coding type (V/UV/G...)*/
+ Word16 mode_glb, /* i : LVQ coding mode */
+ Word16 pred_flag, /* i : prediction flag (0: safety net, 1 - predictive )*/
+ Word16 no_scales[][2]
+);
+
+Word32 mslvq_cng_fx (
+ Word16 idx_cv, /* i : index of cv from previous stage */
+ Word16 *pTmp, /* i : 16 dimensional input vector x2.56*/
+ Word16 *quant, /* o : quantized vector x2.56*/
+ Word16 *cv_out, /* o : corresponding 8-dim lattice codevectors (without the scaling) Q13*/
+ Word16 *idx_lead, /* o : leader index for each 8-dim subvector */
+ Word16 *idx_scale, /* o : scale index for each subvector */
+ const Word16 *w, /* i : weights for LSF quantization Q10*/
+ Word16 * no_scales
+);
+
+void sort_fx(
+ Word16 *r, /* i/o: Vector to be sorted in place */
+ Word16 lo, /* i : Low limit of sorting range */
+ Word16 up /* I : High limit of sorting range */
+);
+
+void lsf_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: State structure */
+ const Word16 tc_subfr, /* i : TC subframe index */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 bwidth, /* i : input signal bandwidth */
+ Word16 *Aq, /* o : quantized A(z) for 4 subframes */
+ Word16 *LSF_Q_prediction, /* o : LSF prediction mode */
+ Word16 *lsf_new, /* o : de-quantized LSF vector */
+ Word16 *lsp_new, /* o : de-quantized LSP vector */
+ Word16 *lsp_mid /* o : de-quantized mid-frame LSP vector */
+);
+
+void lsf_end_enc_fx(
+ Encoder_State_fx *st,
+ const Word16 *lsf,
+ Word16 *qlsf,
+ Word16 *mem_AR,
+ Word16 * mem_MA,
+ const Word16 nBits,
+ const Word16 coder_type_org,
+ const Word16 bwidth,
+ Word32 *Bin_Ener,
+ Word16 Q_ener,
+ const Word32 int_fs,
+ Word32 core_brate,
+ Word16 *streaklimit,
+ Word16 *pstreaklen,
+ Word16 force_sf,
+ Word16 RF_flag,
+ Word16 mode2_flag,
+ Word16 * lpc_param,
+ Word16 * no_stages,
+ Word16 * bits_param_lpc,
+ Word16 coder_type_raw
+);
+
+void lsf_end_dec_fx(
+ Decoder_State_fx *st,
+ Word16 mode2_flag,
+ const Word16 coder_type_org,
+ const Word16 bwidth,
+ const Word16 nBits,
+ Word16 *qlsf,
+ Word16 *mem_AR,
+ Word16 *mem_MA,
+ const Word32 int_fs,
+ Word32 core_brate,
+ Word32 *p_offset_scale1,
+ Word32 *p_offset_scale2,
+ Word32 *p_offset_scale1_p,
+ Word32 *p_offset_scale2_p,
+ Word16 *p_no_scales,
+ Word16 *p_no_scales_p,
+ Word16 *safety_net,
+ Word16 *lpc_param,
+ Word16 *LSF_Q_prediction, /* o : LSF prediction mode */
+ Word16 * nb_indices
+);
+
+Word16 find_pred_mode(
+ const Word16 coder_type,
+ const Word16 bwidth,
+ const Word32 int_fs,
+ Word16 * p_mode_lvq,
+ Word16 * p_mode_lvq_p,
+ Word32 core_brate
+);
+
+Word16 xsf_to_xsp(
+ Word16 lsf
+);
+
+Word16 xsp_to_xsf(
+ Word16 lsp
+);
+
+void int_lsp4_fx(
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 lsp_old[], /* i : LSPs from past frame Q15*/
+ const Word16 lsp_mid[], /* i : LSPs from mid-frame Q15*/
+ const Word16 lsp_new[], /* i : LSPs from present frame Q15*/
+ Word16 *Aq, /* o : LP coefficients in both subframes Q12*/
+ const Word16 m, /* i : order of LP filter */
+ Word16 relax_prev_lsf_interp /* i : relax prev frame lsf interp after erasure */
+);
+
+Word16 modify_Fs_fx( /* o : length of output Q0 */
+ const Word16 sigIn_fx[], /* i : signal to decimate Q0 */
+ Word16 lg, /* i : length of input Q0 */
+ const Word32 fin, /* i : frequency of input Q0 */
+ Word16 sigOut_fx[], /* o : decimated signal Q0 */
+ const Word32 fout, /* i : frequency of output Q0 */
+ Word16 mem_fx[], /* i/o: filter memory Q0 */
+ const Word16 nblp /* i : flag indicating if NB low-pass is applied */
+);
+
+void addBassPostFilterFx(
+ const Word16 *harm_timeIn_Fx,
+ Word32 **rAnalysis_Fx,
+ Word32 **iAnalysis_Fx,
+ HANDLE_CLDFB_FILTER_BANK cldfbBank_bpf_Fx,
+ Word32 *workBuffer,
+ const Word16 timeIn_e,
+ const Word16 nTimeSlots,
+ const Word16 nTimeSlotsTotal,
+ const Word16 nBandsTotal,
+ CLDFB_SCALE_FACTOR *cldfb_scale
+);
+
+void bass_psfilter_fx(
+ const Word16 Opt_AMR_WB, /* i : AMR-WB IO flag */
+ Word16 synth_in_fx[], /* i : input synthesis (at 16kHz) */
+ const Word16 L_frame, /* i : length of the last frame */
+ Word16 pitch_buf_fx[], /* i : pitch for every subfr [0,1,2,3] */
+ Word16 old_syn_fx[], /* i/o: NBPSF_PIT_MAX */
+ Word16 *mem_deemph_err, /* o : Error deemphasis memory */
+ Word16 *lp_ener, /* o : long_term error signal energy */
+ const Word16 bpf_off, /* i : do not use BPF when set to 1 */
+ Word16 v_stab_fx, /* i : stability factor */
+ Word16 *v_stab_smooth_fx, /* i/o: smoothed stability factor */
+ Word16 *mem_mean_pit, /* i/o: average pitch memory */
+ Word16 *Track_on_hist, /* i/o: History of half frame usage */
+ Word16 *vibrato_hist, /* i/o: History of frames declared as vibrato*/
+ Word16 *psf_att, /* i/o: Post filter attenuation factor */
+ const Word16 coder_type, /* i : coder_type */
+ Word16 Q_syn,
+ Word16 bpf_noise_buf[] /* o : BPF error signal (at int_fs) */
+);
+
+void speech_music_classif_fx(
+ Encoder_State_fx *st, /* i/o: state structure */
+ Word16 *sp_aud_decision0,
+ Word16 *sp_aud_decision1, /* o : 1st stage speech/music */
+ Word16 *sp_aud_decision2, /* o : 2nd stage speech/music */
+ const Word16 *new_inp, /* i : new input signal */
+ const Word16 *inp, /* i : input signal to locate attach position */
+ const Word16 vad_flag,
+ const Word16 localVAD,
+ const Word16 localVAD_HE_SAD, /* i : HE-SAD flag without hangover */
+ const Word16 pitch[3], /* i : open-loop pitch estimate in three subframes */
+ const Word16 voicing[3], /* i : voicing estimate in three subframes Q15 */
+ const Word16 lsp_new[M], /* i : LSPs in current frame Q15 */
+ const Word16 cor_map_sum, /* i : correlation map sum (from multi-harmonic anal.)Q8*/
+ const Word32 epsP[M+1], /* i : LP prediciton error Q_esp*/
+ const Word32 PS[], /* i : energy spectrum Q_new+QSCALE*/
+ const Word16 Etot, /* i : total frame energy Q8 */
+ const Word16 old_cor, /* i : max correlation from previous frame Q15 */
+ Word16 *coder_type, /* i/o: coding type */
+ Word16 *attack_flag, /* o : flag to indicate if attack is to be treated by TC or GSC */
+ Word16 non_sta, /* i : unbound non-stationarity for sp/mus classifier */
+ Word16 relE, /* i : relative frame energy */
+ Word16 Q_esp, /* i : scaling of esP */
+ Word16 Q_inp /* i : scaling of input */
+ ,Word16 *high_lpn_flag_ptr /* o : noise log prob flag for NOISE_EST */
+ ,Word16 flag_spitch /* i: flag to indicate very short stable pitch */
+);
+
+Word32 sub_lsp2lsf_fx(
+ const Word16 lsp_i /* i : lsp[m] (range: -1<=val<1) Q15*/
+);
+Word16 lsp_convert_poly_fx(
+ Word16 w[], /* i/o: LSP or ISP parameters */
+ const Word16 L_frame, /* i : flag for up or down conversion */
+ const Word16 Opt_AMRWB /* i : flag for the AMR-WB IO mode */
+);
+
+void StableHighPitchDetect_fx(
+ Word16 *flag_spitch, /* o : flag to indicate very short stable pitch */
+ Word16 pitch[], /* i/o: OL pitch buffer */
+ const Word16 voicing[], /* i : OL pitch gains */
+ const Word16 wsp[], /* i : weighted speech */
+ const Word16 localVAD,
+ Word16 *voicing_sm, /* i/o: smoothed open-loop pitch gains */
+ Word16 *voicing0_sm, /* i/o: smoothed high pitch gains */
+ Word16 *LF_EnergyRatio_sm, /* i/o: smoothed [0, 300Hz] relative peak energy*/
+ Word16 *predecision_flag, /* i/o: predecision flag */
+ Word32 *diff_sm, /* i/o: smoothed pitch frequency difference */
+ Word32 *energy_sm , /* i/o: smoothed energy around pitch frequency */
+ Word16 Q_new,
+ Word16 EspecdB[]
+);
+
+void Es_pred_enc_fx(
+ Word16 *Es_pred, /* o : predicited scaled innovation energy Q8 */
+ Word16 *indice, /* o : indice of quantization */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 *res, /* i : residual signal */
+ const Word16 *voicing, /* i : normalized correlation in three 1/2frames */
+ const Word16 nb_bits, /* i : allocated number of bits */
+ const Word16 no_ltp, /* i : no_ltp flag */
+ Word16 Q_new /* i : Scaling in speech Q0 */
+);
+
+void calc_residu_fx(
+ Encoder_State_fx *st, /* i/o: state structure */
+ const Word16 *speech, /* i : weighted speech signal */
+ Word16 *res, /* o : residual signal */
+ const Word16 *p_Aq, /* i : quantized LP filter coefficients */
+ const Word16 vad_hover_flag,
+ const Word16 vad_flag_dtx
+);
+void updt_IO_switch_enc_fx(
+ Encoder_State_fx *st, /* i/o: state structure */
+ const Word16 input_frame /* i : input frame length */
+);
+/*-------------------------------------------------------------------*
+ * pre_proc()
+ *
+ * Pre-processing (spectral analysis, LP analysis, VAD, OL pitch calculation, coder mode selection, ...)
+ *--------------------------------------------------------------------*/
+
+void pre_proc_fx(
+ Encoder_State_fx *st, /* i/o: encoder state structure */
+ const Word16 input_frame, /* i : frame length */
+ const Word16 signal_in[], /* i : new samples */
+ Word16 old_inp_12k8[], /* i/o: buffer of old input signal */
+ Word16 old_inp_16k[], /* i/o: buffer of old input signal @ 16kHz */
+ Word16 **inp, /* o : ptr. to inp. signal in the current frame */
+ Word16 *sp_aud_decision1, /* o : 1st stage speech/music classification */
+ Word16 *sp_aud_decision2, /* o : 2nd stage speech/music classification */
+ Word32 fr_bands[2*NB_BANDS], /* o : energy in frequency bands */
+ Word16 *vad_flag,
+ Word16 *localVAD,
+ Word16 *Etot, /* o : total energy */
+ Word32 *ener, /* o : residual energy from Levinson-Durbin */
+ Word16 pitch[3], /* o : open-loop pitch values for quantiz. */
+ Word16 voicing[3], /* o : OL maximum normalized correlation */
+ Word16 A[NB_SUBFR16k*(M+1)], /* o : A(z) unquantized for the 4 subframes */
+ Word16 Aw[NB_SUBFR16k*(M+1)], /* o : weighted A(z) unquantized for subframes */
+ Word16 epsP_h[M+1], /* o : LP prediction errors */
+ Word16 epsP_l[M+1], /* o : LP prediction errors */
+ Word32 epsP[M+1], /* o : LP prediction errors */
+ Word16 lsp_new[M], /* o : LSPs at the end of the frame */
+ Word16 lsp_mid[M], /* o : LSPs in the middle of the frame */
+ Word16 *coder_type, /* o : coder type */
+ Word16 *sharpFlag, /* o : formant sharpening flag */
+ Word16 *vad_hover_flag,
+ Word16 *attack_flag, /* o : flag signalling attack encoded by AC mode (GSC) */
+ Word16 *new_inp_resamp16k, /* o : new input signal @16kHz, non pre-emphasised, used by the WB TBE/BWE */
+ Word16 *Voicing_flag, /* o : voicing flag for HQ FEC */
+
+ Word32 realBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX], /* i/o : cldfb real buffer */
+ Word32 imagBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX], /* i/o : cldfb imag buffer */
+ CLDFB_SCALE_FACTOR *cldfbScale, /* o : cldfb scale */
+ Word16 *old_exc, /* i/o: static excitation memory */
+ Word16 *hq_core_type, /* o : HQ core type */
+ Word16 *Q_new,
+ Word16 *shift,
+ Word16 *Q_r
+);
+
+Word16 mdct_classifier_fx( /* o: MDCT A/B decision */
+ const Word16 *Y, /* i: re[0], re[1], ..., re[n/2], im[n/2 - 1], im[n/2 - 2], ..., im[1] */
+ Encoder_State_fx *st_fx, /* i/o: Encoder state variable */
+ Word16 vadflag
+ ,Word32 *cldfbBuf_Ener
+ ,Word16 enerBuffer_exp
+);
+
+void floating_point_add(
+ Word32 *mx, /* io: mantissa of the addend Q31 */
+ Word16 *ex, /* io: exponent of the addend Q0 */
+ const Word32 my, /* i: mantissa of the adder Q31 */
+ const Word16 ey /* i: exponent of the adder Q0 */
+);
+
+void MDCT_selector(
+ Encoder_State_fx *st /* i/o: Encoder State */
+ , Word16 sp_floor /* i : Noise floor estimate Q7 */
+ , Word16 Etot /* i : Total energy Q8 */
+ , Word16 cor_map_sum /* i : harmonicity factor Q8 */
+ , const Word16 voicing[] /* i : voicing factors Q15*/
+ , const Word32 enerBuffer[] /* i : CLDFB buffers */
+ , Word16 enerBuffer_exp /* i : exponent of enerBuffer */
+ , Word16 vadflag
+);
+
+void MDCT_selector_reset(
+ Encoder_State_fx *st); /* i/o: Encoder State */
+
+Word16 minimum_fx( /* o : index of the minimum value in the input vector */
+ const Word16 *vec_fx, /* i : input vector */
+ const Word16 lvec_fx, /* i : length of input vector */
+ Word16 *min_fx /* o : minimum value in the input vector */
+);
+Word16 minimum_32_fx( /* o : index of the minimum value in the input vector */
+ const Word32 *vec_fx, /* i : input vector */
+ const Word16 lvec_fx, /* i : length of input vector */
+ Word32 *min_fx /* o : minimum value in the input vector */
+);
+Word16 maximum_32_fx( /* o : index of the maximum value in the input vector */
+ const Word32 *vec, /* i : input vector */
+ const Word16 lvec, /* i : length of input vector */
+ Word32 *max /* o : maximum value in the input vector */
+);
+Word16 maximum_fx( /* o : index of the maximum value in the input vector */
+ const Word16 *vec_fx, /* i : input vector */
+ const Word16 lvec_fx, /* i : length of input vector */
+ Word16 *max_fx /* o : maximum value in the input vector */
+);
+Word16 Exp32Array(
+ const Word16 n, /* (i): Array size */
+ const Word32 *sx /* (i): Data array */
+);
+Word16 Exp16Array(
+ const Word16 n, /* (i): Array size */
+ const Word16 *sx /* (i): Data array */
+);
+
+Word32 sum16_32_fx( /* o : sum of all vector elements Qx*/
+ const Word16 *vec, /* i : input vector Qx*/
+ const Word16 lvec /* i : length of input vector */
+);
+Word32 dot_product_mat_fx( /* o : the dot product x'*A*x */
+ const Word16 *x, /* i : vector x Q15 */
+ const Word32 *A, /* i : matrix A Q0*/
+ const Word16 m /* i : vector & matrix size */
+
+);
+
+Word16 std_fx( /* o: standard deviation */
+ const Word16 *x, /* i: input vector */
+ const Word16 len /* i: length of the input vector */
+);
+
+Word16 stab_est_fx(
+ Word16 etot, /* i : Total energy of the current frame */
+ Word16 *lt_diff_etot, /* i/o : Long term total energy variation */
+ Word16 *mem_etot, /* i/o : Total energy memory */
+ Word16 *nb_thr_3, /* i/o : Number of consecutives frames of level 3 */
+ Word16 *nb_thr_1, /* i/o : Number of consecutives frames of level 1 */
+ Word16 *thresh, /* i/o : Detection thresold */
+ Word16 *last_music_flag,/* i/o : Previous music detection ouptut */
+ Word16 vad_flag
+);
+Word16 var_fx( /* o: variance of vector Qx*/
+ const Word16 *x, /* i: input vector Qx*/
+ const Word16 Qx,
+ const Word16 len /* i: length of inputvector */
+);
+void conv_fx(
+ const Word16 x[], /* i : input vector Q_new*/
+ const Word16 h[], /* i : impulse response (or second input vector) Q(15)*/
+ Word16 y[], /* o : output vetor (result of convolution) 12 bits*/
+ const Word16 L /* i : vector size */
+);
+void norm_corr_fx(
+ const Word16 exc[], /* i : excitation buffer Q_new*/
+ const Word16 xn[], /* i : target signal Q_new-1+shift*/
+ const Word16 h[], /* i : weighted synthesis filter impulse response Q(14+shift)*/
+ const Word16 t_min, /* i : minimum value of searched range */
+ const Word16 t_max, /* i : maximum value of searched range */
+ Word16 ncorr[], /* o : normalized correlation Q15 */
+ const Word16 L_subfr /* i : subframe size */
+);
+void pit_Q_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode */
+ const Word16 nBits, /* i : # of Q bits */
+ const Word16 delta, /* i : Half the CL searched interval */
+ const Word16 pit_flag, /* i : absolute(0) or delta(1) pitch Q */
+ const Word16 limit_flag, /* i : restrained(0) or extended(1) Q limits */
+ const Word16 T0, /* i : integer pitch lag */
+ const Word16 T0_frac, /* i : pitch fraction */
+ Word16 *T0_min, /* i/o: delta search min */
+ Word16 *T0_max /* o : delta search max */
+);
+/*void pit16k_Q_enc_fx( */
+/*Encoder_State_fx *st_fx, */ /* i/o: encoder state structure */
+/* const Word16 nBits, */ /* i : # of Q bits */
+/* const Word16 i_subfr, */ /* i : subframe index */
+/* const Word16 limit_flag, */ /* i : restrained(0) or extended(1) Q limits */
+/* const Word16 T0, */ /* i : integer pitch lag */
+/* const Word16 T0_frac, */ /* i : pitch fraction */
+/* Word16 *T0_min, */ /* i/o: delta search min */
+/* Word16 *T0_max */ /* o : delta search max */
+/*); */
+
+Word16 pitch_fr4_fx( /* o : chosen integer pitch lag */
+ const Word16 exc[], /* i : excitation buffer Q_new*/
+ const Word16 xn[], /* i : target signal Q_new-1+shift*/
+ const Word16 h[], /* i : weighted synthesis filter impulse response Q(14+shift)*/
+ const Word16 t0_min, /* i : minimum value in the searched range. Q0*/
+ const Word16 t0_max, /* i : maximum value in the searched range. Q0*/
+ Word16 *pit_frac, /* o : chosen fraction (0, 1, 2 or 3) */
+ const Word16 i_subfr, /* i : flag to first subframe */
+ const Word16 limit_flag, /* i : flag for limits (0=restrained, 1=extended) */
+ const Word16 t0_fr2, /* i : minimum value for resolution 1/2 */
+ const Word16 t0_fr1, /* i : minimum value for resolution 1 */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 L_subfr /* i : size of subframe */
+);
+
+Word32 var_fx_32( /* o: variance of vector Qx+16*/
+ const Word16 *x, /* i: input vector Qx*/
+ const Word16 Qx,
+ const Word16 len /* i: length of inputvector */
+);
+
+Word16 sum16_fx( /* o : sum of all vector elements Qx*/
+ const Word16 *vec, /* i : input vector Qx*/
+ const Word16 lvec /* i : length of input vector */
+);
+
+Word32 sum32_fx( /* o : sum of all vector elements Qx*/
+ const Word32 *vec, /* i : input vector Qx*/
+ const Word16 lvec /* i : length of input vector */
+);
+
+Word32 Mean32( /* o : mean of the elements of the vector */
+ const Word32 in[], /* i : input vector */
+ const Word16 L /* i : length of input vector */
+);
+
+void Deemph2(
+ Word16 x[], /* i/o: input signal overwritten by the output Qx/Qx-1 */
+ const Word16 mu, /* i : deemphasis factor Q15 */
+ const Word16 L, /* i : vector size Q0 */
+ Word16 *mem /* i/o: memory (y[-1]) Qx-1 */
+);
+
+void deemph_fx(
+ Word16 *signal, /* i/o: signal Qx */
+ const Word16 mu, /* i : deemphasis factor Q15 */
+ const Word16 L, /* i : vector size Q0 */
+ Word16 *mem /* i/o: memory (y[-1]) Qx */
+);
+Word16 deindex_lvq_fx(
+ Word16 *index, /* i : index to be decoded, as an array of 3 short */
+ Word16 *x_lvq, /* o : decoded codevector Q(x2.56)*/
+ Word16 mode, /* i : LVQ coding mode (select scales & no_lead ), or idx_cv */
+ Word16 sf_flag, /* i : safety net flag */
+ Word16 no_bits, /* i : number of bits for lattice */
+ Word32 *p_offset_scale1, /* i : offset for first subvector */
+ Word32 *p_offset_scale2, /* i : offset for the second subvector */
+ Word16 *p_no_scales
+);
+void Syn_filt_s(
+ const Word16 shift, /* i : scaling to apply Q0 */
+ const Word16 a[], /* i : LP filter coefficients Q12 */
+ const Word16 m, /* i : order of LP filter Q0 */
+ const Word16 x[], /* i : input signal Qx */
+ Word16 y[], /* o : output signal Qx-s */
+ const Word16 lg, /* i : size of filtering Q0 */
+ Word16 mem[], /* i/o: memory associated with this filtering. Qx-s */
+ const Word16 update /* i : 0=no update, 1=update of memory. Q0 */
+);
+void hp400_12k8_fx(
+ Word16 signal[], /* i/o: input signal / output is divided by 16 */
+ const Word16 lg, /* i : lenght of signal */
+ Word16 mem[] /* i/o: filter memory [6] */
+);
+Word16 dot_prod_satcontr(const Word16 *x, const Word16 *y, Word16 qx, Word16 qy, Word16 *qo, Word16 len);
+void syn_12k8_fx(
+ Word16 L_frame,
+ const Word16 *Aq, /* i : LP filter coefficients Q12 */
+ const Word16 *exc, /* i : input signal Q_exc */
+ Word16 *synth, /* o : output signal Q_syn */
+ Word16 *mem, /* i/o: initial filter states Q_syn */
+ const Word16 update_m, /* i : update memory flag: 0 --> no memory update Q0 */
+ /* 1 --> update of memory */
+ const Word16 Q_exc, /* i : Excitation scaling Q0 */
+ const Word16 Q_syn /* i : Synthesis scaling Q0 */
+);
+void updt_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: state structure */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 *old_exc_fx, /* i : buffer of excitation */
+ const Word16 *pitch_buf_fx, /* i : floating pitch values for each subframe */
+ const Word16 Es_pred, /* i : predicited scaled innovation energy */
+ const Word16 *Aq, /* i : A(z) quantized for all subframes */
+ const Word16 *lsf_new_fx, /* i : current frame LSF vector */
+ const Word16 *lsp_new_fx, /* i : current frame LSP vector */
+ const Word16 voice_factors[], /* i : voicing factors */
+ const Word16 *old_bwe_exc_fx /* i : buffer of excitation */
+ , const Word16 *gain_buf /*Q14*/
+);
+Word32 Interpol_lc_fx( /* o : interpolated value Qx+16 */
+ const Word16 *x, /* i : input vector Q0 */
+ const Word16 *win, /* i : interpolation window Q14 */
+ const Word16 frac, /* i : fraction (0..up_samp) Q0 */
+ const Word16 up_samp, /* i : upsampling factor Q0 */
+ const Word16 nb_coef /* i : number of coefficients Q0 */
+);
+
+Word16 corr_xy1_fx( /* o : pitch gain (0..GAIN_PIT_MAX) */
+ const Word16 xn_1[], /* i : target signal */
+ const Word16 y1_1[], /* i : filtered adaptive codebook excitation */
+ Word16 g_corr[], /* o : correlations and -2 */
+ const Word16 L_subfr, /* i : vector length */
+ const Word16 norm_flag /* i : flag for constraining pitch contribution */
+);
+
+void updt_tar_fx(
+ const Word16 *x, /* i : old target (for pitch search) */
+ Word16 *x2, /* o : new target (for codebook search) */
+ const Word16 *y, /* i : filtered adaptive codebook vector */
+ const Word16 gain, /* i : adaptive codebook gain */
+ const Word16 L /* i : subframe size */
+);
+void updt_tar_HR_fx(
+ const Word16 *x, /* i : old target (for pitch search) */
+ Word16 *x2, /* o : new target (for codebook search) */
+ const Word16 *y, /* i : filtered adaptive codebook vector */
+ const Word16 gain, /* i : adaptive codebook gain */
+ const Word16 Qx, /* i : Scaling factor to adapt output to input */
+ const Word16 L /* i : subframe size */
+);
+
+Word16 lp_filt_exc_enc_fx(
+ const Word16 codec_mode, /* i : MODE1 or MODE2 Q0 */
+ const Word32 core_brate, /* i : core bitrate Q0 */
+ const Word16 Opt_AMR_WB, /* i : flag indicating AMR-WB IO mode Q0 */
+ const Word16 coder_type, /* i : coding type Q0 */
+ const Word16 i_subfr, /* i : subframe index Q0 */
+ Word16 *exc, /* i/o: pointer to excitation signal frame Q_new */
+ const Word16 *h1, /* i : weighted filter input response Q(14+shift) */
+ const Word16 *xn, /* i : target vector Q_new-1+shift */
+ Word16 *y1, /* o : zero-memory filtered adaptive excitation Q_new-1+shift */
+ Word16 *xn2, /* o : target vector for innovation search Q_new-1+shift */
+ const Word16 L_subfr, /* i : length of vectors for gain quantization Q0 */
+ const Word16 L_frame, /* i : frame size Q0 */
+ Word16 *g_corr, /* o : ACELP correlation values mant/exp */
+ const Word16 clip_gain, /* i : adaptive gain clipping flag Q0 */
+ Word16 *gain_pit, /* o : adaptive excitation gain Q14 */
+ Word16 *lp_flag /* i/o: mode selection Q0 */
+);
+
+Word16 Interpol_4( /* o : interpolated value */
+ Word16 * x, /* i : input vector */
+ Word16 frac /* i : fraction (-4..+3) */
+);
+
+void r_fft_fx_lc(
+ const Word16 *phs_tbl, /* i : Table of phase */
+ const Word16 SIZE, /* i : Size of the FFT */
+ const Word16 SIZE2, /* i : Size / 2 */
+ const Word16 NUM_STAGE, /* i : Number of stage */
+ const Word16 *in_ptr, /* i : coeffients in the order re[0], re[1], ... re[n/2], im[1], im[2], ..., im[n/2-1] */
+ Word16 *out_ptr, /* o : coeffients in the order re[0], re[1], ... re[n/2], im[1], im[2], ..., im[n/2-1] */
+ const Word16 isign /* i : 1=fft, otherwize it's ifft */
+);
+
+void hf_synth_fx(
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 output_frame, /* i : output frame length */
+ const Word16 *Aq, /* i : quantized Az */
+ const Word16 *exc, /* i : excitation at 12.8 kHz */
+ Word16 *synth, /* i : 12.8kHz synthesis signal */
+ Word16 *synth16k, /* o : 16kHz synthesis signal */
+ Word16 *seed2, /* i/o: random seed for HF noise gen */
+ Word16 *mem_hp400, /* i/o: memory of hp 400 Hz filter */
+ Word16 *mem_syn_hf, /* i/o: HF synthesis memory */
+ Word16 *mem_hf, /* i/o: HF band-pass filter memory */
+ const Word16 Q_exc, /* i : excitation scaling */
+ const Word16 Q_syn2, /* i : synthesis scaling */
+ Word16 *delay_syn_hf, /*i/o: HF synthesis memory */
+ Word16 *memExp1, /* o : HF excitation exponent */
+ Word16 *mem_hp_interp, /* i/o: interpol. memory */
+ const Word16 extl, /* i : flag indicating BWE */
+ const Word16 CNG_mode /* i : CNG_mode */
+);
+void acelp_core_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 synth_out[], /* o : synthesis */
+ Word32 bwe_exc_extended[], /* i/o: bandwidth extended excitation */
+ Word16 *voice_factors, /* o : voicing factors */
+ Word16 old_syn_12k8_16k[], /* o : intermediate ACELP synthesis at 12.8kHz or 16kHz to be used by SWB BWE */
+ Word16 coder_type_fx, /* i : coder type */
+ Word16 sharpFlag,
+ Word16 pitch_buf_fx[NB_SUBFR16k], /* o : floating pitch for each subframe */
+ Word16 *unbits /* o : number of unused bits */
+ ,Word16 *sid_bw /* o : 0-NB/WB, 1-SWB SID */
+);
+void Inac_swtch_ematch_fx(
+ Word16 exc2[], /* i/o: CELP/GSC excitation buffer Q_exc*/
+ Word16 dct_exc_tmp[], /* i : GSC excitation in DCT domain */
+ Word16 lt_ener_per_band[], /* i/o: Long term energy per band Q12 */
+ const Word16 coder_type, /* i : Coding mode */
+ const Word16 L_frame, /* i : Frame lenght */
+ const Word32 core_brate, /* i : Core bit rate */
+ const Word16 Q_exc /* i : input and output format of exc2 */
+ ,const Word16 bfi /* i : frame lost indicator */
+ ,const short last_core, /* i : Last core used */
+ const short last_codec_mode /* i : Last codec mode */
+);
+void stat_noise_uv_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ const Word16 coder_type, /* i : coding type */
+ const Word32 *LepsP, /* i : LP prediction errors */
+ Word16 *isp_new, /* i : immittance spectral pairs at 4th sfr */
+ Word16 *isp_mid, /* i : immittance spectral pairs at 2nd sfr */
+ Word16 *Aq, /* i : A(z) quantized for the 4 subframes */
+ Word16 *exc2, /* i/o: excitation buffer */
+ Word16 Q_new
+);
+
+void updt_enc_fx(
+ Encoder_State_fx *st, /* i/o: state structure */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 coder_type, /* i : speech coder type */
+ const Word16 *old_exc, /* i : buffer of excitation */
+ const Word16 *pitch_buf, /* i : floating pitch for each subframe */
+ const Word16 Es_pred, /* i : predicited scaled innovation energy */
+ const Word16 *Aq, /* i : A(z) quantized for all subframes */
+ const Word16 *lsf_new, /* i : current frame LSF vector */
+ const Word16 *lsp_new, /* i : current frame LSP vector */
+ const Word16 *old_bwe_exc /* i : buffer of excitation */
+);
+void FEC_encode_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 *synth, /* i : pointer to synthesized speech for E computation */
+ const Word16 coder_type, /* i : type of coder */
+ Word16 clas, /* i : signal clas for current frame */
+ const Word16 *fpit, /* i : close loop fractional pitch buffer */
+ const Word16 *res, /* i : LP residual signal frame */
+ Word16 *last_pulse_pos, /* i/o: Position of the last pulse */
+ const Word16 L_frame, /* i : Frame length */
+ const Word32 total_brate, /* i : total codec bitrate */
+ const Word32 core_brate, /* i : total codec bitrate */
+ const Word16 Q_new, /* i : input scaling */
+ const Word16 shift /* i : scaling to get 12bits */
+);
+void Ener_per_band_comp_fx(
+ const Word16 exc_diff[], /* i : target signal Q_exc_diff */
+ Word16 y_gain4[], /* o : Energy per band to quantize Q12 */
+ const Word16 Q_exc_diff,
+ const Word16 Mband, /* i : Max band */
+ const Word16 Eflag
+);
+void acelp_core_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ LPD_state *mem, /* i/o: acelp memories */
+ const Word16 inp_fx[], /* i : input signal of the current frame */
+ const Word16 vad_flag_fx,
+ const Word32 ener_fx, /* i : residual energy from Levinson-Durbin*/
+ const Word16 pitch[3], /* i : open-loop pitch values for quantiz. */
+ const Word16 voicing_fx[3], /* i : Open-loop pitch gains */
+ Word16 A_fx[NB_SUBFR16k*(M+1)], /* i : A(z) unquantized for the 4 subframes*/
+ Word16 Aw_fx[NB_SUBFR16k*(M+1)], /* i : weighted A(z) unquant. for subframes*/
+ const Word16 epsP_h_fx[M+1], /* i : LP prediction errors */
+ const Word16 epsP_l_fx[M+1], /* i : LP prediction errors */
+ Word16 lsp_new_fx[M], /* i : LSPs at the end of the frame */
+ Word16 lsp_mid_fx[M], /* i : LSPs in the middle of the frame */
+ Word16 coder_type_fx, /* i : coding type */
+ const Word16 sharpFlag_fx, /* i : formant sharpening flag */
+ Word16 vad_hover_flag_fx,
+ const Word16 gsc_attack_flag_fx, /* i : flag signalling attack encoded by AC mode (GSC) */
+ Word32 bwe_exc_extended_fx[], /* i/o: bandwidth extended excitation */
+ Word16 *voice_factors_fx, /* o : voicing factors */
+ Word16 old_syn_12k8_16k_fx[], /* o : intermediate ACELP synthesis at 12.8kHz or 16kHz to be used by SWB BWE */
+ Word16 pitch_buf_fx[NB_SUBFR16k], /* o : floating pitch for each subframe */
+ Word16 *unbits_fx, /* o : number of unused bits */
+ const Word16 Q_new,
+ const Word16 shift
+);
+
+#define EDCT_FACTOR_SCALE 2
+void edct_fx(
+ const Word32 *x, /* i : input signal Qq */
+ Word32 *y, /* o : output transform Qq */
+ Word16 length, /* i : length */
+ Word16 *q /* i : Q value of input signal */
+);
+
+void edst_fx(
+ const Word32 *x, /* i : input signal Qq */
+ Word32 *y, /* o : output transform Qq */
+ Word16 length, /* i : length */
+ Word16 *q /* i : Q value of input signal */
+);
+
+void DoRTFTn_fx(
+ Word32 *x, /* i/o : real part of input and output data */
+ Word32 *y, /* i/o : imaginary part of input and output data */
+ const Word16 n /* i : size of the FFT up to 1024 */
+);
+
+void edct2_fx(
+ Word16 n,
+ Word16 isgn,
+ Word16 *in,
+ Word32 *a,
+ Word16 *q,
+ const Word16 *ip,
+ const Word16 *w
+);
+void DoRTFT160_16fx(
+ Word16 x[], /* i/o : real part of input and output data */
+ Word16 y[] /* i/o : imaginary part of input and output data */
+);
+void DoRTFT320_16fx(
+ Word16 *x, /* i/o : real part of input and output data */
+ Word16 *y /* i/o : imaginary part of input and output data */
+);
+void DoRTFT128_16fx(
+ Word16 *x, /* i/o : real part of input and output data Q(Qx+Q_edct)*/
+ Word16 *y /* i/o : imaginary part of input and output data Q(Qx+Q_edct)*/
+);
+void edct_16fx(
+ const Word16 *x, /* i : input signal Qx */
+ Word16 *y, /* o : output transform Qx */
+ Word16 length, /* i : length */
+ Word16 bh /* bit-headroom */
+);
+void highband_exc_dct_in_fx(
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 *mfreq_bindiv_loc, /* i : bin per bands tables */
+ Word16 last_bin, /* i : last bin of bit allocation */
+ Word16 Diff_len, /* i : number of bin before cut-off frequency */
+ Word16 noise_lev, /* i : pulses dynamic */
+ Word16 pit_band_idx, /* i : bin position of the cut-off frequency */
+ Word16 *exc_diffQ, /* i : frequency coefficients of per band */
+ Word16 *seed_tcx, /* i : Seed for noise */
+ Word16 *Ener_per_bd_iQ, /* i : Quantized energy of targeted vector */
+ Word16 nb_subfr, /* i : Number of subframe considered */
+ Word16 *exc_dct_in, /* o : dct of residual signal */
+ Word16 last_coder_type, /* i : coding type of last frame */
+ Word16 *bitallocation_band, /* i : bit allocation flag of each band */
+ Word16 *lsf_new, /* i : LSFs at the end of the frame */
+ Word16 *last_exc_dct_in, /* i : dct of residual signal of last frame */
+ Word16 *last_ener, /* i : frequency energy of last frame */
+ Word16 *last_bitallocation_band, /* i : bit allocation flag of each band of last frame */
+ Word16 *bitallocation_exc, /* i : flag of decoded coefficients */
+ Word16 bfi, /* i : bad frame indicator */
+ const Word16 coder_type, /* i : coder type */
+ Word16 bwidth,
+ Word16 *exc_wo_nf , /* o : temporal excitation (in f domain) without noisefill */
+ Word16 Qexc_diffQ,
+ Word16 Q_exc,
+ const Word16 GSC_noisy_speech
+ ,Word16 *lt_ener_per_band_fx /* i/o: Average per band energy */
+);
+
+
+void long_enr_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ const Word16 Etot, /* i : total channel E (see lib_enc\analy_sp.c) */
+ const Word16 localVAD_HE_SAD, /* i : HE-SAD flag without hangover */
+ Word16 high_lpn_flag
+);
+
+Word16 correlation_shift_fx( /* o : noise dependent voicing correction Q15 */
+ Word16 totalNoise_fx /* i/o: noise estimate over all critical bands Q8 */
+);
+
+void analy_lp_fx(
+ const Word16 speech[], /* i : pointer to the speech frame */
+ const Word16 L_frame, /* i : length of the frame */
+ const Word16 L_look, /* i : look-ahead */
+ Word32 *ener, /* o : residual energy from Levinson-Durbin */
+ Word16 A[], /* o : A(z) filter coefficients */
+ Word16 epsP_h[], /* o : LP analysis residual energies for each iteration */
+ Word16 epsP_l[], /* o : LP analysis residual energies for each iteration */
+ Word16 lsp_new[], /* o : current frame LSPs */
+ Word16 lsp_mid[], /* o : current mid-frame LSPs */
+ Word16 lsp_old[], /* i/o: previous frame unquantized LSPs */
+ const Word16 Top[2], /* i : open loop pitch lag */
+ const Word16 Tnc[2], /* i : open loop pitch gain */
+ const Word32 Core_sr, /* i : Internal core sampling rate */
+ Word16 Q_new,
+ Word16 *Q_r
+);
+
+void analy_lp_AMR_WB_fx(
+ const Word16 speech[], /* i : pointer to the speech frame */
+ Word32 *ener, /* o : residual energy from Levinson-Durbin */
+ Word16 A[], /* o : A(z) filter coefficients */
+ Word16 epsP_h[], /* o : LP analysis residual energies for each iteration */
+ Word16 epsP_l[], /* o : LP analysis residual energies for each iteration */
+ Word16 isp_new[], /* o : current frame ISPs */
+ Word16 isp_old[], /* i/o: previous frame unquantized ISPs */
+ Word16 isf_new[], /* o : current frame ISPs */
+ Word16 Top, /* i : open loop pitch lag */
+ Word16 Tnc, /* i : open loop pitch gain */
+ Word16 Q_new,
+ Word16 *Q_r
+);
+
+void a2rc_fx(const Word16 *a, Word16 *refl,Word16 lpcorder);
+
+Word32 invert_dp(Word40 Linput, Word16 n, Word16 *Qout, Word16 wb_mode_bit);
+
+void vad_param_updt_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ Word16 pitch[3], /* i : open loop pitch lag for each half-frame Q0*/
+ Word16 voicing[3], /* i : maximum normalized correlation for each half-frame Q15*/
+ const Word16 old_pitch1,/* i : OL pitch value from last frame */
+ Word16 corr_shift, /* i : correlation shift Q15*/
+ Word16 vad_flag, /* i : vad flag Q0*/
+ const Word16 Az[] /* i: a coeffs */
+);
+
+void pitch_ol2_fx(
+ const Word16 pit_min, /* i : minimum pitch value (20 or 29) */
+ const Word16 pitch_ol, /* i : pitch to be improved */
+ Word16 *pitch_fr_fx, /* o : adjusted 1/4 fractional pitch */ /*Q7 */
+ Word16 *voicing_fr_fx, /* o : adjusted 1/4 fractional voicing */ /*Q15 */
+ const Word16 pos, /* i : position in frame where to calculate the improv. */
+ const Word16 *wsp_fx, /* i : weighted speech for current frame and look-ahead */ /*Q_new-1+shift*/
+ const Word16 delta /* i : delta for pitch search (2 or 7) */
+);
+
+void pitch_ol_fx(
+ Word16 pitch[3], /* o : open loop pitch lag for each half-frame in range [29,231] Q0 */
+ Word16 voicing[3], /* o : maximum normalized correlation for each half-frame in [0,1.0[ Q15 */
+ Word16 *old_pitch, /* i/o: pitch of the 2nd half-frame of previous frame (i.e. pitch[1]) Q0 */
+ Word16 *old_corr, /* i/o: correlation of old_pitch (i.e. voicing[1] or corr_mean) Q15 */
+ Word16 corr_shift, /* i : normalized correlation correction Q15 */
+ Word16 *old_thres, /* i/o: maximum correlation weighting with respect to past frame pitch Q15 */
+ Word16 *delta_pit, /* i/o: old pitch extrapolation correction in range [-14,+14] Q0 */
+ Word16 *st_old_wsp2, /* i/o: weighted speech memory qwsp */
+ const Word16 *wsp, /* i : weighted speech for current frame and look-ahead qwsp */
+ Word16 mem_decim2[3], /* i/o: wsp decimation filter memory qwsp */
+ const Word16 relE, /* i : relative frame energy Q8 */
+ const Word16 last_class, /* i : frame classification of last frame */
+ const Word16 bwidth, /* i : bandwidth */
+ const Word16 Opt_SC_VBR /* i : SC-VBR flag */
+);
+
+void Scale_wsp(
+ Word16 *wsp, /* i : Weigthed speech */
+ Word16 *old_wsp_max, /* i : Last weigthed speech maximal valu */
+ Word16 *shift, /* i/o: Scaling of current frame */
+ Word16 *Q_exp, /* i/o: Differential scaling factor */
+ Word16 *old_wsp_shift, /* i/o: Last wsp scaling */
+ Word16 *old_wsp, /* i/o: Old weighted speech buffer */
+ Word16 *mem_decim2, /* i/o: Decimation buffer */
+ Word16 *old_wsp12k8, /* i/o: wsp memory @ 12.8 kHz used in pitol2 */
+ const Word16 Len_p_look /* i : L_frame + look ahead */
+);
+
+Word16 multi_harm_fx( /* o : frame multi-harmonicity (1-harmonic, 0-not) */
+ const Word16 Bin_E[], /* i : log-energy spectrum of the current frame Q7 */
+ Word16 old_S[], /* i/o: prev. log-energy spectrum w. subtracted floor Q7 */
+ Word16 cor_map_LT[], /* i/o: LT correlation map Q15 */
+ Word16 *multi_harm_limit, /* i/o: multi harminic threshold Q9 */
+ const Word32 total_brate, /* i : total bitrate Q0 */
+ const Word16 bwidth, /* i : input signal bandwidth Q0 */
+ Word16 *cor_strong_limit, /* i/o: HF correlation indicator Q0 */
+ Word16 *st_mean_avr_dyn, /* i/o: long term average dynamic Q7 */
+ Word16 *st_last_sw_dyn, /* i/o: last dynamic Q7 */
+ Word16 *cor_map_sum /* Q8 */
+ , Word16 *sp_floor /* o : noise floor estimate Q7 */
+);
+
+Word16 find_uv_fx( /* o : coding type */
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 *T_op_fr, /* i : pointer to adjusted fractional pitch (4 val.) Q6 */
+ const Word16 *voicing_fr, /* i : refined correlation for each subframes Q15 */
+ const Word16 *voicing, /* i : correlation for 3 half-frames Q15 */
+ const Word16 *speech, /* i : pointer to speech signal for E computation Q_new*/
+ const Word16 localVAD, /* i : vad without hangover */
+ const Word32 *ee, /* i : lf/hf Energy ratio for present frame Q6 */
+ const Word16 corr_shift, /* i : normalized correlation correction in noise Q15 */
+ const Word16 relE, /* i : relative frame energy Q8 */
+ const Word16 Etot, /* i : total energy Q8 */
+ const Word32 hp_E[], /* i : energy in HF Q_new + Q_SCALE */
+ const Word16 Q_new,
+ Word16 *flag_spitch, /* i/o: flag to indicate very short stable pitch and high correlation */
+ const Word16 voicing_sm /* i : smoothed open-loop pitch gains */
+ , const Word16 shift
+ , const Word16 last_core_orig /* i : original last core */
+);
+
+Word16 signal_clas_fx( /* o : classification for current frames */
+ Encoder_State_fx *st, /* i/o: encoder state structure */
+ Word16 *coder_type, /* i/o: coder type */
+ const Word16 voicing[3], /* i : normalized correlation for 3 half-frames */
+ const Word16 *speech, /* i : pointer to speech signal for E computation */
+ const Word16 localVAD, /* i : vad without hangover */
+ const Word16 pit[3], /* i : open loop pitch values for 3 half-frames */
+ const Word32 *ee, /* i : lf/hf E ration for 2 half-frames */
+ const Word16 relE, /* i : frame relative E to the long term average */
+ const Word16 L_look , /* i : look-ahead */
+ Word16 *uc_clas /* o : temporary classification used in music/speech class*/
+);
+
+void find_tilt_fx(
+ const Word32 fr_bands[], /* i : energy in frequency bands Q_new + Q_SCALE*/
+ const Word32 bckr[], /* i : per band background noise energy estimate Q_new + Q_SCALE*/
+ Word32 ee[2], /* o : lf/hf E ration for present frame Q6*/
+ const Word16 pitch[3], /* i : open loop pitch values for 3 half-frames Q0*/
+ const Word16 voicing[3], /* i : normalized correlation for 3 half-frames Q15*/
+ const Word32 *lf_E, /* i : per bin energy for low frequencies Q_new + Q_SCALE - 2*/
+ const Word16 corr_shift, /* i : normalized correlation correction Q15*/
+ const Word16 bwidth, /* i : input signal bandwidth */
+ const Word16 max_band, /* i : maximum critical band */
+ Word32 hp_E[], /* o : energy in HF Q_new + Q_SCALE*/
+ const Word16 codec_mode, /* i : MODE1 or MODE2 */
+ const Word16 Q_new, /* i : scaling factor */
+ Word32 *bckr_tilt_lt
+ ,Word16 Opt_vbr_mode
+);
+void synth_mem_updt2(
+ const Word16 L_frame, /* i : frame length */
+ const Word16 last_L_frame, /* i : frame length */
+ Word16 old_exc[], /* i/o: excitation buffer */
+ Word16 mem_syn_r[], /* i/o: synthesis filter memory */
+ Word16 mem_syn2[], /* o : synthesis filter memory for find_target */
+ Word16 mem_syn[], /* o : synthesis filter memory for find_target */
+ const Word16 dec /* i : flag for decoder indication */
+);
+void swb_hr_noise_fill_fx(
+ const Word16 is_transient, /* i : transient flag */
+ const Word16 spect_start, /* i : spectrum start point */
+ const Word16 spect_end, /* i : spectrum end point */
+ const Word16 tilt_wb, /* i : tilt of wideband signal */
+ const Word16 pitch, /* i : pitch value */
+ const Word16 nq[], /* i : AVQ nq index */
+ Word16 Nsv, /* i : number of subband */
+ Word16 *bwe_highrate_seed, /* i/o: seed of random noise */
+ Word16 *t_audio, /* i/o: mdct spectrum */
+ Word16 Q_audio
+);
+Word16 swb_bwe_dec_hr_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 *syn_12k8_16k_fx, /* i : ACELP core synthesis @16kHz */
+ const Word16 old_syn_exp, /* i : Exponent of core synthesis */
+ Word16 *hb_synth_fx, /* o : SHB synthesis */
+ const Word16 output_frame, /* i : frame length */
+ const Word16 unbits, /* i : number of core unused bits */
+ const Word16 pitch_buf[] /* i : pitch buffer */
+);
+Word32 calc_tilt_bwe_fx( /* o : Tilt in Q24 */
+ const Word16 *sp0, /* i : input signal */
+ const Word16 exp, /* i : Exp of inp signal */
+ const Word16 N /* i : signal length */
+);
+void Inverse_Transform(
+ const Word32 *in_mdct, /* i : input MDCT vector */
+ Word16 *Q, /* i/o: Q value of input */
+ Word32 *out, /* o : output vector */
+ const Word16 is_transient, /* i : transient flag */
+ const Word16 L, /* i : output frame length */
+ const Word16 L_inner /* i : length of the transform */
+);
+void iedct_short_fx(
+ const Word32 *in, /* i : input vector */
+ Word16 *Q, /* i/o: Q value of input */
+ Word32 *out, /* o : output vector */
+ const Word16 segment_length /* i : length */
+);
+
+void swb_bwe_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 *old_input_12k8_fx, /* i : input signal @12.8kHz for SWB BWE */
+ Word16 *old_input_16k_fx, /* i : input signal @16kHz for SWB BWE */
+ const Word16 *old_syn_12k8_16k_fx, /* i : ACELP core synthesis at 12.8kHz or 16kHz */
+ const Word16 *new_swb_speech_fx, /* i : original input signal at 32kHz */
+ Word16 *shb_speech_fx, /* i : SHB target signal (6-14kHz) at 16kHz */
+ const Word16 coder_type, /* i : coding type */
+ Word16 Q_shb_speech,
+ Word16 Q_slb_speech
+);
+void wb_bwe_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 *new_wb_speech_fx, /* i : original input signal at 16kHz */
+ Word16 coder_type /* i : coding type */
+);
+
+Word16 WB_BWE_encoding_fx( /* o : classification of wb signal */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 *yos_fx, /* i : MDCT coefficients of weighted original */
+ Word16 *WB_fenv_fx, /* i/o: energy of WB envelope */
+ Encoder_State_fx *st_fx, /* i/o: Encoder structure */
+ Word16 Q_synth,
+ Word16 Q_synth_lf
+);
+
+
+Word16 wb_bwe_dec_fx(
+ Word16 *synth_fx, /* i/o: ACELP core synthesis/final synthesis */
+ Word16 *hb_synth_fx, /* o : SHB synthesis/final synthesis */
+ const Word16 output_frame, /* i : frame length */
+ Word16 coder_type, /* i : coding type */
+ Word16 *voice_factors_fx, /* i : voicing factors */
+ const Word16 pitch_buf_fx[], /* i : pitch buffer */
+ Decoder_State_fx *st_fx /* i/o: decoder state structure */
+ ,Word16 * Qpost
+);
+
+Word16 WB_BWE_gain_deq_fx(
+ Decoder_State_fx *st_fx , /* i/o: decoder state structure */
+ Word16 *WB_fenv
+);
+Word16 swb_bwe_gain_deq_fx( /* o : BWE class */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 core, /* i : core */
+ Word16 *SWB_tenv, /* o : Q0, time-domain BWE envelope */
+ Word16 *SWB_fenv, /* o : Q1, frequency-domain BWE envelope */
+ const Word16 hr_flag, /* i : high rate flag */
+ const Word16 hqswb_clas /* i : HQ BWE class */
+);
+
+Word16 swb_bwe_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 *synth_fx, /* i : ACELP core synthesis/final synthesis */
+ Word16 *hb_synth, /* o : SHB synthesis/final synthesis */
+ const Word16 output_frame /* i : frame length */
+ ,Word16 * Qpost
+ ,Word16 coder_type /* i : coding type */
+);
+
+Word16 WB_BWE_gain_pred_fx(
+ Word16 *WB_fenv, /* o : WB frequency envelopes */
+ const Word16 *core_dec_freq, /* i : Frequency domain core decoded signal */
+ const Word16 coder_type, /* i : coding type */
+ Word16 prev_coder_type, /* i : coding type of last frame */
+ Word16 prev_WB_fenv, /* i : envelope for last frame */
+ Word16 *voice_factors, /* i : voicing factors Q15 */
+ const Word16 pitch_buf[], /* i : pitch buffer Q6 */
+ Word32 last_core_brate, /* i : previous frame core bitrate */
+ Word16 last_wb_bwe_ener , /* i : previous frame wb bwe signal energy */
+ Word16 Q_syn
+ ,Word16 last_extl_fx,
+ Word16 tilt_wb_fx
+);
+void calc_normal_length_fx(
+ const Word16 core, /* i : core */
+ const Word16 *sp, /* i : input signal */
+ const Word16 mode, /* i : input mode */
+ const Word16 extl, /* i : extension layer */
+ Word16 *L_swb_norm, /* o : normalize length */
+ Word16 *prev_L_swb_norm, /*i/o : last normalize length */
+ Word16 Q_syn
+);
+
+void calc_norm_envelop_fx(
+ const Word16 SWB_signal[], /* i : SWB spectrum Q_syn*/
+ Word32 *envelope, /* o : normalized envelope Q_syn*/
+ const Word16 L_swb_norm, /* i : length of envelope Q0 */
+ const Word16 SWB_flength, /* i : Length of input/output */
+ const Word16 st_offset /* i : offset */
+);
+
+void WB_BWE_decoding_fx(
+ const Word16 *core_dec_freq, /* i : Frequency domain core decoded signal */
+ Word16 *WB_fenv, /* i : WB frequency envelopes */
+ Word32 *WB_signal32, /* o : WB signal in MDCT domain */
+ const Word16 WB_flength, /* i : Length of input/output */
+ const Word16 mode, /* i : classification for WB signal */
+ const Word16 last_extl, /* i : extl. layer for last frame */
+ Word32 *prev_Energy, /* i/o: energy for last frame */
+ Word16 *prev_WB_fenv, /* i/o: envelope for last frame */
+ Word16 *prev_L_wb_norm, /* i/o: length for last frame wb norm */
+ const Word16 extl, /* i : extension layer */
+ const Word16 coder_type, /* i : coding type */
+ const Word32 total_brate, /* i : core layer bitrate */
+ Word16 *Seed, /* i/o: random generator seed */
+ Word16 *prev_flag, /* i/o: attenu flag of last frame */
+ Word16 prev_coder_type , /* i : coding type of last frame */
+ Word16 Q_syn,
+ Word16 *Q_syn_hb /*o : Q value of WB_signal_32 */
+);
+
+void SWB_BWE_decoding_fx(
+ const Word16 *core_dec_freq, /* i : Frequency domain core decoded signal */
+ Word16 *SWB_fenv, /* i/o: SWB frequency envelopes */
+ Word32 *SWB_signal, /* o : SWB signal in MDCT domain */
+ const Word16 SWB_flength, /* i : Length of input/output */
+ const Word16 mode, /* i : classification for SWB signal */
+ Word16 *frica_flag, /* o : fricative signal flag */
+ Word16 *prev_Energy, /* i/o: energy for last frame */
+ Word16 *prev_SWB_fenv, /* i/o: envelope for last frame */
+ Word16 *prev_L_swb_norm, /* i/o: length for last frame wb norm */
+ const Word16 tilt_nb, /* i : tilt of synthesis wb signal */
+ Word16 *Seed, /* i/o: random generator seed */
+ const Word16 st_offset, /* i : offset value due to different core */
+ Word16 *prev_weight, /* i/o: excitation weight value of last frame */
+ const Word16 extl , /* i : extension layer */
+ Word16 Q_syn
+ ,const Word16 last_extl /* i : extension layer of last frame */
+);
+void time_envelop_shaping_fx(
+ Word16 werr[], /* i/o: SHB synthesis Q_synth*/
+ Word32 SWB_tenv[], /* i/o: frequency envelope Q15*/
+ const Word16 L , /* i : frame length */
+ Word16 *Q_synth
+);
+void time_reduce_pre_echo_fx(
+ const Word16 *synth, /* i : ACELP core synthesis Q_syn*/
+ Word16 *error, /* i/o: SHB BWE synthesis Q0*/
+ Word16 prev_td_energy, /* o : last td energy Q0*/
+ const Word16 L, /* i : subframe length */
+ Word16 Q_syn,
+ Word16 Q_synth
+);
+/*Word16 detect_transient_fx( */
+/* const Word16 *in_fx, *//*Q_new */
+/* Encoder_State *st, */
+/* const Word16 L, */
+/* const Word16 coder_type , */ /* i : coder type */
+/* Word16 Q_new, */
+/*Encoder_State_fx *st_fx */
+/*); */
+
+
+void preset_hq2_swb_fx
+(
+ const Word16 hqswb_clas_fx, /* i : HQ2 class information */
+ const Word16 band_end_fx[], /* i : band end of each SB */
+ Word16 *har_bands_fx, /* i/o : Number of LF harmonic bands */
+ Word16 p2a_bands_fx, /* i : flag for peakness */
+ const Word16 length_fx, /* i : processed band length */
+ const Word16 bands_fx, /* i : Total number of Subbands in a frame */
+ Word16 *lowlength_fx, /* o : lowband length */
+ Word16 *highlength_fx, /* o : highband length */
+ Word32 L_m[] /* o : MDCT */
+);
+void post_hq2_swb_fx
+(
+ const Word32 L_m[], /* i : input_signal */
+ const Word16 lowlength_fx, /* i : lowband length */
+ const Word16 highlength_fx, /* i : highband length */
+ const Word16 hqswb_clas_fx, /* i : HQ2 class information */
+ const Word16 har_bands_fx, /* i : Number of LF harmonic bands */
+ const Word16 bands_fx, /* i : Total number of Subbands in a frame */
+ const Word16 p2a_flags_fx[], /* i : HF tonal indicator */
+ const Word16 band_start_fx[], /* i : band start of each SB */
+ const Word16 band_end_fx[], /* i : band end of each SB */
+ Word32 L_y2[], /* o : output signal */
+ Word16 npulses_fx[] /* i/o : Number of coded spectrum */
+);
+
+void swb_bwe_enc_lr_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word32 L_m_core[], /* i : lowband synthesis */
+ Word16 QsL,
+ const Word32 L_m_orig[], /* i/o: scaled orig signal (MDCT) */
+ Word32 L_m[], /* o : highband synthesis with lowband zeroed */
+ const Word32 L_total_brate, /* i : total bitrate for selecting subband pattern */
+ Word16 BANDS_fx, /* i : Total number of Subbands in a frame */
+ Word16 *band_start_fx, /* i : band start of each SB */
+ Word16 *band_end_fx, /* i : band end of each SB */
+ Word32 *L_band_energy, /* i : band_energy of each SB */
+ Word16 Qbe, /* i : Q value of band energy */
+ Word16 *p2a_flags_fx, /* i : HF tonal indicator */
+ const Word16 hqswb_clas_fx, /* i : HQ_NORMAL2 or HQ_HARMONIC mode */
+ Word16 lowlength_fx, /* i : lowband length */
+ Word16 highlength_fx, /* i : highband length */
+ Word16 *prev_frm_index_fx, /* i/o: previous frame lag index for harmonic mode */
+ const Word16 har_bands_fx, /* i : Number of LF harmonic bands */
+ Word16 *prev_frm_hfe2, /* i/o: */
+ Word16 *prev_stab_hfe2, /* i/o: */
+ const Word16 band_width_fx[], /* i : band_width information */
+ const Word32 L_y2_ni[], /* i : band_width information */
+ Word16 *ni_seed_fx /* i/o: random seed for search buffer NI */
+);
+
+void swb_bwe_dec_lr_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word32 L_m_core[], /* i : lowband synthesis */
+ const Word16 QsL, /* i : Q value of m_core */
+ Word32 L_m[], /* o : highband synthesis with lowband zeroed */
+ const Word32 L_total_brate, /* i : total bitrate for selecting subband pattern */
+ Word16 BANDS_fx, /* i : Number subbands/Frame */
+ Word16 *band_start_fx, /* i : Band Start of each SB */
+ Word16 *band_end_fx, /* i : Band end of each SB */
+ Word32 *L_band_energy, /* i : Band energy of each SB : Qbe */
+ Word16 Qbe, /* i : Q value of band energy */
+ Word16 *p2a_flags_fx, /* i : HF tonal Indicator */
+ const Word16 hqswb_clas_fx, /* i : class information */
+ Word16 lowlength_fx, /* i : Lowband Length */
+ Word16 highlength_fx, /* i : Highband Length */
+ const Word16 har_bands_fx, /* i : Number of LF harmonic bands */
+ Word16 *prev_frm_hfe2_fx, /* i/o: */
+ Word16 *prev_stab_hfe2_fx, /* i/o: */
+ Word16 band_width_fx[], /* i : subband bandwidth */
+ const Word32 L_y2_ni[], /* i/o: Sparse filled corecoder */
+ Word16 *ni_seed_fx /* i/o: random seed */
+);
+
+void GetPredictedSignal_fx(
+ const Word16 *predBuf_fx, /* i: Q8 */
+ Word32 *L_outBuf, /* o: Q9 */
+ const Word16 lag_fx, /* i: Q0 */
+ const Word16 fLen_fx, /* i: Q0 */
+ const Word16 lagGains_fx, /* i: Qgain */
+ const Word16 Qgain /* i: Q0 */
+);
+
+void Get20Log10Spec_fx(
+ const Word32 *L_inBuf, /* i : input Q_inBuf */
+ Word16 *outBuf_fx, /* o : output Q7 */
+ const Word16 fLen, /* i : loop length */
+ const Word16 Q_inBuf /* i : Qvalue of L_inBuf */
+);
+
+void convert_lagIndices_pls2smp_fx(
+ Word16 lagIndices_in_fx[],
+ Word16 nBands_search_fx,
+ Word16 lagIndices_out_fx[],
+ const Word16 sspectra_fx[],
+ const Word16 sbWidth_fx[],
+ const Word16 fLenLow_fx
+);
+
+Word16 get_usebit_npswb_fx(
+ Word16 hqswb_clas_fx
+);
+
+void SpectrumSmoothing_nss_fx(
+ const Word32 *L_inBuf, /* i : lowband MDCT */
+ Word16 *outBuf_fx, /* o : output */
+ Word16 *Qss, /* o : Q value for output vector */
+ const Word16 fLen /* i : length */
+);
+
+void SpectrumSmoothing_fx(
+ const Word32 *L_inBuf, /* i : Qs Low band MDCT */
+ Word16 *outBuf_fx, /* o : Qss output */
+ Word16 *Qss, /* o : Q0 Q value of output vector */
+ const Word16 fLen, /* i : Q0 length */
+ const Word16 th_cut_fx /* i : Qss threshold of cut */
+);
+
+void GetSynthesizedSpecThinOut_fx(
+ const Word16 *predBuf_fx, /* i : Qss: prediction buffer (i.e., lowband) */
+ const Word16 Qss, /* i : Q value of input vector */
+ Word32 *L_outBuf, /* o : QsL: synthesized spectrum */
+ Word16 QsL, /* o : Q value of synthesized spectrum */
+ const Word16 nBands_fx, /* i : Q0: number of subbands calculated */
+ const Word16 *sbWidth_fx, /* i : Q0: subband lengths */
+ const Word16 *lagIndices_fx, /* i : Q0: lowband index for each subband */
+ const Word16 *lagGains_fx, /* i : Qgain: lagGain for each subband */
+ const Word16 *QlagGains_fx, /* i : Q0: Q value of lagGains_fx */
+ const Word16 predBufLen_fx /* i : Q0: lowband length */
+);
+
+Word32 hq2_bit_alloc_fx (
+ const Word32 L_band_energy[], /* i : band energy of each subband */
+ const Word16 bands, /* i : total number of subbands in a frame */
+ Word32 L_Rk[], /* i/o: Bit allocation/Adjusted bit alloc. */
+ Word16 *bit_budget_fx, /* i/o: bit bugdet */
+ Word16 *p2a_flags, /* i : HF tonal indicator */
+ const Word16 weight_fx, /* i : weight */
+ const Word16 band_width[], /* i : Sub band bandwidth */
+ const Word16 num_bits, /* i : available bits */
+ const Word16 hqswb_clas, /* i : HQ2 class information */
+ const Word16 bwidth, /* i : input bandwidth */
+ const Word16 is_transient /* i : indicator HQ_TRANSIENT or not */
+);
+
+void hq2_noise_inject_fx(
+ Word32 L_y2[],
+ const Word16 band_start[],
+ const Word16 band_end[],
+ const Word16 band_width[],
+ Word32 Ep_fx[],
+ Word32 Rk_fx[],
+ const Word16 npulses[],
+ Word16 ni_seed,
+ const Word16 bands,
+ const Word16 ni_start_band,
+ const Word16 bw_low,
+ const Word16 bw_high,
+ const Word32 enerL_fx,
+ const Word32 enerH_fx,
+ Word32 last_ni_gain_fx[],
+ Word16 last_env_fx[],
+ Word16 *last_max_pos_pulse,
+ Word16 *p2a_flags,
+ Word16 p2a_bands,
+ const Word16 hqswb_clas,
+ const Word16 bwidth,
+ const Word32 bwe_br
+);
+
+void reordvct_fx(
+ Word16 *y, /* i/o: vector to rearrange */
+ const Word16 N, /* i : dimensions */
+ Word16 *idx /* o : reordered vector index */
+);
+
+void Bits2indvsb_fx (
+ const Word32 *L_be, /* i : Q14 Band Energy of sub-band */
+ const Word16 start_band, /* i : Q0 start band indices */
+ const Word16 end_band, /* i : Q0 end band indices */
+ const Word16 Bits, /* i : Q0 Total number of bits allocated to a group */
+ const Word32 L_Bits_needed, /* i : Q0 smallest bit number for allocation in group */
+ Word32 *L_Rsubband, /* o : Q18 bit allocation of sub-band */
+ Word16 *p2aflags_fx /* i/o: Q0 peaky/noise subband flag */
+);
+
+void hq2_bit_alloc_har_fx (
+ const Word32 *L_y, /* i : Q14 band energy of sub-vectors */
+ Word16 B_fx, /* i : Q0 number of available bits */
+ const Word16 N_fx, /* i : Q0 number of sub-vectors */
+ Word32 *L_Rsubband, /* o : Q18 sub-band bit-allocation vector */
+ Word16 p2a_bands_fx, /* i : Q0 highfreq bands */
+ const Word32 L_core_brate, /* i : Q0 core bit rate */
+ Word16 p2a_flags_fx[], /* i/o: Q0 p2a_flags */
+ const Word16 band_width_fx[] /* i : Q0 table of band_width */
+);
+
+void hq2_core_configure_fx (
+ const Word16 frame_length,
+ const Word16 num_bits,
+ const Word16 is_transient,
+ Word16 *bands,
+ Word16 *length,
+ Word16 band_width[],
+ Word16 band_start[],
+ Word16 band_end[],
+ Word32 *L_qint,
+ Word16 *eref,
+ Word16 *bit_alloc_weight,
+ Word16 *gqlevs,
+ Word16 *Ngq,
+ Word16 *p2a_bands,
+ Word16 *p2a_th,
+ Word16 *pd_thresh,
+ Word16 *ld_slope,
+ Word16 *ni_coef,
+ Word32 L_bwe_br
+);
+
+void hq_lr_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: : encoder state structure */
+ Word32 L_t_audio[], /* i/o: Q12 : transform-domain coefs. */
+ const Word16 inner_frame_fx, /* i : Q0 : inner frame length */
+ Word16 *num_bits_fx, /* i/o: Q0 : number of available bits */
+ const Word16 is_transient_fx /* i : Q0 : transient flag */
+);
+
+void hq_lr_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: : decoder state structure */
+ Word32 L_yout[], /* o : Q12 : transform-domain output coefs. */
+ const Word16 inner_frame, /* i : Q0 : inner frame length */
+ Word16 num_bits, /* i : Q0 : number of available bits */
+ Word16 *is_transient_fx /* o : Q0 : transient flag */
+);
+
+void reverse_transient_frame_energies_fx(
+ Word32 L_band_energy[], /* o : Q14 : band energies */
+ const Word16 bands /* i : Q0 : number of bands */
+);
+
+Word16 har_est_fx(
+ Word32 L_spectra[], /* i : coded spectrum */
+ Word16 N, /* i : length of the desired spectrum */
+ Word16 *har_freq_est1, /* i/o: Estimation harmonics 1 */
+ Word16 *har_freq_est2, /* o : Estimation harmonics 2 */
+ Word16 *flag_dis, /* i/o: flag for BWE reconstruction */
+ Word16 *prev_frm_hfe2, /* i/o: Estimated harmonic update */
+ const Word16 subband_search_offset[], /* i : Subband Search range */
+ const Word16 sbWidth[], /* i : Subband Search range */
+ Word16 *prev_stab_hfe2 /* i/o: Estimated harmonic position */
+);
+
+typedef struct GainItemStr_fx
+{
+ Word16 nmrValue_fx;
+ Word16 gainIndex_fx;
+} GainItem_fx;
+
+void genhf_noise_fx(
+ Word16 noise_flr_fx[], /* i : Qss smoothed non tonal */ /* sspectra_diff_fx:Qss */
+ Word16 Qss, /* i : Q0 Q value */
+ Word32 L_xSynth_har[], /* o : QsL hf non tonal components */ /* xSynth_har:QsL */
+ Word16 QsL, /* i : Q0 Q value */
+ Word16 *predBuf_fx, /* i : Qss smoothed tonal compone */ /* sspectra:Qss */
+ Word16 bands, /* i : Q0 total number of subbands in a frame */
+ Word16 harmonic_band, /* i : Q0 Number of LF harmonic frames */
+ Word16 har_freq_est2, /* i : Q0 harmonic signal parameter */
+ Word16 pos_max_hfe2, /* i : Q0 last pulse in core coder */
+ Word16 *pul_res, /* o : Q0 pulse resolution */
+ GainItem_fx pk_sf_fx[], /* o : representative region */
+ const Word16 fLenLow, /* i : Q0 low frequency length */
+ const Word16 fLenHigh, /* i : Q0 high frequency length */
+ const Word16 sbWidth[], /* i : Q0 bandwidth for high bands */
+ const Word16 lagIndices[], /* i : Q0 correlation indices for most representative */
+ const Word16 subband_offsets[], /* i : Q0 band offsets for HF reconstruction */
+ const Word16 subband_search_offset[] /* i : Q0 most representative regions offsets in LF */
+);
+
+void spt_shorten_domain_pre_fx(
+ const Word16 band_start[], /* i: Starting position of sub band */
+ const Word16 band_end[], /* i: End position of sub band */
+ const Word16 prev_SWB_peak_pos[], /* i: Spectral peak */
+ const Word16 BANDS, /* i: total number of bands */
+ const Word32 L_bwe_br, /* i: bitrate information */
+ Word16 new_band_start[], /* o: Starting position of new shorten sub band */
+ Word16 new_band_end[], /* o: End position of new shorten sub band */
+ Word16 new_band_width[] /* o: new sub band bandwidth */
+);
+
+void spt_shorten_domain_band_save_fx(
+ const Word16 bands, /* i: total subband */
+ const Word16 band_start[], /* i: starting position of subband */
+ const Word16 band_end[], /* i: end position of subband */
+ const Word16 band_width[], /* i: band width of subband */
+ Word16 org_band_start[], /* o: starting position of subband */
+ Word16 org_band_end[], /* o: end position of subband */
+ Word16 org_band_width[] /* o: band width of subband */
+);
+
+void spt_shorten_domain_band_restore_fx(
+ const Word16 bands, /* i: total subband */
+ Word16 band_start[], /* i/o: starting position of subband */
+ Word16 band_end[], /* i/o: end position of subband */
+ Word16 band_width[], /* i/o: band width of subband */
+ const Word16 org_band_start[], /* o: starting position of subband */
+ const Word16 org_band_end[], /* o: end position of subband */
+ const Word16 org_band_width[] /* o: band width of subband */
+);
+
+void spt_swb_peakpos_tmp_save_fx(
+ const Word32 L_y2[], /* i: coded spectral information */
+ const Word16 bands, /* i: total number of bands */
+ const Word16 band_start[], /* i: starting position of subband */
+ const Word16 band_end[], /* i: end position of subband */
+ Word16 prev_SWB_peak_pos_tmp[] /* o: spectral peaks */
+);
+
+Word16 div_s_ss( /* o: result of division (Word16 Q0) */
+ const Word16 n, /* i: numerator (Word16 Q0 */
+ const Word16 d /* i: denominator (Word16 Q0) */
+);
+
+void updat_prev_frm_fx(
+ Word32 L_y2[], /* i/o: core coder buffer */
+ Word32 L_t_audio[], /* o: core coder buffer */
+ Word32 L_bwe_br, /* i: core bitrate */
+ Word16 length_fx, /* i: frame length coded bw */
+ const Word16 inner_frame_fx, /* i: input frame length */
+ Word16 bands_fx, /* i: sub band resolution */
+ Word16 bwidth_fx, /* i: NB/WB/SWB indicator */
+ const Word16 is_transient_fx, /* i: signal class information */
+ Word16 hqswb_clas_fx, /* i: signal class information */
+ Word16 *prev_hqswb_clas_fx, /* o: update signal class information */
+ Word16 prev_SWB_peak_pos_fx[], /* o: update core coder last coded peaks*/
+ Word16 prev_SWB_peak_pos_tmp_fx[], /* o: update core coder last coded peaks*/
+ Word16 *prev_frm_hfe2_fx, /* o: update harmonics */
+ Word16 *prev_stab_hfe2_fx, /* o: update harmonics */
+ Word16 bws_cnt_fx /* i: band width detector */
+);
+
+void hf_parinitiz_fx(
+ const Word32 L_total_brate,
+ const Word16 hqswb_clas_fx,
+ Word16 lowlength_fx,
+ Word16 highlength_fx,
+ Word16 wBands_fx[],
+ const Word16 **subband_search_offset_fx,
+ const Word16 **subband_offsets_fx,
+ Word16 *nBands_fx,
+ Word16 *nBands_search_fx,
+ Word16 *swb_lowband_fx,
+ Word16 *swb_highband_fx
+);
+
+void GetlagGains_fx(
+ const Word16 *predBuf_fx, /* i: Qss Low freq. Smoothed Spectrum */
+ const Word16 Qss, /* i: Q0 Q value of predBuf */
+ const Word32 *L_band_energy, /* i: Qbe Band Energy */
+ const Word16 Qbe, /* i: Q0 Q value of band energy */
+ const Word16 nBands, /* i: Q0 number of SWB subbands */
+ const Word16 *sbWidth, /* i: Q0 width of SWB subbands */
+ const Word16 *lagIndices, /* i: Q0 lagIndices */
+ const Word16 predBufLen, /* i: Q0 length of predBuf */
+ Word16 *lagGains_fx, /* o: QlagGains lagGains */
+ Word16 *QlagGains /* o: Q0 Q value of lagGains */
+);
+
+void noise_extr_corcod_fx(
+ Word32 L_spectra[], /* i : QsL core coder */
+ const Word32 L_spectra_ni[], /* i : QsL core coder with sparse filling */
+ Word16 sspectra_fx[], /* o : Qss Smoothed tonal information from core coder */
+ Word16 sspectra_diff_fx[], /* o : Qss non tonal infomration for gap filling */
+ Word16 sspectra_ni_fx[], /* o : Qss smoothed core coder */
+ const Word16 fLenLow_fx, /* i : Q0 low frequency bands width */
+ Word16 prev_hqswb_clas_fx, /* i : Q0 classification information */
+ Word16 *prev_ni_ratio_fx, /* i : Q15 noise paraemeter */
+ Word16 *Qss /* o : Q0 Q value for sspectra_*_fx */
+);
+
+void ton_ene_est_fx(
+ Word32 L_xSynth_har[], /* i : QsL buffer with non tonal compoents */
+ Word16 QsL, /* i : Q0 Q value for xSynth_har */
+ Word32 L_be_tonal[], /* o : QbeL tonal energy of the missing bands */
+ Word16 *QbeL, /* o : Q0 Q value for be_tonal */
+ Word32 L_band_energy[], /* i : Qbe subband energies */
+ Word16 Qbe, /* i : Q0 Q value for band_energy */
+ const Word16 band_start[], /* i : Q0 subband start indices */
+ const Word16 band_end[], /* i : Q0 subband end indices */
+ const Word16 band_width[], /* i : Q0 subband widths */
+ const Word16 fLenLow, /* i : Q0 low frequency width */
+ const Word16 fLenHigh, /* i : Q0 High frequency width */
+ Word16 bands, /* i : Q0 total subbands */
+ Word16 har_bands, /* i : Q0 total number of harmonics bands */
+ Word16 ni_lvl_fx, /* i : Q11 noise enve for the hf bands */
+ GainItem_fx pk_sf_fx[], /* i : */
+ Word16 Qss, /* i : Q0 Q value for GainItem_fx->nmrValue */
+ Word16 *pul_res /* i : Q0 tonal resolution */
+);
+
+void Gettonl_scalfact_fx
+(
+ Word32 *L_outBuf, /* i/o: QsL synthesized spectrum */
+ Word16 QsL, /* i : Q0 Q value for outBuf */
+ const Word32 *L_codbuf, /* i : QsL core coder */
+ const Word16 fLenLow, /* i : Q0 lowband length */
+ const Word16 fLenHigh, /* i : Q0 highband length */
+ const Word16 harmonic_band, /* i : Q0 total number of Low frequency bands */
+ const Word16 bands, /* i : Q0 total number of subbands in a frame */
+ Word32 *L_band_energy, /* i : Qbe band energy of each subband */
+ Word16 Qbe, /* i : Q0 Q value for band_energy */
+ const Word16 *band_start, /* i : Q0 subband start indices */
+ const Word16 *band_end, /* i : Q0 subband end indices */
+ const Word16 p2aflags[], /* i : Q0 missing bands in the core coder */
+ Word32 L_be_tonal[], /* i : QbeL tonal energy */
+ Word16 QbeL, /* i : Q0 Q value for be_tonal */
+ GainItem_fx *pk_sf_fx, /* i : toanl information for Sparse filling */
+ Word16 Qss, /* i : Q0 Q value for pk_sf.nmrValue */
+ Word16 *pul_res_pk /* i : Q0 pulse resolution information */
+);
+
+
+void get_sigma_fx_har(
+ const Word32 L_x_abs[], /* i: Qi absolute input */
+ const Word16 Qi, /* i: Q0 Q value of x_abs */
+ const Word16 avg_fx, /* i: Qavg average of x_abs */
+ const Word16 Qavg, /* i: Q0 Q value of avg */
+ const Word16 length_fx, /* i: Q0 length */
+ Word16 *sigma_fx, /* o: Qsigma sigma */
+ Word16 *Qsigma /* o: Q0 Q value of sigma */
+);
+
+void FindNBiggest2_simple_fx_har(
+ const Word32 *L_inBuf, /* i : input buffer (searched) */
+ const Word16 Qabs_in, /* i : Q value of input buffer */
+ GainItem_fx *pk_sf_fx, /* o : N biggest components found */
+ const Word16 nIdx_fx, /* i : search length */
+ Word16 *n_fx, /* i : number of components searched (N biggest) */
+ Word16 n_nbiggestsearch
+);
+
+Word16 spectrumsmooth_noiseton_fx( /* o : Qss ss_min */
+ Word32 L_spectra[], /* i : Qs core coder */
+ /*Word16 Qs,*/ /* i : Q0 Q value for spectra, spectra_ni */
+ const Word32 L_spectra_ni[], /* i : Qs core coder with sparse filling */
+ Word16 sspectra_fx[], /* o : Qss Smoothed tonal information from core coder */
+ Word16 sspectra_diff_fx[], /* o : Qss non tonal infomration for gap filling */
+ Word16 sspectra_ni_fx[], /* o : Qss smoothed core coder */
+ Word16 *Qss, /* o : Q0 Q value for sspectra* */
+ const Word16 fLenLow_fx, /* i : Q0 low frequency boundaries */
+ Word16 *ni_seed_fx /* io : Q0 random seed */
+);
+
+void noiseinj_hf_fx(
+ Word32 L_xSynth_har[], /* i/o : Qs gap filled information */
+ Word16 Qs, /* i : Q0 Q value for xSynth_har */
+ Word32 L_th_g[], /* i : Qs level adjustment information */
+ Word32 L_band_energy[], /* i : Qbe subband energies */
+ Word16 Qbe, /* i : Q0 Q value for band_energy */
+ Word16 *prev_En_sb_fx, /* i/o : QsEn smoothed sqrt band Energies */
+ const Word16 p2a_flags_fx[], /* i : Q0 Missing bands in the core coder */
+ const Word16 BANDS_fx, /* i : Q0 total bands */
+ const Word16 band_start_fx[], /* i : Q0 band start indices */
+ const Word16 band_end_fx[], /* i : Q0 band end indices */
+ const Word16 fLenLow_fx, /* i : Q0 low frequency bandwidth */
+ const Word16 fLenHigh_fx /* i : Q0 SWB frequency bandwidth */
+);
+
+void sqrt_32n_16_fx(
+ Word32 L_in, /* i : input vector (Word32) */
+ Word16 Qin, /* i : Q value for L_in */
+ Word16 *out_fx, /* o : sqrt input vector (Word16) */
+ Word16 *Qout /* o : Q value for out_fx */
+);
+
+void norm_vec_32_16_scale_fx(
+ Word32 *L_vec_in, /* i : input vector */
+ Word16 Qin, /* i : Q value for input vector */
+ Word16 length_fx, /* i :vector size */
+ Word16 *vec_out_fx, /* o : output vectror */
+ Word16 *Qout, /* o : Q value for output vectro */
+ Word16 exp_safe /* i : suppress left shift: for prevend overflow on sum */
+);
+
+void return_bits_normal2_fx(
+ Word16 *bit_budget_fx, /* i/o : bit budget */
+ const Word16 p2a_flags_fx[], /* i : HF tonal indicator */
+ const Word16 bands_fx, /* i : Total number of Subbands in a frame */
+ const Word16 bits_lagIndices_fx[] /* i : bits for lagIndices */
+);
+
+Word16 peak_avrg_ratio_fx(
+ const Word32 total_brate,
+ const Word32 *input_hi_fx, /* i : input signal */
+ const Word16 length, /* i : number of coefficients */
+ Word16 *mode_count, /* i/o: HQ_HARMONIC mode count */
+ Word16 *mode_count1, /* i/o: HQ_NORMAL mode count */
+ Word16 Q_coeff
+);
+
+void diffcod_fx(
+ const Word16 N, /* (i) number of sub-vectors */
+ Word16 *y, /* (i/o) indices of quantized norms */
+ Word16 *difidx /* (o) differential code */
+);
+
+void diffcod_lrmdct_fx(
+ const Word16 N, /* i : number of sub-vectors */
+ const Word16 be_ref, /* i : band energy reference */
+ Word16 *y, /* i/o: indices of quantized norms */
+ Word16 *difidx, /* o : differential code */
+ const Word16 is_transient /* i : transient flag */
+);
+
+Word16 encode_envelope_indices_fx( /* o : Number of bits if flag_pack=0,0 if flag_pack=1 Q0 */
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 num_sfm, /* i : Number of subbands Q0 */
+ const Word16 numnrmibits, /* i : Bitrate of fall-back coding mode Q0 */
+ Word16 *difidx, /* i/o: Diff indices/encoded diff indices Q0 */
+ Word16 *LCmode, /* o : Coding mode if flag_pack=0, i : if flag_pack=1 Q0 */
+ const Word16 flag_pack, /* i : indicator of packing or estimating bits Q0 */
+ const Word16 flag_HQ2 /* i : indicator of HQ2 core Q0 */
+ ,
+ const Word16 is_transient /* i : indicator of HQ_TRANSIENT Q0 */
+);
+Word16 decode_envelope_indices_fx( /* o : Number of bits */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 start_norm, /* i : starting band index */
+ const Word16 num_sfm, /* i : Number of subbands */
+ const Word16 numnrmibits, /* i : Bitrate of fall-back coding mode */
+ Word16 *difidx, /* o : Diff indices/encoded diff indices */
+ const Word16 flag_HQ2 /* i : indicator of HQ2 core */
+ ,
+ const Word16 is_transient /* i : indicator of HQ_TRANSIENT */
+);
+
+void hdecnrm_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 numNorms, /* (i) number of norms */
+ Word16 *index); /* (o) indices of quantized norms */
+
+Word16 decode_huff_context_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 *hufftab,
+ Word16 *rbits
+);
+
+void hdecnrm_context_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 N,
+ Word16 *index,
+ Word16 *n_length
+);
+
+void hdecnrm_resize_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 N, /* (i) number of SFMs */
+ Word16 *index /* (o) norm quantization index vector */
+);
+
+void hdecnrm_tran_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 N, /* i : number of norms */
+ Word16 *index /* o : indices of quantized norms */
+);
+
+void mdct_spectrum_denorm_fx(
+ const Word16 inp_vector[], /* i : Q0 : */
+ Word32 L_y2[], /* i/o : Qs : decoded spectrum */
+ const Word16 band_start[], /* i : Q0 : table of start freq for every subband */
+ const Word16 band_end[], /* i : Q0 : table of end freq for every subband */
+ const Word16 band_width[], /* i : Q0 : table of bandwidth for every subband */
+ const Word32 L_band_energy[], /* i : Qbe : band energy */
+ const Word16 npulses[], /* i : Q0 : number of coded spectrum */
+ const Word16 bands, /* i : Q0 : numbers of subbands */
+ const Word16 ld_slope_fx, /* i : Q15 : */
+ const Word16 pd_thresh_fx /* i : Q15 : */
+);
+
+/* y(n)(Qx) = alpha(Q15) * x(Qx) + (1.0f-alpha)* y(n-1) (Qx) */
+Word16 noise_est_AR1_Qx( /* o: Qx y(n) */
+ Word16 x, /* i : Qx x(n) */
+ Word16 y, /* i : Qx y(n-1) */
+ Word16 alpha /*i : Q15 scaling of driving x(n) */
+);
+void noise_est_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ const Word32 tmpN[], /* i : temporary noise update Q_new + QSCALE */
+ const Word16 *pit, /* i : open-loop pitch values for each half-frame Q0 */
+ const Word16 cor[], /* i : normalized correlation for all half-frames Q15 */
+ const Word16 epsP_h[], /* i : msb prediction error energies Q_r-1 */
+ const Word16 epsP_l[], /* i : msb prediction error energies Q_r-1 */
+ const Word16 Etot, /* i : total channel E (see find_enr_fx.c) Q8 */
+ const Word16 relE, /* i : (VA_CHECK addition) relative frame energy Q8? */
+ const Word16 corr_shift, /* i : normalized correlation correction Q15 */
+ const Word32 enr[], /* i : averaged energy over both subframes Q_new + Q_SCALE */
+ Word32 fr_bands[], /* i : spectrum per critical bands of the current frame Q_new + Q_SCALE */
+ Word16 *cor_map_sum, /* o : Q8 */
+ Word16 *sp_div, /* o : Q_sp_div */
+ Word16 *Q_sp_div, /* o : Q factor for sp_div */
+ Word16 *non_staX, /* o : non-stationarity for sp/mus classifier */
+ Word16 *loc_harm , /* o : multi-harmonicity flag for UV classifier */
+ const Word32 *lf_E, /* i : per bin energy for low frequencies Q_new + Q_SCALE -2 */
+ Word16 *st_harm_cor_cnt, /* i/o : 1st harm correlation timer Q0 */
+ const Word16 Etot_l_lp, /* i : Smoothed low energy Q8 */
+ const Word16 Etot_v_h2, /* i : Energy variations Q8 */
+ Word16 *bg_cnt, /* i : Background burst length timer Q0 */
+ Word16 EspecdB[], /* i/o: log E spectrum (with f=0) of the current frame Q7 */
+ Word16 Q_new , /* i : Scaling of current frame */
+
+ const Word32 Le_min_scaled /*i : Minimum energy value */
+ , Word16 *sp_floor /* o : noise floor estimate Q7 */
+);
+
+
+void autocorr_fx(
+ const Word16 x[], /* i : Input signal */
+ const Word16 m, /* i : LPC order Q0 */
+ Word16 r_h[], /* o : Autocorrelations (msb) Q15 */
+ Word16 r_l[], /* o : Autocorrelations (lsb) */
+ Word16 *Q_r, /* o : normailsation shift of r Q0 */
+ const Word16 len, /* i : Frame lenght */
+ const Word16* wind, /* i : Window used */
+ Word16 rev_flag,
+ const Word16 sym_flag /* i : symmetric window flag */
+);
+void freq_dnw_scaling_fx(
+ const Word16 cor_strong_limit, /* i : HF correlation */
+ const Word16 coder_type, /* i : coder type */
+ const Word16 noise_lev, /* i : Noise level */
+ const Word32 core_brate, /* i : Core bitrate */
+ Word16 fy_norm[], /* i/o: Frequency quantized parameter */
+ Word16 Qx /* Q format of fy_norm*/
+);
+void Comp_and_apply_gain_fx(
+ Word16 exc_diffQ[], /* i/o: Quantized excitation */
+ Word16 Ener_per_bd_iQ[], /* i : Target ener per band Q13 */
+ Word16 Ener_per_bd_yQ[], /* i/o : Ener per band for norm vector i->Q13/o->Q13 */
+ Word16 Mbands_gn, /* i : number of bands */
+ const Word16 ReUseGain , /* i : Reuse the gain in Ener_per_bd_yQ */
+ Word16 Qexc_diff,
+ Word16 Q_exc
+);
+void dec_pit_exc_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder static memory */
+ const Word16 *Aq_fx, /* i : LP filter coefficient */
+ const Word16 coder_type_fx, /* i : coding type */
+ const Word16 Es_pred_fx, /* i : predicted scaled innov. energy */
+ Word16 *pitch_buf_fx, /* o : floating pitch values for each subframe */
+ Word16 *code_fx, /* o : innovation */
+ Word16 *exc_fx, /* i/o: adapt. excitation exc */
+ Word16 *bwe_exc_fx, /* o : excitation for SWB TBE */
+ const Word16 nb_subfr_fx /* i : Number of subframe considered */
+ , Word16 *gain_buf /*Q14*/
+);
+Word16 mean_fx( /* o : mean of vector */
+ const Word16 *vec_fx, /* i : input vector */
+ const Word16 lvec_fx /* i : length of input vector */
+);
+void gsc_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: State structure */
+ Word16 exc_dct_in[], /* i/o: dct of pitch-only excitation / total excitation */
+ const Word16 pit_band_idx, /* i : bin position of the cut-off frequency */
+ const Word16 Diff_len, /* i : Lenght of the difference signal (before pure spectral)*/
+ const Word16 bits_used, /* i : Number of bit used before frequency Q */
+ const Word16 nb_subfr, /* i : Number of subframe considered */
+ const Word16 coder_type, /* i : coding type */
+ Word16 *last_bin, /* i : last bin of bit allocation */
+ Word16 *lsf_new, /* i : ISFs at the end of the frame */
+ Word16 *exc_wo_nf, /* o : excitation (in f domain) without noisefill */
+ Word16 Q_exc
+);
+void fft_rel_fx(
+ Word16 x[], /* i/o: input/output vector */
+ const Word16 n, /* i : vector length */
+ const Word16 m /* i : log2 of vector length */
+);
+void ifft_rel_fx(
+ Word16 io[], /* i/o: input/output vector */
+ const Word16 n, /* i : vector length */
+ const Word16 m /* i : log2 of vector length */
+);
+
+Word16 gsc_gaindec_fx( /* o : average frequency gain */
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 y_gainQ_fx[], /* o : quantized gain per band */
+ const Word32 core_brate_fx, /* i : core used */
+ Word16 old_y_gain_fx[], /* i/o: AR gain quantizer for low rate */
+ const Word16 coder_type_fx, /* i : coding type */
+ const Word16 bwidth_fx /* i : input signal bandwidth */
+);
+void Copy_Scale_sig(
+ const Word16 x[], /* i : signal to scale input Qx */
+ Word16 y[], /* o : scaled signal output Qx */
+ const Word16 lg, /* i : size of x[] Q0 */
+ const Word16 exp0 /* i : exponent: x = round(x << exp) Qx ?exp */
+);
+
+void bands_and_bit_alloc_fx(
+ const Word16 cor_strong_limit, /* i : HF correlation */
+ const Word16 noise_lev, /* i : dwn scaling factor */
+ const Word32 core_brate, /* i : core bit rate */
+ const Word16 Diff_len, /* i : Lenght of the difference signal (before pure spectral)*/
+ const Word16 bits_used, /* i : Number of bit used before frequency Q */
+ Word16 *bit, /* i/o: Number of bit allowed for frequency quantization */
+ const Word16 *Ener_per_bd_iQ, /* i/o: Quantized energy vector */
+ Word16 *max_ener_band, /* o : Sorted order */
+ Word16 *bits_per_bands, /* i/o: Number of bit allowed per allowed subband Q3 */
+ Word16 *nb_subbands, /* o : Number of subband allowed */
+ const Word16 *exc_diff, /* i : Difference signal to quantize (encoder side only) */
+ Word16 *concat_in, /* o : Concatened PVQ's input vector (encoder side only) */
+ Word16 *pvq_len, /* o : Number of bin covered with the PVQ */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 bwidth, /* i : input signal bandwidth */
+ const Word16 GSC_noisy_speech
+);
+
+
+void decod_audio_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder static memory */
+ Word16 dct_epit[], /* o : GSC excitation in DCT domain */
+ const Word16 *Aq, /* i : LP filter coefficient */
+ const Word16 coder_type, /* i : coding type */
+ Word16 *pitch_buf, /* o : floating pitch values for each subframe */
+ Word16 *voice_factors, /* o : voicing factors */
+ Word16 *exc, /* i/o: adapt. excitation exc */
+ Word16 *exc2, /* i/o: adapt. excitation/total exc */
+ Word16 *bwe_exc, /* o : excitation for SWB TBE */
+ Word16 *lsf_new /* i : ISFs at the end of the frame */
+ , Word16 *gain_buf /*Q14*/
+);
+Word16 Pit_exc_contribution_len_fx( /* o : bin where pitch contribution is significant */
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ const Word16 *dct_res, /* i : DCT of residual */
+ Word16 *dct_pitex, /* i/o: DCT of pitch contribution */
+ Word16 *pitch_buf, /* i/o: Pitch per subframe */
+ const Word16 nb_subfr, /* i : Number of subframe considered */
+ Word16 *hangover, /* i : hangover for the time contribution switching */
+ const Word16 coder_type, /* i : coding type */
+ Word16 Qnew
+);
+void enc_pit_exc_fx(
+ Encoder_State_fx *st_fx, /* i/o: State structure */
+ LPD_state *mem, /* i/o: acelp memories */
+ const Word16 *speech, /* i : Input speech */
+ const Word16 Aw[], /* i : weighted A(z) unquantized for subframes */
+ const Word16 Aq[], /* i : 12k8 Lp coefficient */
+ const Word16 Es_pred, /* i : predicted scaled innov. energy */
+ const Word16 *T_op, /* i : open loop pitch */
+ const Word16 *voicing, /* i : voicing */
+ const Word16 *res, /* i : residual signal */
+ Word16 *synth, /* i/o: core synthesis */
+ Word16 *exc, /* i/o: current non-enhanced excitation */
+ Word16 *T0, /* i/o: close loop integer pitch */
+ Word16 *T0_frac, /* i/o: close-loop pitch period - fractional part */
+ Word16 *pitch_buf, /* i/o: Fractionnal per subframe pitch */
+ const Word16 nb_subfr, /* i : Number of subframe considered */
+ Word16 *gpit, /* o : pitch mean gpit */
+ Word16 *saved_bit_pos, /* o : saved position in the bitstream before pitch contribution */
+ Word16 Q_new,
+ Word16 shift
+);
+void encod_amr_wb_fx(
+ Encoder_State_fx *st, /* i/o: state structure */
+ LPD_state *mem, /* i/o: acelp memories */
+ const Word16 speech[], /* i : input speech */
+ const Word16 Aw[], /* i : weighted A(z) unquantized for subframes */
+ const Word16 Aq[], /* i : 12k8 Lp coefficient */
+ const Word16 pitch[3], /* i : open-loop pitch values for quantiz. */
+ const Word16 voicing[], /* i : voicing */
+ const Word16 *res, /* i : residual signal */
+ Word16 *syn, /* i/o: core synthesis */
+ Word16 *exc, /* i/o: current non-enhanced excitation */
+ Word16 *exc2, /* i/o: current enhanced excitation */
+ Word16 *pitch_buf, /* i/o: floating pitch values for each subframe */
+ Word16 hf_gain_fx[NB_SUBFR], /* o : decoded HF gain */
+ const Word16 *speech16k_fx,
+ Word16 shift,
+ Word16 Q_new
+);
+void amr_wb_enc_fx(
+ Encoder_State_fx *st, /* i/o: encoder state structure */
+ const Word16 input_sp[], /* i : input signal */
+ const Word16 n_samples /* i : number of input samples */
+);
+void encod_gen_voic_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ LPD_state *mem, /* i/o: acelp memories */
+ const Word16 L_frame_fx, /* i : length of the frame */
+ const Word16 sharpFlag_fx, /* o : formant sharpening flag */
+ const Word16 speech_fx[], /* i : input speech */
+ const Word16 Aq_fx[], /* i : 12k8 Lp coefficient */
+ const Word16 A_fx[], /* i : unquantized A(z) filter with bandwidth expansion */
+ const Word16 coder_type_fx, /* i : coding type */
+ const Word16 Es_pred_fx, /* i : predicted scaled innov. energy */
+ const Word16 T_op_fx[], /* i : open loop pitch */
+ const Word16 voicing_fx[], /* i : voicing */
+ const Word16 *res_fx, /* i : residual signal */
+ Word16 *syn_fx, /* i/o: core synthesis */
+ Word16 *exc_fx, /* i/o: current non-enhanced excitation */
+ Word16 *exc2_fx, /* i/o: current enhanced excitation */
+ Word16 *pitch_buf_fx, /* i/o: floating pitch values for each subframe */
+ Word16 *voice_factors_fx, /* o : voicing factors */
+ Word16 *bwe_exc_fx, /* o : excitation for SWB TBE */
+ Word16 *unbits_fx, /* i/o: number of unused bits */
+ Word16 shift,
+ Word16 Q_new
+);
+void bw_detect_fx(
+ Encoder_State_fx *st, /* i/o: Encoder State */
+ const Word16 signal_in[], /* i : input signal */
+ const Word16 localVAD,
+ Word32 *enerBuffer, /* i : CLDFB Energy */
+ Word16 *cldfbBuf_Ener_Exp /* i : CLDFB Energy Exponent */
+);
+void hf_synth_amr_wb_init_fx(
+ Word16 *prev_r, /* o : previous sub-frame gain */
+ Word16 *fmerit_w_sm, /* o : 1 sample memory fmerit_w param */
+ Word16 mem_syn_hf_fx[], /* o : HF LPC synthesis filter initialization */
+ Word16 *frame_count, /* o : frame counter initialization */
+ Word16 *ne_min, /* o : minimum Noise gate - short-term energy initialization*/
+ Word16 *fmerit_m_sm, /* o : 1 sample memory fmerit_m param */
+ Word16 *voice_fac, /* o : voice factor initialization */
+ Word16 *unvoicing, /* o : unvoiced parameter */
+ Word16 *unvoicing_sm, /* o : smoothed unvoiced parameter */
+ Word16 *unvoicing_flag, /* o : unvoiced flag */
+ Word16 *voicing_flag, /* o : voiced flag */
+ Word16 *start_band_old, /* o : previous start point for copying frequency band */
+ Word32 *OptCrit_old /* o : previous criterion value for deciding the start point */
+);
+
+void hf_synth_amr_wb_reset_fx(
+ Word16 *seed2, /* i/o: random seed for HF noise gen */
+ Word16 mem_syn_hf[], /* o : HF synthesis memory */
+ Word16 mem_hp_interp[], /* o : interpol. memory */
+ Word16 *prev_r, /* o : previous sub-frame gain */
+ Word16 *fmerit_w_sm, /* o : 1 sample memory fmerit_w param */
+ Word16 delay_syn_hf[], /* o : HF synthesis memory */
+ Word16 *frame_count, /* o : frame counter memory */
+ Word16 *ne_min, /* o : minimum Noise gate - short-term energy memory */
+ Word16 *fmerit_m_sm, /* o : 1 sample memory fmerit_m param */
+ Word16 *voice_fac, /* o : voice factor memory */
+ Word16 *unvoicing, /* o : unvoiced parameter */
+ Word16 *unvoicing_sm, /* o : smoothed unvoiced parameter */
+ Word16 *unvoicing_flag, /* o : unvoiced flag */
+ Word16 *voicing_flag, /* o : voiced flag */
+ Word16 *start_band_old, /* o : previous start point for copying frequency band */
+ Word32 *OptCrit_old /* o : previous criterion value for deciding the start point */
+);
+
+void hf_synth_amr_wb_fx(
+ const Word32 core_brate, /* i : core bitrate */
+ const Word16 output_frame, /* i : output frame length */
+ const Word16 *Aq, /* i : quantized Az : Q12 */
+ const Word16 *exc, /* i : excitation at 12.8 kHz : Qexc */
+ Word16 *synth, /* i/o: synthesis signal at 12.8k : Qsyn */
+ Word16 *mem_syn_hf, /* i/o: HF synthesis memory : Qout */
+ Word16 *delay_syn_hf, /* i/o: HF synthesis memory : Qout */
+ Word16 *prev_r, /* i/o : previous sub-frame gain : Q10 */
+ Word16 *fmerit_w_sm, /* i/o: smoothed fmerit_w : Q14 */
+ Word16 *amr_io_class, /* i : signal class (determined by FEC algorithm) */
+ Word16 *mem_hp_interp, /* i/o: interpol. memory : Qout */
+ Word16 *synth_out, /* i/o: output signal at output Fs : Qout */
+ Word16 fmerit, /* i : classify parameter from FEC : Q14 */
+ const Word16 *hf_gain, /* i : decoded HF gain */
+ const Word16 *voice_factors, /* i : voicing factors : Q15 */
+ const Word16 pitch_buf[], /* i : pitch buffer : Q5 */
+ const Word16 ng_ener_ST, /* i : Noise gate - short-term energy : Q8 */
+ const Word16 *lsf_new, /* i : ISF vector : Q2 */
+ Word16 *frame_count, /* i/o: frame counter */
+ Word16 *ne_min, /* i/o: minimum Noise gate : Q8 */
+ Word16 *fmerit_m_sm, /* i/o: smoothed fmerit_m : Q14 */
+ Word16 *voice_facor_sm, /* o : voice factor memory : Q15 */
+ Word16 *unvoicing, /* o : unvoiced parameter : Q15 */
+ Word16 *unvoicing_sm, /* o : smoothed unvoiced parameter : Q15 */
+ Word16 *unvoicing_flag, /* o : unvoiced flag */
+ Word16 *voicing_flag, /* o : voiced flag */
+ Word16 *start_band_old, /* o : previous start point for copying frequency band */
+ Word32 *OptCrit_old, /* o : previous criterion value for deciding the start point */
+ const Word16 Q_exc, /* i : exc scaling */
+ const Word16 Q_out /* i : synth_out scaling */
+);
+
+void hf_cod_init_fx(
+ Word16 *mem_hp400_enc, /* o: memory of hp 400 Hz filter */
+ Word16 *mem_hf1_enc, /* o: HF band-pass filter memory */
+ Word16 *mem_syn_hf_enc, /* o: HF synthesis memory */
+ Word16 *mem_hf2_enc, /* o: HF band-pass filter memory */
+ Word16 *gain_alpha_fx /* o: smoothing gain for transitions between active and inactive frames */
+);
+
+void hf_cod_fx(
+ const Word32 core_brate_fx, /* i : core bitrate */
+ const Word16 *speech16k_fx, /* i : original speech at 16 kHz */
+ const Word16 Aq_fx[], /* i : quantized Aq */
+ const Word16 exc_fx[], /* i : excitation at 12.8 kHz */
+ Word16 synth_fx[], /* i : 12.8kHz synthesis signal */
+ Word16 *seed2_enc_fx, /* i/o: random seed for HF noise gen */
+ Word16 *mem_hp400_enc_fx, /* i/o: memory of hp 400 Hz filter */
+ Word16 *mem_syn_hf_enc_fx, /* i/o: HF synthesis memory */
+ Word16 *mem_hf1_enc_fx, /* i/o: HF band-pass filter memory */
+ Word16 *mem_hf2_enc_fx, /* i/o: HF band-pass filter memory */
+ const Word16 dtxHangoverCount_fx,
+ Word16 *gain_alpha_fx, /* i/o: smoothing gain for transitions between active and inactive frames */
+ Word16 *hf_gain_fx, /* o : HF gain to be transmitted to decoder */
+ Word16 Q_exc,
+ Word16 Q_syn
+);
+
+void re8_compute_base_index_fx(
+ const Word16 *x, /* i : Elemen of Q2, Q3 or Q4 */
+ const Word16 ka, /* i : Identifier of the absolute leader related to x */
+ UWord16 *I /* o : index */
+);
+
+void InitSWBencBuffer_fx(
+ Encoder_State_fx* st_fx /* i/o: SHB encoder structure */
+);
+
+void ResetSHBbuffer_Enc_fx(
+ Encoder_State_fx* st_fx /* i/o: SHB encoder structure */
+);
+void wb_tbe_extras_reset_synth_fx( Word16 state_lsyn_filt_shb[], Word16 state_lsyn_filt_dwn_shb[],
+ Word16 state_32and48k_WB_upsample[]
+ ,Word16 state_resamp_HB[]
+ );
+
+void pz_filter_sp_fx (
+ const Word16 b [],
+ const Word16 a [],
+ Word16 x [],
+ Word16 y [],
+ Word16 buf [],
+ Word16 PNR,
+ Word16 PDR,
+ Word16 N,
+ Word16 Qa
+);
+
+void Decimate_allpass_steep_fx(
+ const Word16 *in_fx,
+ Word16 state_fx[], /* array of size: 2*ALLPASSSECTIONS_STEEP+1 */
+ Word16 N, /* number of input samples */
+ Word16 out_fx[] /* array of size N/2 */
+);
+
+Word32 root_a_fx(
+ Word32 a,
+ Word16 Q_a,
+ Word16 *exp_out
+);
+
+Word32 root_a_over_b_fx(
+ Word32 a,
+ Word16 Q_a,
+ Word32 b,
+ Word16 Q_b,
+ Word16 *exp_out
+);
+
+
+void fir_fx(
+ const Word16 x[], /* i : input vector */
+ const Word16 h[], /* i : impulse response of the FIR filter */
+ Word16 y[], /* o : output vector (result of filtering) */
+ Word16 mem[], /* i/o: memory of the input signal (M samples) */
+ const Word16 L, /* i : input vector size */
+ const Word16 K, /* i : order of the FIR filter (M+1 coefs.) */
+ const Word16 upd, /* i : 1 = update the memory, 0 = not */
+ Word16 shift /* i : difference between Q15 and scaling of h[] */
+);
+
+
+void Interpolate_allpass_steep_fx(
+ const Word16 *in_fx, /* i : input signal */
+ Word16 state_fx[], /* array of size: 2*ALLPASSSECTIONS_STEEP+1 */
+ Word16 N, /* number of input samples */
+ Word16 out_fx[] /* o : output signal, size 2*N */
+);
+
+void interpolate_3_over_2_allpass_fx(
+ const Word16 *input_fx,
+ const Word16 len,
+ Word16 *out_fx,
+ Word16 *mem_fx,
+ const Word16 *filt_coeff_fx
+);
+void interpolate_3_over_1_allpass_fx(
+ const Word16 *input_fx,
+ const Word16 len,
+ Word16 *out_fx,
+ Word16 *mem_fx,
+ const Word16 *filt_coeff_fx
+);
+void decimate_2_over_3_allpass_fx(
+ const Word16 *input_fx,
+ const Word16 len,
+ Word16 *out_fx,
+ Word16 *mem_fx,
+ const Word16 *filt_coeff_fx,
+ const Word16 *lp_num_fx,
+ const Word16 *lp_den_fx,
+ Word16 *lp_mem_fx
+);
+
+void retro_interp4_5_fx(
+ const Word16 *syn_fx,
+ Word16 *pst_old_syn_fx
+);
+void retro_interp5_4_fx(
+ Word16 *pst_old_syn_fx
+);
+
+void lsp2lpc_fx(
+ Word16 *a,
+ Word16 *freq,
+ Word16 *prev_a,
+ Word16 order
+);
+
+void PostShortTerm_fx(
+ Word16 *sig_in, /* i : input signal (pointer to current subframe */
+ Word16 *lpccoeff, /* i : LPC coefficients for current subframe */
+ Word16 *sig_out, /* o : postfiltered output */
+ Word16 *mem_stp, /* i/o: postfilter memory*/
+ Word16 *ptr_mem_stp, /* i/o: pointer to postfilter memory*/
+ Word16 *ptr_gain_prec, /* i/o: for gain adjustment*/
+ Word16 *mem_zero, /* i/o: null memory to compute h_st*/
+ Word16 formant_fac_fx /* i : Strength of post-filter*/
+);
+
+void GenShapedWBExcitation_fx(
+ Word16 *excSHB, /* o : synthesized shaped shb exctiation */
+ const Word16 *lpc_shb, /* i : lpc coefficients */
+ Word16 *exc4kWhtnd, /* o : whitened synthesized shb excitation */
+ Word32 *mem_csfilt, /* i/o : memory */
+ Word16 *mem_genSHBexc_filt_down1, /* i/o : memory */
+ Word16 *mem_genSHBexc_filt_down2, /* i/o : memory */
+ Word16 *mem_genSHBexc_filt_down3, /* i/o : memory */
+ Word16 *state_lpc_syn, /* i/o : memory */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 *bwe_exc_extended, /* i : bandwidth extended exciatation */
+ const Word16 Q_bwe_exc,
+ Word16 bwe_seed[], /* i/o : random number generator seed */
+ const Word16 voice_factors[], /* i : voicing factor */
+ const Word16 signal_type
+ , const Word16 igf_flag
+);
+
+void GenWBSynth_fx(
+ const Word16 *input_synspeech, /* i : input synthesized speech */
+ Word16 *shb_syn_speech_16k, /* o : output highband compnent */
+ Word16 *state_lsyn_filt_shb1, /* i/o: memory */
+ Word16 *state_lsyn_filt_shb2 /* i/o: memory */
+);
+
+void GenSHBSynth_fx(
+ const Word16 *shb_target_speech, /* i : input synthesized speech */
+ Word16 *shb_syn_speech_32k, /* o : output highband component */
+ Word32 Hilbert_Mem[], /* i/o: memory */
+ Word16 genSHBsynth_allpass_mem[], /* i/o: memory */
+ const Word16 L_frame, /* i : ACELP Frame length */
+ Word16 *syn_dm_phase
+);
+
+Word16 swb_formant_fac_fx( /* o : Formant filter strength [0,1] */
+ const Word16 lpc_shb2, /* Q12 i : 2nd HB LPC coefficient */
+ Word16* tilt_mem /* i/o: Tilt smoothing memory */
+);
+
+void compute_poly_product_fx(Word16 *coef, Word32 *p,Word16 order);
+
+void ScaleShapedSHB_fx(
+ const Word16 length, /* i : SHB overlap length */
+ Word16 *synSHB, /* i/o: synthesized shb signal */
+ Word16 *overlap, /* i/o: buffer for overlap-add */
+ const Word16 *subgain, /* i : subframe gain */
+ const Word32 frame_gain, /* i : frame gain */
+ const Word16 *win, /* i : window */
+ const Word16 *subwin, /* i : subframes window */
+ Word16 *Q_bwe_exc
+ ,Word16 *Qx
+ ,Word16 n_mem3
+ ,Word16 prev_Q_bwe_syn2
+);
+
+void ScaleShapedWB_fx(
+ const Word16 length, /* i : SHB overlap length */
+ Word16* synSHB, /* i/o : synthesized shb signal */
+ Word16* overlap, /* i/o : buffer for overlap-add */
+ const Word16* subgain, /* i : subframe gain */
+ const Word32 frame_gain, /* i : frame gain */
+ const Word16* win, /* i : window */
+ const Word16* subwin, /* i : subframes window */
+ const Word16 Q_bwe_exc
+ ,Word16 L_frame /* i : Frame length - determines whether 12.8 or 16kHz core in-use */
+ ,Word16 dynQ /* i : indicate whether output is dynamic Q, or Q0 */
+ ,Word16* Qx /* o : newly computed Q factor for synSHB */
+ ,Word16 prev_Qx /* i : prev_Qx for memory scaling */
+ ,Word32* Hilbert_Mem /* i : Hilbert memory used for computing Qx */
+);
+
+void GenShapedSHBExcitation_fx(
+ Word16 *excSHB, /* o : synthesized shaped shb excitation Q_bwe_exc*/
+ const Word16 *lpc_shb, /* i : lpc coefficients Q12*/
+ Word16 *White_exc16k_FB, /* o : white excitation for the Fullband extension Q_bwe_exc */
+ Word32 *mem_csfilt, /* i/o: memory */
+ Word16 *mem_genSHBexc_filt_down_shb, /* i/o: memory */
+ Word16 *state_lpc_syn, /* i/o: memory */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 *bwe_exc_extended, /* i : bandwidth extended excitation */
+ Word16 bwe_seed[], /* i/o: random number generator seed */
+ Word16 voice_factors[], /* i : voicing factor*/
+ const Word16 extl, /* i : extension layer */
+ Word16 *tbe_demph, /* i/o: de-emphasis memory */
+ Word16 *tbe_premph, /* i/o: pre-emphasis memory */
+ Word16 *lpc_shb_sf, /* i: LP coefficients */
+ const Word32 shb_ener_sf_32,
+ Word16 *shb_res_gshape,
+ Word16 *shb_res,
+ Word16 *vf_ind,
+ const Word16 formant_fac, /* i : Formant sharpening factor [0..1] */
+ Word16 fb_state_lpc_syn[], /* i/o: memory */
+ Word16 *fb_tbe_demph, /* i/o: fb de-emphasis memory */
+ Word16 *Q_bwe_exc,
+ Word16 *Q_bwe_exc_fb,
+ const Word16 Q_shb,
+ Word16 n_mem2, /* i : n_mem2 scale factor to adjust 24.4/32kbps memories */
+ Word16 prev_Q_bwe_syn, /* i : st_fx->prev_Q_bwe_syn */
+ const Word32 bitrate,
+ const Word16 prev_bfi
+);
+
+
+void space_lsfs_fx (
+ Word16 *lsfs, /* i/o: Line spectral frequencies */
+ const Word16 order /* i : order of LP analysis */
+);
+
+
+void lsp_weights_fx(
+ Word16 lsp_nq_fx[],
+ Word16 w[],
+ Word16 Order,
+ Word16 *Qout
+);
+
+
+void lsp_convolve_fx(Word32 x, Word32 *p1, Word32 *p2, Word16 len);
+Word32 poscos_fx(Word16 w);
+
+void flip_spectrum_and_decimby4_fx(
+ const Word16 input[], /* i : input spectrum */
+ Word16 output[], /* o : output spectrum */
+ const Word16 length, /* i : vector length */
+ Word16 mem1[], /* i/o : memory */
+ Word16 mem2[], /* i/o : memory */
+ const Word16 ramp_flag /* i : flag to trigger slow ramp-up of output following change of core */
+);
+
+
+Word16 lpc2lsp_fx(
+ Word32 *a,
+ Word16 *freq,
+ Word16 *old_freq,
+ Word16 order
+);
+
+Word16 usquant_fx( /* o: index of the winning codeword */
+ const Word16 x, /* i: scalar value to quantize Qx*/
+ Word16 *xq, /* o: quantized value Qx*/
+ const Word16 qlow, /* i: lowest codebook entry (index 0) Qx*/
+ const Word16 delta, /* i: quantization step Qx-1*/
+ const Word16 cbsize /* i: codebook size */
+);
+
+void wb_tbe_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 *hb_speech, /* i : HB target signal (6-8kHz) at 16kHz */
+ const Word32 *bwe_exc_extended, /* i : bandwidth extended exciatation */
+ const Word16 Q_new, /* i : input HB speech Q factor */
+ const Word16 voice_factors[], /* i : voicing factors */
+ const Word16 pitch_buf[], /* i : pitch for each subframe */
+ const Word16 voicing[] /* i : OL maximum normalized correlation */
+);
+
+void wb_pre_proc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 *new_inp_resamp16k, /* i : original input signal */
+ Word16 *hb_speech /* o : HB target signal (6-8kHz) at 16kHz */
+);
+
+
+void pz_filter_dp_fx (
+ const Word16 b [],
+ const Word16 a [],
+ Word16 x [],
+ Word16 y [],
+ Word32 buf [],
+ Word16 PNR,
+ Word16 PDR,
+ Word16 N,
+ Word16 Qa
+);
+
+void flip_and_downmix_generic_fx(
+ Word16 input[], /* i : input spectrum */
+ Word16 output[], /* o : output spectrum */
+ const Word16 length, /* i : length of spectra */
+ Word32 mem1_ext[HILBERT_ORDER1], /* i/o: Hilbert filter memory */
+ Word32 mem2_ext[2*HILBERT_ORDER2], /* i/o: memory */
+ Word32 mem3_ext[2*HILBERT_ORDER2], /* i/o: memory */
+ Word16 *phase_state /* i/o: Phase state in case frequency isn't multiple of 50 Hz */
+);
+
+
+void wb_tbe_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 coder_type, /* i : coding type */
+ Word32 *bwe_exc_extended, /* i : bandwidth extended exciatation */
+ const Word16 Q_exc,
+ const Word16 voice_factors[], /* i : voicing factors */
+ Word16 *synth, /* i/o: ACELP core synthesis/final synthesis */
+ Word16 *Q_synth
+);
+
+void swb_tbe_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 coder_type_fx, /* i : coding type */
+ Word16 *new_speech_fx, /* i : original input signal */
+ Word32 *bwe_exc_extended_fx, /* i : bandwidth extended excitation */
+ const Word16 voice_factors_fx[], /* i : voicing factors */
+ Word16 *White_exc16k_fx, /* o : shaped white excitation for the FB TBE */
+ Word16 *Q_white_exc, /* o : generated white noise for FB Q factor */
+ Word16 Q_bwe_exc, /* i : bandwidth extended excitation Q factor */
+ Word16 Q_shb, /* i : SHB target Q factor */
+ Word16 *voicing_fx, /* i : OL maximum normalized correlation */
+ const Word16 pitch_buf[] /* i : pitch for each subframe */
+);
+
+void swb_pre_proc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 *input_fx, /* i : original input signal */
+ Word16 *new_swb_speech_fx, /* o : original input signal at 32kHz */
+ Word16 *shb_speech_fx, /* o : SHB target signal (6-14kHz) at 16kHz */
+ Word16 *Q_shb_spch /* o : shb target signal Q factor */
+ , Word32 realBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX] /* i : real buffer */
+ , Word32 imagBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX] /* i : imag buffer */
+ ,const CLDFB_SCALE_FACTOR *cldfbScale /* i : scale data of real and imag CLDFB buffers */
+);
+
+void wb_tbe_extras_reset_fx(
+ Word16 mem_genSHBexc_filt_down_wb2[],
+ Word16 mem_genSHBexc_filt_down_wb3[]
+);
+
+void swb_tbe_reset_synth_fx(
+ Word32 genSHBsynth_Hilbert_Mem[],
+ Word16 genSHBsynth_state_lsyn_filt_shb_local_fx[]
+);
+
+void swb_tbe_reset_fx(
+ Word32 mem_csfilt[],
+ Word16 mem_genSHBexc_filt_down_shb[],
+ Word16 state_lpc_syn[],
+ Word16 syn_overlap[],
+ Word16 state_syn_shbexc[],
+ Word16 *tbe_demph,
+ Word16 *tbe_premph,
+ Word16 mem_stp_swb[],
+ Word16 *gain_prec_swb
+);
+
+void InitSWBdecBuffer_fx(
+ Decoder_State_fx *swb_dnc_fx /* i/o: SHB decoder structure */
+);
+
+void ResetSHBbuffer_Dec_fx(
+ Decoder_State_fx *st_fx /* i/o: decoder state structure */
+);
+
+Word16 squant_fx( /* o: index of the winning codeword */
+ const Word16 x, /* i: scalar value to quantize */
+ Word16* xq, /* o: quantized value */
+ const Word16 cb[], /* i: codebook */
+ const Word16 cbsize /* i: codebook size */
+);
+
+void swb_tbe_dec_fx(
+ Decoder_State_fx* st_fx, /* i/o: decoder state structure */
+ const Word16 coder_type, /* i : coding type */
+ Word32* bwe_exc_extended, /* i : bandwidth extended exciatation 2*Q_exc*/
+ Word16 Q_exc,
+ const Word16 voice_factors[], /* i : voicing factors */
+ const Word16 old_syn_12k8_16k[], /* i : low band synthesis*/
+ Word16* White_exc16k, /* o : shaped white excitation for the FB TBE */
+ Word16* Q_white_exc,
+ Word16* synth, /* o : SHB synthesis/final synthesis */
+ Word16* Q_synth,
+ Word16* pitch_buf
+);
+
+
+void tbe_write_bitstream_fx(
+ Encoder_State_fx *st_fx /* i/o: encoder state structure */
+);
+
+void tbe_read_bitstream_fx(
+ Decoder_State_fx *st_fx /* i/o: encoder state structure */
+);
+
+Word16 get_tbe_bits_fx( /* o : TBE bit consumption per frame */
+ Word32 bitrate, /* i : overall bitrate */
+ Word16 bandwidth /* i : bandwidht mode */
+ ,Word16 rf_mode
+);
+
+void GenTransition_fx(
+ const Word16 *input, /* i : gain shape overlap buffer */
+ const Word16 *old_hb_synth, /* i : synthesized HB from previous frame */
+ Word16 length, /* i : targeted length of transition signal */
+ Word16 *output, /* o : synthesized transitions signal */
+ Word32 Hilbert_Mem[], /* i/o: memory */
+ Word16 state_lsyn_filt_shb_local[],/* i/o: memory */
+ Word16 mem_resamp_HB_32k[], /* i/o: memory */
+ Word16 *syn_dm_phase,
+ Word32 output_Fs,
+ Word16 *up_mem,
+ Word16 rf_flag
+ , Word32 bitrate
+);
+
+void GenTransition_WB_fx(
+ const Word16 *input, /* i : gain shape overlap buffer */
+ const Word16 *old_hb_synth, /* i : synthesized HB from previous frame */
+ const Word16 prev_Qx, /* i : scaling of old_hb_synth */
+ Word16 length, /* i : targeted length of transition signal */
+ Word16 *output, /* o : synthesized transitions signal */
+ Word16 state_lsyn_filt_shb1[],
+ Word16 state_lsyn_filt_shb2[],
+ Word32 output_Fs,
+ Word16 *up_mem
+);
+
+void TBEreset_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 bandwidth /* i : bandwidth mode */
+);
+
+void TBEreset_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 bandwidth /* i : bandwidth mode */
+);
+
+void fb_tbe_enc_fx(
+ Encoder_State_fx *st, /* i/o: encoder state structure */
+ const Word16 new_input[], /* i : input speech at 48 kHz sample rate */
+ const Word16 fb_exc[], /* i : FB excitation from the SWB part */
+ Word16 Q_fb_exc
+);
+
+void fb_tbe_dec_fx(
+ Decoder_State_fx *st, /* i/o: encoder state structure */
+ const Word16 fb_exc[], /* i : FB excitation from the SWB part */
+ Word16 Q_fb_exc,
+ Word16 *hb_synth, /* o : high-band synthesis */
+ Word16 hb_synth_exp
+);
+
+void elliptic_bpf_48k_generic_fx(
+ const Word16 input_fx[], /* i : input signal */
+ Word16 *Q_input_fx,
+ Word16 output_fx[], /* o : output signal */
+ Word32 memory_fx[][4], /* i/o: 4 arrays of 4 for memory */
+ Word16 memory_fx_Q[],
+ const Word16 full_band_bpf[][5] /* i : filter coefficients b0,b1,b2,a0,a1,a2 Q13 */
+);
+void synthesise_fb_high_band_fx(
+ const Word16 excitation_in[], /* i : full band excitation */
+ Word16 Q_fb_exc,
+ Word16 output[], /* o : high band speech - 14.0 to 20 kHz */
+ const Word32 fb_exc_energy, /* i : full band excitation energy */
+ const Word16 ratio, /* i : energy ratio */
+ const Word16 L_frame, /* i : ACELP frame length */
+ const Word16 bfi, /* i : fec flag */
+ Word16 *prev_fbbwe_ratio, /* o : previous frame energy for FEC */
+ Word32 bpf_memory[][4], /* i/o: memory for elliptic bpf 48k */
+ Word16 bpf_memory_Q[],
+ Word16 Qout
+);
+
+void lsf_syn_mem_restore_fx(
+ Encoder_State_fx *st_fx, /* o: state structure */
+ LPD_state* LPDmem, /* o: LPD_state vewctor */
+ Word16 btilt_code_fx, /* i: */
+ Word32 gc_threshold_fx, /* i: */
+ Word16 *clip_var_bck_fx, /* i: */
+ Word16 next_force_sf_bck_fx, /* i: */
+ Word16 *lsp_new, /* o: LSP vector to quantize */
+ Word16 *lsf_new, /* o: quantized LSF vector */
+ Word16 *lsp_mid, /* o: mid-frame LSP vector */
+ Word16 clip_var, /* i: pitch clipping state var */
+ Word16 *mem_AR, /* i: quantizer memory for AR model */
+ Word16 *mem_MA, /* i: quantizer memory for MA model */
+ Word16 *lsp_new_bck, /* i: LSP vector to quantize- backup */
+ Word16 *lsf_new_bck, /* i: quantized LSF vector - backup */
+ Word16 *lsp_mid_bck, /* i: mid-frame LSP vector - backup */
+ Word16 mCb1, /* i: counter for stationary frame after a transition frame */
+ Word32 *Bin_E, /* i: FFT Bin energy 128 *2 sets */
+ Word32 *Bin_E_old, /* i: FFT Bin energy 128 sets */
+ Word16 *mem_syn_bck, /* i: synthesis filter memory */
+ Word16 mem_w0_bck, /* i: memory of the weighting filter */
+ Word16 streaklimit, /* i:LSF quantizer */
+ Word16 pstreaklen /* i:LSF quantizer */
+);
+
+void encod_nelp_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ LPD_state *mem, /* i/o: acelp memories */
+ const Word16 *speech_fx, /* i : input speech */
+ const Word16 Aw_fx[], /* i : weighted A(z) unquantized for subframes */
+ const Word16 Aq_fx[], /* i : 12k8 Lp coefficient */
+ Word16 *res_fx, /* o : residual signal */
+ Word16 *synth_fx, /* o : core synthesis */
+ Word16 *tmp_noise_fx, /* o : long-term noise energy */
+ Word16 *exc_fx, /* i/o: current non-enhanced excitation */
+ Word16 *exc2_fx, /* i/o: current enhanced excitation */
+ Word16 *pitch_buf_fx, /* o : floating pitch values for each subframe */
+ Word16* voice_factors_fx, /* o : voicing factors */
+ Word16* bwe_exc_fx, /* o : excitation for SWB TBE */
+ Word16 Q_new,
+ Word16 shift
+);
+
+void nelp_encoder_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state */
+ Word16 *in_fx, /* i : residual signal */
+ Word16 *exc_fx, /* o : NELP quantized excitation signal */
+ Word16 *qIn1
+ ,Word16 reduce_gains
+);
+
+Word16 dequantize_uvg_fx(
+ Word16 iG1, /* i: gain 1 index */
+ Word16 *iG2, /* i: gain 2 index */
+ Word16 *G, /* o: quantized gain */
+ Word16 bandwidth /* i: bandwidth */
+ ,Word16 do_scale
+);
+
+void quantize_uvg_fx(
+ Word16 *G,
+ Word16 *iG1,
+ Word16 *iG2,
+ Word16 *quantG,
+ Word16 bandwidth
+);
+
+
+void generate_nelp_excitation_fx(
+ Word16 *seed,
+ Word16 *Gains,
+ Word16 *output,
+ Word16 gain_fac
+);
+
+
+Word16 find_rem(
+ Word16 n,
+ Word16 m,
+ Word16 *r
+);
+
+Word32 find_remd(
+ Word32 n,
+ Word32 m,
+ Word32 *r
+);
+
+void set_ppp_mode_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ Word16 *coder_type /* i : coding type */
+ ,const Word16 noisy_speech_HO, /* i : SC-VBR noisy speech HO flag */
+ const Word16 clean_speech_HO, /* i : SC-VBR clean speech HO flag */
+ const Word16 NB_speech_HO, /* i : SC-VBR NB speech HO flag */
+ const Word16 localVAD,
+ const Word16 localVAD_he, /* i : HE-SAD flag without hangover */
+ Word16 *vad_flag
+ ,Word16 T_op_fx[] /* i : open loop pitch lag */
+ ,Word16 sp_aud_decision1 /* i : Speech Audio Decision */
+);
+
+void update_average_rate_fx(
+ Encoder_State_fx *st_fx /* i/o: encoder state structure */
+);
+
+
+void encod_ppp_fx(
+ Encoder_State_fx * st_fx, /* i/o: state structure */
+ LPD_state *mem, /* i/o: acelp memories */
+ const Word16 speech_fx[], /* i : input speech Q_new*/
+ const Word16 Aw_fx[], /* i : weighted A(z) unquantized for subframes */
+ const Word16 Aq_fx[], /* i : 12k8 Lp coefficient */
+ Word16 *coder_type, /* i/o : coding type */
+ Word16 sharpFlag_fx, /* i : formant sharpening flag */
+ const Word16 T_op_fx[], /* i : open loop pitch */
+ const Word16 voicing_fx[], /* i : voicing Q14*/
+ Word16 *res_fx, /* i/o: residual signal Q_new*/
+ Word16 *synth_fx, /* i/o: core synthesis Q-1*/
+ Word16 *exc_fx, /* i/o: current non-enhanced excitation Q_new*/
+ Word16 *exc2_fx, /* o: current enhanced excitation Q0*/
+ Word16 *pitch_buf_fx, /* o: floating pitch values for each subframe Q6*/
+ Word16 *voice_factors, /* o : voicing factors */
+ Word16 *bwe_exc, /* o : excitation for SWB TBE */
+ Word16 Q_new,
+ Word16 shift
+);
+
+void ppp_voiced_encoder_fx(
+ Encoder_State_fx *st_fx, /* i/o: state structure */
+ Word16 *in_fx, /* i : residual signal */
+ Word16 *out_fx, /* o : Quantized residual signal */
+ Word16 delay_fx, /* i : open loop pitch */
+ Word16 *lpc1_fx, /* i : prev frame de-emphasized LPC */
+ Word16* lpc2_fx, /* i : current frame de-emphasized LPC */
+ Word16 *exc_fx, /* i: previous frame quantized excitation */
+ Word16 *pitch_fx, /* o: floating pitch values for each subframe */
+ Word16 vadsnr_fx, /* i: current frame SNR Q7*/
+ Word16 Qres
+);
+
+Word16 rint_new_fx(
+ Word32 x /* i/o: Round to the nearest integer with mid point exception */
+);
+
+void decod_nelp_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder static memory */
+ const Word16 coder_type, /* i : coding type */
+ Word16 *tmp_noise_fx, /* o : long term temporary noise energy */
+ Word16 *pitch_buf_fx, /* o : floating pitch values for each subframe*/
+ Word16 *exc_fx, /* o : adapt. excitation exc */
+ Word16 *exc2_fx, /* o : adapt. excitation/total exc */
+ Word16 *voice_factors, /* o : Voice factor */
+ Word16 *bwe_exc,
+ Word16 *Q_exc,
+ Word16 bfi /* i : frame error rate */
+ , Word16 *gain_buf /*Q14*/
+);
+
+void nelp_decoder_fx(
+ Decoder_State_fx *st, /* i/o: decoder static memory */
+ Word16 *exc_nelp, /* o : adapt. excitation/total exc */
+ Word16 *exc, /* o : adapt. excitation exc */
+ Word16 *Q_exc,
+ Word16 bfi, /* i : frame error rate */
+ const Word16 coder_type /* i : coding type */
+ , Word16 *gain_buf /*Q14*/
+);
+
+void core_switching_pre_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 output_frame /* i : frame length */
+);
+
+void fb_tbe_reset_synth_fx(
+ Word32 fbbwe_hpf_mem_fx[][4],
+ Word16 fbbwe_hpf_mem_fx_Q[],
+ Word16 *prev_fbbwe_ratio_fx
+);
+
+void core_switching_post_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 *synth, /* i/o: output synthesis Qsynth */
+ const Word16 output_frame, /* i : frame length */
+ const Word16 core_switching_flag, /* i : ACELP->HQ switching flag */
+ const Word16 coder_type, /* i : ACELP coder type */
+ Word16 *Qsynth
+);
+void acelp_core_switch_dec_bfi_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 synth_out[], /* o : synthesis Q_syn */
+ const Word16 coder_type /* i : coder type */
+);
+void acelp_core_switch_dec_fx(
+ Decoder_State_fx *st_fx, /* decoder state structure */
+ Word16 *synth_subfr_out, /* o synthesized ACELP subframe Q_syn*/
+ Word16 *tmp_synth_bwe, /* o synthesized ACELP subframe BWE Q_syn*/
+ const Word16 output_frame, /* i : input frame legth */
+ const Word16 core_switching_flag, /* i : core switching flag */
+ Word16 *mem_synth, /* o : synthesis to overlap */
+ Word16 *Q_syn
+);
+
+void core_switching_hq_prepare_dec_fx(
+ Decoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 *num_bits, /* i/o: bit budget update */
+ const Word16 output_frame /* i : output frame length */
+);
+void fb_tbe_reset_enc_fx(
+ Word32 elliptic_bpf_2_48k_mem_fx[][4],
+ Word32 *prev_fb_energy_fx,
+ Word16 elliptic_bpf_2_48k_mem_fx_Q[],
+ Word16 *prev_fb_energy_fx_Q
+);
+
+void core_switching_OLA_fx(
+ Word16 *mem_over_hp, /* i : upsampling filter memory Q0 */
+ const Word16 last_L_frame, /* i : last L_frame lengthture */
+ const Word32 output_Fs, /* i : output sampling rate */
+ Word16 *synth, /* i/o: synthesized signal from HQ core Q0 */
+ Word16 *synth_subfr_out, /* i : synthesized signal from ACELP core Q0 */
+ Word16 *synth_subfr_bwe, /* i : synthesized BWE from ACELP core Q0 */
+ const Word16 output_frame, /* i : output frame length */
+ const Word16 bwidth, /* i : output bandwidth */
+ Word16* Qsynth,
+ Word16* Qsubfr
+);
+
+void acelp_core_switch_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ LPD_state *mem,
+ const Word16 inp12k8[], /* i : input signal @12.8 kHz Q0 */
+ const Word16 inp16k[], /* i : input signal @16 kHz Q0 */
+ const Word16 T_op_orig[2], /* i : open-loop pitch values for quantiz. Q0*/
+ const Word16 voicing[3], /* i : Open-loop pitch gains Q15 */
+ const Word16 A[NB_SUBFR16k*(M+1)], /* i : A(z) unquantized for the 4 subframes Q12*/
+ Word16 shift,
+ Word16 Q_new
+);
+
+void core_switching_hq_prepare_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 *num_bits, /* i/o: bit budget update */
+ const Word16 input_frame, /* i : frame length */
+ Word32 *wtda_audio, /* shall be q_audio + 15, audio allready scalled in wtda function */
+ const Word16 *audio
+);
+
+void core_switching_pre_enc_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ LPD_state *mem, /* i/o: encoder state structure */
+ const Word16 *old_inp_12k8, /* i : old input signal @12.8kHz */
+ const Word16 *old_inp_16k /* i : old input signal @16kHz */
+);
+
+void core_switching_post_enc_fx( /*done */
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ const Word16 inp12k8[], /* i : input signal @12.8 kHz */
+ const Word16 inp16k[], /* i : input signal @16 kHz */
+ const Word16 T_op[2], /* i : open-loop pitch values for quantiz. */
+ const Word16 voicing[3], /* i : Open-loop pitch gains */
+ const Word16 A[], /* i : unquant. LP filter coefs. (Q12) */
+ Word16 Qshift,
+ Word16 Q_new,
+ const Word16 Qsp, /* i/o : Q from acelp synthsis */
+ Word16 *Qmus /* i/o : Q from mdct synthsis / Q of output synthesis */
+);
+
+Word16 modify_Fs_intcub3m_sup_fx( /* o : length of output */
+ const Word16 sigIn[], /* i : signal to decimate with memory of 2 samples (indexes -2 & -1) */
+ const Word16 lg, /* i : length of input (suppose that lg is such that lg_out is integer, ex multiple of 5 in case of 16kHz to 12.8 kHz) */
+ const Word32 fin, /* i : frequency of input */
+ Word16 sigOut[], /* o : decimated signal */
+ const Word32 fout, /* i : frequency of output */
+ Word16 *delayout /* o : delay of output */
+);
+void add_vec_fx(
+ const Word16 x1[], /* i : Input vector 1 */
+ const Word16 Qx1, /* i : SCaling of iput 1 */
+ const Word16 x2[], /* i : Input vector 2 */
+ const Word16 Qx2, /* i : SCaling of iput 1 */
+ Word16 y[], /* o : Output vector that contains vector 1 + vector 2 */
+ const Word16 Qy, /* i : SCaling of output 1 */
+ const Word16 N /* i : Vector lenght */
+);
+
+/******************************* wrappers related functions **************/
+void convert_fl_2_fx(const float *var_fl, Word16 *var_fx, Word16 count, Word16 Q_format);
+void convert_fl_2_fx_32(const float *var_fl, Word32 *var_fx, Word16 count, Word16 Q_format);
+void convert_fl_2_fx_32_MIN(const float *var_fl, Word32 *var_fx, Word16 count, Word16 Q_format, Word32 MIN_VAL);
+void convert_sh_2_fx(const short *var_fl, Word16 *var_fx, Word16 count, Word16 Q_format);
+void convert_dl_2_fx_32(double *var_fl, Word32 *var_fx, Word16 count, Word16 Q_format);
+void convert_fx_2_fl(float *var_fl, const Word16 *var_fx, Word16 count, Word16 Q_format);
+void convert_fx_2_sh(short *var_fl, const Word16 *var_fx, Word16 count, Word16 Q_format);
+void convert_fx_2_dl_32(double *var_fl, const Word32 *var_fx, Word16 count, Word16 Q_format);
+void convert_fx_2_fl_32(float *var_fl, const Word32 *var_fx, Word16 count, Word16 Q_format);
+void convert_fx_2_fl_32_floor(float *var_fl, const Word32 *var_fx, Word16 count, Word16 Q_format);
+/* void pre_proc_acelp_core_dec(Decoder_State *st,Decoder_State_fx *st_fx); */
+/* void post_proc_acelp_core_dec(Decoder_State *st,Decoder_State_fx *st_fx); */
+
+void convert_fl_2_fx_q(const float *x, Word16 *x_fx, Word16 len, Word16 *q);
+/******************************* END OF wrappers related functions **************/
+
+/******************************* END of temporary Hybride function related functions **************/
+
+void Copy_Scale_sig32_16(
+ const Word32 *src, /* i : signal to scale Qx */
+ Word16 *dst, /* o : scaled signal Qx */
+ Word16 len, /* i : size of x[] Q0 */
+ Word16 exp0 /* i : exponent: x = round(x << exp) Qx ?exp */
+);
+Word32 Add_flt32_flt32(/* o: Result */
+ Word32 a, /* i: 1st Value */
+ Word16 exp_a, /* i: Exponent of 1st Value (Q of Value) */
+ Word32 b, /* i: 2nd Value */
+ Word16 exp_b, /* i: Exponent of 2nd Value (Q of Value) */
+ Word16 *exp_out /* o: Exponent of Result */
+);
+Word32 Mul_flt32_Q15( /* o: Result (Normalized) */
+ Word32 value, /* i: Pseudo_float Value */
+ Word16 *exp_v, /*i/o: Exponent of Value (Q of Value) */
+ Word16 frac /* i: Q15 value */
+);
+Word32 Div_flt32_flt32(/* o: Result (Normalized) */
+ Word32 a, /* i: 1st Value */
+ Word16 exp_a, /* i: Exponent of 1st Value (Q of Value) */
+ Word32 b, /* i: 2nd Value */
+ Word16 exp_b, /* i: Exponent of 2nd Value (Q of Value) */
+ Word16 *exp_out /* o: Exponent of Result */
+);
+Word32 Calc_Energy_Autoscaled(/* o: Result (Energy) */
+ const Word16 *signal, /* i: Signal */
+ Word16 signal_exp, /* i: Exponent of Signal (Q of Signal) */
+ Word16 len, /* i: Frame Length */
+ Word16 *energy_exp /* o: Exponent of Energy (Q of Energy) */
+);
+Word16 Find_Max_Norm16(const Word16 *src, Word16 len);
+Word16 Find_Max_Norm32(const Word32 *src, Word16 len);
+Word32 Sqrt_Ratio32(Word32 L_val1, Word16 exp1, Word32 L_val2, Word16 exp2, Word16 *exp);
+Word16 Invert16( /* result in Q'15 + 'exp' */
+ Word16 val,
+ Word16 *exp);
+
+void swb_bwe_enc_hr_fx(
+ Encoder_State_fx *st_fx, /* i/o: encoder state structure */
+ Word16 *new_input_fx, /* i : input signal */
+ Word16 new_input_fx_exp, /* i : Exponent of input signal */
+ const Word16 input_frame, /* i : frame length */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 unbits /* i : number of core unused bits */
+);
+
+void wtda_fx(
+ Word16 *new_audio, /* i : input audio Q0 */
+ Word16 *Q, /* i/o : Q of Output Audio (use 15 for 'qout' for backward compatibility - NON SWB ENC HR FX MODULES) */
+ Word32 *wtda_audio, /* o : windowed audio Qout */
+ Word16 *old_wtda, /* i/o: windowed audio from previous frame Qout */
+ Word16 *Qold_wtda,
+ Word16 left_mode,
+ Word16 right_mode, /* window overlap of current frame (0: full, 2: none, or 3: half) */
+ const Word16 L
+);
+
+void direct_transform_fx(
+ const Word32 in32_fx[],
+ Word32 out32_fx[],
+ const Word16 is_transient,
+ const Word16 L,
+ Word16 *Q
+);
+
+
+void r_fft_4_fx(Word16 * farray_ptr_fx, Word16 size, Word16 stage, Word16 isign);
+
+DTFS_STRUCTURE_FX* DTFS_new_fx(
+ void
+);
+
+void DTFS_copy_fx(
+ DTFS_STRUCTURE_FX *Xout_fx, /* o: DTFS structure */
+ DTFS_STRUCTURE_FX Xinp_fx /* i: DTFS structure */
+);
+
+DTFS_STRUCTURE_FX DTFS_sub_fx(
+ DTFS_STRUCTURE_FX X1, /* i: DTFS input 1 */
+ DTFS_STRUCTURE_FX X2 /* i: DTFS input 2 */
+); /* o: X1 - X2 */
+
+
+void DTFS_to_fs_fx(
+ const Word16 *x, /* i : time domain signal */
+ Word16 N, /* i : Length of input vector */
+ DTFS_STRUCTURE_FX *X_fx, /* o : DTFS structure with a, b, lag */
+ Word16 Fs, /* i : sampling rate */
+ Word16 FR_flag, /* i: FR flag */
+ Word16 *S_fx,
+ Word16 *C_fx
+);
+
+void DTFS_fast_fs_inv_fx( DTFS_STRUCTURE_FX *This,Word16 *out_fx, Word16 N_fx, Word16 LOG2N);
+
+void DTFS_car2pol_fx(
+ DTFS_STRUCTURE_FX *X_fx /* i/o : DTFS structure a, b, lag */
+);
+void copy_phase_fx( DTFS_STRUCTURE_FX *X1_fx, DTFS_STRUCTURE_FX X2_fx, DTFS_STRUCTURE_FX *retX_fx);
+Word32 getSpEngyFromResAmp_fx( DTFS_STRUCTURE_FX *X_fx,Word16 lband, Word16 hband,
+ const Word16 *curr_lpc, Word16 *sin_tab,
+ Word16 *cos_tab);
+
+Word32 DTFS_setEngyHarm_fx(
+ Word16 f1_fx, /* i : lower band freq of input to control energy */
+ Word16 f2_fx, /* i : upper band freq of input to control energy */
+ Word16 g1_fx, /* i : lower band freq of output to control energy */
+ Word16 g2_fx, /* i : upper band freq of output to control energy */
+ Word32 en2_fx, /* i : Target Energy to set the DTFS to */
+ Word16 Qen2_fx, /* i : Input Q format for en2 */
+ Word16 *Qa_fx, /* i : Output Q format for x->a */
+ DTFS_STRUCTURE_FX *X_fx /* i/o: DTFS to adjust the energy of */
+);
+
+void rshiftHarmBand_fx( DTFS_STRUCTURE_FX *X_fx,Word16 lband_fx, Word16 hband_fx, Word16 shift_fx);
+void quant_target_fx( DTFS_STRUCTURE_FX *X_fx,const Word16 *curr_lpc, Word16 *w, Word16 *target,
+ Word16 *sin_tab, Word16 *cos_tab);
+
+void GetSinCosTab_fx(Word16 L, Word16 *sinTab, Word16 *cosTab);
+
+void DTFS_to_erb_fx(
+ const DTFS_STRUCTURE_FX X_fx, /* i : DTFS input */
+ Word16 *out_fx /* o : ERB output */
+);
+
+void DTFS_zeroPadd_fx(Word16 N_fx,DTFS_STRUCTURE_FX *X_fx);
+
+Word32 DTFS_getEngy_fx( DTFS_STRUCTURE_FX *X_fx);
+
+Word32 DTFS_getEngy_P2A_fx( DTFS_STRUCTURE_FX *X_fx);
+
+
+Word32 DTFS_getEngy_band_fx(
+ DTFS_STRUCTURE_FX X_fx,
+ Word16 lband,
+ Word16 hband
+);
+
+Word32 DTFS_getEngy_band_wb_fx(
+ DTFS_STRUCTURE_FX X_fx,
+ Word16 lband,
+ Word16 hband
+);
+
+Word32 DTFS_freq_corr_fx(
+ DTFS_STRUCTURE_FX X1_DTFS_fx, /* i : X1 DTFS */
+ DTFS_STRUCTURE_FX X2_DTFS_fx, /* i : X2 DTFS */
+ Word16 lband, /* i : low cutoff */
+ Word16 hband, /* i : high cutoff */
+ Word16 *Qout /* o : Correlation Q format */
+); /* o : Correlation */
+
+Word32 DTFS_setEngy_fx( DTFS_STRUCTURE_FX *X_DTFS_FX,Word32 en2_fx);
+
+void DTFS_adjustLag_fx(
+ DTFS_STRUCTURE_FX *X_DTFS_FX, /* i/o : DTFS to adjust lag for */
+ Word16 N_fx /* i : Target lag */
+);
+
+void DTFS_poleFilter_fx( DTFS_STRUCTURE_FX *X_fx,Word16 *LPC, Word16 N, Word16 *S_fx, Word16 *C_fx);
+void DTFS_poleFilter_fx_9( DTFS_STRUCTURE_FX *X_fx, Word16 *pf_temp1, Word16 *pf_temp2, Word16 *pf_temp, Word16 *pf_n2_temp1);
+void poleFilter_setup_fx(const Word16 *LPC, Word16 N, DTFS_STRUCTURE_FX X_fx, Word16 *S_fx, Word16 *C_fx, Word16 *pf_temp1, Word16 *pf_temp2, Word16 *pf_temp, Word16 *pf_n2_temp1);
+
+void DTFS_zeroFilter_fx(
+ DTFS_STRUCTURE_FX *X_fx,
+ Word16 *LPC,
+ Word16 N,
+ Word16 *S_fx,
+ Word16 *C_fx
+);
+
+Word16 DTFS_alignment_full_fx(
+ DTFS_STRUCTURE_FX X1_DTFS_fx, /* i : reference DTFS */
+ DTFS_STRUCTURE_FX X2_DTFS_fx, /* i : DTFS to shift */
+ Word16 ph_offset_fx, /* i : resolution */
+ Word16 *S_fx,
+ Word16 *C_fx
+ , Word16 FR_flag
+);
+
+Word16 DTFS_alignment_extract_td_fx(Word16 *x1, Word16 *x2, Word16 lag);
+
+Word16 DTFS_alignment_weight_fx(
+ DTFS_STRUCTURE_FX *X_fx,
+ DTFS_STRUCTURE_FX X2,
+ Word16 Eshift,
+ const Word16 *LPC1,
+ const Word16 *LPC2,
+ Word16 *S_fx,
+ Word16 *C_fx,
+ Word16 *pf_temp1,
+ Word16 *pf_temp2,
+ Word16 *pf_temp,
+ Word16 *pf_n2
+);
+
+
+Word16 DTFS_alignment_fine_new_fx( DTFS_STRUCTURE_FX X1_fx, DTFS_STRUCTURE_FX X2_fx, Word16 *S_fx, Word16 *C_fx);
+
+
+void DTFS_phaseShift_fx( DTFS_STRUCTURE_FX *X_fx,Word16 ph, Word16 Lag, Word16 *S_fx, Word16 *C_fx);
+void Q2phaseShift_fx( DTFS_STRUCTURE_FX *X_fx,Word16 ph, Word16 Lag, Word16 *S_fx, Word16 *C_fx);
+
+
+void DTFS_erb_inv_fx(
+ Word16 *in_fx, /* i : ERB inpt */
+ Word16 *slot_fx, /* i : ERB slots filled based on lag */
+ Word16 *mfreq_fx, /* i : erb frequence edges */
+ DTFS_STRUCTURE_FX *X_fx, /* o : DTFS after erb-inv */
+ Word16 num_erb_fx /* i : Number of ERB bands */
+);
+
+void erb_add_fx(
+ Word16 *curr_erb_fx, /* i/o: current ERB */
+ Word16 l_fx, /* i : current lag */
+ const Word16 *prev_erb_fx, /* i : previous ERB */
+ Word16 pl_fx, /* i : previous lag */
+ const Word16 *index_fx, /* i : ERB index */
+ Word16 num_erb_fx /* i : number of ERBs */
+);
+
+void LPCPowSpect_fx(Word16 *freq, Word16 Nf, Word16 *LPC, Word16 Np,
+ Word16 *out);
+
+void erb_slot_fx(
+ Word16 lag_fx, /* i : input lag */
+ Word16 *out_fx, /* o : ERB slots */
+ Word16 *mfreq_fx, /* i : ERB frequencies */
+ Word16 num_erb_fx /* i : number of ERBs */
+);
+
+Word16 DTFS_quant_cw_fx(
+ DTFS_STRUCTURE_FX *X_fx, /* i/o: DTFS unquant inp, quant out */
+ Word16 pl, /* i : Previous lag */
+ const Word16 *curr_lpc_fx, /* i : LPC */
+ Word16 *POWER_IDX, /* o : Power index */
+ Word16 *AMP_IDX, /* o : Amplitude index */
+ Word16 *lastLgainE_fx, /* i/o: last frame lowband gain */
+ Word16 *lastHgainE_fx, /* i/o: last frame highband gain */
+ Word16 *lasterbE_fx, /* i/o: last frame ERB vector */
+ Word16 *sin_tab,
+ Word16 *cos_tab
+);
+
+
+void DTFS_dequant_cw_fx(
+ Word16 pl_fx, /* i : Previous lag */
+ Word16 POWER_IDX_fx, /* i : POWER index */
+ const Word16 *AMP_IDX_fx, /* i : Amp Shape index */
+ Word16 *lastLgainD_fx, /* i/o: low band last gain */
+ Word16 *lastHgainD_fx, /* i/o: high band last gain */
+ Word16 *lasterbD_fx, /* i/o: last frame ERB vector */
+ DTFS_STRUCTURE_FX *X_fx, /* o : DTFS structure dequantized */
+ Word16 num_erb_fx
+);
+
+void DTFS_transform_fx(
+ DTFS_STRUCTURE_FX X_fx, /* i : Starting DTFS to use in WI */
+ DTFS_STRUCTURE_FX X2_fx, /* i : Ending DTFS to use in WI */
+ const Word32 *phase_fx, /* i : Phase contour */
+ Word16 *out_fx, /* o : Output time domain waveform */
+ Word16 N, /* i : Number of samples to generate */
+ Word16 FR_flag /* i : Flag to indicate called in FR context */
+);
+
+void DTFS_peaktoaverage_fx(
+ DTFS_STRUCTURE_FX X_fx, /* i : DTFS */
+ Word32 *pos_fx, /* o : positive peak to ave */
+ Word16 *Qpos, /* o : positive peak to ave Q format */
+ Word32 *neg_fx, /* o : negative peak to ave */
+ Word16 *Qneg /* o : negative peak to ave Q format */
+);
+
+
+
+Word16 ppp_extract_pitch_period_fx(
+ const Word16 *in, /* i : input residual */
+ Word16 *out, /* o : output residual */
+ Word16 l, /* i : lag */
+ Word16 *out_of_bound, /* o : out of bound flag */
+ Word16 Qres
+
+);
+
+void Interpol_delay_fx(
+ Word16 *out_fx,
+ Word16 last_fx,
+ Word16 current_fx,
+ Word16 SubNum,
+ const Word16* frac_fx
+);
+
+
+Word16 ppp_quarter_encoder_fx(
+ DTFS_STRUCTURE_FX *CURRCW_Q_FX, /* o : Quantized (amp/phase) DTFS */
+ DTFS_STRUCTURE_FX *TARGETCW_FX, /* o : DTFS with quant phase but unquant Amp */
+ Word16 prevCW_lag, /* i : previous lag */
+ DTFS_STRUCTURE_FX CURRCW_NQ_FX, /* i : Unquantized DTFS */
+ const Word16 *curr_lpc_fx, /* i : LPCS */
+ Word16 *lastLgainE_fx, /* i/o: last low band gain */
+ Word16 *lastHgainE_fx, /* i/o: last high band gain */
+ Word16 *lasterbE_fx, /* i/o: last ERB vector */
+ DTFS_STRUCTURE_FX PREV_CW_E_FX, /* i : past DTFS */
+ Word16 *S_fx, /* i : sin table, Q15 */
+ Word16 *C_fx, /* i : cos table, Q15 */
+ Encoder_State_fx *st_fx
+);
+
+
+void WIsyn_fx(
+ DTFS_STRUCTURE_FX PREVCW_FX,
+ DTFS_STRUCTURE_FX *CURR_CW_DTFS_FX,
+ const Word16 *curr_lpc_fx,
+ Word16 *ph_offset_fx,
+ Word16 *out_fx,
+ Word16 N,
+ Word16 FR_flag, /* i : called for post-smoothing in FR */
+ Word16 *S_fx,
+ Word16* C_fx,
+ Word16 *pf_temp1,
+ Word16 *pf_temp2,
+ Word16 *pf_temp,
+ Word16 *pf_n2
+);
+
+void deemph_lpc_fx(
+ Word16 *p_Aq_curr_fx, /* i : LP coefficients current frame */
+ Word16 *p_Aq_old_fx, /* i : LP coefficients previous frame */
+ Word16 *LPC_de_curr_fx, /* o : De-emphasized LP coefficients current frame */
+ Word16 *LPC_de_old_fx, /* o : De-emphasized LP coefficients previous frame */
+ Word16 deemph_old
+
+);
+
+Word16 erb_diff_search_fx(Word16 *prev_erb, const Word16 *curr_erb, Word16 *dif_erb,
+ Word16 *pow_spec, const Word16 *cb_fx,
+ Word16 cb_size, Word16 cb_dim, Word16 offset
+ );
+
+
+void Acelp_dec_total_exc(
+ Word16 *exc_fx, /* i/o: adapt. excitation exc */
+ Word16 *exc2_fx, /* i/o: adapt. excitation/total exc */
+ const Word16 gain_code16, /* i : Gain code Q0 */
+ const Word16 gain_pit_fx, /* i ; Pitch gain in Q14 */
+ const Word16 i_subfr, /* i ; subfr */
+ const Word16 *code_fx /* i : code in Q12 */
+);
+void tbe_celp_exc(
+ const Word16 L_frame_fx, /* i : Frame lenght */
+ const Word16 i_subfr_fx, /* i : sub frame */
+ const Word16 T0_fx, /* i : Integer pitch */
+ const Word16 T0_frac_fx, /* i : Fractional part of the pitch */
+ Word16 *error_fx, /* i/o: Error */
+ Word16 *bwe_exc_fx /* i/o: bandwitdh extension signal */
+);
+Word16 tbe_celp_exc_offset(
+ const Word16 T0_fx, /* i : Integer pitch */
+ const Word16 T0_frac_fx, /* i : Fractional part of the pitch */
+ const Word16 L_frame /* i : frame lenght */
+);
+void lsf_syn_mem_backup_fx(
+ Encoder_State_fx *st_fx, /* i: state structure */
+ LPD_state* LPDmem, /* i: LPD state memory structure */
+ Word16 *btilt_code, /* i: tilt code */
+ Word32 *bgc_threshold, /* i: */
+ Word16 *clip_var_bck, /* o: */
+ Word16 *next_force_sf_bck, /* o: */
+ Word16 *lsp_new, /* i: LSP vector to quantize */
+ Word16 *lsf_new, /* i: quantized LSF vector */
+ Word16 *lsp_mid, /* i: mid-frame LSP vector */
+ Word16 *clip_var, /* o: pitch clipping state var */
+ Word16 *mem_AR, /* o: quantizer memory for AR model */
+ Word16 *mem_MA, /* o: quantizer memory for AR model */
+ Word16 *lsp_new_bck, /* o: LSP vector to quantize- backup */
+ Word16 *lsf_new_bck, /* o: quantized LSF vector - backup */
+ Word16 *lsp_mid_bck, /* o: mid-frame LSP vector - backup */
+ Word16 *mCb1, /* o: counter for stationary frame after a transition frame */
+ Word32 *Bin_E, /* o: FFT Bin energy 128 *2 sets */
+ Word32 *Bin_E_old, /* o: FFT Bin energy 128 sets */
+ Word16 *mem_syn_bck, /* o: synthesis filter memory */
+ Word16 *mem_w0_bck, /* o: memory of the weighting filter */
+ Word16 *streaklimit,
+ Word16 *pstreaklen
+);
+
+void decod_ppp_fx(
+ Decoder_State_fx *st_fx, /* i/o: state structure */
+ const Word16 Aq_fx[], /* i : 12k8 Lp coefficient */
+ Word16 *pitch_buf_fx, /* i/o: fixed pitch values for each subframe */
+ Word16 *exc_fx, /* i/o: current non-enhanced excitation */
+ Word16 *exc2_fx, /* i/o: current enhanced excitation */
+ Word16 bfi /* i : bad frame indicator */
+ ,Word16 *gain_buf /*Q14*/
+ ,Word16 *voice_factors, /* o : voicing factors */
+ Word16 *bwe_exc_fx /* o : excitation for SWB TBE */
+);
+
+void ppp_quarter_decoder_fx(
+ DTFS_STRUCTURE_FX *CURRCW_Q_DTFS_FX, /* i/o: Current CW DTFS */
+ Word16 prevCW_lag_fx, /* i : Previous lag */
+ Word16 *lastLgainD_fx, /* i/o: Last gain lowband Q11 */
+ Word16 *lastHgainD_fx, /* i/o: Last gain highwband Q11 */
+ Word16 *lasterbD_fx, /* i/o: Last ERB vector Q13 */
+ Word16 bfi, /* i : FER flag */
+ Word16 *S_fx, /* i : sine table, Q15 */
+ Word16 *C_fx, /* i : cosine table, Q15 */
+ DTFS_STRUCTURE_FX PREV_CW_D_FX /* i : Previous DTFS */
+ ,Decoder_State_fx *st
+);
+
+
+void ppp_voiced_decoder_fx(
+ Decoder_State_fx *st_fx, /* i/o: state structure */
+ Word16 *out_fx, /* o : residual signal */
+ const Word16 *lpc2_fx, /* i : current frame LPC */
+ Word16 *exc_fx, /* i : previous frame excitation */
+ Word16 *pitch, /* o : floating pitch values for each subframe */
+ Word16 bfi /* i : Frame error rate */
+);
+
+
+void bandwidth_switching_detect_fx(
+ Decoder_State_fx *st_fx /* i/o: encoder state structure */
+);
+
+void bw_switching_pre_proc_fx(
+ const Word16 *old_syn_12k8_16k_fx, /* i : ACELP core synthesis at 12.8kHz or 16kHz */
+ Decoder_State_fx *st_fx /* i/o: decoder state structure */
+);
+
+void updt_bw_switching_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ const Word16 *synth, /* i : float synthesis signal */
+ const Word16 Qpost
+);
+void updt_dec_common_fx(
+ Decoder_State_fx *st_fx, /* i/o: decoder state structure */
+ Word16 hq_core_type_fx, /* i : HQ core type */
+ const Word16 *synth /* i : decoded synthesis */
+);
+
+void sort_32_fx(
+ Word32 *r, /* i/o: Vector to be sorted in place */
+ const Word16 lo, /* i : Low limit of sorting range */
+ const Word16 up /* I : High limit of sorting range */
+);
+Word16 FEC_SinOnset_fx (
+ Word16 *exc, /* i/o : exc vector to modify */
+ Word16 puls_pos, /* i : last pulse position desired */
+ const Word16 T0, /* i : Pitch information of the 1 subfr */
+ Word32 enr_q, /* i : energy provide by the encoder */
+ Word16 *Aq, /* i : A(z) filter Q12 */
+ const Word16 L_frame /* i : frame length */
+ ,const Word16 Qold
+);
+Word16 FEC_enhACB_fx(
+ const Word16 L_frame, /* i : frame length */
+ const Word16 last_L_frame, /* i : frame length of previous frame */
+ Word16 *exc_io, /* i/o : adaptive codebook memory */
+ const Word16 new_pit, /* i : decoded first frame pitch */
+ const Word16 puls_pos, /* i : decoder position of the last glottal pulses decoded in the previous frame */
+ const Word16 bfi_pitch /* i : Q6 pitch used for concealment */
+);
+
+
+void fft3_fx(const Word16 [], Word16 [], const Word16);
+void ifft3_fx(const Word16 [], Word16 [], const Word16);
+void hq_ecu_fx(
+ const Word16 *prevsynth, /* i : buffer of previously synthesized signal */
+ Word32 *ecu_rec, /* o : reconstructed frame in tda domain */
+ Word16 *time_offs,
+ Word16 *X_sav,
+ Word16 *Q_spec, /* i/o : Q value of stored spectrum */
+ Word16 *num_p,
+ Word16 *plocs,
+ Word32 *plocsi, /* o : Interpolated positions of the identified peaks (Q16) */
+ const Word16 env_stab,
+ Word16 *last_fec,
+ const Word16 ph_ecu_HqVoicing,
+ Word16 *ph_ecu_active, /* i : Phase ECU active flag */
+ Word16 *gapsynth,
+ const Word16 prev_bfi, /* i : indicating burst frame error */
+ const Word16 old_is_transient[2], /* i : flags indicating previous transient frames */
+ Word16 *mag_chg_1st, /* i/o: per band magnitude modifier for transients*/
+ Word16 *Xavg, /* i/o: Frequency group average gain to fade to */
+ Word16 *beta_mute, /* o : Factor for long-term mute */
+ const Word16 output_frame, /* i : frame length */
+ Decoder_State_fx *st_fx /* i/o: decoder state structure */
+);
+
+void hq_timedomain_conc_fx(
+ Word32 *ecu_rec, /* o : reconstructed frame in tda domain */
+ Word16 *gapsynth, /* o : Gap synthesis */
+ const Word16 output_frame, /* i : frame length */
+ const Word16 *prevsynth, /* i : buffer of previously synthesized signal */
+ Decoder_State_fx *st_fx /* i/o: decoder state structure */
+);
+
+Word16 ratio(const Word32, const Word32, Word16 *);
+
+
+void nearProjQ15_fx(
+ Word16 x,
+ Word16 *result
+);
+
+void Ratio_rQ3_fx(
+ Word16 opp,
+ Word16 near,
+ Word16 *result
+);
+
+void densityAngle2RmsProjDec_fx(
+ Word16 D, /* i: density */
+ Word16 indexphi, /* i: decoded index from AR dec */
+ Word16 *oppQ15, /* o: proj*/
+ Word16 *nearQ15, /* o: */
+ Word16 *oppRatioQ3 /* o: */
+) ;
+
+void densityAngle2RmsProjEnc_fx (
+ Word16 D,
+ Word16 phiQ14uq,
+ Word16 *indexphi, /* o: index to send to AR */
+ Word16 *oppQ15, /* o: proj*/
+ Word16 *nearQ15,
+ Word16 *oppRatioQ3
+) ;
+void dsDiracPerQuanta_fx(
+ const Word16 td,
+ const Word16 t_quanta,
+ const Word16 dsm,
+ const unsigned char* const *frQuanta,
+ Word16 *DsIdx
+);
+
+void QuantaPerDsDirac_fx(
+ Word16 td,
+ Word16 dsDiracIndex,
+ const unsigned char* const* dimFrQuanta,
+ Word16 *Quanta
+);
+
+void obtainEnergyQuantizerDensity_fx(
+ const Word16 L,
+ const Word16 R,
+ Word16 *Density
+);
+
+void dsDirac2Dirac_fx(
+ const Word16 dsDiracIndex,
+ Word16 *diracs
+);
+
+
+void NearOppSplitAdjustment_fx(
+ const Word16 qband,
+ const Word16 qzero,
+ const Word16 Qac,
+ const UWord32 INTac,
+ const Word16 qglobal,
+ const Word16 FlagCons,
+ const Word16 Np,
+ const Word16 Nhead,
+ const Word16 Ntail,
+ const Word16 Nnear,
+ const Word16 Nopp,
+ Word16 oppRQ3,
+ Word16 *qnear,
+ Word16 *qopp,
+ Word16 *qglobalupd
+) ;
+
+
+
+
+/* IGFEnc.c */
+void IGFEncApplyMono(const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
+ const Word16 igfGridIdx, /**< in: Q0 | IGF grid index */
+ Encoder_State_fx *st, /**< in: | Encoder state */
+ Word32 *pMDCTSpectrum, /**< in: Q31 | MDCT spectrum */
+ Word16 MDCTSpectrum_e, /**< in: | exponent of MDCT spectrum */
+ Word32 *pPowerSpectrum, /**< in: Q31 | MDCT^2 + MDST^2 spectrum, or estimate */
+ Word16 PowerSpectrum_e, /**< in: | exponent of pPowerSpectrum */
+ Word16 isTCX20, /**< in: Q0 | flag indicating if the input is TCX20 or TCX10/2xTCX5 */
+ Word16 isTNSActive, /**< in: Q0 | flag indicating if the TNS is active */
+ Word16 last_core_acelp /**< in: Q0 | indictaor if last frame was acelp coded */
+ );
+
+void IGFEncConcatenateBitstream(const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
+ Word16 bsBits, /**< in: Q0 | number of IGF bits written to list of indices */
+ Word16 *next_ind, /**< in/out: | pointer to actual bit indice */
+ Word16 *nb_bits, /**< in/out: | total number of bits already written */
+ Indice_fx *ind_list_fx /**< in: | pointer to list of indices */
+ );
+
+void IGFEncResetTCX10BitCounter(const IGF_ENC_INSTANCE_HANDLE hInstance /**< in: | instance handle of IGF Encoder */
+ );
+
+void IGFEncSetMode(const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
+ const Word32 bitRate, /**< in: Q0 | encoder bitrate */
+ const Word16 mode /**< in: Q0 | encoder bandwidth mode */
+ , const Word16 rf_mode /**< in: | flag to signal the RF mode */
+
+ );
+
+Word16 IGFEncWriteBitstream( /**< out: | number of bits written per frame */
+ const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
+ Encoder_State_fx *st, /**< in: | encoder state */
+ Word16 *pBitOffset, /**< in: | ptr to bitOffset counter */
+ const Word16 igfGridIdx, /**< in: Q0 | igf grid index see declaration of IGF_GRID_IDX for details */
+ const Word16 isIndepFlag /**< in: Q0 | if 1 frame is independent, 0 = frame is coded with data from previous frame */
+);
+
+Word16 IGFEncWriteConcatenatedBitstream( /**< out: Q0 | total number of bits written */
+ const IGF_ENC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Encoder */
+ void *st /**< in: | encoder state */
+);
+
+/* IGFDec.c */
+void IGFDecApplyMono(const IGF_DEC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Decoder */
+ Word32 *spectrum, /**< in/out: | MDCT spectrum */
+ Word16 *spectrum_e, /**< in/out: | exponent of spectrum */
+ const Word16 igfGridIdx, /**< in: | in case of CELP->TCX switching, use 1.25 framelength */
+ Word16 bfi /**< in: | frame loss == 1, frame good == 0 */
+ );
+
+void IGFDecCopyLPCFlatSpectrum(const IGF_DEC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Decoder */
+ const Word32 *pSpectrumFlat, /**< in: Q31 | LPC flattend spectrum from TCX dec */
+ const Word16 pSpectrumFlat_exp, /**< in: | exponent of pSpectrumFlat */
+ const Word16 igfGridIdx /**< in: Q0 | IGF grid index */
+ );
+
+void IGFDecReadData(const IGF_DEC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Deccoder */
+ Decoder_State_fx *st, /**< in: | decoder state */
+ const Word16 igfGridIdx, /**< in: Q0 | in case of CELP->TCX switching, use 1.25 framelength */
+ const Word16 isIndepFrame /**< in: Q0 | if 1: arith dec force reset, if 0: no reset */
+ );
+
+void IGFDecReadLevel( const IGF_DEC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Deccoder */
+ Decoder_State_fx *st, /**< in: | decoder state */
+ const Word16 igfGridIdx, /**< in: Q0 | in case of CELP->TCX switching, use 1.25 framelength */
+ const Word16 isIndepFrame /**< in: Q0 | if 1: arith dec force reset, if 0: no reset */
+ );
+
+void IGFDecRestoreTCX10SubFrameData(const IGF_DEC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Decoder */
+ const Word16 subFrameIdx /**< in: Q0 | index of subframe */
+ );
+
+void IGFDecSetMode(const IGF_DEC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Decoder */
+ const Word32 bitRate, /**< in: Q0 | bitrate */
+ const Word16 mode, /**< in: Q0 | bandwidth mode */
+ const Word16 defaultStartLine, /**< in: Q0 | default start subband index */
+ const Word16 defaultStopLine /**< in: Q0 | default stop subband index */
+ , const Word16 rf_mode /**< in: | flag to signal the RF mode */
+ );
+
+void IGFDecStoreTCX10SubFrameData(const IGF_DEC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Decoder */
+ const Word16 subFrameIdx /**< in: Q0 | index of subframe */
+ );
+
+void IGFDecUpdateInfo(const IGF_DEC_INSTANCE_HANDLE hInstance, /**< in: | instance handle of IGF Decoder */
+ const Word16 igfGridIdx /**< in: | IGF grid index */
+ );
+
+/* iisBaseLib.c */
+void IGFCommonFuncsCalcSfbEnergyPowerSpec(const Word16 startSfb, /**< in: Q0 | start sfb index */
+ const Word16 stopSfb, /**< in: Q0 | stop sfb index */
+ const Word16 *swb_offset, /**< in: Q0 | IGF swb offset table */
+ Word32 *pPowerSpectrum, /**< in: Q31 | power spectrum */
+ Word16 *pPowerSpectrum_exp, /**< in: | Exponent of PowerSpectrum */
+ Word32 *sfbEnergy, /**< out:Q31 | SFB energies , will be initialized inside this function */
+ Word16 *sfbEnergy_exp /**< out: | Exponent of PowerSpectrum */
+ );
+
+Word16 IGFCommonFuncsIGFConfiguration( /**< out: | error value: 0 -> error, 1 -> ok */
+ Word32 bitRate, /**< in: Q0 | bitrate in bs e.g. 9600 for 9.6kbs */
+ Word16 mode, /**< in: Q0 | bandwidth mode */
+ H_IGF_INFO hIGFInfo /**< out: | IGF info handle */
+ ,Word16 rf_mode /**< in: flag to signal the RF mode */
+);
+
+Word16 IGFCommonFuncsIGFGetCFTables( /**< out: | error value: 0 -> error, 1 -> ok */
+ Word32 bitRate, /**< in: Q0 | bitrate in bs e.g. 9600 for 9.6kbs */
+ Word16 mode, /**< in: Q0 | bandwidth mode */
+ Word16 rf_mode, /**< in: | flag to signal the RF mode */
+ const Word16 **cf_se00, /**< out: | CF table for t == 0 and f == 0 */
+ const Word16 **cf_se01, /**< out: | CF table for t == 0 and f == 1 */
+ Word16 *cf_off_se01, /**< out: | offset for CF table above */
+ const Word16 **cf_se02, /**< out: | CF tables for t == 0 and f >= 2 */
+ const Word16 **cf_off_se02, /**< out: | offsets for CF tables above */
+ const Word16 **cf_se10, /**< out: | CF table for t == 1 and f == 0 */
+ Word16 *cf_off_se10, /**< out: | offset for CF table above */
+ const Word16 **cf_se11, /**< out: | CF tables for t == 1 and f >= 1 */
+ const Word16 **cf_off_se11 /**< out: | offsets for CF tables above */
+);
+
+void IGFCommonFuncsMDCTSquareSpec(const Word16 sqrtBgn, /**< in: Q0 | start MDCT subband index */
+ const Word16 sqrtEnd, /**< in: Q0 | stop MDCT subband index */
+ const Word32 *mdctSpec, /**< in: Q31 | MDCT spectrum to square */
+ const Word16 mdctSpec_e, /**< in: | exponent of mdctSpectrum */
+ Word32 *mdctSquareSpec, /**< out:Q31 | MDCT square spectrum */
+ Word16 *mdctSquareSpec_e, /**< out: | exponent of mdctSquareSpec */
+ Word16 indexOffset /**< in: Q0 | index offset */
+ );
+
+void IGFCommonFuncsWriteSerialBit(void *st, /**< in: | encoder/decoder state structure */
+ Word16 *pBitOffset, /**< out: Q0 | bit offset */
+ Word16 bit /**< in: Q0 | value of bit */
+ );
+
+/* IGFSCFEncoder.c */
+void IGFSCFEncoderOpen(
+ IGFSCFENC_INSTANCE_HANDLE hPublicData, /* i/o: handle to public data */
+ Word16 scfCountLongBlock, /* i: number of SCFs for a long block */
+ Word32 bitRate, /* i: bitrate in bps */
+ Word16 mode /* i: operating mode */
+ , Word16 rf_mode /**< in: flag to signal the RF mode */
+);
+
+void IGFSCFEncoderReset(
+ IGFSCFENC_INSTANCE_HANDLE hPublicData /* i/o: handle to public data */
+);
+
+Word16 IGFSCFEncoderEncode(
+ IGFSCFENC_INSTANCE_HANDLE hPublicData, /* i/o: handle to public data */
+ Encoder_State_fx *st, /* i/o: pointer to encoder state */
+ Word16 bitCount, /* i: offset to the first bit in bitbuffer which should be written by the raw AC functions */
+ Word16 *sfe, /* i: pointer to an array which contains the quantized SCF energies to be encoded */
+ Word16 indepFlag, /* i: 1 if the block is an independent block, 0 otherwise */
+ Word16 doRealEncoding /* i: whether the real encoding is needed, otherwise only the number of bits is used */
+);
+
+void IGFSCFEncoderSaveContextState(
+ IGFSCFENC_INSTANCE_HANDLE hPublicData /* i/o: handle to public data */
+);
+
+void IGFSCFEncoderRestoreContextState(
+ IGFSCFENC_INSTANCE_HANDLE hPublicData /* i/o: handle to public data */
+);
+
+/* IGFSCFDecoder.c */
+void IGFSCFDecoderOpen(
+ IGFSCFDEC_INSTANCE_HANDLE hPublicData, /* i/o: handle to public data */
+ Word16 scfCountLongBlock, /* i: number of SCFs for a long block */
+ Word32 bitRate, /* i: bitrate in bps */
+ Word16 mode /* i: operating mode */
+ ,Word16 rf_mode
+);
+
+void IGFSCFDecoderReset(
+ IGFSCFDEC_INSTANCE_HANDLE hPublicData /* i/o: handle to public data */
+);
+
+void IGFSCFDecoderDecode(
+ IGFSCFDEC_INSTANCE_HANDLE hPublicData, /* i/o: handle to public data */
+ Decoder_State_fx *st, /* i/o: pointer to decoder state */
+ Word16 *sfe, /* o: pointer to an array which will contain the decoded quantized SCFs */
+ Word16 indepFlag /* i: 1 if the block is an independent block, 0 otherwise */
+);
+
+Word32 SFM_Cal(Word32 magn[], Word16 n);
+
+
+void Unified_weighting_fx(
+ Word32 Bin_Ener_128_fx[], /* i : FFT Bin energy 128 bins in two sets Q_ener */
+ Word16 Q_ener,
+ const Word16 lsf_fx[], /* i : LSF vector x2.56 */
+ Word16 w_fx[], /* o : LP weighting filter (numerator) Q8 */
+ const Word16 narrowBand, /* i : flag for Narrowband */
+ const Word16 unvoiced, /* i : flag for Unvoiced frame */
+ const Word32 sr_core, /* i : sampling rate of core-coder */
+ const Word16 order /* i : LP order */
+);
+
+void lsf_dec_bfi(
+ const Word16 codec_mode, /* i: : codec mode: MODE1 | MODE2 */
+ Word16*lsf, /*!< o : 14Q1*1.28 quantized ISFs */
+ const Word16*lsfold, /*!< i : 14Q1*1.28 past quantized ISF */
+ Word16*lsf_adaptive_mean, /*!< i : 14Q1*1.28 ISF adaptive mean, updated when BFI==0 */
+ const Word16 lsfBase[], /* i : base for differential lsf coding */
+ Word16*mem_MA, /*!< i/o: 14Q1*1.28 quantizer memory for MA model */
+ Word16*mem_AR, /*!< i/o: 14Q1*1.28 quantizer memory for MA model */
+ Word16 stab_fac, /*!< i : ISF stability factor (shifted right by 1) */
+ const Word16 last_coder_type, /*!< i : coding type in last good received fr. */
+ Word16 L_frame,
+ const Word16 last_good, /*!< i : last good received frame */
+ const Word16 nbLostCmpt, /*!< i : counter of consecutive bad frames */
+ Word8 plcBackgroundNoiseUpdated,
+ Word16 *lsf_q_cng, /* o : quantized ISFs for background noise (14Q1*1.28) */
+ Word16 *lsf_cng,
+ Word16 *old_lsf_q_cng, /* o : old quantized ISFs for background noise */
+ const Word16 Last_GSC_pit_band_idx,
+ const Word16 Opt_AMR_WB, /* i : IO flag */
+ const Word8 tcxonly
+ ,const short MODE1_bwidth /* i: coded bandwidth */
+);
+
+
+void lpc_quantization(
+ Encoder_State_fx * st,
+ const Word16 core,
+ const Word16 lpcQuantization,
+ const Word16 lsfold_q[],
+ const Word16 lsp[],
+ const Word16 lspmid[],
+ Word16 lsp_q[],
+ Word16 lsf_q[], /* 14Q1*1.28 */
+ Word16 lspmid_q[],
+ Word16 lspq_ind[],
+ Word16 clip_var[],
+ Word16 mem_MA[],
+ Word16 mem_AR[],
+ const Word8 narrowBand,
+ const Word16 coder_type,
+ const Word8 acelp_midLpc,
+ Word16 param_lpc[],
+ Word16 nbits_lpc[],
+ Word16 * bits_param_lpc,
+ Word16 *no_param_lpc,
+ Word16 *seed_acelp,
+ Word32 * Bin_Ener_fx,
+ Word32 * Bin_Ener_old_fx,
+ const Word16 Q_ener
+);
+
+
+
+/* enc_util.c */
+void Scale_sig(
+ Word16 x[], /* i/o: signal to scale Qx */
+ const Word16 lg, /* i : size of x[] Q0 */
+ const Word16 exp0 /* i : exponent: x = round(x << exp) Qx xx exp */
+);
+void E_UTIL_f_preemph(Word16 *signal, const Word16 mu, const Word16 lg, Word16 *mem);
+void E_UTIL_f_preemph2(Word16 shift, Word16 *signal, const Word16 mu, const Word16 lg, Word16 *mem);
+Word16 E_UTIL_f_preemph3(Word16 *signal, const Word16 mu, const Word16 lg, Word16 *mem, Word16 bits);
+void deemph_fx(Word16 * signal, const Word16 mu, const Word16 L, Word16 * mem);
+void E_UTIL_deemph2(Word16 shift, Word16 *x, const Word16 mu, const Word16 L, Word16 *mem);
+void E_UTIL_synthesis(const Word16 shift, const Word16 a[], const Word16 x[], Word16 y[],
+ const Word16 lg, Word16 mem[], const Word16 update, const Word16 m);
+void E_UTIL_f_convolve(const Word16 x[], const Word16 h[], Word16 y[], const Word16 size);
+
+Word16 E_ACELP_hh_corr(Word16 *x, Word16 *y, Word16 L_subfr, Word16 bits);
+Word16 E_ACELP_toeplitz_mul(const Word16 R[], const Word16 c[], Word16 d[], const Word16 L_subfr, const Word16 highrate);
+
+void E_ACELP_weighted_code(
+ const Word16 code[], /* i: code */
+ const Word16 H[], /* i: impulse response */
+ Word16 Q, /* i: Q format of H */
+ Word16 y[] /* o: weighted code */
+);
+
+void E_ACELP_conv(
+ const Word16 xn2[], /* i */
+ const Word16 h2[], /* i */
+ Word16 cn2[] /* o */
+);
+
+void E_ACELP_build_code(
+ Word16 nb_pulse, /* i */
+ const Word16 codvec[], /* i */
+ const Word16 sign[], /* i */
+ Word16 code[], /* o */
+ Word16 ind[] /* o */
+);
+
+void E_ACELP_setup_pulse_search_pos(
+ const PulseConfig *config, /* i: pulse configuration */
+ Word16 k, /* i: interation number */
+ UWord8 ipos[] /* o: pulse search positions */
+);
+
+void find_wsp(
+ const Word16 Az[],
+ const Word16 speech[],
+ Word16 wsp[],
+ Word16 *mem_wsp,
+ const Word16 preemph_fac,
+ const Word16 L_frame,
+ const Word16 lookahead,
+ const Word16 L_subfr,
+ Word16 Aw[], /* o : weighted A(z) filter coefficients */
+ const Word16 gamma, /* i : weighting factor */
+ const Word16 nb_subfr /* i : number of subframes */
+);
+
+void init_sig_buffers( Encoder_State_fx *st, const Word16 L_frame_old, const Word16 L_subfr );
+
+void E_UTIL_cb_shape(
+ const Word16 preemphFlag, /* i : flag for pre-emphasis */
+ const Word16 pitchFlag, /* i : flag for pitch sharpening */
+ const Word16 scramblingFlag, /* i : flag for phase scrambling */
+ const Word16 formant_enh, /* i : use formant enhancement Q15 */
+ const Word16 formant_tilt, /* i : use tilt of formant enhancement Q0 */
+ const Word16 g1, /* i : formant sharpening numerator weighting */
+ const Word16 g2, /* i : formant sharpening denominator weighting */
+ const Word16 *Aq, /* i : quantized LPC coefficients 3Q12 */
+ Word16 *code, /* i/o: <14b */
+ const Word16 tilt_code, /* i : tilt factor Q15 */
+ const Word16 pitch /* i : pointer to current subframe fractional pitch */
+);
+
+void E_UTIL_voice_factor( Word16 *exc, /* i : pointer to the excitation frame Q_new */
+ Word16 i_subfr, /* i : subframe index */
+ Word16 *code, /* i : innovative codebook Q9 */
+ Word16 gain_pit, /* i : adaptive codebook gain 1Q14 */
+ Word32 gain_code, /* i : innovative cb. gain 15Q16 */
+ Word16 *voice_fac, /* o : subframe voicing estimation Q15 */
+ Word16 *tilt_code, /* o : tilt factor Q15 */
+ Word16 L_subfr, /* i : subframe length */
+ Word16 flag_tilt, /* i : Flag for triggering new voice factor tilt*/
+ Word16 Q_new, /* i : excitation buffer format */
+ Word16 shift /* i : scaling to get 12bit */
+ );
+
+Word16 E_UTIL_enhancer(
+ Word16 voice_fac, /* i : subframe voicing estimation Q15 */
+ Word16 stab_fac, /* i : LP filter stability measure Q15 */
+ Word32 gain_code, /* i : innovative cb. gain 15Q16 */
+ Word16 gain_inov, /* i : gain of the unscaled innovation Q12 */
+ Word32 *gc_threshold, /* i/o: gain code threshold 15Q16 */
+ Word16 *code, /* i/o: innovation(in: Q9) code_exp */
+ Word16 *exc2, /* i/o: adapt. excitation/total exc. Q15 */
+ Word16 gain_pit, /* i : Quantized pitch gain 1Q14 */
+ Word32 *prev_gain_code, /* i/o: previous codebook gain 15Q16 */
+ Word16 prev_gain_pit[], /* i/o: previous pitch gain, size=6 1Q14 */
+ Word16 *prev_state, /* i/o: Phase dispersion algorithm memory Q0 */
+ Word16 coder_type, /* i : coder type */
+ Word16 cdk_index, /* i : */
+ Word16 L_subfr, /* i : */
+ Word16 L_frame, /* i : frame size */
+ Word16 Q_new
+);
+
+Word32 E_LPC_schur(Word32 r[], Word16 reflCoeff[], Word32 epsP[], const Word16 m);
+Word16 E_LPC_lev_dur_stab(const Word16 Rh[], const Word16 Rl[], Word16 A[],
+ Word32 epsP[], const Word16 order, Word16 *parcorr, Word16 k_max
+ );
+Word16 E_LPC_lev_dur(const Word16 Rh[], const Word16 Rl[], Word16 A[],
+ Word32 epsP[], const Word16 order, Word16 *parcorr
+ );
+
+void E_LPC_a_weight_inv(const Word16 *a, Word16 *ap, const Word16 gamma, const Word16 m);
+void E_LPC_a_add_tilt(const Word16 *a, Word16 *ap, Word16 gamma, Word16 m);
+void E_LPC_a_lsf_isf_conversion(Word16 *lpcCoeffs, Word16 *lsf, const Word16 *old_lsf, Word16 lpcOrder, Word8 lpcRep);
+void E_LPC_a_lsp_conversion(
+ const Word16 *a, /* input : LP filter coefficients */
+ Word16 *lsp, /* output: Line spectral pairs (in the cosine domain) */
+ const Word16 *old_lsp, /* input : LSP vector from past frame */
+ const Word16 m /* input : LPC order */
+);
+void E_LPC_lsp_lsf_conversion(
+ const Word16 lsp[], /* input: lsp[m] (range: -1<=val<1) */
+ Word16 lsf[], /* output : lsf[m] normalized (range: 0<=val<=6400) */
+ const Word16 m /* input : LPC order */
+);
+void E_LPC_lsf_lsp_conversion(
+ const Word16 lsf[], /* input : lsf[m] normalized (range: 0<=val<=6400) */
+ Word16 lsp[], /* output: lsp[m] (range: -1<=val<1) */
+ const Word16 m /* input : LPC order */
+);
+
+void E_LPC_f_lsp_a_conversion(const Word16 *lsp, Word16 *a, const Word16 m);
+void E_LPC_a_isp_conversion(
+ const Word16 *a, /* input : LP filter coefficients */
+ Word16 *isp, /* output: Line spectral pairs (in the cosine domain) */
+ const Word16 *old_isp,/* input : LSP vector from past frame */
+ const Word16 m /* input : LPC order */
+);
+void E_LPC_isp_isf_conversion(const Word16 isp[], Word16 isf[], const Word16 m);
+void E_LPC_isf_isp_conversion(const Word16 isf[], Word16 isp[], const Word16 m);
+void E_LPC_f_isp_a_conversion(const Word16 *isp, Word16 *a, const Word16 m);
+void E_LPC_int_lpc_tcx(const Word16 lsp_old[], /* input : LSPs from past frame (1Q14) */
+ const Word16 lsp_new[], /* input : LSPs from present frame (1Q14) */
+ Word16 a[] /* output: interpolated LP coefficients (4Q11) */
+ );
+
+/* enc_gain.c */
+
+Word16 E_GAIN_closed_loop_search(Word16 exc[],
+ Word16 xn[], Word16 h[],
+ Word16 t0_min, Word16 t0_min_frac, Word16 t0_max, Word16 t0_max_frac, Word16 t0_min_max_res, Word16 *pit_frac, Word16 *pit_res, Word16 pit_res_max,
+ Word16 i_subfr, Word16 pit_min, Word16 pit_fr2, Word16 pit_fr1, Word16 L_subfr);
+void E_GAIN_norm_corr(Word16 exc[], Word16 xn[], Word16 h[],
+ Word16 t_min, Word16 t_max, Word16 corr_norm[], Word16 L_subfr);
+
+/* enc_acelp.c */
+void E_ACELP_xy2_corr(Word16 xn[], Word16 y1[], Word16 y2[], ACELP_CbkCorr *g_corr, Word16 L_subfr, Word16 exp_xn);
+Word16 E_ACELP_xy1_corr(Word16 xn[], Word16 y1[], ACELP_CbkCorr *g_corr, Word16 norm_flag, Word16 L_subfr, Word16 exp_xn);
+void E_ACELP_codebook_target_update(Word16 *x, Word16 *x2, Word16 *y, Word16 gain, Word16 L_subfr);
+void E_ACELP_h_vec_corr1(Word16 h[], Word16 vec[], UWord8 track, Word16 sign[], Word16 (*rrixix)[16], Word16 cor[], Word16 dn2_pos[], Word16 nb_pulse);
+void E_ACELP_h_vec_corr2(Word16 h[], Word16 vec[], UWord8 track, Word16 sign[], Word16 (*rrixix)[16], Word16 cor[]);
+void E_ACELP_4tsearch(Word16 dn[], const Word16 cn[], const Word16 H[], Word16 code[], const PulseConfig *config, Word16 ind[], Word16 y[]);
+void E_ACELP_4tsearchx(Word16 dn[], const Word16 cn[], Word16 Rw[], Word16 code[], const PulseConfig *config, Word16 ind[]);
+void E_ACELP_pulsesign(const Word16 cn[], Word16 dn[], Word16 dn2[], Word16 sign[], Word16 vec[], const Word16 alp, Word16 const sign_val, const Word16 L_subfr);
+
+Word16 E_ACELP_indexing(const Word16 code[], const PulseConfig *config, Word16 num_tracks, Word16 prm[]);
+void E_ACELP_findcandidates(Word16 dn2[], Word16 dn2_pos[], Word16 pos_max[]);
+void E_ACELP_vec_neg(Word16 h[], Word16 h_inv[], Word16 L_subfr);
+void E_ACELP_corrmatrix(Word16 h[], Word16 sign[], Word16 vec[], Word16 rrixix[4][16], Word16 rrixiy[4][256]);
+void E_ACELP_codearithp(const Word16 v[], UWord32 *n, UWord32 *ps, Word16 *p);
+
+void find_targets_fx(
+ const Word16 *speech, /* i : pointer to the speech frame Q_new-1*/
+ const Word16 *mem_syn, /* i : memory of the synthesis filter Q_new-1*/
+ const Word16 i_subfr, /* i : subframe index */
+ Word16 *mem_w0, /* i/o: weighting filter denominator memory Q_new-1*/
+ const Word16 *p_Aq, /* i : interpolated quantized A(z) filter Q12*/
+ const Word16 *res, /* i : residual signal Q_new*/
+ const Word16 L_subfr, /* i : length of vectors for gain quantization */
+ const Word16 *Ap, /* i : unquantized A(z) filter with bandwidth expansion Q12*/
+ Word16 tilt_fac, /* i : tilt factor Q15 */
+ Word16 *xn, /* o : Close-loop Pitch search target vector Q_new-1*/
+ Word16 *cn /* o : target vector in residual domain Q_new*/
+ ,Word16 *h1 /* Q14 ?*/
+);
+
+void E_ACELP_adaptive_codebook(
+ Word16 *exc, /* i : pointer to the excitation frame */
+ Word16 T0, /* i : integer pitch lag */
+ Word16 T0_frac, /* i : fraction of lag */
+ Word16 T0_res, /* i : pitch resolution */
+ Word16 T0_res_max, /* i : maximum pitch resolution */
+ Word16 mode, /* i : filtering mode (0: no, 1: yes, 2: adaptive) */
+ Word16 i_subfr, /* i : subframe index */
+ Word16 L_subfr, /* i : subframe length */
+ Word16 L_frame, /* i : subframe length */
+ Word16 *h1, /* i : impulse response of weighted synthesis filter */
+ Word16 clip_gain,
+ Word16 *xn, /* i : Close-loop Pitch search target vector */
+ Word16 *y1, /* o : zero-memory filtered adaptive excitation */
+ ACELP_CbkCorr *g_corr, /* o : ACELP correlation values */
+ Word16 **pt_indice, /* i/o: quantization indices pointer */
+ Word16 *pitch_gain, /* o : adaptive codebook gain */
+ Word16 exp_xn
+ ,Word16 rf_mode
+ ,Word16 use_prev_sf_pit_gain
+ ,Word16* lp_select
+);
+
+void E_ACELP_innovative_codebook(
+ Word16 *exc, /* i : pointer to the excitation frame */
+ Word16 T0, /* i : integer pitch lag */
+ Word16 T0_frac, /* i : fraction of lag */
+ Word16 T0_res, /* i : pitch resolution */
+ Word16 gain_pit, /* i : adaptive codebook gain */
+ Word16 tilt_code, /* i : tilt factor */
+ Word16 mode, /* i : innovative codebook mode */
+ Word16 formant_enh, /* i : use formant enhancement Q15 */
+ Word16 formant_tilt, /* i : use tilt of formant enhancement */
+ const Word16 formant_enh_num, /* i : formant sharpening numerator weighting */
+ const Word16 foramnt_enh_den, /* i : formant sharpening denominator weighting */
+ Word16 pitch_sharpening,/* i : use pitch sharpening */
+ Word16 pre_emphasis,
+ Word16 phase_scrambling,
+ Word16 i_subfr, /* i : subframe index */
+ const Word16 *Aq, /* i : quantized LPC coefficients */
+ Word16 *h1, /* i : impulse response of weighted synthesis filter */
+ Word16 *xn, /* i : Close-loop Pitch search target vector */
+ Word16 *cn, /* i : Innovative codebook search target vector */
+ Word16 *y1, /* i : zero-memory filtered adaptive excitation */
+ Word16 *y2, /* o : zero-memory filtered algebraic excitation */
+ Word8 acelpautoc, /* i : autocorrelation mode enabled */
+ Word16 **pt_indice, /* i/o: quantization indices pointer */
+ Word16 *code, /* o : innovative codebook Q9 */
+ Word16 shift /* i : Scaling to get 12 bits */
+ ,const Word16 L_frame, /* i : length of the frame */
+ const Word16 last_L_frame, /* i : length of the last frame */
+ const Word32 total_brate /* i : total bit-rate */
+);
+
+Word16 E_ACELP_code43bit(const Word16 code[], UWord32 *ps, Word16 *p, UWord16 idxs[]);
+void fcb_pulse_track_joint(UWord16 *idxs, Word16 wordcnt, UWord32 *index_n, Word16 *pulse_num, Word16 track_num);
+
+void encode_acelp_gains(
+ Word16 *code, /* Q9 */
+ Word16 gains_mode,
+ Word16 mean_ener_code,
+ Word16 clip_gain,
+ ACELP_CbkCorr *g_corr,
+ Word16 *gain_pit, /* Q14 */
+ Word32 *gain_code, /* 15Q16 */
+ Word16 **pt_indice,
+ Word32 *past_gcode, /* 15Q16 */
+ Word16 *gain_inov, /* Q12 */
+ Word16 L_subfr,
+ Word16 *code2,
+ Word32 *gain_code2,
+ Word8 noisy_speech_flag /* (i) : noisy speech flag */
+);
+
+extern const long int pulsestable[6][7];
+extern const PulseConfig PulseConfTable[];
+extern const Word16 ACELP_CDK_BITS[];
+
+void D_ACELP_indexing(
+ Word16 code[],
+ PulseConfig config,
+ Word16 num_tracks,
+ Word16 index[]
+ ,Word16 *BER_detect
+);
+
+void D_ACELP_decode_43bit(UWord16 idxs[], Word16 code[], Word16 *pulsestrack);
+void fcb_pulse_track_joint_decode(UWord16 *idxs, Word16 wordcnt, UWord32 *index_n, Word16 *pulse_num, Word16 track_num);
+
+/* lag window lag_wind.c */
+void lag_wind(
+ Word16 r_h[], /* in/out: autocorrelations */
+ Word16 r_l[], /* in/out: autocorrelations */
+ Word16 m, /* input : order of LP filter */
+ Word32 sr, /* input : sampling rate */
+ Word16 strength /* input : LAGW_WEAK, LAGW_MEDIUM, or LAGW_STRONG */
+);
+
+void adapt_lag_wind(
+ Word16 r_h[], /* in/out: autocorrelations */
+ Word16 r_l[], /* in/out: autocorrelations */
+ Word16 m, /* input : order of LP filter */
+ const Word16 Top, /* input : open loop pitch lag */
+ const Word16 Tnc, /* input : open loop pitch gain */
+ Word32 sr /* input : sampling rate */
+);
+
+void hp20(Word16 signal[], /* i/o: signal to filter any */
+ const Word16 stride, /* i : stride to be applied accessing signal */
+ const Word16 lg, /* i : length of signal (integer) Q0 */
+ Word32 mem[5], /* i/o: static filter memory with this layout: */
+ /* mem[0]: y[-2] (32-bit) */
+ /* mem[1]; y[-1] (32-bit) */
+ /* mem[2]: x[-2] << 16 */
+ /* mem[3]: x[-1] << 16 */
+ /* Note: mem[0..3] need to be scaled per frame */
+ /* mem[4]: states scale */
+ const Word32 sFreq); /* i : input sampling rate Q0 */
+
+/* pit_fr4.c */
+void Mode2_pred_lt4(Word16 exc[], /* in/out: excitation buffer */
+ Word16 T0, /* input : integer pitch lag */
+ Word16 frac, /* input : fraction of lag */
+ Word16 T0_res, /* input : pitch lag resolution */
+ Word16 T0_res_max, /* input : maximum resolution */
+ Word16 L_subfr); /* input : subframe size */
+
+
+#define mvr2r_Word32(x,y,n) Copy32(x,y,n)
+#define mvr2r_Word16(x,y,n) Copy(x,y,n)
+#define vr_intset(val, vector, count) { Word16 i; FOR(i=0; i<(count); i++) { vector[i]=val; } }
+
+float mean( /* o : the mean of the elements of the vector */
+ const float *vec, /* i : input vector */
+ const short lvec /* i : length of input vector */
+);
+
+/* window.c */
+void ham_cos_window(Word16 *fh, const Word16 n1, const Word16 n2);
+
+
+/*---------------------------------------------------------------------*
+ * main routines *
+ *---------------------------------------------------------------------*/
+
+void init_coder_ace_plus( Encoder_State_fx* st,const Word16 shift);
+void core_coder_reconfig( Encoder_State_fx *st);
+void core_coder_mode_switch( Encoder_State_fx *st, const Word16 bandwidth_in, const Word32 bitrate, const Word16 shift);
+
+void enc_acelp_tcx_main(
+ const Word16 new_samples[], /* i : new samples */
+ Encoder_State_fx *st, /* i/o: encoder state structure */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 pitch[3], /* i : open-loop pitch values for quantiz. */
+ const Word16 voicing[3], /* i : open-loop pitch gains */
+ Word16 Aw[NB_SUBFR16k*(M+1)], /* i : weighted A(z) unquant. for subframes*/
+ const Word16 lsp_new[M], /* i : LSPs at the end of the frame */
+ const Word16 lsp_mid[M], /* i : LSPs at the middle of the frame */
+ HANDLE_FD_CNG_ENC hFdCngEnc, /* i/o: FD CNG handle */
+ Word32 bwe_exc_extended[], /* i/o: bandwidth extended excitation */
+ Word16 *voice_factors, /* o : voicing factors */
+ Word16 pitch_buf[], /* o : floating pitch for each subframe */
+ Word16 vad_hover_flag,
+ const Word16 vad_flag_dtx,
+ Word16 *Q_new,
+ Word16 *shift
+);
+
+/*-----------------------------------------------------------------*
+ * Pitch prediction for frame erasure *
+ *-----------------------------------------------------------------*/
+void pitch_pred_linear_fit(
+ const Word16 /*short*/ bfi_cnt, /* i: bfi counter */ /*Q0 */
+ const Word16 /*short*/ last_good, /* i: last classification type */ /*Q0 */
+ Word32 /*float*/ *old_pitch_buf, /* i: pitch lag buffer */ /*Q16*/
+ Word32 /*float*/ *old_fpitch, /* i: */ /*Q16*/
+ Word32 /*float*/ *T0_out, /* o: estimated close loop pitch */ /*Q16*/
+ Word16 /* int*/ pit_min, /* i: Minimum pitch lag */ /*Q0 */
+ Word16 /* int*/ pit_max, /* i: Maximum pitch lag */ /*Q0 */
+ Word16 /*float*/ *mem_pitch_gain, /* i: pitch gain [0] is the most recent subfr gain */ /*Q0*/
+ Word16 /* int*/ limitation,
+ Word8 /*short*/ plc_use_future_lag, /* i: */ /*Q0 */
+ Word16 /*short*/ *extrapolationFailed, /* o: flag if extrap decides not to change the pitch *//*Q0 */
+ Word16 nb_subfr /* i: number of ACELP subframes */
+);
+
+void get_subframe_pitch(
+ Word16 nSubframes, /* i: number of subframes */ /* Q0 */
+ Word32 pitchStart, /* i: starting pitch lag (in subframe -1) */ /*15Q16*/
+ Word32 pitchEnd, /* i: ending pitch lag (in subframe nSubframes-1) */ /*15Q16*/
+ Word32 *pitchBuf /* o: interpolated pitch lag per subframe */ /*15Q16*/
+);
+
+void core_encode_openloop(
+ Encoder_State_fx *st, /* i/o: encoder state structure */
+ const Word16 coder_type, /* i : coding type */
+ const Word16 pitch[3], /* i : open-loop pitch values for quantiz. */
+ const Word16 voicing[3], /* i : open-loop pitch gains */
+ const Word16 Aw[NB_SUBFR16k*(M+1)], /* i : weighted A(z) unquant. for subframes*/
+ const Word16 *lsp_new, /* i : LSPs at the end of the frame */
+ const Word16 *lsp_mid, /* i : LSPs at the middle of the frame */
+ Word16 *pitch_buf, /* i/o: floating pitch values for each subfr*/
+ Word16 *voice_factors, /* o : voicing factors */
+ Word16 *ptr_bwe_exc, /* o : excitation for SWB TBE */
+ const Word16 vad_hover_flag,
+ const Word16 vad_flag_dtx,
+ Word16 Q_new,
+ Word16 shift
+);
+
+void core_acelp_tcx20_switching(
+ Encoder_State_fx *st, /* i/o: encoder state structure */
+ const Word16 vad_flag,
+ Word16 sp_aud_decision0,
+ Word16 non_staX,
+ Word16 *pitch, /* i : open-loop pitch values for quantiz. */
+ Word16 *pitch_fr, /* i/o: fraction pitch values */
+ Word16 *voicing_fr, /* i/o: fractional voicing values */
+ const Word16 currFlatness, /* i : flatness */
+ const Word16 lsp_mid[M], /* i : LSPs at the middle of the frame */
+ const Word16 stab_fac, /* i : LP filter stability */
+ Word16 Q_new,
+ Word16 shift
+);
+
+void core_encode_twodiv(
+ const Word16 new_samples[],
+ Encoder_State_fx *st,
+ const Word16 coder_type, /* i : coding type */
+ const Word16 pitch[3], /* i : open-loop pitch values for quantiz. */
+ const Word16 voicing[3], /* i : open-loop pitch gains */
+ Word16 Aw[NB_SUBFR16k*(M+1)], /* i : weighted A(z) unquant. for subframes*/
+ Word16 *Q_new,
+ Word16 *shift
+);
+
+void core_encode_update( Encoder_State_fx *st);
+
+void core_encode_update_cng( Encoder_State_fx *st,
+ Word16 *timeDomainBuffer,
+ Word16 *A,
+ Word16 *Aw,
+ Word16 Q_new,
+ Word16 shift
+ );
+
+/* core_sig_ana.c */
+void core_signal_analysis_post(const Word16 *new_samples, Encoder_State_fx *st);
+
+/* ext_sig_ana.c */
+void core_signal_analysis_enc(const Word16 *new_samples, /*, -2,, -2 and 2*/
+ Word16 mean_ener, /*, -2,, -2 and 2*/
+ Word16 mean_ener, /*syn */
+ Word8 fb /* i: fullband flag */
+);
+
+Word16 tcx_get_segSnr(Word16 *wsig, Word16 wsig_e,
+ Word32 *X, Word16 X_e,
+ Word32 *Xq, Word16 Xq_e,
+ Word8 *memQuantZeros,
+ const Word16 snrPenalty, /* 1Q14 */
+ Word16 gainlpc_reweight[], Word16 gainlpc_reweight_e[],
+ Word16 fdns_npts,
+ Word8 narrowBand,
+ Word16 gain_tcx, Word16 gain_tcx_e,
+ Word16 L_frame,
+ Word16 L_frame_glob,
+ Word16 L_subfr
+ );
+
+/* Returns: number of bits used (including "bits") Q0 */
+Word16 tcx_ari_res_Q_spec(
+ const Word32 x_orig[], /* i: original spectrum Q31-e */
+ Word16 x_orig_e, /* i: original spectrum exponent Q0 */
+ const Word16 signs[], /* i: signs (x_orig[.]<0) Q0 */
+ Word32 x_Q[], /* i/o: quantized spectrum Q31-e */
+ Word16 x_Q_e, /* i: quantized spectrum exponent Q0 */
+ Word16 L_frame, /* i: number of lines Q0 */
+ Word16 gain, /* i: TCX gain Q15-e */
+ Word16 gain_e, /* i: TCX gain exponent Q0 */
+ Word16 prm[], /* o: bit-stream Q0 */
+ Word16 target_bits, /* i: number of bits available Q0 */
+ Word16 bits, /* i: number of bits used so far Q0 */
+ Word16 deadzone, /* i: quantizer deadzone Q15 */
+ const Word16 x_fac[] /* i: spectrum post-quantization factors Q14 */
+);
+
+/* Returns: number of bits used (including "bits") */
+Word16 tcx_ari_res_invQ_spec(
+ Word32 x_Q[], /* i/o: quantized spectrum Q31-e */
+ Word16 x_Q_e, /* i: quantized spectrum exponent Q0 */
+ Word16 L_frame, /* i: number of lines Q0 */
+ const Word16 prm[], /* i: bit-stream Q0 */
+ Word16 target_bits, /* i: number of bits available Q0 */
+ Word16 bits, /* i: number of bits used so far Q0 */
+ Word16 deadzone, /* i: quantizer deadzone Q15 */
+ const Word16 x_fac[] /* i: spectrum post-quantization factors Q14 */
+);
+
+Word16 tcx_res_Q_gain(
+ Word16 sqGain,
+ Word16 sqGain_e,
+ Word16 *gain_tcx,
+ Word16 *gain_tcx_e,
+ Word16 *prm,
+ Word16 sqTargetBits
+);
+
+Word16 tcx_res_Q_spec(
+ Word32 *x_orig,
+ Word16 x_orig_e,
+ Word32 *x_Q,
+ Word16 x_Q_e,
+ Word16 L_frame,
+ Word16 sqGain,
+ Word16 sqGain_e,
+ Word16 *prm,
+ Word16 sqTargetBits,
+ Word16 bits,
+ Word16 sq_round,
+ const Word16 lf_deemph_factors[]
+);
+
+Word16 tcx_res_invQ_gain(
+ Word16 *gain_tcx,
+ Word16 *gain_tcx_e,
+ Word16 *prm,
+ Word16 resQBits
+);
+
+Word16 tcx_res_invQ_spec(
+ Word32 *x,
+ Word16 x_e,
+ Word16 L_frame,
+ Word16 *prm,
+ Word16 resQBits,
+ Word16 bits,
+ Word16 sq_round,
+ const Word16 lf_deemph_factors[]
+);
+
+void InitTnsConfigs(
+ Word32 nSampleRate,
+ Word16 L_frame,
+ STnsConfig tnsConfig[2][2]
+ ,Word16 igfStopFreq
+ ,Word32 bitrate
+);
+
+void SetTnsConfig(TCX_config * tcx_cfg, Word8 isTCX20, Word8 isAfterACELP);
+
+
+/* ari.c */
+Word32 L_multi31x16_X2(Word16 xh, Word16 xl, Word16 y);
+Word32 mul_sbc_14bits(Word32 r, Word16 c);
+
+void ari_copy_states(
+ TastatEnc *source,
+ TastatEnc *dest
+);
+
+void ari_start_encoding_14bits(
+ TastatEnc *s
+);
+
+Word16 ari_done_encoding_14bits(
+ Word16 *ptr,
+ Word16 bp,
+ TastatEnc *s
+);
+
+Word16 ari_encode_14bits_ext(
+ Word16 *ptr,
+ Word16 bp,
+ TastatEnc *s,
+ Word32 symbol,
+ UWord16 const *cum_freq
+);
+
+void ari_start_decoding_14bits(
+ Decoder_State_fx *st,
+ TastatDec *s
+);
+
+Word16 ari_decode_14bits_s17_ext(
+ Decoder_State_fx *st,
+ TastatDec *s,
+ UWord16 const *cum_freq
+);
+
+Word16 ari_decode_14bits_s27_ext(
+ Decoder_State_fx *st,
+ TastatDec *s,
+ UWord16 const *cum_freq
+);
+
+Word16 ari_decode_14bits_bit_ext(
+ Decoder_State_fx *st,
+ TastatDec *s
+);
+
+
+Word16 ari_encode_overflow(TastatEnc *s);
+Word16 ari_encode_14bits_range(Word16 *ptr, Word16 bp, Word16 bits, TastatEnc *s, Word16 cum_freq_low, Word16 cum_freq_high);
+Word16 ari_encode_14bits_sign(Word16 *ptr, Word16 bp, Word16 bits, TastatEnc *s, Word16 sign);
+Word16 ari_done_cbr_encoding_14bits(Word16 *ptr, Word16 bp, Word16 bits, TastatEnc *s);
+Word16 ari_decode_overflow(TastatDec *s);
+Word16 ari_decode_14bits_pow(Word16 *ptr, Word16 bp, Word16 bits, Word16 *res, TastatDec *s, Word16 base);
+Word16 ari_decode_14bits_sign(Word16 *ptr, Word16 bp, Word16 bits, Word16 *res, TastatDec *s);
+Word16 ari_start_decoding_14bits_prm(const Word16 *ptr, Word16 bp, TastatDec *s);
+
+/*arith_code.c*/
+Word32 expfp( /* o: Q31 */
+ Word16 x, /* i: mantissa Q-e */
+ Word16 x_e); /* i: exponent Q0 */
+
+void powfp_odd2(Word16 base, /* Q15 */
+ Word16 exp, /* Q0 */
+ Word16 *pout1, /* Q15 */
+ Word16 *pout2); /* Q15 */
+
+void tcx_arith_scale_envelope(
+ Word16 L_spec_core, /* i: number of lines to scale Q0 */
+ Word16 L_frame, /* i: number of lines Q0 */
+ Word32 env[], /* i: unscaled envelope Q16 */
+ Word16 target_bits, /* i: number of available bits Q0 */
+ Word16 low_complexity, /* i: low-complexity flag Q0 */
+ Word16 s_env[], /* o: scaled envelope Q15-e */
+ Word16 *s_env_e /* o: scaled envelope exponent Q0 */
+);
+
+void tcx_arith_render_envelope(
+ const Word16 A_ind[], /* i: LPC coefficients of signal envelope */
+ Word16 L_frame, /* i: number of spectral lines */
+ Word16 L_spec,
+ Word16 preemph_fac, /* i: pre-emphasis factor */
+ Word16 gamma_w, /* i: A_ind -> weighted envelope factor */
+ Word16 gamma_uw, /* i: A_ind -> non-weighted envelope factor */
+ Word32 env[] /* o: shaped signal envelope */
+);
+
+void tcx_get_gain(Word32 *x, /* i: spectrum 1 */
+ Word16 x_e, /* i: spectrum 1 exponent */
+ Word32 *y, /* i: spectrum 2 */
+ Word16 y_e, /* i: spectrum 2 exponent */
+ Word16 n, /* i: length */
+ Word16 *gain, /* o: gain */
+ Word16 *gain_e, /* o: gain exponent */
+ Word32 *en_y, /* o: energy of y (optional) */
+ Word16 *en_y_e /* o: energy of y exponent (optional) */
+ );
+
+void init_TCX_config(TCX_config *tcx_cfg,
+ Word16 L_frame,
+ Word16 fscale
+ ,Word16 L_frameTCX
+ ,Word16 fscaleFB
+ );
+
+void tcx_arith_encode_envelope(
+ Word32 spectrum[], /* i/o: MDCT coefficients Q31-e */
+ Word16 *spectrum_e, /* i/o: MDCT exponent Q0 */
+ Word16 signs[], /* o: signs (spectrum[.]<0) Q0 */
+ Word16 L_frame, /* i: frame or MDCT length Q0 */
+ Word16 L_frame_orig, /* i: length w/o BW limitation Q0 */
+ Encoder_State_fx *st, /* i/o: coder state */
+ const Word16 A_ind[], /* i: quantised LPC coefficients Q12 */
+ Word16 target_bits, /* i: number of available bits Q0 */
+ Word16 prm[], /* o: bitstream parameters Q0 */
+ Word8 use_hm, /* i: use HM in current frame? */
+ Word16 prm_hm[], /* o: HM parameter area Q0 */
+ Word16 tcxltp_pitch, /* i: TCX LTP pitch in FD, -1 if n/a Q0*/
+ Word16 *arith_bits, /* o: bits used for ari. coding Q0 */
+ Word16 *signaling_bits, /* o: bits used for signaling Q0 */
+ Word16 *nf_seed /* o: noise filling seed Q0 */
+ ,Word16 low_complexity /* i: low-complexity flag Q0 */
+);
+void tcx_arith_decode_envelope(
+ Word32 q_spectrum[], /* o: quantised MDCT coefficients Q31-e */
+ Word16 *q_spectrum_e, /* o: MDCT exponent Q0 */
+ Word16 L_frame, /* i: frame or MDCT length */
+ Word16 L_frame_orig, /* i: length w/o BW limitation */
+ Decoder_State_fx *st,
+ const Word16 A_ind[], /* i: quantised LPC coefficients */
+ Word16 target_bits, /* i: number of available bits */
+ Word16 prm[], /* i: bitstream parameters */
+ Word8 use_hm, /* i: use HM in current frame? */
+ Word16 prm_hm[], /* i: HM parameter area */
+ Word16 tcxltp_pitch, /* i: TCX LTP pitch in FD, -1 if n/a*/
+ Word16 *arith_bits, /* o: bits used for ari. coding */
+ Word16 *signaling_bits, /* o: bits used for signaling */
+ Word16 *nf_seed /* o: noise filling seed Q0 */
+ ,Word16 low_complexity /* i: low-complexity flag Q0 */
+
+);
+
+# define GET_ADJ2(T,L,F) (((L) << (F)) - (T))
+
+int tcx_hm_render(
+ Word32 lag, /* i: pitch lag Q0 */
+ Word16 fract_res, /* i: fractional resolution of the lag Q0 */
+ Word16 p[] /* o: harmonic model Q13 */
+);
+
+void tcx_hm_modify_envelope(
+ Word16 gain, /* i: HM gain Q11 */
+ Word32 lag, /* i: pitch lag Q0 */
+ Word16 fract_res, /* i: fractional resolution of the lag Q0 */
+ Word16 p[], /* i: harmonic model Q13 */
+ Word32 env[], /* i/o: envelope Q16 */
+ Word16 L_frame /* i: number of spectral lines Q0 */
+);
+
+void UnmapIndex(
+ Word16 PeriodicityIndex,
+ Word16 Bandwidth,
+ Word16 LtpPitchLag,
+ Word8 SmallerLags,
+ Word16 *FractionalResolution,
+ Word32 *Lag);
+
+/* Returns: PeriodicityIndex */
+Word16 SearchPeriodicityIndex(
+ const Word32 Mdct[], /* (I) Coefficients, Mdct[0..NumCoeffs-1] */
+ const Word32 UnfilteredMdct[], /* (I) Unfiltered coefficients, UnfilteredMdct[0..NumCoeffs-1] */
+ Word16 NumCoeffs, /* (I) Number of coefficients */
+ Word16 TargetBits, /* (I) Target bit budget (excl. Done flag) */
+ Word16 LtpPitchLag,
+ Word16 LtpGain, /* (I) LTP gain */
+ Word16 *RelativeScore /* (O) Energy concentration factor */
+);
+
+void ConfigureContextHm(
+ Word16 NumCoeffs, /* (I) Number of coefficients */
+ Word16 TargetBits, /* (I) Target bit budget (excl. Done flag) */
+ Word16 PeriodicityIndex, /* (I) Pitch related index */
+ Word16 LtpPitchLag, /* (I) TCX-LTP pitch in F.D. */
+ CONTEXT_HM_CONFIG *hm_cfg /* (O) Context-based harmonic model configuration */
+);
+
+Word16 EncodeIndex(
+ Word16 Bandwidth, /* 0: NB, 1: (S)WB */
+ Word16 PeriodicityIndex,
+ Encoder_State_fx *st);
+
+Word16 CountIndexBits(
+ Word16 Bandwidth, /* 0: NB, 1: (S)WB */
+ Word16 PeriodicityIndex);
+
+Word16
+DecodeIndex(
+ Decoder_State_fx *st,
+ Word16 Bandwidth,
+ Word16 *PeriodicityIndex);
+
+
+void tcx_hm_analyse(
+ const Word32 abs_spectrum[], /* i: absolute spectrum Q31-e */
+ Word16 *spectrum_e, /* i: absolute spectrum exponent Q0 */
+ Word16 L_frame, /* i: number of spectral lines Q0 */
+ Word32 env[], /* i/o: envelope shape Q16 */
+ Word16 targetBits, /* i: target bit budget Q0 */
+ Word16 coder_type, /* i: coder type Q0 */
+ Word16 prm_hm[], /* o: HM parameters Q0 */
+ Word16 LtpPitchLag, /* i: LTP pitch lag or -1 if none Q0 */
+ Word16 LtpGain, /* i: LTP gain Q15 */
+ Word16 *hm_bits /* o: bit consumption Q0 */
+);
+
+void tcx_hm_decode(
+ Word16 L_frame, /* i: number of spectral lines Q0 */
+ Word32 env[], /* i/o: envelope shape Q16 */
+ Word16 targetBits, /* i: target bit budget Q0 */
+ Word16 coder_type, /* i: coder_type Q0 */
+ Word16 prm_hm[], /* i: HM parameters Q0 */
+ Word16 LtpPitchLag, /* i: LTP pitch lag or -1 if none Q0 */
+ Word16 *hm_bits /* o: bit consumption Q0 */
+);
+
+void coder_tcx(
+ Word16 n,
+ TCX_config *tcx_cfg, /*input: configuration of TCX*/
+ Word16 A[], /* input: quantized coefficients NxAz_q[M+1] */
+ Word16 Aqind[], /* input: frame-independent quantized coefficients (M+1) */
+ Word16 synth[],
+ Word16 L_frame_glob, /* input: frame length */
+ Word16 L_frameTCX_glob,
+ Word16 L_spec,
+ Word16 nb_bits, /*input: bit budget*/
+ Word8 tcxonly, /*input: only TCX flag*/
+ Word32 spectrum[], /* i/o: MDCT spectrum */
+ Word16 *spectrum_e, /* i/o: MDCT spectrum exponent */
+ LPD_state *LPDmem, /*i/o: memories*/
+ Word16 prm[], /* output: tcx parameters */
+ Encoder_State_fx *st,
+ CONTEXT_HM_CONFIG *hm_cfg
+);
+
+void coder_tcx_post(Encoder_State_fx *st,
+ LPD_state *LPDmem,
+ TCX_config *tcx_cfg,
+ Word16 *synth,
+ const Word16 *A,
+ const Word16 *Ai,
+ Word16 *wsig,
+ Word16 Q_new,
+ Word16 shift
+ );
+
+void decoder_tcx(
+ TCX_config *tcx_cfg, /* input: configuration of TCX */
+ Word16 prm[], /* input: parameters */
+ Word16 A[], /* input: coefficients NxAz[M+1] */
+ Word16 Aind[], /* input: frame-independent coefficients Az[M+1] */
+ Word16 L_frame_glob, /* input: frame length */
+ Word16 L_frameTCX,
+ Word16 L_spec,
+ Word16 synth[], /* in/out: synth[-M-LFAC..lg] */
+ Word16 synthFB[],
+ Decoder_State_fx*st,
+ Word16 coder_type, /* input : coder type */
+ Word16 bfi, /* input: Bad frame indicator */
+ Word16 frame_cnt, /* input: frame counter in the super_frame */
+ Word16 stab_fac /* input: stability of isf */
+);
+
+void decoder_tcx_post(Decoder_State_fx *st_fx,
+ Word16 *synth,
+ Word16 *synthFB,
+ Word16 *A,
+ Word16 bfi
+ );
+
+/* cod_ace.c */
+Word16 coder_acelp( /* output SEGSNR for CL decision */
+ ACELP_config *acelp_cfg, /*input/output: configuration of the ACELP coding*/
+ const Word16 coder_type, /* input: coding type */
+ const Word16 A[], /* input: coefficients 4xAz[M+1] */
+ const Word16 Aq[], /* input: coefficients 4xAz_q[M+1] */
+ Word16 speech[], /* input: speech[-M..lg] */
+ Word16 synth[],
+ LPD_state *LPDmem,
+ const Word16 voicing[], /* input: open-loop LTP gain */
+ const Word16 T_op[], /* input: open-loop LTP lag */
+ Word16 *prm, /* output: acelp parameters */
+ Word16 stab_fac,
+ Encoder_State_fx *st,
+ HANDLE_PLC_ENC_EVS hPlc_Ext,
+ Word16 target_bits, /* i/o : coder memory state */
+ Word16 Q_new,
+ Word16 shift,
+ Word16 *pitch_buf, /* output : pitch values for each subfr.*/
+ Word16 *voice_factors, /* output : voicing factors */
+ Word16 *bwe_exc /* output : excitation for SWB TBE */
+);
+
+
+void decoder_acelp(
+ Decoder_State_fx *st,
+ Word16 coder_type, /* input: coder type */
+ Word16 prm[], /* input: parameters */
+ Word16 A[], /* input: coefficients NxAz[M+1] */
+ ACELP_config acelp_cfg, /* input: ACELP config */
+ Word16 synth[], /* i/o: synth[-2*LFAC..L_DIV] Q0 */
+ Word16 *pT, /* out: pitch for all subframe Q0 */
+ Word16 *pgainT, /* out: pitch gain for all subfr 1Q14 */
+ Word16 stab_fac, /* input: stability of isf */
+ Word16 *pitch_buffer, /* out: pitch values for each subfr.*/
+ Word16 *voice_factors, /* out: voicing factors */
+ const Word16 LSF_Q_prediction,/* i : LSF prediction mode */
+ Word16 *bwe_exc /* out: excitation for SWB TBE */
+);
+
+void enc_prm(
+ const Word16 coder_type, /* (i) : coding type */
+ Word16 param[], /* (i) : parameters */
+ Word16 param_lpc[], /* (i) : LPC parameters */
+ Encoder_State_fx *st, /* io: quantization Analysis values */
+ Word16 L_Frame,
+ CONTEXT_HM_CONFIG hm_cfg[],
+ Word16 * bits_param_lpc,
+ Word16 no_param_lpc
+);
+
+void enc_prm_rf(
+ Encoder_State_fx *st,
+ const Word16 rf_frame_type,
+ const Word16 fec_offset
+);
+
+void dec_prm(
+ Word16 *coder_type,
+ Word16 param[], /* (o) : decoded parameters */
+ Word16 param_lpc[], /* (o) : LPC parameters */
+ Word16 *total_nbbits, /* i/o : number of bits / decoded bits */
+ Decoder_State_fx *st,
+ Word16 L_frame,
+ Word16 *bitsRead
+);
+
+void dec_prm_core(
+ Decoder_State_fx *st
+);
+
+void analy_sp( /* o: fft0 bin energy Q0 */
+ Word16 *speech, /* i: speech buffer Q_new - preemph_bits */
+ const Word16 Q_new, /* i: current scaling exp Q0 */
+ Word32 *fr_bands, /* o: energy in critical frequency bands Q_new + QSCALE */
+ Word32 *lf_E, /* o: per bin E for first... Q_new + QSCALE - 2*/
+ Word16 *Etot, /* o: total input energy Q8 */
+ const Word16 min_band, /* i: minimum critical band Q0 */
+ const Word16 max_band, /* i: maximum critical band Q0 */
+ const Word32 e_min_scaled, /* i: minimum energy scaled Q_new + QSCALE */
+ Word16 Scale_fac[2], /* o: FFT scales factors (2 values by frame) Q0 */
+ Word32 *Bin_E, /* o : per bin log energy spectrum */
+ Word32 *Bin_E_old, /* o : per bin log energy spectrum for mid-frame */
+ Word32 *PS, /* o : Per bin energy spectrum */
+ Word16 *EspecdB, /* o : log E spectrum (with f=0) of the current frame Q7 */
+ Word32 *band_energies, /* o : energy in critical frequency bands without minimum noise floor MODE2_E_MIN */
+ Word16 *fft_buff /* o : FFT coefficients */
+);
+
+void E_UTIL_copy_scale_sig(
+ const Word16 x[], /* i : signal to scale input Qx */
+ Word16 y[], /* o : scaled signal output Qx */
+ const Word16 lg, /* i : size of x[] Q0 */
+ const Word16 exp0 /* i : exponent: x = round(x << exp) Qx xx exp */
+);
+
+void scale_sig32(
+ Word32 x[], /* i/o: signal to scale Qx */
+ const Word16 lg, /* i : size of x[] Q0 */
+ const Word16 exp0 /* i : exponent: x = round(x << exp) Qx xx exp */
+);
+
+
+Word32 scale_mem( /* o : Min energy scaled */
+ Word16 ini_frames, /* i : Frame number */
+ Word16 Q_exp, /* i : Diff scaling factor */
+ Word16 *Q_new, /* i/o: Absolute scaling factor */
+ Word16 *old_speech, /* i/o: Speech memory */
+ Word16 *old_speech_ns, /* i/o: Speech denoised memory */
+ Word16 *mem_wsp, /* i/o: wsp vector memory */
+ Word32 *enrO, /* i/o: Enr mem */
+ Word32 *bckr, /* i/o: Back ground_fx ener mem */
+ Word32 *lf_EO, /* i/o: Energy per low freq bin mem */
+ Word32 *ave_enr, /* i/o: Ave_enr mem */
+ Word32 *st_fr_bands1, /* i/o: spectrum per critical bands of the previous frame */
+ Word32 *st_fr_bands2, /* i/o: spectrum per critical bands 2 frames ago */
+ Word32 *ave_enr2 /* i/o: LT average E per crit. band (for non_sta2) Q_new + QSCALE */
+);
+
+Word16 rescale_exc(
+ Word16 exc[], /* i/o: excitation to rescale Q_exc */
+ Word16 lg, /* i : frame size */
+ Word32 L_gain_code, /* i : decoded codebook gain Q16 */
+ Word16 *sQ_exc, /* i/o: Excitation scaling factor */
+ Word16 *sQsubfr, /* i/o: Past excitation scaling factors */
+ Word16 exc2[], /* o : local excitation vector */
+ Word16 i_subfr /* i : subframe number */
+);
+
+Word16 rescale_mem(
+ const Word16 *Q_exc, /* i : current excitation scaling (>=0) */
+ Word16 *prev_Q_syn, /* i/o : scaling factor of previous frame */
+ Word16 *Q_syn, /* i/o : scaling factor of frame */
+ Word16 *mem_syn2, /* i/o : modified synthesis memory */
+ Word16 *syn, /* i/o : synthesis to rescale Q_syn */
+ Word16 mem_len, /* i : lenght of modified synthesis memory */
+ Word16 i_subfr /* i : subframe number */
+);
+
+void gauss_L2(
+ const Word16 h[], /* i : weighted LP filter impulse response Q14+s */
+ Word16 code2[], /* o : gaussian excitation Q9 */
+ const Word16 y2[], /* i : zero-memory filtered code. excitation Q9 */
+ Word16 y11[], /* o : zero-memory filtered gauss. excitation Q9 */
+ Word32 *gain, /* o : excitation gain */
+ ACELP_CbkCorr *g_corr, /*i/o : correlation structure for gain coding */
+ const Word16 gain_pit, /* i : unquantized gain of code */
+ const Word16 tilt_code, /* i : tilt of code Q15 */
+ const Word16 *Aq, /* i : quantized LPCs Q12 */
+ const Word16 formant_enh, /* i : formant enhancement factor Q15 */
+ Word16 *seed_acelp, /*i/o : random seed Q0 */
+ const Word16 shift
+);
+
+void gaus_L2_dec(
+ Word16 *code, /* o : decoded gaussian codevector Q9 */
+ Word16 tilt_code, /* i : tilt of code Q15 */
+ const Word16 *A, /* i : quantized LPCs Q12 */
+ Word16 formant_enh, /* i : formant enhancement factor Q15 */
+ Word16 *seed_acelp /*i/o : random seed Q0 */
+);
+
+void tcx_ltp_get_lpc(
+ Word16 *x,
+ Word16 L,
+ Word16 *A,
+ Word16 order
+);
+
+void predict_signal(
+ const Word16 excI[], /* i : input excitation buffer */
+ Word16 excO[], /* o : output excitation buffer */
+ const Word16 T0, /* i : integer pitch lag */
+ Word16 frac, /* i : fraction of lag */
+ const Word16 frac_max, /* i : max fraction */
+ const Word16 L_subfr /* i : subframe size */
+);
+
+void tcx_ltp_pitch_search(
+ Word16 pitch_ol,
+ Word16 *pitch_int,
+ Word16 *pitch_fr,
+ Word16 *index,
+ Word16 *norm_corr,
+ const Word16 len,
+ Word16 *wsp,
+ Word16 pitmin,
+ Word16 pitfr1,
+ Word16 pitfr2,
+ Word16 pitmax,
+ Word16 pitres
+);
+
+void tcx_ltp_encode( Word8 tcxltp_on,
+ Word8 tcxOnly,
+ Word16 tcxMode,
+ Word16 L_frame,
+ Word16 L_subfr,
+ Word16 *speech,
+ Word16 *speech_ltp,
+ Word16 *wsp,
+ Word16 Top,
+ Word16 *ltp_param,
+ Word16 *ltp_bits,
+ Word16 *pitch_int,
+ Word16 *pitch_fr,
+ Word16 *gain,
+ Word16 *pitch_int_past,
+ Word16 *pitch_fr_past,
+ Word16 *gain_past,
+ Word16 *norm_corr_past,
+ Word16 last_core,
+ Word16 pitmin,
+ Word16 pitfr1,
+ Word16 pitfr2,
+ Word16 pitmax,
+ Word16 pitres,
+ struct TransientDetection const * pTransientDetection,
+ Word8 SideInfoOnly,
+ Word16 *A,
+ Word16 lpcorder
+ );
+
+void tcx_ltp_post( Word8 tcxltp_on,
+ Word16 core,
+ Word16 L_frame,
+ Word16 L_frame_core,
+ Word16 delay,
+ Word16 *sig,
+ Word16 *tcx_buf,
+ Word16 tcx_buf_len,
+ Word16 bfi,
+ Word16 pitch_int,
+ Word16 pitch_fr,
+ Word16 gain,
+ Word16 *pitch_int_past,
+ Word16 *pitch_fr_past,
+ Word16 *gain_past,
+ Word16 *filtIdx_past,
+ Word16 pitres,
+ Word16 *pitres_past,
+ Word16 damping,
+ Word16 SideInfoOnly,
+ Word16 *mem_in,
+ Word16 *mem_out,
+ Word32 bitrate
+ );
+
+Word16 tcx_ltp_decode_params( Word16 *ltp_param,
+ Word16 *pitch_int,
+ Word16 *pitch_fr,
+ Word16 *gain,
+ Word16 pitmin,
+ Word16 pitfr1,
+ Word16 pitfr2,
+ Word16 pitmax,
+ Word16 pitres
+ );
+
+/*isf_msvq_ma.c, lsf_msvq_ma.c*/
+void msvq_enc
+(
+ const Word16 *const*cb, /* i : Codebook (indexed cb[*stages][levels][p]) (0Q15) */
+ const Word16 dims[], /* i : Dimension of each codebook stage (NULL: full dim.) */
+ const Word16 offs[], /* i : Starting dimension of each codebook stage (NULL: 0) */
+ const Word16 u[], /* i : Vector to be encoded (prediction and mean removed)(14Q1*1.28) */
+ const Word16 *levels, /* i : Number of levels in each stage */
+ const Word16 maxC, /* i : Tree search size (number of candidates kept from */
+ /* one stage to the next == M-best) */
+ const Word16 stages, /* i : Number of stages */
+ const Word16 w[], /* i : Weights Q8 */
+ const Word16 N, /* i : Vector dimension */
+ const Word16 maxN, /* i : Codebook dimension */
+ Word16 Idx[] /* o : Indices */
+);
+void msvq_dec
+(
+ const Word16 *const*cb, /* i : Codebook (indexed cb[*stages][levels][p]) (0Q15) */
+ const Word16 dims[], /* i : Dimension of each codebook stage (NULL: full dim.) */
+ const Word16 offs[], /* i : Starting dimension of each codebook stage (NULL: 0) */
+ const Word16 stages, /* i : Number of stages */
+ const Word16 N, /* i : Vector dimension */
+ const Word16 maxN, /* i : Codebook dimension */
+ const Word16 Idx[], /* i : Indices */
+ Word16 *uq /* o : quantized vector (3Q12) */
+);
+
+
+/*-------------------------------------------------------------------------
+* Recovery tools for resynchronization
+*------------------------------------------------------------------------*/
+/*er_sync_exc.c*/
+/** Resynchronize glotal pulse positions of the signal in src_exc and store it in dst_exc.
+ * src_exc holds on call the harmonic part of the signal with the constant pitch, constructed by repeating the last pitch cycle of length pitchStart.
+ * dst_exc holds on return the harmonic part of the signal with the pitch changing from pitchStart to pitchEnd.
+ * src_exc and dst_exc can overlap, but src_exc < dst_exc must be fullfiled.
+ * @param src_exc Input excitation buffer.
+ * @param dst_exc Output excitation buffer.
+ * @param nFrameLength Length of the frame, that is the length of the valid data in the excitation buffer on return.
+ * @param nSubframes Number of subframes in the excitation buffer. nFrameLength must be divisible by nSubframes.
+ * @param pitchStart Pitch at the end of the last frame.
+ * @param pitchEnd Pitch at the end of the current frame.
+ */
+void PulseResynchronization(
+ Word16 /*float*/ const * const src_exc, /*i Q15*/
+ Word16 /*float*/ * const dst_exc, /*o Q15*/
+ Word16 /*int*/ const nFrameLength, /*i Q0 */
+ Word16 /*int*/ const nSubframes, /*i Q0 */
+ Word32 /*float*/ const pitchStart, /*i Q16*/
+ Word32 /*float*/ const pitchEnd /*i Q16*/
+);
+
+/* er_util.c*/
+/* PLC: [TCX: TD PLC]
+ * PLC: FindSubframePitchInTCX: function to find the pitch per half a frame for the last TCX */
+/*VERSIONINFO: This port is up to date with trunk rev. 30479*/
+/*VERSIONINFO: This port is up to date with trunk rev. 7611*/
+
+void con_acelp(
+ const Word16 A[], /*mem_syn >rescaling done */
+ , Word16 *pitch_buffer
+ , Word16 *voice_factors
+ , Word16 *bwe_exc
+);
+
+void con_tcx(
+ Decoder_State_fx *st, /* i/o: coder memory state */
+ Word16 /*float*/ synth[] /* i/o: synth[] *//*Q0 */
+);
+
+
+/* isf_msvq_ma.c */
+void isf_msvq_ma_enc(const Word16 *isf, /* i: isf coefficients (3Q12) */
+ Word16 *isfq, /* o: quantized isf */
+ Word16 *isfq_ind,
+ Word16 *indices, /* o: quantizer indices */
+ Word16 *nb_indices, /* o: number of bits for the indices */
+ Word16 *mem_MA, /* i/o: moving average filter buffer (3Q12) */
+ Word16 *parcorr,
+ const Word16 m, /* i: lpc order */
+ const Word16 acelp_mode, /* i: acelp mode */
+ const Word8 narrow_band /* i: narrow-band flag */
+ );
+void isf_msvq_ma_dec( Word16 *isfq,
+ Word16 *isfq_ind,
+ Word16 *indices,
+ Word16 *nb_indices,
+ Word16 *mem_MA,
+ Word16 m,
+ Word16 acelp_mode,
+ Word8 narrow_band /* i: narrow-band flag */
+ );
+Word16 isf_msvq_ma_encprm( Encoder_State_fx *st, Word16 *param_lpc, Word16 core, Word16 acelp_mode, Word16 acelp_midLpc, Word16 m );
+Word16 isf_msvq_ma_decprm( Decoder_State_fx *st, Word16 *param_lpc, Word16 core, Word16 acelp_mode, Word16 acelp_midLpc, Word16 m );
+
+/* Returns: non-zero on conversion error, 0 otherwise */
+Word16 E_LPC_lsp_unweight(
+ /* const */ Word16 xsp_w[], /* (I): weighted xSP */
+ Word16 xsp_uw[], /* (O): unweighted xSP */
+ Word16 xsf_uw[], /* (O): unweighted xSF */
+ Word16 inv_gamma, /* (I): inverse weighting factor */
+ Word16 lpcorder /* (I): prediction order */
+);
+
+Word16 lsf_ind_is_active(
+ const Word16 lsf_q_ind[],
+ const Word16 means[],
+ Word16 bandwidth,
+ Word16 cdk);
+
+void lsf_update_memory(
+ Word16 narrowband, /* i : narrowband flag */
+ const Word16 qisf[], /* i : quantized xSF coefficients */
+ Word16 old_mem_MA[], /* i : MA memory */
+ Word16 mem_MA[], /* o : updated MA memory */
+ Word16 lpcorder /* i : LPC order */
+);
+
+/* Returns: number of indices */
+Word16 Q_lsf_tcxlpc(
+ /* const */ Word16 xsf[], /* (I) original xSF */
+ Word16 xsf_q[], /* (O) quantized xSF */
+ Word16 xsf_q_ind[], /* (O) quantized xSF (w/o MA prediction) */
+ Word16 indices[], /* (O) VQ indices */
+ Word16 lpcorder, /* (I) LPC order */
+ Word16 narrowband, /* (I) narrowband flag */
+ Word16 cdk, /* (I) codebook selector */
+ Word16 mem_MA[], /* (I) MA memory */
+ Word16 coder_type,
+ Word32 * Bin_Ener,
+ const Word16 Q_ener
+);
+
+/* Returns: number of indices */
+Word16 D_lsf_tcxlpc(
+ const Word16 indices[], /* (I) VQ indices */
+ Word16 xsf_q[], /* (O) quantized xSF */
+ Word16 xsf_q_ind[], /* (O) quantized xSF (w/o MA prediction) */
+ Word16 narrowband, /* (I) narrowband flag */
+ Word16 cdk, /* (I) codebook selector */
+ Word16 mem_MA[] /* (I) MA memory */
+);
+
+/* Returns: number of bits written */
+Word16 enc_lsf_tcxlpc(
+ Word16 **indices, /* (I) Ptr to VQ indices */
+ Encoder_State_fx *st /* (I/O) Encoder state */
+);
+
+/* Returns: number of bits read */
+Word16 dec_lsf_tcxlpc(
+ Decoder_State_fx *st, /* (I/O) Decoder state */
+ Word16 **indices, /* (O) Ptr to VQ indices */
+ Word16 narrowband, /* (I) narrowband flag */
+ Word16 cdk /* (I) codebook selector */
+);
+
+/* Returns: codebook index */
+Word16 tcxlpc_get_cdk(
+ Word16 coder_type /* (I) VOICED indicator */
+);
+
+/* lsf_msvq_ma.c */
+void lsf_msvq_ma_enc(
+ const Word16 *lsf, /* i: lsf coefficients (14Q1*1.28)*/
+ Word16 *lsfq, /* o: quantized lsf */
+ Word16 *lsfq_ind,
+ Word32 * Bin_Ener_128_fx,
+ const Word16 Q_ener,
+ Word16 *indices, /* o: quantizer indices */
+ Word16 *nb_indices, /* o: number of bits for the indices */
+ Word16 *mem_MA, /* i/o: moving average filter buffer (3Q12*1.28)*/
+ const Word16 m, /* i: lpc order */
+ const Word16 acelp_mode /* i: acelp mode */
+);
+
+void lsf_msvq_ma_dec( Word16 *lsfq,
+ Word16 *lsfq_ind,
+ Word16 *indices,
+ Word16 *nb_indices,
+ Word16 *mem_MA,
+ Word16 m,
+ Word16 acelp_mode
+ );
+
+Word16 lsf_msvq_ma_encprm( Encoder_State_fx * st,
+ Word16 *param_lpc,
+ Word16 core,
+ Word16 acelp_mode,
+ Word16 acelp_midLpc,
+ Word16 * bits_param_lpc,
+ Word16 no_indices
+ );
+Word16 lsf_msvq_ma_decprm( Decoder_State_fx *st, Word16 *param_lpc, Word16 core, Word16 acelp_mode, Word16 acelp_midLpc
+ ,Word16 narrowBand
+ ,Word32 sr_core
+ );
+
+Word16 lsf_bctcvq_encprm(
+ Encoder_State_fx *st,
+ Word16 *param_lpc,
+ Word16 * bits_param_lpc,
+ Word16 no_indices
+);
+
+Word16 lsf_bctcvq_decprm(
+ Decoder_State_fx * st,
+ Word16 *param_lpc
+);
+void lpc_unquantize(
+ Decoder_State_fx * st,
+ Word16 *lsfold,
+ Word16 *lspold,
+ Word16 *lsf,
+ Word16 *lsp,
+ const Word16 m,
+ const Word16 lpcQuantization,
+ Word16 *param_lpc,
+ const Word16 numlpc,
+ const Word16 core,
+ Word16 *mem_MA,
+ Word16 *mem_AR,
+ Word16 *lspmid,
+ Word16 *lsfmid,
+ Word16 coder_type,
+ Word16 acelp_midLpc,
+ Word8 narrow_band,
+ Word16 *seed_acelp,
+ Word32 sr_core,
+ Word16 *mid_lsf_int,
+ Word16 prev_bfi,
+ Word16 *LSF_Q_prediction, /* o : LSF prediction mode */
+ Word16 *safety_net
+);
+
+void midlsf_enc(const Word16 qlsf0[], /* i: quantized lsf coefficients (3Q12) */
+ const Word16 qlsf1[], /* i: quantized lsf coefficients (3Q12) */
+ const Word16 lsf[], /* i: lsf coefficients (3Q12) */
+ Word16 *idx, /* o: codebook index */
+ const Word16 lpcorder /* i: order of the lpc */
+ , Word32 * Bin_Ener_128_fx
+ ,const Word16 Q_ener
+ ,Word8 narrowBand
+ ,Word32 sr_core
+ ,Word16 coder_type
+ );
+
+
+void midlsf_dec(
+ const Word16 qlsf0[], /* i: quantized lsf coefficients (3Q12) */
+ const Word16 qlsf1[], /* i: quantized lsf coefficients (3Q12) */
+ Word16 idx, /* i: codebook index */
+ Word16 qlsf[], /* o: decoded lsf coefficients (3Q12) */
+ Word16 coder_type,
+ Word16 *mid_lsf_int,
+ Word16 prev_bfi,
+ Word16 safety_net);
+
+
+Word16 const * PlcGetLsfBase (Word16 const lpcQuantization,
+ Word16 const narrowBand,
+ Word32 const sr_core);
+
+/* tcx_mdct.h */
+#define MDCT_A_E 1
+
+#define TCX_IMDCT_SCALE 15
+#define TCX_IMDCT_HEADROOM 1
+
+void TCX_MDCT(const Word16 *x, Word32 *y, Word16 *y_e, Word16 l, Word16 m, Word16 r);
+
+void TCX_MDST(const Word16 *x, Word32 *y, Word16 *y_e, Word16 l, Word16 m, Word16 r);
+
+void TCX_MDCT_Inverse(Word32 *x, Word16 x_e, Word16 *y, Word16 l, Word16 m, Word16 r);
+
+
+/* post_dec.h */
+void post_decoder(
+ Decoder_State_fx *st,
+ Word16 coder_type,
+ Word16 synth_buf[],
+ Word16 pit_gain[],
+ Word16 pitch[],
+ Word16 signal_out[],
+ Word16 * bpf_noise_buf
+);
+
+Word16 bass_pf_enc(
+ Word16 *orig, /* (i) : 12.8kHz original signal Q0 */
+ Word16 *syn, /* (i) : 12.8kHz synthesis to postfilter Q0 */
+ Word16 *T_sf, /* (i) : Pitch period for all subframes (T_sf[16]) Q0 */
+ Word16 *gainT_sf, /* (i) : Pitch gain for all subframes (gainT_sf[16]) Q14 */
+ Word16 l_frame, /* (i) : frame length (should be multiple of l_subfr) Q0 */
+ Word16 l_subfr, /* (i) : sub-frame length (60/64) Q0 */
+ Word16 *gain_factor_param, /* (o) : quantized gain factor Q0 */
+ Word16 mode, /* (i) : coding mode of adapt bpf */
+ struct MEM_BPF *mem_bpf /* i/o : memory state */
+);
+void cldfb_synth_set_bandsToZero(
+ Decoder_State_fx *st,
+ Word32 **rAnalysis,
+ Word32 **iAnalysis,
+ const Word16 nTimeSlots,
+ const CLDFB_SCALE_FACTOR scaleFactor
+);
+/* fd_cng_common.h */
+/* Create an instance of type FD_CNG */
+void createFdCngCom(HANDLE_FD_CNG_COM* hFdCngCom);
+
+void initFdCngCom(HANDLE_FD_CNG_COM hFdCngCom, Word16 scale);
+
+/* Delete the instance of type FD_CNG */
+void deleteFdCngCom(HANDLE_FD_CNG_COM * hFdCngCom);
+
+void resetFdCngEnc( Encoder_State_fx * st);
+
+/* Initialize the spectral partitioning */
+void initPartitions( const Word16* part_in,
+ Word16 npart_in,
+ Word16 startBand,
+ Word16 stopBand,
+ Word16* part_out,
+ Word16* npart_out,
+ Word16* midband,
+ Word16* psize,
+ Word16* psize_norm,
+ Word16* psize_norm_exp,
+ Word16* psize_inv,
+ Word16 stopBandFR);
+
+/* Noise estimation using Minimum Statistics (MS) */
+void compress_range(Word32 *in,
+ Word16 in_exp,
+ Word16 *out,
+ Word16 len
+ );
+
+void expand_range(Word16 *in,
+ Word32 *out,
+ Word16 *out_exp,
+ Word16 len
+ );
+
+void minimum_statistics(Word16 len, /* i : Total number of partitions (CLDFB or FFT) */
+ Word16 lenFFT, /* i : Number of FFT partitions */
+ Word16 *psize, /* i : Partition sizes, fractional */
+ Word16 *msPeriodog, /* i : Periodogram (energies) */
+ Word16 *msNoiseFloor, /* i/o: Noise floors (energies) */
+ Word16 *msNoiseEst, /* i/o: Noise estimates (energies) */
+ Word32 *msAlpha, /* i/o: Forgetting factors */
+ Word16 *msPsd, /* i/o: Power Spectral Density (smoothed periodogram => energies) */
+ Word16 *msPsdFirstMoment, /* i/o: PSD statistics of 1st order (energy means) */
+ Word32 *msPsdSecondMoment, /* i/o: PSD statistics of 2nd order (energy variances) */
+ Word32 *msMinBuf, /* i/o: Buffer of minima (energies) */
+ Word32 *msBminWin, /* o : Bias correction factors */
+ Word32 *msBminSubWin, /* o : Bias correction factors */
+ Word32 *msCurrentMin, /* i/o: Local minima (energies) */
+ Word32 *msCurrentMinOut, /* i/o: Local minima (energies) */
+ Word32 *msCurrentMinSubWindow, /* i/o: Local minima (energies) */
+ Word16 *msLocalMinFlag, /* i : Binary flag */
+ Word16 *msNewMinFlag, /* i : Binary flag */
+ Word16 *msPeriodogBuf, /* i/o: Buffer of periodograms (energies) */
+ Word16 *msPeriodogBufPtr, /* i/o: Counter */
+ HANDLE_FD_CNG_COM st /* i/o: FD_CNG structure containing buffers and variables */
+ );
+
+/* Generate the comfort noise based on the target noise level */
+void generate_comfort_noise_enc (Encoder_State_fx *stcod,
+ Word16 Q_new,
+ Word16 gen_exc
+ );
+void generate_comfort_noise_dec (Word32 **bufferReal, /* o : matrix to real part of input bands */
+ Word32 **bufferImag, /* o : matrix to imaginary part of input bands */
+ Word16 *bufferScale, /* o : pointer to scalefactor for real and imaginary part of input bands */
+ Decoder_State_fx *stdec,
+ Word16 *Q_new,
+ Word16 gen_exc
+ );
+void
+generate_comfort_noise_dec_hf (Word32 **bufferReal, /* o : matrix to real part of input bands */
+ Word32 **bufferImag, /* o : matrix to imaginary part of input bands */
+ Word16 *bufferScale, /* o : pointer to scalefactor for real and imaginary part of input bands */
+ Decoder_State_fx *stdec
+ );
+
+/* Generate the comfort noise based on the target noise level */
+void generate_masking_noise (Word16 *timeDomainBuffer, /* i/o: time-domain signal */
+ Word16 Q,
+ HANDLE_FD_CNG_COM st /* i/o: FD_CNG structure containing all buffers and variables */
+ ,Word16 length
+ ,Word16 core
+ );
+
+void generate_masking_noise_update_seed (
+ HANDLE_FD_CNG_COM st /* i/o : pointer to FD_CNG_COM structure */
+);
+
+void generate_masking_noise_mdct (Word32 *mdctBuffer, /* i/o: time-domain signal */
+ Word16 *mdctBuffer_e, /* i/o: exponent time-domain signal */
+ HANDLE_FD_CNG_COM st /* i/o: FD_CNG structure containing all buffers and variables */
+ ,Word16 L_frame
+ );
+
+/* Apply bitrate-dependant scale */
+void apply_scale(Word32 *scale,
+ Word16 bwmode,
+ Word32 bitrate
+ );
+
+/* Compute the power for each partition */
+void bandcombinepow(Word32* bandpow, /* i : Power for each band */
+ Word16 exp_bandpow, /* i : exponent of bandpow */
+ Word16 nband, /* i : Number of bands */
+ Word16* part, /* i : Partition upper boundaries (band indices starting from 0) */
+ Word16 npart, /* i : Number of partitions */
+ Word16* psize_inv, /* i : Inverse partition sizes */
+ Word32* partpow, /* o : Power for each partition */
+ Word16* exp_partpow
+ );
+
+/* Scale partitions (with smoothing) */
+void scalebands (Word32 *partpow, /* i : Power for each partition */
+ Word16 *part, /* i : Partition upper boundaries (band indices starting from 0) */
+ Word16 npart, /* i : Number of partitions */
+ Word16 *midband, /* i : Central band of each partition */
+ Word16 nFFTpart, /* i : Number of FFT partitions */
+ Word16 nband, /* i : Number of bands */
+ Word32 *bandpow, /* o : Power for each band */
+ Word16 flag_fft_en
+ );
+
+/* Get central band for each partition */
+void getmidbands(Word16* part, /* i : Partition upper boundaries (band indices starting from 0) */
+ Word16 npart, /* i : Number of partitions */
+ Word16* midband, /* o : Central band of each partition */
+ Word16* psize, /* o : Partition sizes */
+ Word16* psize_norm, /* o : Partition sizes, fractional values */
+ Word16* psize_norm_exp, /* o : Exponent for fractional partition sizes */
+ Word16* psize_inv /* o : Inverse of partition sizes */
+ );
+
+/* STFT analysis filterbank */
+void AnalysisSTFT (const Word16 *timeDomainInput, /* i : pointer to time signal */
+ Word16 Q,
+ Word32 *fftBuffer, /* o : FFT bins */
+ Word16 *fftBuffer_exp, /* i : exponent of FFT bins */
+ HANDLE_FD_CNG_COM st /* i/o: FD_CNG structure containing all buffers and variables */
+ );
+
+/* STFT synthesis filterbank */
+void SynthesisSTFT (Word32 *fftBuffer, /* i : pointer to FFT bins */
+ Word16 fftBufferExp, /* i : exponent of FFT bins */
+ Word16 *timeDomainOutput, /* o : pointer to time domain signal */
+ Word16 *olapBuffer, /* i/o : pointer to overlap buffer */
+ const PWord16 *olapWin, /* i : pointer to overlap window */
+ Word16 tcx_transition,
+ HANDLE_FD_CNG_COM st, /* i/o : pointer to FD_CNG structure containing all buffers and variables */
+ Word16 gen_exc,
+ Word16 *Q_new
+ );
+
+/* Compute some calues used in the bias correction of the minimum statistics algorithm */
+void mhvals(Word16 d, Word16 * m/*, float * h*/);
+
+/* Random generator with Gaussian distribution with mean 0 and std 1 */
+Word32 rand_gauss (Word16 *seed);
+
+void lpc_from_spectrum (Word32 *powspec,
+ Word16 powspec_exp,
+ Word16 start,
+ Word16 stop,
+ Word16 fftlen,
+ Word16 *A,
+ Word16 lpcorder,
+ Word16 preemph_fac);
+
+void msvq_decoder(const Word16 *const cb[], /* i : Codebook (indexed cb[*stages][levels][p]) */
+ Word16 stages, /* i : Number of stages */
+ Word16 N, /* i : Vector dimension */
+ Word16 maxN, /* i : Codebook vector dimension */
+ Word16 Idx[], /* i : Indices */
+ Word16 *uq /* o : quantized vector */
+ );
+
+/*fd_cng_dec.h*/
+/* Create an instance of type FD_CNG */
+void createFdCngDec(HANDLE_FD_CNG_DEC* hFdCngDec);
+
+Word16 initFdCngDec(HANDLE_FD_CNG_DEC hFdCngDec, Word16 scale);
+extern void E_LPC_isf_isp_conversion(const Word16 isf[], Word16 isp[], const Word16 m);
+extern void E_LPC_f_isp_a_conversion(const Word16 *isp, Word16 *a, const Word16 m);
+
+/* Delete the instance of type FD_CNG */
+void deleteFdCngDec(HANDLE_FD_CNG_DEC * hFdCngDec);
+
+/* Configure CLDFB-CNG */
+void configureFdCngDec(HANDLE_FD_CNG_DEC hs, /* i/o: Contains the variables related to the CLDFB-based CNG process */
+ Word16 bandwidth,
+ Word32 bitrate,
+ Word16 cng_type);
+
+
+/* Apply the CLDFB-based CNG */
+Word16 ApplyFdCng (Word16 * timeDomainInput, /* i : pointer to time domain input */
+ Word16 Q,
+ Word32 ** cldfbBufferReal, /* i/o: real part of the CLDFB buffer */
+ Word32 ** cldfbBufferImag, /* i/o: imaginary part of the CLDFB buffer */
+ Word16 * cldfbBufferScale, /* o : pointer to the scalefactor for real and imaginary part of the CLDFB buffer */
+ HANDLE_FD_CNG_DEC st, /* i/o: pointer to FD_CNG structure containing all buffers and variables */
+ Word16 m_frame_type, /* i : type of frame at the decoder side */
+ Decoder_State_fx *stdec,
+ const Word16 concealWholeFrame, /* i : binary flag indicating frame loss */
+ Word16 is_music
+ );
+
+/* Perform noise estimation */
+void perform_noise_estimation_dec(const Word16 *timeDomainInput, /* i: pointer to time domain input */
+ Word16 Q,
+ HANDLE_FD_CNG_DEC st /* i/o: FD_CNG structure containing all buffers and variables */
+ );
+
+/* Decode the CLDFB-CNG bitstream */
+void FdCng_decodeSID(HANDLE_FD_CNG_COM st, /* i/o: FD_CNG structure containing all buffers and variables */
+ Decoder_State_fx *corest); /* i/o: decoder state structure */
+
+void FdCng_exc(
+ HANDLE_FD_CNG_COM hs,
+ Word16 *CNG_mode,
+ Word16 L_frame,
+ Word16 *lsp_old,
+ Word16 first_CNG,
+ Word16 *lsp_CNG,
+ Word16 *Aq, /* o: LPC coeffs */
+ Word16 *lsp_new, /* o: lsp */
+ Word16 *lsf_new, /* o: lsf */
+ Word16 *exc, /* o: LP excitation */
+ Word16 *exc2, /* o: LP excitation */
+ Word16 *bwe_exc /* o: LP excitation for BWE */
+);
+
+void noisy_speech_detection(
+ const Word16 vad,
+ const Word16 *ftimeInPtr, /* i : input time-domain frame */
+ const Word16 frameSize, /* i : frame size */
+ const Word16 Q,
+ const Word32 *msNoiseEst, /* i : noise estimate over all critical bands */
+ const Word16 msNoiseEst_exp, /* i : exponent for noise estimate over all critical bands */
+ const Word16 *psize_norm,
+ const Word16 psize_norm_exp,
+ const Word16 nFFTpart, /* i : Number of partitions taken into account */
+ Word32 *lp_noise, /* i/o: pointer to long term total Noise energy average */
+ Word32 *lp_speech, /* i/o: pointer to long term active speech energy average */
+ Word16 *flag_noisy_speech
+);
+
+/* Create an instance of type FD_CNG */
+void createFdCngEnc(HANDLE_FD_CNG_ENC* hFdCngEnc);
+
+void initFdCngEnc(HANDLE_FD_CNG_ENC hsEnc, Word32 input_Fs, Word16 scale);
+
+/* Delete the instance of type FD_CNG */
+void deleteFdCngEnc(HANDLE_FD_CNG_ENC * hFdCngEnc);
+
+/* Configure CLDFB-CNG */
+void configureFdCngEnc(HANDLE_FD_CNG_ENC hs, /* i/o: Contains the variables related to the CLDFB-based CNG process */
+ Word16 bandwidth, /* i: bandwidth */
+ Word32 bitrate);
+
+/* Perform noise estimation */
+void perform_noise_estimation_enc(
+ Word32 *band_energies, /* i: energy in critical bands without minimum noise floor MODE2_E_MIN */
+ Word16 exp_band_energies,
+ Word32 *enerBuffer,
+ Word16 enerBuffer_exp,
+ HANDLE_FD_CNG_ENC st); /* i/o: FD_CNG structure containing all buffers and variables */
+
+/* Adjust the noise estimator at the beginning of each CNG phase (encoder-side) */
+Word16
+AdjustFirstSID(Word16 npart,
+ Word32 *msPeriodog,
+ Word16 msPeriodog_exp,
+ Word32 *energy_ho,
+ Word16 *energy_ho_exp,
+ Word32 *msNoiseEst,
+ Word16 *msNoiseEst_exp,
+ Word32 *msNoiseEst_old,
+ Word16 *msNoiseEst_old_exp,
+ Word16 *active_frame_counter,
+ Encoder_State_fx *stcod
+ );
+
+/* Generate a bitstream out of the partition levels */
+void FdCng_encodeSID (HANDLE_FD_CNG_ENC st, /* i/o: FD_CNG structure containing all buffers and variables */
+ Encoder_State_fx *corest,
+ Word16 preemph_fac /* i : preemphase factor */
+ );
+
+/*parameter_bitmaping.h*/
+/** Writes parameters from paramsBitMap into a stream.
+ * @param paramsBitMap Definition of parameters and mappings to a bitstream.
+ * @param nParam Size of paramsBitMap.
+ * @param pParameter A parameter to be used in get and set functions from paramsBitMap.
+ * @param pStream Pointer to a stream where parameters should be stored.
+ * @param pnSize Set to the number of elements written to the stream.
+ * @param pnBits Set to the number of required bits.
+ */
+void GetParameters(ParamsBitMap const * paramsBitMap, Word16 nParams, void const * pParameter, Word16 ** pStream, Word16 * pnSize, Word16 * pnBits);
+
+/** Reads parameters from a stream into paramsBitMap.
+ * @param paramsBitMap Definition of parameters and mappings to a bitstream.
+ * @param nParam Size of paramsBitMap.
+ * @param pParameter A parameter to be used in get and set functions from paramsBitMap.
+ * @param pStream Pointer to a stream from which parameters are read.
+ * @param pnSize Set to the number of elements read from the stream.
+ */
+void SetParameters(ParamsBitMap const * paramsBitMap, Word16 nParams, void * pParameter, Word16 const ** pStream, Word16 * pnSize);
+
+/** Writes parameters from a stream into a bitstream.
+ * @param paramsBitMap Definition of parameters and mappings to a bitstream.
+ * @param nParam Size of paramsBitMap.
+ * @param pStream Pointer to a stream from which parameters are read.
+ * @param pnSize Set to the number of elements read from the stream.
+ * @param st Encoder state.
+ * @param pnBits Set to the number of bits written.
+ */
+void WriteToBitstream(ParamsBitMap const * paramsBitMap, Word16 nParams, Word16 const ** pStream, Word16 * pnSize, Encoder_State_fx *st, Word16 * pnBits);
+
+/** Reads parameters from a bitstream into a stream.
+ * @param paramsBitMap Definition of parameters and mappings to a bitstream.
+ * @param nArrayLength Size of paramsBitMap.
+ * @param st Decoder state.
+ * @param pStream Pointer to a stream where parameters should be stored.
+ * @param pnSize Set to the number of elements written to the stream.
+ */
+void ReadFromBitstream(ParamsBitMap const * paramsBitMap, Word16 nArrayLength, Decoder_State_fx *st, Word16 ** pStream, Word16 * pnSize);
+
+void const * GetTnsFilterOrder(void const * p, Word16 index, Word16 * pValue);
+void * SetTnsFilterOrder(void * p, Word16 index, Word16 value);
+void const * GetNumOfTnsFilters(void const * p, Word16 index, Word16 * pValue);
+void * SetNumOfTnsFilters(void * p, Word16 index, Word16 value);
+void const * GetTnsEnabled(void const * p, Word16 index, Word16 * pValue);
+void * SetTnsEnabled(void * p, Word16 index, Word16 value);
+void const * GetTnsEnabledSingleFilter(void const * p, Word16 index, Word16 * pValue);
+void * SetTnsEnabledSingleFilter(void * p, Word16 index, Word16 value);
+void const * GetTnsFilterCoeff(void const * p, Word16 index, Word16 * pValue);
+void * SetTnsFilterCoeff(void * p, Word16 index, Word16 value);
+
+
+Word16 GetSWBTCX10TnsFilterCoeffBits(Word16 value, Word16 index);
+Word16 EncodeSWBTCX10TnsFilterCoeff(Word16 value, Word16 index);
+Word16 DecodeSWBTCX10TnsFilterCoeff(Decoder_State_fx *st, Word16 index, Word16 * pValue);
+Word16 GetSWBTCX20TnsFilterCoeffBits(Word16 value, Word16 index);
+Word16 EncodeSWBTCX20TnsFilterCoeff(Word16 value, Word16 index);
+Word16 DecodeSWBTCX20TnsFilterCoeff(Decoder_State_fx *st, Word16 index, Word16 * pValue);
+
+Word16 GetWBTCX20TnsFilterCoeffBits(Word16 value, Word16 index);
+Word16 EncodeWBTCX20TnsFilterCoeff(Word16 value, Word16 index);
+Word16 DecodeWBTCX20TnsFilterCoeff(Decoder_State_fx *st, Word16 index, Word16 * pValue);
+
+Word16 GetTnsFilterOrderBitsSWBTCX10(Word16 value, Word16 index);
+Word16 EncodeTnsFilterOrderSWBTCX10(Word16 value, Word16 index);
+Word16 DecodeTnsFilterOrderSWBTCX10(Decoder_State_fx *st, Word16 index, Word16 * pValue);
+Word16 GetTnsFilterOrderBitsSWBTCX20(Word16 value, Word16 index);
+Word16 EncodeTnsFilterOrderSWBTCX20(Word16 value, Word16 index);
+Word16 DecodeTnsFilterOrderSWBTCX20(Decoder_State_fx *st, Word16 index, Word16 * pValue);
+Word16 GetTnsFilterOrderBits(Word16 value, Word16 index);
+Word16 EncodeTnsFilterOrder(Word16 value, Word16 index);
+Word16 DecodeTnsFilterOrder(Decoder_State_fx *st, Word16 index, Word16 * pValue);
+
+
+/*tns_base.h*/
+/** Reset TNS data.
+ * Resets TNS data to the initial state.
+ * @param pTnsData pointer to a TNS data to be reset.
+ */
+void ResetTnsData(STnsData * pTnsData);
+
+/** Clear TNS filter data.
+ * Resets TNS filter order and all coefficients to 0.
+ * @param pTnsFilter pointer to a TNS filter to be cleared.
+ */
+void ClearTnsFilterCoefficients(STnsFilter * pTnsFilter);
+
+/** Init TNS configuration.
+ * Fills STnsConfig structure with sensible content.
+ * @param nSampleRate Sampling rate of the input.
+ * @param nFrameLength Frame length.
+ * @param pTnsConfig TNS configuration to be initialized.
+ * @return 0 on success, otherwise 1.
+ */
+Word16 InitTnsConfiguration(Word32 nSampleRate,
+ Word16 frameLength,
+ STnsConfig * pTnsConfig
+ ,Word16 igfStopFreq
+ ,Word32 bitrate
+ );
+
+/** Detect TNS parameters.
+ * Detects if TNS should be used and fills TNS data in pTnsData.
+ * @param pTnsConfig TNS configuration.
+ * @param pSpectrum Spectrum lines.
+ TNS is tested on the spectrum defined by pSpectrum.
+ * @param sbCnt Number of active subbands.
+ * @param pTnsData TNS data is filled with sensible information.
+ * @return Returns 1 if Tns should be used, otherwise 0.
+ */
+Word16 DetectTnsFilt(STnsConfig const * pTnsConfig,
+ Word32 const pSpectrum[],
+ STnsData * pTnsData,
+ Word16 *predictionGain);
+
+/** Modify spectrum using TNS filter.
+ * Modifies spectrum unsing TNS filter defined by pTnsData.
+ * If fIsAnalyses is true considers spectrum to be
+ * an input of encoder and returns residum.
+ * If fIsAnalyses is false considers spectrum to be
+ * a residum from decoder and returns output spectrum.
+ * @param pTnsConfig TNS configuration.
+ * @param pTnsData TNS data describing filters.
+ * @param spectrum Input/output spectrum.
+ * @param fIsAnalysis Defines if TNS filter is applied
+ * in encoder (TRUE) or in decoder (FALSE).
+ * @return 0 on success, otherwise 1.
+ */
+Word16 ApplyTnsFilter(STnsConfig const * pTnsConfig,
+ STnsData const * pTnsData,
+ Word32 spectrum[],
+ Word8 fIsAnalysis);
+
+Word16 ITF_Detect_fx(Word32 const pSpectrum[],
+ Word16 startLine,
+ Word16 stopLine,
+ Word16 maxOrder,
+ Word16* A,
+ Word16* Q_A,
+ Word16* predictionGain,
+ Word16* curr_order,
+ Word16 Q);
+
+TNS_ERROR ITF_Apply_fx(Word32 spectrum[],
+ Word16 startLine, Word16 stopLine, const Word16* A,
+ Word16 Q_A,
+ Word16 curr_order);
+
+/** Write TNS data into a stream of integers.
+ * Writes TNS data into a stream of integers.
+ * @param pTnsConfig TNS configuration.
+ * @param pTnsData TNS data to be written to a bitstream.
+ * @param stream Output stream of integers.
+ * @param pnSize Set to the number of elements written to the stream.
+ * @param pnBits Set to the number of required.
+ * @return 0 on success, otherwise 1.
+ */
+Word16 EncodeTnsData(STnsConfig const * pTnsConfig,
+ STnsData const * pTnsData,
+ Word16 * stream,
+ Word16 * pnSize,
+ Word16 * pnBits);
+
+/** Read TNS data from a stream of integers.
+ * Reads TNS data from a stream of integers.
+ * @param pTnsConfig TNS configuration.
+ * @param stream Input stream of integers.
+ * @param pnSize Set to the number of elements read from stream.
+ * @param pTnsData TNS data to be read from the bitstream.
+ * @return 1 if TNS is active, otherwise 0.
+ */
+Word16 DecodeTnsData(STnsConfig const * pTnsConfig,
+ Word16 const * stream,
+ Word16 * pnSize,
+ STnsData * pTnsData);
+
+/** Write TNS data into a bitstream.
+ * Writes TNS data into a bitstream.
+ * @param pTnsConfig TNS configuration.
+ * @param stream Contains TNS data written with EncodeTnsData.
+ * @param pnSize Set to the number of used elements from stream.
+ * @param st Encoder state.
+ * @param pnBits Set to the number of bits written.
+ * @return 0 on success, otherwise 1.
+ */
+Word16 WriteTnsData(STnsConfig const * pTnsConfig,
+ Word16 const * stream,
+ Word16 * pnSize,
+ Encoder_State_fx *st,
+ Word16 * pnBits);
+
+/** Read TNS data from a bitstream.
+ * Reads TNS data from a bitstream using bin2int.
+ * @param pTnsConfig TNS configuration.
+ * @param st Decoder state.
+ * @param pnBits Set to the number of bits written.
+ * @param stream Contains TNS data that can be decoded with DecodeTnsData.
+ * @param pnSize Set to the number of used elements from stream.
+ * @return 0 on success, otherwise 1.
+ */
+Word16 ReadTnsData(STnsConfig const * pTnsConfig,
+ Decoder_State_fx *st,
+ Word16 * pnBits,
+ Word16 * stream,
+ Word16 * pnSize);
+
+Word16
+CLDFB_getNumChannels(Word32 sampleRate);
+
+void
+cldfbAnalysisFiltering( HANDLE_CLDFB_FILTER_BANK anaCldfb, /*!< Handle of Cldfb Analysis Bank */
+ Word32 **cldfbReal, /*!< Pointer to real subband slots */
+ Word32 **cldfbImag, /*!< Pointer to imag subband slots */
+ CLDFB_SCALE_FACTOR *scaleFactor, /*!< Scale factors of CLDFB data */
+ const Word16 *timeIn, /*!< Time signal */
+ const Word16 timeIn_e, /*!< Time signal */
+ const Word16 nTimeSlots, /*!< Time slots to be processed */
+ Word32 *pWorkBuffer /*!< pointer to temporal working buffer */
+ );
+
+void
+cldfbSynthesisFiltering(HANDLE_CLDFB_FILTER_BANK synCldfb, /*!< Handle of Cldfb Synthesis Bank */
+ Word32 **CldfbBufferReal, /*!< Pointer to 32 bit real subband slots */
+ Word32 **CldfbBufferImag, /*!< Pointer to 32 bit imag subband slots */
+ const CLDFB_SCALE_FACTOR *scaleFactor, /*!< Scale factors of CLDFB data */
+ Word16 *timeOut, /*!< Time signal */
+ const Word16 timeOut_e, /*!< Target exponent for output signal */
+ const Word16 nTimeSlots, /*!< number of time slots to be processed */
+ Word32 *pWorkBuffer /*!< pointer to temporal working buffer */
+ );
+
+Word16
+cldfbInitAnalysisFilterBank(HANDLE_CLDFB_FILTER_BANK h_Cldfb, /*!< CLDFB Handle */
+ Word16 *pFilterStates, /*!< Pointer to filter state buffer */
+ Word16 frameSize, /*!< FrameSize */
+ Word16 lsb, /*!< Number of lower bands */
+ Word16 usb, /*!< Number of upper bands */
+ Word16 no_channels, /*!< Number of critically sampled bands */
+ UWord16 flags /*!< Flags */
+ );
+
+void
+cldfbAnalysisFilteringSlot(HANDLE_CLDFB_FILTER_BANK anaCldfb, /*!< Handle of Cldfb Synthesis Bank */
+ Word32 *cldfbReal, /*!< Low and High band, real */
+ Word32 *cldfbImag, /*!< Low and High band, imag */
+ Word32 *pWorkBuffer /*!< pointer to temporal working buffer */
+ );
+
+Word16
+cldfbInitSynthesisFilterBank(HANDLE_CLDFB_FILTER_BANK h_Cldfb, /*!< CLDFB Handle */
+ Word16 *pFilterStates, /*!< Pointer to filter state buffer */
+ Word16 noCols, /*!< Number of time slots */
+ Word16 lsb, /*!< Number of lower bands */
+ Word16 usb, /*!< Number of upper bands */
+ Word16 no_channels, /*!< Number of critically sampled bands */
+ UWord16 flags /*!< Flags */
+ );
+
+void cldfbSynthesisFilteringSlot(HANDLE_CLDFB_FILTER_BANK synCldfb,
+ const Word32 *realSlot,
+ const Word32 *imagSlot,
+ const Word16 scaleFactorLowBand,
+ const Word16 scaleFactorHighBand,
+ Word16 *timeOut,
+ const Word16 stride,
+ Word32 *pWorkBuffer
+ );
+
+
+void configureCldfb ( HANDLE_CLDFB_FILTER_BANK h_cldfb, /*!< CLDFB Handle */
+ const Word16 no_channels, /*!< Number of critically sampled bands */
+ const Word16 frameSize /*!< FrameSize */
+ );
+
+void openCldfb ( HANDLE_CLDFB_FILTER_BANK *h_cldfb, /*!< CLDFB Handle */
+ const Word16 type, /*!< analysis or synthesis */
+ const Word16 maxCldfbBands, /*!< number of cldfb bands */
+ const Word16 frameSize /*!< FrameSize */
+ );
+
+void resampleCldfb (
+ HANDLE_CLDFB_FILTER_BANK hs, /*!< CLDFB Handle */
+ const Word16 newCldfbBands, /*!< number of cldfb bands */
+ const Word16 frameSize, /*!< FrameSize */
+ const Word8 firstFrame
+);
+
+void
+deleteCldfb (HANDLE_CLDFB_FILTER_BANK * h_cldfb); /*!< CLDFB Handle */
+
+Word16
+CreateCldfbAnalysisFilterBank (HANDLE_CLDFB_FILTER_BANK *hAnalysisCldfb,
+ const Word16 maxCldfbBands,
+ const Word16 frameSize,
+ UWord16 flags
+ );
+
+Word16
+DestroyCldfbAnalysisFilterBank (HANDLE_CLDFB_FILTER_BANK *hAnalysisCldfb
+ );
+
+Word16
+CreateCldfbSynthesisFilterBank (HANDLE_CLDFB_FILTER_BANK *hSynthesisCldfb,
+ const Word16 maxCldfbBands,
+ const Word16 frameSize,
+ UWord16 flags
+ );
+
+Word16
+DestroyCldfbSynthesisFilterBank (HANDLE_CLDFB_FILTER_BANK *hSynthesisCldfb
+ );
+
+Word16
+ResampleCldfbAnalysisFilterBank (HANDLE_CLDFB_FILTER_BANK hs,
+ const Word16 newCldfbBands,
+ Word16 newFrameSize,
+ UWord16 flags,
+ Word8 firstFrame
+ );
+
+
+
+Word16
+AnalysisPostSpectrumScaling_Fx (HANDLE_CLDFB_FILTER_BANK cldfbBank,
+ Word32 **rSubband32,
+ Word32 **iSubband32,
+ Word16 **rSubband16,
+ Word16 **iSubband16,
+ Word16 *cldfbScale
+ );
+
+void
+GetEnergyFromCplxCldfbData_Fx(Word32 **energyValues,
+ Word32 *energyLookahead,
+ Word16 *sf_energyLookahead,
+ const Word16 numLookahead,
+ Word16 **realValues,
+ Word16 **imagValues,
+ Word16 sf_Values,
+ Word16 numberBands,
+ Word16 numberCols,
+ Word32 *energyHF,
+ Word16 *energyHF_Exp
+ );
+
+void
+GetEnergyCldfb( Word32 *energyLookahead, /*!< o: Q31 | pointer to the result in the core look-ahead slot */
+ Word16 *sf_energyLookahead, /*!< o: pointer to the scalefactor of the result in the core look-ahead slot - apply as negative exponent*/
+ const Word16 numLookahead, /*!< i: Q0 the number of look-ahead time-slots */
+ Word16 **realValues, /*!< i: Q15 | the real part of the CLDFB subsamples */
+ Word16 **imagValues, /*!< i: Q15 | the imaginary part of the CLDFB subsamples */
+ Word16 sf_Values, /*!< i: scalefactor of the CLDFB subcamples - apply as a negated Exponent */
+ Word16 numberBands, /*!< i: Q0 | number of CLDFB bands */
+ Word16 numberCols, /*!< i: Q0 | number of CLDFB subsamples */
+ Word32 *energyHF, /*!< o: Q31 | pointer to HF energy */
+ Word16 *energyHF_Exp, /*!< o: pointer to exponent of HF energy */
+ Word32 *energyValuesSum, /*!< o: Q31 | pointer to sum array of energy values, not initialized*/
+ Word16 *energyValuesSum_Exp /*!< o: pointer to exponents of energyValuesSum, not initialized */
+ , HANDLE_TEC_ENC_FX hTecEnc
+ );
+
+/*bits_alloc.h*/
+Word16 BITS_ALLOC_get_rate_mode(
+ const Word16 frame_size_index /*i: frame_size_index*/
+);
+
+void BITS_ALLOC_init_config_acelp(
+ const Word32 bit_rate,
+ const Word8 narrowBand,
+ const Word16 nb_subfr,
+ ACELP_config *pConfigAcelp /*o: configuration structure of ACELP*/
+);
+
+Word16 BITS_ALLOC_config_acelp(
+ const Word16 bits_frame, /*i: remaining bit budget for the frame */
+ const Word16 coder_type, /*i: coder type */
+ ACELP_config *pConfigAcelp, /*i/o: configuration structure of ACELP*/
+ const Word16 narrowband,
+ const Word16 nb_subfr
+);
+
+void BITS_ALLOC_ACELP_config_rf(const Word16 coder_type,
+ Word16 *tilt_code,
+ Word16 *rf_frame_type,
+ Word16 *rf_target_bits,
+ Word16 nb_subfr
+ , Word16 rf_fec_indicator
+ , Word16 *pitch_buf
+ );
+void BITS_ALLOC_TCX_config_rf(
+ Word16 *rf_frame_type,
+ Word16 *rf_target_bits,
+ Word16 PLC_Mode,
+ Word16 coder_type,
+ Word16 last_core,
+ Word16 TD_mode
+);
+
+Word16 BITS_ALLOC_adjust_acelp_fixed_cdk(
+ const Word16 bits_frame, /*i: bit budget */
+ Word16 *fixed_cdk_index, /*o: codebook index */
+ const Word16 nb_subfr /*i: number of subframes*/
+);
+
+
+
+Word16 BITS_ALLOC_adjust_acelp_fixed_16KHZ_cdk(
+ const Word16 bits_frame, /*i: bit budget */
+ Word16 *fixed_cdk_index, /*o: codebook index */
+ const Word16 nb_subfr /*i: number of subframes*/
+);
+
+/*transient_detection.h*/
+/** Init transient detection.
+ * Fills TransientDetection structure with sensible content.
+ * @param nFrameLength Frame length.
+ * @param nTCXDelay Delay for the TCX Long/Short transient detector.
+ * Don't include the delay of the MDCT overlap.
+ * @param pTransientDetection Structure to be initialized. It contains all transient detectors to be used.
+ */
+void InitTransientDetection(Word16 nFrameLength,
+ Word16 nTCXDelay,
+ struct TransientDetection * pTransientDetection);
+
+/** Runs transient detection.
+ * Runs all transient detectors defined in pTransientDetection
+ * and calculates mean zero crossing.
+ * @param input New input samples.
+ * @param nSamplesAvailable Number of new input samples available.
+ * @param pTransientDetection Structure that contains transient detectors to be run.
+ */
+void RunTransientDetection(Word16 const * input, Word16 nSamplesAvailable, struct TransientDetection * pTransientDetection);
+
+
+/** Get the average temporal flatness measure using subblock energies aligned with the TCX.
+ * @param pTransientDetection Structure that contains transient detectors to be run.
+ * @param nCurrentSubblocks Number of the subblocks from the current frame to use for the calculation.
+ A lookeahead can also be use if it exists.
+ * @param nPrevSubblocks Number of subblocks from the previous frames to use for the calculation.
+ * @return average temporal flatness measure with exponent AVG_FLAT_E
+ */
+Word16 GetTCXAvgTemporalFlatnessMeasure(struct TransientDetection const * pTransientDetection, Word16 nCurrentSubblocks, Word16 nPrevSubblocks);
+
+
+/** Get the maximum energy change using subblock energies aligned with the TCX.
+ * @param pTransientDetection Structure that contains transient detectors to be run.
+ * @param nCurrentSubblocks Number of the subblocks from the current frame to use for the calculation.
+ A lookeahead can also be use if it exists.
+ * @param nPrevSubblocks Number of subblocks from the previous frames to use for the calculation.
+ * @param maximum energy change with exponent NRG_CHANGE_E
+ */
+Word16 GetTCXMaxenergyChange(struct TransientDetection const * pTransientDetection,
+ const Word8 isTCX10,
+ const Word16 nCurrentSubblocks, const Word16 nPrevSubblocks);
+
+/** Set TCX window length and overlap configuration
+ * @param prevEnergyHF previous HF energy. Exponent must be the same as for currEnergyHF.
+ * @param currEnergyHF current HF energy. Exponent must be the same as for prevEnergyHF.
+ */
+void SetTCXModeInfo(Encoder_State_fx *st,
+ struct TransientDetection const * pTransientDetection,
+ Word16 * tcxModeOverlap);
+
+/* Tonal Concealment */
+
+TONALMDCTCONCEAL_ERROR TonalMDCTConceal_Init( TonalMDCTConcealPtr self,
+ Word16 nSamples,
+ Word16 nSamplesCore,
+ Word16 nScaleFactors,
+ TCX_config * tcx_cfg
+ );
+
+
+/* Must be called only when a good frame is recieved - concealment is inactive */
+TONALMDCTCONCEAL_ERROR TonalMDCTConceal_SaveFreqSignal( TonalMDCTConcealPtr self,
+ Word32 const *mdctSpectrum,
+ Word16 const mdctSpectrum_exp,
+ Word16 nNewSamples,
+ Word16 nNewSamplesCore,
+ Word16 const *scaleFactors,
+ Word16 const *scaleFactors_exp,
+ Word16 const gain_tcx_exp
+ );
+
+/* The call to TonalMDCTConceal_UpdateState() should be called after TonalMDCTConceal_Apply. */
+TONALMDCTCONCEAL_ERROR TonalMDCTConceal_UpdateState(TonalMDCTConcealPtr self,
+ Word16 nNewSamples,
+ Word32 pitchLag,
+ Word16 badBlock,
+ Word8 tonalConcealmentActive
+ );
+
+/* The call to TonalMDCTConceal_SaveTimeSignal() should be at the
+ * place where the TD signal corresponds to the FD signal stored with TonalMDCTConceal_SaveFreqSignal. */
+TONALMDCTCONCEAL_ERROR TonalMDCTConceal_SaveTimeSignal( TonalMDCTConcealPtr self,
+ Word16 *timeSignal,
+ Word16 numSamples
+ );
+
+/* Calculates MDST, power spectrum and performs peak detection.
+ * Uses the TD signal in pastTimeSignal; if pastTimeSignal is NULL, uses the
+ * TD signal stored using TonalMDCTConceal_SaveTimeSignal. If the
+ * second last frame was also lost, it is expected that pastTimeSignal
+ * could hold a signal somewhat different from the one stored in
+ * TonalMDCTConceal_SaveTimeSignal (e.g. including fade-out).*/
+TONALMDCTCONCEAL_ERROR TonalMDCTConceal_Detect( TonalMDCTConcealPtr const self, /*IN */
+ Word32 const pitchLag, /*IN */
+ Word16 * const umIndices /*OUT*/
+ );
+
+/* Conceals the lost frame using the FD signal previously stored using
+ * TonalMDCTConceal_SaveFreqSignal. Stores the concealed harmonic part of
+ * the signal in mdctSpectrum, the rest of the spectrum is unchanged. */
+TONALMDCTCONCEAL_ERROR TonalMDCTConceal_Apply( TonalMDCTConcealPtr self, /*IN */
+ Word32 * mdctSpectrum, /*OUT*/
+ Word16 * mdctSpectrum_exp /*OUT*/
+ );
+
+/* Conceals the lost frame using the FD signal previously stored using
+ * TonalMDCTConceal_SaveFreqSignal. Stores the concealed noise part of
+ * the signal in mdctSpectrum, the rest of the spectrum is unchanged. */
+TONALMDCTCONCEAL_ERROR TonalMDCTConceal_InsertNoise( TonalMDCTConcealPtr self, /*IN */
+ Word32* mdctSpectrum, /*OUT*/
+ Word16* mdctSpectrum_exp, /*OUT*/
+ Word8 tonalConcealmentActive,
+ Word16* pSeed, /*IN/OUT*/
+ Word16 tiltCompFactor,
+ Word16 crossfadeGain,
+ Word16 crossOverFreq);
+
+/* Detect tonal components in the lastMDCTSpectrum, use
+ * secondLastPowerSpectrum for the precise location of the peaks and
+ * store them in indexOfTonalPeak. Updates lowerIndex, upperIndex,
+ * pNumIndexes accordingly. */
+void DetectTonalComponents(Word16 indexOfTonalPeak[], /* OUT */
+ Word16 lowerIndex[], /* OUT */
+ Word16 upperIndex[], /* OUT */
+ Word16 * pNumIndexes, /* OUT */
+ Word32 lastPitchLag, Word32 currentPitchLag, /* IN */
+ Word16 const lastMDCTSpectrum[], /* IN */
+ Word16 lastMDCTSpectrum_exp, /* IN */
+ Word16 const scaleFactors[], /* IN */
+ Word16 const scaleFactors_exp[], /* IN */
+ Word16 const scaleFactors_max_e, /* IN */
+ Word32 const secondLastPowerSpectrum[], /* IN */
+ Word16 nSamples /* IN */
+ ,Word16 nSamplesCore
+ ,Word16 floorPowerSpectrum /* IN */
+ );
+
+/* When called, the tonal components are already stored in
+ * indexOfTonalPeak. Detect tonal components in the lastMDCTSpectrum,
+ * use secondLastPowerSpectrum for the precise location of the peaks and
+ * then keep in indexOfTonalPeak only the tonal components that are
+ * again detected Updates indexOfTonalPeak, lowerIndex, upperIndex,
+ * phaseDiff, phases, pNumIndexes accordingly. */
+void RefineTonalComponents(Word16 indexOfTonalPeak[], /* OUT */
+ Word16 lowerIndex[], /* OUT */
+ Word16 upperIndex[], /* OUT */
+ Word16 phaseDiff[], /* OUT */
+ Word16 phases[], /* OUT */
+ Word16 * pNumIndexes, /* OUT */
+ Word32 lastPitchLag, /* IN */
+ Word32 currentPitchLag, /* IN */
+ Word16 const lastMDCTSpectrum[], /* IN */
+ Word16 const lastMDCTSpectrum_exp, /* IN */
+ Word16 const scaleFactors[], /* IN */
+ Word16 const scaleFactors_exp[], /* IN */
+ Word16 const scaleFactors_max_e, /* IN */
+ Word32 const secondLastPowerSpectrum[], /* IN */
+ Word16 nSamples /* IN */
+ ,Word16 nSamplesCore
+ ,Word16 floorPowerSpectrum /* IN */
+ );
+
+void set_state(Word16 *state, Word16 num, Word16 N);
+void concealment_init_x(Word16 N, void *_plcInfo);
+void concealment_update_x(Word16 bfi, Word16 curr_mode, Word16 harmonic, Word32 *invkoef, Word16 *invkoef_scale, void *_plcInfo);
+
+void waveform_adj2_fix( Word16 *overlapbuf,
+ Word16 *outx_new,
+ Word16 *data_noise,
+ Word16 *outx_new_n1,
+ Word16 *nsapp_gain,
+ Word16 *nsapp_gain_n,
+ Word16 *recovery_gain,
+ Word16 step_concealgain,
+ Word16 pitch,
+ Word16 Framesize,
+ Word16 delay,
+ Word16 bfi_cnt,
+ Word16 bfi
+ );
+
+Word16 ffr_getSfWord16(Word16 *vector, /*!< Pointer to input vector */
+ Word16 len); /*!< Length of input vector */
+
+void concealment_decode_fix(Word16 curr_mode, Word32 *invkoef, Word16 *invkoef_scale,void *_plcInfo);
+
+void concealment_signal_tuning_fx(Word16 bfi,
+ Word16 curr_mode,
+ Word16 *outx_new_fx,
+ void *_plcInfo,
+ Word16 nbLostCmpt,
+ Word16 pre_bfi,
+ Word16 *OverlapBuf_fx,
+ Word16 past_core_mode,
+ Word16 *outdata2_fx,
+ Decoder_State_fx *st);
+
+Word16 Spl_GetScalingSquare_x(Word16 *in_vector, Word16 in_vector_length, Word16 times);
+Word32 Spl_Energy_x(Word16* vector, Word16 vector_length, Word16* scale_factor);
+void Log10OfEnergy_x(Word16 *s, Word32 *enerlogval, Word16 len);
+void concealment_update2_x(Word16 *outx_new, void *_plcInfo, Word16 FrameSize);
+Word16 Sqrt_x_fast(Word32 value);
+
+Word32 dot_w32_accuracy_x(Word16 *s1, Word16 *s2, Word16 nbits, Word16 N);
+
+Word16 int_div_s_x(Word16 a, Word16 b);
+
+Word16 GetW32Norm_x(Word32 *s, Word16 N);
+
+Word16 harmo_x(Word32 *X, Word16 Framesize, Word16 pitch);
+
+
+void LpFilter2_x(Word16 *x, Word16 *y, Word16 N);
+
+void sig_tilt_x(Word16 *s, Word16 FrameSize, Word32 *enr1, Word32 *enr2) ;
+
+void get_maxConv_and_pitch_x(Word16 *s_LP, Word16 s, Word16 e, Word16 N,
+ Word32 *maxConv, Word16 *maxConv_bits, Word16 *pitch);
+
+Word16 get_voicing_x(Word16 *s_LP, Word16 pitch, Word32 covMax,Word16 maxConv_bits, Word16 Framesize);
+
+void pitch_modify_x(Word16 *s_LP, Word16 *voicing, Word16 *pitch, Word16 FrameSize);
+
+Word16 Is_Periodic_x(Word32 *mdct_data, Word16 cov_max, Word16 zp, Word32 ener,
+ Word32 ener_mean, Word16 pitch, Word16 Framesize);
+
+Word16 get_conv_relation_x(Word16 *s_LP, Word16 shift, Word16 N);
+
+
+
+/* 14Q1*1.28 */
+#define LSF_GAP_VAL(x) (Word16)((x)*2.0f*1.28f)
+
+/*longarith.h*/
+
+/**
+ * \brief inplace long shift right: a[] = a[] >> bits
+ * Logical shift right of UWord32 vector a[] by 'bits' positions.
+ */
+
+void longshr (UWord32 a[], Word16 bits, Word16 len);
+
+
+/*qlpc_avq.h*/
+void lsf_weight_2st(const Word16 *lsfq, /* input: quantized lsf coefficients (3Q12) */
+ Word16 *w, /* output: weighting function (0Q15) */
+ const Word16 mode /* input: operational mode */
+ );
+
+
+
+void qlpc_avq(
+ const Word16 *lsf, /* (i) Input LSF vectors */
+ const Word16 *lsfmid, /* (i) Input LSF vectors */
+ Word16 *lsf_q, /* (o) Quantized LFS vectors */
+ Word16 *lsfmid_q, /* (o) Quantized LFS vectors */
+ Word16 *index, /* (o) Quantization indices */
+ Word16 *nb_indices, /* (o) Number of quantization indices */
+ Word16 *nbbits, /* (o) Number of quantization bits */
+ const Word16 core, /* (i) TCX10 or TCX20 */
+ Word32 sr_core
+);
+
+Word16 encode_lpc_avq( Encoder_State_fx *st, Word16 numlpc, Word16 *param_lpc, Word16 mode );
+
+Word16 dlpc_avq(
+ Word16 *index, /* (i) Quantization indices */
+ Word16 *LSF_Q, /* (o) Quantized LSF vectors */
+ Word16 numlpc, /* (i) Number of sets of lpc */
+ Word32 sr_core
+);
+
+Word16 decode_lpc_avq( Decoder_State_fx *st, Word16 numlpc, Word16 *param_lpc );
+
+Word16 vlpc_1st_cod(const Word16 *lsf, /* input: vector to quantize */
+ Word16 *lsfq /* i/o: i:prediction o:quantized lsf */
+ ,Word16 *wout /* o: lsf weights */
+ ,Word16 rf_mode
+ );
+
+Word16 vlpc_2st_cod( /* output: number of allocated bits */
+ const Word16 *lsf, /* input: normalized vector to quantize (3Q12) */
+ Word16 *lsfq, /* i/o: i:1st stage o:1st+2nd stage (3Q12) */
+ Word16 *indx, /* output: index[] (4 bits per words) */
+ Word16 mode, /* input: 0=abs, >0=rel */
+ Word32 sr_core
+);
+
+void vlpc_2st_dec(
+ Word16 *lsfq, /* i/o: i:1st stage o:1st+2nd stage */
+ Word16 *indx, /* input: index[] (4 bits per words) */
+ Word16 mode, /* input: 0=abs, >0=rel */
+ Word32 sr_core);
+
+void open_decoder_LPD(
+ Decoder_State_fx *st,
+ Word32 bitrate,
+ Word16 bandwidth
+);
+
+
+void update_decoder_LPD_cng(
+ Decoder_State_fx *st,
+ Word16 coder_type,
+ Word16 *timeDomainBuffer,
+ Word16 *A,
+ Word16 *bpf_noise_buf
+);
+
+void reconfig_decoder_LPD( Decoder_State_fx *st, Word16 bits_frame, Word16 bandwidth_mode, Word32 bitrate, Word16 L_frame_old);
+
+void mode_switch_decoder_LPD( Decoder_State_fx *st, Word16 bandwidth_in, Word32 bitrate, Word16 frame_size_index
+ );
+
+void decoder_LPD(
+ Word16 signal_out[], /* output: signal with LPD delay (7 subfrs) */
+ Word16 signal_outFB[],
+ Word16 *total_nbbits, /* i/o: number of bits / decoded bits */
+ Decoder_State_fx *st , /* i/o: decoder memory state pointer */
+ Word16 *bpf_noise_buf,
+ Word16 bfi,
+ Word16 *bitsRead,
+ Word16 *coder_type,
+ Word16 param[],
+ Word16 *pitch_buf,
+ Word16 *voice_factors,
+ Word16 *ptr_bwe_exc
+);
+
+Word16 dec_acelp_tcx_frame(
+ Decoder_State_fx *st,
+ Word16 *coder_type,
+ Word16 *concealWholeFrame,
+ Word16 *pcmBuf,
+ Word16 * bpf_noise_buf,
+ Word16 * pcmbufFB,
+ Word32 bwe_exc_extended[],
+ Word16 *voice_factors,
+ Word16 pitch_buf[]
+);
+
+
+Word16 tcxGetNoiseFillingTilt(Word16 A[],
+ Word16 lpcorder,
+ Word16 L_frame,
+ Word16 mode,
+ Word16 *noiseTiltFactor
+ );
+
+
+void tcxFormantEnhancement(
+ Word16 xn_buf[],
+ Word16 gainlpc[], Word16 gainlpc_e[],
+ Word32 spectrum[], Word16 *spectrum_e,
+ Word16 L_frame
+ ,Word16 L_frameTCX
+);
+
+
+void tcxInvertWindowGrouping(TCX_config *tcx_cfg,
+ Word32 xn_buf[],
+ Word32 spectrum[],
+ Word16 L_frame,
+ Word8 fUseTns,
+ Word16 last_core,
+ Word16 index,
+ Word16 frame_cnt,
+ Word16 bfi);
+
+/*lerp.h*/
+
+void lerp(Word16 *f, Word16 *f_out, Word16 bufferNewSize, Word16 bufferOldSize);
+
+void attenuateNbSpectrum(Word16 L_frame, Word32 *spectrum);
+
+Word8 getTcxonly(const Word32 bitrate);
+Word8 getCtxHm(const Word32 bitrate, const Word16 rf_flag);
+Word8 getResq(const Word32 bitrate);
+
+Word8 getTnsAllowed(const Word32 bitrate
+ ,const Word16 igf
+ );
+
+Word8 getRestrictedMode(const Word32 bitrate, const Word16 Opt_AMR_WB);
+
+Word16 sr2fscale(const Word32 sr);
+
+Word32 getCoreSamplerateMode2(const Word32 bitrate, const Word16 bandwidth, const Word16 rf_flag);
+Word16 getTcxBandwidth(const Word16 bandwidth);
+
+Word8 getIgfPresent(
+ const Word32 bitrate,
+ const Word16 bandwidth
+ , const Word16 rf_mode
+);
+
+Word8 getCnaPresent(
+ const Word32 bitrate,
+ const Word16 bandwidth
+);
+
+Word8 getTcxLtp(
+ const Word32 sr_core
+);
+
+Word16 initPitchLagParameters(
+ const Word32 sr_core,
+ Word16 *pit_min,
+ Word16 *pit_fr1,
+ Word16 *pit_fr1b,
+ Word16 *pit_fr2,
+ Word16 *pit_max
+);
+
+Word16 getNumTcxCodedLines(const Word16 bwidth);
+
+Word16 getTcxLpcShapedAri(
+ const Word32 total_brate,
+ const Word16 bwidth
+ ,const Word16 rf_mode
+);
+
+
+Word16 vad_init(T_CldfbVadState *vad_state);
+
+void subband_FFT(
+ Word32 ** Sr, /*(i) real part of the CLDFB*/
+ Word32 ** Si, /*(i) imag part of the CLDFB*/
+ Word32 *spec_amp, /*(o) spectral amplitude*/
+ Word32 Offset, /*(i) offset of the CLDFB*/
+ Word16 *fftoQ /*(o) the Scaling */
+);
+
+void UpdateState( T_CldfbVadState *vad_state,
+ Word16 vad_flag,
+ Word32 frame_energy, /*(i) current frame energy*/
+ Word16 sacle_sbpower, /*(i) the Scaling of current frame energy*/
+ Word32 update_flag, /*(i) current frame update flag*/
+ Word16 music_backgound_f, /*(i) backgound music flag*/
+ Word32 HB_Power, /*(i) current frame high frequency energy*/
+ Word16 HB_Power_Q /*(i) the Scaling of current frame high frequency energy*/
+ ,Word32 snr
+ );
+
+void calc_snr_flux( Word32 tsnr_fix, /*(i) time-domain SNR*/
+ Word32 *pre_snr, /*(io)time-domain SNR storage*/
+ Word32 *snr_flux /*(o) average tsnr*/
+ );
+
+Word16 update_decision(
+ T_CldfbVadState *st,
+ Word32 frame_energy, /*(i) current frame energy*/
+ Word32 HB_Power, /*(i) current frame high frequency energy*/
+ Word16 frameloop, /*(i) amount of frames*/
+ Word16 bw, /*(i) band width index*/
+ Word16 frame_energy_Q, /*(i) the Scaling of current frame energy*/
+ Word16 HB_Power_Q, /*(i) the Scaling of current frame high frequency energy*/
+ Word32 snr, /*(i) frequency domain SNR */
+ Word32 tsnr, /*(i) time domain SNR */
+ Word16 vad_flag,
+ Word16 music_backgound_f /*(i) background music flag*/
+);
+
+void frame_spec_dif_cor_rate( T_CldfbVadState *st, /*(io) vad state*/
+ Word32 *spec_amp, /*(i) spectral amplitude*/
+ Word16 sacle, /*(i) the scaling of spec_amp*/
+ Word16 f_tonality_rate[3] /*(o) tonality rate*/
+ );
+
+void ltd_stable( T_CldfbVadState *st, /*(io) vad state*/
+ Word16 *ltd_stable_rate, /*(o) time-domain stable rate*/
+ Word32 frame_energy, /*(i) current frame energy*/
+ Word16 frameloop, /*(i) amount of frames*/
+ Word16 Q_frames_power /*(i) the Scaling of frames_power*/
+ );
+
+void snr_calc( T_CldfbVadState *st, /*(io) vad state*/
+ Word16 sacle_sbpower, /*(i) the Scaling of sbpower*/
+ Word32 *snr, /*(o) frequency domain SNR */
+ Word32 *tsnr, /*(o) time domain SNR */
+ Word32 frame_energy, /*(i) current frame energy */
+ Word32 bandwith /*(i) band width*/
+ );
+
+void bg_music_decision( T_CldfbVadState *st,
+ Word16 *music_backgound_f, /*(i) background music flag*/
+ Word32 frame_energy, /*(i) current frame energy 1*/
+ Word16 frame_energy_Q /*(i) the Scaling of current frame energy*/
+ );
+
+void background_update( T_CldfbVadState *st,
+ Word16 scale, /*(i) the Scaling of frame energy*/
+ Word32 frame_energy, /*(i) current frame energy*/
+ Word32 update_flag, /*(i) update flag*/
+ Word16 music_backgound_f /*(i) background music flag*/
+ ,Word32 snr
+ );
+
+void spec_center( Word32* sb_power, /*(i) energy of sub-band divided uniformly*/
+ Word16* sp_center, /*(o) spectral center*/
+ Word32 bandwith, /*(i) band width*/
+ Word16 Q_sb_p /*(i) the Scaling of sb_power*/
+ );
+
+void spec_flatness( Word32 *spec_amp, /*(i) spectral amplitude*/
+ Word32 smooth_spec_amp[], /*(i) smoothed spectral amplitude*/
+ Word16 sSFM[5] /*(o) spectral flatness rate*/
+ );
+
+void calc_lt_snr( T_CldfbVadState *st, /*(io) vad state*/
+ Word32 *lt_snr_org, /*(o) original long time SNR*/
+ Word32 *lt_snr, /*(o) long time SNR calculated by fg_energy and bg_energy*/
+ Word32 fg_energy, /*(i) foreground energy sum */
+ Word16 fg_energy_count, /*(i) amount of the foreground energy frame */
+ Word32 bg_energy, /*(i) background energy sum */
+ Word16 bg_energy_count, /*(i) amount of the background energy frame */
+ Word16 bw_index, /*(i) band width index*/
+ Word16 lt_noise_sp_center0 /*(i) long time noise spectral center by 0*/
+ );
+
+Word16 vad_decision( T_CldfbVadState *st,
+ Word32 l_snr, /*(i) long time frequency domain*/
+ Word32 lt_snr_org, /*(i) original long time SNR*/
+ Word32 lt_snr, /*(i) long time SNR calculated by fg_energy and bg_energy*/
+ Word32 snr_flux, /*(i) average tsnr of several frames*/
+ Word32 snr, /*(i) frequency domain SNR */
+ Word32 tsnr, /*(i) time domain SNR */
+ Word32 frame_energy, /*(i) current frame energy */
+ Word16 music_backgound_f, /*(i) background music flag*/
+ Word16 frame_energy_Q /*(i) the scaling of current frame energy*/
+ );
+
+Word16 comvad_decision( T_CldfbVadState *st,
+ Word32 l_snr, /*(i) long time frequency domain*/
+ Word32 lt_snr_org, /*(i) original long time SNR*/
+ Word32 lt_snr, /*(i) long time SNR calculated by fg_energy and bg_energy*/
+ Word32 snr_flux, /*(i) average tsnr of several frames*/
+ Word32 snr, /*(i) frequency domain SNR */
+ Word32 tsnr, /*(i) time domain SNR */
+ Word32 frame_energy, /*(i) current frame energy */
+ Word16 music_backgound_f, /*(i) background music flag*/
+ Word16 frame_energy_Q, /*(i) the Scaling of current frame energy*/
+ Word16 *cldfb_addition, /*(o) adjust the harmonized hangover */
+ Word16 vada_flag
+ );
+
+void calc_lf_snr(
+ Word32 *lf_snr_smooth, /*(o) smoothed lf_snr*/
+ Word32 *lf_snr, /*(o) long time frequency domain SNR calculated by l_speech_snr and l_silence_snr*/
+ Word32 l_speech_snr, /*(i) sum of active frames snr */
+ Word32 l_speech_snr_count, /*(i) amount of the active frame */
+ Word32 l_silence_snr, /*(i) sum of the nonactive frames snr*/
+ Word32 l_silence_snr_count, /*(i) amount of the nonactive frame */
+ Word16 fg_energy_count, /*(i) amount of the foreground energy frame */
+ Word16 bg_energy_count, /*(i) amount of the background energy frame */
+ Word16 bw_index /*(i) band width index*/
+);
+
+Word32 construct_snr_thresh( Word16 sp_center[], /*(i) spectral center*/
+ Word32 snr_flux, /*(i) snr flux*/
+ Word32 lt_snr, /*(i) long time time domain snr*/
+ Word32 l_snr, /*(i) long time frequency domain snr*/
+ Word32 continuous_speech_num, /*(i) amount of continuous speech frames*/
+ Word16 continuous_noise_num, /*(i) amount of continuous noise frames*/
+ Word32 fg_energy_est_start, /*(i) whether if estimated energy*/
+ Word16 bw_index /*(i) band width index*/
+ );
+
+Word16 vad_proc(T_CldfbVadState *vad_st,
+ Word32 realBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX], /* i: real values */
+ Word32 imagBuffer[CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX], /* i: imag values */
+ Word16 riBuffer_exp, /* i: exponent of real & imag Buffer */
+
+ Word16 *cldfb_addition, /*o: adjust the harmonized hangover */
+ Word32 enerBuffer[CLDFB_NO_CHANNELS_MAX], /* i: energy vector per band */
+ Word16 enerBuffer_exp, /* i: exponent of energy vector */
+ Word16 bandwidth, /* 1: NB; 2:WB;3:SWB;4:FB*/
+ Word16 vada_flag
+ );
+
+void est_energy(Word32 enerBuffer[CLDFB_NO_CHANNELS_MAX], /* i: energy vector per band */
+ Word16 enerBuffer_exp, /* i: exponent of energy vector */
+ Word32 *frame_sb_energy, /*(o) energy of sub-band divided non-uniformly*/
+ Word32 *frame_energy2_p, /*(o) frame energy 2*/
+ Word32 *HB_Power_p, /*(o) high frequency energy*/
+ Word32 *frame_energy_p, /*(o) frame energy 1*/
+ Word16 *sb_power_Q, /*(o) the scaling of sb_power*/
+ Word16 *frame_energy2_Q, /*(o) the scaling of frame_energy*/
+ Word16 *HB_Power_Q, /*(o) the scaling of HB_Power*/
+ Word16 *frame_energy_Q, /*(o) the Scaling of frame_energy*/
+ Word16 *frame_sb_energy_scale, /*(o) the Scaling of frame_sb_energy[]*/
+ Word32 bandwidth /*(i) band width*/
+ );
+
+/**
+ * \brief Function performs a complex 16-point FFT
+ * The FFT is performed inplace. The result of the FFT
+ * is scaled by SCALEFACTOR16 bits.
+ *
+ * WOPS FLC version: 196 cycles
+ * WOPS with 32x16 bit multiplications (scale on ): 288 cycles
+ * WOPS with 32x16 bit multiplications (scale off): 256 cycles
+ *
+ * \param [i/o] re real input / output
+ * \param [i/o] im imag input / output
+ * \param [i ] s stride real and imag input / output
+ *
+ * \return void
+ */
+void fft16(Word32 *re, Word32 *im, Word16 s, Word16 bScale);
+
+
+
+void dlpc_bfi(
+ const Word16 L_frame,
+ Word16 *lsf_q, /* o : quantized LSFs */
+ const Word16 *lsfold, /* i : past quantized LSF */
+ const Word16 last_good, /* i : last good received frame */
+ const Word16 nbLostCmpt, /* i : counter of consecutive bad frames */
+ Word16 mem_MA[], /* i/o: quantizer memory for MA model */
+ Word16 mem_AR[], /* i/o: quantizer memory for AR model */
+ Word16 *stab_fac, /* i : LSF stability factor */
+ Word16 *lsf_adaptive_mean,/* i : LSF adaptive mean, updated when BFI==0 */
+ Word16 numlpc, /* i : Number of division per superframe */
+ Word16 lsf_cng[],
+ Word8 plcBackgroundNoiseUpdated,
+ Word16 *lsf_q_cng, /* o : quantized LSFs */
+ Word16 *old_lsf_q_cng, /* o : old quantized LSFs for background noise */
+ const Word16* lsfBase, /* i : base for differential LSF coding */
+ Word8 tcxonly
+);
+
+void isf_dec_bfi(
+ const Word16 last_type, /*!< i : coding type in last good received fr. */
+ Word16*isf_q, /*!< o : 14Q1*1.28 quantized ISFs */
+ const Word16*isfold, /*!< i : 14Q1*1.28 past quantized ISF */
+ const Word16 last_good, /*!< i : last good received frame */
+ const Word16 bfi_cnt, /*!< i : counter of consecutive bad frames */
+ Word16*mem_MA, /*!< i/o: 14Q1*1.28 quantizer memory for MA model */
+ Word16 stab_fac, /*!< i : ISF stability factor (shifted right by 1) */
+ Word16*isf_adaptive_mean, /*!< i : 14Q1*1.28 ISF adaptive mean, updated when BFI==0 */
+ const Word16 coder_type, /*!< i : Coders frame type */
+ Word16 lpcorder, /*!< i: : lpc order */
+ Word16 *isf_cng,
+ Word8 plcBackgroundNoiseUpdated,
+ Word16 *isf_q_cng, /* o : quantized ISFs for background noise */
+ Word16 *old_isf_q_cng, /* o : old quantized ISFs for background noise */
+ const Word16 xsfBase[] /* i : base for differential XSF coding */
+);
+
+void tfaCalcEnv_fx(const Word16* shb_speech, Word32* enr);
+Word16 tfaEnc_TBE_fx(Word32* enr,
+ Word16 last_core,
+ Word16* voicing, /* Q15 */
+ Word16* pitch_buf, /* Q6 */
+ Word16 Q_enr
+ );
+
+void tecEnc_TBE_fx(Word16* corrFlag, const Word16* voicing, Word16 coder_type);
+
+void set_TEC_TFA_code_fx(const Word16 corrFlag, Word16* tec_flag, Word16* tfa_flag);
+
+Word16 procTecTfa_TBE_Fx(Word16 *hb_synth_Fx,
+ Word16 hb_synth_fx_exp,
+ Word16 *gain_m,
+ Word16 *gain_e,
+ Word16 flat_flag,
+ Word16 last_core
+ , Word16 l_subfr
+ , Word16 code
+ );
+
+
+void
+calcGainTemp_TBE_Fx(
+ Word32** pCldfbRealSrc_Fx,
+ Word32** pCldfbImagSrc_Fx,
+ Word16 cldfb_exp,
+ Word16* loBuffer_Fx,
+ Word16 startPos, /*!< Start position of the current envelope. */
+ Word16 stopPos, /*!< Stop position of the current envelope. */
+ Word16 lowSubband, /* lowSubband */
+ Word16* pGainTemp_m,
+ Word16* pGainTemp_e
+ , Word16 code
+);
+
+void resetTecEnc_Fx(
+ HANDLE_TEC_ENC_FX hTecEnc,
+ Word16 flag
+
+);
+
+void
+resetTecDec_Fx(
+ HANDLE_TEC_DEC_FX hTecDec
+);
+
+void calcHiEnvLoBuff_Fix(
+ Word16 noCols,
+ Word16* pFreqBandTable, /*!< freqbandTable. */
+ Word16 nSfb, /*!< Number of scalefactors. */
+ Word32** pCldfbPow_Fix /*float** pCldfbPow*/,
+ Word16* loBuffer_Fix /*float* loBuffer Q8*/,
+ Word16* hiTempEnvOrig_Fix /*float* hiTempEnvOrig*/,
+ Word16 pCldfbPow_FixScale
+);
+
+void calcLoEnvCheckCorrHiLo_Fix(
+ Word16 noCols,
+ Word16* pFreqBandTable, /*!< freqbandTable. */
+ Word16* loBuffer_Fix /*float* loBuffer*/,
+ Word16* loTempEnv_Fix /*float* loTempEnv*/,
+ Word16* loTempEnv_ns_Fix /* float* loTempEnv_ns*/,
+ Word16* hiTempEnvOrig_Fix /*float* hiTempEnvOrig*/,
+ Word16* corrFlag /*int* corrFlag*/
+);
+
+
+
+/**************************** Moved from er_util.h: ********************************/
+
+/*----------------------------------------------------------------------*
+ * PLC: [ACELP: Fade-out]
+ * PLC: getLevelSynDeemph: derive on subframe basis the level of LPC
+ * synthesis and deeemphasis based on the given input
+ *----------------------------------------------------------------------*/
+
+Word16 getLevelSynDeemph( /*10Q5*/
+ Word16 h1Init[], /* i: input value or vector to be processed */ /* Q15 */
+ Word16 const A[], /* i: LPC coefficients */ /* Qx */
+ Word16 const lpcorder, /* i: LPC order */ /* Q0 */
+ Word16 const lenLpcExc, /* i: length of the LPC excitation buffer */ /* Q0 */
+ Word16 const preemph_fac, /* i: preemphasis factor */ /* Q15 */
+ Word16 const numLoops, /* i: number of loops */ /* Q0 */
+ Word16 *Exp /* o: exponent of return value Q15 */
+);
+
+
+/*-----------------------------------------------------------------*
+ * PLC: [ACELP: general]
+ * PLC: high pass filtering
+ *-----------------------------------------------------------------*/
+void highPassFiltering(
+ const Word16 last_good, /* i: short last classification type */
+ const Word16 L_buffer, /* i: int buffer length */
+ Word16 exc2[], /* i/o: Qx unvoiced excitation before the high pass filtering */
+ const Word16 hp_filt[], /* i: Q15 high pass filter coefficients */
+ const Word16 l_fir_fer); /* i: high pass filter length */
+
+
+/*----------------------------------------------------------------------------------*
+ * PLC: [Common: mode decision]
+ * PLC: Decide which Concealment to use. Update pitch lags if needed
+ *----------------------------------------------------------------------------------*/
+Word16 GetPLCModeDecision( Decoder_State_fx *st
+ );
+
+/* PLC: [Common: Fade-out]
+ * PLC: and for PLC fade out */
+
+void minimumStatistics(Word16* noiseLevelMemory, /* Q15, internal state */
+ Word16* noiseLevelIndex, /* Q0, internal state */
+ Word16* currLevelIndex, /* Q0, internal state (circular buffer) */
+ Word16* noiseEstimate, /* Q15, previous estimate of background noise */
+ Word16* lastFrameLevel, /* Q15, level of the last frame */
+ Word16 currentFrameLevel, /* Q15, level of the current frame */
+ Word16* noiseLevelMemory_e, /* scaling factor for noiseLevelMemory */
+ Word16 const noiseEstimate_e, /* exponent of noiseEstimate */
+ Word16* new_noiseEstimate_e, /* new exponent of noise Estimate*/
+ Word16* const lastFrameLevel_e, /* exponent of lastFrameLevel */
+ Word16 currentFrameLevel_e); /* exponent of currentFrameLevel */
+
+/*-----------------------------------------------------------------------------------*
+ * PLC: [ACELP: innovative codebook]
+ * PLC: genPlcFiltBWAdapt : deriuve filter coefficients for filtering
+ the first pitch cycle, bitrate dependent
+ *-----------------------------------------------------------------------------------*/
+
+void genPlcFiltBWAdap(
+ Word32 const sr_core, /*Qold) */
+ Word16 *old_exc, /* i: input excitation in Q(st->Qold) */
+ Word16 L_frame /* i: input frame length */
+);
+
+void encoderSideLossSimulation(
+ Encoder_State_fx *st,
+ HANDLE_PLC_ENC_EVS hPlc_Ext,
+ Word16 *isf_q, /* Q1*1.28 */
+ Word16 stab_fac, /* Q15 */
+ Word8 calcOnlyISF,
+ const Word16 L_frame
+);
+
+void enc_prm_side_Info( HANDLE_PLC_ENC_EVS hPlc_Ext, Encoder_State_fx *st );
+
+void GplcTcxEncSetup(Encoder_State_fx *st,
+ HANDLE_PLC_ENC_EVS hPlc_Ext,
+ Word16 Q_new);
+Word16 encSideSpecPowDiffuseDetector(
+ Word16 *isf_ref,
+ Word16 *isf_con,
+ Word32 sr_core,
+ Word16 *prev_isf4_mean,
+ Word8 sw
+ , Word16 coder_type
+);
+
+void updateSpecPowDiffuseIdx( Encoder_State_fx *st);
+
+void blend_subfr2(
+ Word16 *sigIn1, /* i : input signal for fade-out */
+ Word16 *sigIn2, /* i : input signal for fade-in */
+ Word16 *sigOut /* o : output signal */
+);
+
+
+void BASOP_cfft(cmplx *pComplexBuf, Word16 sizeOfFft, Word16 *scale, Word32 workBuffer[2*BASOP_CFFT_MAX_LENGTH]);
+void BASOP_cfft16(Word16 *re, Word16 *im, Word16 sizeOfFft, Word16 s, Word16 *scale);
+void BASOP_rfft(Word32 *x, Word16 sizeOfFft, Word16 *scale, Word16 isign);
+void BASOP_rfft16(Word16 *x, Word16 sizeOfFft, Word16 *scale, Word16 isign);
+
+void open_PLC_ENC_EVS(
+ HANDLE_PLC_ENC_EVS hPlcExt,
+ Word32 sampleRate
+);
+
+void gPLC_encInfo (
+ HANDLE_PLC_ENC_EVS self,
+ Word32 modeBitrate,
+ Word16 modeBandwidth,
+ Word16 old_clas,
+ Word16 acelp_ext_mode
+);
+
+void v_sort(Word16 *r, const Word16 lo, const Word16 up);
+
+void coder_acelp_rf(
+ ACELP_config *acelp_cfg_rf, /*input/output: configuration of the ACELP coding*/
+ const Word16 coder_type, /* input: coding type */
+ const Word16 A[], /* input: coefficients 4xAz[M+1] */
+ const Word16 Aq[], /* input: coefficients 4xAz_q[M+1] */
+ Word16 speech[], /* input: speech[-M..lg] */
+ const Word16 voicing[], /* input: open-loop LTP gain */
+ const Word16 T_op[], /* input: open-loop LTP lag */
+ Word16 stab_fac,
+ Encoder_State_fx *st,
+ Word16 target_bits, /* i/o : coder memory state */
+ const Word16 rf_frame_type, /* i : rf_frame_type */
+ Word16 *exc_rf, /* i/o: pointer to RF excitation */
+ Word16 *syn_rf, /* i/o: pointer to RF synthesis */
+ Word16 Q_new,
+ Word16 shift
+);
+
+
+#endif /*PROT_COM_FX_H */
diff --git a/lib_com/pvq_com_fx.c b/lib_com/pvq_com_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..69b5518c44bdf254826f3c853dd523557cf6b4dd
--- /dev/null
+++ b/lib_com/pvq_com_fx.c
@@ -0,0 +1,753 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+
+#include "prot_fx.h" /* Function prototypes */
+#include "cnst_fx.h" /* Common constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "stl.h" /* required for wmc_tool */
+
+
+#include "options.h"
+
+
+UWord32 intLimCDivPos_fx(
+ UWord32 NUM,
+ Word16 DEN
+)
+{
+ UWord32 UL_ru, UL_rl;
+ Mpy_32_32_uu(UL_lshl(NUM, 1), intLimCDivInvDQ31[DEN], &UL_ru, &UL_rl);
+ return UL_ru;
+}
+
+
+Word32 intLimCDivSigned_fx(
+ Word32 NUM,
+ Word16 DEN)
+{
+ Word32 L_tmp;
+
+ L_tmp = intLimCDivPos_fx( L_abs(NUM) , DEN);
+ if (NUM < 0)
+ {
+ L_tmp= L_negate(L_tmp); /* one op */
+ }
+ return L_tmp;
+}
+
+
+Word16 shrtCDivSignedApprox( const Word16 num,
+ const Word16 den
+ )
+{
+ Word16 pool_part;
+
+ pool_part = extract_h( L_mult( negate(abs_s(num)), lim_neg_inv_tbl_fx[den] ));
+ /* neg_in always, positive out always, so that positive truncation(rounding) is used */
+ if ( num < 0 )
+ {
+ pool_part = negate(pool_part); /* make negative, one op */
+ }
+ return pool_part;
+}
+
+void nearProjQ15_fx(
+ Word16 x,
+ Word16 *result
+)
+{
+ const Word16 a[4] = {14967, -25518, 3415, 32351};
+ Word32 b;
+ UWord16 lsb;
+
+ b = L_deposit_l(a[0]);
+ b = L_shl((Word32)add(a[1], extract_h(L_mult0((Word16)b, x))), 1);
+ Mpy_32_16_ss(b, x, &b, &lsb);
+ b = L_add((Word32)a[2], b);
+ Mpy_32_16_ss(b, x, &b, &lsb);
+ b = L_add((Word32)a[3], b);
+ *result = extract_l(b);
+ return ;
+}
+
+/*-------------------------------------------------------------------*
+ * obtainEnergyQuantizerDensity_fx()
+ *
+ *
+ *-------------------------------------------------------------------*/
+void obtainEnergyQuantizerDensity_fx(
+ const Word16 L,
+ const Word16 R,
+ Word16 *Density )
+{
+ Word16 Rnrg, den, n;
+
+ den = sub(shl(L, 1), 1);
+ IF( den <= 67 )
+ {
+ Rnrg = extract_l(intLimCDivPos_fx( L_deposit_l(R) , den));
+ }
+ ELSE
+ {
+ n = norm_s(den);
+ Rnrg = shr(div_s(R, shl(den, n)), sub(15, n));
+ }
+ Rnrg = add(Rnrg, 28);
+
+ Rnrg = s_min(Rnrg, 56);
+ Rnrg = s_min(Rnrg, sub(R, 96));
+
+ Rnrg = s_max(Rnrg, 3);
+ *Density = obtainEnergyQuantizerDensity_f[Rnrg];
+ return;
+}
+
+
+/*-------------------------------------------------------------------*
+ * dsDirac2Dirac_fx()
+ *
+ *
+ *-------------------------------------------------------------------*/
+void dsDirac2Dirac_fx(
+ const Word16 dsDiracIndex,
+ Word16 *diracs
+)
+{
+ *diracs = dsDiracsTab[dsDiracIndex];
+ return;
+}
+
+void dsDiracPerQuanta_fx(
+ const Word16 td,
+ const Word16 t_quanta,
+ const Word16 dsm,
+ const unsigned char* const *frQuanta,
+ Word16 *DsIdx
+)
+{
+ const unsigned char *sv;
+ Word16 nsv;
+ Word16 t_quanta_o;
+ Word16 dsIndex;
+ Word16 i;
+
+ sv = frQuanta[td];
+ nsv = sv[0];
+
+ t_quanta_o = sub(t_quanta, QUANTAQ3OFFSET);
+
+ IF (GE_16(t_quanta_o, sv[nsv]))
+ {
+ *DsIdx = nsv;
+ move16();
+ return ;
+ }
+
+ IF (LE_16(t_quanta_o, sv[1]))
+ {
+ *DsIdx = 1;
+ move16();
+ return ;
+ }
+
+
+ dsIndex = shl(1, frQuanta[0][td]);
+ if (GT_16(t_quanta_o, sv[shr(nsv, 1) ]))
+ {
+ dsIndex = sub(nsv, dsIndex );
+ }
+ FOR (i = sub(frQuanta[0][td], 1); i >= 0; i--)
+ {
+ dsIndex = add(dsIndex, shl(sub(shl(lshr(sub(sv[dsIndex], t_quanta_o), 15), 1), 1), i));
+ }
+
+ dsIndex = add(dsIndex, lshr(sub(sv[dsIndex], t_quanta_o), 15));
+ dsIndex = sub(dsIndex, lshr(sub(1, dsIndex), 15));
+
+ IF (dsm > 0)
+ {
+ *DsIdx=dsIndex;
+ move16();
+ return;
+ }
+ *DsIdx = add(dsIndex, lshr(sub(add(sv[add(dsIndex,1)], sv[dsIndex]), shl(t_quanta_o, 1)), 15));
+ return;
+}
+
+void QuantaPerDsDirac_fx(
+ Word16 td,
+ Word16 dsDiracIndex,
+ const unsigned char* const* dimFrQuanta,
+ Word16 *Quanta
+)
+{
+ *Quanta = dimFrQuanta[td][dsDiracIndex];
+ move16();
+ if(dsDiracIndex == 0)
+ {
+ *Quanta = -1; /* single op */ move16();
+ }
+ *Quanta = add(*Quanta, QUANTAQ3OFFSET);
+ return ;
+}
+
+void conservativeL1Norm_fx(
+ Word16 L,
+ Word16 Qvec,
+ Word16 Fcons,
+ Word16 Qavail,
+ Word16 Qreserv,
+ Word16 Dspec,
+ Word16 *Dvec,
+ Word16 *Qspare,
+ Word16 *Qreservplus,
+ Word16 *Dspecplus
+)
+{
+
+ Word16 Minit, Mprime;
+ Word16 Qtestminus;
+ const unsigned char *frQuantaL;
+
+ frQuantaL = hBitsN[L];
+
+ *Qreservplus = add(Qreserv, sub(Qvec, QUANTAQ3OFFSET));
+
+ dsDiracPerQuanta_fx(L, Qvec, Fcons, hBitsN, &Minit);
+
+ Mprime = Minit;
+ move16();
+ DO
+ {
+ Qtestminus = (short)frQuantaL[Mprime];
+ move16();
+ *Qspare = sub(Qavail, Qtestminus);
+ Mprime = sub(Mprime, 1);
+ }
+ WHILE ( (Mprime >= 0) && LT_16(*Qspare, QUANTAQ3OFFSET ));
+
+ if(Mprime < 0)
+ {
+ *Qspare = add(Qavail, QUANTAQ3OFFSET); /* single op */
+ }
+ dsDirac2Dirac_fx(add(Mprime, 1), Dvec);
+
+ *Dspecplus = add(Dspec, *Dvec);
+ *Qreservplus = sub(*Qreservplus, (short)frQuantaL[Minit]);
+ *Qspare = sub(*Qspare, QUANTAQ3OFFSET);
+
+ return;
+}
+
+
+
+
+
+void bandBitsAdjustment_fx(
+ Word16 Brc,
+ UWord32 INTrc,
+ Word16 Bavail,
+ Word16 Nbands,
+ Word16 D,
+ Word16 L,
+ Word16 Bband,
+ Word16 Breserv,
+ Word16 *Bband_adj,
+ Word16 *Brem,
+ Word16 *Breservplus)
+{
+ Word16 Btemp;
+ Word16 Bff;
+ Word32 L_tmp;
+
+ rangeCoderFinalizationFBits_fx(Brc, INTrc, &Bff);
+
+ IF(LT_16(D, Nbands))
+ {
+ L_tmp = L_deposit_l(sub(Breserv, Bff));
+ Btemp = extract_l(intLimCDivSigned_fx(L_tmp, s_min(D, 3))); /* result always fits in Word16 */
+ *Breservplus = add(Bband, Breserv);
+ }
+ ELSE
+ {
+ Btemp = 0;
+ move16();
+ *Breservplus = add(Bband, Bff);
+ }
+ *Bband_adj = s_min(extract_l(L_mult(L, 40)), Bband);
+ *Brem = sub(Bavail, Bff);
+ *Bband_adj = s_min(*Brem, add(*Bband_adj, Btemp));
+ *Bband_adj = s_max(0, *Bband_adj);
+}
+
+
+
+static Word16 Ratio_base2Q11_fx( /* o : Q11 */
+ const Word16 opp, /* i : Q15 */
+ const Word16 near /* i : Q15 */
+)
+{
+ Word16 mc, nc, ms, ns, d, z;
+ Word16 result;
+ Word32 acc;
+
+ ns = norm_s(opp ); /* exponent */
+ nc = norm_s(near ); /* exponent */
+
+ ms = shl(opp, ns); /* mantissa */
+ mc = shl(near, nc); /* mantissa */
+
+ acc = L_mac(538500224L, mc, -2776); /* a0*mc + a1, acc(Q27), a0(Q11), a1(Q27) */
+ z = mac_r(acc, ms, -2776); /* z in Q11, a0 in Q11 */
+ d = sub(ms, mc); /* d in Q15 */
+ z = mult_r(z, d); /* z in Q11 */
+
+ result = add(z, shl(sub(nc, ns), 11));
+
+ return result;
+}
+
+void Ratio_rQ3_fx(
+ Word16 opp,
+ Word16 near,
+ Word16 *result
+)
+{
+ Word16 tmp;
+
+ tmp = add(1<<7 , Ratio_base2Q11_fx(opp, near));
+ *result = shr(tmp, 8);
+ return ;
+}
+
+
+void densityAngle2RmsProjDec_fx(
+ Word16 D,
+ Word16 indexphi,
+ Word16 *oppQ15,
+ Word16 *nearQ15,
+ Word16 *oppRatioQ3
+)
+{
+ Word16 phiQ14q;
+ Word16 oppTail, nearTail;
+
+ phiQ14q = (Word16)intLimCDivPos_fx(L_shl(L_deposit_l(indexphi), 13), shr(D, 1));
+ if (indexphi < 0)
+ {
+ phiQ14q = 1 << 13; /* one op */ move16();
+ }
+
+ oppTail = shr(sub(16320, phiQ14q), 15);
+ nearTail = shr(sub(phiQ14q, 64), 15);
+
+ IF (s_or(oppTail, nearTail) < 0)
+ {
+ *oppQ15 = s_and(oppTail, (1 << 15) - 1);
+ *nearQ15 = s_and(nearTail, (1 << 15) - 1);
+ *oppRatioQ3 = shl(add(1, shl(nearTail, 1)), 14);
+ }
+ ELSE
+ {
+ nearProjQ15_fx( shl(sub(1 << 14, phiQ14q), 1), oppQ15);
+ nearProjQ15_fx(shl(phiQ14q, 1), nearQ15);
+ Ratio_rQ3_fx(*oppQ15, *nearQ15, oppRatioQ3);
+ }
+
+ return;
+}
+
+void densityAngle2RmsProjEnc_fx(
+ Word16 D,
+ Word16 phiQ14uq,
+ Word16 *indexphi,
+ Word16 *oppQ15,
+ Word16 *nearQ15,
+ Word16 *oppRatioQ3
+)
+{
+ *indexphi = mult_r(shl(D, 1), phiQ14uq);
+ if (s_and(D, 1) > 0)
+ {
+ *indexphi = -1; /* one op */ move16();
+ }
+ densityAngle2RmsProjDec_fx(D, *indexphi, oppQ15, nearQ15, oppRatioQ3);
+
+ return;
+}
+
+void NearOppSplitAdjustment_fx(
+ const Word16 qband,
+ const Word16 qzero,
+ const Word16 Qac,
+ const UWord32 INTac,
+ const Word16 qglobal,
+ const Word16 FlagCons,
+ const Word16 Np,
+ const Word16 Nhead,
+ const Word16 Ntail,
+ const Word16 Nnear,
+ const Word16 Nopp,
+ Word16 oppRQ3,
+ Word16 *qnear,
+ Word16 *qopp,
+ Word16 *qglobalupd
+)
+{
+
+ Word16 qac, qboth, qskew, qavg, qmin, Midx;
+ Word32 L_QIb, L_qnum;
+ Word16 QIb, QIa;
+
+ rangeCoderFinalizationFBits_fx(Qac, INTac, &qac);
+ qboth = sub(qband, sub(qac, qzero));
+ /* skew calc code */
+ qskew = 0 ;
+ move16();
+ IF (GT_16(Nhead, 1))
+ {
+ qavg = extract_h(L_shl(intLimCDivSigned_fx((Word32)qboth, Np),16)); /* qboth may be negative */
+ dsDiracPerQuanta_fx(Ntail, qavg, FlagCons, hBitsN, &Midx );
+ QuantaPerDsDirac_fx(Nhead, Midx, hBitsN, &qmin);
+ qskew = sub(qavg, qmin);
+ qskew = s_max(0, qskew);
+ } /* end of skew calc code*/
+
+ QIa = add(extract_l(intLimCDivPos_fx((UWord32)L_deposit_l(Nopp), Nnear)), 1); /* always positive Word16 out */
+ L_qnum = L_sub( L_deposit_l(sub(sub(add(qband, qzero), qac), qskew)), L_mult0(Nopp, oppRQ3));
+
+ L_QIb = L_deposit_l(0);
+ IF (L_qnum > 0)
+ {
+ L_QIb = (Word32) intLimCDivPos_fx(L_qnum, QIa);
+ }
+ *qnear = qboth;
+ QIb = extract_h(L_shl(L_QIb, 16)); /* may saturate */
+ if (LE_16(QIb, qboth))
+ {
+ *qnear = QIb;
+ }
+ *qopp = sub(qboth, *qnear);
+ *qglobalupd = sub(qglobal, sub(qac, qzero));
+
+ return;
+}
+
+
+/*--------------------------------------------------------------------------*
+ * apply_gain()
+ *
+ * Apply gain
+ *--------------------------------------------------------------------------*/
+
+void apply_gain_fx(
+ const Word16 *ord, /* i : Indices for energy order */
+ const Word16 *band_start, /* i : Sub band start indices */
+ const Word16 *band_end, /* i : Sub band end indices */
+ const Word16 num_sfm, /* i : Number of bands */
+ const Word16 *gains, /* i : Band gain vector Q12 */
+ Word16 *xq /* i/o: Float synthesis / Gain adjusted synth Q15/Q12 */
+)
+{
+ Word16 band,i;
+ Word16 g; /* Q12 */
+
+ FOR ( band = 0; band < num_sfm; band++)
+ {
+ g = gains[ord[band]];
+
+ FOR( i = band_start[band]; i < band_end[band]; i++)
+ {
+ /*xq[i] *= g; */
+ xq[i] = mult_r(g, xq[i]);
+ move16(); /*12+15+1-16=12 */
+ }
+ }
+
+ return;
+}
+
+/*--------------------------------------------------------------------------*
+ * fine_gain_quant()
+ *
+ * Fine gain quantization
+ *--------------------------------------------------------------------------*/
+
+void fine_gain_quant_fx(
+ Encoder_State_fx *st_fx,
+ const Word16 *ord, /* i : Indices for energy order */
+ const Word16 num_sfm, /* i : Number of bands */
+ const Word16 *gain_bits, /* i : Gain adjustment bits per sub band */
+ Word16 *fg_pred, /* i/o: Predicted gains / Corrected gains Q12 */
+ const Word16 *gopt /* i : Optimal gains Q12 */
+)
+{
+ Word16 band;
+ Word16 gbits;
+ Word16 idx;
+ Word16 gain_db,gain_dbq;
+ Word16 err;
+
+ Word16 tmp1, tmp2, exp1, exp2;
+ Word32 L_tmp;
+ UWord16 lsb;
+
+ FOR ( band = 0; band < num_sfm; band++)
+ {
+ gbits = gain_bits[ord[band]];
+ test();
+ IF ( fg_pred[band] != 0 && gbits > 0 )
+ {
+ exp1 = norm_s(gopt[band]);
+ exp1 = sub(exp1, 1);
+ tmp1 = shl(gopt[band], exp1);
+ exp2 = norm_s(fg_pred[band]);
+ tmp2 = shl(fg_pred[band], exp2);
+ exp1 = add(15, sub(exp1, exp2));
+ err = div_s(tmp1, tmp2);
+ tmp1 = norm_s(err);
+ exp2 = Log2_norm_lc(L_deposit_h(shl(err, tmp1)));
+ tmp1 = sub(14, tmp1);
+ tmp1 = sub(tmp1, exp1);
+ L_tmp = L_Comp(tmp1, exp2);
+ Mpy_32_16_ss(L_tmp, 24660, &L_tmp, &lsb); /* 24660 = 20*log10(2) in Q12 */ /*16+12-15=13 */
+ gain_db = round_fx(L_shl(L_tmp, 17));
+
+ idx = squant_fx(gain_db, &gain_dbq, finegain_fx[gbits-1], gain_cb_size[gbits-1]);
+ push_indice_fx( st_fx, IND_PVQ_FINE_GAIN, idx, gbits );
+
+ L_tmp = L_mult0(gain_dbq, 21771); /* 21771=0.05*log2(10) */ /* 14+17=31 */
+ L_tmp = L_shr(L_tmp, 15);
+ tmp1 = L_Extract_lc(L_tmp, &exp1);
+ tmp1 = abs_s(tmp1);
+ tmp1 = extract_l(Pow2(14, tmp1));
+ exp1 = sub(14, exp1);
+
+ L_tmp = L_mult0(fg_pred[band], tmp1); /*12+exp1 */
+ fg_pred[band] = round_fx(L_shl(L_tmp, sub(16, exp1))); /*12+exp1+16-exp1-16=12 */
+ }
+ }
+
+ return;
+}
+
+/*-------------------------------------------------------------------*
+ * srt_vec_ind()
+ *
+ * sort vector and save sorting indeces
+ *-------------------------------------------------------------------*/
+
+void srt_vec_ind16_fx (
+ const Word16 *linear, /* linear input */
+ Word16 *srt, /* sorted output*/
+ Word16 *I, /* index for sorted output */
+ Word16 length
+)
+{
+ Word16 pos,npos;
+ Word16 idxMem;
+ Word16 valMem;
+
+ /*initilize */
+ FOR (pos = 0; pos < length; pos++)
+ {
+ I[pos] = pos;
+ move16();
+ }
+
+ Copy(linear, srt,length);
+
+ /* now iterate */
+ FOR (pos = 0; pos < (length - 1); pos++)
+ {
+ FOR (npos = (pos + 1); npos < length; npos++)
+ {
+ IF (LT_16(srt[npos], srt[pos]))
+ {
+ idxMem = I[pos];
+ move16();
+ I[pos] = I[npos];
+ move16();
+ I[npos] = idxMem;
+ move16();
+
+ valMem = srt[pos];
+ move16();
+ srt[pos] = srt[npos];
+ move16();
+ srt[npos] = valMem;
+ move16();
+ }
+ }
+ }
+
+ return;
+}
+
+/*-----------------------------------------------------------------------------
+ * atan2_fx():
+ *
+ * Approximates arctan piecewise with various 4th to 5th order least square fit
+ * polynomials for input in 5 segments:
+ * - 0.0 to 1.0
+ * - 1.0 to 2.0
+ * - 2.0 to 4.0
+ * - 4.0 to 8.0
+ * - 8.0 to infinity
+ *---------------------------------------------------------------------------*/
+Word16 atan2_fx( /* o: Angle between 0 and PI/2 radian (Q14) */
+ const Word32 y, /* i: Argument must be positive (Q15) */
+ const Word32 x /* i: Q15 */
+)
+{
+ Word32 acc, arg;
+ Word16 man, expo, reciprocal;
+ Word16 angle, w, z;
+
+ IF (x == 0)
+ {
+ return 25736; /* PI/2 in Q14 */
+ }
+ man = ratio(y, x, &expo); /* man in Q14 */
+ expo = sub(expo, (15 - 14)); /* Now, man is considered in Q15 */
+ arg = L_shr((Word32)man, expo);
+
+ IF (L_shr(arg, 3+15) != 0)
+ /*===============================*
+ * 8.0 <= x < infinity *
+ *===============================*/
+ {
+ /* atan(x) = PI/2 - 1/x + 1/(3x^3) - 1/(5x^5) + ...
+ * ~ PI/2 - 1/x, for x >= 8.
+ */
+ expo = norm_l(arg);
+ man = extract_h(L_shl(arg, expo));
+ reciprocal = div_s(0x3fff, man);
+ expo = sub(15 + 1, expo);
+ reciprocal = shr(reciprocal, expo); /* Q14 */
+ angle = sub(25736, reciprocal); /* Q14 (PI/2 - 1/x) */
+
+ /* For 8.0 <= x < 10.0, 1/(5x^5) is not completely negligible.
+ * For more accurate result, add very small correction term.
+ */
+ if (LT_32(L_shr(arg, 15), 10L))
+ {
+ angle = add(angle, 8); /* Add tiny correction term. */
+ }
+ }
+ ELSE IF (L_shr(arg, 2+15) != 0)
+ /*==========================*
+ * 4.0 <= x < 8.0 *
+ *==========================*/
+ {
+ /* interval: [3.999, 8.001]
+ * atan(x) ~ (((a0*x + a1)*x + a2)*x + a3)*x + a4
+ * = (((a0*8*y + a1)*8*y + a2)*8*y + a3)*8*y + a4 Substitute 8*y -> x
+ * = (((a0*8^3*y + a1*8^2)*y + a2*8)*y + a3)*8*y + a4
+ * = ((( c0*y + c1)*y + c2)*y + c3)*8*y + c4,
+ * where y = x/8
+ * and a0 = -1.28820869667651e-04, a1 = 3.88263533346295e-03,
+ * a2 = -4.64216306484597e-02, a3 = 2.75986060068931e-01,
+ * a4 = 7.49208077809799e-01.
+ */
+ w = extract_l(L_shr(arg, 3)); /* Q15 y = x/8 */
+ acc = L_add(533625337L, 0); /* Q31 c1 = a1*8^2 */
+ z = mac_r(acc, w, -2161); /* Q15 c0 = a0*8^3 */
+ acc = L_add(-797517542L, 0); /* Q31 c2 = a2*8 */
+ z = mac_r(acc, w, z); /* Q15 */
+ acc = L_add(592675551L, 0); /* Q31 c3 = a3 */
+ z = mac_r(acc, w, z); /* z (in:Q15, out:Q12) */
+ acc = L_add(201114012L, 0); /* Q28 c4 = a4 */
+ acc = L_mac(acc, w, z); /* Q28 */
+ angle = extract_l(L_shr(acc, (28 - 14))); /* Q14 result of atan(x), where 4 <= x < 8 */
+ }
+ ELSE IF (L_shr(arg, 1+15) != 0)
+ /*==========================*
+ * 2.0 <= x < 4.0 *
+ *==========================*/
+ {
+ /* interval: [1.999, 4.001]
+ * atan(x) ~ (((a0*x + a1)*x + a2)*x + a3)*x + a4
+ * = (((a0*4*y + a1)*4*y + a2)*4*y + a3)*4*y + a4 Substitute 4*y -> x
+ * = (((a0*16*y + a1*4)*y + a2)*4*y + a3)*4*y + a4
+ * = (((a0*32*y + a1*8)*y + a2*2)*2*y + a3)*4*y + a4
+ * = ((( c0*y + c1)*y + c2)*2*y + c3)*4*y + c4,
+ * where y = x/4
+ * and a0 = -0.00262378195660943, a1 = 0.04089687039888652,
+ * a2 = -0.25631148958325911, a3 = 0.81685854627399479,
+ * a4 = 0.21358070563097167
+ * */
+ w = extract_l(L_shr(arg, 2)); /* Q15 y = x/4 */
+ acc = L_add(702602883L, 0); /* Q31 c1 = a1*8 */
+ z = mac_r(acc, w, -2751); /* Q15 c0 = a0*32 */
+ acc = L_add(-1100849465L, 0); /* Q31 c2 = a2*2 */
+ z = mac_r(acc, w, z); /* z (in:Q15, out:Q14) */
+ acc = L_add(877095185L, 0); /* Q30 c3 = a3 */
+ z = mac_r(acc, w, z); /* z (in:Q14, out:Q12) */
+ acc = L_add(57332634L, 0); /* Q28 c4 = a4 */
+ acc = L_mac(acc, w, z); /* Q28 */
+ angle = extract_l(L_shr(acc, (28 - 14))); /* Q14 result of atan(x) where 2 <= x < 4 */
+ }
+ ELSE IF (L_shr(arg, 15) != 0)
+ /*==========================*
+ * 1.0 <= x < 2.0 *
+ *==========================*/
+ {
+ /* interval: [0.999, 2.001]
+ * atan(x) ~ (((a0*x + 1)*x + a2)*x + a3)*x + a4
+ * = (((a0*2*y + a1)*2*y + a2)*2*y + a3)*2*y + a4 Substitute 2*y -> x
+ * = (((a0*4*y + a1*2)*y + a2)*2*y + a3)*2*y + a4
+ * = (((a0*4*y + a1*2)*y + a2)*y + a3/2)*4*y + a4
+ * = ((( c0*y + c1)*y + c2)*y + c3)*4*y + c4,
+ * where y = x/2
+ * and a0 = -0.0160706457245251, a1 = 0.1527106504065224,
+ * a2 = -0.6123208404800871, a3 = 1.3307896976322915,
+ * a4 = -0.0697089375247448
+ */
+ w = extract_l(L_shr(arg, 1)); /* Q15 y= x/2 */
+ acc = L_add(655887249L, 0); /* Q31 c1 = a1*2 */
+ z = mac_r(acc, w, -2106); /* Q15 c0 = a0*4 */
+ acc = L_add(-1314948992L, 0); /* Q31 c2 = a2 */
+ z = mac_r(acc, w, z);
+ acc = L_add(1428924557L, 0); /* Q31 c3 = a3/2 */
+ z = mac_r(acc, w, z); /* z (in:Q15, out:Q13) */
+ acc = L_add(-37424701L, 0); /* Q29 c4 = a4 */
+ acc = L_mac(acc, w, z); /* Q29 */
+ angle = extract_l(L_shr(acc, (29 - 14))); /* Q14 result of atan(x) where 1 <= x < 2 */
+ }
+ ELSE
+ /*==========================*
+ * 0.0 <= x < 1.0 *
+ *==========================*/
+ {
+ /* interval: [-0.001, 1.001]
+ * atan(x) ~ ((((a0*x + a1)*x + a2)*x + a3)*x + a4)*x + a5
+ * = ((((a0*2*x + a1*2)*x/2 + a2)*x + a3)*x + a4)*x + a5
+ * = (((( c0*x + c1)*x/2 + c2)*x + c3)*x + c4)*x + c5
+ * where
+ * a0 = -5.41182677118661e-02, a1 = 2.76690449232515e-01,
+ * a2 = -4.63358392562492e-01, a3 = 2.87188466598566e-02,
+ * a4 = 9.97438122814383e-01, a5 = 5.36158556179092e-05.
+ */
+ w = extract_l(arg); /* Q15 */
+ acc = L_add(1188376431L, 0); /* Q31 c1 = a1*2 */
+ z = mac_r(acc, w, -3547); /* Q15 c0 = a0*2 */
+ acc = L_add(-995054571L, 0); /* Q31 c2 = a2 */
+ z = extract_h(L_mac0(acc, w, z)); /* Q15 non-fractional mode multiply */
+ acc = L_add(61673254L, 0); /* Q31 c3 = a3 */
+ z = mac_r(acc, w, z);
+ acc = L_add(2141982059L, 0); /* Q31 c4 = a4 */
+ z = mac_r(acc, w, z);
+ acc = L_add(115139L, 0); /* Q31 c5 = a5 */
+ acc = L_mac(acc, w, z); /* Q31 */
+ angle = extract_l(L_shr(acc, 31 - 14)); /* Q14 result of atan(x), where 0 <= x < 1 */
+ }
+
+ return angle; /* Q14 between 0 and PI/2 radian. */
+}
+
+
+
diff --git a/lib_com/range_com_fx.c b/lib_com/range_com_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..1e7aa09b07e312f64eb1b6eb928e3df574bc1044
--- /dev/null
+++ b/lib_com/range_com_fx.c
@@ -0,0 +1,62 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h" /* required for wmc_tool */
+
+
+/*-------------------------------------------------------------------*
+ * rc_get_bits2()
+ *
+ * Get number of bits needed to finalize range coder
+ *-------------------------------------------------------------------*/
+
+Word16 rc_get_bits2_fx( /* o: Number of bits needed */
+ const Word16 N, /* i: Number of bits currently used */
+ const UWord32 range /* i: Range of range coder */
+)
+{
+ return add(add(N, 2), norm_ul(range));
+}
+
+void rangeCoderFinalizationFBits_fx(
+ Word16 Brc,
+ UWord32 INTrc,
+ Word16 *FBits
+)
+{
+ Word32 L_Bq15;
+ UWord32 h, UL_tmp;
+ UWord16 Bq15ui16, l;
+ Word16 B, E, x, k;
+ *FBits = shl(add(Brc, 32), 3);
+
+ B = sub(30, norm_ul(INTrc));
+ x = sub(B, RCF_INIT_SHIFT );
+ L_Bq15 = 0;
+ move16();
+ if (x >= 0)
+ {
+ L_Bq15 = (Word32)UL_lshr(INTrc, x);
+ }
+
+ E = 2;
+ move16();
+ FOR(k = 1; k < 4; k++)
+ {
+ Bq15ui16 = u_extract_l(L_shr(L_Bq15, s_and(E, 1)));
+ UL_tmp = UL_lshl(UL_deposit_l(Bq15ui16), 1);
+ Mpy_32_16_uu(UL_tmp, Bq15ui16, &h , &l);
+ L_Bq15 = (Word32) h;
+ E = add(shl(B, 1), extract_l(L_lshr(L_sub(((1L << 16) - 1L), L_Bq15), 31)));
+ B = E;
+ move16();
+ }
+ *FBits = sub(*FBits, B);
+ return;
+}
+
diff --git a/lib_com/re8_ppv_fx.c b/lib_com/re8_ppv_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..873ff54dac05bbc30a5d62585081fb39844980c0
--- /dev/null
+++ b/lib_com/re8_ppv_fx.c
@@ -0,0 +1,193 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+
+/*-------------------------------------------------------------------*
+ * Prototypes
+ *-------------------------------------------------------------------*/
+
+static void nearest_neighbor_2D8_fx( const Word32 x[], Word16 y[] );
+static Word32 compute_error_2D8_fx( const Word32 x[], const Word16 y[] );
+
+/*--------------------------------------------------------------*
+ * RE8_PPV:
+ *
+ * NEAREST NEIGHBOR SEARCH IN INFINITE LATTICE RE8
+ * the algorithm is based on the definition of RE8 as
+ * RE8 = (2D8) U (2D8+[1,1,1,1,1,1,1,1])
+ * it applies the coset decoding of Sloane and Conway
+ * --------------------------------------------------------------*/
+
+void re8_PPV_fx(
+ const Word32 x[], /* i : point in R^8Q15 */
+ Word16 y[] /* o : point in RE8 (8-dimensional integer vector) */
+)
+{
+ Word16 i, y0[8];
+ Word32 e0, e1, x1[8];
+
+ /*--------------------------------------------------------------*
+ * find the nearest neighbor y0 of x in 2D8
+ *--------------------------------------------------------------*/
+ nearest_neighbor_2D8_fx( x, y0 );
+
+ /*--------------------------------------------------------------*
+ * find the nearest neighbor y1 of x in 2D8+(1,...,1) (by coset decoding)
+ *--------------------------------------------------------------*/
+
+ FOR( i=0; i<8; i++ )
+ {
+ x1[i] = L_sub(x[i], QR);
+ move32();
+ }
+ nearest_neighbor_2D8_fx( x1, y );
+
+ FOR ( i = 0; i < 8; i++ )
+ {
+ y[i] = add(y[i], 1);
+ move16();
+ }
+
+ /*--------------------------------------------------------------*
+ * compute e0=||x-y0||^2 and e1=||x-y1||^2
+ *--------------------------------------------------------------*/
+
+ e0 = compute_error_2D8_fx( x, y0 );
+ e1 = compute_error_2D8_fx( x, y );
+
+
+ /*--------------------------------------------------------------*
+ * select best candidate y0 or y1 to minimize distortion
+ *--------------------------------------------------------------*/
+ IF( LT_32(e0, e1))
+ {
+ Copy( y0, y, 8 );
+ }
+
+ return;
+}
+
+
+/*--------------------------------------------------------------*
+ * Nearest_neighbor_2D8(x,y)
+ *
+ * NEAREST NEIGHBOR SEARCH IN INFINITE LATTICE 2D8
+ * algorithm: nn_2D8(x) = 2*nn_D8(x/2)
+ * nn_D8 = decoding of Z^8 with Wagner rule
+ * (see Conway and Sloane's paper in IT-82)
+ --------------------------------------------------------------*/
+
+static void nearest_neighbor_2D8_fx(
+ const Word32 x[], /* i : point in R^8 */
+ Word16 y[] /* o : point in 2D8 (8-dimensional integer vector) */
+)
+{
+ Word16 i,j;
+ Word16 sum, tmp16, tmp16b;
+ Word32 s, e, em;
+
+ /*--------------------------------------------------------------*
+ * round x into 2Z^8 i.e. compute y=(y1,...,y8) such that yi = 2[xi/2]
+ * where [.] is the nearest integer operator
+ * in the mean time, compute sum = y1+...+y8
+ *--------------------------------------------------------------*/
+ sum = 0;
+ move16();
+
+ FOR( i=0; i<8; i++ )
+ {
+ /* round to ..., -2, 0, 2, ... ([-1..1[ --> 0) */
+ tmp16 = round_fx(L_add(x[i], L_shr(x[i], 31)));
+ y[i] = shl(tmp16, 1);
+ move16();
+ /* sum += y[i] */
+ sum = add(sum, y[i]);
+ }
+
+ /*--------------------------------------------------------------*
+ * check if y1+...+y8 is a multiple of 4
+ * if not, y is not round xj in the wrong way where j is defined by
+ * j = arg max_i | xi -yi|
+ * (this is called the Wagner rule)
+ *--------------------------------------------------------------*/
+ IF( s_and(sum, 2) != 0 )
+ {
+ /* find j = arg max_i | xi -yi| */
+ em = L_deposit_l(0);
+ j = 0;
+ move16();
+
+ FOR( i=0; i<8; i++ )
+ {
+ /* compute ei = xi-yi */
+ /* e[i]=x[i]-y[i] */
+ e = L_msu(x[i], y[i], QR/2);
+
+ /* compute |ei| = | xi-yi | */
+ s = L_abs(e);
+
+ /* check if |ei| is maximal, if so, set j=i */
+ if( LT_32(em, s))
+ {
+ j = i;
+ move16();
+ }
+ em = L_max(s, em);
+ }
+
+ /* round xj in the "wrong way" */
+ e = L_msu(x[j], y[j], QR/2);
+ tmp16 = extract_h(e);
+ tmp16b = add(y[j], 2);
+
+ if( tmp16 < 0 )
+ {
+ tmp16b = sub(tmp16b, 2+2);
+ }
+ y[j] = tmp16b;
+ move16();
+ }
+
+ return;
+}
+
+
+/*--------------------------------------------------------------*
+ * Compute_error_2D8(x,y)
+ *
+ * Compute mean square error between input vector and
+ * (quantized) point in 2D8.
+ --------------------------------------------------------------*/
+
+static Word32 compute_error_2D8_fx( /* o : mean squared error */
+ const Word32 x[], /* i : input vector */
+ const Word16 y[] /* i : point in 2D8 (8-dimensional integer vector) */
+)
+{
+ Word16 i, hi, lo;
+ Word32 err, Ltmp;
+
+ err = L_deposit_l(0);
+ FOR( i=0; i<8; i++ )
+ {
+ /*tmp = x[i]-y[i];*/
+ Ltmp = L_msu(x[i], y[i], 16384);
+ hi = extract_h(L_shl(Ltmp, 1));
+ lo = extract_l(L_msu(Ltmp, hi, 16384));
+
+ Ltmp = L_mult(hi, hi);
+ Ltmp = L_shl(Ltmp, 14);
+ Ltmp = L_mac(Ltmp, hi, lo);
+ Ltmp = L_mac0(Ltmp, mult(lo, lo), 1);
+
+ /* err+=tmp*tmp */
+ err = L_add(Ltmp, err);
+ }
+
+ return( err );
+}
diff --git a/lib_com/re8_util_fx.c b/lib_com/re8_util_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..b67c73f59edcdbb076bb9902b338d07d8ba886a9
--- /dev/null
+++ b/lib_com/re8_util_fx.c
@@ -0,0 +1,387 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "cnst_fx.h" /* Common constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+#include "prot_fx.h" /* Function prototypes */
+#include "stl.h"
+
+
+/*-------------------------------------------------------------------*
+ * Prototypes
+ *-------------------------------------------------------------------*/
+
+static Word16 re8_identify_absolute_leader_fx( const Word16 y[] );
+static void re8_coord_fx( const Word16 *y, Word16 *k) ;
+
+
+/*----------------------------------------------------------------*
+ * re8_vor_fx()
+ *
+ * MULTI-RATE RE8 INDEXING BY VORONOI EXTENSION
+ *----------------------------------------------------------------*/
+void re8_vor_fx(
+ const Word16 y[], /* i : point in RE8 (8-dimensional integer vector) */
+ Word16 *n, /* o : codebook number n=0,2,3,4,... (scalar integer) */
+ Word16 k[], /* o : Voronoi index (integer vector of dimension 8) used only if n>4*/
+ Word16 c[], /* o : codevector in Q0, Q2, Q3, or Q4 if n<=4, y=c */
+ Word16 *ka /* o : identifier of absolute leader (to index c) */
+)
+{
+ Word16 i, r, iter, ka_tmp, n_tmp, mask;
+ Word16 k_tmp[8], v[8], c_tmp[8], k_mod[8];
+ Word32 Ltmp, Lsphere;
+
+ /*----------------------------------------------------------------*
+ * verify if y is in Q0, Q2, Q3 or Q4
+ * (a fast search is used here:
+ * the codebooks Q0, Q2, Q3 or Q4 are specified in terms of RE8 absolute leaders
+ * (see FORinstance Xie and Adoul's paper in ICASSP 96)
+ * - a unique code identifying the absolute leader related to y is computed
+ * in re8_identify_absolute_leader()
+ * this code is searched FORin a pre-defined list which specifies Q0, Q2, Q3 or Q4)
+ * the absolute leader is identified by ka
+ * - a translation table maps ka to the codebook number n)
+ *----------------------------------------------------------------*/
+ *ka = re8_identify_absolute_leader_fx( y );
+ move16();
+
+ /*----------------------------------------------------------------*
+ * compute codebook number n of Qn (by table look-up)
+ * at this stage, n=0,2,3,4 or out=100
+ *----------------------------------------------------------------*/
+ *n = Da_nq_fx[*ka];
+ move16();
+
+ /*----------------------------------------------------------------*
+ * decompose y into :
+ * (if n<=4:)
+ * y = c where c is in Q0, Q2, Q3 or Q4
+ * or
+ * (if n>4:)
+ * y = m c + v where c is in Q3 or Q4, v is a Voronoi codevector
+ * m=2^r (r integer >=2)
+ *
+ * in the latter case (if n>4), as a side-product, compute the (Voronoi) index k[] of v
+ * and replace n by n = n' + 2r where n' = 3 or 4 (c is in Qn') and r is defined above
+ *----------------------------------------------------------------*/
+
+ IF( LE_16(*n, 4))
+ {
+ Copy( y, c, 8 );
+ }
+ ELSE
+ {
+ /*------------------------------------------------------------*
+ * initialize r and m=2^r based on || y ||^2/8
+ *------------------------------------------------------------*/
+ Ltmp = L_mult(y[0], y[0]);
+ FOR( i = 1; i < 8; i++ )
+ {
+ Ltmp = L_mac( Ltmp, y[i], y[i]);
+ }
+
+ Lsphere = L_shr(Ltmp, 5+1); /* *0.125*0.25 / 2 to remove L_mac effect */
+
+ r = 1;
+ move16();
+ FOR( ; Lsphere > 11; Lsphere >>= 2 )
+ {
+ r = add(r, 1);
+ }
+ /*------------------------------------------------------------*
+ * compute the coordinates of y in the RE8 basis
+ *------------------------------------------------------------*/
+ re8_coord_fx( y, k_mod );
+
+ /*------------------------------------------------------------*
+ * compute m and the mask needed for modulo m (for Voronoi coding)
+ *------------------------------------------------------------*/
+ mask = sub(shl(1, r), 1); /* 0x0..011...1 */
+
+ /*------------------------------------------------------------*
+ * find the minimal value of r (or equivalently of m) in 2 iterations
+ *------------------------------------------------------------*/
+
+ FOR( iter=0; iter<2; iter++ )
+ {
+ /*--------------------------------------------------------*
+ * compute v such that y is in m RE_8 +v (by Voronoi coding)
+ *--------------------------------------------------------*/
+ FOR( i=0; i<8; i++ )
+ {
+ k_tmp[i] = s_and( k_mod[i], mask);
+ move16();
+ }
+
+ re8_k2y_fx( k_tmp, r, v );
+
+ /*--------------------------------------------------------*
+ * compute c = (y-v)/m
+ * (y is in RE8, c is also in RE8 by definition of v)
+ *--------------------------------------------------------*/
+
+ FOR( i=0; i<8; i++ )
+ {
+ c_tmp[i] = shr(sub(y[i], v[i]), r);
+ move16();
+ }
+
+ /*--------------------------------------------------------*
+ * verify if c_tmp is in Q2, Q3 or Q4
+ *--------------------------------------------------------*/
+ ka_tmp = re8_identify_absolute_leader_fx( c_tmp );
+
+ /*--------------------------------------------------------*
+ * at this stage, n_tmp=2,3,4 or out = 100 -- n=0 is not possible
+ *--------------------------------------------------------*/
+ n_tmp = Da_nq_fx[ka_tmp];
+ move16();
+
+ IF( GT_16(n_tmp, 4))
+ {
+ /*--------------------------------------------------------*
+ * if c is not in Q2, Q3, or Q4 (i.e. n_tmp>4), use m = 2^(r+1) instead of 2^r
+ *--------------------------------------------------------*/
+ r = add(r, 1);
+ mask = add(shl(mask, 1), 1); /* mask = m-1 <- this is less complex */
+ }
+ ELSE
+ {
+ /*--------------------------------------------------------*
+ * c is in Q2, Q3, or Q4 -> the decomposition of y as y = m c + v is valid
+ *
+ * since Q2 is a subset of Q3, indicate n=3 instead of n=2 (this is because
+ * for n>4, n=n'+2r with n'=3 or 4, so n'=2 is not valid)
+ *--------------------------------------------------------*/
+ n_tmp = s_max(n_tmp, 3);
+
+ /*--------------------------------------------------------*
+ * save current values into ka, n, k and c
+ *--------------------------------------------------------*/
+ *ka = ka_tmp;
+ move16();
+ *n = add(n_tmp, shl(r, 1));
+ move16();
+ Copy( k_tmp, k, 8 );
+ Copy( c_tmp, c, 8 );
+
+ /*--------------------------------------------------------*
+ * try m = 2^(r-1) instead of 2^r to be sure that m is minimal
+ *--------------------------------------------------------*/
+ r = sub(r, 1);
+ mask = shr(mask, 1);
+ }
+ }
+ }
+
+ return;
+}
+
+
+/*-------------------------------------------------------------------------
+ * re8_k2y_fx()
+ *
+ * VORONOI INDEXING (INDEX DECODING) k -> y
+ -------------------------------------------------------------------------*/
+void re8_k2y_fx(
+ const Word16 *k, /* i : Voronoi index k[0..7] */
+ const Word16 m, /* i : Voronoi modulo (m = 2^r = 1<=2) */
+ Word16 *y /* o : 8-dimensional point y[0..7] in RE8 */
+)
+{
+ Word16 i, v[8], *ptr1, *ptr2, m_tmp, mm;
+ Word32 ytp[8], z[8], Ltmp, Lsum ;
+
+ /*---------------------------------------------------------------*
+ * compute y = k M and z=(y-a)/m, where
+ * M = [4 ]
+ * [2 2 ]
+ * [| \ ]
+ * [2 2 ]
+ * [1 1 _ 1 1]
+ * a=(2,0,...,0)
+ *---------------------------------------------------------------*/
+ m_tmp = sub(15, m);
+
+ Lsum = L_deposit_l(k[7]);
+ ytp[7] = Lsum;
+ move32();
+ z[7] = L_shl(Lsum, m_tmp);
+ move32(); /* (int)(floor(y[7]*QR+0.5))>>m */
+
+ FOR( i=6; i>=1; i-- )
+ {
+ Ltmp = L_deposit_l( shl(k[i],1) );
+ Lsum = L_add (Lsum, Ltmp);
+ ytp[i] = L_add(ytp[7], Ltmp);
+ move32();
+ z[i] = L_shl(ytp[i], m_tmp);
+ move32(); /* (int)(floor(y[7]*QR+0.5))>>m */
+ }
+
+ Lsum = L_add( Lsum, L_deposit_l(shl(k[0],2) ));
+ ytp[0] = Lsum;
+ move32();
+ z[0] = L_shl(L_sub(Lsum, 2), m_tmp);
+ move32(); /* (int)(floor(y[7]*QR+0.5))>>m */
+
+ /*---------------------------------------------------------------*
+ * find nearest neighbor v of z in infinite RE8
+ *---------------------------------------------------------------*/
+ re8_PPV_fx( z, v );
+
+ /*---------------------------------------------------------------*
+ * compute y -= m v
+ *---------------------------------------------------------------*/
+ ptr1=y;
+ ptr2=v;
+
+ mm = shr(shl(1, m), 1); /* shr to remove effect of L_mult in L_msu */
+
+ FOR( i=0; i<8; i++ )
+ {
+ Ltmp = L_msu(ytp[i], *ptr2++, mm);
+ *ptr1++ = extract_l(Ltmp);
+ }
+
+ return;
+}
+
+
+/*-----------------------------------------------------------------------*
+ * re8_identify_absolute_leader:
+ *
+ * IDENTIFY THE ABSOLUTE LEADER RELATED TO y USING A PRE-DEFINED TABLE WHICH
+ * SPECIFIES THE CODEBOOKS Q0, Q2, Q3 and Q4
+ -----------------------------------------------------------------------*/
+
+static Word16 re8_identify_absolute_leader_fx( /* o : integer indicating if y if in Q0, Q2, Q3 or Q4 (or if y is an outlier) */
+ const Word16 y[] /* i : point in RE8 (8-dimensional integer vector) */
+)
+{
+ Word16 i,s,id,nb,pos,ka, tmp16;
+ Word32 Ltmp, Ls;
+ Word32 C;
+ const Word16 *ptr;
+
+ /*-----------------------------------------------------------------------*
+ * compute the RE8 shell number s = (y1^2+...+y8^2)/8 and C=(y1^2, ..., y8^2)
+ *-----------------------------------------------------------------------*/
+ Ls = L_mult(y[0], y[0]);
+ FOR( i = 1; i < 8; i++ )
+ {
+ Ls = L_mac( Ls, y[i], y[i]);
+ }
+ s = extract_h(L_shl(Ls, 16-(3+1))); /* s can saturate here */
+
+ /*-----------------------------------------------------------------------*
+ * compute the index 0 <= ka <= NB_LEADER+1 which identifies an absolute leader of Q0, Q2, Q3 or Q4
+ *
+ * by default, ka=index of last element of the table (to indicate an outlier)
+ *-----------------------------------------------------------------------*/
+ /*-------------------------------------------------------------------*
+ * if s=0, y=0 i.e. y is in Q0 -> ka=index of element indicating Q0
+ *-------------------------------------------------------------------*/
+ ka = NB_LEADER;
+ move16();
+ IF( s != 0 )
+ {
+ ka = NB_LEADER+1;
+ move16();
+ /*-------------------------------------------------------------------*
+ * the maximal value of s for y in Q0, Q2, Q3 or Q4 is NB_SPHERE
+ * if s> NB_SPHERE, y is an outlier (the value of ka is set correctly)
+ *-------------------------------------------------------------------*/
+ IF( LE_16(s, NB_SPHERE))
+ {
+ /*---------------------------------------------------------------*
+ * compute the unique identifier id of the absolute leader related to y:
+ * s = (y1^4 + ... + y8^4)/8
+ *---------------------------------------------------------------*/
+ C = L_mult(y[0], y[0]);
+ tmp16 = extract_h(L_shl(C, 16-1));
+ Ltmp = L_mult(tmp16, tmp16);
+ FOR( i=1; i<8; i++ )
+ {
+ C = L_mult(y[i], y[i]);
+ tmp16 = extract_h(L_shl(C, 16-1));
+ Ltmp = L_mac(Ltmp, tmp16, tmp16);
+ }
+ id = extract_h(L_shl(Ltmp, 16-(3+1))); /* id can saturate to 8192 */
+
+ /*---------------------------------------------------------------*
+ * search for id in table Da_id
+ * (containing all possible values of id if y is in Q2, Q3 or Q4)
+ * this search is focused based on the shell number s so that
+ * only the id's related to the shell of number s are checked
+ *---------------------------------------------------------------*/
+
+ nb = Da_nb_fx[s - 1]; /* get the number of absolute leaders used on the shell of number s */
+ pos = Da_pos_fx[s - 1]; /* get the position of the first absolute leader of shell s in Da_id */
+ move16();
+ move16();
+
+ ptr = &Da_id_fx[pos];
+ move16();
+ FOR( i=0; i=1; i-- )
+ {
+ /* apply factor 2/4 from M^-1 */
+ k[i] = shr(sub(y[i], tmp), 1);
+ move16();
+ sum = sub(sum, y[i]);
+ }
+ /* apply factor 1/4 from M^-1 */
+ k[0]= shr(add(y[0], sum), 2);
+ move16();
+
+ return;
+}
diff --git a/lib_com/recovernorm_fx.c b/lib_com/recovernorm_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..f061c71eff8a959140fb851019764ce5ad92743a
--- /dev/null
+++ b/lib_com/recovernorm_fx.c
@@ -0,0 +1,62 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "stl.h" /* required for wmc_tool */
+#include "prot_fx.h" /* Function prototypes */
+#include "cnst_fx.h" /* Common constants */
+#include "rom_com_fx.h" /* Static table prototypes */
+
+/*--------------------------------------------------------------------------*
+ * recovernorm_fx()
+ *
+ * Recover reordered quantization indices and norms
+ *--------------------------------------------------------------------------*/
+
+void recovernorm_fx(
+ Word16 *idxbuf, /* i : reordered quantization indices */
+ Word16 *ynrm, /* o : recovered quantization indices */
+ Word16 *normqlg2, /* o : recovered quantized norms */
+ Word16 nb_sfm /* i : number of SFMs */
+)
+{
+ Word16 i,j,k;
+ const Word16 *order = NULL;
+ move16();
+
+ SWITCH (nb_sfm)
+ {
+ case NB_SFM:
+ order = norm_order_48;
+ move16();
+ BREAK;
+ case SFM_N_SWB:
+ order = norm_order_32;
+ move16();
+ BREAK;
+ case SFM_N_WB:
+ order = norm_order_16;
+ move16();
+ BREAK;
+ default:
+ order = norm_order_48;
+ move16();
+ BREAK;
+ }
+
+ FOR (i = 0; i < nb_sfm; i++)
+ {
+ j = order[i];
+ move16();
+ k = idxbuf[i];
+ move16();
+ ynrm[j] = k;
+ move16();
+ normqlg2[j] = dicnlg2[k];
+ move16();
+ }
+
+ return;
+}
+
diff --git a/lib_com/reordvct_fx.c b/lib_com/reordvct_fx.c
new file mode 100644
index 0000000000000000000000000000000000000000..952c483d000c9838059d047c59c8c328d8161415
--- /dev/null
+++ b/lib_com/reordvct_fx.c
@@ -0,0 +1,58 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "options.h" /* Compilation switches */
+#include "stl.h"
+#include "prot_fx.h" /* Function prototypes */
+
+
+/*--------------------------------------------------------------------------*
+ * reordvct()
+ *
+ * Rearrange a vector in decreasing order
+ *--------------------------------------------------------------------------*/
+
+void reordvct_fx(
+ Word16 *y, /* i/o: vector to rearrange */
+ const Word16 N, /* i : dimensions */
+ Word16 *idx /* o : reordered vector index */
+)
+{
+ Word16 i, j, k, n, im, temp;
+
+ n = sub(N, 1);
+ move16();
+ FOR (i=0; i 0)
+ q = add(q, shift);
+ *y++ = shl(x[0], shift);
+ move16();
+
+ FOR (i = 1; i < m; i++)
+ {
+ s = L_mult(x[i], a[0]);
+ /* Stop at i to Avoid Mults with Zeros */
+ FOR (j = 1; j <= i; j++)
+ {
+ s = L_mac(s, x[i-j], a[j]);
+ }
+
+ s = L_shl(s, q);
+ *y++ = round_fx(s);
+ }
+
+ FOR (; i < lg; i++)
+ {
+ s = L_mult(x[i], a[0]);
+ FOR (j = 1; j <= m; j++)
+ {
+ s = L_mac(s, x[i-j], a[j]);
+ }
+
+ s = L_shl(s, q);
+ *y++ = round_fx(s);
+ }
+}
+
+/*--------------------------------------------------------------------*
+ * Residu3_10_fx:
+ *
+ * Compute the LP residual by filtering the input speech through A(z)
+ * Output is in Qx
+ *--------------------------------------------------------------------*/
+void Residu3_10_fx(
+ const Word16 a[], /* i : prediction coefficients Q12 */
+ const Word16 x[], /* i : input signal (usually speech) Qx */
+ /* (note that values x[-10..-1] are needed) */
+ Word16 y[], /* o : output signal (usually residual) Qx */
+ const Word16 lg, /* i : vector size Q0 */ const Word16 shift
+)
+{
+ Word16 i,j;
+ Word32 s;
+ Word64 s64;
+ Word16 q;
+ q = add( norm_s(a[0]), 1 );
+ if (shift != 0)
+ q = add(q, shift);
+ FOR (i = 0; i < lg; i++)
+ {
+ s64 = 0;
+ FOR (j = 0; j <= 10; j++)
+ {
+ s64 = W_mac_16_16(s64, x[i-j], a[j]);
+ }
+ s = W_shl_sat_l(s64, q);
+ y[i] = round_fx(s);
+ }
+}
+/*--------------------------------------------------------------------*
+ * Residu3_fx:
+ *
+ * Compute the LP residual by filtering the input speech through A(z)
+ * Output is in Qx
+ *--------------------------------------------------------------------*/
+void Residu3_fx(
+ const Word16 a[], /* i : prediction coefficients Q12 */
+ const Word16 x[], /* i : input signal (usually speech) Qx */
+ /* (note that values x[-M..-1] are needed) */
+ Word16 y[], /* o : output signal (usually residual) Qx */
+ const Word16 lg, /* i : vector size Q0 */
+ const Word16 shift
+)
+{
+ Word16 i, j;
+ Word64 s64;
+ Word32 s32;
+ Word16 q;
+ q = add( norm_s(a[0]), 1 );
+ if (shift != 0)
+ q = add(q, shift);
+ FOR (i = 0; i < lg; i++)
+ {
+ s64 = 0;
+ FOR (j = 0; j <= 15; j++)
+ {
+ s64 = W_mac_16_16(s64, x[i-j], a[j]);
+ }
+ s64 = W_mac_16_16(s64, x[i-16], a[16]);
+ s32 = W_shl_sat_l(s64, q);
+ y[i] = round_fx( s32 );
+ }
+}
+/*==========================================================================*/
+/* FUNCTION : void calc_residu() */
+/*--------------------------------------------------------------------------*/
+/* PURPOSE : Compute the LP residual by filtering the input through */
+/* A(z) in all subframes */
+/*--------------------------------------------------------------------------*/
+/* INPUT ARGUMENTS : */
+/* Word16 *speech i : weighted speech signal Qx */
+/* Word16 L_frame i : order of LP filter Q0 */
+/* Word16 *p_Aq i : quantized LP filter coefficients Q12 */
+/*--------------------------------------------------------------------------*/
+/* OUTPUT ARGUMENTS : */
+/* Word16 *res o : residual signal Qx+1 */
+/*--------------------------------------------------------------------------*/
+/* INPUT/OUTPUT ARGUMENTS : */
+/*--------------------------------------------------------------------------*/
+/* RETURN ARGUMENTS : */
+/* _ None */
+/*--------------------------------------------------------------------------*/
+/* CALLED FROM : */
+/*==========================================================================*/
+
+void calc_residu_fx(
+ Encoder_State_fx *st, /* i/o: state structure */
+ const Word16 *speech, /* i : weighted speech signal */
+ Word16 *res, /* o : residual signal */
+ const Word16 *p_Aq, /* i : quantized LP filter coefficients */
+ const Word16 vad_hover_flag,
+ const Word16 vad_flag_dtx
+)
+{
+ Word16 i_subfr;
+ Word16 i;
+ Word16 att;
+ Word16 offset;
+
+ FOR( i_subfr = 0; i_subfr < st->L_frame_fx; i_subfr += L_SUBFR )
+ {
+ /* calculate the residual signal */
+ Residu3_fx( p_Aq, &speech[i_subfr], &res[i_subfr], L_SUBFR, 1 );
+
+ /* next subframe */
+ p_Aq += (M+1);
+ }
+ /* smoothing in case of CNG */
+ test();
+ IF( (st->Opt_DTX_ON_fx != 0 ) && (vad_hover_flag != 0) ) /* corresponds to line 504 in FLT acelp_core_enc.c */
+ {
+ st->burst_ho_cnt_fx = add(st->burst_ho_cnt_fx,1);
+ st->burst_ho_cnt_fx = s_min(st->burst_ho_cnt_fx, HO_HIST_SIZE);
+ IF( NE_16(st->bwidth_fx, NB))
+ {
+ offset = 5;
+ test();
+ if( EQ_16(st->bwidth_fx, WB)&&st->CNG_mode_fx>=0)
+ {
+ offset = st->CNG_mode_fx;
+ move16();
+ }
+
+ att = CNG_burst_att_fx[offset][sub(st->burst_ho_cnt_fx,1)]; /*Q15*/
+
+ FOR( i = 0; i < st->L_frame_fx; i++ )
+ {
+ res[i] = mult_r(res[i], att);
+ move16();
+ }
+ }
+ }
+ ELSE
+ {
+ test();
+ IF( (st->Opt_DTX_ON_fx != 0) && (vad_flag_dtx != 0) )
+ {
+ st->burst_ho_cnt_fx = 0;
+ move16();
+ }
+ }
+ return;
+}
+
diff --git a/lib_com/rom_basop_util.c b/lib_com/rom_basop_util.c
new file mode 100644
index 0000000000000000000000000000000000000000..646653e87904352f6a82778bfed2190f429728e9
--- /dev/null
+++ b/lib_com/rom_basop_util.c
@@ -0,0 +1,991 @@
+/*====================================================================================
+ EVS Codec 3GPP TS26.452 Aug 12, 2021. Version 16.3.0
+ ====================================================================================*/
+
+#include "rom_basop_util.h"
+#include "stl.h"
+#include
+#include