/*
 * 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.
 */

/*!     This class controls our playback
        Note: Add/RemoveListener() are the only methods that lock the object
        themselves. All other methods need it to be locked before.
*/
#ifndef PLAYBACK_MANAGER_H
#define PLAYBACK_MANAGER_H


#include <List.h>
#include <Looper.h>
#include <Rect.h>


class MessageEvent;
class PlaybackListener;


enum {
        MODE_PLAYING_FORWARD                    = 1,
        MODE_PLAYING_BACKWARD                   = 2,
        MODE_PLAYING_PAUSED_FORWARD             = -1,
        MODE_PLAYING_PAUSED_BACKWARD    = -2,
};

enum {
        LOOPING_ALL                                             = 0,
        LOOPING_RANGE                                   = 1,
        LOOPING_SELECTION                               = 2,
        LOOPING_VISIBLE                                 = 3,
};

enum {
        MSG_PLAYBACK_FORCE_UPDATE               = 'pbfu',
        MSG_PLAYBACK_SET_RANGE                  = 'pbsr',
        MSG_PLAYBACK_SET_VISIBLE                = 'pbsv',
        MSG_PLAYBACK_SET_LOOP_MODE              = 'pbsl',
};


class PlaybackManager : public BLooper {
private:
                        struct PlayingState;
                        struct SpeedInfo;

public:
                                                                PlaybackManager();
        virtual                                         ~PlaybackManager();

                        void                            Init(float frameRate,
                                                                        bool initPerformanceTimes,
                                                                        int32 loopingMode = LOOPING_ALL,
                                                                        bool loopingEnabled = true,
                                                                        float speed = 1.0,
                                                                        int32 playMode
                                                                                = MODE_PLAYING_PAUSED_FORWARD,
                                                                        int32 currentFrame = 0);
                        void                            Cleanup();

        // BHandler interface
        virtual void                            MessageReceived(BMessage* message);

                        void                            StartPlaying(bool atBeginning = false);
                        void                            StopPlaying();
                        void                            TogglePlaying(bool atBeginning = false);
                        void                            PausePlaying();
                        bool                            IsPlaying() const;

                        int32                           PlayMode() const;
                        int32                           LoopMode() const;
                        bool                            IsLoopingEnabled() const;
                        int64                           CurrentFrame() const;
                        float                           Speed() const;

        virtual void                            SetFramesPerSecond(float framesPerSecond);
                        float                           FramesPerSecond() const;

        virtual BRect                           VideoBounds() const = 0;

        virtual void                            FrameDropped() const;

                        void                            DurationChanged();
        virtual int64                           Duration() = 0;

        virtual void                            SetVolume(float percent) = 0;

                        // playing state manipulation
                        void                            SetCurrentFrame(int64 frame);
        virtual void                            SetPlayMode(int32 mode,
                                                                        bool continuePlaying = true);
                        void                            SetLoopMode(int32 mode,
                                                                        bool continuePlaying = true);
                        void                            SetLoopingEnabled(bool enabled,
                                                                        bool continuePlaying = true);
                        void                            SetSpeed(float speed);

                        // playing state change info
                        int64                           NextFrame() const;
                        int64                           NextPlaylistFrame() const;

                        int64                           FirstPlaybackRangeFrame();
                        int64                           LastPlaybackRangeFrame();

                        // playing state access
                        int64                           StartFrameAtFrame(int64 frame);
                        int64                           StartFrameAtTime(bigtime_t time);
                        int64                           EndFrameAtFrame(int64 frame);
                        int64                           EndFrameAtTime(bigtime_t time);
                        int64                           FrameCountAtFrame(int64 frame);
                        int64                           FrameCountAtTime(bigtime_t time);
                        int32                           PlayModeAtFrame(int64 frame);
                        int32                           PlayModeAtTime(bigtime_t time);
                        int32                           LoopModeAtFrame(int64 frame);
                        int32                           LoopModeAtTime(bigtime_t time);
                        // ...

                        // playing frame/time/interval info
                        int64                           PlaylistFrameAtFrame(int64 frame,
                                                                        int32& playingDirection,
                                                                        bool& newState) const;
                        int64                           PlaylistFrameAtFrame(int64 frame,
                                                                        int32& playingDirection) const;
                        int64                           PlaylistFrameAtFrame(int64 frame) const;
                        int64                           NextChangeFrame(int64 startFrame,
                                                                                                int64 endFrame) const;
                        bigtime_t                       NextChangeTime(bigtime_t startTime,
                                                                                           bigtime_t endTime) const;
                        void                            GetPlaylistFrameInterval(
                                                                        int64 startFrame, int64& endFrame,
                                                                        int64& xStartFrame, int64& xEndFrame,
                                                                        int32& playingDirection) const;

        virtual void                            GetPlaylistTimeInterval(
                                                                        bigtime_t startTime, bigtime_t& endTime,
                                                                        bigtime_t& xStartTime, bigtime_t& xEndTime,
                                                                        float& playingSpeed) const;

