/*!

    @struct     AudioUnitEvent

    @abstract   Describes a change to an Audio Unit's state.

    @field      mEventType

        The type of event.

    @field      mArgument

        Specifies the parameter or property which has changed.

*/

typedef struct AudioUnitEvent {

    AudioUnitEventType                  mEventType;

    union {

        AudioUnitParameter  mParameter; // for parameter value change, begin and end gesture

        AudioUnitProperty   mProperty; // for kAudioUnitEvent_PropertyChange

    }                                   mArgument;

} AudioUnitEvent;

/*!

    @enum       AudioUnitEventType

    @abstract   Types of Audio Unit Events.

    @constant   kAudioUnitEvent_ParameterValueChange

                    The event is a change to a parameter value

    @constant   kAudioUnitEvent_BeginParameterChangeGesture

                    The event signifies a gesture (e.g. mouse-down) beginning a potential series of

                    related parameter value change events.

    @constant   kAudioUnitEvent_EndParameterChangeGesture

                    The event signifies a gesture (e.g. mouse-up) ending a series of related

                    parameter value change events.

    @constant   kAudioUnitEvent_PropertyChange

                    The event is a change to a property value.

*/

enum {  // typedef UInt32 AudioUnitEventType

    kAudioUnitEvent_ParameterValueChange        = 0,

    kAudioUnitEvent_BeginParameterChangeGesture = 1,

    kAudioUnitEvent_EndParameterChangeGesture   = 2,

    kAudioUnitEvent_PropertyChange              = 3

};

typedef UInt32 AudioUnitEventType;

/*!

    @typedef    AUParameterListenerProc

    @abstract   A function called when an Audio Unit event occurs.

    @param  inCallbackRefCon

                The value passed to AUListenerCreate when the callback function was installed.

    @param  inObject

                The object which generated the parameter change.

    @param  inEvent

                The event which occurred.

    @param  inEventHostTime

                The host time at which the event occurred.

    @param  inParameterValue

                If the event is parameter change, the parameter's new value (otherwise, undefined).

*/

typedef void (*AUEventListenerProc)(void *                  inCallbackRefCon,

                                    void *                  inObject,

                                    const AudioUnitEvent *  inEvent,

                                    UInt64                  inEventHostTime,

                                    AudioUnitParameterValue inParameterValue);

/*!

    @functiongroup  AUEventListener

*/

/*!

    @function   AUEventListenerCreate

    @abstract   Creates an Audio Unit event listener.

    @param      inProc

                    Function called when an event occurs.

    @param      inCallbackRefCon

                    A reference value for the use of the callback function.

    @param      inRunLoop

                    The run loop on which the callback is called. If NULL,

                    CFRunLoopGetCurrent() is used.

    @param      inRunLoopMode

                    The run loop mode in which the callback's underlying run loop source will be

                    attached. If NULL, kCFRunLoopDefaultMode is used.

    @param      inNotificationInterval

                    The minimum time interval, in seconds, at which the callback will be called.

    @param      inValueChangeGranularity

                    Determines how parameter value changes occuring within this interval are

                    queued; when an event follows a previous one by a smaller time interval than

                    the granularity, then the listener will only be notified for the second

                    parameter change.

    @param      outListener

                    On succcessful return, an AUEventListenerRef.

    @discussion

        AUEventListener is a specialization of AUParameterListener; use AUListenerDispose to

        dispose of an AUEventListener. You may use AUListenerAddParameter and

        AUListenerRemoveParameter with AUEventListerRef's, in addition to

        AUEventListenerAddEventType / AUEventListenerRemoveEventType.

        Some examples illustrating inNotificationInterval and inValueChangeGranularity:

        [1] a UI receiver: inNotificationInterval = 100 ms, inValueChangeGranularity = 100 ms.

            User interfaces almost never care about previous values, only the current one,

            and don't wish to perform redraws too often.

        [2] An automation recorder: inNotificationInterval = 200 ms, inValueChangeGranularity = 10 ms.

            Automation systems typically wish to record events with a high degree of timing precision,

            but do not need to be woken up for each event.

        In case [1], the listener will be called within 100 ms (the notification interval) of an

        event. It will only receive one notification for any number of value changes to the

        parameter concerned, occurring within a 100 ms window (the granularity).

        In case [2], the listener will be received within 200 ms (the notification interval) of

        an event It can receive more than one notification per parameter, for the last of each

        group of value changes occurring within a 10 ms window (the granularity).

        In both cases, thread scheduling latencies may result in more events being delivered to

        the listener callback than the theoretical maximum (notification interval /

        granularity).

*/

