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

/* 	interface is optional. If NULL, then all interfaces will be used*/FskErr FskHTTPServerCreate(int port, char *interfaceName, FskHTTPServer *server, void *refCon, Boolean ssl) {	FskHTTPServer	http;	FskErr err;	FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "httpServerCreate/n");	err = FskMemPtrNewClear(sizeof(FskHTTPServerRecord), (FskMemPtr*)&http);	BAIL_IF_ERR(err);	sFskHTTPServerUpUse(http);	http->stopped = true;	http->refCon = refCon;	http->port = port;	http->keepAliveTimeout = kFskHTTPKeepAliveTimeout;	http->defaultBufferSize = kFskHTTPServerDefaultBufferSize;	http->owner = FskThreadGetCurrent();	http->ssl = ssl;	snprintf(http->name, 64, "%s:%d", interfaceName ? interfaceName : "all", port);	FskInstrumentedItemNew(http, http->name, &gFskHTTPServerTypeInstrumentation);	if (interfaceName) {		err = FskHTTPServerListenerAdd(http, port, interfaceName, NULL);	}	else {		FskNetInterfaceRecord *ifc;		int i, numI;		http->all = true;		numI = FskNetInterfaceEnumerate();		for (i=0; i<numI; i++) {			FskErr notErr = FskNetInterfaceDescribe(i, &ifc);			if (notErr) continue;			if (ifc->status) {				notErr = FskHTTPServerListenerAdd(http, port, ifc->name, NULL);				if (notErr) err = notErr;			}			FskNetInterfaceDescriptionDispose(ifc);		}	}	http->interfaceNotifier = FskNetInterfaceAddNotifier(httpServerInterfaceChanged, http, "http server");bail:	*server = http;	return err;}

 FskErr amrReaderNew(FskMediaReader reader, void **readerState, const char *mimeType, const char *uri, FskMediaSpooler spooler){	FskErr err;	amrReader state = NULL;    BAIL_IF_NULL(spooler, err, kFskErrUnimplemented);		err = FskMemPtrNewClear(sizeof(amrReaderRecord), &state);	BAIL_IF_ERR(err);	*readerState = state;			// must be set before anything that might issue a callback	state->spooler = spooler;	state->reader = reader;	if (spooler->doOpen) {		err = (spooler->doOpen)(spooler, kFskFilePermissionReadOnly);		BAIL_IF_ERR(err);		state->spoolerOpen = true;	}	state->spooler->onSpoolerCallback = amrSpoolerCallback;	state->spooler->clientRefCon = state;	state->spooler->flags |= kFskMediaSpoolerForwardOnly;	state->duration = kFskUInt32Max;	(reader->doSetState)(reader, kFskMediaPlayerStateInstantiating);	err = amrInstantiate(state);	if (err) {		if (kFskErrNeedMoreTime == err)			err = kFskErrNone;		goto bail;	}bail:	if ((kFskErrNone != err) && (NULL != state)) {		amrReaderDispose(reader, state);		state = NULL;	}	*readerState = state;	return err;}

FskErr KprSSDPClientNew(KprSSDPClient *it, const char* type){	FskErr err = kFskErrNone;	KprSSDPClient self = NULL;	bailIfError(FskMemPtrNewClear(sizeof(KprSSDPClientRecord), it));	self = *it;	if (type) {		self->type = FskStrDoCopy(type);		bailIfNULL(self->type);	}	FskInstrumentedItemNew(self, NULL, &KprSSDPClientInstrumentation);bail:	if (err)		KprSSDPClientDispose(self);	return err;}

void scanVolumes() {	FILE *mountList;	struct mntent	*cur;	int err;	volInfo	vi;	mntdevmap *walker;	struct statfs fsinfo;	mountList = setmntent(kKplLinuxVolumeListFile, "r");	if (mountList) {		while (NULL != (cur = getmntent(mountList))) {			err = statfs(cur->mnt_dir, &fsinfo);			if (0 != err) {				continue;			}			for (walker = gMntDevMap; NULL != walker->name; walker++) {				if (0 == FskStrCompareWithLength(cur->mnt_type, walker->name, FskStrLen(walker->name)))					break;			}			if (!walker->name) {				continue;			}			FskMemPtrNewClear(sizeof(volInfoRec), &vi);			vi->type = walker->type;			vi->removable = walker->removable;			vi->mounted = true;			vi->typeStr = FskStrDoCopy(cur->mnt_type);			if (kFskErrNone == FskMemPtrNew(FskStrLen(cur->mnt_dir) + 2, &vi->mountPoint)) {				FskStrCopy(vi->mountPoint, cur->mnt_dir);				if (vi->mountPoint[FskStrLen(vi->mountPoint)-1] != '/')					FskStrCat(vi->mountPoint, "/");			}			vi->name = copyNiceName(cur->mnt_fsname);			vi->capacity = fsinfo.f_blocks * fsinfo.f_bsize;			vi->remaining = fsinfo.f_bavail * fsinfo.f_bsize;			FskListAppend(&volumeList, vi);		}		endmntent(mountList);	}}

FskErr lpcmPacketParserProcessPacket(RTPPacketParser parser, RTPPacket rtpHeader){	LPCMPacketParser lpcmPacketParser = (LPCMPacketParser)parser->handlerRefCon;	RTPCompressedMediaFrame frame;	FskErr err;	err = FskMemPtrNewClear(rtpHeader->dataSize + sizeof(RTPCompressedMediaFrameRecord), &frame);	BAIL_IF_ERR(err);	rtpHeader->frames = frame;	frame->length = rtpHeader->dataSize;	FskMemMove(frame + 1, rtpHeader->data, rtpHeader->dataSize);		rtpHeader->totalSamples = frame->length / (lpcmPacketParser->bitsPerSample/8) / lpcmPacketParser->nChannels;bail:	return err;}

FskErr KprZeroconfServiceNewType(char* authority, char** it){#define kKPRZeroconfKinomaServe "_%s._tcp."	FskErr err = kFskErrNone;	char* type = NULL;	char* ptr;	UInt32 length = FskStrLen(authority);	UInt32 size = length + FskStrLen(kKPRZeroconfKinomaServe);	bailIfError(FskMemPtrNewClear(size, &type));	snprintf(type, size, kKPRZeroconfKinomaServe, authority);	type[length + 1] = 0;	for (ptr = FskStrChr(type, '.'); ptr; ptr = FskStrChr(ptr, '.')) 		*ptr = '_';	type[length + 1] = '.';	*it = type;bail:	return err;}

FskErr KprCanvasNew(KprCanvas* it,  KprCoordinates coordinates){	FskErr err = kFskErrNone;	KprCanvas self;	bailIfError(FskMemPtrNewClear(sizeof(KprCanvasRecord), it));	self = *it;	FskInstrumentedItemNew(self, NULL, &KprCanvasInstrumentation);	self->dispatch = &KprCanvasDispatchRecord;	self->flags = kprVisible;	KprContentInitialize((KprContent)self, coordinates, NULL, NULL);	if (coordinates->width && coordinates->height) {		bailIfError(FskCanvasNew(coordinates->width, coordinates->height, PreferredPixelFormat(), &self->cnv));        FskCanvas2dSetOpenGLSourceAccelerated(self->cnv, true);    }bail:	return err;}

FskErr KprWebSocketServerNew(KprWebSocketServer* it, void *refCon){	FskErr err = kFskErrNone;	KprWebSocketServer self = NULL;	bailIfError(FskMemPtrNewClear(sizeof(KprWebSocketServerRecord), it));	self = *it;	self->stopped = false;	self->refCon = refCon;	self->owner = FskThreadGetCurrent();//	self->interfaceNotifier = FskNetInterfaceAddNotifier(KprWebSocketServerInterfaceChanged, self, "websocket server");	return err;bail:	KprWebSocketServerDispose(self);	return err;}

FskErr KprDebugNew(KprDebug* it, UInt32 port){	FskErr err = kFskErrNone;	KprDebug self = NULL;	BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KprDebugRecord), it));	self = *it;	self->port = port;	BAIL_IF_ERR(err = KprSocketServerNew(&self->server, self));	self->server->debugName = "Debug";	self->server->acceptCallback = KprDebugAcceptNewConnection;	BAIL_IF_ERR(err = KprSocketServerListen(self->server, self->port, NULL));	FskListAppend(&gKprDebugList, self);	FskInstrumentedItemNew(self, NULL, &KprDebugInstrumentation);	return err;bail:	KprDebugDispose(self);	return err;}

