/******************************************************************************
/
/       File:                   RadeonProducer.h
/
/       Description:    ATI Radeon Video Producer media node.
/
/       Copyright 2001, Carlos Hasan
/
*******************************************************************************/

#ifndef __RADEON_PRODUCER_H__
#define __RADEON_PRODUCER_H__

#include <kernel/OS.h>
#include <media/BufferProducer.h>
#include <media/Controllable.h>
#include <media/MediaDefs.h>
#include <media/MediaEventLooper.h>
#include <media/MediaNode.h>
#include <support/Locker.h>
#include "VideoIn.h"

class CRadeonAddOn;

class CRadeonProducer :
        public virtual BMediaEventLooper,
        public virtual BBufferProducer,
        public virtual BControllable
{
public:
        CRadeonProducer(CRadeonAddOn *addon, const char *name, const char *device_name, 
                                        int32 internal_id, BMessage *config );
        virtual                 ~CRadeonProducer();

        void                    setupWeb();
        virtual status_t        InitCheck() const { return fInitStatus; }

/* BMediaNode */
public:
        virtual port_id         ControlPort() const;
        virtual BMediaAddOn *AddOn(int32 * internal_id) const;
        virtual status_t        HandleMessage(int32 message, const void *data,
                                        size_t size);
protected:      
        virtual void            Preroll();
        virtual void            SetTimeSource(BTimeSource * time_source);
        virtual status_t        RequestCompleted(const media_request_info & info);

/* BMediaEventLooper */
protected:
        virtual void            NodeRegistered();
        virtual void            Start(bigtime_t performance_time);
        virtual void            Stop(bigtime_t performance_time, bool immediate);
        virtual void            Seek(bigtime_t media_time, bigtime_t performance_time);
        virtual void            TimeWarp(bigtime_t at_real_time,
                                                                bigtime_t to_performance_time);
        virtual status_t        AddTimer(bigtime_t at_performance_time, int32 cookie);
        virtual void            SetRunMode(run_mode mode);
        virtual void            HandleEvent(const media_timed_event *event,
                                                                bigtime_t lateness, bool realTimeEvent = false);
        virtual void            CleanUpEvent(const media_timed_event *event);
        virtual bigtime_t       OfflineTime();
        virtual void            ControlLoop();
        virtual status_t        DeleteHook(BMediaNode * node);

/* BBufferProducer */                                                                   
protected:
        virtual status_t        FormatSuggestionRequested(media_type type, int32 quality,
                                                                media_format * format);
        virtual status_t        FormatProposal(const media_source &output,
                                                                media_format *format);
        virtual status_t        FormatChangeRequested(const media_source &source,
                                                                const media_destination &destination,
                                                                media_format *io_format, int32 *_deprecated_);
        virtual status_t        GetNextOutput(int32 * cookie, media_output * out_output);
        virtual status_t        DisposeOutputCookie(int32 cookie);
        virtual status_t        SetBufferGroup(const media_source &for_source,
                                                                BBufferGroup * group);
        virtual status_t        VideoClippingChanged(const media_source &for_source,
                                                                int16 num_shorts, int16 *clip_data,
                                                                const media_video_display_info &display,
                                                                int32 * _deprecated_);
        virtual status_t        GetLatency(bigtime_t * out_latency);
        virtual status_t        PrepareToConnect(const media_source &what,
                                                                const media_destination &where,
                                                                media_format *format,
                                                                media_source *out_source, char *out_name);
        virtual void            Connect(status_t error, const media_source &source,
                                                                const media_destination &destination,
                                                                const media_format & format, char *io_name);
        virtual void            Disconnect(const media_source & what,
                                                                const media_destination & where);
        virtual void            LateNoticeReceived(const media_source & what,
                                                                bigtime_t how_much, bigtime_t performance_time);
        virtual void            EnableOutput(const media_source & what, bool enabled,
                                                                int32 * _deprecated_);
        virtual status_t        SetPlayRate(int32 numer,int32 denom);
        virtual void            AdditionalBufferRequested(const media_source & source,
                                                                media_buffer_id prev_buffer, bigtime_t prev_time,
                                                                const media_seek_tag * prev_tag);
        virtual void            LatencyChanged(const media_source & source,
                                                                const media_destination & destination,
                                                                bigtime_t new_latency, uint32 flags);

/* BControllable */                                                                     
protected:
        virtual status_t        GetParameterValue(int32 id, bigtime_t *last_change,
                                                                void *value, size_t *size);
        virtual void            SetParameterValue(int32 id, bigtime_t when,
                                                                const void *value, size_t size);
        virtual status_t        StartControlPanel(BMessenger *out_messenger);

public:
        enum {
                C_GET_CONFIGURATION = BTimedEventQueue::B_USER_EVENT,
                C_GET_CONFIGURATION_REPLY
        };
        
        struct configuration_msg {
                port_id reply_port;
        };
        
        struct configuration_msg_reply {
                status_t                res;
                size_t                  config_size;
                char                    config;
        };

/* state */
private:
        void                            HandleStart(bigtime_t performance_time);
        void                            HandleStop();
        void                            HandleTimeWarp(bigtime_t performance_time);
        void                            HandleSeek(bigtime_t performance_time);
        void                            HandleHardware();
        
        // home-brewed extension
        status_t                        GetConfiguration( BMessage *out );
        
        CVideoIn                        fVideoIn;
        
        status_t                        fInitStatus;

        int32                           fInternalID;
        CRadeonAddOn            *fAddOn;

        BBufferGroup            *fBufferGroup;
        //BBufferGroup          *fUsedBufferGroup;
                
        static  int32                           _frame_generator_(void *data);
        int32                           FrameGenerator();

        /* The remaining variables should be declared volatile, but they
         * are not here to improve the legibility of the sample code. */
        //uint32                                fFrame;
        uint32                          fFieldSequenceBase;
        //bigtime_t                     fPerformanceTimeBase;
        bigtime_t                       fProcessingLatency;
        media_output            fOutput;
        //media_raw_video_format        fConnectedFormat;
        //bool                          fConnected;
        bool                            fEnabled;

        // use fixed names as they are used in settings file
        enum EOptions           { 
                P_SOURCE                = 'VSRC', 
                P_AUDIO_SOURCE  = 'ASRC',
                P_AUDIO_FORMAT  = 'AFMT',
                P_VOLUME                = 'VOL ',
                P_STANDARD              = 'TVST',
                P_MODE                  = 'CMOD',
                P_FORMAT                = 'VFMT',
                P_RESOLUTION    = 'RES ',
                P_TUNER                 = 'TUNR',
                P_BRIGHTNESS    = 'BRGT',
                P_CONTRAST              = 'CONT',
                P_SATURATION    = 'SATU',
                P_HUE                   = 'HUE ',
                P_SHARPNESS             = 'SHRP' 
        };
        
        enum { C_RESOLUTION_MAX = 6 };
        enum { C_CHANNEL_MAX = 125 };
        
        int32                           fSource;
        int32                           fStandard;
        int32                           fMode;
        int32                           fCurMode;       // mode, overwritten by application
        int32                           fFormat;
        int32                           fResolution;
        int32                           fTuner;         
        int32                           fBrightness;
        int32                           fContrast;
        int32                           fSaturation;
        int32                           fHue;
        int32                           fSharpness;
        bigtime_t                       fSourceLastChange;
        bigtime_t                       fStandardLastChange;
        bigtime_t                       fModeLastChange;
        bigtime_t                       fFormatLastChange;
        bigtime_t                       fResolutionLastChange;
        bigtime_t                       fTunerLastChange;
        bigtime_t                       fBrightnessLastChange; 
        bigtime_t                       fContrastLastChange;
        bigtime_t                       fSaturationLastChange;
        bigtime_t                       fHueLastChange;
        bigtime_t                       fSharpnessLastChange;

        status_t        AddInt32( 
                BMessage *msg, EOptions option, int32 value );
                
        status_t        FindInt32( 
                BMessage *config, EOptions option, int32 min_value, int32 max_value, 
                int32 default_value, int32 *value );

        // format negotiation helpers
        status_t        verifySetMode( media_format *format );
        int32           extractCaptureMode( const media_format *format );
        status_t        verifySetPixelAspect( media_format *format );
        status_t        verifyActiveRange( media_format *format );
        void            setActiveRange( media_format *format );
        status_t        verifyOrientation( media_format *format );
        void            setOrientation( media_format *format );
        status_t        verifyPixelFormat( media_format *format );
        void            setPixelFormat( media_format *format );
        status_t        verifySetSize( media_format *format, int32 mode, bool set_bytes_per_row );
        status_t        verifyFormatOffsets( media_format *format );
        void            setFormatOffsets( media_format *format );
        status_t        verifyFormatFlags( media_format *format );
        void            setFormatFlags( media_format *format );
        
        status_t        finalizeFormat( media_format *format );
        
        void            startCapturing();
        void            captureField( bigtime_t *capture_time );
        void            setDefaultBufferGroup();
        void            instantFormatChange( media_format *new_format );
};

#endif