/*************************************************************************/
/*  sample_player.cpp                                                    */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md)    */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/
#include "sample_player.h"

#include "servers/audio_server.h"

bool SamplePlayer::_set(const StringName &p_name, const Variant &p_value) {

	String name = p_name;

	if (name == "play/play") {
		if (library.is_valid()) {

			String what = p_value;
			if (what == "")
				stop_all();
			else
				play(what);

			played_back = what;
		}
	} else if (name == "config/samples")
		set_sample_library(p_value);
	else if (name == "config/polyphony")
		set_polyphony(p_value);
	else if (name.begins_with("default/")) {

		String what = name.right(8);

		if (what == "volume_db")
			set_default_volume_db(p_value);
		else if (what == "pitch_scale")
			set_default_pitch_scale(p_value);
		else if (what == "pan")
			_default.pan = p_value;
		else if (what == "depth")
			_default.depth = p_value;
		else if (what == "height")
			_default.height = p_value;
		else if (what == "filter/type")
			_default.filter_type = FilterType(p_value.operator int());
		else if (what == "filter/cutoff")
			_default.filter_cutoff = p_value;
		else if (what == "filter/resonance")
			_default.filter_resonance = p_value;
		else if (what == "filter/gain")
			_default.filter_gain = p_value;
		else if (what == "reverb_room")
			_default.reverb_room = ReverbRoomType(p_value.operator int());
		else if (what == "reverb_send")
			_default.reverb_send = p_value;
		else if (what == "chorus_send")
			_default.chorus_send = p_value;
		else
			return false;

	} else
		return false;

	return true;
}

bool SamplePlayer::_get(const StringName &p_name, Variant &r_ret) const {

	String name = p_name;

	if (name == "play/play") {
		r_ret = played_back;
	} else if (name == "config/polyphony") {
		r_ret = get_polyphony();
	} else if (name == "config/samples") {

		r_ret = get_sample_library();
	} else if (name.begins_with("default/")) {

		String what = name.right(8);

		if (what == "volume_db")
			r_ret = get_default_volume_db();
		else if (what == "pitch_scale")
			r_ret = get_default_pitch_scale();
		else if (what == "pan")
			r_ret = _default.pan;
		else if (what == "depth")
			r_ret = _default.depth;
		else if (what == "height")
			r_ret = _default.height;
		else if (what == "filter/type")
			r_ret = _default.filter_type;
		else if (what == "filter/cutoff")
			r_ret = _default.filter_cutoff;
		else if (what == "filter/resonance")
			r_ret = _default.filter_resonance;
		else if (what == "filter/gain")
			r_ret = _default.filter_gain;
		else if (what == "reverb_room")
			r_ret = _default.reverb_room;
		else if (what == "reverb_send")
			r_ret = _default.reverb_send;
		else if (what == "chorus_send")
			r_ret = _default.chorus_send;
		else
			return false;

	} else
		return false;

	return true;
}

