/*
 * Copyright 2009, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _MEDIA_EVENT_LOOPER_H
#define _MEDIA_EVENT_LOOPER_H


#include <MediaNode.h>
#include <TimedEventQueue.h>


/*! BMediaEventLooper spawns a thread which calls WaitForMessage, pushes
        BMediaNode messages onto its BTimedEventQueues. informs you when it
        is time to handle an event. Report your event latency, push other events
        onto the queue and override HandleEvent to do your work.
*/
class BMediaEventLooper : public virtual BMediaNode {
protected:
        enum run_state {
                B_IN_DISTRESS           = -1,
                B_UNREGISTERED,
                B_STOPPED,
                B_STARTED,
                B_QUITTING,
                B_TERMINATED,
                B_USER_RUN_STATES       = 0x4000
        };

protected:
        explicit                                        BMediaEventLooper(
                                                                        uint32 apiVersion = B_BEOS_VERSION);
        virtual                                         ~BMediaEventLooper();

protected:
        // BMediaNode interface
        virtual void                            NodeRegistered();
        virtual void                            Start(bigtime_t performanceTime);
        virtual void                            Stop(bigtime_t performanceTime,
                                                                        bool immediate);
        virtual void                            Seek(bigtime_t mediaTime,
                                                                        bigtime_t performanceTime);
        virtual void                            TimeWarp(bigtime_t atRealTime,
                                                                        bigtime_t toPerformanceTime);
        virtual status_t                        AddTimer(bigtime_t atPerformanceTime,
                                                                        int32 cookie);
        virtual void                            SetRunMode(run_mode mode);

protected:
        // BMediaEventLooper Hook functions

        // NOTE: You must override this method to handle your events!
        // You should not call HandleEvent directly.
        virtual void                            HandleEvent(const media_timed_event* event,
                                                                        bigtime_t lateness,
                                                                        bool realTimeEvent = false) = 0;

        // Override this method to properly clean up any custom events you have
        // added to your event queue.
        virtual void                            CleanUpEvent(const media_timed_event* event);

        // NOTE: Called in offline mode to determine the current time of the node.
        // Update your internal information whenever it changes.
        virtual bigtime_t                       OfflineTime();

        // NOTE: Override this method only if you know what you are doing!
        // The default control loop function waits for messages, pops events
        // off the queue and calls DispatchEvent.
        virtual void                            ControlLoop();

                        thread_id                       ControlThread();

protected:
                        BTimedEventQueue*       EventQueue();
                        BTimedEventQueue*       RealTimeQueue();

                        int32                           Priority() const;
                        int32                           RunState() const;
                        bigtime_t                       EventLatency() const;
                        bigtime_t                       BufferDuration() const;
                        bigtime_t                       SchedulingLatency() const;

        // NOTE: Use the priority constants from OS.h or suggest_thread_priority
        // from scheduler.h. The passed priority will be clamped to be in range 5
        // to 120.
                        status_t                        SetPriority(int32 priority);
                        void                            SetRunState(run_state state);
                        void                            SetEventLatency(bigtime_t latency);
                        void                            SetBufferDuration(bigtime_t duration);
                        void                            SetOfflineTime(bigtime_t offTime);

        // Spawns and resumes the control thread - must be called from
        // NodeRegistered().
                        void                            Run();

        // Quits the control thread - must be called from your destructor.
                        void                            Quit();

        // Calls HandleEvent and does BMediaEventLooper event work
                        void                            DispatchEvent(const media_timed_event* event,
                                                                        bigtime_t lateness,
                                                                        bool realTimeEvent = false);

private:
        static  int32                           _ControlThreadStart(void* cookie);
        static  void                            _CleanUpEntry(const media_timed_event* event,
                                                                        void* context);
                        void                            _DispatchCleanUp(
                                                                        const media_timed_event* event);

private:
                        BTimedEventQueue        fEventQueue;
                        BTimedEventQueue        fRealTimeQueue;
                        thread_id                       fControlThread;
                        int32                           fCurrentPriority;
                        int32                           fSetPriority;
                        vint32                          fRunState;
                        bigtime_t                       fEventLatency;
                        bigtime_t                       fSchedulingLatency;
                        bigtime_t                       fBufferDuration;
                        bigtime_t                       fOfflineTime;
                        uint32                          fApiVersion;

protected:
        virtual status_t        DeleteHook(BMediaNode * node);

private:
        // FBC padding and forbidden methods
                                                                BMediaEventLooper(const BMediaEventLooper&);
                        BMediaEventLooper&      operator=(const BMediaEventLooper&);

        virtual status_t                        _Reserved_BMediaEventLooper_0(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_1(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_2(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_3(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_4(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_5(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_6(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_7(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_8(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_9(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_10(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_11(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_12(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_13(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_14(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_15(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_16(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_17(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_18(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_19(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_20(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_21(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_22(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEventLooper_23(int32 arg, ...);

        bool                                            _reserved_bool_[4];
        uint32                                          _reserved_BMediaEventLooper_[12];
};

#endif // _MEDIA_EVENT_LOOPER_H