/*
     File: CAAUMIDIMap.h
 Abstract: Part of CoreAudio Utility Classes
  Version: 1.1
 
 Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple
 Inc. ("Apple") in consideration of your agreement to the following
 terms, and your use, installation, modification or redistribution of
 this Apple software constitutes acceptance of these terms.  If you do
 not agree with these terms, please do not use, install, modify or
 redistribute this Apple software.
 
 In consideration of your agreement to abide by the following terms, and
 subject to these terms, Apple grants you a personal, non-exclusive
 license, under Apple's copyrights in this original Apple software (the
 "Apple Software"), to use, reproduce, modify and redistribute the Apple
 Software, with or without modifications, in source and/or binary forms;
 provided that if you redistribute the Apple Software in its entirety and
 without modifications, you must retain this notice and the following
 text and disclaimers in all such redistributions of the Apple Software.
 Neither the name, trademarks, service marks or logos of Apple Inc. may
 be used to endorse or promote products derived from the Apple Software
 without specific prior written permission from Apple.  Except as
 expressly stated in this notice, no other rights or licenses, express or
 implied, are granted by Apple herein, including but not limited to any
 patent rights that may be infringed by your derivative works or by other
 works in which the Apple Software may be incorporated.
 
 The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
 MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
 THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
 FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
 OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
 
 IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
 OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
 MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
 AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
 STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 
 Copyright (C) 2014 Apple Inc. All Rights Reserved.
 
*/
#ifndef __CAAUMIDIMap_h_
#define __CAAUMIDIMap_h_

#include <AudioUnit/AudioUnitProperties.h>
#include <algorithm>

/*
enum {
	kAUParameterMIDIMapping_AnyChannelFlag		= (1L << 0),
		// If this flag is set and mStatus is a MIDI channel message, then the MIDI channel number 
		// in the status byte is ignored; the mapping is from the specified MIDI message on ANY channel.

	kAUParameterMIDIMapping_AnyNoteFlag			= (1L << 1),
		// If this flag is set and mStatus is a Note On, Note Off, or Polyphonic Pressure message,
		// the message's note number is ignored; the mapping is from ANY note number.

	kAUParameterMIDIMapping_SubRange			= (1L << 2),
		// set this flag if the midi control should map only to a sub-range of the parameter's value
		// then specify that range in the mSubRangeMin and mSubRangeMax members

	kAUParameterMIDIMapping_Toggle				= (1L << 3),
		// this is only useful for boolean typed parameters. When set, it means that the parameter's
		// value should be toggled (if true, become false and vice versa) when the represented MIDI message
		// is received
	
	kAUParameterMIDIMapping_Bipolar				= (1L << 4),
		// this can be set to when mapping a MIDI Controller to indicate that the parameter (typically a boolean
		// style parameter) will only have its value changed to either the on or off state of a MIDI controller message
		// (0 < 64 is off, 64 < 127 is on) such as the sustain pedal. The seeting of the next flag
		// (kAUParameterMIDIMapping_Bipolar_On) determine whether the parameter is mapped to the on or off
		// state of the controller
	kAUParameterMIDIMapping_Bipolar_On			= (1L << 5)
		// only a valid flag if kAUParameterMIDIMapping_Bipolar is set
};

// The reserved fields here are being used to reserve space (as well as align to 64 bit size) for future use
// When/If these fields are used, the names of the fields will be changed to reflect their functionality
// so, apps should NOT refer to these reserved fields directly by name
typedef struct AUParameterMIDIMapping
{
	AudioUnitScope			mScope;
	AudioUnitElement		mElement;
	AudioUnitParameterID	mParameterID;
	UInt32					mFlags;
	Float32					mSubRangeMin;
	Float32					mSubRangeMax;
	UInt8					mStatus;
	UInt8					mData1;
	UInt8					reserved1; // MUST be set to zero
	UInt8					reserved2; // MUST be set to zero
	UInt32					reserved3; // MUST be set to zero
} AUParameterMIDIMapping;
*/

