repository_infos: Enable automatic updates on the main Haiku repostiory.

[haiku.git] / src / apps / cortex / addons / Flanger / FlangerNode.h

/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions, and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// FlangerNode.h
// * PURPOSE
// - implements a basic audio filter
// - eventually abstract -> 'SimpleAudioFilter'?
//
//
// * HISTORY
//   e.moon             15jun99         Begun

#ifndef __FlangerNode_H__
#define __FlangerNode_H__

#include <BufferProducer.h>
#include <BufferConsumer.h>
#include <Controllable.h>
#include <MediaEventLooper.h>

// forwards
class BBufferGroup;
class BMediaAddOn;

class AudioBuffer;

class FlangerNode :
        public          BBufferConsumer,
        public          BBufferProducer,
        public          BControllable,
        public          BMediaEventLooper {
        
public:                                 // *** ctor/dtor
        virtual ~FlangerNode();
        FlangerNode(BMediaAddOn* pAddOn=0);
        
public:                                 // *** BMediaNode

        virtual status_t HandleMessage(
                int32 code,
                const void* pData,
                size_t size);

        virtual BMediaAddOn* AddOn(
                int32* poID) const;

        virtual void SetRunMode(
                run_mode mode);
        
protected:                              // *** BMediaEventLooper

        virtual void HandleEvent(
                const media_timed_event* pEvent,
                bigtime_t howLate,
                bool realTimeEvent=false);

protected:
        // "The Media Server calls this hook function after the node has
        //  been registered.  This is derived from BMediaNode; BMediaEventLooper
        //  implements it to call Run() automatically when the node is registered;
        //  if you implement NodeRegistered() you should call through to
        //  BMediaEventLooper::NodeRegistered() after you've done your custom 
        //  operations."

        virtual void NodeRegistered();
        
        // "Augment OfflineTime() to compute the node's current time; it's called
        //  by the Media Kit when it's in offline mode. Update any appropriate
        //  internal information as well, then call through to the BMediaEventLooper
        //  implementation."

        virtual bigtime_t OfflineTime(); //nyi

public:                                 // *** BBufferConsumer

        virtual status_t AcceptFormat(
                const media_destination& destination,
                media_format* pioFormat);
        
        // "If you're writing a node, and receive a buffer with the B_SMALL_BUFFER
        //  flag set, you must recycle the buffer before returning."    

        virtual void BufferReceived(
                BBuffer* pBuffer);
        
        // * make sure to fill in poInput->format with the contents of
        //   pFormat; as of R4.5 the Media Kit passes poInput->format to
        //   the producer in BBufferProducer::Connect().

        virtual status_t Connected(
                const media_source& source,
                const media_destination& destination,
                const media_format& format,
                media_input* poInput);

        virtual void Disconnected(
                const media_source& source,
                const media_destination& destination);
                
        virtual void DisposeInputCookie(
                int32 cookie);
        
        // "You should implement this function so your node will know that the data
        //  format is going to change. Note that this may be called in response to
        //  your AcceptFormat() call, if your AcceptFormat() call alters any wildcard
        //  fields in the specified format. 
        //
        //  Because FormatChanged() is called by the producer, you don't need to (and
        //  shouldn't) ask it if the new format is acceptable. 
        //
        //  If the format change isn't possible, return an appropriate error from
        //  FormatChanged(); this error will be passed back to the producer that
        //  initiated the new format negotiation in the first place."

        virtual status_t FormatChanged(
                const media_source& source,
                const media_destination& destination,
                int32 changeTag,
                const media_format& newFormat);
                
        virtual status_t GetLatencyFor(
                const media_destination& destination,
                bigtime_t* poLatency,
                media_node_id* poTimeSource);
                
        virtual status_t GetNextInput(
                int32* pioCookie,
                media_input* poInput);

        virtual void ProducerDataStatus(
                const media_destination& destination,
                int32 status,
                bigtime_t tpWhen);
        
        // "This function is provided to aid in supporting media formats in which the
        //  outer encapsulation layer doesn't supply timing information. Producers will
        //  tag the buffers they generate with seek tags; these tags can be used to
        //  locate key frames in the media data."

        virtual status_t SeekTagRequested(
                const media_destination& destination,
                bigtime_t targetTime,
                uint32 flags,
                media_seek_tag* poSeekTag,
                bigtime_t* poTaggedTime,
                uint32* poFlags);
        
public:                                 // *** BBufferProducer

        // "When a consumer calls BBufferConsumer::RequestAdditionalBuffer(), this
        //  function is called as a result. Its job is to call SendBuffer() to
        //  immediately send the next buffer to the consumer. The previousBufferID,
        //  previousTime, and previousTag arguments identify the last buffer the
        //  consumer received. Your node should respond by sending the next buffer
        //  after the one described. 
        //
        //  The previousTag may be NULL.
        //  Return B_OK if all is well; otherwise return an appropriate error code."
        virtual void AdditionalBufferRequested(
                const media_source& source,
                media_buffer_id previousBufferID,
                bigtime_t previousTime,
                const media_seek_tag* pPreviousTag); //nyi
                
        virtual void Connect(
                status_t status,
                const media_source& source,
                const media_destination& destination,
                const media_format& format,
                char* pioName); //nyi
                
        virtual void Disconnect(
                const media_source& source,
                const media_destination& destination); //nyi
                
        virtual status_t DisposeOutputCookie(
                int32 cookie); //nyi
                
        virtual void EnableOutput(
                const media_source& source,
                bool enabled,
                int32* _deprecated_); //nyi
                
        virtual status_t FormatChangeRequested(
                const media_source& source,
                const media_destination& destination,
                media_format* pioFormat,
                int32* _deprecated_); //nyi
                
        virtual status_t FormatProposal(
                const media_source& source,
                media_format* pioFormat); //nyi
                
        virtual status_t FormatSuggestionRequested(
                media_type type,
                int32 quality,
                media_format* poFormat); //nyi
                
        virtual status_t GetLatency(
                bigtime_t* poLatency); //nyi
                
        virtual status_t GetNextOutput(
                int32* pioCookie,
                media_output* poOutput); //nyi
        
        // "This hook function is called when a BBufferConsumer that's receiving data
        //  from you determines that its latency has changed. It will call its
        //  BBufferConsumer::SendLatencyChange() function, and in response, the Media
        //  Server will call your LatencyChanged() function.  The source argument
        //  indicates your output that's involved in the connection, and destination
        //  specifies the input on the consumer to which the connection is linked.
        //  newLatency is the consumer's new latency. The flags are currently unused."
        virtual void LatencyChanged(
                const media_source& source,
                const media_destination& destination,
                bigtime_t newLatency,
                uint32 flags); //nyi

        virtual void LateNoticeReceived(
                const media_source& source,
                bigtime_t howLate,
                bigtime_t tpWhen); //nyi
        
        // PrepareToConnect() is the second stage of format negotiations that happens
        // inside BMediaRoster::Connect().  At this point, the consumer's AcceptFormat()
        // method has been called, and that node has potentially changed the proposed
        // format.  It may also have left wildcards in the format.  PrepareToConnect()
        // *must* fully specialize the format before returning!

        virtual status_t PrepareToConnect(
                const media_source& source,
                const media_destination& destination,
                media_format* pioFormat,
                media_source* poSource,
                char* poName); //nyi
                
        virtual status_t SetBufferGroup(
                const media_source& source,
                BBufferGroup* pGroup); //nyi
        
        virtual status_t SetPlayRate(
                int32 numerator,
                int32 denominator); //nyi
        
        virtual status_t VideoClippingChanged(
                const media_source& source,
                int16 numShorts,
                int16* pClipData,
                const media_video_display_info& display,
                int32* poFromChangeTag); //nyi

public:                                 // *** BControllable

        virtual status_t GetParameterValue(
                int32 id,
                bigtime_t* poLastChangeTime,
                void* poValue,
                size_t* pioSize); //nyi
                
        virtual void SetParameterValue(
                int32 id,
                bigtime_t changeTime,
                const void* pValue,
                size_t size); //nyi

        
protected:                              // HandleEvent() impl.
        void handleParameterEvent(
                const media_timed_event* pEvent);
                
        void handleStartEvent(
                const media_timed_event* pEvent);
                
        void handleStopEvent(
                const media_timed_event* pEvent);
                
        void ignoreEvent(
                const media_timed_event* pEvent);

protected:                              // *** internal operations

        // figure the preferred format: any fields left as wildcards
        // are negotiable
        virtual void getPreferredFormat(
                media_format& ioFormat);
                
        // test the given template format against a proposed format.
        // specialize wildcards for fields where the template contains
        // non-wildcard data; write required fields into proposed format
        // if they mismatch.
        // Returns B_OK if the proposed format doesn't conflict with the
        // template, or B_MEDIA_BAD_FORMAT otherwise.

        status_t validateProposedFormat(
                const media_format& preferredFormat,
                media_format& ioProposedFormat);
                
        // fill in wildcards in the given format.
        // (assumes the format passes validateProposedFormat().)
        void specializeOutputFormat(
                media_format& ioFormat);
                
        // set parameters to their default settings
        virtual void initParameterValues();
        
        // create and register a parameter web
        virtual void initParameterWeb();
        
        // construct delay line if necessary, reset filter state
        virtual void initFilter();
        
        virtual void startFilter();
        virtual void stopFilter();

        // figure processing latency by doing 'dry runs' of filterBuffer()
        virtual bigtime_t calcProcessingLatency();
        
        // filter buffer data in place  
        virtual void filterBuffer(
                BBuffer* pBuffer); //nyi
                
private:                                        // *** connection/format members

        // The 'template' format
        // +++++ init in NodeRegistered()
        media_format                    m_preferredFormat;

        // The current input/output format (this filter doesn't do any
        // on-the-fly conversion.)  Any fields that are not wildcards
        // are mandatory; the first connection (input or output) decides
        // the node's format.  If both input and output are disconnected,
        // m_format.u.raw_audio should revert to media_raw_audio_format::wildcard.      
        media_format                    m_format;
        
        // Connections & associated state variables     
        media_input                             m_input;

        media_output                    m_output;
        bool                                                            m_outputEnabled;

// [16jun99] buffers are generated by the upstream producer; this
//           node processes them in-place and forwards them downstream.
//      
//      // The outbound buffer group    
//      BBufferGroup*                   m_pBufferGroup;

        // Time required by downstream consumer(s) to properly deliver a buffer
        bigtime_t                                       m_downstreamLatency;

        // Worst-case time needed to fill a buffer
        bigtime_t                                       m_processingLatency;

private:                                        // *** filter state

        // Frames sent since the filter started
        uint64                                          m_framesSent;
        
        // the buffer
        AudioBuffer*                    m_pDelayBuffer;
        
        // write position (buffer offset at which the next
        // incoming frame will be stored)
        uint32                                          m_delayWriteFrame;

        // radial counter (for sweep 'LFO')
        float                                                   m_fTheta;
        float                                                   m_fThetaInc;
        
        // sweep LFO state
        float                                                   m_fSweepBase;
        float                                                   m_fSweepFactor;

//      // position (relative to m_delayWriteFrame) from which
//      // delayed frames are read.  varies between -m_fSweepMax and
//      // -m_fSweepMin.
//      float                                                   m_fDelayReadOffset;
//      
//      // rate at which m_fDelayReadOffset currently varies.
//      // [16jun99: a triangle-shaped sweep for now]
//      float                                                   m_fDelayReadDelta;
        
        // maximum delay (buffer length) in milliseconds
        static const float                      s_fMaxDelay;
        
private:                                        // *** filter parameter data

        // ratio of dry-to-processed signal
        float                                                   m_fMixRatio;
        bigtime_t                                       m_tpMixRatioChanged;
        
        // rate of sweep (Hz)
        float                                                   m_fSweepRate;
        bigtime_t                                       m_tpSweepRateChanged;
        
        // minimum delay (low bound of sweep) (ms)
        float                                                   m_fDelay;
        bigtime_t                                       m_tpDelayChanged;

        // range of sweep (ms)
        float                                                   m_fDepth;
        bigtime_t                                       m_tpDepthChanged;
        
        // feedback (0.0 - 1.0)
        float                                                   m_fFeedback;
        bigtime_t                                       m_tpFeedbackChanged;    

private:                                        // *** add-on stuff

        // host add-on
        BMediaAddOn*    m_pAddOn;
        
        static const char* const                s_nodeName;
};

#endif /*__FlangerNode_H__*/