/*
        ToneProducer.h

        Copyright 1999, Be Incorporated.   All Rights Reserved.
        This file may be used under the terms of the Be Sample Code License.

        NOTES eamoon@meadgroup.com 11june99
        - this node has some holes in it, but it's pretty useful starting
          point for writing producers.
        - I've tried to clean up the format negotiation a bit, which didn't
          fare too well when faced with an apathetic downstream node
          (LoggingConsumer.)

        KNOWN BUGS
          eamoon 17jun99
          * Can't handle 2 channels, but is too polite to refuse.
            How embarrassing.

*/

#ifndef ToneProducer_H
#define ToneProducer_H 1

#include <media/BufferProducer.h>
#include <media/MediaEventLooper.h>
#include <media/Controllable.h>

class BMediaAddOn;

// ----------------
// ToneProducer - a node to generate precisely defined digital tones
class ToneProducer : public BBufferProducer,  public BControllable, public BMediaEventLooper
{
public:
        enum event_t {
                // e.moon 2jun99
                _PARAMETER_EVENT                = BTimedEventQueue::B_USER_EVENT
        };

public:
        // add-on-friendly ctor
        // e.moon [8jun99]
        ToneProducer(BMediaAddOn* pAddOn=0);
        ~ToneProducer();

// BMediaNode methods
        BMediaAddOn* AddOn(     int32* internal_id) const;

// BControllable methods
        status_t GetParameterValue(
                int32 id,
                bigtime_t* last_change,
                void* value,
                size_t* ioSize);

        void SetParameterValue(
                int32 id,
                bigtime_t when,
                const void* value,
                size_t size);

        status_t StartControlPanel(
                BMessenger* pMessenger);

// BBufferProducer methods
        status_t FormatSuggestionRequested(
                media_type type,
                int32 quality,
                media_format* format);

        status_t FormatProposal(
                const media_source& output,
                media_format* format);

        /* If the format isn't good, put a good format into *io_format and return error */
        /* If format has wildcard, specialize to what you can do (and change). */
        /* If you can change the format, return OK. */
        /* The request comes from your destination sychronously, so you cannot ask it */
        /* whether it likes it -- you should assume it will since it asked. */
        status_t FormatChangeRequested(
                const media_source& source,
                const media_destination& destination,
                media_format* io_format,
                int32* _deprecated_);

        status_t GetNextOutput( /* cookie starts as 0 */
                int32* cookie,
                media_output* out_output);

        status_t DisposeOutputCookie(
                int32 cookie);

        /* In this function, you should either pass on the group to your upstream guy, */
        /* or delete your current group and hang on to this group. Deleting the previous */
        /* group (unless you passed it on with the reclaim flag set to false) is very */
        /* important, else you will 1) leak memory and 2) block someone who may want */
        /* to reclaim the buffers living in that group. */
        status_t SetBufferGroup(
                const media_source& for_source,
                BBufferGroup* group);

        /* Iterates over all outputs and maxes the latency found */
        status_t GetLatency(
                bigtime_t* out_latency);

        status_t PrepareToConnect(
                const media_source& what,
                const media_destination& where,
                media_format* format,
                media_source* out_source,
                char* out_name);

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

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

        void LateNoticeReceived(
                const media_source& what,
                bigtime_t how_much,
                bigtime_t performance_time);

        void EnableOutput(
                const media_source & what,
                bool enabled,
                int32* _deprecated_);

        status_t SetPlayRate(
                int32 numer,
                int32 denom);

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

        void AdditionalBufferRequested(
                const media_source& source,
                media_buffer_id prev_buffer,
                bigtime_t prev_time,
                const media_seek_tag* prev_tag);        //      may be NULL

        void LatencyChanged(
                const media_source& source,
                const media_destination& destination,
                bigtime_t new_latency,
                uint32 flags);

// BMediaEventLooper methods
        void NodeRegistered();

        void Start(bigtime_t performance_time);

        // Workaround for a Metrowerks PPC compiler bug
        void Stop(bigtime_t performance_time, bool immediate);

        void SetRunMode(run_mode mode);

        void HandleEvent(
                const media_timed_event* event,
                bigtime_t lateness,
                bool realTimeEvent = false);

private:
        void AllocateBuffers();
        BBuffer* FillNextBuffer(bigtime_t event_time);

        // 20sep99 e.moon: stereo support
        void FillSineBuffer(float* data, size_t numFrames, bool stereo);
        void FillTriangleBuffer(float* data, size_t numFrames, bool stereo);
        void FillSawtoothBuffer(float* data, size_t numFrames, bool stereo);

        BParameterWeb* mWeb;
        BBufferGroup* mBufferGroup;
        bigtime_t mLatency, mInternalLatency;
        media_output mOutput;
        bool mOutputEnabled;
        media_format mPreferredFormat;

        // These next attributes are related to tone buffer generation
        double mTheta;                  // generic parameter used by all generators
        bool mWaveAscending;            // used by the triangle-wave generator
        float mFrequency;               // can be anything, in Hertz
        float mGain;                            // should be in the range [0,1]
        int32 mWaveform;
        uint64 mFramesSent;
        bigtime_t mStartTime;

        // more parameter handling
        bigtime_t mGainLastChanged;
        bigtime_t mFreqLastChanged;
        bigtime_t mWaveLastChanged;

        // host addon
        // [8jun99] e.moon
        BMediaAddOn*            m_pAddOn;
};

#endif