cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/AU/PublicUtility/CAStreamBasicDescription.cpp

@@ -0,0 +1,795 @@
+/*
+     File: CAStreamBasicDescription.cpp 
+ Abstract:  CAStreamBasicDescription.h  
+  Version: 1.01 
+  
+ 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) 2012 Apple Inc. All Rights Reserved. 
+  
+*/
+#include "CAStreamBasicDescription.h"
+#include "CAMath.h"
+
+#if !defined(__COREAUDIO_USE_FLAT_INCLUDES__)
+	#include <CoreFoundation/CFByteOrder.h>
+#else
+	#include <CFByteOrder.h>
+#endif
+
+#pragma mark	This file needs to compile on earlier versions of the OS, so please keep that in mind when editing it
+
+char *CAStringForOSType (OSType t, char *writeLocation)
+{
+	char *p = writeLocation;
+    unsigned char str[4] = {0}, *q = str;
+	*(UInt32 *)str = CFSwapInt32HostToBig(t);
+
+	bool hasNonPrint = false;
+	for (int i = 0; i < 4; ++i) {
+		if (!(isprint(*q) && *q != '\\')) {
+			hasNonPrint = true;
+			break;
+		}
+        q++;
+	}
+    q = str;
+	
+	if (hasNonPrint)
+		p += sprintf (p, "0x");
+	else
+		*p++ = '\'';
+		
+	for (int i = 0; i < 4; ++i) {
+		if (hasNonPrint) {
+			p += sprintf(p, "%02X", *q++);
+		} else {
+			*p++ = *q++;
+		}
+	}
+	if (!hasNonPrint)
+		*p++ = '\'';
+	*p = '\0';
+	return writeLocation;
+}
+
+
+const AudioStreamBasicDescription	CAStreamBasicDescription::sEmpty = { 0.0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+CAStreamBasicDescription::CAStreamBasicDescription() 
+{ 
+	memset (this, 0, sizeof(AudioStreamBasicDescription)); 
+}
+	
+CAStreamBasicDescription::CAStreamBasicDescription(const AudioStreamBasicDescription &desc)
+{
+	SetFrom(desc);
+}
+
+
+CAStreamBasicDescription::CAStreamBasicDescription(double inSampleRate,		UInt32 inFormatID,
+									UInt32 inBytesPerPacket,	UInt32 inFramesPerPacket,
+									UInt32 inBytesPerFrame,		UInt32 inChannelsPerFrame,
+									UInt32 inBitsPerChannel,	UInt32 inFormatFlags)
+{
+	mSampleRate = inSampleRate;
+	mFormatID = inFormatID;
+	mBytesPerPacket = inBytesPerPacket;
+	mFramesPerPacket = inFramesPerPacket;
+	mBytesPerFrame = inBytesPerFrame;
+	mChannelsPerFrame = inChannelsPerFrame;
+	mBitsPerChannel = inBitsPerChannel;
+	mFormatFlags = inFormatFlags;
+	mReserved = 0;
+}
+
+char *CAStreamBasicDescription::AsString(char *buf, size_t _bufsize) const
+{
+	int bufsize = (int)_bufsize;	// must be signed to protect against overflow
+	char *theBuffer = buf;
+	int nc;
+	char formatID[24];
+	CAStringForOSType (mFormatID, formatID);
+	nc = snprintf(buf, bufsize, "%2d ch, %6.0f Hz, %s (0x%08X) ", (int)NumberChannels(), mSampleRate, formatID, (int)mFormatFlags);
+	buf += nc; if ((bufsize -= nc) <= 0) goto exit;
+	if (mFormatID == kAudioFormatLinearPCM) {
+		bool isInt = !(mFormatFlags & kLinearPCMFormatFlagIsFloat);
+		int wordSize = SampleWordSize();
+		const char *endian = (wordSize > 1) ? 
+			((mFormatFlags & kLinearPCMFormatFlagIsBigEndian) ? " big-endian" : " little-endian" ) : "";
+		const char *sign = isInt ? 
+			((mFormatFlags & kLinearPCMFormatFlagIsSignedInteger) ? " signed" : " unsigned") : "";
+		const char *floatInt = isInt ? "integer" : "float";
+		char packed[32];
+		if (wordSize > 0 && PackednessIsSignificant()) {
+			if (mFormatFlags & kLinearPCMFormatFlagIsPacked)
+				snprintf(packed, sizeof(packed), "packed in %d bytes", wordSize);
+			else
+				snprintf(packed, sizeof(packed), "unpacked in %d bytes", wordSize);
+		} else
+			packed[0] = '\0';
+		const char *align = (wordSize > 0 && AlignmentIsSignificant()) ?
+			((mFormatFlags & kLinearPCMFormatFlagIsAlignedHigh) ? " high-aligned" : " low-aligned") : "";
+		const char *deinter = (mFormatFlags & kAudioFormatFlagIsNonInterleaved) ? ", deinterleaved" : "";
+		const char *commaSpace = (packed[0]!='\0') || (align[0]!='\0') ? ", " : "";
+		char bitdepth[20];
+
+		int fracbits = (mFormatFlags & kLinearPCMFormatFlagsSampleFractionMask) >> kLinearPCMFormatFlagsSampleFractionShift;
+		if (fracbits > 0)
+			snprintf(bitdepth, sizeof(bitdepth), "%d.%d", (int)mBitsPerChannel - fracbits, fracbits);
+		else
+			snprintf(bitdepth, sizeof(bitdepth), "%d", (int)mBitsPerChannel);
+		
+		/* nc =*/ snprintf(buf, bufsize, "%s-bit%s%s %s%s%s%s%s",
+			bitdepth, endian, sign, floatInt, 
+			commaSpace, packed, align, deinter);
+		// buf += nc; if ((bufsize -= nc) <= 0) goto exit;
+	} else if (mFormatID == 'alac') {	//	kAudioFormatAppleLossless
+		int sourceBits = 0;
+		switch (mFormatFlags)
+		{
+			case 1:	//	kAppleLosslessFormatFlag_16BitSourceData
+				sourceBits = 16;
+				break;
+    		case 2:	//	kAppleLosslessFormatFlag_20BitSourceData
+    			sourceBits = 20;
+    			break;
+    		case 3:	//	kAppleLosslessFormatFlag_24BitSourceData
+    			sourceBits = 24;
+    			break;
+    		case 4:	//	kAppleLosslessFormatFlag_32BitSourceData
+    			sourceBits = 32;
+    			break;
+		}
+		if (sourceBits)
+			nc = snprintf(buf, bufsize, "from %d-bit source, ", sourceBits);
+		else
+			nc = snprintf(buf, bufsize, "from UNKNOWN source bit depth, ");
+		buf += nc; if ((bufsize -= nc) <= 0) goto exit;
+		/* nc =*/ snprintf(buf, bufsize, "%d frames/packet", (int)mFramesPerPacket);
+		//	buf += nc; if ((bufsize -= nc) <= 0) goto exit;
+	}
+	else
+		/* nc =*/ snprintf(buf, bufsize, "%d bits/channel, %d bytes/packet, %d frames/packet, %d bytes/frame",
+			(int)mBitsPerChannel, (int)mBytesPerPacket, (int)mFramesPerPacket, (int)mBytesPerFrame);
+exit:
+	return theBuffer;
+}
+
+void	CAStreamBasicDescription::NormalizeLinearPCMFormat(AudioStreamBasicDescription& ioDescription)
+{
+	//  the only thing that changes is to make mixable linear PCM into the canonical linear PCM format
+	if((ioDescription.mFormatID == kAudioFormatLinearPCM) && ((ioDescription.mFormatFlags & kIsNonMixableFlag) == 0))
+	{
+		//  the canonical linear PCM format
+		ioDescription.mFormatFlags = kAudioFormatFlagsCanonical;
+		ioDescription.mBytesPerPacket = SizeOf32(AudioSampleType) * ioDescription.mChannelsPerFrame;
+		ioDescription.mFramesPerPacket = 1;
+		ioDescription.mBytesPerFrame = SizeOf32(AudioSampleType) * ioDescription.mChannelsPerFrame;
+		ioDescription.mBitsPerChannel = 8 * SizeOf32(AudioSampleType);
+	}
+}
+
+void	CAStreamBasicDescription::NormalizeLinearPCMFormat(bool inNativeEndian, AudioStreamBasicDescription& ioDescription)
+{
+	//  the only thing that changes is to make mixable linear PCM into the canonical linear PCM format
+	if((ioDescription.mFormatID == kAudioFormatLinearPCM) && ((ioDescription.mFormatFlags & kIsNonMixableFlag) == 0))
+	{
+		//  the canonical linear PCM format
+		ioDescription.mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked;
+		if(inNativeEndian)
+		{
+#if TARGET_RT_BIG_ENDIAN
+			ioDescription.mFormatFlags |= kAudioFormatFlagIsBigEndian;
+#endif
+		}
+		else
+		{
+#if TARGET_RT_LITTLE_ENDIAN
+			ioDescription.mFormatFlags |= kAudioFormatFlagIsBigEndian;
+#endif
+		}
+		ioDescription.mBytesPerPacket = SizeOf32(AudioSampleType) * ioDescription.mChannelsPerFrame;
+		ioDescription.mFramesPerPacket = 1;
+		ioDescription.mBytesPerFrame = SizeOf32(AudioSampleType) * ioDescription.mChannelsPerFrame;
+		ioDescription.mBitsPerChannel = 8 * SizeOf32(AudioSampleType);
+	}
+}
+
+void	CAStreamBasicDescription::ResetFormat(AudioStreamBasicDescription& ioDescription)
+{
+	ioDescription.mSampleRate = 0;
+	ioDescription.mFormatID = 0;
+	ioDescription.mBytesPerPacket = 0;
+	ioDescription.mFramesPerPacket = 0;
+	ioDescription.mBytesPerFrame = 0;
+	ioDescription.mChannelsPerFrame = 0;
+	ioDescription.mBitsPerChannel = 0;
+	ioDescription.mFormatFlags = 0;
+}
+
+void	CAStreamBasicDescription::FillOutFormat(AudioStreamBasicDescription& ioDescription, const AudioStreamBasicDescription& inTemplateDescription)
+{
+	if(fiszero(ioDescription.mSampleRate))
+	{
+		ioDescription.mSampleRate = inTemplateDescription.mSampleRate;
+	}
+	if(ioDescription.mFormatID == 0)
+	{
+		ioDescription.mFormatID = inTemplateDescription.mFormatID;
+	}
+	if(ioDescription.mFormatFlags == 0)
+	{
+		ioDescription.mFormatFlags = inTemplateDescription.mFormatFlags;
+	}
+	if(ioDescription.mBytesPerPacket == 0)
+	{
+		ioDescription.mBytesPerPacket = inTemplateDescription.mBytesPerPacket;
+	}
+	if(ioDescription.mFramesPerPacket == 0)
+	{
+		ioDescription.mFramesPerPacket = inTemplateDescription.mFramesPerPacket;
+	}
+	if(ioDescription.mBytesPerFrame == 0)
+	{
+		ioDescription.mBytesPerFrame = inTemplateDescription.mBytesPerFrame;
+	}
+	if(ioDescription.mChannelsPerFrame == 0)
+	{
+		ioDescription.mChannelsPerFrame = inTemplateDescription.mChannelsPerFrame;
+	}
+	if(ioDescription.mBitsPerChannel == 0)
+	{
+		ioDescription.mBitsPerChannel = inTemplateDescription.mBitsPerChannel;
+	}
+}
+
+void	CAStreamBasicDescription::GetSimpleName(const AudioStreamBasicDescription& inDescription, char* outName, UInt32 inMaxNameLength, bool inAbbreviate, bool inIncludeSampleRate)
+{
+	if(inIncludeSampleRate)
+	{
+		int theCharactersWritten = snprintf(outName, inMaxNameLength, "%.0f ", inDescription.mSampleRate);
+		outName += theCharactersWritten;
+		inMaxNameLength -= theCharactersWritten;
+	}
+	
+	switch(inDescription.mFormatID)
+	{
+		case kAudioFormatLinearPCM:
+			{
+				const char* theEndianString = NULL;
+				if((inDescription.mFormatFlags & kAudioFormatFlagIsBigEndian) != 0)
+				{
+					#if	TARGET_RT_LITTLE_ENDIAN
+						theEndianString = "Big Endian";
+					#endif
+				}
+				else
+				{
+					#if	TARGET_RT_BIG_ENDIAN
+						theEndianString = "Little Endian";
+					#endif
+				}
+				
+				const char* theKindString = NULL;
+				if((inDescription.mFormatFlags & kAudioFormatFlagIsFloat) != 0)
+				{
+					theKindString = (inAbbreviate ? "Float" : "Floating Point");
+				}
+				else if((inDescription.mFormatFlags & kAudioFormatFlagIsSignedInteger) != 0)
+				{
+					theKindString = (inAbbreviate ? "SInt" : "Signed Integer");
+				}
+				else
+				{
+					theKindString = (inAbbreviate ? "UInt" : "Unsigned Integer");
+				}
+				
+				const char* thePackingString = NULL;
+				if((inDescription.mFormatFlags & kAudioFormatFlagIsPacked) == 0)
+				{
+					if((inDescription.mFormatFlags & kAudioFormatFlagIsAlignedHigh) != 0)
+					{
+						thePackingString = "High";
+					}
+					else
+					{
+						thePackingString = "Low";
+					}
+				}
+				
+				const char* theMixabilityString = NULL;
+				if((inDescription.mFormatFlags & kIsNonMixableFlag) == 0)
+				{
+					theMixabilityString = "Mixable";
+				}
+				else
+				{
+					theMixabilityString = "Unmixable";
+				}
+				
+				if(inAbbreviate)
+				{
+					if(theEndianString != NULL)
+					{
+						if(thePackingString != NULL)
+						{
+							snprintf(outName, inMaxNameLength, "%s %d Ch %s %s %s%d/%s%d", theMixabilityString, (int)inDescription.mChannelsPerFrame, theEndianString, thePackingString, theKindString, (int)inDescription.mBitsPerChannel, theKindString, (int)(inDescription.mBytesPerFrame / inDescription.mChannelsPerFrame) * 8);
+						}
+						else
+						{
+							snprintf(outName, inMaxNameLength, "%s %d Ch %s %s%d", theMixabilityString, (int)inDescription.mChannelsPerFrame, theEndianString, theKindString, (int)inDescription.mBitsPerChannel);
+						}
+					}
+					else
+					{
+						if(thePackingString != NULL)
+						{
+							snprintf(outName, inMaxNameLength, "%s %d Ch %s %s%d/%s%d", theMixabilityString, (int)inDescription.mChannelsPerFrame, thePackingString, theKindString, (int)inDescription.mBitsPerChannel, theKindString, (int)((inDescription.mBytesPerFrame / inDescription.mChannelsPerFrame) * 8));
+						}
+						else
+						{
+							snprintf(outName, inMaxNameLength, "%s %d Ch %s%d", theMixabilityString, (int)inDescription.mChannelsPerFrame, theKindString, (int)inDescription.mBitsPerChannel);
+						}
+					}
+				}
+				else
+				{
+					if(theEndianString != NULL)
+					{
+						if(thePackingString != NULL)
+						{
+							snprintf(outName, inMaxNameLength, "%s %d Channel %d Bit %s %s Aligned %s in %d Bits", theMixabilityString, (int)inDescription.mChannelsPerFrame, (int)inDescription.mBitsPerChannel, theEndianString, theKindString, thePackingString, (int)(inDescription.mBytesPerFrame / inDescription.mChannelsPerFrame) * 8);
+						}
+						else
+						{
+							snprintf(outName, inMaxNameLength, "%s %d Channel %d Bit %s %s", theMixabilityString, (int)inDescription.mChannelsPerFrame, (int)inDescription.mBitsPerChannel, theEndianString, theKindString);
+						}
+					}
+					else
+					{
+						if(thePackingString != NULL)
+						{
+							snprintf(outName, inMaxNameLength, "%s %d Channel %d Bit %s Aligned %s in %d Bits", theMixabilityString, (int)inDescription.mChannelsPerFrame, (int)inDescription.mBitsPerChannel, theKindString, thePackingString, (int)(inDescription.mBytesPerFrame / inDescription.mChannelsPerFrame) * 8);
+						}
+						else
+						{
+							snprintf(outName, inMaxNameLength, "%s %d Channel %d Bit %s", theMixabilityString, (int)inDescription.mChannelsPerFrame, (int)inDescription.mBitsPerChannel, theKindString);
+						}
+					}
+				}
+			}
+			break;
+		
+		case kAudioFormatAC3:
+			strlcpy(outName, "AC-3", sizeof(outName));
+			break;
+		
+		case kAudioFormat60958AC3:
+			strlcpy(outName, "AC-3 for SPDIF", sizeof(outName));
+			break;
+		
+		default:
+			CACopy4CCToCString(outName, inDescription.mFormatID);
+			break;
+	};
+}
+
+#if CoreAudio_Debug
+#include "CALogMacros.h"
+
+void	CAStreamBasicDescription::PrintToLog(const AudioStreamBasicDescription& inDesc)
+{
+	PrintFloat		("  Sample Rate:        ", inDesc.mSampleRate);
+	Print4CharCode	("  Format ID:          ", inDesc.mFormatID);
+	PrintHex		("  Format Flags:       ", inDesc.mFormatFlags);
+	PrintInt		("  Bytes per Packet:   ", inDesc.mBytesPerPacket);
+	PrintInt		("  Frames per Packet:  ", inDesc.mFramesPerPacket);
+	PrintInt		("  Bytes per Frame:    ", inDesc.mBytesPerFrame);
+	PrintInt		("  Channels per Frame: ", inDesc.mChannelsPerFrame);
+	PrintInt		("  Bits per Channel:   ", inDesc.mBitsPerChannel);
+}
+#endif
+
+bool	operator<(const AudioStreamBasicDescription& x, const AudioStreamBasicDescription& y)
+{
+	bool theAnswer = false;
+	bool isDone = false;
+	
+	//	note that if either side is 0, that field is skipped
+	
+	//	format ID is the first order sort
+	if((!isDone) && ((x.mFormatID != 0) && (y.mFormatID != 0)))
+	{
+		if(x.mFormatID != y.mFormatID)
+		{
+			//	formats are sorted numerically except that linear
+			//	PCM is always first
+			if(x.mFormatID == kAudioFormatLinearPCM)
+			{
+				theAnswer = true;
+			}
+			else if(y.mFormatID == kAudioFormatLinearPCM)
+			{
+				theAnswer = false;
+			}
+			else
+			{
+				theAnswer = x.mFormatID < y.mFormatID;
+			}
+			isDone = true;
+		}
+	}
+	
+	
+	//  mixable is always better than non-mixable for linear PCM and should be the second order sort item
+	if((!isDone) && ((x.mFormatID == kAudioFormatLinearPCM) && (y.mFormatID == kAudioFormatLinearPCM)))
+	{
+		if(((x.mFormatFlags & kIsNonMixableFlag) == 0) && ((y.mFormatFlags & kIsNonMixableFlag) != 0))
+		{
+			theAnswer = true;
+			isDone = true;
+		}
+		else if(((x.mFormatFlags & kIsNonMixableFlag) != 0) && ((y.mFormatFlags & kIsNonMixableFlag) == 0))
+		{
+			theAnswer = false;
+			isDone = true;
+		}
+	}
+	
+	//	floating point vs integer for linear PCM only
+	if((!isDone) && ((x.mFormatID == kAudioFormatLinearPCM) && (y.mFormatID == kAudioFormatLinearPCM)))
+	{
+		if((x.mFormatFlags & kAudioFormatFlagIsFloat) != (y.mFormatFlags & kAudioFormatFlagIsFloat))
+		{
+			//	floating point is better than integer
+			theAnswer = y.mFormatFlags & kAudioFormatFlagIsFloat;
+			isDone = true;
+		}
+	}
+	
+	//	bit depth
+	if((!isDone) && ((x.mBitsPerChannel != 0) && (y.mBitsPerChannel != 0)))
+	{
+		if(x.mBitsPerChannel != y.mBitsPerChannel)
+		{
+			//	deeper bit depths are higher quality
+			theAnswer = x.mBitsPerChannel < y.mBitsPerChannel;
+			isDone = true;
+		}
+	}
+	
+	//	sample rate
+	if((!isDone) && fnonzero(x.mSampleRate) && fnonzero(y.mSampleRate))
+	{
+		if(fnotequal(x.mSampleRate, y.mSampleRate))
+		{
+			//	higher sample rates are higher quality
+			theAnswer = x.mSampleRate < y.mSampleRate;
+			isDone = true;
+		}
+	}
+	
+	//	number of channels
+	if((!isDone) && ((x.mChannelsPerFrame != 0) && (y.mChannelsPerFrame != 0)))
+	{
+		if(x.mChannelsPerFrame != y.mChannelsPerFrame)
+		{
+			//	more channels is higher quality
+			theAnswer = x.mChannelsPerFrame < y.mChannelsPerFrame;
+			//isDone = true;
+		}
+	}
+	
+	return theAnswer;
+}
+
+static bool MatchFormatFlags(const AudioStreamBasicDescription& x, const AudioStreamBasicDescription& y)
+{
+	UInt32 xFlags = x.mFormatFlags;
+	UInt32 yFlags = y.mFormatFlags;
+	
+	// match wildcards
+	if (x.mFormatID == 0 || y.mFormatID == 0 || xFlags == 0 || yFlags == 0) 
+		return true;
+	
+	if (x.mFormatID == kAudioFormatLinearPCM)
+	{		 		
+		// knock off the all clear flag
+		xFlags = xFlags & ~kAudioFormatFlagsAreAllClear;
+		yFlags = yFlags & ~kAudioFormatFlagsAreAllClear;
+	
+		// if both kAudioFormatFlagIsPacked bits are set, then we don't care about the kAudioFormatFlagIsAlignedHigh bit.
+		if (xFlags & yFlags & kAudioFormatFlagIsPacked) {
+			xFlags = xFlags & ~kAudioFormatFlagIsAlignedHigh;
+			yFlags = yFlags & ~kAudioFormatFlagIsAlignedHigh;
+		}
+		
+		// if both kAudioFormatFlagIsFloat bits are set, then we don't care about the kAudioFormatFlagIsSignedInteger bit.
+		if (xFlags & yFlags & kAudioFormatFlagIsFloat) {
+			xFlags = xFlags & ~kAudioFormatFlagIsSignedInteger;
+			yFlags = yFlags & ~kAudioFormatFlagIsSignedInteger;
+		}
+		
+		//	if the bit depth is 8 bits or less and the format is packed, we don't care about endianness
+		if((x.mBitsPerChannel <= 8) && ((xFlags & kAudioFormatFlagIsPacked) == kAudioFormatFlagIsPacked))
+		{
+			xFlags = xFlags & ~kAudioFormatFlagIsBigEndian;
+		}
+		if((y.mBitsPerChannel <= 8) && ((yFlags & kAudioFormatFlagIsPacked) == kAudioFormatFlagIsPacked))
+		{
+			yFlags = yFlags & ~kAudioFormatFlagIsBigEndian;
+		}
+		
+		//	if the number of channels is 1, we don't care about non-interleavedness
+		if (x.mChannelsPerFrame == 1 && y.mChannelsPerFrame == 1) {
+			xFlags &= ~kLinearPCMFormatFlagIsNonInterleaved;
+			yFlags &= ~kLinearPCMFormatFlagIsNonInterleaved;
+		}
+	}
+	return xFlags == yFlags;
+}
+
+bool	operator==(const AudioStreamBasicDescription& x, const AudioStreamBasicDescription& y)
+{
+	//	the semantics for equality are:
+	//		1) Values must match exactly -- except for PCM format flags, see above.
+	//		2) wildcard's are ignored in the comparison
+	
+#define MATCH(name) ((x.name) == 0 || (y.name) == 0 || (x.name) == (y.name))
+	
+	return 
+			//	check the sample rate
+		(fiszero(x.mSampleRate) || fiszero(y.mSampleRate) || fequal(x.mSampleRate, y.mSampleRate))
+		
+			//	check the format ids
+		&& MATCH(mFormatID)
+		
+			//	check the format flags
+		&& MatchFormatFlags(x, y)  
+			
+			//	check the bytes per packet
+		&& MATCH(mBytesPerPacket) 
+		
+			//	check the frames per packet
+		&& MATCH(mFramesPerPacket) 
+		
+			//	check the bytes per frame
+		&& MATCH(mBytesPerFrame) 
+		
+			//	check the channels per frame
+		&& MATCH(mChannelsPerFrame) 
+		
+			//	check the channels per frame
+		&& MATCH(mBitsPerChannel) ;
+}
+
+bool	CAStreamBasicDescription::IsEqual(const AudioStreamBasicDescription &other, bool interpretingWildcards) const
+{
+	if (interpretingWildcards)
+		return *this == other;
+	return memcmp(this, &other, offsetof(AudioStreamBasicDescription, mReserved)) == 0;
+}
+
+bool SanityCheck(const AudioStreamBasicDescription& x)
+{
+	// This function returns false if there are sufficiently insane values in any field.
+	// It is very conservative so even some very unlikely values will pass.
+	// This is just meant to catch the case where the data from a file is corrupted.
+	
+	return 
+		(x.mSampleRate >= 0.)	
+		&& (x.mSampleRate < 3e6)	// SACD sample rate is 2.8224 MHz
+		&& (x.mBytesPerPacket < 1000000)
+		&& (x.mFramesPerPacket < 1000000)
+		&& (x.mBytesPerFrame < 1000000)
+		&& (x.mChannelsPerFrame <= 1024)
+		&& (x.mBitsPerChannel <= 1024)
+		&& (x.mFormatID != 0)
+		&& !(x.mFormatID == kAudioFormatLinearPCM && (x.mFramesPerPacket != 1 || x.mBytesPerPacket != x.mBytesPerFrame));
+}
+
+bool CAStreamBasicDescription::FromText(const char *inTextDesc, AudioStreamBasicDescription &fmt)
+{
+	const char *p = inTextDesc;
+	
+	memset(&fmt, 0, sizeof(fmt));
+
+	bool isPCM = true;	// until proven otherwise
+	UInt32 pcmFlags = kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
+
+	if (p[0] == '-')	// previously we required a leading dash on PCM formats
+		++p;
+
+	if (p[0] == 'B' && p[1] == 'E') {
+		pcmFlags |= kLinearPCMFormatFlagIsBigEndian;
+		p += 2;
+	} else if (p[0] == 'L' && p[1] == 'E') {
+		p += 2;
+	} else {
+		// default is native-endian
+#if TARGET_RT_BIG_ENDIAN
+		pcmFlags |= kLinearPCMFormatFlagIsBigEndian;
+#endif
+	}
+	if (p[0] == 'F') {
+		pcmFlags = (pcmFlags & ~kAudioFormatFlagIsSignedInteger) | kAudioFormatFlagIsFloat;
+		++p;
+	} else {
+		if (p[0] == 'U') {
+			pcmFlags &= ~kAudioFormatFlagIsSignedInteger;
+			++p;
+		}
+		if (p[0] == 'I')
+			++p;
+		else {
+			// it's not PCM; presumably some other format (NOT VALIDATED; use AudioFormat for that)
+			isPCM = false;
+			p = inTextDesc;	// go back to the beginning
+			char buf[4] = { ' ',' ',' ',' ' };
+			for (int i = 0; i < 4; ++i) {
+				if (*p != '\\') {
+					if ((buf[i] = *p++) == '\0') {
+						// special-case for 'aac'
+						if (i != 3) return false;
+						--p;	// keep pointing at the terminating null
+						buf[i] = ' ';
+						break;
+					}
+				} else {
+					// "\xNN" is a hex byte
+					if (*++p != 'x') return false;
+					int x;
+					if (sscanf(++p, "%02X", &x) != 1) return false;
+					buf[i] = x;
+					p += 2;
+				}
+			}
+			
+			if (strchr("-@/#", buf[3])) {
+				// further special-casing for 'aac'
+				buf[3] = ' ';
+				--p;
+			}
+			
+			fmt.mFormatID = CFSwapInt32BigToHost(*(UInt32 *)buf);
+		}
+	}
+	
+	if (isPCM) {
+		fmt.mFormatID = kAudioFormatLinearPCM;
+		fmt.mFormatFlags = pcmFlags;
+		fmt.mFramesPerPacket = 1;
+		fmt.mChannelsPerFrame = 1;
+		int bitdepth = 0, fracbits = 0;
+		while (isdigit(*p))
+			bitdepth = 10 * bitdepth + *p++ - '0';
+		if (*p == '.') {
+			++p;
+			if (!isdigit(*p)) {
+				fprintf(stderr, "Expected fractional bits following '.'\n");
+				goto Bail;
+			}
+			while (isdigit(*p))
+				fracbits = 10 * fracbits + *p++ - '0';
+			bitdepth += fracbits;
+			fmt.mFormatFlags |= (fracbits << kLinearPCMFormatFlagsSampleFractionShift);
+		}
+		fmt.mBitsPerChannel = bitdepth;
+		fmt.mBytesPerPacket = fmt.mBytesPerFrame = (bitdepth + 7) / 8;
+		if (bitdepth & 7) {
+			// assume unpacked. (packed odd bit depths are describable but not supported in AudioConverter.)
+			fmt.mFormatFlags &= ~kLinearPCMFormatFlagIsPacked;
+			// alignment matters; default to high-aligned. use ':L_' for low.
+			fmt.mFormatFlags |= kLinearPCMFormatFlagIsAlignedHigh;
+		}
+	}
+	if (*p == '@') {
+		++p;
+		while (isdigit(*p))
+			fmt.mSampleRate = 10 * fmt.mSampleRate + (*p++ - '0');
+	}
+	if (*p == '/') {
+		UInt32 flags = 0;
+		while (true) {
+			char c = *++p;
+			if (c >= '0' && c <= '9')
+				flags = (flags << 4) | (c - '0');
+			else if (c >= 'A' && c <= 'F')
+				flags = (flags << 4) | (c - 'A' + 10);
+			else if (c >= 'a' && c <= 'f')
+				flags = (flags << 4) | (c - 'a' + 10);
+			else break;
+		}
+		fmt.mFormatFlags = flags;
+	}
+	if (*p == '#') {
+		++p;
+		while (isdigit(*p))
+			fmt.mFramesPerPacket = 10 * fmt.mFramesPerPacket + (*p++ - '0');
+	}
+	if (*p == ':') {
+		++p;
+		fmt.mFormatFlags &= ~kLinearPCMFormatFlagIsPacked;
+		if (*p == 'L')
+			fmt.mFormatFlags &= ~kLinearPCMFormatFlagIsAlignedHigh;
+		else if (*p == 'H')
+			fmt.mFormatFlags |= kLinearPCMFormatFlagIsAlignedHigh;
+		else
+			goto Bail;
+		++p;
+		int bytesPerFrame = 0;
+		while (isdigit(*p))
+			bytesPerFrame = 10 * bytesPerFrame + (*p++ - '0');
+		fmt.mBytesPerFrame = fmt.mBytesPerPacket = bytesPerFrame;
+	}
+	if (*p == ',') {
+		++p;
+		int ch = 0;
+		while (isdigit(*p))
+			ch = 10 * ch + (*p++ - '0');
+		fmt.mChannelsPerFrame = ch;
+		if (*p == 'D') {
+			++p;
+			if (fmt.mFormatID != kAudioFormatLinearPCM) {
+				fprintf(stderr, "non-interleaved flag invalid for non-PCM formats\n");
+				goto Bail;
+			}
+			fmt.mFormatFlags |= kAudioFormatFlagIsNonInterleaved;
+		} else {
+			if (*p == 'I') ++p;	// default
+			if (fmt.mFormatID == kAudioFormatLinearPCM)
+				fmt.mBytesPerPacket = fmt.mBytesPerFrame *= ch;
+		}
+	}
+	if (*p != '\0') {
+		fprintf(stderr, "extra characters at end of format string: %s\n", p);
+		goto Bail;
+	}
+	return true;
+
+Bail:
+	fprintf(stderr, "Invalid format string: %s\n", inTextDesc);
+	fprintf(stderr, "Syntax of format strings is: \n");
+	return false;
+}
+
+const char *CAStreamBasicDescription::sTextParsingUsageString = 
+	"format[@sample_rate_hz][/format_flags][#frames_per_packet][:LHbytesPerFrame][,channelsDI].\n"
+	"Format for PCM is [-][BE|LE]{F|I|UI}{bitdepth}; else a 4-char format code (e.g. aac, alac).\n";