#if HAVE_CRT
 #define _CRTDBG_MAP_ALLOC 
 #include <stdlib.h> 
 #include <crtdbg.h>
 #endif //HAVE_CRT
 /*
 * Copyright (C) 2017, University of the Basque Country (UPV/EHU)
 * Contact for licensing options: <licensing-mcpttclient(at)mcopenplatform(dot)com>
 *
 * The original file was part of Open Source Doubango Framework
 * Copyright (C) 2010-2011 Mamadou Diop.
 * Copyright (C) 2012 Doubango Telecom <http://doubango.org>
 *
 * This file is part of Open Source Doubango Framework.
 *
 * DOUBANGO is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * DOUBANGO is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with DOUBANGO.
 *
 */
 
 
 /**@file tmedia_denoise.c
 * @brief Denoiser (Noise suppression, AGC, AEC, VAD) Plugin
 *
 * @author Mamadou Diop <diopmamadou(at)doubango[dot]org>
 *
 
 */
 #include "tinymedia/tmedia_denoise.h"
 #include "tinymedia/tmedia_defaults.h"
 
 #include "tsk_debug.h"
 
 static const tmedia_denoise_plugin_def_t* __tmedia_denoise_plugin = tsk_null;
 
 int tmedia_denoise_init(tmedia_denoise_t* self)
 {
 	if(!self){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 
 	self->echo_tail = tmedia_defaults_get_echo_tail();
 	self->echo_skew = tmedia_defaults_get_echo_skew();
 	self->echo_supp_enabled = tmedia_defaults_get_echo_supp_enabled();
 	self->agc_enabled = tmedia_defaults_get_agc_enabled();
 	self->agc_level = tmedia_defaults_get_agc_level();
 	self->vad_enabled = tmedia_defaults_get_vad_enabled();
 	self->noise_supp_enabled = tmedia_defaults_get_noise_supp_enabled();
 	self->noise_supp_level = tmedia_defaults_get_noise_supp_level();
 
 	return 0;
 }
 
 int tmedia_denoise_set(tmedia_denoise_t* self, const tmedia_param_t* param)
 {
 	if(!self || !self->plugin){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 
 	if(self->plugin->set){
 		return self->plugin->set(self, param);
 	}
 	return 0;
 }
 
 int tmedia_denoise_open(tmedia_denoise_t* self, uint32_t record_frame_size_samples, uint32_t record_sampling_rate, uint32_t record_channels, uint32_t playback_frame_size_samples, uint32_t playback_sampling_rate, uint32_t playback_channels)
 {
 	if (!self || !self->plugin) {
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 	if (self->opened) {
 		TSK_DEBUG_WARN("Denoiser already opened");
 		return 0;
 	}
 
 	if (self->plugin->open) {
 		int ret;
 
 		TSK_OBJECT_SAFE_FREE(self->record_frame);
 		TSK_OBJECT_SAFE_FREE(self->playback_frame);
 		if (!(self->record_frame = tsk_buffer_create(tsk_null, (record_frame_size_samples * sizeof(int16_t))))) {
 			TSK_DEBUG_ERROR("Failed to create record the buffer");
 			return -2;
 		}
 		if (!(self->playback_frame = tsk_buffer_create(tsk_null, (playback_frame_size_samples * sizeof(int16_t))))) {
 			TSK_DEBUG_ERROR("Failed to create playback the buffer");
 			return -2;
 		}
 		if ((ret = self->plugin->open(self, record_frame_size_samples, record_sampling_rate, record_channels, playback_frame_size_samples, playback_sampling_rate, playback_channels))) {
 			TSK_DEBUG_ERROR("Failed to open [%s] denoiser", self->plugin->desc);
 			return ret;
 		}
 		else {
 			self->opened = tsk_true;
 			return 0;
 		}
 	}
 	else{
 		self->opened = tsk_true;
 		return 0;
 	}
 }
 
 int tmedia_denoise_echo_playback(tmedia_denoise_t* self, const void* echo_frame, uint32_t echo_frame_size_bytes)
 {
 	if(!self || !self->plugin){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 
 	if(!self->opened){
 		TSK_DEBUG_ERROR("Denoiser not opened");
 		return -2;
 	}
 
 	if(self->plugin->echo_playback){
 		return self->plugin->echo_playback(self, echo_frame, echo_frame_size_bytes);
 	}
 	else{
 		return 0;
 	}
 }
 
 int tmedia_denoise_process_record(tmedia_denoise_t* self, void* audio_frame, uint32_t audio_frame_size_bytes, tsk_bool_t* silence_or_noise)
 {
 	if(!self || !self->plugin || !silence_or_noise){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 
 	if(!self->opened){
 		TSK_DEBUG_ERROR("Denoiser not opened");
 		return -2;
 	}
 
 	if(self->plugin->process_record){
 		return self->plugin->process_record(self, audio_frame, audio_frame_size_bytes, silence_or_noise);
 	}
 	else{
 		*silence_or_noise = tsk_false;
 		return 0;
 	}
 }
 
 int tmedia_denoise_process_playback(tmedia_denoise_t* self, void* audio_frame, uint32_t audio_frame_size_bytes)
 {
 	if(!self || !self->plugin){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 
 	if(!self->opened){
 		TSK_DEBUG_ERROR("Denoiser not opened");
 		return -2;
 	}
 
 	if(self->plugin->process_playback){
 		return self->plugin->process_playback(self, audio_frame, audio_frame_size_bytes);
 	}
 	return 0;
 }
 
 int tmedia_denoise_close(tmedia_denoise_t* self)
 {
 	if(!self || !self->plugin){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 	if(!self->opened){
 		return 0;
 	}
 
 	if(self->plugin->close){
 		int ret;
 
 		if((ret = self->plugin->close(self))){
 			TSK_DEBUG_ERROR("Failed to close [%s] denoiser", self->plugin->desc);
 			return ret;
 		}
 		else{
 			self->opened = tsk_false;
 			return 0;
 		}
 	}
 	else{
 		self->opened = tsk_false;
 		return 0;
 	}
 }
 
 int tmedia_denoise_deinit(tmedia_denoise_t* self)
 {
 	if (!self) {
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 	
 	if (self->opened) {
 		tmedia_denoise_close(self);
 	}
 
 	TSK_OBJECT_SAFE_FREE(self->record_frame);
 	TSK_OBJECT_SAFE_FREE(self->playback_frame);
 
 	return 0;
 }
 
 int tmedia_denoise_plugin_register(const tmedia_denoise_plugin_def_t* plugin)
 {
 	if(!plugin){
 		TSK_DEBUG_ERROR("Invalid parameter");
 		return -1;
 	}
 	if(!__tmedia_denoise_plugin) {
 		TSK_DEBUG_INFO("Register denoiser: %s", plugin->desc);
 		__tmedia_denoise_plugin = plugin;
 	}
 	return 0;
 }
 
 int tmedia_denoise_plugin_unregister(const tmedia_denoise_plugin_def_t* plugin)
 {
 	(void)(plugin);
 	__tmedia_denoise_plugin = tsk_null;
 	return 0;
 }
 
 tmedia_denoise_t* tmedia_denoise_create()
 {
 	tmedia_denoise_t* denoise = tsk_null;
 
 	if(__tmedia_denoise_plugin){
 		if((denoise = tsk_object_new(__tmedia_denoise_plugin->objdef))){
 			denoise->plugin = __tmedia_denoise_plugin;
 		}
 	}
 	return denoise;
 }