Use full form rather than abbreviations

Change-Id: I709ef0c5eb0317d6996d147065f218b535d0cad3
Signed-off-by: Nishant Chaprana <n.chaprana@samsung.com>

diff --git a/include/NSLogger.h b/include/NSLogger.h
index 490ae6b..b8dc374 100644 (file)
--- a/include/NSLogger.h
+++ b/include/NSLogger.h
@@ -39,8 +39,8 @@ extern "C"
 {
 #endif /* __cplusplus */
 
-void set_ns_print(ns_log_cb print_func);
-void ns_print(const char* fmt, ...);
+void set_noise_suppression_print(noise_suppression_log_cb print_func);
+void noise_suppression_print(const char* fmt, ...);
 
 #ifdef __cplusplus
 }

diff --git a/include/log.h b/include/log.h
index a8526e5..e1e591d 100644 (file)
--- a/include/log.h
+++ b/include/log.h
@@ -36,9 +36,9 @@
 #include <string.h>
 #include "NSLogger.h"
 
-#define LOGI(fmt, arg...)  ns_print("[I] " fmt, ##arg)
-#define LOGE(fmt, arg...)  ns_print("[E] " fmt, ##arg)
-#define LOGD(fmt, arg...)  ns_print("[D] " fmt, ##arg)
+#define LOGI(fmt, arg...)  noise_suppression_print("[I] " fmt, ##arg)
+#define LOGE(fmt, arg...)  noise_suppression_print("[E] " fmt, ##arg)
+#define LOGD(fmt, arg...)  noise_suppression_print("[D] " fmt, ##arg)
 
 #define COLOR_YELLOW "\033[1;40;33m"
 #define COLOR_RED   "\033[0;40;31m"

diff --git a/include/modelParameters.h b/include/modelParameters.h
index fde7adf..b9f9d75 100644 (file)
--- a/include/modelParameters.h
+++ b/include/modelParameters.h
@@ -80,7 +80,7 @@ typedef struct st_ModelParams {
        int setModelParams(unsigned int _sample_rate, unsigned int max_delay_msec)
        {
                FN_START;
-               retv_if(10 >= max_delay_msec, NS_ERROR_INVALID_PARAMETER);
+               retv_if(10 >= max_delay_msec, NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER);
 
                try {
                        nb_bands = sampleRateToBand.at(_sample_rate);
@@ -100,11 +100,11 @@ typedef struct st_ModelParams {
                        freq_size = frame_size + 1;
                } catch (...) {
                        _E("Unsupported sample rate: %d", sample_rate);
-                       return NS_ERROR_INVALID_PARAMETER;
+                       return NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER;
                }
 
                FN_END;
-               return NS_ERROR_NONE;
+               return NOISE_SUPPRESSION_ERROR_NONE;
        }
 } ns_model_params_t;
 

diff --git a/include/noise-suppression-type.h b/include/noise-suppression-type.h
index 75e0fdd..aa623db 100644 (file)
--- a/include/noise-suppression-type.h
+++ b/include/noise-suppression-type.h
@@ -47,20 +47,20 @@ extern "C"
 #define TIZEN_ERROR_NOT_SUPPORTED -4
 #endif /* __has_include(<tizen_error.h>) */
 
-#define TIZEN_ERROR_NS -0x04F20000
+#define TIZEN_ERROR_NOISE_SUPPRESSION -0x04F20000
 typedef enum {
-       NS_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful*/
-       NS_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
-       NS_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
-       NS_ERROR_NOW_IN_PROGRESS = TIZEN_ERROR_NOW_IN_PROGRESS, /**< Operation now in progress */
-       NS_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< BT is Not Supported */
-       NS_ERROR_NOT_INITIALIZED = TIZEN_ERROR_NS | 0x0101, /**< Not initialized */
-       NS_ERROR_ALREADY_DONE = TIZEN_ERROR_NS | 0x0102, /**< Operation already done  */
-       NS_ERROR_OPERATION_FAILED = TIZEN_ERROR_NS | 0x0103, /**< Operation failed */
-       NS_ERROR_NOT_IN_PROGRESS = TIZEN_ERROR_NS | 0x0104, /**< Operation not in progress */
-} ns_error_e;
+       NOISE_SUPPRESSION_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful*/
+       NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+       NOISE_SUPPRESSION_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
+       NOISE_SUPPRESSION_ERROR_NOW_IN_PROGRESS = TIZEN_ERROR_NOW_IN_PROGRESS, /**< Operation now in progress */
+       NOISE_SUPPRESSION_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< BT is Not Supported */
+       NOISE_SUPPRESSION_ERROR_NOT_INITIALIZED = TIZEN_ERROR_NOISE_SUPPRESSION | 0x0101, /**< Not initialized */
+       NOISE_SUPPRESSION_ERROR_ALREADY_DONE = TIZEN_ERROR_NOISE_SUPPRESSION | 0x0102, /**< Operation already done  */
+       NOISE_SUPPRESSION_ERROR_OPERATION_FAILED = TIZEN_ERROR_NOISE_SUPPRESSION | 0x0103, /**< Operation failed */
+       NOISE_SUPPRESSION_ERROR_NOT_IN_PROGRESS = TIZEN_ERROR_NOISE_SUPPRESSION | 0x0104, /**< Operation not in progress */
+} noise_suppression_error_e;
 