/*
Parameter To MIDI Mapping Properties
These properties are used to:
Describe a current set of mappings between MIDI messages and Parameter value setting
Create a mapping between a parameter and a MIDI message through either:
- explicitly adding (or removing) the mapping
- telling the AU to hot-map the next MIDI message to a specified Parameter
	The same MIDI Message can map to one or more parameters
	One Parameter can be mapped from multiple MIDI messages

	In general usage, these properties only apply to AU's that implement the MIDI API
	AU Instruments (type=='aumu') and Music Effects (type == 'aumf')

	These properties are used in the Global scope. The scope and element members of the structure describe
	the scope and element of the parameter. In all usages, mScope, mElement and mParameterID must be
	correctly specified.


	* The AUParameterMIDIMapping Structure

	Command				mStatus			mData1			
	Note Off			0x8n			Note Num		
	Note On				0x9n			Note Num		
	Key Pressure		0xAn			Note Num		
	Control Change		0xBn			ControllerID	
	Patch Change		0xCn			Patch Num		
	Channel Pressure	DxDn			0 (Unused)		
	Pitch Bend			0xEn			0 (Unused)		

	(where n is 0-0xF to correspond to MIDI channels 1-16)

		Details:

	In general MIDI Commands can be mapped to either a specific channel as specified in the mStatus bit.
	If the kAUParameterMIDIMapping_AnyChannelFlag bit is set mStatus is a MIDI channel message, then the 
	MIDI channel number in the status byte is ignored; the mapping is from the specified MIDI message on ANY channel.

	For note commands (note on, note off, key pressure), the MIDI message can trigger either with just a specific
	note number, or any note number if the kAUParameterMIDIMapping_AnyNoteFlag bit is set. In these instances, the
	note number is used as the trigger value (for instance, a note message could be used to set the 
											  cut off frequency of a filter).

 The Properties:								

	kAudioUnitProperty_AllParameterMIDIMappings							array of AUParameterMIDIMapping (read/write)
	This property is used to both retreive and set the current mapping state between (some/many/all of) its parameters
	and MIDI messages. When set, it should replace any previous mapped settings the AU had.

	If this property is implemented by a non-MIDI capable AU (such as an 'aufx' type), then the property is
	read only, and recommends a suggested set of mappings for the host to perform. In this case, it is the 
	host's responsibility to map MIDI message to the AU parameters. As described previously, there are a set
	of default mappings (see AudioToolbox/AUMIDIController.h) that the host can recommend to the user 
	in this circumstance.

	This property's size will be very dynamic, depending on the number of mappings currently in affect, so the 
	caller should always get the size of the property first before retrieving it. The AU should return an error
	if the caller doesn't provide enough space to return all of the current mappings.

	kAudioUnitProperty_AddParameterMIDIMapping							array of AUParameterMIDIMapping (write only)
	This property is used to Add mappings to the existing set of mappings the AU possesses. It does NOT replace
	any existing mappings.

	kAudioUnitProperty_RemoveParameterMIDIMapping						array of AUParameterMIDIMapping (write only)
	This property is used to remove the specified mappings from the AU. If a mapping is specified that does not
	currently exist in the AU, then it should just be ignored.

	kAudioUnitProperty_HotMapParameterMIDIMapping								AUParameterMIDIMapping (read/write)
	This property is used in two ways, determined by the value supplied by the caller.
	(1) If a mapping struct is provided, then that struct provides *all* of the information that the AU should
	use to map the parameter, *except* for the MIDI message. The AU should then listen for the next MIDI message
	and associate that MIDI message with the supplied AUParameter mapping. When this MIDI message is received and
	the mapping made, the AU should also issue a notification on this property 
	(kAudioUnitProperty_HotMapParameterMIDIMapping) to indicate to the host that the mapping has been made. The host
	can then retrieve the mapping that was made by getting the value of this property.

	To avoid possible confusion, it is recommended that once the host has retrieved this mapping (if it is 
	presenting a UI to describe the mappings for example), that it then clears the mapping state as described next.

	Thus, the only time this property will return a valid value is when the AU has made a mapping. If the AU's mapping
	state has been cleared (or it has not been asked to make a mapping), then the AU should return 
	kAudioUnitErr_InvalidPropertyValue if the host tries to read this value.

	(2) If the value passed in is NULL, then if the AU had a parameter that it was in the process of mapping, it
	should disregard that (stop listening to the MIDI messages to create a mapping) and discard the partially 
	mapped struct. If the value is NULL and the AU is not in the process of mapping, the AU can ignore the request.

	At all times, the _AllMappings property will completely describe the current known state of the AU's mappings
	of MIDI messages to parameters.
*/


/*
	When mapping, it is recommended that LSB controllers are in general not mapped (ie. the controller range of 32 < 64)
	as many host parsers will map 14 bit control values. If you know (or can present an option) that the host deals with
	7 bit controllers only, then these controller ID's can be mapped of course.
*/


struct MIDIValueTransformer {
	virtual double  tolinear(double) = 0;
	virtual double  fromlinear(double) = 0;
#if DEBUG
	// suppress warning
	virtual ~MIDIValueTransformer() { }
#endif
};