                        // conversion: video frame <-> (performance) time
                        int64                           FrameForTime(bigtime_t time) const;
                        bigtime_t                       TimeForFrame(int64 frame) const;
                        // conversion: (performance) time <-> real time
        virtual bigtime_t                       RealTimeForTime(bigtime_t time) const = 0;
        virtual bigtime_t                       TimeForRealTime(bigtime_t time) const = 0;
                        // conversion: Playist frame <-> Playlist time
                        int64                           PlaylistFrameForTime(bigtime_t time) const;
                        bigtime_t                       PlaylistTimeForFrame(int64 frame) const;

                        // to be called by audio/video producers
        virtual void                            SetCurrentAudioTime(bigtime_t time);
                        void                            SetCurrentVideoFrame(int64 frame);
                        void                            SetCurrentVideoTime(bigtime_t time);
                        void                            SetPerformanceFrame(int64 frame);
                        void                            SetPerformanceTime(bigtime_t time);

                        // listener support
                        void                            AddListener(PlaybackListener* listener);
                        void                            RemoveListener(PlaybackListener* listener);

        virtual void                            NotifyPlayModeChanged(int32 mode) const;
        virtual void                            NotifyLoopModeChanged(int32 mode) const;
        virtual void                            NotifyLoopingEnabledChanged(
                                                                        bool enabled) const;
        virtual void                            NotifyVideoBoundsChanged(BRect bounds) const;
        virtual void                            NotifyFPSChanged(float fps) const;
        virtual void                            NotifyCurrentFrameChanged(int64 frame) const;
        virtual void                            NotifySpeedChanged(float speed) const;
        virtual void                            NotifyFrameDropped() const;
        virtual void                            NotifyStopFrameReached() const;
        virtual void                            NotifySeekHandled(int64 seekedFrame) const;

                        // debugging
                        void                            PrintState(PlayingState* state);
                        void                            PrintStateAtFrame(int64 frame);

 private:
                        // state management
                        void                            _PushState(PlayingState* state,
                                                                                   bool adjustCurrentFrame);
                        void                            _UpdateStates();
                        int32                           _IndexForFrame(int64 frame) const;
                        int32                           _IndexForTime(bigtime_t time) const;
                        PlayingState*           _LastState() const;
                        PlayingState*           _StateAt(int32 index) const;
                        PlayingState*           _StateAtTime(bigtime_t time) const;
                        PlayingState*           _StateAtFrame(int64 frame) const;

        static  int32                           _PlayingDirectionFor(int32 playingMode);
        static  int32                           _PlayingDirectionFor(PlayingState* state);
        static  void                            _GetPlayingBoundsFor(PlayingState* state,
                                                                                                         int64& startFrame,
                                                                                                         int64& endFrame,
                                                                                                         int64& frameCount);
        static  int64                           _PlayingStartFrameFor(PlayingState* state);
        static  int64                           _PlayingEndFrameFor(PlayingState* state);
        static  int64                           _RangeFrameForFrame(PlayingState* state,
                                                                                                        int64 frame);
        static  int64                           _FrameForRangeFrame(PlayingState* state,
                                                                                                        int64 index);
        static  int64                           _NextFrameInRange(PlayingState* state,
                                                                                                  int64 frame);

                        // speed management
                        void                            _PushSpeedInfo(SpeedInfo* info);
                        SpeedInfo*                      _LastSpeedInfo() const;
                        SpeedInfo*                      _SpeedInfoAt(int32 index) const;
                        int32                           _SpeedInfoIndexForFrame(int64 frame) const;
                        int32                           _SpeedInfoIndexForTime(bigtime_t time) const;
                        SpeedInfo*                      _SpeedInfoForFrame(int64 frame) const;
                        SpeedInfo*                      _SpeedInfoForTime(bigtime_t time) const;
                        void                            _UpdateSpeedInfos();

                        bigtime_t                       _TimeForLastFrame() const;
                        bigtime_t                       _TimeForNextFrame() const;

                        void                            _NotifySeekHandledIfNecessary(
                                                                        PlayingState* state);
                        void                            _CheckStopPlaying();

private:
                        BList                           fStates;
                        BList                           fSpeeds;
        volatile bigtime_t                      fCurrentAudioTime;
        volatile bigtime_t                      fCurrentVideoTime;
        volatile bigtime_t                      fPerformanceTime;

                        MessageEvent*           fPerformanceTimeEvent;

        volatile float                          fFrameRate;                     // video frame rate
        volatile bigtime_t                      fStopPlayingFrame;      // frame at which playing
                                                                                                        // shall be stopped,
                                                                                                        // disabled: -1

                        BList                           fListeners;
protected:
                        bool                            fNoAudio;
};


#endif  // PLAYBACK_MANAGER_H