void SamplePlayer::_get_property_list(List<PropertyInfo> *p_list) const {

	String en = "";
	if (library.is_valid()) {
		List<StringName> samples;
		Ref<SampleLibrary> ncl = library;
		ncl->get_sample_list(&samples);
		for (List<StringName>::Element *E = samples.front(); E; E = E->next()) {

			en += ",";
			en += E->get();
		}
	}

	p_list->push_back(PropertyInfo(Variant::STRING, "play/play", PROPERTY_HINT_ENUM, en, PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_ANIMATE_AS_TRIGGER));
	p_list->push_back(PropertyInfo(Variant::INT, "config/polyphony", PROPERTY_HINT_RANGE, "1,256,1"));
	p_list->push_back(PropertyInfo(Variant::OBJECT, "config/samples", PROPERTY_HINT_RESOURCE_TYPE, "SampleLibrary"));
	p_list->push_back(PropertyInfo(Variant::REAL, "default/volume_db", PROPERTY_HINT_RANGE, "-80,24,0.01"));
	p_list->push_back(PropertyInfo(Variant::REAL, "default/pitch_scale", PROPERTY_HINT_RANGE, "0.01,48,0.01"));
	p_list->push_back(PropertyInfo(Variant::REAL, "default/pan", PROPERTY_HINT_RANGE, "-1,1,0.01"));
	p_list->push_back(PropertyInfo(Variant::REAL, "default/depth", PROPERTY_HINT_RANGE, "-1,1,0.01"));
	p_list->push_back(PropertyInfo(Variant::REAL, "default/height", PROPERTY_HINT_RANGE, "-1,1,0.01"));
	p_list->push_back(PropertyInfo(Variant::INT, "default/filter/type", PROPERTY_HINT_ENUM, "Disabled,Lowpass,Bandpass,Highpass,Notch,Peak,BandLimit,LowShelf,HighShelf"));
	p_list->push_back(PropertyInfo(Variant::REAL, "default/filter/cutoff", PROPERTY_HINT_RANGE, "20,16384.0,0.01"));
	p_list->push_back(PropertyInfo(Variant::REAL, "default/filter/resonance", PROPERTY_HINT_RANGE, "0,4,0.01"));
	p_list->push_back(PropertyInfo(Variant::REAL, "default/filter/gain", PROPERTY_HINT_RANGE, "0,2,0.01"));
	p_list->push_back(PropertyInfo(Variant::INT, "default/reverb_room", PROPERTY_HINT_ENUM, "Small,Medium,Large,Hall"));
	p_list->push_back(PropertyInfo(Variant::REAL, "default/reverb_send", PROPERTY_HINT_RANGE, "0,1,0.01"));
	p_list->push_back(PropertyInfo(Variant::REAL, "default/chorus_send", PROPERTY_HINT_RANGE, "0,1,0.01"));
}

SamplePlayer::Voice::Voice() {

	voice = AudioServer::get_singleton()->voice_create();
	clear();
}

void SamplePlayer::Voice::clear() {

	check = 0;

	mix_rate = 44100;
	volume = 1;
	pan = 0;
	pan_depth = 0;
	pan_height = 0;
	filter_type = FILTER_NONE;
	filter_cutoff = 0;
	filter_resonance = 0;
	chorus_send = 0;
	reverb_room = REVERB_HALL;
	reverb_send = 0;
	active = false;
	priority = 0;
}
SamplePlayer::Voice::~Voice() {

	AudioServer::get_singleton()->free(voice);
}

void SamplePlayer::set_polyphony(int p_voice_count) {

	ERR_FAIL_COND(p_voice_count < 1 || p_voice_count > 0xFFFE);

	voices.resize(p_voice_count);
}

int SamplePlayer::get_polyphony() const {

	return voices.size();
}

