AAX.h

Go to the documentation of this file.

/*================================================================================================*/
/*
 
 *  Copyright 2013-2017, 2019, 2023-2024 Avid Technology, Inc.
 *  All rights reserved.
 *  
 *  This file is part of the Avid AAX SDK.
 *  
 *  The AAX SDK is subject to commercial or open-source licensing.
 *  
 *  By using the AAX SDK, you agree to the terms of both the Avid AAX SDK License
 *  Agreement and Avid Privacy Policy.
 *  
 *  AAX SDK License: https://developer.avid.com/aax
 *  Privacy Policy: https://www.avid.com/legal/privacy-policy-statement
 *  
 *  Or: You may also use this code under the terms of the GPL v3 (see
 *  www.gnu.org/licenses).
 *  
 *  THE AAX SDK IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
 *  EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
 *  DISCLAIMED.
 *
 */
 
/*================================================================================================*/
 
 
#pragma once
 
#ifndef _AAX_H_
#define _AAX_H_
 
#include <stdint.h>
#include <stddef.h>
 
#include "AAX_Version.h"
#include "AAX_Enums.h"
#include "AAX_Errors.h"
#include "AAX_Properties.h"
 
 
 
 
#ifndef TI_VERSION
    #if defined _TMS320C6X
        #define TI_VERSION 1
    #elif defined DOXYGEN_PREPROCESSOR
        #define TI_VERSION 0
    #endif
#endif
 
 
#ifndef AAX_CPP11_SUPPORT
    #if (defined __cplusplus) && (__cplusplus >= 201103L)
        #define AAX_CPP11_SUPPORT   1
    // VS2015 supports all features except expression SFINAE
    #elif ((defined _MSVC_LANG) && (_MSVC_LANG >= 201402))
        #define AAX_CPP11_SUPPORT   1
    // Let Doxygen see the C++11 version of all code
    #elif defined DOXYGEN_PREPROCESSOR
        #define AAX_CPP11_SUPPORT   1
    #endif
#endif
 
 
 
#if AAX_CPP11_SUPPORT
#   define AAX_OVERRIDE override
#   define AAX_FINAL final
#   define AAX_DEFAULT_DTOR(X) ~X() = default
#   define AAX_DEFAULT_DTOR_OVERRIDE(X) ~X() override = default
#   define AAX_DEFAULT_CTOR(X) X() = default
#   define AAX_DEFAULT_COPY_CTOR(X) X(const X&) = default
#   define AAX_DEFAULT_ASGN_OPER(X) X& operator=(const X&) = default
#   define AAX_DELETE(X) X = delete
#   define AAX_DEFAULT_MOVE_CTOR(X) X(X&&) = default
#   define AAX_DEFAULT_MOVE_OPER(X) X& operator=(X&&) = default
#   define AAX_CONSTEXPR constexpr
#   define AAX_UNIQUE_PTR(X) std::unique_ptr<X>
#else
#   define AAX_OVERRIDE
#   define AAX_FINAL
#   define AAX_DEFAULT_DTOR(X) ~X() {}
#   define AAX_DEFAULT_DTOR_OVERRIDE(X) ~X() {}
#   define AAX_DEFAULT_CTOR(X) X() {}
#   define AAX_DEFAULT_COPY_CTOR(X)
#   define AAX_DEFAULT_MOVE_CTOR(X)
#   define AAX_DEFAULT_ASGN_OPER(X)
#   define AAX_DEFAULT_MOVE_OPER(X)
// Assumes public access in the declaration scope where AAX_DELETE is used
#   define AAX_DELETE(X) private: X; public:
#   define AAX_CONSTEXPR const
#   define AAX_UNIQUE_PTR(X) std::auto_ptr<X>
#endif
 
 
#define AAXPointer_32bit    1
#define AAXPointer_64bit    2
 
#if !defined(AAX_PointerSize)
    #if defined(_M_X64) || defined (__LP64__)
        #define AAX_PointerSize AAXPointer_64bit
    #else
        #define AAX_PointerSize AAXPointer_32bit
    #endif
#endif
 