-typedef void (*ns_log_cb)(const char *log);
+typedef void (*noise_suppression_log_cb)(const char *log);
 
 typedef void* (noise_suppression_h);
 

diff --git a/include/noise-suppression.h b/include/noise-suppression.h
index ab2ba6e..14034f7 100644 (file)
--- a/include/noise-suppression.h
+++ b/include/noise-suppression.h
@@ -40,22 +40,25 @@ extern "C"
 #endif /* __cplusplus */
 
 typedef enum {
-       NS_LEVEL_VERY_LOW,
-       NS_LEVEL_LOW,
-       NS_LEVEL_MID,
-       NS_LEVEL_HIGH,
-       NS_LEVEL_VERY_HIGH
-} ns_level_e;
+       NOISE_SUPPRESSION_LEVEL_VERY_LOW,
+       NOISE_SUPPRESSION_LEVEL_LOW,
+       NOISE_SUPPRESSION_LEVEL_MID,
+       NOISE_SUPPRESSION_LEVEL_HIGH,
+       NOISE_SUPPRESSION_LEVEL_VERY_HIGH
+} noise_suppression_level_e;
 
-int ns_initialize(ns_log_cb cb, const unsigned int input_sample_rate,
+int noise_suppression_initialize(noise_suppression_log_cb cb,
+               const unsigned int input_sample_rate,
                const unsigned int allowed_delay_msec,
                noise_suppression_h *handle, unsigned int *frame_size);
 
-void ns_deinitialize(noise_suppression_h handle);
+void noise_suppression_deinitialize(noise_suppression_h handle);
 
-int ns_set_level(noise_suppression_h handle, ns_level_e level);
+int noise_suppression_set_level(noise_suppression_h handle,
+               noise_suppression_level_e level);
 
-int ns_process_audio(noise_suppression_h handle, const float *in, float *out);
+int noise_suppression_process_audio(noise_suppression_h handle,
+               const float *in, float *out);
 
 #ifdef __cplusplus
 }

diff --git a/src/AudioProcessor.cpp b/src/AudioProcessor.cpp
index e488182..c2c6dee 100644 (file)
--- a/src/AudioProcessor.cpp
+++ b/src/AudioProcessor.cpp
@@ -145,7 +145,7 @@ int CAudioProcessor::init(unsigned int sample_rate, unsigned int max_delay_msec,
                {SAMPLE_RATE_48K, 22}
        };
 