extern OSStatus

AUEventListenerCreate(AUEventListenerProc   inProc,

                      void *                inCallbackRefCon,

                      CFRunLoopRef          inRunLoop,

                      CFStringRef           inRunLoopMode,

                      Float32               inNotificationInterval,     // seconds

                      Float32               inValueChangeGranularity,   // seconds

                      AUEventListenerRef *  outListener)

// The inObject parameter should specify an object interested in the event type.

// This object is passed as the inObject parameter to the listener callback function.

OSStatus createListener(void *inObject)

{

    AudioUnitEvent      myPropertyEvent;

    AudioUnitProperty   myProperty;

    AUEventListenerRef  MyListener;

    OSStatus result = noErr;

    //this may be a run loop of your choosing

    CFRunLoopRef runLoop = (CFRunLoopRef)GetCFRunLoopFromEventLoop(GetCurrentEventLoop());

    CFStringRef loopMode = kCFRunLoopDefaultMode;

    myPropertyEvent.mEventType = kAudioUnitEvent_PropertyChange;

    myProperty.mAudioUnit = mAudioUnit;

    myProperty.mPropertyID = kAudioUnitCustomProperty_FilterFrequencyResponse;

    myProperty.mScope = kAudioUnitScope_Global;

    myProperty.mElement = 0;

    myPropertyEvent.mArgument.mProperty = myProperty;

    result = AUEventListenerCreate(MyPropertyListener,

                                   NULL,

                                   runLoop,

                                   loopMode,

                                   0.05,

                                   0.05,

                                   &MyListener);

    if (noErr == result) {

        result = AUEventListenerAddEventType(MyListener, inObject, &myPropertyEvent);

    }

    return result;

}

AudioUnitEvent myEvent;

myEvent.mEventType = kAudioUnitEvent_ParameterValueChange;

myEvent.mArgument.mParameter.mAudioUnit = mAudioUnit;

myEvent.mArgument.mParameter.mParameterID = kFilterParam_CutoffFrequency;

myEvent.mArgument.mParameter.mScope = kAudioUnitScope_Global;

myEvent.mArgument.mParameter.mElement = 0;

AUEventListenerNotify(NULL, NULL, &myEvent);

AudioUnitEvent myEvent;

myEvent.mEventType = kAudioUnitEvent_PropertyChange;

myEvent.mArgument.mProperty.mAudioUnit = mAudioUnit;

myEvent.mArgument.mProperty.mPropertyID = kAudioUnitCustomProperty_FilterFrequencyResponse;

myEvent.mArgument.mProperty.mScope = kAudioUnitScope_Global;

myEvent.mArgument.mProperty.mElement = 0;

AUEventListenerNotify(NULL, NULL, &myEvent);

void CreateAudioUnitEventForParameterID(AudioUnitEvent *myEvent, AudioUnitParameterID inParameterID)

{

    myEvent->mArgument.mParameter.mAudioUnit = mAudioUnit;

    myEvent->mArgument.mParameter.mParameterID = inParameterID;

    myEvent->mArgument.mParameter.mScope = kAudioUnitScope_Global;

    myEvent->mArgument.mParameter.mElement = 0;

}

void HandleMouseDown(AudioUnitEvent *myEvent)

{

    myEvent->mEventType = kAudioUnitEvent_BeginParameterChangeGesture;

    AUEventListenerNotify(NULL, NULL, myEvent);

}

void HandleParameterChange(AudioUnitEvent *myEvent)

{

    myEvent->mEventType =kAudioUnitEvent_ParameterValueChange;

    AUEventListenerNotify(NULL, NULL, myEvent);

}