// ensure that preprocessor comparison logic gives the correct result
#if ((AAX_PointerSize == AAXPointer_32bit) && (defined(_M_X64) || defined (__LP64__)))
    #error incorrect result of AAX_PointerSize check!
#elif ((AAX_PointerSize == AAXPointer_64bit) && !(defined(_M_X64) || defined (__LP64__)))
    #error incorrect result of AAX_PointerSize check!
#endif
 
 
 
#if ( defined(_WIN64) || defined(__LP64__) )
    #define AAX_ALIGN_FILE_HOST     "AAX_Push8ByteStructAlignment.h"
#elif ( defined(_TMS320C6X) )
    // AAX_ALIGN_FILE_HOST is not compatible with this compiler
    // We don't use an #error here b/c that causes Doxygen to get confused
#else
    #define AAX_ALIGN_FILE_HOST     "AAX_Push2ByteStructAlignment.h"
#endif
#define AAX_ALIGN_FILE_ALG      "AAX_Push8ByteStructAlignment.h"
#define AAX_ALIGN_FILE_RESET    "AAX_PopStructAlignment.h"
#define AAX_ALIGN_FILE_BEGIN        "AAX_PreStructAlignmentHelper.h"
#define AAX_ALIGN_FILE_END      "AAX_PostStructAlignmentHelper.h"
 
 
#ifndef AAX_CALLBACK
#   ifdef _MSC_VER
#       define AAX_CALLBACK     __cdecl
#   else
#       define AAX_CALLBACK
#   endif
#endif // AAX_CALLBACK
 
 
#ifdef _MSC_VER
#   define AAX_RESTRICT
#elif defined(_TMS320C6X) // TI
#   define AAX_RESTRICT restrict
#elif defined (__GNUC__)// Mac
#   define AAX_RESTRICT __restrict__
#endif // _MSC_VER
 
 
// preprocessor helper macros
#define AAX_PREPROCESSOR_CONCAT_HELPER(X,Y) X ## Y
#define AAX_PREPROCESSOR_CONCAT(X,Y) AAX_PREPROCESSOR_CONCAT_HELPER(X,Y)
 
 
 
#ifdef _MSC_VER
// Disable unknown pragma warning for TI pragmas under VC++
#pragma warning( disable : 4068 )
#endif
 
 
#define AAX_FIELD_INDEX( aContextType, aMember ) \
    ((AAX_CFieldIndex) (offsetof (aContextType, aMember) / sizeof (void *)))
 
 
typedef int32_t     AAX_CIndex;        
typedef AAX_CIndex  AAX_CCount;        
typedef uint8_t     AAX_CBoolean;      
typedef uint32_t    AAX_CSelector;     
typedef int64_t     AAX_CTimestamp;    
typedef int64_t     AAX_CTimeOfDay;    
typedef int64_t     AAX_CTransportCounter;  
typedef float       AAX_CSampleRate;   
 
typedef uint32_t    AAX_CTypeID;  
typedef int32_t     AAX_Result;
typedef int32_t     AAX_CPropertyValue; 
typedef int64_t     AAX_CPropertyValue64; 
#if AAX_PointerSize == AAXPointer_32bit
    typedef AAX_CPropertyValue AAX_CPointerPropertyValue; 
#elif AAX_PointerSize == AAXPointer_64bit
    typedef AAX_CPropertyValue64 AAX_CPointerPropertyValue; 
#else
    #error unexpected pointer size
#endif
typedef int32_t     AAX_CTargetPlatform;  
 
typedef AAX_CIndex      AAX_CFieldIndex;    
typedef AAX_CSelector   AAX_CComponentID;   
typedef AAX_CSelector   AAX_CMeterID;       
typedef const char *    AAX_CParamID;       
typedef AAX_CParamID    AAX_CPageTableParamID; 
typedef const char *    AAX_CEffectID;      
 
// Forward declarations required for AAX_Feature_UID typedef (the "real" typedef is in AAX_UIDs.h)
struct _acfUID;
typedef _acfUID acfUID;
 
typedef acfUID AAX_Feature_UID;
 
AAX_CONSTEXPR size_t        kAAX_ParameterIdentifierMaxSize = 32;
 
