/*
 * Copyright 2002-2009, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Marcus Overhagen
 *              Jérôme Duval
 */
#ifndef _SOUND_PLAY_NODE_H
#define _SOUND_PLAY_NODE_H


#include <Buffer.h>
#include <BufferGroup.h>
#include <BufferProducer.h>
#include <MediaEventLooper.h>
#include <SoundPlayer.h>


namespace BPrivate {


class SoundPlayNode : public BBufferProducer, public BMediaEventLooper {
public:
                                                                SoundPlayNode(const char* name,
                                                                        BSoundPlayer* player);
        virtual                                         ~SoundPlayNode();

                        bool                            IsPlaying();
                        bigtime_t                       CurrentTime();

        // BMediaNode methods

        virtual BMediaAddOn*            AddOn(int32* _internalID) const;

protected:
        virtual void                            Preroll();

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

protected:
        virtual void                            NodeRegistered();
        virtual status_t                        RequestCompleted(
                                                                        const media_request_info& info);
        virtual void                            SetTimeSource(BTimeSource* timeSource);
        virtual void                            SetRunMode(run_mode mode);

        // BBufferProducer methods

        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* format, int32* _deprecated_);
        virtual status_t                        GetNextOutput(int32* cookie,
                                                                        media_output* _output);
        virtual status_t                        DisposeOutputCookie(int32 cookie);

        virtual status_t                        SetBufferGroup(const media_source& forSource,
                                                                        BBufferGroup* group);
        virtual status_t                        GetLatency(bigtime_t* _latency);

        virtual status_t                        PrepareToConnect(const media_source& what,
                                                                        const media_destination& where,
                                                                        media_format* format, media_source* _source,
                                                                        char* _name);

        virtual void                            Connect(status_t error,
                                                                        const media_source& source,
                                                                        const media_destination& destination,
                                                                        const media_format& format,
                                                                        char* name);

        virtual void                            Disconnect(const media_source& what,
                                                                        const media_destination& where);

        virtual void                            LateNoticeReceived(const media_source& what,
                                                                        bigtime_t howMuch,
                                                                        bigtime_t performanceTime);

        virtual void                            EnableOutput(const media_source& what,
                                                                        bool enabled, int32* _deprecated_);
        virtual void                            AdditionalBufferRequested(
                                                                        const media_source& source,
                                                                        media_buffer_id previousBuffer,
                                                                        bigtime_t previousTime,
                                                                        const media_seek_tag* previousTag);
        virtual void                            LatencyChanged(const media_source& source,
                                                                        const media_destination& destination,
                                                                        bigtime_t newLatency, uint32 flags);

        // BMediaEventLooper methods

protected:
        virtual void                            HandleEvent(const media_timed_event* event,
                                                                        bigtime_t lateness,
                                                                        bool realTimeEvent = false);
public:
                        media_multi_audio_format Format() const;

protected:
        virtual status_t                        HandleStart(const media_timed_event* event,
                                                                        bigtime_t lateness,
                                                                        bool realTimeEvent = false);
        virtual status_t                        HandleSeek(const media_timed_event* event,
                                                                        bigtime_t lateness,
                                                                        bool realTimeEvent = false);
        virtual status_t                        HandleWarp(const media_timed_event* event,
                                                                        bigtime_t lateness,
                                                                        bool realTimeEvent = false);
        virtual status_t                        HandleStop(const media_timed_event* event,
                                                                        bigtime_t lateness,
                                                                        bool realTimeEvent = false);
        virtual status_t                        SendNewBuffer(const media_timed_event* event,
                                                                        bigtime_t lateness,
                                                                        bool realTimeEvent = false);
        virtual status_t                        HandleDataStatus(const media_timed_event* event,
                                                                        bigtime_t lateness,
                                                                        bool realTimeEvent = false);
        virtual status_t                        HandleParameter(const media_timed_event* event,
                                                                        bigtime_t lateness,
                                                                        bool realTimeEvent = false);

                        status_t                        AllocateBuffers();
                        BBuffer*                        FillNextBuffer(bigtime_t eventTime);

private:
                        BSoundPlayer*           fPlayer;

                        status_t                        fInitStatus;
                        bool                            fOutputEnabled;
                        media_output            fOutput;
                        BBufferGroup*           fBufferGroup;
                        bigtime_t                       fLatency;
                        bigtime_t                       fInternalLatency;
                        bigtime_t                       fStartTime;
                        uint64                          fFramesSent;
                        int32                           fTooEarlyCount;
};


}       // namespace BPrivate


#endif  // _SOUND_PLAY_NODE_H