FskErr KprWebSocketEndpointNew(KprWebSocketEndpoint* it, void *refcon){	FskErr err = kFskErrNone;	KprWebSocketEndpoint self = NULL;		bailIfError(FskMemPtrNewClear(sizeof(KprWebSocketEndpointRecord), it));	self = *it;	FskInstrumentedItemNew(self, NULL, &gKprWebSocketEndpointInstrumentation);		self->refcon = refcon;	self->state = kKprWebSocketStateConnecting;	FskDebugStr("CREATE: KprWebSocketEndpoint/n");	return err;bail:	if (self) KprWebSocketEndpointDispose(self);	return err;}

FskErr FskGtkWindowCreate(FskWindow fskWindow, UInt32 style, SInt32 width, SInt32 height){	FskErr			err = kFskErrNone;	FskGtkWindow	gtkWin;	if(fskWindow->gtkWin == NULL) {		err = FskMemPtrNewClear(sizeof(FskGtkWindowRecord), &(fskWindow->gtkWin));		BAIL_IF_ERR(err);	}	gtkWin = (FskGtkWindow)fskWindow->gtkWin;	gtkWin->width = width;	gtkWin->height = height;	FskGtkWindowInit(fskWindow);bail:	return err;}

FskErr KplConditionNew(KplCondition *conditionOut){    FskErr err;    KplCondition condition = NULL;    err = FskMemPtrNewClear(sizeof(KplConditionRecord), (FskMemPtr *)&condition);    if (err) goto bail;	pthread_cond_init(&condition->cond, NULL);bail:    if (err) {        KplConditionDispose(condition);        condition = NULL;    }    *conditionOut = condition;    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;}