-       retv_if(10 >= max_delay_msec, NS_ERROR_INVALID_PARAMETER);
+       retv_if(10 >= max_delay_msec, NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER);
        try {
                nb_bands = srToNbBands.at(sample_rate);
                nb_features = nb_bands + 3 * NB_DELTA_CEPS + 2;
@@ -158,7 +158,7 @@ int CAudioProcessor::init(unsigned int sample_rate, unsigned int max_delay_msec,
 
                if (frameSizeId < 0) {
                        _E("Could not get correct frame size multiple of only 2, 3, and 5");
-                       return NS_ERROR_OPERATION_FAILED;
+                       return NOISE_SUPPRESSION_ERROR_OPERATION_FAILED;
                }
 
                frame_size = (int)multiples_2_3_5[frameSizeId];
@@ -221,16 +221,16 @@ int CAudioProcessor::init(unsigned int sample_rate, unsigned int max_delay_msec,
                _E("bad_alloc caught: %s", ba.what());
                _E("System failed to allocate new memory for Core NS AudioProcessor");
                deinit();
-               return NS_ERROR_OUT_OF_MEMORY;
+               return NOISE_SUPPRESSION_ERROR_OUT_OF_MEMORY;
        } catch (...) {
                _E("Exception caught, sampleRate: %d, maxDelay: %d",
                                sample_rate, max_delay_msec);
                deinit();
-               return NS_ERROR_INVALID_PARAMETER;
+               return NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER;
        }
 
        FN_END;
-       return NS_ERROR_NONE;
+       return NOISE_SUPPRESSION_ERROR_NONE;
 }
 
 void CAudioProcessor::deinit()

diff --git a/src/AudioResampler.cpp b/src/AudioResampler.cpp
index 72fda60..f6eb1ce 100644 (file)
--- a/src/AudioResampler.cpp
+++ b/src/AudioResampler.cpp
@@ -47,18 +47,18 @@ int CAudioReSampler::init(unsigned int inputSR, unsigned int outputSR)
 {
        int err =0;
 
-       retv_if(isInitialized, NS_ERROR_NONE);
+       retv_if(isInitialized, NOISE_SUPPRESSION_ERROR_NONE);
 
        resampler = speex_resampler_init(
                        1, inputSR, outputSR, 10, &err);
        if (!resampler) {
                _E("speex_resampler_init() failed with %d", err);
-               return NS_ERROR_OPERATION_FAILED;
+               return NOISE_SUPPRESSION_ERROR_OPERATION_FAILED;
        }
 
        speex_resampler_skip_zeros(resampler);
        isInitialized = true;
-       return NS_ERROR_NONE;
+       return NOISE_SUPPRESSION_ERROR_NONE;
 }
 
 void CAudioReSampler::deinit()
@@ -74,7 +74,7 @@ void CAudioReSampler::deinit()
 int CAudioReSampler::resampleAudio(const float *in, unsigned int inputLen,
                float *out, unsigned int outputLen)
 {
-       retv_if(!isInitialized, NS_ERROR_NOT_INITIALIZED);
+       retv_if(!isInitialized, NOISE_SUPPRESSION_ERROR_NOT_INITIALIZED);
 
        if (inputLen != outputLen) {
                unsigned int in_len = inputLen;
@@ -84,11 +84,11 @@ int CAudioReSampler::resampleAudio(const float *in, unsigned int inputLen,
                                in, &in_len, out, &out_len);
                if (0 != err) {
                        _E("speex_resampler_process_float() fail with %d", err);
-                       return NS_ERROR_OPERATION_FAILED;
+                       return NOISE_SUPPRESSION_ERROR_OPERATION_FAILED;
                }
        } else {
                std::copy(in, (in + inputLen), out);
        }
 
-       return NS_ERROR_NONE;
+       return NOISE_SUPPRESSION_ERROR_NONE;
 }

diff --git a/src/DNNManager.cpp b/src/DNNManager.cpp
index 40dc067..f42917a 100644 (file)
--- a/src/DNNManager.cpp
+++ b/src/DNNManager.cpp
@@ -98,8 +98,8 @@ void serialize_weights(const GRULayer *gru)
 int CDNNManager::init(unsigned int inputSR, unsigned int *modelSR)
 {
 
-       retv_if(NULL == modelSR, NS_ERROR_INVALID_PARAMETER);
-       retv_if((16000 != inputSR && 48000 != inputSR), NS_ERROR_INVALID_PARAMETER);
+       retv_if(NULL == modelSR, NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER);
+       retv_if((16000 != inputSR && 48000 != inputSR), NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER);
 
        if (isInitialized) {
                _I("Reinitialization requested, deinit first");
@@ -127,7 +127,7 @@ int CDNNManager::init(unsigned int inputSR, unsigned int *modelSR)
        catch (std::bad_alloc& ba) {
                _E("bad_alloc caught: %s", ba.what());
                _E("System failed to allocate new memory for Core NS Model States");
-               return NS_ERROR_OUT_OF_MEMORY;
+               return NOISE_SUPPRESSION_ERROR_OUT_OF_MEMORY;
        }
 
        z = new float[MAX_NEURONS]();
@@ -154,7 +154,7 @@ int CDNNManager::init(unsigned int inputSR, unsigned int *modelSR)
        serialize_weights(rnn.model->denoise_gru);
 
        isInitialized = true;
-       return NS_ERROR_NONE;
+       return NOISE_SUPPRESSION_ERROR_NONE;
 }
 
 void CDNNManager::deinit()
@@ -189,11 +189,11 @@ void CDNNManager::deinit()
 int CDNNManager::processFrame(const float *features, int featureLen,
                float **gains, float *vad)
 {
-       retv_if(!isInitialized, NS_ERROR_NOT_INITIALIZED);
-       retv_if(!features, NS_ERROR_INVALID_PARAMETER);
-       retv_if(0 >= featureLen, NS_ERROR_INVALID_PARAMETER);
-       retv_if(!gains, NS_ERROR_INVALID_PARAMETER);
-       retv_if(!vad, NS_ERROR_INVALID_PARAMETER);
+       retv_if(!isInitialized, NOISE_SUPPRESSION_ERROR_NOT_INITIALIZED);
+       retv_if(!features, NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER);
+       retv_if(0 >= featureLen, NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER);
+       retv_if(!gains, NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER);
+       retv_if(!vad, NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER);
 
        float dense_out[MAX_NEURONS];
 
@@ -232,12 +232,12 @@ int CDNNManager::processFrame(const float *features, int featureLen,
        catch (std::bad_alloc& ba) {
                _E("bad_alloc caught: %s", ba.what());
                _E("System failed to allocate new memory for Core NS Model Output");
-               return NS_ERROR_OUT_OF_MEMORY;
+               return NOISE_SUPPRESSION_ERROR_OUT_OF_MEMORY;
        }
 
        compute_dense(rnn.model->denoise_output, *gains, rnn.denoise_gru_state);
 
-       return NS_ERROR_NONE;
+       return NOISE_SUPPRESSION_ERROR_NONE;
 }
 
 float CDNNManager::tansig_approx(float x)

diff --git a/src/NSLogger.c b/src/NSLogger.c
index 350003f..847bdb2 100644 (file)
--- a/src/NSLogger.c
+++ b/src/NSLogger.c
@@ -35,14 +35,14 @@
 
 #include "NSLogger.h"
 
-static ns_log_cb g_print_cb = NULL;
+static noise_suppression_log_cb g_print_cb = NULL;
 
-void set_ns_print(ns_log_cb print_func)
+void set_noise_suppression_print(noise_suppression_log_cb print_func)
 {
        g_print_cb = print_func;
 }
 
-void ns_print(const char* fmt, ...)
+void noise_suppression_print(const char* fmt, ...)
 {
        if (g_print_cb == NULL || fmt == NULL)
                return;

diff --git a/src/NoiseSuppression.cpp b/src/NoiseSuppression.cpp
index ed404c4..b0e782e 100644 (file)
--- a/src/NoiseSuppression.cpp
+++ b/src/NoiseSuppression.cpp
@@ -61,16 +61,16 @@ int CNoiseSuppression::init(unsigned int inputSR,
 
        try {
                int ret = dnnManager.init(inputSR, &modelSR);
-               if (NS_ERROR_NONE != ret)
+               if (NOISE_SUPPRESSION_ERROR_NONE != ret)
                        throw std::runtime_error("dnnManager Initialization failed");
 
                _I("Input Sampling Rate: %u, Model Sampling Rate: %u",
                                inputSR, modelSR);
 #if defined ENABLE_AUDIO_RESAMPLING
-               if (NS_ERROR_NONE != audioResamplerIn.init(inputSR, modelSR))
+               if (NOISE_SUPPRESSION_ERROR_NONE != audioResamplerIn.init(inputSR, modelSR))
                        throw std::runtime_error("audioResamplerIn.init() fail");
 
-               if (NS_ERROR_NONE != audioResamplerOut.init(modelSR, inputSR))
+               if (NOISE_SUPPRESSION_ERROR_NONE != audioResamplerOut.init(modelSR, inputSR))
                        throw std::runtime_error("audioResamplerIn.init() fail");
 #else
                _modelSR = modelSR;
@@ -78,7 +78,7 @@ int CNoiseSuppression::init(unsigned int inputSR,
 #endif
 
                ret = audioProcessor.init(modelSR, maxDelayMSec, &modelFrameSize);
-               if (NS_ERROR_NONE != ret)
+               if (NOISE_SUPPRESSION_ERROR_NONE != ret)
                        throw std::runtime_error("AudioProcessor initialization failed");
 
                *frameSize = (unsigned int)((modelFrameSize * inputSR) / modelSR);
@@ -89,10 +89,10 @@ int CNoiseSuppression::init(unsigned int inputSR,
        } catch (const std::runtime_error& e) {
                _E("%s", e.what());
                deinit();
-               return NS_ERROR_OPERATION_FAILED;
+               return NOISE_SUPPRESSION_ERROR_OPERATION_FAILED;
        }
 
-       return NS_ERROR_NONE;
+       return NOISE_SUPPRESSION_ERROR_NONE;
 }
 
 void CNoiseSuppression::deinit()
@@ -114,19 +114,19 @@ void CNoiseSuppression::setNSLevel(int level)
        float bestAtteunation = audioProcessor.getMinMaxAtteunation();
 
        switch (level) {
-               case NS_LEVEL_VERY_LOW:
+               case NOISE_SUPPRESSION_LEVEL_VERY_LOW:
                        bestAtteunation = 0.630957; // pow(10, (-2/10)) for 2dB
                        break;
-               case NS_LEVEL_LOW:
+               case NOISE_SUPPRESSION_LEVEL_LOW:
                        bestAtteunation = 0.501187; // pow(10, (-3/10))
                        break;
-               case NS_LEVEL_MID:
+               case NOISE_SUPPRESSION_LEVEL_MID:
                        bestAtteunation = 0.316227; // pow(10, (-5/10))
                        break;
-               case NS_LEVEL_HIGH:
+               case NOISE_SUPPRESSION_LEVEL_HIGH:
                        bestAtteunation = 0.158489; // pow(10, (-8/10)) for 9dB
                        break;
-               case NS_LEVEL_VERY_HIGH:
+               case NOISE_SUPPRESSION_LEVEL_VERY_HIGH:
                        bestAtteunation = 0.000001;
                        break;
                default:
@@ -138,7 +138,7 @@ void CNoiseSuppression::setNSLevel(int level)
 
 int CNoiseSuppression::processAudio(const float *in, float *out)
 {
-       retv_if(!isInitialized, NS_ERROR_NOT_INITIALIZED);
+       retv_if(!isInitialized, NOISE_SUPPRESSION_ERROR_NOT_INITIALIZED);
 
        float buf[_modelFrameSize] = {};
        float *features = NULL;
@@ -155,13 +155,13 @@ int CNoiseSuppression::processAudio(const float *in, float *out)
 
        audioProcessor.audioToFeatures(&features, &featureLen, buf, &isSilence);
 
-       int dnnRet = NS_ERROR_NONE;
+       int dnnRet = NOISE_SUPPRESSION_ERROR_NONE;
        if (!isSilence) {
                dnnRet = dnnManager.processFrame(features, featureLen, &gain,
                                &vadProbability);
        }
 
-       if (NS_ERROR_NONE != dnnRet) {
+       if (NOISE_SUPPRESSION_ERROR_NONE != dnnRet) {
                _E("processFrame() failed with error Code: %d", dnnRet);
        }
        else
@@ -175,5 +175,5 @@ int CNoiseSuppression::processAudio(const float *in, float *out)
 
        delete_arr(features);
        delete_arr(gain);
-       return NS_ERROR_NONE;
+       return NOISE_SUPPRESSION_ERROR_NONE;
 }

diff --git a/src/NoiseSuppressionApi.cpp b/src/NoiseSuppressionApi.cpp
index f922aa4..4246c3c 100644 (file)
--- a/src/NoiseSuppressionApi.cpp
+++ b/src/NoiseSuppressionApi.cpp
@@ -40,11 +40,12 @@
 
 static std::vector<CNoiseSuppression *> _handles = {};
 
-int ns_initialize(ns_log_cb cb, const unsigned int input_sample_rate,
+int noise_suppression_initialize(noise_suppression_log_cb cb,
+               const unsigned int input_sample_rate,
                const unsigned int allowed_delay_msec,
                noise_suppression_h *handle, unsigned int *frame_size)
 {
-       set_ns_print(cb);
+       set_noise_suppression_print(cb);
        FN_START;
 
        CNoiseSuppression* ns;
@@ -54,11 +55,11 @@ int ns_initialize(ns_log_cb cb, const unsigned int input_sample_rate,
        catch (std::bad_alloc& ba) {
                _E("bad_alloc caught: %s", ba.what());
                _E("System failed to allocate new memory for NS Core Handle Initialization");
-               return NS_ERROR_OUT_OF_MEMORY;
+               return NOISE_SUPPRESSION_ERROR_OUT_OF_MEMORY;
        }
 
        int ret = ns->init(input_sample_rate, allowed_delay_msec, frame_size);
-       if (NS_ERROR_NONE != ret) {
+       if (NOISE_SUPPRESSION_ERROR_NONE != ret) {
                _E("Init failed with %d", ret);
                delete_instance(ns);
                return ret;
@@ -68,21 +69,21 @@ int ns_initialize(ns_log_cb cb, const unsigned int input_sample_rate,
        *handle = (noise_suppression_h)ns;
 
        FN_END;
-       return NS_ERROR_NONE;
+       return NOISE_SUPPRESSION_ERROR_NONE;
 }
 
-int ns_set_level(noise_suppression_h handle, ns_level_e level)
+int noise_suppression_set_level(noise_suppression_h handle, noise_suppression_level_e level)
 {
        FN_START;
        auto it = std::find(_handles.begin(), _handles.end(), handle);
        if (it == _handles.end()) {
                _E("Invalid handle: %p", handle);
-               return NS_ERROR_INVALID_PARAMETER;
+               return NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER;
        }
 
-       if (level > NS_LEVEL_VERY_HIGH) {
+       if (level > NOISE_SUPPRESSION_LEVEL_VERY_HIGH) {
                _E("Invalid handle: %p", handle);
-               return NS_ERROR_INVALID_PARAMETER;
+               return NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER;
        }
 
        CNoiseSuppression* ns = (CNoiseSuppression*)handle;
@@ -91,21 +92,21 @@ int ns_set_level(noise_suppression_h handle, ns_level_e level)
        ns->setNSLevel(level);
 
        FN_END;
-       return NS_ERROR_NONE;
+       return NOISE_SUPPRESSION_ERROR_NONE;
 }
 
-int ns_process_audio(noise_suppression_h handle, const float *in, float *out)
+int noise_suppression_process_audio(noise_suppression_h handle, const float *in, float *out)
 {
        auto it = std::find(_handles.begin(), _handles.end(), handle);
        if (it == _handles.end()) {
                _E("Invalid handle: %p", handle);
-               return NS_ERROR_INVALID_PARAMETER;
+               return NOISE_SUPPRESSION_ERROR_INVALID_PARAMETER;
        }
 
        return (*it)->processAudio(in, out);
 }
 
-void ns_deinitialize(noise_suppression_h handle)
+void noise_suppression_deinitialize(noise_suppression_h handle)
 {
        FN_START;
 
@@ -120,5 +121,5 @@ void ns_deinitialize(noise_suppression_h handle)
        _handles.erase(it);
 
        FN_END;
-       set_ns_print(nullptr);
+       set_noise_suppression_print(nullptr);
 }

diff --git a/tool/noise_suppression_tool.c b/tool/noise_suppression_tool.c
index 1b516d0..7df8d6e 100644 (file)
--- a/tool/noise_suppression_tool.c
+++ b/tool/noise_suppression_tool.c
@@ -37,7 +37,7 @@
 
 #define BILLION 1000000000L
 
-void ns_log_callback(const char *log)
+static void ns_log_callback(const char *log)
 {
        printf("%s", log);
 }
@@ -59,7 +59,7 @@ int main(int argc, char **argv)
                return -1;
        }
 
-       ns_level_e NSLevel = (ns_level_e) atoi(argv[4]);
+       noise_suppression_level_e NSLevel = (noise_suppression_level_e) atoi(argv[4]);
        if (NSLevel < 0 || NSLevel > 4) {
                fprintf(stderr, "Use proper NS level (0 - Very Low, 1 - Low, 2 - Mid, 3 - High, 4 - Very High)\n");
                fprintf(stderr, "usage: %s <sample rate 16/48> <noisy speech> <output denoised> <level 0/1/2/3/4>\n", argv[0]);
@@ -73,14 +73,14 @@ int main(int argc, char **argv)
                return -1;
        }
 
-       //if (NS_ERROR_NONE != ns_initialize(NULL, atoi(argv[1]),
-       if (NS_ERROR_NONE != ns_initialize(ns_log_callback, atoi(argv[1]),
+       //if (NOISE_SUPPRESSION_ERROR_NONE != noise_suppression_initialize(NULL, atoi(argv[1]),
+       if (NOISE_SUPPRESSION_ERROR_NONE != noise_suppression_initialize(ns_log_callback, atoi(argv[1]),
                                MAX_DELAY_MSEC, &ns_handle, &frame_size)) {
                fprintf(stderr, "ns_initialize() failed\n");
                return -1;
        }
 
-       ns_set_level(ns_handle, NSLevel);
+       noise_suppression_set_level(ns_handle, NSLevel);
 
        f1 = fopen(argv[2], "r");
        if (!f1) {
@@ -105,7 +105,7 @@ int main(int argc, char **argv)
                for (i = 0; i < frame_size; i++)
                        x[i] = tmp[i];
 
-               ns_process_audio(ns_handle, x, x);
+               noise_suppression_process_audio(ns_handle, x, x);
 
                for (i = 0; i < frame_size; i++)
                        tmp[i] = x[i];
@@ -118,7 +118,7 @@ int main(int argc, char **argv)
        diff = (end.tv_sec - start.tv_sec) * 1000 + (uint64_t)((end.tv_nsec - start.tv_nsec) / 1000000);
        printf("elapsed time = %llu milliseconds\n", (long long unsigned int) diff);
 
-       ns_deinitialize(ns_handle);
+       noise_suppression_deinitialize(ns_handle);
        fclose(f1);
        fflush(fout);
        fclose(fout);