struct MIDILinearTransformer : public MIDIValueTransformer {
	virtual double  tolinear(double x) { return x; }
	virtual double  fromlinear(double x) { return x; }
};

struct MIDILogTransformer : public MIDIValueTransformer {
	virtual double  tolinear(double x) { return log(std::max(x, .00001)); }
	virtual double  fromlinear(double x) { return exp(x); }
};

struct MIDIExpTransformer : public MIDIValueTransformer {
	virtual double  tolinear(double x) { return exp(x); }
	virtual double  fromlinear(double x) { return log(std::max(x, .00001)); }
};

struct MIDISqrtTransformer : public MIDIValueTransformer {
	virtual double  tolinear(double x) { return x < 0. ? -(sqrt(-x)) : sqrt(x); }
	virtual double  fromlinear(double x) { return x < 0. ? -(x * x) : x * x; }
};

struct MIDISquareTransformer : public MIDIValueTransformer {
	virtual double  tolinear(double x) { return x < 0. ? -(x * x) : x * x; }
	virtual double  fromlinear(double x) { return x < 0. ? -(sqrt(-x)) : sqrt(x); }
};

struct MIDICubeRtTransformer : public MIDIValueTransformer {
	virtual double  tolinear(double x) { return x < 0. ? -(pow(-x, 1./3.)) : pow(x, 1./3.); }
	virtual double  fromlinear(double x) { return x * x * x; }
};

struct MIDICubeTransformer : public MIDIValueTransformer {
	virtual double  tolinear(double x) { return x * x * x; }
	virtual double  fromlinear(double x) { return x < 0. ? -(pow(-x, 1./3.)) : pow(x, 1./3.); }
};


class CAAUMIDIMap : public AUParameterMIDIMapping {
	
public:
// variables for more efficient parsing of MIDI to Param value	
	Float32						mMinValue;
	Float32						mMaxValue;
	MIDIValueTransformer		*mTransType;

// methods	
	static MIDIValueTransformer *GetTransformer (UInt32 inFlags);
	
								CAAUMIDIMap() { memset(this, 0, sizeof(CAAUMIDIMap)); }
								CAAUMIDIMap (const AUParameterMIDIMapping& inMap) 
								{
									memset(this, 0, sizeof(CAAUMIDIMap));
									memcpy (this, &inMap, sizeof(inMap));
								}
								CAAUMIDIMap (AudioUnitScope inScope, AudioUnitElement inElement, AudioUnitParameterID inParam) 
								{ 
									memset(this, 0, sizeof(CAAUMIDIMap)); 
									mScope = inScope;
									mElement = inElement;
									mParameterID = inParam;
								}


	bool						IsValid () const { return mStatus != 0; }

	// returns -1 if any channel bit is set
	SInt32						Channel () const { return IsAnyChannel() ? -1 : (mStatus & 0xF); }
	bool						IsAnyChannel () const { 
									return mFlags & kAUParameterMIDIMapping_AnyChannelFlag; 
								}
									// preserves the existing channel info in the status byte
									// preserves any previously set mFlags value
	void						SetAnyChannel (bool inFlag) 
								{ 
									if (inFlag) 
										mFlags |= kAUParameterMIDIMapping_AnyChannelFlag; 
									else
										mFlags &= ~kAUParameterMIDIMapping_AnyChannelFlag;
								}

	bool						IsAnyNote () const { 		
									return (mFlags & kAUParameterMIDIMapping_AnyNoteFlag) != 0;
								}
									// preserves the existing key num in the mData1 byte
									// preserves any previously set mFlags value
	void						SetAnyNote (bool inFlag)
								{ 
									if (inFlag) 
										mFlags |= kAUParameterMIDIMapping_AnyNoteFlag; 
									else
										mFlags &= ~kAUParameterMIDIMapping_AnyNoteFlag;
								}
									
	bool						IsToggle() const { return (mFlags & kAUParameterMIDIMapping_Toggle) != 0; }
	void						SetToggle (bool inFlag)
								{
									if (inFlag) 
										mFlags |= kAUParameterMIDIMapping_Toggle; 
									else
										mFlags &= ~kAUParameterMIDIMapping_Toggle;
								}
	
