OSStatus ACCodec::ComponentEntryDispatch(ComponentParameters *inParameters, ACCodec *inThis) { OSStatus theError = kAudioCodecNoError; try { switch (inParameters->what) { // these selectors don't use the object pointer case kComponentOpenSelect: case kComponentCloseSelect: theError = ComponentBase::ComponentEntryDispatch(inParameters, inThis); break; case kComponentCanDoSelect: { switch (GetSelectorForCanDo(inParameters)) { case kAudioCodecGetPropertyInfoSelect: case kAudioCodecGetPropertySelect: case kAudioCodecSetPropertySelect: case kAudioCodecInitializeSelect: case kAudioCodecUninitializeSelect: // was missing -- why? case kAudioCodecAppendInputDataSelect: case kAudioCodecProduceOutputDataSelect: case kAudioCodecResetSelect: theError = 1; break; default: theError = ComponentBase::ComponentEntryDispatch(inParameters, inThis); break; } } break; default: // these selectors use the object pointer if(inThis != NULL) { switch (inParameters->what) { case kComponentVersionSelect: theError = inThis->Version(); break; case kAudioCodecGetPropertyInfoSelect: { PARAM(AudioCodecPropertyID, inPropertyID, 0, 3); PARAM(UInt32 *, outSize, 1, 3); PARAM(Boolean *, outWritable, 2, 3); UInt32 theSize = 0; Boolean isWritable = false; inThis->GetPropertyInfo(inPropertyID, theSize, isWritable); if(outSize != NULL) { *outSize = theSize; } if(outWritable != NULL) { *outWritable = isWritable ? 1 : 0; } } break; case kAudioCodecGetPropertySelect: { PARAM(AudioCodecPropertyID, inPropertyID, 0, 3); PARAM(UInt32 *, ioPropertyDataSize, 1, 3); PARAM(void *, outPropertyData, 2, 3); if((ioPropertyDataSize != NULL) && (outPropertyData != NULL)) { inThis->GetProperty(inPropertyID, *ioPropertyDataSize, outPropertyData); } else { theError = kAudio_ParamError; } } break; case kAudioCodecSetPropertySelect: { PARAM(AudioCodecPropertyID, inPropertyID, 0, 3); PARAM(UInt32, inPropertyDataSize, 1, 3); PARAM(const void *, inPropertyData, 2, 3); if(inPropertyData != NULL) { inThis->SetProperty(inPropertyID, inPropertyDataSize, inPropertyData); } else { theError = kAudio_ParamError; } } break; case kAudioCodecInitializeSelect: { PARAM(const AudioStreamBasicDescription *, inInputFormat, 0, 4); PARAM(const AudioStreamBasicDescription *, inOutputFormat, 1, 4); PARAM(const void *, inMagicCookie, 2, 4); PARAM(UInt32, inMagicCookieByteSize, 3, 4); inThis->Initialize(inInputFormat, inOutputFormat, inMagicCookie, inMagicCookieByteSize); } break; case kAudioCodecUninitializeSelect: { inThis->Uninitialize(); } break; case kAudioCodecAppendInputDataSelect: { PARAM(const void *, inInputData, 0, 4); PARAM(UInt32 *, ioInputDataByteSize, 1, 4); PARAM(UInt32 *, ioNumberPackets, 2, 4); PARAM(const AudioStreamPacketDescription *, inPacketDescription, 3, 4); if((inInputData != NULL) && (ioInputDataByteSize != NULL)) { if(ioNumberPackets != NULL) { inThis->AppendInputData(inInputData, *ioInputDataByteSize, *ioNumberPackets, inPacketDescription); } else { UInt32 theNumberPackets = 0; inThis->AppendInputData(inInputData, *ioInputDataByteSize, theNumberPackets, inPacketDescription); } } else { theError = kAudio_ParamError; } } break; case kAudioCodecProduceOutputDataSelect: { PARAM(void *, outOutputData, 0, 5); PARAM(UInt32 *, ioOutputDataByteSize, 1, 5); PARAM(UInt32 *, ioNumberPackets, 2, 5); PARAM(AudioStreamPacketDescription *, outPacketDescription, 3, 5); PARAM(UInt32 *, outStatus, 4, 5); if((outOutputData != NULL) && (ioOutputDataByteSize != NULL) && (ioNumberPackets != NULL) && (outStatus != NULL)) { *outStatus = inThis->ProduceOutputPackets(outOutputData, *ioOutputDataByteSize, *ioNumberPackets, outPacketDescription); if(kAudioCodecProduceOutputPacketFailure == *outStatus) { theError = kAudio_ParamError; } } else { theError = kAudio_ParamError; } } break; #if AC_NON_INTERLEAVED_SUPPORT case kAudioCodecAppendInputBufferListSelect: { PARAM(const AudioBufferList *, inBufferList, 0, 4); PARAM(UInt32 *, ioNumberPackets, 1, 4); PARAM(const AudioStreamPacketDescription *, inPacketDescription, 2, 4); PARAM(UInt32 *, outBytesConsumed, 3, 4); if((inBufferList != NULL) && (outBytesConsumed != NULL)) { if(ioNumberPackets != NULL) { inThis->AppendInputBufferList(inBufferList, *ioNumberPackets, inPacketDescription, outBytesConsumed); } else { UInt32 theNumberPackets = 0; inThis->AppendInputBufferList(inBufferList, theNumberPackets, inPacketDescription, outBytesConsumed); } } else { theError = kAudio_ParamError; } } break; case kAudioCodecProduceOutputBufferListSelect: { PARAM(AudioBufferList *, ioBufferList, 0, 4); PARAM(UInt32 *, ioNumberPackets, 1, 4); PARAM(AudioStreamPacketDescription *, outPacketDescription, 2, 4); PARAM(UInt32 *, outStatus, 3, 4); if((ioBufferList != NULL) && (ioNumberPackets != NULL) && (outStatus != NULL)) { *outStatus = inThis->ProduceOutputBufferList(ioBufferList, *ioNumberPackets, outPacketDescription); if(kAudioCodecProduceOutputPacketFailure == *outStatus) { theError = kAudio_ParamError; } } else { theError = kAudio_ParamError; } } break; #endif // AC_NON_INTERLEAVED_SUPPORT case kAudioCodecResetSelect: { inThis->Reset(); } break; default: theError = badComponentSelector; break; }; } else { theError = kAudio_ParamError; } break; }; }
OSStatus AUBase::ComponentEntryDispatch(ComponentParameters *params, AUBase *This) { if (This == NULL) return kAudio_ParamError; OSStatus result = noErr; switch (params->what) { case kComponentCanDoSelect: switch (GetSelectorForCanDo(params)) { // any selectors case kAudioUnitInitializeSelect: case kAudioUnitUninitializeSelect: case kAudioUnitGetPropertyInfoSelect: case kAudioUnitGetPropertySelect: case kAudioUnitSetPropertySelect: case kAudioUnitAddPropertyListenerSelect: #if (!__LP64__) case kAudioUnitRemovePropertyListenerSelect: #endif case kAudioUnitGetParameterSelect: case kAudioUnitSetParameterSelect: case kAudioUnitResetSelect: result = 1; break; // v1 selectors // v2 selectors case kAudioUnitRemovePropertyListenerWithUserDataSelect: case kAudioUnitAddRenderNotifySelect: case kAudioUnitRemoveRenderNotifySelect: case kAudioUnitScheduleParametersSelect: case kAudioUnitRenderSelect: result = (This->AudioUnitAPIVersion() > 1); break; default: return ComponentBase::ComponentEntryDispatch(params, This); } break; case kAudioUnitInitializeSelect: { CAMutex::Locker lock2(This->GetMutex()); result = This->DoInitialize(); } break; case kAudioUnitUninitializeSelect: { CAMutex::Locker lock2(This->GetMutex()); This->DoCleanup(); result = noErr; } break; case kAudioUnitGetPropertyInfoSelect: { CAMutex::Locker lock(This->GetMutex()); PARAM(AudioUnitPropertyID, pinID, 0, 5); PARAM(AudioUnitScope, pinScope, 1, 5); PARAM(AudioUnitElement, pinElement, 2, 5); PARAM(UInt32 *, poutDataSize, 3, 5); PARAM(Boolean *, poutWritable, 4, 5); // pass our own copies so that we assume responsibility for testing // the caller's pointers against null and our C++ classes can // always assume they're non-null UInt32 dataSize; Boolean writable; result = This->DispatchGetPropertyInfo(pinID, pinScope, pinElement, dataSize, writable); if (poutDataSize != NULL) *poutDataSize = dataSize; if (poutWritable != NULL) *poutWritable = writable; } break; case kAudioUnitGetPropertySelect: { CAMutex::Locker lock(This->GetMutex()); PARAM(AudioUnitPropertyID, pinID, 0, 5); PARAM(AudioUnitScope, pinScope, 1, 5); PARAM(AudioUnitElement, pinElement, 2, 5); PARAM(void *, poutData, 3, 5); PARAM(UInt32 *, pioDataSize, 4, 5); UInt32 actualPropertySize, clientBufferSize; Boolean writable; char *tempBuffer; void *destBuffer; if (pioDataSize == NULL) { ca_debug_string("AudioUnitGetProperty: null size pointer"); result = kAudio_ParamError; goto finishGetProperty; } if (poutData == NULL) { UInt32 dataSize; result = This->DispatchGetPropertyInfo(pinID, pinScope, pinElement, dataSize, writable); *pioDataSize = dataSize; goto finishGetProperty; } clientBufferSize = *pioDataSize; if (clientBufferSize == 0) { ca_debug_string("AudioUnitGetProperty: *ioDataSize == 0 on entry"); // $$$ or should we allow this as a shortcut for finding the size? result = kAudio_ParamError; goto finishGetProperty; } result = This->DispatchGetPropertyInfo(pinID, pinScope, pinElement, actualPropertySize, writable); if (result) goto finishGetProperty; if (clientBufferSize < actualPropertySize) { tempBuffer = new char[actualPropertySize]; destBuffer = tempBuffer; } else { tempBuffer = NULL; destBuffer = poutData; } result = This->DispatchGetProperty(pinID, pinScope, pinElement, destBuffer); if (result == noErr) { if (clientBufferSize < actualPropertySize && tempBuffer != NULL) { memcpy(poutData, tempBuffer, clientBufferSize); delete[] tempBuffer; // pioDataSize remains correct, the number of bytes we wrote } else *pioDataSize = actualPropertySize; } else *pioDataSize = 0; finishGetProperty: ; } break; case kAudioUnitSetPropertySelect: { CAMutex::Locker lock(This->GetMutex()); PARAM(AudioUnitPropertyID, pinID, 0, 5); PARAM(AudioUnitScope, pinScope, 1, 5); PARAM(AudioUnitElement, pinElement, 2, 5); PARAM(const void *, pinData, 3, 5); PARAM(UInt32, pinDataSize, 4, 5); if (pinData && pinDataSize) result = This->DispatchSetProperty(pinID, pinScope, pinElement, pinData, pinDataSize); else { if (pinData == NULL && pinDataSize == 0) { result = This->DispatchRemovePropertyValue (pinID, pinScope, pinElement); } else { if (pinData == NULL) { ca_debug_string("AudioUnitSetProperty: inData == NULL"); result = kAudio_ParamError; goto finishSetProperty; } if (pinDataSize == 0) { ca_debug_string("AudioUnitSetProperty: inDataSize == 0"); result = kAudio_ParamError; goto finishSetProperty; } } } finishSetProperty: ; } break; case kAudioUnitAddPropertyListenerSelect: { CAMutex::Locker lock(This->GetMutex()); PARAM(AudioUnitPropertyID, pinID, 0, 3); PARAM(AudioUnitPropertyListenerProc, pinProc, 1, 3); PARAM(void *, pinProcRefCon, 2, 3); result = This->AddPropertyListener(pinID, pinProc, pinProcRefCon); } break; #if (!__LP64__) case kAudioUnitRemovePropertyListenerSelect: { CAMutex::Locker lock(This->GetMutex()); PARAM(AudioUnitPropertyID, pinID, 0, 2); PARAM(AudioUnitPropertyListenerProc, pinProc, 1, 2); result = This->RemovePropertyListener(pinID, pinProc, NULL, false); } break; #endif case kAudioUnitRemovePropertyListenerWithUserDataSelect: { CAMutex::Locker lock(This->GetMutex()); PARAM(AudioUnitPropertyID, pinID, 0, 3); PARAM(AudioUnitPropertyListenerProc, pinProc, 1, 3); PARAM(void *, pinProcRefCon, 2, 3); result = This->RemovePropertyListener(pinID, pinProc, pinProcRefCon, true); } break; case kAudioUnitAddRenderNotifySelect: { CAMutex::Locker lock(This->GetMutex()); PARAM(AURenderCallback, pinProc, 0, 2); PARAM(void *, pinProcRefCon, 1, 2); result = This->SetRenderNotification (pinProc, pinProcRefCon); } break; case kAudioUnitRemoveRenderNotifySelect: { CAMutex::Locker lock(This->GetMutex()); PARAM(AURenderCallback, pinProc, 0, 2); PARAM(void *, pinProcRefCon, 1, 2); result = This->RemoveRenderNotification (pinProc, pinProcRefCon); } break; case kAudioUnitGetParameterSelect: { CAMutex::Locker lock(This->GetMutex()); PARAM(AudioUnitParameterID, pinID, 0, 4); PARAM(AudioUnitScope, pinScope, 1, 4); PARAM(AudioUnitElement, pinElement, 2, 4); PARAM(AudioUnitParameterValue *, poutValue, 3, 4); result = (poutValue == NULL ? kAudio_ParamError : This->GetParameter(pinID, pinScope, pinElement, *poutValue)); } break; case kAudioUnitSetParameterSelect: { CAMutex::Locker lock(This->GetMutex()); // is this realtime or no??? PARAM(AudioUnitParameterID, pinID, 0, 5); PARAM(AudioUnitScope, pinScope, 1, 5); PARAM(AudioUnitElement, pinElement, 2, 5); PARAM(AudioUnitParameterValue, pinValue, 3, 5); PARAM(UInt32, pinBufferOffsetInFrames, 4, 5); result = This->SetParameter(pinID, pinScope, pinElement, pinValue, pinBufferOffsetInFrames); } break; case kAudioUnitScheduleParametersSelect: { CAMutex::Locker lock(This->GetMutex()); // is this realtime or no??? if (This->AudioUnitAPIVersion() > 1) { PARAM(AudioUnitParameterEvent *, pinParameterEvent, 0, 2); PARAM(UInt32, pinNumParamEvents, 1, 2); result = This->ScheduleParameter (pinParameterEvent, pinNumParamEvents); } else result = badComponentSelector; }
OSStatus AudioFileComponentBase::ComponentEntryDispatch(ComponentParameters* params, AudioFileComponentBase* inThis) { OSStatus result = noErr; if (inThis == NULL) return kAudio_ParamError; try { switch (params->what) { case kComponentCanDoSelect: switch (GetSelectorForCanDo(params)) { case kAudioFileCreateURLSelect: case kAudioFileOpenURLSelect: case kAudioFileOpenWithCallbacksSelect: case kAudioFileInitializeWithCallbacksSelect: case kAudioFileCloseSelect: case kAudioFileOptimizeSelect: case kAudioFileReadBytesSelect: case kAudioFileWriteBytesSelect: case kAudioFileReadPacketsSelect: case kAudioFileWritePacketsSelect: case kAudioFileGetPropertyInfoSelect: case kAudioFileGetPropertySelect: case kAudioFileSetPropertySelect: case kAudioFileExtensionIsThisFormatSelect: case kAudioFileFileDataIsThisFormatSelect: case kAudioFileGetGlobalInfoSizeSelect: case kAudioFileGetGlobalInfoSelect: case kAudioFileCountUserDataSelect: case kAudioFileGetUserDataSizeSelect: case kAudioFileGetUserDataSelect: case kAudioFileSetUserDataSelect: case kAudioFileRemoveUserDataSelect: result = 1; break; default: // these are no longer supported /* case kAudioFileCreateSelect: case kAudioFileOpenSelect: case kAudioFileInitializeSelect: */ result = ComponentBase::ComponentEntryDispatch(params, inThis); }; break; case kAudioFileCreateURLSelect: { PARAM(CFURLRef, inFileRef, 0, 3); PARAM(const AudioStreamBasicDescription*, inFormat, 1, 3); PARAM(UInt32, inFlags, 2, 3); result = inThis->AFAPI_CreateURL(inFileRef, inFormat, inFlags); } break; case kAudioFileOpenURLSelect: { PARAM(CFURLRef, inFileRef, 0, 3); PARAM(SInt32, inPermissions, 1, 3); PARAM(int, inFileDescriptor, 2, 3); result = inThis->AFAPI_OpenURL(inFileRef, inPermissions, inFileDescriptor); } break; case kAudioFileOpenWithCallbacksSelect: { PARAM(void*, inRefCon, 0, 5); PARAM(AudioFile_ReadProc, inReadFunc, 1, 5); PARAM(AudioFile_WriteProc, inWriteFunc, 2, 5); PARAM(AudioFile_GetSizeProc, inGetSizeFunc, 3, 5); PARAM(AudioFile_SetSizeProc, inSetSizeFunc, 4, 5); result = inThis->AFAPI_OpenWithCallbacks(inRefCon, inReadFunc, inWriteFunc, inGetSizeFunc, inSetSizeFunc); } break; case kAudioFileInitializeWithCallbacksSelect: { PARAM(void*, inRefCon, 0, 8); PARAM(AudioFile_ReadProc, inReadFunc, 1, 8); PARAM(AudioFile_WriteProc, inWriteFunc, 2, 8); PARAM(AudioFile_GetSizeProc, inGetSizeFunc, 3, 8); PARAM(AudioFile_SetSizeProc, inSetSizeFunc, 4, 8); PARAM(UInt32, inFileType, 5, 8); PARAM(const AudioStreamBasicDescription*, inFormat, 6, 8); PARAM(UInt32, inFlags, 7, 8); result = inThis->AFAPI_InitializeWithCallbacks(inRefCon, inReadFunc, inWriteFunc, inGetSizeFunc, inSetSizeFunc, inFileType, inFormat, inFlags); } break; case kAudioFileCloseSelect: { result = inThis->AFAPI_Close(); } break; case kAudioFileOptimizeSelect: { result = inThis->AFAPI_Optimize(); } break; case kAudioFileReadBytesSelect: { PARAM(UInt32, inUseCache, 0, 4); PARAM(SInt64*, inStartingByte, 1, 4); PARAM(UInt32*, ioNumBytes, 2, 4); PARAM(void*, outBuffer, 3, 4); result = inThis->AFAPI_ReadBytes(inUseCache, *inStartingByte, ioNumBytes, outBuffer); } break; case kAudioFileWriteBytesSelect: { PARAM(UInt32, inUseCache, 0, 4); PARAM(SInt64*, inStartingByte, 1, 4); PARAM(UInt32*, ioNumBytes, 2, 4); PARAM(const void*, inBuffer, 3, 4); result = inThis->AFAPI_WriteBytes(inUseCache, *inStartingByte, ioNumBytes, inBuffer); } break; case kAudioFileReadPacketsSelect: { PARAM(UInt32, inUseCache, 0, 6); PARAM(UInt32*, outNumBytes, 1, 6); PARAM(AudioStreamPacketDescription*, outPacketDescriptions, 2, 6); PARAM(SInt64*, inStartingPacket, 3, 6); PARAM(UInt32*, ioNumPackets, 4, 6); PARAM(void*, outBuffer, 5, 6); result = inThis->AFAPI_ReadPackets(inUseCache, outNumBytes, outPacketDescriptions, *inStartingPacket, ioNumPackets, outBuffer); } break; case kAudioFileWritePacketsSelect: { PARAM(UInt32, inUseCache, 0, 6); PARAM(UInt32, inNumBytes, 1, 6); PARAM(const AudioStreamPacketDescription*, inPacketDescriptions, 2, 6); PARAM(SInt64*, inStartingPacket, 3, 6); PARAM(UInt32*, ioNumPackets, 4, 6); PARAM(const void*, inBuffer, 5, 6); result = inThis->AFAPI_WritePackets(inUseCache, inNumBytes, inPacketDescriptions, *inStartingPacket, ioNumPackets, inBuffer); } break; case kAudioFileGetPropertyInfoSelect: { PARAM(AudioFileComponentPropertyID, inPropertyID, 0, 3); PARAM(UInt32*, outPropertySize, 1, 3); PARAM(UInt32*, outWritable, 2, 3); result = inThis->AFAPI_GetPropertyInfo(inPropertyID, outPropertySize, outWritable); } break; case kAudioFileGetPropertySelect: { PARAM(AudioFileComponentPropertyID, inPropertyID, 0, 3); PARAM(UInt32*, ioPropertyDataSize, 1, 3); PARAM(void*, outPropertyData, 2, 3); result = inThis->AFAPI_GetProperty(inPropertyID, ioPropertyDataSize, outPropertyData); } break; case kAudioFileSetPropertySelect: { PARAM(AudioFileComponentPropertyID, inPropertyID, 0, 3); PARAM(UInt32, inPropertyDataSize, 1, 3); PARAM(const void*, inPropertyData, 2, 3); result = inThis->AFAPI_SetProperty(inPropertyID, inPropertyDataSize, inPropertyData); } break; case kAudioFileGetGlobalInfoSizeSelect: { PARAM(AudioFileComponentPropertyID, inPropertyID, 0, 4); PARAM(UInt32, inSpecifierSize, 1, 4); PARAM(const void*, inSpecifier, 2, 4); PARAM(UInt32*, outPropertyDataSize, 3, 4); result = inThis->AFAPI_GetGlobalInfoSize(inPropertyID, inSpecifierSize, inSpecifier, outPropertyDataSize); } break; case kAudioFileGetGlobalInfoSelect: { PARAM(AudioFileComponentPropertyID, inPropertyID, 0, 5); PARAM(UInt32, inSpecifierSize, 1, 5); PARAM(const void*, inSpecifier, 2, 5); PARAM(UInt32*, ioPropertyDataSize, 3, 5); PARAM(void*, outPropertyData, 4, 5); result = inThis->AFAPI_GetGlobalInfo(inPropertyID, inSpecifierSize, inSpecifier, ioPropertyDataSize, outPropertyData); } break; case kAudioFileExtensionIsThisFormatSelect: { PARAM(CFStringRef, inExtension, 0, 2); PARAM(UInt32*, outResult, 1, 2); AudioFileFormatBase* aff = inThis->GetAudioFileFormatBase(); if (!aff) return kAudio_ParamError; UInt32 res = aff->ExtensionIsThisFormat(inExtension); if (outResult) *outResult = res; } break; case kAudioFileFileDataIsThisFormatSelect: { PARAM(UInt32, inDataByteSize, 0, 3); PARAM(const void*, inData, 1, 3); PARAM(UInt32*, outResult, 2, 3); AudioFileFormatBase* aff = inThis->GetAudioFileFormatBase(); if (!aff) return kAudio_ParamError; UncertainResult res = aff->FileDataIsThisFormat(inDataByteSize, inData); if (outResult) *outResult = res; } break; case kAudioFileCountUserDataSelect: { PARAM(UInt32, inUserDataID, 0, 2); PARAM(UInt32*, outNumberItems, 1, 2); result = inThis->AFAPI_CountUserData(inUserDataID, outNumberItems); } break; case kAudioFileGetUserDataSizeSelect: { PARAM(UInt32, inUserDataID, 0, 3); PARAM(UInt32, inIndex, 1, 3); PARAM(UInt32*, outUserDataSize, 2, 3); result = inThis->AFAPI_GetUserDataSize(inUserDataID, inIndex, outUserDataSize); } break; case kAudioFileGetUserDataSelect: { PARAM(UInt32, inUserDataID, 0, 4); PARAM(UInt32, inIndex, 1, 4); PARAM(UInt32*, ioUserDataSize, 2, 4); PARAM(void*, outUserData, 3, 4); result = inThis->AFAPI_GetUserData(inUserDataID, inIndex, ioUserDataSize, outUserData); } break; case kAudioFileSetUserDataSelect: { PARAM(UInt32, inUserDataID, 0, 4); PARAM(UInt32, inIndex, 1, 4); PARAM(UInt32, inUserDataSize, 2, 4); PARAM(const void*, inUserData, 3, 4); result = inThis->AFAPI_SetUserData(inUserDataID, inIndex, inUserDataSize, inUserData); } break; case kAudioFileRemoveUserDataSelect: { PARAM(UInt32, inUserDataID, 0, 2); PARAM(UInt32, inIndex, 1, 2); result = inThis->AFAPI_RemoveUserData(inUserDataID, inIndex); } break; default: result = ComponentBase::ComponentEntryDispatch(params, inThis); break; } } COMPONENT_CATCH return result; }