FskErr FskPinI2CNew(FskPinI2C *pin, SInt32 sda, SInt32 sclk, SInt32 bus)
{
FskErr err;
FskPinI2CDispatch dispatch = NULL;
UInt32 i = 0;
while (true) {
SInt32 remappedBus = kFskPinI2CNoBus;
FskPinI2CDispatch aDispatch = FskExtensionGetByIndex(kFskExtensionPinI2C, i++);
if (NULL == aDispatch)
BAIL(kFskErrExtensionNotFound);
if ((aDispatch->doCanHandle)(sda, sclk, bus, &remappedBus)) {
dispatch = aDispatch;
break;
}
if (kFskPinI2CNoBus != remappedBus)
bus = remappedBus;
}
err = (dispatch->doNew)(pin, sda, sclk, bus);
BAIL_IF_ERR(err);
(*pin)->dispatch = dispatch;
bail:
return err;
}
FskErr FskPinAnalogNew(FskPinAnalog *pin, SInt32 number, const char *name)
{
FskErr err;
FskPinAnalogDispatch dispatch = NULL;
UInt32 i = 0;
while (true) {
FskPinAnalogDispatch aDispatch = FskExtensionGetByIndex(kFskExtensionPinAnalog, i++);
if (NULL == aDispatch)
BAIL(kFskErrExtensionNotFound);
if ((aDispatch->doCanHandle)(number, name, &number)) {
dispatch = aDispatch;
break;
}
}
err = (dispatch->doNew)(pin, number, name);
BAIL_IF_ERR(err);
(*pin)->dispatch = dispatch;
bail:
return err;
}
FskErr FskAudioDecompressNew(FskAudioDecompress *decoOut, UInt32 audioFormat, const char *mimeType, UInt32 sampleRate, UInt32 channelCount, void *formatInfo, UInt32 formatInfoSize)
{
FskErr err;
FskAudioDecompressor decoder;
FskAudioDecompress deco;
UInt32 i = 0;
while (true) {
Boolean canHandle = false;
decoder = (FskAudioDecompressor)FskExtensionGetByIndex(kFskExtensionAudioDecompressor, i++);
if (NULL == decoder) {
if (decoOut)
*decoOut = NULL;
return kFskErrExtensionNotFound;
}
if ((kFskErrNone == decoder->doCanHandle(audioFormat, mimeType, &canHandle)) && canHandle)
break;
}
if (NULL == decoOut)
return kFskErrNone; // can handler
err = FskMemPtrNewClear(sizeof(FskAudioDecompressRecord), &deco);
BAIL_IF_ERR(err);
deco->inputSampleRate = sampleRate;
deco->inputChannelCount = channelCount;
deco->outputChannelCount = channelCount;
deco->formatInfoSize = formatInfoSize;
err = FskMemPtrNewFromData(formatInfoSize, formatInfo, (FskMemPtr*)(void*)&deco->formatInfo);
BAIL_IF_ERR(err);
deco->decoder = decoder;
FskInstrumentedItemNew(deco, FskStrDoCopy_Untracked(mimeType), &gAudioDecompressTypeInstrumentation);
err = deco->decoder->doNew(deco, audioFormat, mimeType);
BAIL_IF_ERR(err);
bail:
if (err) {
FskAudioDecompressDispose(deco);
deco = NULL;
}
*decoOut = deco;
return err;
}
FskErr FskAudioCompressNew(FskAudioCompress *compOut, const char *outputFormat, const char *inputFormat, UInt32 inputSampleRate, UInt32 inputChannelCount)
{
FskErr err;
FskAudioCompressor encoder;
FskAudioCompress comp;
UInt32 i = 0;
while (true) {
Boolean canHandle = false;
encoder = (FskAudioCompressor)FskExtensionGetByIndex(kFskExtensionAudioCompressor, i++);
if (NULL == encoder) {
*compOut = NULL;
return kFskErrExtensionNotFound;
}
if ((kFskErrNone == encoder->doCanHandle(outputFormat, &canHandle)) && canHandle)
break;
}
err = FskMemPtrNewClear(sizeof(FskAudioCompressRecord), &comp);
BAIL_IF_ERR(err);
comp->outputFormat = FskStrDoCopy(outputFormat);
comp->inputFormat = FskStrDoCopy(inputFormat);
comp->inputSampleRate = inputSampleRate;
comp->inputChannelCount = inputChannelCount;
comp->outputSampleRate = inputSampleRate;
comp->outputChannelCount = inputChannelCount;
comp->encoder = encoder;
err = comp->encoder->doNew(comp);
BAIL_IF_ERR(err);
bail:
if (err) {
FskAudioCompressDispose(comp);
comp = NULL;
}
*compOut = comp;
return err;
}
FskErr FskAudioFilterNew(FskAudioFilter *filterOut, const char *filterType)
{
FskErr err = kFskErrNone;
FskAudioFilter filter = NULL;
UInt32 i = 0;
FskAudioFilterDispatch dispatch;
while (true) {
dispatch = (FskAudioFilterDispatch)FskExtensionGetByIndex(kFskExtensionAudioFilter, i++);
if (NULL == dispatch)
return kFskErrUnimplemented;
if (dispatch->doCanHandle(filterType))
break;
}
if (NULL == filterOut) goto bail; // "can handle" request
err = FskMemPtrNewClear(sizeof(FskAudioFilterRecord) + FskStrLen(filterType) + 1, &filter);
BAIL_IF_ERR(err);
filter->filterType = (char *)(filter + 1);
FskStrCopy(filter->filterType, filterType);
filter->dispatch = dispatch;
FskInstrumentedItemNew(filter, filter->filterType, &gAudioFilterTypeInstrumentation);
err = (filter->dispatch->doNew)(filter, &filter->state);
BAIL_IF_ERR(err);
bail:
if (kFskErrNone != err) {
FskAudioFilterDispose(filter);
filter = NULL;
}
if (NULL != filterOut)
*filterOut = filter;
return err;
}
FskErr FskMuxerNew(FskMuxer *muxerOut, const char *mimeType, UInt32 scale, FskMuxerWriteProc write, void *writeRefCon)
{
FskErr err;
FskMuxer muxer = NULL;
UInt32 i = 0;
FskMuxerDispatch dispatch;
while (true) {
dispatch = (FskMuxerDispatch)FskExtensionGetByIndex(kFskExtensionMuxer, i++);
if (NULL == dispatch)
return kFskErrExtensionNotFound;
if (dispatch->doCanHandle(mimeType))
break;
}
err = FskMemPtrNewClear(sizeof(FskMuxerRecord) + FskStrLen(mimeType) + 1, &muxer);
BAIL_IF_ERR(err);
muxer->mimeType = (char *)(muxer + 1);
FskStrCopy(muxer->mimeType, mimeType);
muxer->scale = scale;
muxer->write = write;
muxer->writeRefCon = writeRefCon;
muxer->dispatch = dispatch;
err = (muxer->dispatch->doNew)(muxer, &muxer->state);
BAIL_IF_ERR(err);
bail:
if (kFskErrNone != err) {
FskMuxerDispose(muxer);
muxer = NULL;
}
*muxerOut = muxer;
return err;
}
FskErr FskPinSerialNew(FskPinSerial *pin, SInt32 rxNumber, SInt32 txNumber, const char *nameIn, SInt32 baud)
{
FskErr err;
const char *name = nameIn;
FskPinSerialDispatch dispatch = NULL;
UInt32 i = 0;
while (true) {
char *remappedName = NULL;
FskPinSerialDispatch aDispatch = FskExtensionGetByIndex(kFskExtensionPinSerial, i++);
if (NULL == aDispatch)
BAIL(kFskErrExtensionNotFound);
if ((aDispatch->doCanHandle)(rxNumber, txNumber, name, &remappedName)) {
dispatch = aDispatch;
break;
}
if (remappedName) {
if (name != nameIn)
FskMemPtrDispose((char *)name);
name = remappedName;
}
}
err = (dispatch->doNew)(pin, rxNumber, txNumber, name, baud);
BAIL_IF_ERR(err);
(*pin)->dispatch = dispatch;
bail:
if (name != nameIn)
FskMemPtrDispose((char *)name);
return err;
}
