/*      Copyright (c) 1998-99, Be Incorporated, All Rights Reserved.
 *      Distributed under the terms of the Be Sample Code license.
 *
 *      Copyright (c) 2000-2008, Ingo Weinhold <ingo_weinhold@gmx.de>,
 *      Copyright (c) 2000-2008, Stephan Aßmus <superstippi@gmx.de>,
 *      All Rights Reserved. Distributed under the terms of the MIT license.
 */
#ifndef VIDEO_CONSUMER_H
#define VIDEO_CONSUMER_H


#include <BufferConsumer.h>
#include <Locker.h>
#include <MediaEventLooper.h>


class BBitmap;
class NodeManager;
class VideoTarget;


// TODO: The buffer count should depend on the latency!
static const unsigned int kBufferCount = 4;


class VideoConsumer : public BMediaEventLooper, public BBufferConsumer {
public:
                                                                VideoConsumer(
                                                                        const char* name,
                                                                        BMediaAddOn* addon,
                                                                        const uint32 internal_id,
                                                                        NodeManager* manager,
                                                                        VideoTarget* target);
                                                                ~VideoConsumer();
        
        // BMediaNode interface
public:
        
        virtual BMediaAddOn*            AddOn(int32* cookie) const;
        
protected:
        virtual void                            NodeRegistered();
        virtual status_t                        RequestCompleted(
                                                                        const media_request_info& info);
                                                        
        virtual status_t                        HandleMessage(int32 message, const void* data,
                                                                        size_t size);

        // BMediaEventLooper interface
protected:
        virtual void                            HandleEvent(const media_timed_event* event,
                                                                        bigtime_t lateness, bool realTimeEvent);

        // BBufferConsumer interface
public:
        virtual status_t                        AcceptFormat(const media_destination& dest,
                                                                        media_format* format);
        virtual status_t                        GetNextInput(int32* cookie,
                                                                        media_input* _input);
                                                        
        virtual void                            DisposeInputCookie(int32 cookie);
        
protected:
        virtual void                            BufferReceived(BBuffer* buffer);
        
private:
        virtual void                            ProducerDataStatus(
                                                                        const media_destination& forWhom,
                                                                        int32 status,
                                                                        bigtime_t atMediaTime);                                                                 
        virtual status_t                        GetLatencyFor(
                                                                        const media_destination& forWhom,
                                                                        bigtime_t* outLatency,
                                                                        media_node_id* outId);  
        virtual status_t                        Connected(const media_source& producer,
                                                                        const media_destination& where,
                                                                        const media_format& withFormat,
                                                                        media_input* outInput);
        virtual void                            Disconnected(const media_source& producer,
                                                                        const media_destination& where);                                                        
        virtual status_t                        FormatChanged(const media_source& producer,
                                                                        const media_destination& consumer, 
                                                                        int32 from_change_count,
                                                                        const media_format& format);
                                                        
        // VideoConsumer
public:
                        status_t                        CreateBuffers(
                                                                        const media_format& withFormat);
                                                        
                        void                            DeleteBuffers();

                        void                            SetTarget(VideoTarget* target);
                        void                            SetTryOverlay(bool tryOverlay);

private:
                        void                            _SetPerformanceTimeBase(
                                                                        bigtime_t performanceTime);
                        void                            _HandleBuffer(BBuffer* buffer);
                        void                            _UnsetTargetBuffer();

private:
                        int32                           fInternalID;
                        BMediaAddOn*            fAddOn;

                        bool                            fConnectionActive;
                        media_input                     fIn;
                        bigtime_t                       fMyLatency;
                        bigtime_t                       fPerformanceTimeBase;

                        BBitmap*                        fBitmap[kBufferCount];
                        bool                            fOurBuffers;
                        BBufferGroup*           fBuffers;
                        BBuffer*                        fBufferMap[kBufferCount];       

                        NodeManager*            fManager;
                        BLocker                         fTargetLock;    // locks the following variable
                        VideoTarget* volatile   fTarget;
                        int32                           fLastBufferIndex;

                        bool                            fTryOverlay;
};

#endif // VIDEO_CONSUMER_H