自学教程：C++ CODEC_THROW函数代码示例

void ACFLACCodec::SetMagicCookie(const void* inMagicCookieData, UInt32 inMagicCookieDataByteSize){	if(mIsInitialized)	{		CODEC_THROW(kAudioCodecStateError);	}	if(inMagicCookieDataByteSize > 256) // the largest cookie we can store	{		CODEC_THROW(kAudioCodecBadPropertySizeError);	}	else // store the cookie	{		memcpy (mMagicCookie, (const void *)(inMagicCookieData), inMagicCookieDataByteSize);		mMagicCookieLength = inMagicCookieDataByteSize;		mCookieSet = 1;	}		ParseMagicCookie(inMagicCookieData, inMagicCookieDataByteSize, &mStreamInfo);		if (inMagicCookieDataByteSize > 0)	{		mCookieDefined = true;	}	else	{		mCookieDefined = false;	}}

void	ACAppleIMA4Encoder::SetCurrentInputFormat(const AudioStreamBasicDescription& inInputFormat){	if(!mIsInitialized)	{		//	check to make sure the input format is legal		if(	(inInputFormat.mFormatID != kAudioFormatLinearPCM) ||			(inInputFormat.mFormatFlags != (kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked)) ||			(inInputFormat.mBitsPerChannel != 16))		{	#if VERBOSE			DebugMessage("ACAppleIMA4Encoder::SetCurrentInputFormat: only support 16 bit native endian signed integer for input");	#endif			CODEC_THROW(kAudioCodecUnsupportedFormatError);		}				// Do some basic sanity checking		if(inInputFormat.mSampleRate < 0.0)		{	#if VERBOSE			DebugMessage("ACAppleIMA4Encoder::SetCurrentInputFormat: input sample rates may not be negative");	#endif			CODEC_THROW(kAudioCodecUnsupportedFormatError);		}				if(inInputFormat.mChannelsPerFrame > kMaxIMA4Channels)		{	#if VERBOSE			DebugMessage("ACAppleIMA4Encoder::SetCurrentInputFormat: only supports mono or stereo");	#endif			CODEC_THROW(kAudioCodecUnsupportedFormatError);		}				//	tell our base class about the new format		ACAppleIMA4Codec::SetCurrentInputFormat(inInputFormat);		// The encoder does no sample rate conversion nor channel manipulation		if (inInputFormat.mChannelsPerFrame == 0)		{			mInputFormat.mChannelsPerFrame = mOutputFormat.mChannelsPerFrame;		}		else		{			mOutputFormat.mChannelsPerFrame = mInputFormat.mChannelsPerFrame;		}		if (inInputFormat.mSampleRate == 0.0)		{			mInputFormat.mSampleRate = mOutputFormat.mSampleRate;		}		else		{			mOutputFormat.mSampleRate = mInputFormat.mSampleRate;		}		// Fix derived values		mInputFormat.mBytesPerFrame = mInputFormat.mBytesPerPacket = (mInputFormat.mBitsPerChannel >> 3) * mInputFormat.mChannelsPerFrame;		mInputFormat.mFramesPerPacket = 1;				// Zero out everything that has to be zero		mInputFormat.mReserved = 0;	}	else	{

void ACFLACCodec::SetProperty(AudioCodecPropertyID inPropertyID, UInt32 inPropertyDataSize, const void* inPropertyData){	switch(inPropertyID)	{        case kAudioCodecPropertyCurrentInputSampleRate:			if(mIsInitialized)			{				CODEC_THROW(kAudioCodecIllegalOperationError);			}			if(inPropertyDataSize == sizeof(Float64))			{				mInputFormat.mSampleRate = *((Float64*)inPropertyData);			}			else			{				CODEC_THROW(kAudioCodecBadPropertySizeError);			}			break;		case kAudioCodecPropertyFormatInfo:		case kAudioCodecPropertyHasVariablePacketByteSizes:		case kAudioCodecPropertyCurrentOutputSampleRate:		case kAudioCodecPropertyAvailableInputChannelLayouts:		case kAudioCodecPropertyAvailableOutputChannelLayouts:		case kAudioCodecPropertyPacketFrameSize:		case kAudioCodecPropertyMaximumPacketByteSize:			CODEC_THROW(kAudioCodecIllegalOperationError);			break;		default:			ACBaseCodec::SetProperty(inPropertyID, inPropertyDataSize, inPropertyData);			break;            	}}

void	ACSimpleCodec::AppendInputData(const void* inInputData, UInt32& ioInputDataByteSize, UInt32& ioNumberPackets, const AudioStreamPacketDescription* inPacketDescription){	//	this buffer handling code doesn't care about such things as the packet descriptions	if(!mIsInitialized) CODEC_THROW(kAudioCodecStateError);		//	this is a ring buffer we're dealing with, so we need to set up a few things	UInt32 theUsedByteSize = GetUsedInputBufferByteSize();	UInt32 theAvailableByteSize = GetInputBufferByteSize() - theUsedByteSize;	UInt32 theMaxAvailableInputBytes = ioInputDataByteSize; // we can't consume more than we get	const Byte* theInputData = static_cast<const Byte*>(inInputData);		// >>jamesmcc: added this because ioNumberPackets was not being updated if less was taken than given.	// THIS ASSUMES CBR!	UInt32 bytesPerPacketOfInput = mInputFormat.mBytesPerPacket;	UInt32 theAvailablePacketSize = theAvailableByteSize / bytesPerPacketOfInput;		UInt32 minPacketSize = ioNumberPackets < theAvailablePacketSize ? ioNumberPackets : theAvailablePacketSize;	UInt32 minByteSize = minPacketSize * bytesPerPacketOfInput;		//	we can copy only as much data as there is or up to how much space is availiable	ioNumberPackets = minPacketSize;	ioInputDataByteSize = minByteSize;		// ioInputDataByteSize had better be <= to theMaxAvailableInputBytes or we're screwed	if (ioInputDataByteSize > theMaxAvailableInputBytes)	{		CODEC_THROW(kAudioCodecStateError);	}	// <<jamesmcc 		//	now we have to copy the data taking into account the wrap around and where the start is	if(mInputBufferEnd + ioInputDataByteSize < mInputBufferByteSize)	{		//	no wrap around here		memcpy(mInputBuffer + mInputBufferEnd, theInputData, ioInputDataByteSize);				//	adjust the end point		mInputBufferEnd += ioInputDataByteSize;	}	else	{		//	the copy will wrap				//	copy the first part		UInt32 theBeforeWrapByteSize = mInputBufferByteSize - mInputBufferEnd;		memcpy(mInputBuffer + mInputBufferEnd, theInputData, theBeforeWrapByteSize);				//	and the rest		UInt32 theAfterWrapByteSize = ioInputDataByteSize - theBeforeWrapByteSize;		memcpy(mInputBuffer, theInputData + theBeforeWrapByteSize, theAfterWrapByteSize);				//	adjust the end point		mInputBufferEnd = theAfterWrapByteSize;	}	}

void CAOggFLACDecoder::SetCurrentInputFormat(const AudioStreamBasicDescription& inInputFormat){    if (!mIsInitialized) {        if (inInputFormat.mFormatID != kAudioFormatXiphOggFramedFLAC) {            dbg_printf("CAOggFLACDecoder::SetFormats: only support Xiph FLAC (Ogg-framed) for input/n");            CODEC_THROW(kAudioCodecUnsupportedFormatError);        }        XCACodec::SetCurrentInputFormat(inInputFormat);    } else {        CODEC_THROW(kAudioCodecStateError);    }}

void	ACShepA52Codec::GetProperty(AudioCodecPropertyID inPropertyID, UInt32& ioPropertyDataSize, void* outPropertyData) {    switch(inPropertyID) {    case kAudioCodecPropertyManufacturerCFString:    {        if (ioPropertyDataSize != sizeof(CFStringRef)) {            CODEC_THROW(kAudioCodecBadPropertySizeError);        }        CFStringRef name = CFCopyLocalizedStringFromTableInBundle(CFSTR("Shepmaster Productions"), CFSTR("CodecNames"), GetCodecBundle(), CFSTR(""));        *(CFStringRef*)outPropertyData = name;        break;    }    case kAudioCodecPropertyMaximumPacketByteSize:        if(ioPropertyDataSize == sizeof(UInt32)) {            *reinterpret_cast<UInt32*>(outPropertyData) = 3840; //Stolen from liba52 docs        } else {            CODEC_THROW(kAudioCodecBadPropertySizeError);        }        break;    case kAudioCodecPropertyRequiresPacketDescription:        if(ioPropertyDataSize == sizeof(UInt32)) {            *reinterpret_cast<UInt32*>(outPropertyData) = 0;        } else {            CODEC_THROW(kAudioCodecBadPropertySizeError);        }        break;    case kAudioCodecPropertyHasVariablePacketByteSizes:        if(ioPropertyDataSize == sizeof(UInt32)) {            *reinterpret_cast<UInt32*>(outPropertyData) = 1;        } else {            CODEC_THROW(kAudioCodecBadPropertySizeError);        }        break;    case kAudioCodecPropertyPacketFrameSize:        if(ioPropertyDataSize == sizeof(UInt32)) {            *reinterpret_cast<UInt32*>(outPropertyData) = 6 * 256; // A frame has 6 blocks of 256 samples        } else {            CODEC_THROW(kAudioCodecBadPropertySizeError);        }        break;    default:        ACSimpleCodec::GetProperty(inPropertyID, ioPropertyDataSize, outPropertyData);    }}

void CASpeexDecoder::SetMagicCookie(const void* inMagicCookieData, UInt32 inMagicCookieDataByteSize){    dbg_printf(" >> [%08lx] CASpeexDecoder :: SetMagicCookie()/n", (UInt32) this);    if (mIsInitialized)        CODEC_THROW(kAudioCodecStateError);    SetCookie(inMagicCookieData, inMagicCookieDataByteSize);    InitializeCompressionSettings();    if (!mCompressionInitialized)        CODEC_THROW(kAudioCodecUnsupportedFormatError);    dbg_printf("<.. [%08lx] CASpeexDecoder :: SetMagicCookie()/n", (UInt32) this);}

void	ACSimpleCodec::ConsumeInputData(UInt32 inConsumedByteSize){	//	this is a convenience routine to make maintaining the ring buffer state easy	UInt32 theContiguousRange = GetInputBufferContiguousByteSize();		if(inConsumedByteSize > GetUsedInputBufferByteSize()) CODEC_THROW(kAudioCodecUnspecifiedError);		if(inConsumedByteSize <= theContiguousRange)	{		//	the region to consume doesn't wrap				//	figure out how much to consume		inConsumedByteSize = (theContiguousRange < inConsumedByteSize) ? theContiguousRange : inConsumedByteSize;				//	clear the consumed bits		memset(mInputBuffer + mInputBufferStart, 0, inConsumedByteSize);				//	adjust the start		mInputBufferStart += inConsumedByteSize;	}	else	{		//	the region to consume will wrap				//	clear the bits to the end of the buffer		memset(mInputBuffer + mInputBufferStart, 0, theContiguousRange);				//	now clear the bits left from the start		memset(mInputBuffer, 0, inConsumedByteSize - theContiguousRange);				//	adjust the start		mInputBufferStart = inConsumedByteSize - theContiguousRange;	}}

void	ACBaseCodec::SetMagicCookie(const void* outMagicCookieData, UInt32 inMagicCookieDataByteSize){	if(mIsInitialized)	{		CODEC_THROW(kAudioCodecStateError);	}}

void	ACShepA52Codec::Initialize(const AudioStreamBasicDescription* inInputFormat,                                   const AudioStreamBasicDescription* inOutputFormat,                                   const void* inMagicCookie, UInt32 inMagicCookieByteSize) {    //	use the given arguments, if necessary    if(inInputFormat != NULL)    {        SetCurrentInputFormat(*inInputFormat);    }    if(inOutputFormat != NULL)    {        SetCurrentOutputFormat(*inOutputFormat);    }    //	make sure the sample rate and number of channels match between the input format and the output format    if( (mInputFormat.mSampleRate != mOutputFormat.mSampleRate))    {        CODEC_THROW(kAudioCodecUnsupportedFormatError);    }    ACSimpleCodec::Initialize(inInputFormat, inOutputFormat, inMagicCookie, inMagicCookieByteSize);}

void	ACFLACCodec::Initialize(const AudioStreamBasicDescription* inInputFormat, const AudioStreamBasicDescription* inOutputFormat, const void* inMagicCookie, UInt32 inMagicCookieByteSize){	//	use the given arguments, if necessary	if(inInputFormat != NULL)	{		SetCurrentInputFormat(*inInputFormat);	}	if(inOutputFormat != NULL)	{		SetCurrentOutputFormat(*inOutputFormat);	}		//	make sure the sample rate and number of channels match between the input format and the output format	if( (mInputFormat.mSampleRate != mOutputFormat.mSampleRate) ||		(mInputFormat.mChannelsPerFrame != mOutputFormat.mChannelsPerFrame))	{#if VERBOSE			printf("The channels and sample rates don't match, mInputFormat.mSampleRate == %f, mOutputFormat.mSampleRate == %f, mInputFormat.mChannelsPerFrame == %lu, mOutputFormat.mChannelsPerFrame == %lu/n", 				mInputFormat.mSampleRate, mOutputFormat.mSampleRate, mInputFormat.mChannelsPerFrame, mOutputFormat.mChannelsPerFrame);#endif		CODEC_THROW(kAudioCodecUnsupportedFormatError);	}		if(inMagicCookie != NULL)	{		SetMagicCookie(inMagicCookie, inMagicCookieByteSize);	}	ACBaseCodec::Initialize(inInputFormat, inOutputFormat, inMagicCookie, inMagicCookieByteSize);}

void	ACSimpleCodec::Initialize(const AudioStreamBasicDescription* inInputFormat, const AudioStreamBasicDescription* inOutputFormat, const void* inMagicCookie, UInt32 inMagicCookieByteSize){	ReallocateInputBuffer(mInputBufferByteSize - kBufferPad);	// By definition CBR has this greater than 0. We must avoid a div by 0 error in AppendInputData()	// Note this will cause us to fail initialization which is intended	if (mInputFormat.mBytesPerPacket == 0)	{		CODEC_THROW(kAudioCodecUnsupportedFormatError);	}			ACBaseCodec::Initialize(inInputFormat, inOutputFormat, inMagicCookie, inMagicCookieByteSize);}

void CAOggFLACDecoder::InPacket(const void* inInputData, const AudioStreamPacketDescription* inPacketDescription){    if (!mCompressionInitialized)        CODEC_THROW(kAudioCodecUnspecifiedError);    ogg_page op;    if (!WrapOggPage(&op, inInputData, inPacketDescription->mDataByteSize + inPacketDescription->mStartOffset, inPacketDescription->mStartOffset))        CODEC_THROW(kAudioCodecUnspecifiedError);    dbg_printf("[ oFD]   : [%08lx] InPacket() [%4.4s] %ld/n", (UInt32) this, (char *) (static_cast<const Byte*> (inInputData) + inPacketDescription->mStartOffset),               ogg_page_pageno(&op));    ogg_packet opk;    SInt32 packet_count = 0;    int oret;    AudioStreamPacketDescription flac_packet_desc = {0, 0, 0};    UInt32 page_packets = ogg_page_packets(&op);    ogg_stream_pagein(&mO_st, &op);    while ((oret = ogg_stream_packetout(&mO_st, &opk)) != 0) {        if (oret < 0) {            page_packets--;            continue;        }        packet_count++;        flac_packet_desc.mDataByteSize = opk.bytes;        CAFLACDecoder::InPacket(opk.packet, &flac_packet_desc);    }    if (packet_count > 0)        complete_pages += 1;    mFramesBufferedList.push_back(OggPagePacket(packet_count, inPacketDescription->mVariableFramesInPacket));}

void ACAppleIMA4Encoder::SetProperty(AudioCodecPropertyID inPropertyID, UInt32 inPropertyDataSize, const void* inPropertyData){	switch(inPropertyID)	{		case kAudioCodecPropertyAvailableInputSampleRates:		case kAudioCodecPropertyAvailableOutputSampleRates:		case kAudioCodecPropertyZeroFramesPadded:		case kAudioCodecPropertyPrimeInfo:			CODEC_THROW(kAudioCodecIllegalOperationError);			break;		default:			ACAppleIMA4Codec::SetProperty(inPropertyID, inPropertyDataSize, inPropertyData);			break;            	}}

void	ACSimpleCodec::SetProperty(AudioCodecPropertyID inPropertyID, UInt32 inPropertyDataSize, const void* inPropertyData){	switch(inPropertyID)	{		case kAudioCodecPropertyInputBufferSize:			if(inPropertyDataSize == sizeof(UInt32))			{				ReallocateInputBuffer(*reinterpret_cast<const UInt32*>(inPropertyData));			}			else			{				CODEC_THROW(kAudioCodecBadPropertySizeError);			}			break;		default:            ACBaseCodec::SetProperty(inPropertyID, inPropertyDataSize, inPropertyData);            break;                }}

void	ACSimpleCodec::AppendInputBuffer(const void* inInputData, UInt32 inOffset, UInt32& ioInputDataByteSize){	//	this buffer handling code doesn't care about such things as the packet descriptions	if(!mIsInitialized) CODEC_THROW(kAudioCodecStateError);		//	this is a ring buffer we're dealing with, so we need to set up a few things	UInt32 theUsedByteSize = GetUsedInputBufferByteSize();	UInt32 theAvailableByteSize = GetInputBufferByteSize() - theUsedByteSize;		const Byte* theInputData = static_cast<const Byte*>(inInputData) + inOffset;		if(ioInputDataByteSize > theAvailableByteSize) {		ioInputDataByteSize = theAvailableByteSize;	}		//	now we have to copy the data taking into account the wrap around and where the start is	if(mInputBufferEnd + ioInputDataByteSize < mInputBufferByteSize)	{		//	no wrap around here		memcpy(mInputBuffer + mInputBufferEnd, theInputData, ioInputDataByteSize);				//	adjust the end point		mInputBufferEnd += ioInputDataByteSize;	}	else	{		//	the copy will wrap				//	copy the first part		UInt32 theBeforeWrapByteSize = mInputBufferByteSize - mInputBufferEnd;		memcpy(mInputBuffer + mInputBufferEnd, theInputData, theBeforeWrapByteSize);				//	and the rest		UInt32 theAfterWrapByteSize = ioInputDataByteSize - theBeforeWrapByteSize;		memcpy(mInputBuffer, theInputData + theBeforeWrapByteSize, theAfterWrapByteSize);				//	adjust the end point		mInputBufferEnd = theAfterWrapByteSize;	}}

Byte* ACSimpleCodec::GetBytes(UInt32& ioNumberBytes) const{	// if a client's algorithm has to have contiguous data and mInputBuffer wraps, then someone has to make a copy.	// I can do it more efficiently than the client. 		if(!mIsInitialized) CODEC_THROW(kAudioCodecStateError);	UInt32 theUsedByteSize = GetUsedInputBufferByteSize();	//UInt32 theAvailableByteSize = GetInputBufferByteSize() - theUsedByteSize;		if (ioNumberBytes > theUsedByteSize) ioNumberBytes = theUsedByteSize;			SInt32 leftOver = mInputBufferStart + ioNumberBytes - mInputBufferByteSize;		if(leftOver > 0)	{		// need to copy beginning of buffer to the end. 		// We cleverly over allocated our buffer space to make this possible.		memmove(mInputBuffer + mInputBufferByteSize, mInputBuffer, leftOver);	}		return GetInputBufferStart();}

void	ACBaseCodec::GetPropertyInfo(AudioCodecPropertyID inPropertyID, UInt32& outPropertyDataSize, Boolean& outWritable){	switch(inPropertyID)	{		case kAudioCodecPropertyNameCFString:			outPropertyDataSize = SizeOf32(CFStringRef);			outWritable = false;			break;					case kAudioCodecPropertyManufacturerCFString:			outPropertyDataSize = SizeOf32(CFStringRef);			outWritable = false;			break;					case kAudioCodecPropertyFormatCFString:			outPropertyDataSize = SizeOf32(CFStringRef);			outWritable = false;			break;		case kAudioCodecPropertyRequiresPacketDescription:			outPropertyDataSize = SizeOf32(UInt32);			outWritable = false;			break;					case kAudioCodecPropertyMinimumNumberInputPackets :			outPropertyDataSize = SizeOf32(UInt32);			outWritable = false;			break;					case kAudioCodecPropertyMinimumNumberOutputPackets :			outPropertyDataSize = SizeOf32(UInt32);			outWritable = false;			break;		case kAudioCodecPropertyCurrentInputFormat:			outPropertyDataSize = SizeOf32(AudioStreamBasicDescription);			outWritable = true;			break;					case kAudioCodecPropertySupportedInputFormats:		case kAudioCodecPropertyInputFormatsForOutputFormat:			outPropertyDataSize = GetNumberSupportedInputFormats() * SizeOf32(AudioStreamBasicDescription);			outWritable = false;			break;					case kAudioCodecPropertyCurrentOutputFormat:			outPropertyDataSize = SizeOf32(AudioStreamBasicDescription);			outWritable = true;			break;					case kAudioCodecPropertySupportedOutputFormats:		case kAudioCodecPropertyOutputFormatsForInputFormat:			outPropertyDataSize = GetNumberSupportedOutputFormats() * SizeOf32(AudioStreamBasicDescription);			outWritable = false;			break;					case kAudioCodecPropertyMagicCookie:			outPropertyDataSize = GetMagicCookieByteSize();			outWritable = true;			break;					case kAudioCodecPropertyInputBufferSize:			outPropertyDataSize = SizeOf32(UInt32);			outWritable = false;			break;					case kAudioCodecPropertyUsedInputBufferSize:			outPropertyDataSize = SizeOf32(UInt32);			outWritable = false;			break;				case kAudioCodecPropertyIsInitialized:			outPropertyDataSize = SizeOf32(UInt32);			outWritable = false;			break;		case kAudioCodecPropertyAvailableNumberChannels:			outPropertyDataSize = SizeOf32(UInt32) * 2; // Mono, stereo			outWritable = false;			break;			 		case kAudioCodecPropertyPrimeMethod:			outPropertyDataSize = SizeOf32(UInt32);			outWritable = false;			break; 		case kAudioCodecPropertyPrimeInfo:			outPropertyDataSize = SizeOf32(AudioCodecPrimeInfo);			outWritable = false;			break; 		case kAudioCodecPropertyDoesSampleRateConversion:			outPropertyDataSize = SizeOf32(UInt32);			outWritable = false;			break;		default:			CODEC_THROW(kAudioCodecUnknownPropertyError);			break;				};//.........这里部分代码省略.........

void CASpeexDecoder::InitializeCompressionSettings(){    if (mCookie == NULL)        return;    if (mCompressionInitialized) {        memset(&mSpeexHeader, 0, sizeof(mSpeexHeader));        mSpeexStereoState.balance = 1.0;        mSpeexStereoState.e_ratio = 0.5;        mSpeexStereoState.smooth_left = 1.0;        mSpeexStereoState.smooth_right = 1.0;        if (mSpeexDecoderState != NULL) {            speex_decoder_destroy(mSpeexDecoderState);            mSpeexDecoderState = NULL;        }    }    mCompressionInitialized = false;    OggSerialNoAtom *atom = reinterpret_cast<OggSerialNoAtom*> (mCookie);    Byte *ptrheader = mCookie + EndianU32_BtoN(atom->size);    CookieAtomHeader *aheader = reinterpret_cast<CookieAtomHeader*> (ptrheader);    // scan quickly through the cookie, check types and packet sizes    if (EndianS32_BtoN(atom->type) != kCookieTypeOggSerialNo || static_cast<UInt32> (ptrheader - mCookie) > mCookieSize)        return;    ptrheader += EndianU32_BtoN(aheader->size);    if (EndianS32_BtoN(aheader->type) != kCookieTypeSpeexHeader || static_cast<UInt32> (ptrheader - mCookie) > mCookieSize)        return;    // we ignore the rest: comments and extra headers    // all OK, back to the first speex packet    aheader = reinterpret_cast<CookieAtomHeader*> (mCookie + EndianU32_BtoN(atom->size));    SpeexHeader *inheader = reinterpret_cast<SpeexHeader *> (&aheader->data[0]);    // TODO: convert, at some point, mSpeexHeader to a pointer?    mSpeexHeader.bitrate =                 EndianS32_LtoN(inheader->bitrate);    mSpeexHeader.extra_headers =           EndianS32_LtoN(inheader->extra_headers);    mSpeexHeader.frame_size =              EndianS32_LtoN(inheader->frame_size);    mSpeexHeader.frames_per_packet =       EndianS32_LtoN(inheader->frames_per_packet);    mSpeexHeader.header_size =             EndianS32_LtoN(inheader->header_size);    mSpeexHeader.mode =                    EndianS32_LtoN(inheader->mode);    mSpeexHeader.mode_bitstream_version =  EndianS32_LtoN(inheader->mode_bitstream_version);    mSpeexHeader.nb_channels =             EndianS32_LtoN(inheader->nb_channels);    mSpeexHeader.rate =                    EndianS32_LtoN(inheader->rate);    mSpeexHeader.reserved1 =               EndianS32_LtoN(inheader->reserved1);    mSpeexHeader.reserved2 =               EndianS32_LtoN(inheader->reserved2);    mSpeexHeader.speex_version_id =        EndianS32_LtoN(inheader->speex_version_id);    mSpeexHeader.vbr =                     EndianS32_LtoN(inheader->vbr);    if (mSpeexHeader.mode >= SPEEX_NB_MODES)        CODEC_THROW(kAudioCodecUnsupportedFormatError);    //TODO: check bitstream version here    mSpeexDecoderState = speex_decoder_init(speex_lib_get_mode(mSpeexHeader.mode));    if (!mSpeexDecoderState)        CODEC_THROW(kAudioCodecUnsupportedFormatError);    //TODO: fix some of the header fields here    int enhzero = 0;    speex_decoder_ctl(mSpeexDecoderState, SPEEX_SET_ENH, &enhzero);    if (mSpeexHeader.nb_channels == 2)    {        SpeexCallback callback;        callback.callback_id = SPEEX_INBAND_STEREO;        callback.func = speex_std_stereo_request_handler;        callback.data = &mSpeexStereoState;        speex_decoder_ctl(mSpeexDecoderState, SPEEX_SET_HANDLER, &callback);    }    mCompressionInitialized = true;}

//FLAC__StreamMetadata_StreamInfovoid ACFLACCodec::GetMagicCookie(void* outMagicCookieData, UInt32& ioMagicCookieDataByteSize) const{	Byte *						buffer;	Byte *						currPtr;	AudioFormatAtom * frmaAtom;	FullAtomHeader * flacAtom;	AudioTerminatorAtom * termAtom;	SInt32						atomSize;	UInt32						flacSize;	UInt32						chanSize;	UInt32						frmaSize;	UInt32						termSize;	FLAC__StreamMetadata_StreamInfo *		config;	OSStatus					status;	UInt32						tempMaxFrameBytes;		//RequireAction( sampleDesc != nil, return paramErr; );	config		= nil;		frmaSize = sizeof(AudioFormatAtom);	flacSize		= sizeof(FullAtomHeader) + sizeof(FLAC__StreamMetadata_StreamInfo);	chanSize		= 0;	termSize = sizeof(AudioTerminatorAtom);	// if we're encoding more than two channels, add an AudioChannelLayout atom to describe the layout	if ( mOutputFormat.mChannelsPerFrame > 2 )	{		chanSize = sizeof(FullAtomHeader) + offsetof(AudioChannelLayout, mChannelDescriptions);	}	// create buffer of the required size	atomSize = frmaSize + flacSize + chanSize + termSize;		// Someone might have a stereo/mono cookie while we're trying to do surround.	if ((UInt32)atomSize > ioMagicCookieDataByteSize)	{		CODEC_THROW(kAudioCodecBadPropertySizeError);	}		tempMaxFrameBytes = kInputBufferPackets * mOutputFormat.mChannelsPerFrame * ((10 + kMaxSampleSize) / 8) + 1;	buffer = (Byte *)calloc( atomSize, 1 );	currPtr = buffer;	// fill in the atom stuff	frmaAtom = (AudioFormatAtom *) currPtr;	frmaAtom->size			= EndianU32_NtoB( frmaSize );	frmaAtom->atomType		= EndianU32_NtoB( kAudioFormatAtomType );	frmaAtom->format	= EndianU32_NtoB( 'flac' );	currPtr += frmaSize;	// fill in the FLAC config	flacAtom = (FullAtomHeader *) currPtr;	flacAtom->size				= EndianU32_NtoB( flacSize );	flacAtom->type				= EndianU32_NtoB( 'flac' );	flacAtom->versionFlags		= 0;	currPtr += sizeof(FullAtomHeader);/*	unsigned min_blocksize, max_blocksize;	unsigned min_framesize, max_framesize;	unsigned sample_rate;	unsigned channels;	unsigned bits_per_sample;	FLAC__uint64 total_samples;	FLAC__byte md5sum[16];*/	config = (FLAC__StreamMetadata_StreamInfo *) currPtr;	if (mCookieDefined)	{		config->min_blocksize	= EndianU32_NtoB( mStreamInfo.min_blocksize );		config->max_blocksize	= EndianU32_NtoB( mStreamInfo.max_blocksize );		config->min_framesize	= EndianU32_NtoB( mStreamInfo.min_framesize );		config->max_framesize	= EndianU32_NtoB( mStreamInfo.max_framesize );		config->sample_rate		= EndianU32_NtoB( mStreamInfo.sample_rate );		config->channels		= EndianU32_NtoB( mStreamInfo.channels );		config->bits_per_sample	= EndianU32_NtoB( mStreamInfo.bits_per_sample );		config->total_samples	= EndianU64_NtoB( mStreamInfo.total_samples );		config->md5sum[0]		= mStreamInfo.md5sum[0];		config->md5sum[1]		= mStreamInfo.md5sum[1];		config->md5sum[2]		= mStreamInfo.md5sum[2];		config->md5sum[3]		= mStreamInfo.md5sum[3];		config->md5sum[4]		= mStreamInfo.md5sum[4];		config->md5sum[5]		= mStreamInfo.md5sum[5];		config->md5sum[6]		= mStreamInfo.md5sum[6];		config->md5sum[7]		= mStreamInfo.md5sum[7];		config->md5sum[8]		= mStreamInfo.md5sum[8];		config->md5sum[9]		= mStreamInfo.md5sum[9];		config->md5sum[10]		= mStreamInfo.md5sum[10];		config->md5sum[11]		= mStreamInfo.md5sum[11];		config->md5sum[12]		= mStreamInfo.md5sum[12];		config->md5sum[13]		= mStreamInfo.md5sum[13];		config->md5sum[14]		= mStreamInfo.md5sum[14];		config->md5sum[15]		= mStreamInfo.md5sum[15];	}	else	{//.........这里部分代码省略.........

void	ACFLACEncoder::GetProperty(AudioCodecPropertyID inPropertyID, UInt32& ioPropertyDataSize, void* outPropertyData){	switch(inPropertyID)	{		case kAudioCodecPropertyNameCFString:		{			if (ioPropertyDataSize != sizeof(CFStringRef))			{				CODEC_THROW(kAudioCodecBadPropertySizeError);			}			CABundleLocker lock;			CFStringRef name = CFCopyLocalizedStringFromTableInBundle(CFSTR("FLAC encoder"), CFSTR("CodecNames"), GetCodecBundle(), CFSTR(""));			*(CFStringRef*)outPropertyData = name;			break; 		}				case kAudioCodecPropertyAvailableNumberChannels:  			if(ioPropertyDataSize == sizeof(UInt32) * kFLACNumberSupportedChannelTotals)			{				memcpy(reinterpret_cast<UInt32*>(outPropertyData), mSupportedChannelTotals, ioPropertyDataSize);			}			else			{				CODEC_THROW(kAudioCodecBadPropertySizeError);			}			break;		case kAudioCodecPropertyAvailableInputSampleRates:  			if(ioPropertyDataSize == sizeof(AudioValueRange) )			{				(reinterpret_cast<AudioValueRange*>(outPropertyData))->mMinimum = 0.0;				(reinterpret_cast<AudioValueRange*>(outPropertyData))->mMaximum = 0.0;			}			else			{				CODEC_THROW(kAudioCodecBadPropertySizeError);			}			break;		case kAudioCodecPropertyAvailableOutputSampleRates:  			if(ioPropertyDataSize == sizeof(AudioValueRange) )			{				(reinterpret_cast<AudioValueRange*>(outPropertyData))->mMinimum = 0.0;				(reinterpret_cast<AudioValueRange*>(outPropertyData))->mMaximum = 0.0;			}			else			{				CODEC_THROW(kAudioCodecBadPropertySizeError);			}			break;        case kAudioCodecPropertyPrimeMethod:  			if(ioPropertyDataSize == sizeof(UInt32))			{				*reinterpret_cast<UInt32*>(outPropertyData) = (UInt32)kAudioCodecPrimeMethod_None;			}			else			{				CODEC_THROW(kAudioCodecBadPropertySizeError);			}			break;		case kAudioCodecPropertyPrimeInfo:  			if(ioPropertyDataSize == sizeof(AudioCodecPrimeInfo) )			{				(reinterpret_cast<AudioCodecPrimeInfo*>(outPropertyData))->leadingFrames = 0;				(reinterpret_cast<AudioCodecPrimeInfo*>(outPropertyData))->trailingFrames = mTrailingFrames;			}			else			{				CODEC_THROW(kAudioCodecBadPropertySizeError);			}			break;        case kAudioCodecPropertyQualitySetting:  			if(ioPropertyDataSize == sizeof(UInt32))			{                *reinterpret_cast<UInt32*>(outPropertyData) = mQuality;			}			else			{				CODEC_THROW(kAudioCodecBadPropertySizeError);			}			break;       case kAudioCodecPropertyMaximumPacketByteSize:			if(ioPropertyDataSize == sizeof(UInt32))			{				if (mMaxFrameBytes)				{					*reinterpret_cast<UInt32*>(outPropertyData) = mMaxFrameBytes;				}				else // default case				{					*reinterpret_cast<UInt32*>(outPropertyData) = mMaxFrameBytes = kInputBufferPackets * mOutputFormat.mChannelsPerFrame * (mBitDepth >> 3) + kMaxEscapeHeaderBytes;				}			#if VERBOSE				printf("Max packet size == %lu, mBitDepth == %lu/n", mMaxFrameBytes, mBitDepth);			#endif			}//.........这里部分代码省略.........