SamplePlayer::VoiceID SamplePlayer::play(const String &p_name, bool unique) {

	if (library.is_null())
		return INVALID_VOICE_ID;
	ERR_FAIL_COND_V(!library->has_sample(p_name), INVALID_VOICE_ID);

	Ref<Sample> sample = library->get_sample(p_name);
	float vol_change = library->sample_get_volume_db(p_name);
	float pitch_change = library->sample_get_pitch_scale(p_name);
	int priority = library->sample_get_priority(p_name);

	last_check++;

	const int num_voices = voices.size();
	bool free_found = false;
	int lowest_priority_voice = -1;
	int lowest_priority = 0x7FFFFFFF;
	for (int i = 0; i < num_voices; i++) {
		const int candidate = (last_id + 1 + i) % num_voices;
		const Voice &v = voices[candidate];
		if (!(v.active && AudioServer::get_singleton()->voice_is_active(v.voice))) {
			free_found = true;
			last_id = candidate;
			break;
		}
		if (v.priority <= lowest_priority) {
			lowest_priority = v.priority;
			lowest_priority_voice = candidate;
		}
	}

	if (!free_found) {
		if (lowest_priority > priority) {
			return INVALID_VOICE_ID;
		} else {
			last_id = lowest_priority_voice;
		}
	}

	Voice &v = voices[last_id];
	v.clear();

	v.priority = priority;
	v.mix_rate = sample->get_mix_rate() * (_default.pitch_scale * pitch_change);
	v.sample_mix_rate = sample->get_mix_rate();
	v.check = last_check;
	v.volume = Math::db2linear(_default.volume_db + vol_change);
	v.pan = _default.pan;
	v.pan_depth = _default.depth;
	v.pan_height = _default.height;
	v.filter_type = _default.filter_type;
	v.filter_cutoff = _default.filter_cutoff;
	v.filter_resonance = _default.filter_resonance;
	v.filter_gain = _default.filter_gain;
	v.chorus_send = _default.chorus_send;
	v.reverb_room = _default.reverb_room;
	v.reverb_send = _default.reverb_send;

	AudioServer::get_singleton()->voice_play(v.voice, sample->get_rid());
	AudioServer::get_singleton()->voice_set_mix_rate(v.voice, v.mix_rate);
	AudioServer::get_singleton()->voice_set_volume(v.voice, v.volume);
	AudioServer::get_singleton()->voice_set_pan(v.voice, v.pan, v.pan_depth, v.pan_height);
	AudioServer::get_singleton()->voice_set_filter(v.voice, (AudioServer::FilterType)v.filter_type, v.filter_cutoff, v.filter_resonance, v.filter_gain);
	AudioServer::get_singleton()->voice_set_chorus(v.voice, v.chorus_send);
	AudioServer::get_singleton()->voice_set_reverb(v.voice, (AudioServer::ReverbRoomType)v.reverb_room, v.reverb_send);

	v.active = true;

	if (unique) {

		for (int i = 0; i < voices.size(); i++) {

			if (!voices[i].active || uint32_t(i) == last_id)
				continue;

			AudioServer::get_singleton()->voice_stop(voices[i].voice);

			voices[i].clear();
		}
	}

	return last_id | (last_check << 16);
}

void SamplePlayer::stop_all() {

	for (int i = 0; i < voices.size(); i++) {

		if (!voices[i].active)
			continue;

		AudioServer::get_singleton()->voice_stop(voices[i].voice);
		voices[i].clear();
	}
}

#define _GET_VOICE                                   \
	uint32_t voice = p_voice & 0xFFFF;               \
	ERR_FAIL_COND(voice >= (uint32_t)voices.size()); \
	Voice &v = voices[voice];                        \
	if (v.check != uint32_t(p_voice >> 16))          \
		return;                                      \
	ERR_FAIL_COND(!v.active);

void SamplePlayer::stop(VoiceID p_voice) {

	_GET_VOICE

	AudioServer::get_singleton()->voice_stop(v.voice);
	v.active = false;
}

void SamplePlayer::set_mix_rate(VoiceID p_voice, int p_mix_rate) {

	_GET_VOICE

	v.mix_rate = p_mix_rate;
	AudioServer::get_singleton()->voice_set_mix_rate(v.voice, v.mix_rate);
}
void SamplePlayer::set_pitch_scale(VoiceID p_voice, float p_pitch_scale) {

	_GET_VOICE

	v.mix_rate = v.sample_mix_rate * p_pitch_scale;
	AudioServer::get_singleton()->voice_set_mix_rate(v.voice, v.mix_rate);
}
void SamplePlayer::set_volume(VoiceID p_voice, float p_volume) {

	_GET_VOICE
	v.volume = p_volume;
	AudioServer::get_singleton()->voice_set_volume(v.voice, v.volume);
}

void SamplePlayer::set_volume_db(VoiceID p_voice, float p_db) {

	//@TODO handle 0 volume as -80db or something
	_GET_VOICE
	v.volume = Math::db2linear(p_db);
	AudioServer::get_singleton()->voice_set_volume(v.voice, v.volume);
}

