/*
 * Copyright 2009, Haiku Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _TIME_SOURCE_H
#define _TIME_SOURCE_H


#include <MediaDefs.h>
#include <MediaNode.h>


class _BSlaveNodeStorageP;

namespace BPrivate {
        namespace media {
                class BMediaRosterEx;
                class TimeSourceObject;
                class SystemTimeSourceObject;
                class SlaveNodes;
                struct TimeSourceTransmit;
        }
}


class BTimeSource : public virtual BMediaNode {
protected:
        virtual                                         ~BTimeSource();

public:
        virtual status_t                        SnoozeUntil(bigtime_t performanceTime,
                                                                        bigtime_t withLatency = 0,
                                                                        bool retrySignals = false);

                        bigtime_t                       Now();
                        bigtime_t                       PerformanceTimeFor(bigtime_t realTime);
                        bigtime_t                       RealTimeFor(bigtime_t performanceTime,
                                                                        bigtime_t withLatency);
                        bool                            IsRunning();

                        status_t                        GetTime(bigtime_t* _performanceTime,
                                                                        bigtime_t* _realTime, float* _drift);
                        status_t                        GetStartLatency(bigtime_t* _latency);

        static  bigtime_t                       RealTime();

protected:
                                                                BTimeSource();

        virtual status_t                        HandleMessage(int32 message, const void* data,
                                                                        size_t size);

                        void                            PublishTime(bigtime_t performanceTime,
                                                                        bigtime_t realTime, float drift);

                        void                            BroadcastTimeWarp(bigtime_t atRealTime,
                                                                        bigtime_t newPerformanceTime);

                        void                            SendRunMode(run_mode mode);
        virtual void                            SetRunMode(run_mode mode);

        enum time_source_op {
                B_TIMESOURCE_START = 1,
                B_TIMESOURCE_STOP,
                B_TIMESOURCE_STOP_IMMEDIATELY,
                B_TIMESOURCE_SEEK
        };

        struct time_source_op_info {
                time_source_op  op;
                int32                   _reserved1;
                bigtime_t               real_time;
                bigtime_t               performance_time;
                int32                   _reserved2[6];
        };

        virtual status_t                        TimeSourceOp(const time_source_op_info& op,
                                                                        void* _reserved) = 0;

private:
        friend class BMediaNode;
        friend class BMediaRoster;
        friend class BPrivate::media::BMediaRosterEx;
        friend class BPrivate::media::SystemTimeSourceObject;
        friend class BPrivate::media::TimeSourceObject;

                                                                BTimeSource(const BTimeSource& other);
                        BTimeSource&            operator=(const BTimeSource& other);
                                                                        // not implemented

        explicit                                        BTimeSource(media_node_id id);

                        status_t                        _Reserved_TimeSource_0(void*);
                                // used for TimeSourceOp()
        virtual status_t                        _Reserved_TimeSource_1(void*);
        virtual status_t                        _Reserved_TimeSource_2(void*);
        virtual status_t                        _Reserved_TimeSource_3(void*);
        virtual status_t                        _Reserved_TimeSource_4(void*);
        virtual status_t                        _Reserved_TimeSource_5(void*);

        virtual status_t                        RemoveMe(BMediaNode* node);
        virtual status_t                        AddMe(BMediaNode* node);

                        void                            FinishCreate();

                        void                            DirectStart(bigtime_t at);
                        void                            DirectStop(bigtime_t at, bool immediate);
                        void                            DirectSeek(bigtime_t to, bigtime_t at);
                        void                            DirectSetRunMode(run_mode mode);
                        void                            DirectAddMe(const media_node& node);
                        void                            DirectRemoveMe(const media_node& node);

private:
                        bool                            fStarted;
                        area_id                         fArea;
                        BPrivate::media::TimeSourceTransmit* fBuf;
                        BPrivate::media::SlaveNodes* fSlaveNodes;

                        area_id                         _reserved_area;
                        bool                            fIsRealtime;
                        bool                            _reserved_bool_[3];
                        uint32                          _reserved_time_source_[10];
};


#endif  // _TIME_SOURCE_H