void HandleMouseUp(AudioUnitEvent *myEvent)

{

    myEvent->mEventType = kAudioUnitEvent_EndParameterChangeGesture;

    AUEventListenerNotify(NULL, NULL, myEvent);

}

- (void)setAU:(AudioUnit)inAU {

    // remove previous listeners

    if (mAU)

        [self priv_removeListeners];

    if (!mData) // only allocate the data once

        mData = malloc(kNumberOfResponseFrequencies * sizeof(FrequencyResponse));

    mData = [graphView prepareDataForDrawing: mData]; // fill out the initial

                                                      //frequency values for the data displayed by the graph

    // register for resize notification and data changes for the graph view

    [[NSNotificationCenter defaultCenter] addObserver: self

                                             selector: @selector(handleGraphDataChanged:)

                                                 name: kGraphViewDataChangedNotification

                                               object: graphView];

    [[NSNotificationCenter defaultCenter] addObserver: self

                                             selector: @selector(handleGraphSizeChanged:)

                                                 name: NSViewFrameDidChangeNotification

                                               object: graphView];

    [[NSNotificationCenter defaultCenter] addObserver: self

                                             selector: @selector(beginGesture:)

                                                 name: kGraphViewBeginGestureNotification

                                               object: graphView];

    [[NSNotificationCenter defaultCenter] addObserver: self

                                             selector: @selector(endGesture:)

                                                 name: kGraphViewEndGestureNotification

                                               object: graphView];

    mAU = inAU;

    // add new listeners

    [self priv_addListeners];

    // initial setup

    [self priv_synchronizeUIWithParameterValues];

}

void addParamListener (AUEventListenerRef listener, void* refCon, AudioUnitEvent *inEvent)

{

    inEvent->mEventType = kAudioUnitEvent_BeginParameterChangeGesture;

    verify_noerr (AUEventListenerAddEventType(listener, refCon, inEvent));

    inEvent->mEventType = kAudioUnitEvent_EndParameterChangeGesture;

    verify_noerr (AUEventListenerAddEventType(listener, refCon, inEvent));

    inEvent->mEventType = kAudioUnitEvent_ParameterValueChange;

    verify_noerr (AUEventListenerAddEventType(listener, refCon, inEvent));

}

- (void)priv_addListeners

{

    if (mAU) {

        verify_noerr(AUEventListenerCreate(EventListenerDispatcher, self,

                                           CFRunLoopGetCurrent(), kCFRunLoopDefaultMode, 0.05, 0.05,

                                           &mAUEventListener));

        AudioUnitEvent auEvent;

        AudioUnitParameter parameter = {mAU, kFilterParam_CutoffFrequency, kAudioUnitScope_Global, 0 };

        auEvent.mArgument.mParameter = parameter;

        addParamListener (mAUEventListener, self, &auEvent);

        auEvent.mArgument.mParameter.mParameterID = kFilterParam_Resonance;

        addParamListener (mAUEventListener, self, &auEvent);

        /* Add a listener for the changes in our custom property */

        /* The Audio unit will send a property change when the unit is initialized */

        auEvent.mEventType = kAudioUnitEvent_PropertyChange;

        auEvent.mArgument.mProperty.mAudioUnit = mAU;

        auEvent.mArgument.mProperty.mPropertyID = kAudioUnitCustomProperty_FilterFrequencyResponse;

        auEvent.mArgument.mProperty.mScope = kAudioUnitScope_Global;

        auEvent.mArgument.mProperty.mElement = 0;

        verify_noerr (AUEventListenerAddEventType (mAUEventListener, self, &auEvent));

    }

}

void EventListenerDispatcher (void *inRefCon, void *inObject, const AudioUnitEvent *inEvent,

                              UInt64 inHostTime, Float32 inValue)

{

    AppleDemoFilter_UIView *SELF = (AppleDemoFilter_UIView *)inRefCon;

    [SELF priv_eventListener:inObject event: inEvent value: inValue];

}