void SamplePlayer::set_pan(VoiceID p_voice, float p_pan, float p_pan_depth, float p_pan_height) {

	_GET_VOICE
	v.pan = p_pan;
	v.pan_depth = p_pan_depth;
	v.pan_height = p_pan_height;

	AudioServer::get_singleton()->voice_set_pan(v.voice, v.pan, v.pan_depth, v.pan_height);
}

void SamplePlayer::set_filter(VoiceID p_voice, FilterType p_filter, float p_cutoff, float p_resonance, float p_gain) {

	_GET_VOICE
	v.filter_type = p_filter;
	v.filter_cutoff = p_cutoff;
	v.filter_resonance = p_resonance;
	v.filter_gain = p_gain;

	AudioServer::get_singleton()->voice_set_filter(v.voice, (AudioServer::FilterType)p_filter, p_cutoff, p_resonance);
}
void SamplePlayer::set_chorus(VoiceID p_voice, float p_send) {

	_GET_VOICE
	v.chorus_send = p_send;

	AudioServer::get_singleton()->voice_set_chorus(v.voice, p_send);
}
void SamplePlayer::set_reverb(VoiceID p_voice, ReverbRoomType p_room, float p_send) {

	_GET_VOICE
	v.reverb_room = p_room;
	v.reverb_send = p_send;

	AudioServer::get_singleton()->voice_set_reverb(v.voice, (AudioServer::ReverbRoomType)p_room, p_send);
}

#define _GET_VOICE_V(m_ret)                                   \
	uint32_t voice = p_voice & 0xFFFF;                        \
	ERR_FAIL_COND_V(voice >= (uint32_t)voices.size(), m_ret); \
	const Voice &v = voices[voice];                           \
	if (v.check != (p_voice >> 16))                           \
		return m_ret;                                         \
	ERR_FAIL_COND_V(!v.active, m_ret);

int SamplePlayer::get_mix_rate(VoiceID p_voice) const {

	_GET_VOICE_V(0);

	return v.mix_rate;
}
float SamplePlayer::get_pitch_scale(VoiceID p_voice) const {

	_GET_VOICE_V(0);
	return v.sample_mix_rate / (float)v.mix_rate;
}
float SamplePlayer::get_volume(VoiceID p_voice) const {

	_GET_VOICE_V(0);
	return v.volume;
}

float SamplePlayer::get_volume_db(VoiceID p_voice) const {

	_GET_VOICE_V(0);
	return Math::linear2db(v.volume);
}

float SamplePlayer::get_pan(VoiceID p_voice) const {

	_GET_VOICE_V(0);
	return v.pan;
}
float SamplePlayer::get_pan_depth(VoiceID p_voice) const {

	_GET_VOICE_V(0);
	return v.pan_depth;
}
float SamplePlayer::get_pan_height(VoiceID p_voice) const {

	_GET_VOICE_V(0);

	return v.pan_height;
}
SamplePlayer::FilterType SamplePlayer::get_filter_type(VoiceID p_voice) const {

	_GET_VOICE_V(FILTER_NONE);

	return v.filter_type;
}
float SamplePlayer::get_filter_cutoff(VoiceID p_voice) const {

	_GET_VOICE_V(0);

	return v.filter_cutoff;
}
float SamplePlayer::get_filter_resonance(VoiceID p_voice) const {

	_GET_VOICE_V(0);

	return v.filter_resonance;
}

float SamplePlayer::get_filter_gain(VoiceID p_voice) const {

	_GET_VOICE_V(0);

	return v.filter_gain;
}
float SamplePlayer::get_chorus(VoiceID p_voice) const {

	_GET_VOICE_V(0);

	return v.chorus_send;
}
SamplePlayer::ReverbRoomType SamplePlayer::get_reverb_room(VoiceID p_voice) const {

	_GET_VOICE_V(REVERB_SMALL);

	return v.reverb_room;
}

