#include "ladspa.h"

#define NULL 0

#define INPUT 0
#define OUTPUT 1

#define PORTCOUNT 2

#define BLUR_SIZE 32 // last 5 samples are averaged

struct SoundBlur
{
    LADSPA_Data * input;
    LADSPA_Data * output;
    unsigned long sample_rate;
	LADSPA_Data last_data[BLUR_SIZE]; // used for averaging
};

LADSPA_Handle instantiate_soundblur(const LADSPA_Descriptor * descriptor, unsigned long sample_rate)
{
    SoundBlur * soundblur = NULL;
    soundblur = new SoundBlur;
    soundblur->sample_rate = sample_rate;
	for (int i=0; i<BLUR_SIZE; i++)
	{
		soundblur->last_data[i] = 0;
	}
    LADSPA_Handle handle = soundblur;
    return handle;
}

void connect_port_soundblur(LADSPA_Handle instance, unsigned long port, LADSPA_Data * data_location)
{
    SoundBlur * soundblur = static_cast<SoundBlur*>(instance);
    switch(port)
    {
    case INPUT:
        soundblur->input = data_location;
        break;
    case OUTPUT:
        soundblur->output = data_location;
        break;
    }
}

void activate_soundblur(LADSPA_Handle instance)
{
//    SoundBlur * soundblur = static_cast<SoundBlur*>(instance);
}

void run_soundblur(LADSPA_Handle instance, unsigned long sample_count)
{
    SoundBlur * soundblur = static_cast<SoundBlur*>(instance);
    for (unsigned long i = 0; i<sample_count; i++)
    {
        LADSPA_Data sample = soundblur->input[i];
		for (int j = 0; j<BLUR_SIZE; j++)
		{
			if (soundblur->last_data[j]!=0)
			{
				sample = (soundblur->last_data[j]+sample)/2;
			}
			if (j+1<BLUR_SIZE)
			{
				soundblur->last_data[j]=soundblur->last_data[j+1];
			}
			else 
			{
				soundblur->last_data[j]=soundblur->input[i];
			}
		}
        soundblur->output[i]=sample;
    }
}

void cleanup_soundblur(LADSPA_Handle instance)
{
    SoundBlur * soundblur = static_cast<SoundBlur*>(instance);
    delete soundblur;
}

void
delete_descriptor(LADSPA_Descriptor * descriptor) {
    delete descriptor->PortDescriptors;
    delete descriptor->PortNames;
    delete descriptor;
}

extern "C" __declspec(dllexport) const LADSPA_Descriptor * ladspa_descriptor(unsigned long Index) {
        switch (Index) {
        case 0:
            static LADSPA_Descriptor descriptor;
            static const char * label = "sprk_soundblur";
            static const char * maker = "Nick";
            static const char * copyright = "None";
            static const char * input_string = "Input";
            static const char * output_string = "Output";
            descriptor.UniqueID = 7888;
            descriptor.Label = label;
            descriptor.Properties= LADSPA_PROPERTY_HARD_RT_CAPABLE;
            descriptor.Name = label;
            descriptor.Maker = maker;
            descriptor.Copyright = copyright;
            descriptor.PortCount = PORTCOUNT;
            static LADSPA_PortDescriptor port_descriptors[PORTCOUNT];
            descriptor.PortDescriptors = port_descriptors;
            port_descriptors[INPUT] = LADSPA_PORT_INPUT | LADSPA_PORT_AUDIO;
            port_descriptors[OUTPUT] = LADSPA_PORT_OUTPUT | LADSPA_PORT_AUDIO;
            static LADSPA_PortRangeHint portrangehints[PORTCOUNT];
            portrangehints[INPUT].HintDescriptor = LADSPA_HINT_DEFAULT_0;
            portrangehints[OUTPUT].HintDescriptor = LADSPA_HINT_DEFAULT_0;
            descriptor.PortRangeHints=portrangehints;
            static const char * port_names[PORTCOUNT];
            descriptor.PortNames = port_names;
            port_names[INPUT] = input_string;
            port_names[OUTPUT] = output_string;
            descriptor.instantiate = instantiate_soundblur;
            descriptor.connect_port = connect_port_soundblur;
            descriptor.activate = NULL;
            descriptor.run = run_soundblur;
            descriptor.run_adding = NULL;
            descriptor.set_run_adding_gain = NULL;
            descriptor.deactivate = NULL;
            descriptor.cleanup = cleanup_soundblur;

            return &descriptor;
        default:
            return NULL;
        }
    }