void fxLoadModuleJSB(txMachine* the, txString path, txID moduleID){	FskErr err = kFskErrNone;	txScript* script = NULL;	FskFile fref = NULL;	Atom atom;	bailIfError(FskMemPtrNewClear(sizeof(txScript), &script));	bailIfError(FskFileOpen(path, kFskFilePermissionReadOnly, &fref));	bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));	bailAssert(atom.atomType == XS_ATOM_BINARY);		bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));	bailAssert(atom.atomType == XS_ATOM_VERSION);	bailIfError(FskFileRead(fref, sizeof(script->version), script->version, NULL));	bailAssert(script->version[0] == XS_MAJOR_VERSION);	bailAssert(script->version[1] == XS_MINOR_VERSION);	bailAssert(script->version[2] == XS_PATCH_VERSION);	bailAssert(script->version[3] != -1);		bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));	bailAssert(atom.atomType == XS_ATOM_SYMBOLS);	script->symbolsSize = atom.atomSize - sizeof(atom);	bailIfError(FskMemPtrNew(script->symbolsSize, &script->symbolsBuffer));	bailIfError(FskFileRead(fref, script->symbolsSize, script->symbolsBuffer, NULL));		bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));	bailAssert(atom.atomType == XS_ATOM_CODE);	script->codeSize = atom.atomSize - sizeof(atom);	bailIfError(FskMemPtrNew(script->codeSize, &script->codeBuffer));	bailIfError(FskFileRead(fref, script->codeSize, script->codeBuffer, NULL));bail:	if (fref)		FskFileClose(fref);	if (err) {		if (script) {			fxDeleteScript(script);			script = NULL;		}	}	fxResolveModule(the, moduleID, script, NULL, NULL);}

FskErr FskMutexNew_(FskMutex *mutex, const char *name, FSK_SYNCHRONIZATION_DEBUG_ARGS)#endif{	FskMutex mtx = NULL;	FskErr err;	err = FskMemPtrNewClear(sizeof(FskMutexRecord), (FskMemPtr *)&mtx);	BAIL_IF_ERR(err);	err = KplMutexNew((KplMutex*)&mtx->kplMutex);	BAIL_IF_ERR(err);#if SUPPORT_INSTRUMENTATION	mtx->name = FskStrDoCopy_Untracked(name);	FskInstrumentedItemNew(mtx, mtx->name, &gFskMutexTypeInstrumentation);#if SUPPORT_SYNCHRONIZATION_DEBUG	if (FskInstrumentedItemHasListeners(mtx)) {		FskSynchronizationInstrMsgRecord msg;		msg.name = name;		msg.file = file;		msg.line = line;		msg.function = function;		FskInstrumentedItemSendMessage(mtx, kFskSynchronizationInstrMsgMutexNew, &msg);	}#endif#endifbail:	if ((err != kFskErrNone) && (mtx != NULL)) {		KplMutexDispose(mtx->kplMutex);#if SUPPORT_INSTRUMENTATION		FskMemPtrDispose_Untracked((void*)mtx->name);#endif		FskMemPtrDispose(mtx);		mtx = NULL;	}	*mutex = mtx;	return err;}