float SamplePlayer::get_reverb(VoiceID p_voice) const {

	_GET_VOICE_V(0);

	return v.reverb_send;
}

bool SamplePlayer::is_voice_active(VoiceID p_voice) const {

	_GET_VOICE_V(false);
	return v.active && AudioServer::get_singleton()->voice_is_active(v.voice);
}
bool SamplePlayer::is_active() const {

	for (int i = 0; i < voices.size(); i++) {

		if (voices[i].active && AudioServer::get_singleton()->voice_is_active(voices[i].voice))
			return true;
	}

	return false;
}

void SamplePlayer::set_sample_library(const Ref<SampleLibrary> &p_library) {

	library = p_library;
	_change_notify();
}

Ref<SampleLibrary> SamplePlayer::get_sample_library() const {

	return library;
}

void SamplePlayer::set_default_pitch_scale(float p_pitch_scale) {

	_default.pitch_scale = p_pitch_scale;
}
void SamplePlayer::set_default_volume(float p_volume) {

	_default.volume_db = Math::linear2db(p_volume);
}
void SamplePlayer::set_default_volume_db(float p_db) {

	_default.volume_db = p_db;
}
void SamplePlayer::set_default_pan(float p_pan, float p_pan_depth, float p_pan_height) {

	_default.pan = p_pan;
	_default.depth = p_pan_depth;
	_default.height = p_pan_height;
}
void SamplePlayer::set_default_filter(FilterType p_filter, float p_cutoff, float p_resonance, float p_gain) {

	_default.filter_type = p_filter;
	_default.filter_cutoff = p_cutoff;
	_default.filter_resonance = p_resonance;
	_default.filter_gain = p_gain;
}
void SamplePlayer::set_default_chorus(float p_send) {

	_default.chorus_send = p_send;
}
void SamplePlayer::set_default_reverb(ReverbRoomType p_room, float p_send) {

	_default.reverb_room = p_room;
	_default.reverb_send = p_send;
}

float SamplePlayer::get_default_volume() const {

	return Math::db2linear(_default.volume_db);
}
float SamplePlayer::get_default_volume_db() const {

	return _default.volume_db;
}
float SamplePlayer::get_default_pitch_scale() const {

	return _default.pitch_scale;
}

float SamplePlayer::get_default_pan() const {

	return _default.pan;
}
float SamplePlayer::get_default_pan_depth() const {

	return _default.depth;
}
float SamplePlayer::get_default_pan_height() const {

	return _default.height;
}
SamplePlayer::FilterType SamplePlayer::get_default_filter_type() const {

	return _default.filter_type;
}
float SamplePlayer::get_default_filter_cutoff() const {

	return _default.filter_cutoff;
}
float SamplePlayer::get_default_filter_resonance() const {

	return _default.filter_resonance;
}
float SamplePlayer::get_default_filter_gain() const {

	return _default.filter_gain;
}
float SamplePlayer::get_default_chorus() const {

	return _default.chorus_send;
}
SamplePlayer::ReverbRoomType SamplePlayer::get_default_reverb_room() const {

	return _default.reverb_room;
}
float SamplePlayer::get_default_reverb() const {

	return _default.reverb_send;
}

String SamplePlayer::get_configuration_warning() const {

	if (library.is_null()) {
		return TTR("A SampleLibrary resource must be created or set in the 'samples' property in order for SamplePlayer to play sound.");
	}

	return String();
}