	bool						IsBipolar() const { return (mFlags & kAUParameterMIDIMapping_Bipolar) != 0; }
									// inUseOnValue is valid ONLY if inFlag is true
	void						SetBipolar (bool inFlag, bool inUseOnValue = false)
								{
									if (inFlag) {
										mFlags |= kAUParameterMIDIMapping_Bipolar;
										if (inUseOnValue)
											mFlags |= kAUParameterMIDIMapping_Bipolar_On;
										else
											mFlags &= ~kAUParameterMIDIMapping_Bipolar_On;
									} else {
										mFlags &= ~kAUParameterMIDIMapping_Bipolar;
										mFlags &= ~kAUParameterMIDIMapping_Bipolar_On;
									}
								}
	bool						IsBipolar_OnValue () const { return (mFlags & kAUParameterMIDIMapping_Bipolar_On) != 0; }

	bool						IsSubRange () const { return (mFlags & kAUParameterMIDIMapping_SubRange) != 0; }
	void						SetSubRange (Float32 inStartValue, Float32 inStopValue)
								{
									mFlags |= kAUParameterMIDIMapping_SubRange; 
									
									mSubRangeMin = inStartValue;
									mSubRangeMax = inStopValue;
								}
	
	void						SetParamRange(Float32 minValue, Float32 maxValue)
								{
									mMinValue = minValue;
									mMaxValue = maxValue;		
								}
									
								// this will retain the subrange values previously set.
	void						SetSubRange (bool inFlag) 
								{ 
									if (inFlag)
										mFlags |= kAUParameterMIDIMapping_SubRange; 
									else
										mFlags &= ~kAUParameterMIDIMapping_SubRange; 
								}
	
	bool						IsAnyValue() const{return !IsBipolar();}
	bool						IsOnValue() const{return IsBipolar_OnValue();}
	bool						IsOffValue() const{return IsBipolar();}
								
	bool						IsNoteOff () const { return ((mStatus & 0xF0) == 0x80); }
	bool						IsNoteOn () const { return ((mStatus & 0xF0) == 0x90); }
	
	bool						IsKeyPressure () const { return ((mStatus & 0xF0) == 0xA0); }
	
	bool						IsKeyEvent () const { return (mStatus > 0x7F) && (mStatus < 0xB0); }
	
	bool						IsPatchChange () const { return ((mStatus & 0xF0) == 0xC0); }
	bool						IsChannelPressure () const { return ((mStatus & 0xF0) == 0xD0); }
	bool						IsPitchBend () const { return ((mStatus & 0xF0) == 0xE0); }
	bool						IsControlChange () const { return ((mStatus & 0xF0) == 0xB0); }
	
	
	void						SetControllerOnValue(){SetBipolar(true,true);}
	void						SetControllerOffValue(){SetBipolar(true,false);}
	void						SetControllerAnyValue(){SetBipolar(false,false);}
								
	// All of these Set calls will reset the mFlags field based on the 
	// anyChannel param value
	void						SetNoteOff (UInt8 key, SInt8 channel, bool anyChannel = false)
								{
									mStatus = 0x80 | (channel & 0xF);
									mData1 = key;
									mFlags = (anyChannel ? kAUParameterMIDIMapping_AnyChannelFlag : 0);
									
								}

	void						SetNoteOn (UInt8 key, SInt8 channel, bool anyChannel = false)
								{
									mStatus = 0x90 | (channel & 0xF);
									mData1 = key;
									mFlags = (anyChannel ? kAUParameterMIDIMapping_AnyChannelFlag : 0);
								}

	void						SetPolyKey (UInt8 key, SInt8 channel, bool anyChannel = false)
								{
									mStatus = 0xA0 | (channel & 0xF);
									mData1 = key;
									mFlags = (anyChannel ? kAUParameterMIDIMapping_AnyChannelFlag : 0);
								}

	void						SetControlChange (UInt8 controllerID, SInt8 channel, bool anyChannel = false)
								{
									mStatus = 0xB0 | (channel & 0xF);
									mData1 = controllerID;
									mFlags = (anyChannel ? kAUParameterMIDIMapping_AnyChannelFlag : 0);
								}
	
	void						SetPatchChange (UInt8 patchChange, SInt8 channel, bool anyChannel = false)
								{
									mStatus = 0xC0 | (channel & 0xF);
									mData1 = patchChange;
									mFlags = (anyChannel ? kAUParameterMIDIMapping_AnyChannelFlag : 0);
								}

	void						SetChannelPressure (SInt8 channel, bool anyChannel = false)
								{
									mStatus = 0xD0 | (channel & 0xF);
									mData1 = 0;
									mFlags = (anyChannel ? kAUParameterMIDIMapping_AnyChannelFlag : 0);
								}

