#ifdef WIN32
#include "windows.h"
#define DLGCLASS CGainDialog
#define GUICLASS gain_gui
#include "ospguiatl.h"
#endif

#define OSP_STD_CHANBUF_SIZE 4 // Support maximum 4 channels
#include "osputil.h"
#include <string.h>


class gain_dsp : public osp_std_plugin
{
public:

    OSP_INFO_BEGIN
        OSP_RATE_MINMAX(4000,192000) // these sample rates

     // Supported transforms
       
     // SUGGESTED                    IN/OUT

        OSP_SUGGEST OSP_TRANSFORM_AUD(1,1) // mono to mono

        OSP_SUGGEST OSP_TRANSFORM_AUD(2,2) // stereo to stereo

        OSP_SUGGEST OSP_TRANSFORM_AUD(4,4) // quadro to quadro

    OSP_INFO_END

    // Parameters

    osp_param_volume gain,clip;


    // Plugin information

    static const char *getstr(int idx) 
    {
        static const char *data[]=
        {
      // 12345678901234567890   
    "4front-gain-1", // uniqueid
    
        "4Front Gain Adjuster", "1.0a", // name and version
        
        "Gain",  // short name

        "4Front",  // vendor
        "http://www.yohng.com/ospi/", // support URL
        "Adjusts gain of sound, works as volume control", // description

        // copyrights
        "Copyright(C)2002 4Front Technologies. All rights reserved."
        };

        return (((unsigned int)idx)>7)?NULL:data[idx];
    }

    // constructor and parameter initialization
    //
    // note, that order of initialization should be the same
    // as the order of declaration.
    //
    // this example's GUI has parameter numbers hardcoded, so
    // changing order of these parameters may result in
    // unpredictable failures

    gain_dsp() : 
        gain(this,"Gain",1.0f), // name, default value
        clip(this,"Clip at",1.0f)
    {
        gain.automation(ORDER2);

        OSP_ALIAS(gain)
        OSP_ALIAS(clip)

        // if you ever will want to assign parameter inside filter,
        // use paramvalue/paramint(param.id, newvalue) or 
        // param.setfloat/setint
        //
        // do not use param = value, since that is not going to work
        //
        // normally, parameters should be only changed from GUI using
        // paramvalue and paramint


        // defaults
        osp_init_info(); // should be called BEFORE we want to set defaults
        nports(AUD_IN,2);
        nports(AUD_OUT,2);
        rate(44100);
    }

    // UNCOMMEND IF NEEDED
    //
    // void rateupdated()  
    // { 
    //     osp_std_plugin::rateupdated();
    //
    //     // TODO: add code when rate is updated?
    // }

    // UNCOMMEND IF NEEDED
    //
    // void nportsupdated(int type,int n) 
    // { 
    //     osp_std_plugin::nportsupdated(type,n);
    //
    //     // TODO: add code when number of ports changed?
    // }


    void reset()
    {
        // TODO: add code for resetting plugin
    }


    // processing function
    //
    // osp_std_plugin::processf() function parses events, splits
    // audio to blocks (between events) and calls this function
    //
    //
    // NOTE! Due to osp_std_plugin implementation, this function
    //       is REQUIRED to update in[cn]/out[ch] pointers to point
    //       right past the end of the buffer. This example (gain) modifies
    //       pointers correctly. Default implementation of 
    //       osp_std_plugin::processBLOCK() updates pointers correctly
    //       as well.

    void processBLOCK(int64 stamp,float **in,
                                  int instep,
                                  float **out,
                                  int outstep, int sz)
    {
        float fgain=gain; // cache param values
        float fgain_v=gain.velocity, // automation order1
              fgain_a=gain.accel;    // automation order2 

        int t,k;
        int nch=nports(AUD_IN);

        if (bypass())  // if bypassed, then pass along default implementation
        {
            osp_std_plugin::processBLOCK(stamp,in,instep,out,outstep,sz);
            return;
        }

        

        for(k=0;k<sz;k++)
        {
            for(t=0;t<nch;t++)
            {
                // Due to my personal preference, I write out[t][0] instead
                // of *out[t] - this is barely the same, so don't get confused

                out[t][0] = in[t][0]*fgain;

                // update in/out pointers
                in[t]  += instep;
                out[t] += outstep;
            }

            // automate parameter
            fgain+=fgain_v;
            fgain_v+=fgain_a;
        }
    }

    /*

        This function is required for OSPI plugins to wrap onto other standards
        that need GUIDs and other unique IDs, which cannot be derived from
        OSPI-specification.
        
        Please, be sure to change this for each new plugin! 
        Use guidgen application, shipped with Visual Studio

        If you won't do this, I'll be forced to hunt down and kill you.

    */
    static int factory_extension(const char *name,void *pvt)
    {
#ifdef WIN32
static const GUID w3guid = 
{ 0x973bb76, 0x473f, 0x4e41, { 0x95, 0x90, 0xea, 0x30, 0x52, 0x18, 0xa3, 0xa5 } };

// {4BB864C2-93DE-4fb9-9BAC-F2F96CDA1DCB}
static GUID wmpguid1 = 
{ 0x4bb864c2, 0x93de, 0x4fb9, { 0x9b, 0xac, 0xf2, 0xf9, 0x6c, 0xda, 0x1d, 0xcb } };

// {05D2A150-D4B5-45a2-82F3-EDB41BDFDABF}
static GUID wmpguid2 = 
{ 0x5d2a150, 0xd4b5, 0x45a2, { 0x82, 0xf3, 0xed, 0xb4, 0x1b, 0xdf, 0xda, 0xbf } };

// {D2BA3542-8513-4450-B0A6-EF888753D000}
static GUID wmpguid3 = 
{ 0xd2ba3542, 0x8513, 0x4450, { 0xb0, 0xa6, 0xef, 0x88, 0x87, 0x53, 0xd0, 0x0 } };

        if (!name) return 0;
        if (strcmp(name,"w3guid")==0)
        {
            memcpy(pvt,&w3guid,sizeof(GUID));
            return 1;
        }else 
        if (strcmp(name,"wmpguid1")==0)
        {
            memcpy(pvt,&wmpguid1,sizeof(GUID));
            return 1;
        }else 
        if (strcmp(name,"wmpguid2")==0)
        {
            memcpy(pvt,&wmpguid2,sizeof(GUID));
            return 1;
        }else 
        if (strcmp(name,"wmpguid3")==0)
        {
            memcpy(pvt,&wmpguid3,sizeof(GUID));
            return 1;
        }else 
        if (strcmp(name,"soniqueguid")==0)
        {
            memcpy(pvt,&wmpguid3,sizeof(GUID));
            return 1;
        }else 
#endif
            return 0;
    }

};


OSP_PLUGINS_BEGIN
#ifdef WIN32
    OSP_PLUGIN_GUI(0,gain_dsp,gain_gui)
#else
    OSP_PLUGIN(0,gain_dsp)
#endif    
OSP_PLUGINS_END