/*
 * Copyright 2012, Gerasim Troeglazov (3dEyes**), 3dEyes@gmail.com.
 * All rights reserved.
 * Distributed under the terms of the MIT License.
 */ 

#ifndef __VST_NODE_H__
#define __VST_NODE_H__

#include <Controllable.h>
#include <BufferProducer.h>
#include <BufferConsumer.h>
#include <MediaEventLooper.h>

#include "VSTHost.h"

class BMediaAddOn;
class BBufferGroup;

#define BUFF_SIZE 0x2000

#define ID_AUDIO_INPUT  1
#define ID_AUDIO_OUTPUT 2

//parameter IDs
enum param_id_t {
        P_MUTE          = 50,
        P_BYPASS,
        
        P_PARAM         = 5000,
        P_ABOUT         = 6000,
        P_LABEL         = 7000,
        P_LABEL2        = 8000,         
        P_LABEL3        = 9000,
};


class VSTNode : public  BBufferConsumer,
                                public  BBufferProducer,
                                public  BControllable,
                                public  BMediaEventLooper {     
public:
        virtual                                 ~VSTNode();
                                                        VSTNode(BMediaAddOn *addon, const char *name,
                                                                const char* path);
        //BMediaNode
public:
        virtual         BMediaAddOn *AddOn(int32 *id) const;
        virtual         status_t        HandleMessage(int32 code, const void *data,     size_t size);
protected:
        virtual         void            NodeRegistered();
        //BControllable
public: 
        virtual         status_t        GetParameterValue(int32 id,     bigtime_t *lastChangeTime,
                                                                        void *value, size_t *size);
        virtual         void            SetParameterValue(int32 id,     bigtime_t changeTime,
                                                                        const void *value, size_t size);
        //BBufferConsumer
public:
        virtual         void            BufferReceived(BBuffer *buffer);                                                                        
        virtual         status_t        AcceptFormat(const media_destination &dst,
                                                        media_format *format);
        virtual         status_t        GetNextInput(int32 *cookie,     media_input *input);
        virtual         void            DisposeInputCookie(int32 cookie);
        virtual         status_t        FormatChanged(const media_source &src,
                                                                        const media_destination &dst,
                                                        int32 change_tag, const media_format &format);
        virtual         void            ProducerDataStatus(const media_destination &dst,
                                                                        int32 status,
                                                                        bigtime_t when);        
        virtual         status_t        GetLatencyFor(const media_destination &dst,
                                                        bigtime_t *latency,
                                                        media_node_id *time_src);               
        virtual         status_t        Connected(const media_source &src, 
                                                                        const media_destination &dst,
                                                                        const media_format &format,
                                                                        media_input *input);
        virtual         void            Disconnected(const media_source &src,
                                                                        const media_destination &dst);
        //BBufferProducer
public:
        virtual         status_t        FormatSuggestionRequested(media_type type,
                                                                        int32 quality, media_format *format);
        virtual         status_t        FormatProposal(const media_source &src,
                                                                        media_format *format);
        virtual         status_t        FormatChangeRequested(const media_source &src,
                                                                        const media_destination &dst,
                                                                        media_format *format,
                                                                        int32* _deprecated_);
        virtual         void            LateNoticeReceived(const media_source &src,
                                                                        bigtime_t late, bigtime_t when);
        virtual         status_t        GetNextOutput(int32 *cookie, media_output *output);
        virtual         status_t        DisposeOutputCookie(int32 cookie);
        virtual         status_t        SetBufferGroup(const media_source &src,
                                                                        BBufferGroup *group);
        virtual         status_t        PrepareToConnect(const media_source &src,
                                                                        const media_destination &dst,
                                                                        media_format *format, media_source *out_source,
                                                                        char *name);
        virtual         void            Connect(status_t status,
                                                                        const media_source &src,
                                                                        const media_destination &dst,
                                                                        const media_format &format,
                                                                        char* name);
        virtual         void            Disconnect(const media_source &src,
                                                                        const media_destination &dst);          
        virtual         void            EnableOutput(const media_source &src,
                                                                        bool enabled, int32* _deprecated_);
        virtual         status_t        GetLatency(bigtime_t *outLatency);
        virtual         void            LatencyChanged( const media_source &src,
                                                                        const media_destination &dst,
                                                                        bigtime_t latency, uint32 flags);
        //BMediaEventLooper
protected:                                                                      
        virtual         bigtime_t       OfflineTime();
        //VSTNode
protected:
        virtual         void            HandleEvent(const media_timed_event *event,
                                                                        bigtime_t late,
                                                                        bool realTimeEvent=false);
                                void            ParameterEventProcessing(const media_timed_event *event);               
                                status_t        ValidateFormat(const media_format& preferredFormat,
                                                                        media_format &proposedFormat);
                                void            SetOutputFormat(media_format& ioFormat);
        virtual         void            InitParameterValues();
        virtual         void            InitParameterWeb();
        virtual         void            InitFilter();
        virtual         bigtime_t       GetFilterLatency();
        virtual         void            FilterBuffer(BBuffer* pBuffer);

private:
        BMediaAddOn                             *fAddOn;
        VSTPlugin                               *fPlugin;
        BParameterWeb                   *fWeb;

        media_format                    fPreferredFormat;
        media_format                    fFormat;
        media_input                             fInputMedia;
        media_output                    fOutputMedia;
        bool                                    fOutputMediaEnabled;
        bigtime_t                               fDownstreamLatency;
        bigtime_t                               fProcessLatency;
        
        int32                                   fBlockSize;     
        int32                                   fMute;
        int32                                   fByPass;
        bigtime_t                               fMuteLastChanged;
        bigtime_t                               fByPassLastChanged;
};

#endif //__VST_NODE_H__