	void						SetPitchBend (SInt8 channel, bool anyChannel = false)
								{
									mStatus = 0xE0 | (channel & 0xF);
									mData1 = 0;
									mFlags = (anyChannel ? kAUParameterMIDIMapping_AnyChannelFlag : 0);
								}
	
	
	Float32						ParamValueFromMIDILinear (Float32		inLinearValue) const
	{
								Float32 low, high;
								if (IsSubRange()){
									low = mSubRangeMin;
									high = mSubRangeMax;
								}
								else {
									low = mMinValue;
									high = mMaxValue;
								}
								
								
								// WE ARE ASSUMING YOU HAVE SET THIS UP PROPERLY!!!!! (or this will crash cause it will be NULL)
								return (Float32)mTransType->fromlinear((inLinearValue * (high - low)) + low);
	}
		

		// The CALLER of this method must ensure that the status byte's MIDI Command (ignoring the channel) matches!!!
	bool						MIDI_Matches (UInt8 inChannel, UInt8 inData1, UInt8 inData2, Float32 &outLinear) const;
	
	void						Print () const;
	
	void						Save (CFPropertyListRef &outData) const;
	void						Restore (CFDictionaryRef inData);
	
	static void					SaveAsMapPList (AudioUnit						inUnit, 
											const AUParameterMIDIMapping		* inMappings, 
											UInt32								inNumMappings, 
											CFPropertyListRef					&outData,
											CFStringRef							inName = NULL);

									// inNumMappings describes how much memory is allocated in outMappings
	static void					RestoreFromMapPList (const CFDictionaryRef			inData, 
														AUParameterMIDIMapping		* outMappings, 
														UInt32						inNumMappings);
														
	static UInt32				NumberOfMaps (const CFDictionaryRef inData);
};


	// these sorting operations sort for run-time efficiency based on the MIDI messages
inline bool operator== (const CAAUMIDIMap &a, const CAAUMIDIMap &b)
{
		// ignore channel first
	return (((a.mStatus & 0xF0) == (b.mStatus & 0xF0))
			&& (a.mData1 == b.mData1)
			&& ((a.mStatus & 0xF) == (b.mStatus & 0xf))  // now compare the channel
			&&  (a.mParameterID == b.mParameterID)
			&& (a.mElement == b.mElement)
			&& (a.mScope == b.mScope));
	
	// reserved field comparisons - ignored until/if they are used
}

inline bool operator< (const CAAUMIDIMap	&a, const CAAUMIDIMap &b)
{
	if ((a.mStatus & 0xF0) != (b.mStatus & 0xF0)) 
		return ((a.mStatus & 0xF0) < (b.mStatus & 0xF0));
	
	if (a.mData1 != b.mData1)
		return (a.mData1 < b.mData1);

	if ((a.mStatus & 0xF) != (b.mStatus & 0xf))  // now compare the channel
		return ((a.mStatus & 0xF) < (b.mStatus & 0xf));

// reserved field comparisons - ignored until/if they are used
		
//		we're sorting this by MIDI, so we don't really care how the rest is sorted
	return	((a.mParameterID < b.mParameterID)
				&& (a.mElement < b.mElement)
				&& (a.mScope < b.mScope));
}



class CompareMIDIMap {
	int compare (const CAAUMIDIMap &a, const CAAUMIDIMap &b) 
	{
		if ((a.mStatus & 0xF0) < (b.mStatus & 0xF0))
			return -1;
		if ((a.mStatus & 0xF0) > (b.mStatus & 0xF0))
			return 1;

			// note event
		if (a.mStatus < 0xB0 || a.mStatus >= 0xD0)
			return 0;
		if (a.mData1 > b.mData1) return 1;
		if (a.mData1 < b.mData1) return -1;
		return 0;
	}
					 
public:
	bool operator() (const CAAUMIDIMap &a, const CAAUMIDIMap &b) {
		return compare (a, b) < 0;
	}
	bool Finish (const CAAUMIDIMap &a, const CAAUMIDIMap &b) {
		return compare (a, b) != 0;
	}
};


/*
	usage: To find potential mapped events for a given status byte, where mMMapEvents is a sorted vec
	CompareMIDIMap comparObj;
	sortVecIter lower_iter = std::lower_bound(mMMapEvents.begin(), mMMapEvents.end(), inStatusByte, compareObj);
	for (;lower_iter < mMMapEvents.end(); ++lower_iter) {
		// then, see if we go out of the status byte range, using the Finish method
		if (compareObj.Finish(map, tempMap)) // tempMap is a CAAUMIDIMap object with the status/dataByte 1 set
			break;
	// ...
	}
	
	in the for loop you call the MIDI_Matches call, to see if the MIDI event matches a given AUMIDIParam mapping
	special note: you HAVE to transform note on (with vel zero) events to the note off status byte
*/

#endif