static const AAX_CTimestamp     kAAX_Never = (AAX_CTimestamp) ~0ULL;
 
 
#ifdef _TMS320C6X
    // TI's C compiler defaults to 8 byte alignment of doubles
    #define AAX_ALIGNED(v)
#elif defined(__GNUC__)
    #define AAX_ALIGNED(v) __attribute__((aligned(v)))
#elif defined(_MSC_VER)
    #define AAX_ALIGNED(v) __declspec(align(v))
#else
    #error Teach me to align data types with this compiler.
#endif
 
 
static
inline
int32_t
AAX_GetStemFormatChannelCount (
                               AAX_EStemFormat      inStemFormat)
{
    return AAX_STEM_FORMAT_CHANNEL_COUNT (inStemFormat);
}
 
 
typedef const float * const *       AAX_CAudioInPort;
 
 
typedef float * const *     AAX_CAudioOutPort;
 
 
typedef  float * const      AAX_CMeterPort;
 
 
inline AAX_CBoolean sampleRateInMask(AAX_CSampleRate inSR, uint32_t iMask)
{
    return  static_cast<AAX_CBoolean>(
        (44100.0 == inSR) ? ((iMask & AAX_eSampleRateMask_44100) != 0) :
        (48000.0 == inSR) ?  ((iMask & AAX_eSampleRateMask_48000)  != 0) :
        (88200.0 == inSR) ?  ((iMask & AAX_eSampleRateMask_88200)  != 0) :
        (96000.0 == inSR) ?  ((iMask & AAX_eSampleRateMask_96000)  != 0) :
        (176400.0 == inSR) ? ((iMask & AAX_eSampleRateMask_176400) != 0) :
        (192000.0 == inSR) ? ((iMask & AAX_eSampleRateMask_192000) != 0) : false
    );
}
 
inline AAX_CSampleRate getLowestSampleRateInMask(uint32_t iMask)
{
    return (
        ((iMask & AAX_eSampleRateMask_44100)  != 0) ? 44100.0f : // AAX_eSamplRateMask_All returns 44100
        ((iMask & AAX_eSampleRateMask_48000)  != 0) ? 48000.0f :
        ((iMask & AAX_eSampleRateMask_88200)  != 0) ? 88200.0f :
        ((iMask & AAX_eSampleRateMask_96000)  != 0) ? 96000.0f :
        ((iMask & AAX_eSampleRateMask_176400) != 0) ? 176400.0f :
        ((iMask & AAX_eSampleRateMask_192000) != 0) ? 192000.0f : 0.0f
    );
}
 
inline uint32_t getMaskForSampleRate(float inSR)
{
    return (
      (44100.0 == inSR) ?  AAX_eSampleRateMask_44100 :
      (48000.0 == inSR) ?  AAX_eSampleRateMask_48000 :
      (88200.0 == inSR) ?  AAX_eSampleRateMask_88200 :
      (96000.0 == inSR) ?  AAX_eSampleRateMask_96000 :
      (176400.0 == inSR) ? AAX_eSampleRateMask_176400 :
      (192000.0 == inSR) ? AAX_eSampleRateMask_192000 : AAX_eSampleRateMask_No
    );
}
 
 
#ifndef _TMS320C6X
 
#include AAX_ALIGN_FILE_BEGIN
#include AAX_ALIGN_FILE_HOST
#include AAX_ALIGN_FILE_END
 
#endif
 
struct AAX_SPlugInChunkHeader {
    int32_t             fSize;              
    int32_t             fVersion;           
    AAX_CTypeID         fManufacturerID;    
    AAX_CTypeID         fProductID;         
    AAX_CTypeID         fPlugInID;          
    AAX_CTypeID         fChunkID;           
    unsigned char       fName[32];          
};
typedef struct AAX_SPlugInChunkHeader AAX_SPlugInChunkHeader;
 
struct AAX_SPlugInChunk {
    int32_t             fSize;              
    int32_t             fVersion;           
    AAX_CTypeID         fManufacturerID;    
    AAX_CTypeID         fProductID;         
    AAX_CTypeID         fPlugInID;          
    AAX_CTypeID         fChunkID;           
    unsigned char       fName[32];          
    char                fData[1];           
};
typedef struct AAX_SPlugInChunk AAX_SPlugInChunk, *AAX_SPlugInChunkPtr;
 