void refillQueue(FskAudioOut audioOut) {	void *silence;	FskAudioOutBlock block;	androidAudioExt	*ext;	ext = (androidAudioExt*)audioOut->ext;	FskAudioNativePrintfDebug("refillQueue");	if (audioOut->moreCB) {		SInt32 samplesTarget;//		SInt32 chunkRequestSize = 8192;		SInt32 chunkRequestSize = AUDIO_DATA_BUFFER_SIZE;		samplesTarget = audioOut->sampleRate * audioOut->numChannels;		if (audioOut->chunkRequestSize)			chunkRequestSize = audioOut->chunkRequestSize;		if (audioOut->bufferedSamplesTarget)			samplesTarget = audioOut->bufferedSamplesTarget;		while (true) {			SInt32 samplesNeeded;			FskErr err;			samplesNeeded = samplesTarget - (ext->bytesEnqueued / ext->sampleSize);			//FskAudioNativePrintfDebug("samplesNeeded %d - samplesTarget %d", samplesNeeded, samplesTarget);			if (samplesNeeded < chunkRequestSize)				break;			if (kFskErrNone == (err = (audioOut->moreCB)(audioOut, audioOut->moreRefCon, chunkRequestSize)))				continue;#if DONT_GENERATE_SILENCE			break;#else			// make silence			FskAudioNativePrintfDebug("making silence because more callback returns %d", err);			FskMemPtrNewClear(chunkRequestSize * 2 * audioOut->numChannels, (FskMemPtr*)&silence);			if (kFskErrNone != audioOutEnqueue(audioOut, silence, chunkRequestSize * 2 * audioOut->numChannels, NULL, 0, NULL, &block))				break;			block->silence = true;#endif		}	}	FskAudioNativePrintfDebug("refillQueue - DONE");}

FskErr mraaDigitalNew(FskPinDigital *pin, SInt32 number, const char *name, FskPinsDigitalDirection direction){	FskErr err;	mraa_gpio_context context;	mraaDigital md;	context = mraa_gpio_init(number);	if (!context) return kFskErrOperationFailed;	err = FskMemPtrNewClear(sizeof(mraaDigitalRecord), (FskMemPtr *)&md);	if (err) {		mraa_gpio_close(context);		return err;	}	md->context = context;	*pin = (FskPinDigital)md;	return mraaDigitalSetDirection(*pin, direction);}

FskErr KplSemaphoreNew(KplSemaphore *sem, UInt32 value){	FskErr err;	err = FskMemPtrNewClear(sizeof(KplSemaphoreRecord), (FskMemPtr *)sem);	if (err) goto bail;	if (sem_init(&(*sem)->hSem, 0, value) != 0) {		err = kFskErrOperationFailed;		goto bail;	}bail:	if ((err != kFskErrNone) && (*sem != NULL)) {		FskMemPtrDispose(*sem);		*sem = NULL;	}	return err;}

FskNetInterfaceNotifier FskNetInterfaceAddNotifier(FskNetInterfaceChangedCallback callback, void *param, char *debugName){	FskNetInterfaceNotifier notRef = NULL;	FskThread thread = FskThreadGetCurrent();	UInt32 nameLen = debugName ? FskStrLen(debugName) + 1 : 0;	if (kFskErrNone == FskMemPtrNewClear(sizeof(FskNetInterfaceNotifierRec) + nameLen, &notRef)) {		FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NetInterfaceNotifier NEW -- %x", notRef);		notRef->callback = callback;		notRef->param = param;		notRef->thread = thread;		if (nameLen)			FskMemMove(notRef->name, debugName, nameLen);		FskListMutexPrepend(interfaceChangeCBList, notRef);		FskInstrumentedItemNew(notRef, notRef->name, &gNetInterfaceNotifierTypeInstrumentation);	}	return notRef;}

FskErr KprNetworkInterfaceMark(int ip, char *name){	FskErr err = kFskErrNone;	KprNetworkInterface* address = &gNetworkInterface;	KprNetworkInterface self;	while ((self = *address)) {		if ((self->ip == ip) && !FskStrCompare(self->name, name)) {			self->flag = 1;			return err;		}        address = &self->next;	}	bailIfError(FskMemPtrNewClear(sizeof(KprNetworkInterfaceRecord), address));	self = *address;	self->ip = ip;	self->name = FskStrDoCopy(name);	bailIfNULL(self->name);bail:	return err;}

FskErr FskSemaphoreNew_(FskSemaphore *sem, UInt32 value, FSK_SYNCHRONIZATION_DEBUG_ARGS)#endif{	FskErr err;	err = FskMemPtrNewClear(sizeof(FskSemaphoreRecord), (FskMemPtr *)sem);	BAIL_IF_ERR(err);#if TARGET_OS_MAC	{		FskSemaphore s = *sem;		snprintf(s->name, sizeof(s->name)-1, "/tmp/sem%lx", (unsigned long)s);		if ((s->hSem = sem_open(s->name, O_CREAT|O_EXCL, 666, value)) == NULL) {			BAIL(kFskErrOperationFailed);		}	}#else	if (sem_init(&(*sem)->hSem, 0, value) != 0) {		BAIL(kFskErrOperationFailed);	}#endif	FskInstrumentedItemNew(*sem, NULL, &gFskSemaphoreTypeInstrumentation);#if SUPPORT_INSTRUMENTATION && SUPPORT_SYNCHRONIZATION_DEBUG	if (FskInstrumentedItemHasListeners(*sem)) {		FskSynchronizationInstrMsgRecord msg;		msg.file = file;		msg.line = line;		msg.function = function;		FskInstrumentedItemSendMessage(*sem, kFskSynchronizationInstrMsgSemaphoreNew, &msg);	}#endifbail:	if ((err != kFskErrNone) && (*sem != NULL)) {		FskMemPtrDispose(*sem);		*sem = NULL;	}	return err;}

void KPR_MQTTClient(xsMachine* the){	FskErr err;	KPR_MQTTClientRecord *self = NULL;	KprMQTTClient client = NULL;	FskDeferrer deferrer = NULL;	char *clientIdentifier;	Boolean cleanSession;	if (xsToInteger(xsArgc) != 2) xsThrowIfFskErr(kFskErrParameterError);	clientIdentifier = xsToString(xsArg(0));	cleanSession = xsToBoolean(xsArg(1));	bailIfError(FskMemPtrNewClear(sizeof(KPR_MQTTClientRecord), &self));	bailIfError(FskDeferrerNew(&deferrer));	bailIfError(KprMQTTClientNew(&client, clientIdentifier, cleanSession, kKprMQTTProtocol311, self));	client->connectCallback = KPR_mqttclient_onConnect;	client->subscribeCallback = KPR_mqttclient_onSubscribe;	client->unsubscribeCallback = KPR_mqttclient_onUnsubscribe;	client->publishCallback = KPR_mqttclient_onPublish;	client->messageCallback = KPR_mqttclient_onMessage;	client->disconnectCallback = KPR_mqttclient_onDisconnect;	client->errorCallback = KPR_mqttclient_onError;	self->client = client;	self->deferrer = deferrer;	self->the = the;	self->slot = xsThis;	xsSetHostData(self->slot, self);bail:	if (err) {		KprMQTTClientDispose(client);		FskDeferrerDispose(deferrer);		FskMemPtrDispose(self);		xsThrowIfFskErr(err);	}}

FskErr latmPacketParserNew(RTPPacketParser parser){	FskErr err;	LATMPacketParser latmPacketParser;	SDPMediaDescription mediaDescription;	err = FskMemPtrNewClear(sizeof(LATMPacketParserRecord), &latmPacketParser);	BAIL_IF_ERR(err);		parser->handlerRefCon = latmPacketParser;	parser->mediaFormat = kRTPAudioFormatAAC;	latmPacketParser->bitsPerSample = 16;	latmPacketParser->mediaFormat = kRTPAudioFormatAAC;	mediaDescription = parser->mediaDescription;	if (NULL != mediaDescription) {		SDPAttribute attribute;		// Grab what we need from the "fmtp" attribute		attribute = SDPFindMediaAttribute(mediaDescription, "fmtp");		if (NULL != attribute) {			char *value, *attr;			value = FskStrDoCopy(attribute->value);			if (NULL != copyAttributeValue(value, "config", &attr)) {				latmPacketParser->config = FskStrDoCopy(attr);				FskMemPtrDispose(attr);			}			FskMemPtrDispose(value);		}	}	// Build an ESDS compatible with Kinoma Player / FhG decoder	if (!validateConfig(latmPacketParser->config, &latmPacketParser->nChannels, &latmPacketParser->sampleRate, &latmPacketParser->nSubFrames, latmPacketParser->esds, &latmPacketParser->esdsSize)) {		err = kFskErrRTSPPacketParserUnsupportedFormat;	}bail:	return err;}

FskErrFskSSLAttach(void **fsslp, FskSocket skt){	FskSSL *fssl;	FskErr err;	if ((err = FskMemPtrNewClear(sizeof(FskSSL), (FskMemPtr*)(void*)&fssl)) != kFskErrNone)		return err;	if ((err = newSSLVM(&fssl->vm)) != kFskErrNone) {		FskMemPtrDispose(fssl);		return err;	}	xsBeginHost(fssl->vm->the);	xsTry {		xsVars(2);		xsVar(0) = xsNew1(xsGet(xsGlobal, xsID("Stream")), xsID("Socket"), xsHostData(skt));		xsVar(1) = xsNewInstanceOf(xsObjectPrototype);		(void)xsSet(xsVar(1), xsID("raw"), xsTrue);		xsCall1_noResult(xsVar(0), xsID("setProperties"), xsVar(1));		fssl->socket = xsVar(0); xsRemember(fssl->socket);		xsVar(0) = xsNew0(xsGet(xsGlobal, xsID("FskSSL")), xsID("Session"));		fssl->ssl = xsVar(0); xsRemember(fssl->ssl);	} xsCatch {		if (xsHas(xsException, xsID("code")))			err = xsToInteger(xsGet(xsException, xsID("code")));		if (err == kFskErrNone)			err = kFskErrOperationFailed;	}	xsEndHost(fssl->vm->the);	if (err == kFskErrNone) {		if (fsslp != NULL)			*fsslp = fssl;	}	else {		disposeSSLVM(fssl->vm);		FskMemPtrDispose(fssl);	}	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;}

void addVolume(char *path, int type, int removable) {	pMount 	mnt;	char 	*tmp;	FskErr	err;	if ('/' == path[FskStrLen(path)-1])		tmp = FskStrDoCopy(path);	else		tmp = FskStrDoCat(path, "/");	if (NULL != volumesContain(tmp)) {		FskMemPtrDispose(tmp);		return;	}	err = FskMemPtrNewClear(sizeof(sMountRec), &mnt);	BAIL_IF_ERR(err);	mnt->mountPoint = tmp;	if (sNumMounts == 0) {		mnt->name = FskStrDoCopy(kInternalDataStorageName);	}	else {		gNumCards++;		if (gNumCards > 1) {			char *name = FskStrDoCat("Card (", path);			mnt->name = FskStrDoCat(name, ")");			FskMemPtrDispose(name);		}		else {			mnt->name = FskStrDoCopy("Card");		}	}	mnt->type = type;	mnt->removable = removable;	mnt->fsID = ++sNumMounts;	FskListAppend(&gMounts, mnt);bail:	;}

FskErr KplAudioNew(KplAudio *audioOut){	FskErr err = kFskErrNone;	KplAudio audio = NULL;		bailIfError(FskMemPtrNewClear(sizeof(KplAudioRecord), (FskMemPtr *)&audio));	bailIfError(KplMutexNew(&audio->mutex));	audio->format = SND_PCM_FORMAT_S16_LE;#if TARGET_RT_LITTLE_ENDIAN	audio->format = SND_PCM_FORMAT_S16_LE;#else	audio->format = SND_PCM_FORMAT_S16_BE;#endif	audio->volL = 256;	audio->volR = 256;	*audioOut = audio;bail:	if (err)		KplAudioDispose(audio);	return err;}

FskErr KplVolumeIteratorNew(KplVolumeIterator *volIt){	FskErr	ret = kFskErrNone;	KplVolumeIterator	vol;	if (!volumeList)		scanVolumes();	ret = FskMemPtrNewClear(sizeof(KplVolumeIteratorRecord), (FskMemPtr*)&vol);	if (kFskErrNone == ret)		vol->volumeInfo = volumeList;	if (kFskErrNone == ret) {		*volIt = vol;	}	else {		*volIt = NULL;		FskMemPtrDispose(vol);	}	return ret;}

static FskErr KplAudioOutBlockAdd(KplAudio audio, const char* data, UInt32 size, void *refCon){	FskErr err = kFskErrNone;	KplAudioOutBlock buffer = NULL;	if (size) {		bailIfError(FskMemPtrNewClear(sizeof(KplAudioOutBlockRecord), (FskMemPtr *)&buffer));		buffer->data = data;		buffer->size = size;		buffer->refCon = refCon;        KplMutexAcquire(audio->mutex);		FskListAppend(&audio->buffer, buffer);		audio->bufferSize += size;        KplMutexRelease(audio->mutex);	}	else {		audio->ending = true;	}bail:	return err;}