void SamplePlayer::_bind_methods() {

	ObjectTypeDB::bind_method(_MD("set_sample_library", "library:SampleLibrary"), &SamplePlayer::set_sample_library);
	ObjectTypeDB::bind_method(_MD("get_sample_library:SampleLibrary"), &SamplePlayer::get_sample_library);

	ObjectTypeDB::bind_method(_MD("set_polyphony", "max_voices"), &SamplePlayer::set_polyphony);
	ObjectTypeDB::bind_method(_MD("get_polyphony"), &SamplePlayer::get_polyphony);

	ObjectTypeDB::bind_method(_MD("play", "name", "unique"), &SamplePlayer::play, DEFVAL(false));
	ObjectTypeDB::bind_method(_MD("stop", "voice"), &SamplePlayer::stop);
	ObjectTypeDB::bind_method(_MD("stop_all"), &SamplePlayer::stop_all);

	ObjectTypeDB::bind_method(_MD("set_mix_rate", "voice", "hz"), &SamplePlayer::set_mix_rate);
	ObjectTypeDB::bind_method(_MD("set_pitch_scale", "voice", "ratio"), &SamplePlayer::set_pitch_scale);
	ObjectTypeDB::bind_method(_MD("set_volume", "voice", "volume"), &SamplePlayer::set_volume);
	ObjectTypeDB::bind_method(_MD("set_volume_db", "voice", "db"), &SamplePlayer::set_volume_db);
	ObjectTypeDB::bind_method(_MD("set_pan", "voice", "pan", "depth", "height"), &SamplePlayer::set_pan, DEFVAL(0), DEFVAL(0));
	ObjectTypeDB::bind_method(_MD("set_filter", "voice", "type", "cutoff_hz", "resonance", "gain"), &SamplePlayer::set_filter, DEFVAL(0));
	ObjectTypeDB::bind_method(_MD("set_chorus", "voice", "send"), &SamplePlayer::set_chorus);
	ObjectTypeDB::bind_method(_MD("set_reverb", "voice", "room_type", "send"), &SamplePlayer::set_reverb);

	ObjectTypeDB::bind_method(_MD("get_mix_rate", "voice"), &SamplePlayer::get_mix_rate);
	ObjectTypeDB::bind_method(_MD("get_pitch_scale", "voice"), &SamplePlayer::get_pitch_scale);
	ObjectTypeDB::bind_method(_MD("get_volume", "voice"), &SamplePlayer::get_volume);
	ObjectTypeDB::bind_method(_MD("get_volume_db", "voice"), &SamplePlayer::get_volume_db);
	ObjectTypeDB::bind_method(_MD("get_pan", "voice"), &SamplePlayer::get_pan);
	ObjectTypeDB::bind_method(_MD("get_pan_depth", "voice"), &SamplePlayer::get_pan_depth);
	ObjectTypeDB::bind_method(_MD("get_pan_height", "voice"), &SamplePlayer::get_pan_height);
	ObjectTypeDB::bind_method(_MD("get_filter_type", "voice"), &SamplePlayer::get_filter_type);
	ObjectTypeDB::bind_method(_MD("get_filter_cutoff", "voice"), &SamplePlayer::get_filter_cutoff);
	ObjectTypeDB::bind_method(_MD("get_filter_resonance", "voice"), &SamplePlayer::get_filter_resonance);
	ObjectTypeDB::bind_method(_MD("get_filter_gain", "voice"), &SamplePlayer::get_filter_gain);
	ObjectTypeDB::bind_method(_MD("get_chorus", "voice"), &SamplePlayer::get_chorus);
	ObjectTypeDB::bind_method(_MD("get_reverb_room", "voice"), &SamplePlayer::get_reverb_room);
	ObjectTypeDB::bind_method(_MD("get_reverb", "voice"), &SamplePlayer::get_reverb);

	ObjectTypeDB::bind_method(_MD("set_default_pitch_scale", "ratio"), &SamplePlayer::set_default_pitch_scale);
	ObjectTypeDB::bind_method(_MD("set_default_volume", "volume"), &SamplePlayer::set_default_volume);
	ObjectTypeDB::bind_method(_MD("set_default_volume_db", "db"), &SamplePlayer::set_default_volume_db);
	ObjectTypeDB::bind_method(_MD("set_default_pan", "pan", "depth", "height"), &SamplePlayer::set_default_pan, DEFVAL(0), DEFVAL(0));
	ObjectTypeDB::bind_method(_MD("set_default_filter", "type", "cutoff_hz", "resonance", "gain"), &SamplePlayer::set_default_filter, DEFVAL(0));
	ObjectTypeDB::bind_method(_MD("set_default_chorus", "send"), &SamplePlayer::set_default_chorus);
	ObjectTypeDB::bind_method(_MD("set_default_reverb", "room_type", "send"), &SamplePlayer::set_default_reverb);

	ObjectTypeDB::bind_method(_MD("get_default_pitch_scale"), &SamplePlayer::get_default_pitch_scale);
	ObjectTypeDB::bind_method(_MD("get_default_volume"), &SamplePlayer::get_default_volume);
	ObjectTypeDB::bind_method(_MD("get_default_volume_db"), &SamplePlayer::get_default_volume_db);
	ObjectTypeDB::bind_method(_MD("get_default_pan"), &SamplePlayer::get_default_pan);
	ObjectTypeDB::bind_method(_MD("get_default_pan_depth"), &SamplePlayer::get_default_pan_depth);
	ObjectTypeDB::bind_method(_MD("get_default_pan_height"), &SamplePlayer::get_default_pan_height);
	ObjectTypeDB::bind_method(_MD("get_default_filter_type"), &SamplePlayer::get_default_filter_type);
	ObjectTypeDB::bind_method(_MD("get_default_filter_cutoff"), &SamplePlayer::get_default_filter_cutoff);
	ObjectTypeDB::bind_method(_MD("get_default_filter_resonance"), &SamplePlayer::get_default_filter_resonance);
	ObjectTypeDB::bind_method(_MD("get_default_filter_gain"), &SamplePlayer::get_default_filter_gain);
	ObjectTypeDB::bind_method(_MD("get_default_chorus"), &SamplePlayer::get_default_chorus);
	ObjectTypeDB::bind_method(_MD("get_default_reverb_room"), &SamplePlayer::get_default_reverb_room);
	ObjectTypeDB::bind_method(_MD("get_default_reverb"), &SamplePlayer::get_default_reverb);

	ObjectTypeDB::bind_method(_MD("is_active"), &SamplePlayer::is_active);
	ObjectTypeDB::bind_method(_MD("is_voice_active", "voice"), &SamplePlayer::is_voice_active);

	BIND_CONSTANT(FILTER_NONE);
	BIND_CONSTANT(FILTER_LOWPASS);
	BIND_CONSTANT(FILTER_BANDPASS);
	BIND_CONSTANT(FILTER_HIPASS);
	BIND_CONSTANT(FILTER_NOTCH);
	BIND_CONSTANT(FILTER_PEAK);
	BIND_CONSTANT(FILTER_BANDLIMIT); ///< cutoff is LP resonace is HP
	BIND_CONSTANT(FILTER_LOW_SHELF);
	BIND_CONSTANT(FILTER_HIGH_SHELF);

	BIND_CONSTANT(REVERB_SMALL);
	BIND_CONSTANT(REVERB_MEDIUM);
	BIND_CONSTANT(REVERB_LARGE);
	BIND_CONSTANT(REVERB_HALL);

	BIND_CONSTANT(INVALID_VOICE_ID);
}

SamplePlayer::SamplePlayer() {

	voices.resize(1);

	_default.pitch_scale = 1;
	_default.volume_db = 0;
	_default.pan = 0;
	_default.depth = 0;
	_default.height = 0;
	_default.filter_type = FILTER_NONE;
	_default.filter_cutoff = 5000;
	_default.filter_resonance = 1;
	_default.filter_gain = 1;
	_default.chorus_send = 0;
	_default.reverb_room = REVERB_LARGE;
	_default.reverb_send = 0;
	last_id = 0;
	last_check = 0;
}

SamplePlayer::~SamplePlayer() {
}