- (void)priv_eventListener:(void *) inObject event:(const AudioUnitEvent *)inEvent value:(Float32)inValue {

    switch (inEvent->mEventType) {

        case kAudioUnitEvent_ParameterValueChange: // Parameter Changes

            switch (inEvent->mArgument.mParameter.mParameterID) {

                case kFilterParam_CutoffFrequency: // handle cutoff frequency parameter

                    [cutoffFrequencyField setFloatValue: inValue]; // update the frequency text field

                    [graphView setFreq: inValue]; // update the graph's frequency visual state

                    break;

                case kFilterParam_Resonance: // handle resonance parameter

                    [resonanceField setFloatValue: inValue]; // update the resonance text field

                    [graphView setRes: inValue]; // update the graph's gain visual state

                    break;

            }

            // get the curve data from the audio unit

            [self updateCurve];

            break;

        case kAudioUnitEvent_BeginParameterChangeGesture: // Begin gesture

            [graphView handleBeginGesture]; // notify graph view to update visual state

            break;

        case kAudioUnitEvent_EndParameterChangeGesture: // End gesture

            [graphView handleEndGesture]; // notify graph view to update visual state

            break;

        case kAudioUnitEvent_PropertyChange: // custom property changed

            if (inEvent->mArgument.mProperty.mPropertyID == kAudioUnitCustomProperty_FilterFrequencyResponse)

                [self updateCurve];

            break;

    }

}

- (IBAction) cutoffFrequencyChanged:(id)sender {

    float floatValue = [sender floatValue];

    AudioUnitParameter cutoffParameter = {mAU, kFilterParam_CutoffFrequency, kAudioUnitScope_Global, 0 };

    NSAssert(AUParameterSet(mAUEventListener, sender, &cutoffParameter, (Float32)floatValue, 0) == noErr,

             @"[AppleDemoFilter_UIView cutoffFrequencyChanged:] AUParameterSet()");

}

- (void) beginGesture:(NSNotification *) aNotification {

    AudioUnitEvent event;

    AudioUnitParameter parameter = {mAU, kFilterParam_CutoffFrequency, kAudioUnitScope_Global, 0 };

    event.mArgument.mParameter = parameter;

    event.mEventType = kAudioUnitEvent_BeginParameterChangeGesture;

    AUEventListenerNotify (mAUEventListener, self, &event);

    event.mArgument.mParameter.mParameterID = kFilterParam_Resonance;

    AUEventListenerNotify (mAUEventListener, self, &event);

}

- (void) handleGraphDataChanged:(NSNotification *) aNotification {

    float resonance = [graphView getRes];

    float cutoff    = [graphView getFreq];

    AudioUnitParameter cutoffParameter    = {mAU, kFilterParam_CutoffFrequency, kAudioUnitScope_Global, 0 };

    AudioUnitParameter resonanceParameter = {mAU, kFilterParam_Resonance, kAudioUnitScope_Global, 0 };

    NSAssert(AUParameterSet(mAUEventListener, cutoffFrequencyField, &cutoffParameter, (Float32)cutoff, 0) ==

             noErr, @"[AppleDemoFilter_UIView cutoffFrequencyChanged:] AUParameterSet()");

    NSAssert(AUParameterSet(mAUEventListener, resonanceField, &resonanceParameter, (Float32)resonance, 0) ==

             noErr,  @"[AppleDemoFilter_UIView resonanceChanged:] AUParameterSet()");

}

- (void) endGesture:(NSNotification *) aNotification {

    AudioUnitEvent event;

    AudioUnitParameter parameter = {mAU, kFilterParam_CutoffFrequency, kAudioUnitScope_Global, 0 };

    event.mArgument.mParameter = parameter;

    event.mEventType = kAudioUnitEvent_EndParameterChangeGesture;

    AUEventListenerNotify (mAUEventListener, self, &event);

    event.mArgument.mParameter.mParameterID = kFilterParam_Resonance;

    AUEventListenerNotify (mAUEventListener, self, &event);

}

- (void)priv_removeListeners

{

    if (mAUEventListener) verify_noerr (AUListenerDispose(mAUEventListener));

    mAUEventListener = NULL;

    mAU = NULL;

}