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;
}
