From 15740faf9fe9fe4be08965098bbf2947e096aeeb Mon Sep 17 00:00:00 2001 From: chai Date: Wed, 14 Aug 2019 22:50:43 +0800 Subject: +Unity Runtime code --- Runtime/Audio/Utilities/Conversion.h | 291 +++++++++++++++++++++++++++++++++++ 1 file changed, 291 insertions(+) create mode 100644 Runtime/Audio/Utilities/Conversion.h (limited to 'Runtime/Audio/Utilities/Conversion.h') diff --git a/Runtime/Audio/Utilities/Conversion.h b/Runtime/Audio/Utilities/Conversion.h new file mode 100644 index 0000000..4bd8fad --- /dev/null +++ b/Runtime/Audio/Utilities/Conversion.h @@ -0,0 +1,291 @@ +/* + * AudioConversion.h + * audio-utils + * + * Created by Søren Christiansen on 2/9/11. + * Copyright 2011 Unity Technologies. All rights reserved. + * + */ +#pragma once + +#include +#include +#include +#include "Runtime/Audio/correct_fmod_includer.h" +#include "Runtime/Utilities/dynamic_array.h" + +using std::unary_function; +using std::transform; + +typedef union { + UInt8 int8[3]; +} SInt24; + +template +struct Reformat : public unary_function { + float operator()(const InType x) { assert("NO REFORMAT BETWEEN THESE TYPES"); return OutType(); } +}; + +// --> normalized float +template +struct Reformat : public unary_function { + float operator()(const InType x) { return ( (float) x ) / ( 1 << ( ( sizeof(InType) * 8) - 1 ) ) ; } +}; + +template< > +struct Reformat : public unary_function { + float operator()(const SInt16 x) { return ( ((float)x) / ( 1 << 15)) ; } +}; + +template< > +struct Reformat : public unary_function { + float operator()(const float x) { return x; } +}; + +template< > +struct Reformat : public unary_function { + float operator()(const SInt24 x) + { + int val; + val = ((unsigned int)x.int8[0] << 8); + val |= ((unsigned int)x.int8[1] << 16); + val |= ((unsigned int)x.int8[2] << 24); + val >>= 8; + return (float)(val) * (1.0f / (float)(1<<23)); + } +}; + +// --> 16 bit +template< > +struct Reformat { + SInt16 operator()(const UInt8 x) { return (( ( UInt16 ) x << 8 )); } +}; + +template< > +struct Reformat { + SInt16 operator()(const SInt24 x) { + SInt16 out = ( x.int8[2] << 8 ); + out |= ( x.int8[1] ); + return out; + } +}; + +template +struct Reformat { + T operator()(const float x) { return (T)(x * ( 1 << ( ( sizeof(T) * 8) - 1 ))); } +}; + +template<> +struct Reformat { + SInt16 operator()(const float x) { return SInt16(x * (1 << 15)); } +}; + +template +struct NOP : public unary_function { + T operator()(const T x) { return x; } +}; + +// --> helper functors +template +class Composer : public unary_function { +private: + typedef typename FO2::result_type FO2Result; + typedef typename FO1::argument_type FO1Arg; + +public: + FO1 fo1; // first/inner function object to call + FO2 fo2; // second/outer function object to call + + // constructor: initialize function objects + Composer (FO1 f1, FO2 f2) + : fo1(f1), fo2(f2) { + } + + // ''function call'': nested call of function objects + FO2Result operator() (const FO1Arg v) { + return fo2(fo1(v)); + } +}; + +template +inline +Composer compose (FO1 f1, FO2 f2) { + return Composer (f1, f2); +} + +template +_Function +for_each_channel(_InputIterator __first, _InputIterator __last, _Function __f, int channel, int channels) +{ + for ( __first = __first + channel; __first < __last - channel; __first = __first+channels) + __f(*__first); + return __f; +} + +// --> helper functions interface +typedef Reformat SInt8ToFloat; +typedef Reformat SInt16ToFloat; +typedef Reformat SInt24ToFloat; +typedef Reformat SInt32ToFloat; +typedef Reformat FloatToFloat; +typedef Reformat FloatToSInt8; +typedef Reformat FloatToSInt16; +typedef Reformat FloatToSInt24; +typedef Reformat FloatToSInt32; + +template +inline void ArrayToNormFloat(FMOD_SOUND_FORMAT inFormat, const void* beginIterator, const void* endIterator, dynamic_array& v, _Function __f) +{ + if (inFormat == FMOD_SOUND_FORMAT_PCM8) + std::transform((const SInt8*) beginIterator, (const SInt8*) endIterator, std::back_inserter(v), compose( SInt8ToFloat(), __f )); + else if (inFormat == FMOD_SOUND_FORMAT_PCM16) + std::transform((const SInt16*) beginIterator, (const SInt16*) endIterator, std::back_inserter(v), compose ( SInt16ToFloat(), __f)); + else if (inFormat == FMOD_SOUND_FORMAT_PCM24) + std::transform((const SInt24*) beginIterator, (const SInt24*) endIterator, std::back_inserter(v), compose ( SInt24ToFloat(), __f)); + else if (inFormat == FMOD_SOUND_FORMAT_PCM32) + std::transform((const SInt32*) beginIterator, (const SInt32*) endIterator, std::back_inserter(v), compose ( SInt32ToFloat(), __f)); + else if (inFormat == FMOD_SOUND_FORMAT_PCMFLOAT) + std::transform((const float*) beginIterator, (const float*) endIterator, std::back_inserter(v), compose ( FloatToFloat(), __f)); +} + +inline void ArrayToNormFloat(FMOD_SOUND_FORMAT inFormat, const void* beginIterator, const void* endIterator, dynamic_array& v) +{ + if (inFormat == FMOD_SOUND_FORMAT_PCM8) + std::transform((const SInt8*) beginIterator, (const SInt8*) endIterator, std::back_inserter(v), SInt8ToFloat()); + else if (inFormat == FMOD_SOUND_FORMAT_PCM16) + std::transform((const SInt16*) beginIterator, (const SInt16*) endIterator, std::back_inserter(v), SInt16ToFloat()); + else if (inFormat == FMOD_SOUND_FORMAT_PCM24) + std::transform((const SInt24*) beginIterator, (const SInt24*) endIterator, std::back_inserter(v), SInt24ToFloat()); + else if (inFormat == FMOD_SOUND_FORMAT_PCM32) + std::transform((const SInt32*) beginIterator, (const SInt32*) endIterator, std::back_inserter(v), SInt32ToFloat()); + else if (inFormat == FMOD_SOUND_FORMAT_PCMFLOAT) + std::transform((const float*) beginIterator, (const float*) endIterator, std::back_inserter(v), FloatToFloat()); +} + +template +inline void ArrayFromNormFloat(FMOD_SOUND_FORMAT outFormat, const float* beginIterator, const float* endIterator, dynamic_array& v) +{ + if (outFormat == FMOD_SOUND_FORMAT_PCM8) + std::transform(beginIterator, endIterator, std::back_inserter(v), FloatToSInt8()); + else if (outFormat == FMOD_SOUND_FORMAT_PCM16) + std::transform( beginIterator, endIterator, std::back_inserter(v), FloatToSInt16()); + //else if (outFormat == FMOD_SOUND_FORMAT_PCM24) + // std::transform( beginIterator, endIterator, std::back_inserter(v), FloatToSInt24()); + else if (outFormat == FMOD_SOUND_FORMAT_PCM32) + std::transform( beginIterator, endIterator, std::back_inserter(v), FloatToSInt32()); + else if (outFormat == FMOD_SOUND_FORMAT_PCMFLOAT) + std::transform( beginIterator, endIterator, std::back_inserter(v), FloatToFloat()); +} + +inline void ArrayFromNormFloat(FMOD_SOUND_FORMAT outFormat, const float* beginIterator, const float* endIterator, void* outbuffer) +{ + if (outFormat == FMOD_SOUND_FORMAT_PCM8) + { + SInt8* dstPtr = (SInt8*)outbuffer; + while (beginIterator != endIterator) + { + *dstPtr = FloatToSInt8()(*beginIterator); + beginIterator++; + dstPtr++; + } + } + else + if (outFormat == FMOD_SOUND_FORMAT_PCM16) + { + SInt16* dstPtr = (SInt16*)outbuffer; + while (beginIterator != endIterator) + { + *dstPtr = FloatToSInt16()(*beginIterator); + beginIterator++; + dstPtr++; + } + } + else + if (outFormat == FMOD_SOUND_FORMAT_PCM32) + { + SInt32* dstPtr = (SInt32*)outbuffer; + while (beginIterator != endIterator) + { + *dstPtr = FloatToSInt32()(*beginIterator); + beginIterator++; + dstPtr++; + } + } + else + if (outFormat == FMOD_SOUND_FORMAT_PCMFLOAT) + { + memcpy (outbuffer, beginIterator, (endIterator - beginIterator) * sizeof(float)); + } + else { + Assert("Conversion NOT supported"); + } + +} + + +inline void ArrayToNormFloat(FMOD_SOUND_FORMAT inFormat, const void* beginIterator, const void* endIterator, float* outbuffer) +{ + if (inFormat == FMOD_SOUND_FORMAT_PCM8) + { + SInt8* srcPtr = (SInt8*)beginIterator; + while (srcPtr != (SInt8*)endIterator) + { + *outbuffer = SInt8ToFloat()(*srcPtr); + srcPtr++; + outbuffer++; + } + } + else + if (inFormat == FMOD_SOUND_FORMAT_PCM16) + { + SInt16* srcPtr = (SInt16*)beginIterator; + while (srcPtr != (SInt16*)endIterator) + { + *outbuffer = SInt16ToFloat()(*srcPtr); + srcPtr++; + outbuffer++; + } + } + else + if (inFormat == FMOD_SOUND_FORMAT_PCM24) + { + SInt24* srcPtr = (SInt24*)beginIterator; + while (srcPtr != (SInt24*)endIterator) + { + *outbuffer = SInt24ToFloat()(*srcPtr); + srcPtr++; + outbuffer++; + } + } + else + if (inFormat == FMOD_SOUND_FORMAT_PCM32) + { + SInt32* srcPtr = (SInt32*)beginIterator; + while (srcPtr != (SInt32*)endIterator) + { + *outbuffer = SInt32ToFloat()(*srcPtr); + srcPtr++; + outbuffer++; + } + } + else + if (inFormat == FMOD_SOUND_FORMAT_PCMFLOAT) + { + memcpy (outbuffer, beginIterator, ((float*)endIterator - (float*)beginIterator) * sizeof(float)); + } + else { + ErrorString("Conversion from this format NOT supported"); + } +} + + + +template +inline void ReformatArray(const InType* inArray, const unsigned size, OutType* outArray) +{ + Reformat reformater; + std::transform( inArray, inArray + size, outArray, reformater ); +} + + + -- cgit v1.1-26-g67d0