struct AAX_SPlugInIdentifierTriad {
    AAX_CTypeID         mManufacturerID;    
    AAX_CTypeID         mProductID;         
    AAX_CTypeID         mPlugInID;          
};
typedef struct AAX_SPlugInIdentifierTriad AAX_SPlugInIdentifierTriad, *AAX_SPlugInIdentifierTriadPtr;
 
#ifndef _TMS320C6X
#include AAX_ALIGN_FILE_BEGIN
#include AAX_ALIGN_FILE_RESET
#include AAX_ALIGN_FILE_END
#endif
 
#ifndef TI_VERSION
static inline bool operator==(const AAX_SPlugInIdentifierTriad& v1, const AAX_SPlugInIdentifierTriad& v2)
{
    return ((v1.mManufacturerID == v2.mManufacturerID) &&
            (v1.mProductID      == v2.mProductID) &&
            (v1.mPlugInID       == v2.mPlugInID));
}
 
static inline bool operator!=(const AAX_SPlugInIdentifierTriad& v1, const AAX_SPlugInIdentifierTriad& v2)
{
    return false == operator==(v1, v2);
}
 
static inline bool operator<(const AAX_SPlugInIdentifierTriad & lhs, const AAX_SPlugInIdentifierTriad & rhs)
{
    if (lhs.mManufacturerID < rhs.mManufacturerID)
        return true;
    
    if (lhs.mManufacturerID == rhs.mManufacturerID)
    {
        if (lhs.mProductID < rhs.mProductID)
            return true;
        
        if (lhs.mProductID == rhs.mProductID)
            if (lhs.mPlugInID < rhs.mPlugInID)
                return true;
    }
    return false;
}
 
static inline bool operator>=(const AAX_SPlugInIdentifierTriad & lhs, const AAX_SPlugInIdentifierTriad & rhs)
{
    return false == operator<(lhs, rhs);
}
 
static inline bool operator>(const AAX_SPlugInIdentifierTriad & lhs, const AAX_SPlugInIdentifierTriad & rhs)
{
    return operator>=(lhs, rhs) && operator!=(lhs, rhs);
}
 
static inline bool operator<=(const AAX_SPlugInIdentifierTriad & lhs, const AAX_SPlugInIdentifierTriad & rhs)
{
    return false == operator>(lhs, rhs);
}
#endif //TI_VERSION
 
 
//<DMT> For historical compatibility with PT10, we have to make the MIDI structures DEFAULT aligned instead of ALG aligned.  With PT11 and 64 bit, these will now be ALG aligned.
#if ( defined(_WIN64) || defined(__LP64__) || defined(_TMS320C6X) )
    #include AAX_ALIGN_FILE_BEGIN
    #include AAX_ALIGN_FILE_ALG
    #include AAX_ALIGN_FILE_END
#else
    #if defined (__GNUC__)
        #pragma options align=power // To maintain backwards-compatibility with pre-10 versions of Pro Tools
    #else // Windows, other
        #include AAX_ALIGN_FILE_BEGIN
        #include AAX_ALIGN_FILE_HOST
        #include AAX_ALIGN_FILE_END
    #endif
#endif
 
struct AAX_CMidiPacket 
{
    uint32_t            mTimestamp;     
    uint32_t            mLength;        
    unsigned char       mData[4];       
    AAX_CBoolean        mIsImmediate;   
};
 
struct AAX_CMidiStream
{
    uint32_t            mBufferSize;        
    AAX_CMidiPacket*        mBuffer;        
};  
 
#if ( defined(_WIN64) || defined(__LP64__) || defined(_TMS320C6X) )
    #include AAX_ALIGN_FILE_BEGIN
    #include AAX_ALIGN_FILE_RESET
    #include AAX_ALIGN_FILE_END
#else
    #if defined (__GNUC__)
        #pragma pack()  // To maintian backwards-compatibility with pre-10 versions of Pro Tools
    #else
        #include AAX_ALIGN_FILE_BEGIN
        #include AAX_ALIGN_FILE_RESET
        #include AAX_ALIGN_FILE_END
    #endif
#endif
 
#endif // #ifndef _AAX_H_