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

Notificator::Notificator(const QString &programName, QSystemTrayIcon *trayicon, QWidget *parent):    QObject(parent),    parent(parent),    programName(programName),    mode(None),    trayIcon(trayicon)#ifdef USE_DBUS    ,interface(0)#endif{    if(trayicon && trayicon->supportsMessages())    {        mode = QSystemTray;    }#ifdef USE_DBUS    interface = new QDBusInterface("org.freedesktop.Notifications",          "/org/freedesktop/Notifications", "org.freedesktop.Notifications");    if(interface->isValid())    {        mode = Freedesktop;    }#endif#ifdef Q_OS_MAC    // check if users OS has support for NSUserNotification    if( MacNotificationHandler::instance()->hasUserNotificationCenterSupport()) {        mode = UserNotificationCenter;    }    else {        // Check if Growl is installed (based on Qt's tray icon implementation)        CFURLRef cfurl;        OSStatus status = LSGetApplicationForInfo(kLSUnknownType, kLSUnknownCreator, CFSTR("growlTicket"), kLSRolesAll, 0, &cfurl);        if (status != kLSApplicationNotFoundErr) {            CFBundleRef bundle = CFBundleCreate(0, cfurl);            if (CFStringCompare(CFBundleGetIdentifier(bundle), CFSTR("com.Growl.GrowlHelperApp"), kCFCompareCaseInsensitive | kCFCompareBackwards) == kCFCompareEqualTo) {                if (CFStringHasSuffix(CFURLGetString(cfurl), CFSTR("/Growl.app/")))                    mode = Growl13;                else                    mode = Growl12;            }            CFRelease(cfurl);            CFRelease(bundle);    }    }#endif}

void	InitDeckLinkAPI_v7_6 (void){	CFURLRef		bundleURL;	bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR(kDeckLinkAPI_BundlePath), kCFURLPOSIXPathStyle, true);	if (bundleURL != NULL)	{		gBundleRef = CFBundleCreate(kCFAllocatorDefault, bundleURL);		if (gBundleRef != NULL)		{			gCreateIteratorFunc = (CreateIteratorFunc_v7_6)CFBundleGetFunctionPointerForName(gBundleRef, CFSTR("CreateDeckLinkIteratorInstance"));			gCreateOpenGLPreviewFunc = (CreateOpenGLScreenPreviewHelperFunc_v7_6)CFBundleGetFunctionPointerForName(gBundleRef, CFSTR("CreateOpenGLScreenPreviewHelper"));			gCreateCocoaPreviewFunc = (CreateCocoaScreenPreviewFunc_v7_6)CFBundleGetFunctionPointerForName(gBundleRef, CFSTR("CreateCocoaScreenPreview"));			gCreateVideoConversionFunc = (CreateVideoConversionInstanceFunc_v7_6)CFBundleGetFunctionPointerForName(gBundleRef, CFSTR("CreateVideoConversionInstance"));		}		CFRelease(bundleURL);	}}

static CFBundleRefget_bundle(void){    static CFBundleRef		bundle = NULL;    CFURLRef			url;    if (bundle != NULL) {	return (bundle);    }    url = CFURLCreateWithFileSystemPath(NULL,					CFSTR(kEAPOLControllerPath),					kCFURLPOSIXPathStyle, FALSE);    if (url != NULL) {	bundle = CFBundleCreate(NULL, url);	CFRelease(url);    }    return (bundle);}

static gfx_ctx_proc_t gfx_ctx_cgl_get_proc_address(const char *symbol_name){   CFURLRef bundle_url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,         CFSTR         ("/System/Library/Frameworks/OpenGL.framework"),         kCFURLPOSIXPathStyle, true);   CFBundleRef opengl_bundle_ref  = CFBundleCreate(kCFAllocatorDefault, bundle_url);   CFStringRef function =  CFStringCreateWithCString(kCFAllocatorDefault, symbol_name,         kCFStringEncodingASCII);   gfx_ctx_proc_t ret = (gfx_ctx_proc_t)CFBundleGetFunctionPointerForName(         opengl_bundle_ref, function);   CFRelease(bundle_url);   CFRelease(function);   CFRelease(opengl_bundle_ref);   return ret;}

int Vst::loadPlugin(std::string pathOnDisk){    int error = 0;        plugin = nullptr;        CFStringRef pluginPathReference = CFStringCreateWithCString(nullptr, pathOnDisk.c_str(), kCFStringEncodingASCII);    CFURLRef bundleUrl = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, pluginPathReference, kCFURLPOSIXPathStyle, true);        if(bundleUrl == nullptr)    {        std::cout<<"Could't find reference to VST URL. It might not exist, or the path is wrong."<<std::endl;        return -1;    }        CFBundleRef bundle = CFBundleCreate(kCFAllocatorDefault, bundleUrl);    if(bundle == nullptr)    {        std::cout<<"Couldn't create VST Bundle reference. It might not be a VST, or corrupted"<<std::endl;        CFRelease(bundleUrl);        CFRelease(bundle);        return -1;    }        VSTPlugin = (vstPluginFuncPtr)CFBundleGetFunctionPointerForName(bundle, CFSTR("VSTPluginMain"));        plugin = VSTPlugin(hostCallback);        if(plugin == nullptr)    {        std::cout<<"Couldn't create VST Main Entry Point"<<std::endl;        CFBundleUnloadExecutable(bundle);        CFRelease(bundle);        return -1;    }        CFRelease(pluginPathReference);    CFRelease(bundleUrl);        error = configureCallbacks();    error = startPlugin();        return error;}

bool InjectedBundle::load(APIObject* initializationUserData){    if (m_sandboxExtension) {        if (!m_sandboxExtension->consume()) {            fprintf(stderr, "InjectedBundle::load failed - Could not consume bundle sandbox extension for [%s]./n", m_path.utf8().data());            return false;        }        m_sandboxExtension = 0;    }        RetainPtr<CFStringRef> injectedBundlePathStr(AdoptCF, CFStringCreateWithCharacters(0, reinterpret_cast<const UniChar*>(m_path.characters()), m_path.length()));    if (!injectedBundlePathStr) {        fprintf(stderr, "InjectedBundle::load failed - Could not create the path string./n");        return false;    }        RetainPtr<CFURLRef> bundleURL(AdoptCF, CFURLCreateWithFileSystemPath(0, injectedBundlePathStr.get(), kCFURLPOSIXPathStyle, false));    if (!bundleURL) {        fprintf(stderr, "InjectedBundle::load failed - Could not create the url from the path string./n");        return false;    }    m_platformBundle = CFBundleCreate(0, bundleURL.get());    if (!m_platformBundle) {        fprintf(stderr, "InjectedBundle::load failed - Could not create the bundle./n");        return false;    }            if (!CFBundleLoadExecutable(m_platformBundle)) {        fprintf(stderr, "InjectedBundle::load failed - Could not load the executable from the bundle./n");        return false;    }    WKBundleInitializeFunctionPtr initializeFunction = reinterpret_cast<WKBundleInitializeFunctionPtr>(CFBundleGetFunctionPointerForName(m_platformBundle, CFSTR("WKBundleInitialize")));    if (!initializeFunction) {        fprintf(stderr, "InjectedBundle::load failed - Could not find the initialize function in the bundle executable./n");        return false;    }    initializeFunction(toAPI(this), toAPI(initializationUserData));    return true;}

 void init() {     CFBundleRef mainBundle = CFBundleGetMainBundle();     if (mainBundle)     {         CFStringRef resourceName = CFStringCreateWithCString(NULL, kFayeCppBundleName ,kCFStringEncodingUTF8);         if (resourceName)         {             CFURLRef url = CFBundleCopyResourceURL(mainBundle, resourceName, CFSTR("bundle"), NULL);             CFRelease(resourceName);             if (url)             {                 _localizedBundle = CFBundleCreate(NULL, url);                 CFRelease(url);             }         }         _localizedTableName = CFStringCreateWithCString(NULL, kFayeCppBundleLocalizationTableName ,kCFStringEncodingUTF8);     } }

static CFBundleRef createWebKitBundle(){    if (CFBundleRef existingBundle = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.WebKit"))) {        CFRetain(existingBundle);        return existingBundle;    }    wchar_t dllPathBuffer[MAX_PATH];    DWORD length = ::GetModuleFileNameW(instanceHandle(), dllPathBuffer, WTF_ARRAY_LENGTH(dllPathBuffer));    ASSERT(length);    ASSERT(length < WTF_ARRAY_LENGTH(dllPathBuffer));    RetainPtr<CFStringRef> dllPath(AdoptCF, CFStringCreateWithCharactersNoCopy(0, reinterpret_cast<const UniChar*>(dllPathBuffer), length, kCFAllocatorNull));    RetainPtr<CFURLRef> dllURL(AdoptCF, CFURLCreateWithFileSystemPath(0, dllPath.get(), kCFURLWindowsPathStyle, false));    RetainPtr<CFURLRef> dllDirectoryURL(AdoptCF, CFURLCreateCopyDeletingLastPathComponent(0, dllURL.get()));    RetainPtr<CFURLRef> resourcesDirectoryURL(AdoptCF, CFURLCreateCopyAppendingPathComponent(0, dllDirectoryURL.get(), CFSTR("WebKit.resources"), true));    return CFBundleCreate(0, resourcesDirectoryURL.get());}

	bool loadLibrary (const char* fileName)	{	#if _WIN32		module = LoadLibrary (fileName);	#elif TARGET_API_MAC_CARBON		CFStringRef fileNameString = CFStringCreateWithCString (NULL, fileName, kCFStringEncodingUTF8);		if (fileNameString == 0)			return false;		CFURLRef url = CFURLCreateWithFileSystemPath (NULL, fileNameString, kCFURLPOSIXPathStyle, false);		CFRelease (fileNameString);		if (url == 0)			return false;		module = CFBundleCreate (NULL, url);		CFRelease (url);		if (module && CFBundleLoadExecutable ((CFBundleRef)module) == false)			return false;	#endif		return module != 0;	}

static CFBundleRef_glitz_agl_get_bundle (const char *name){    CFBundleRef bundle = 0;    FSRefParam ref_param;    char framework_name[256];    framework_name[0] = strlen (name);    strcpy (&framework_name[1], name);    memset (&ref_param, 0, sizeof (ref_param));    if (FindFolder (kSystemDomain,		    kFrameworksFolderType,		    kDontCreateFolder,		    &ref_param.ioVRefNum,		    &ref_param.ioDirID) == noErr) {	FSRef ref;	memset (&ref, 0, sizeof (ref));	ref_param.ioNamePtr = (unsigned char *) framework_name;	ref_param.newRef = &ref;	if (PBMakeFSRefSync (&ref_param) == noErr) {	    CFURLRef url;	    url = CFURLCreateFromFSRef (kCFAllocatorDefault, &ref);	    if (url) {		bundle = CFBundleCreate (kCFAllocatorDefault, url);		CFRelease (url);		if (!CFBundleLoadExecutable (bundle)) {		    CFRelease (bundle);		    return (CFBundleRef) 0;		}	    }	}    }    return bundle;}

/* Built-in callback for POSIX domain. Note that we will pick up localizations from ErrnoErrors.strings in /System/Library/CoreServices/CoreTypes.bundle, if the file happens to be there.*/static CFTypeRef _CFErrorPOSIXCallBack(CFErrorRef err, CFStringRef key) {    if (!CFEqual(key, kCFErrorDescriptionKey) && !CFEqual(key, kCFErrorLocalizedFailureReasonKey)) return NULL;        const char *errCStr = strerror(CFErrorGetCode(err));    CFStringRef errStr = (errCStr && strlen(errCStr)) ? CFStringCreateWithCString(kCFAllocatorSystemDefault, errCStr, kCFStringEncodingUTF8) : NULL;        if (!errStr) return NULL;    if (CFEqual(key, kCFErrorDescriptionKey)) return errStr;	// If all we wanted was the non-localized description, we're done    #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS    // We need a kCFErrorLocalizedFailureReasonKey, so look up a possible localization for the error message    // Look for the bundle in /System/Library/CoreServices/CoreTypes.bundle    CFArrayRef paths = CFCopySearchPathForDirectoriesInDomains(kCFLibraryDirectory, kCFSystemDomainMask, false);    if (paths) {	if (CFArrayGetCount(paths) > 0) {	    CFStringRef path = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("%@/CoreServices/CoreTypes.bundle"), CFArrayGetValueAtIndex(paths, 0));	    CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault, path, kCFURLPOSIXPathStyle, false /* not a directory */);	    if (url) {		CFBundleRef bundle = CFBundleCreate(kCFAllocatorSystemDefault, url);		if (bundle) {		    // We only want to return a result if there was a localization		    CFStringRef localizedErrStr = CFBundleCopyLocalizedString(bundle, errStr, errStr, CFSTR("ErrnoErrors"));		    if (localizedErrStr == errStr) {			CFRelease(localizedErrStr);			CFRelease(errStr);			errStr = NULL;		    } else {			CFRelease(errStr);			errStr = localizedErrStr;		    }		    CFRelease(bundle);		}		CFRelease(url);	    }	    CFRelease(path);	}	CFRelease(paths);    }#endif        return errStr;}

Image JUCE_API getIconFromApplication (const String& applicationPath, const int size){    Image hostIcon;    if (CFStringRef pathCFString = CFStringCreateWithCString (kCFAllocatorDefault, applicationPath.toRawUTF8(), kCFStringEncodingUTF8))    {        if (CFURLRef url = CFURLCreateWithFileSystemPath (kCFAllocatorDefault, pathCFString, kCFURLPOSIXPathStyle, 1))        {            if (CFBundleRef appBundle = CFBundleCreate (kCFAllocatorDefault, url))            {                if (CFTypeRef infoValue = CFBundleGetValueForInfoDictionaryKey (appBundle, CFSTR("CFBundleIconFile")))                {                    if (CFGetTypeID (infoValue) == CFStringGetTypeID())                    {                        CFStringRef iconFilename = reinterpret_cast<CFStringRef> (infoValue);                        CFStringRef resourceURLSuffix = CFStringHasSuffix (iconFilename, CFSTR(".icns")) ? nullptr : CFSTR("icns");                        if (CFURLRef iconURL = CFBundleCopyResourceURL (appBundle, iconFilename, resourceURLSuffix, nullptr))                        {                            if (CFStringRef iconPath = CFURLCopyFileSystemPath (iconURL, kCFURLPOSIXPathStyle))                            {                                File icnsFile (CFStringGetCStringPtr (iconPath, CFStringGetSystemEncoding()));                                hostIcon = getIconFromIcnsFile (icnsFile, size);                                CFRelease (iconPath);                            }                            CFRelease (iconURL);                        }                    }                }                CFRelease (appBundle);            }            CFRelease (url);        }        CFRelease (pathCFString);    }    return hostIcon;}

void	InitDeckLinkAPI (void){	CFURLRef		bundleURL;	bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR(kDeckLinkAPI_BundlePath), kCFURLPOSIXPathStyle, true);	if (bundleURL != NULL)	{		gDeckLinkAPIBundleRef = CFBundleCreate(kCFAllocatorDefault, bundleURL);		if (gDeckLinkAPIBundleRef != NULL)		{			gCreateIteratorFunc = (CreateIteratorFunc)CFBundleGetFunctionPointerForName(gDeckLinkAPIBundleRef, CFSTR("CreateDeckLinkIteratorInstance_0003"));			gCreateAPIInformationFunc = (CreateAPIInformationFunc)CFBundleGetFunctionPointerForName(gDeckLinkAPIBundleRef, CFSTR("CreateDeckLinkAPIInformationInstance_0001"));			gCreateOpenGLPreviewFunc = (CreateOpenGLScreenPreviewHelperFunc)CFBundleGetFunctionPointerForName(gDeckLinkAPIBundleRef, CFSTR("CreateOpenGLScreenPreviewHelper_0001"));			gCreateCocoaPreviewFunc = (CreateCocoaScreenPreviewFunc)CFBundleGetFunctionPointerForName(gDeckLinkAPIBundleRef, CFSTR("CreateCocoaScreenPreview_0001"));			gCreateVideoConversionFunc = (CreateVideoConversionInstanceFunc)CFBundleGetFunctionPointerForName(gDeckLinkAPIBundleRef, CFSTR("CreateVideoConversionInstance_0001"));            gCreateDeckLinkDiscoveryFunc = (CreateDeckLinkDiscoveryInstanceFunc)CFBundleGetFunctionPointerForName(gDeckLinkAPIBundleRef, CFSTR("CreateDeckLinkDiscoveryInstance_0002"));            gCreateVideoFrameAncillaryPacketsFunc = (CreateVideoFrameAncillaryPacketsInstanceFunc)CFBundleGetFunctionPointerForName(gDeckLinkAPIBundleRef, CFSTR("CreateVideoFrameAncillaryPacketsInstance_0001"));		}		CFRelease(bundleURL);	}}

static void InitializeIO(){    if (sfwRefCount++) {        return;    }    // race condition, infinitesimal risk    FSRef theRef;    if (FSFindFolder(kOnAppropriateDisk, kFrameworksFolderType, false, &theRef)            == noErr) {        CFURLRef fw = CFURLCreateFromFSRef(kCFAllocatorSystemDefault, &theRef);        if (fw) {            CFURLRef bd = CFURLCreateCopyAppendingPathComponent                          (kCFAllocatorSystemDefault, fw, CFSTR("System.framework"), false);            CFRelease(fw);            if (bd) {                systemFramework = CFBundleCreate(kCFAllocatorSystemDefault, bd);                CFRelease(bd);            }        }        if (!systemFramework || !CFBundleLoadExecutable(systemFramework)) {            return;        }#define F(x) CFBundleGetFunctionPointerForName(systemFramework, CFSTR(#x))        my_fopen = (FILE * (*)(const char *, const char *))F(fopen);        my_fclose = (int(*)(FILE *))F(fclose);        my_ftell = (long(*)(FILE *))F(ftell);        my_fseek = (int(*)(FILE *, long, int))F(fseek);        my_fread = (t4_u32(*)(void *ptr, t4_u32, t4_u32, FILE *))F(fread);        my_fwrite = (t4_u32(*)(const void *ptr, t4_u32, t4_u32, FILE *))F(fwrite);        my_ferror = (int(*)(FILE *))F(ferror);        my_fflush = (int(*)(FILE *))F(fflush);        my_fileno = (int(*)(FILE *))F(fileno);        my_mmap = (char *(*)(char *, t4_u32, int, int, int, long long))F(mmap);        my_munmap = (int(*)(char *, t4_u32))F(munmap);#undef F        d4_assert(my_fopen && my_fclose && my_ftell && my_fseek && my_fread &&                  my_fwrite && my_ferror && my_fflush && my_fileno && my_mmap && my_munmap);    }}

//------------------------------------------------------------------------void CreateVSTGUIBundleRef (){	openCount++;	if (gBundleRef)	{		CFRetain (gBundleRef);		return;	}#if TARGET_OS_IPHONE	gBundleRef = CFBundleGetMainBundle ();	CFRetain (gBundleRef);#else	Dl_info info;	if (dladdr ((const void*)CreateVSTGUIBundleRef, &info))	{		if (info.dli_fname)		{			Steinberg::String name;			name.assign (info.dli_fname);			for (int i = 0; i < 3; i++)			{				int delPos = name.findLast ('/');				if (delPos == -1)				{					fprintf (stdout, "Could not determine bundle location./n");					return; // unexpected				}				name.remove (delPos, name.length () - delPos);			}			CFURLRef bundleUrl = CFURLCreateFromFileSystemRepresentation (0, (const UInt8*)name.text8 (), name.length (), true);			if (bundleUrl)			{				gBundleRef = CFBundleCreate (0, bundleUrl);				CFRelease (bundleUrl);			}		}	}#endif}

void *platGetProcAddress( const char *funcName ){#if defined( PLATFORM_WIN )	return (void *)wglGetProcAddress( funcName );#elif defined( PLATFORM_WIN_CE )	return (void *)eglGetProcAddress( funcName );#elif defined( PLATFORM_MAC )	CFStringRef functionName = CFStringCreateWithCString( kCFAllocatorDefault, funcName, kCFStringEncodingASCII );	CFURLRef bundleURL = CFURLCreateWithFileSystemPath(		kCFAllocatorDefault, CFSTR( "/System/Library/Frameworks/OpenGL.framework" ), kCFURLPOSIXPathStyle, true );	CFBundleRef bundle = CFBundleCreate( kCFAllocatorDefault, bundleURL );   	void *function = CFBundleGetFunctionPointerForName( bundle, functionName );   	CFRelease( bundle );	CFRelease( bundleURL );	CFRelease( functionName );   	return function; #else	return (void *)glXGetProcAddressARB( (const GLubyte *)funcName );#endif}

LibraryHandle getLibraryHandleForPlugin(const CharString pluginAbsolutePath) {  // Create a path to the bundle  CFStringRef pluginPathStringRef = CFStringCreateWithCString(NULL, pluginAbsolutePath->data, kCFStringEncodingASCII);  CFURLRef bundleUrl = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, pluginPathStringRef, kCFURLPOSIXPathStyle, true);  if(bundleUrl == NULL) {    logError("Couldn't make URL reference for plugin");    return NULL;  }  // Open the bundle  CFBundleRef bundleRef = CFBundleCreate(kCFAllocatorDefault, bundleUrl);  if(bundleRef == NULL) {    logError("Couldn't create bundle reference");    CFRelease(pluginPathStringRef);    CFRelease(bundleUrl);    return NULL;  }  // Clean up  CFRelease(pluginPathStringRef);  CFRelease(bundleUrl);  return bundleRef;}

	static OSErr __msl_CreateFrameworkBundleFromName(CFStringRef theFrameworkName,		CFBundleRef *theBundle)	{		OSErr theErr;		FSRef theRef;		CFURLRef theFrameworkURL;		CFURLRef theBundleURL;				/* Find the folder containing all the frameworks */		theErr = FSFindFolder(kOnAppropriateDisk, kFrameworksFolderType, false, &theRef);				if (theErr == noErr)		{			/* Turn the framework folder FSRef into a CFURL */			theFrameworkURL = CFURLCreateFromFSRef(kCFAllocatorSystemDefault, &theRef);						if (theFrameworkURL != NULL)			{				/* Create a CFURL pointing to the desired framework */				theBundleURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault,					theFrameworkURL, theFrameworkName, false);								CFRelease(theFrameworkURL);								if (theBundleURL != NULL)				{					/* Turn the CFURL into a bundle reference */					*theBundle = CFBundleCreate(kCFAllocatorSystemDefault, theBundleURL);										CFRelease(theBundleURL);				}			}		}				return theErr;	}

 int load(std::string name) {     int rval = -1;     vstPluginMain pluginMain = NULL;     CFStringRef path = NULL;     CFURLRef urlRef = NULL;     CFURLRef exeRef = NULL;     Boolean success;          // Start clean     m_bundle = NULL;          // Don't really know what this should be initialize to     m_resource = -1;          // Convert the path to a CFSTring     path = CFStringCreateWithCString(NULL, name.c_str(), kCFStringEncodingUTF8);           // Convert the path to a URL     urlRef = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,                                            path,                                            kCFURLPOSIXPathStyle,                                            true);          if (urlRef == NULL) goto error;             // Create the bundle using the URL     m_bundle = CFBundleCreate(kCFAllocatorDefault, urlRef);                  // Bail if the bundle wasn't created     if (m_bundle == NULL) goto error;          // Retrieve a reference to the executable     exeRef = CFBundleCopyExecutableURL(m_bundle);     if (exeRef == NULL) goto error;          // Convert back to path     UInt8 exePath[PATH_MAX];     if(!CFURLGetFileSystemRepresentation(exeRef, true, exePath, sizeof(exePath)))         goto error;          // Attempt to open it     m_module = dlopen((char *) exePath, RTLD_NOW | RTLD_LOCAL);     if (m_module == NULL) goto error;          // Try to locate the new plugin entry point     pluginMain = (vstPluginMain) dlsym(m_module, "VSTPluginMain");          // If not found, try finding the old entry point     if (pluginMain == NULL) {         pluginMain = (vstPluginMain) dlsym(m_module, "main_macho");     }          // Must not be a VST plugin     if (pluginMain == NULL) goto error;          // Open the resource map ... some plugins (like GRM Tools) need this.     m_resource = CFBundleOpenBundleResourceMap(m_bundle);          // Initialize the plugin     m_effect = pluginMain(audioMaster);          // Was it successful?     if(!m_effect) goto error;          m_effect->user = this;          //     callDispatcher(effOpen, 0, 0, NULL, 0.0);          // Ensure that it looks like a plugin and can deal with ProcessReplacing     // calls.  Also exclude synths for now.     if(m_effect->magic == kEffectMagic &&        !(m_effect->flags & effFlagsIsSynth) &&        m_effect->flags & effFlagsCanReplacing)     {                  //                mVendor = GetString(effGetVendorString);         //                mName = GetString(effGetEffectName);         //                mInputs = mAEffect->numInputs;         //                mOutputs = mAEffect->numOutputs;                  // We could even go so far as to run a small test here.                      rval = 0;         goto cleanup;     }     else     {         goto error;     }      error:     if(m_effect) { callDispatcher(effClose, 0, 0, NULL, 0.0); m_effect = NULL; }     if(m_resource != -1) { CFBundleCloseBundleResourceMap(m_bundle, m_resource); m_resource = -1; }     if(m_module) { dlclose(m_module); m_module = NULL; }     if(m_bundle) { CFRelease(m_bundle); m_bundle = NULL; }     if(pluginMain) { pluginMain = NULL; }      cleanup:     if(exeRef) { CFRelease(exeRef); exeRef = NULL; }//.........这里部分代码省略.........

  bool open(std::string name, const t_canvas*canvas) {    bool loud=false;    const char*hookname="plugMain";    if(name.empty())      return false;    if(m_plugin)      close();    FF_Main_FuncPtr plugmain = NULL;    char buf[MAXPDSTRING];    char buf2[MAXPDSTRING];    char *bufptr=NULL;    const char *extension=#ifdef _WIN32      ".dll";#elif defined __APPLE__    "";#else    ".so";#endif#ifdef __APPLE__    char buf3[MAXPDSTRING];#ifdef DL_OPEN    snprintf(buf3, MAXPDSTRING, "%s.frf/Contents/MacOS/%s", name.c_str(), name.c_str());#else    // this can never work...    snprintf(buf3, MAXPDSTRING, "%s.frf/%s", name.c_str(), name.c_str());#endif    buf3[MAXPDSTRING-1]=0;    name=buf3;#endif    int fd=-1;    if ((fd=canvas_open(const_cast<t_canvas*>(canvas), name.c_str(), extension, buf2, &bufptr, MAXPDSTRING, 1))>=0){      ::close(fd);#if defined __APPLE__ && 0      snprintf(buf, MAXPDSTRING, "%s", buf2);#else      snprintf(buf, MAXPDSTRING, "%s/%s", buf2, bufptr);#endif      buf[MAXPDSTRING-1]=0;    } else {      if(canvas) {        canvas_makefilename(const_cast<t_canvas*>(canvas), const_cast<char*>(name.c_str()), buf, MAXPDSTRING);      } else {        if(loud)::error("pix_freeframe[%s]: unfindeable", name.c_str());        return false;      }    }    name=buf;    std::string libname = name;    if(loud)::post("trying to load %s", buf);#ifdef DL_OPEN    if(loud)::post("dlopen %s", libname.c_str());    m_dlhandle=dlopen(libname.c_str(), RTLD_NOW);    if(!m_dlhandle){      if(loud)::error("pix_freeframe[%s]: %s", libname.c_str(), dlerror());      return NULL;    }    dlerror();    plugmain = reinterpret_cast<FF_Main_FuncPtr>(dlsym(m_dlhandle, hookname));#elif defined __APPLE__    CFURLRef bundleURL = NULL;    CFBundleRef theBundle = NULL;    CFStringRef plugin = CFStringCreateWithCString(NULL,                                                   libname.c_str(), kCFStringEncodingMacRoman);    bundleURL = CFURLCreateWithFileSystemPath( kCFAllocatorSystemDefault,                                               plugin,                                               kCFURLPOSIXPathStyle,                                               true );    theBundle = CFBundleCreate( kCFAllocatorSystemDefault, bundleURL );    // Get a pointer to the function.    if (theBundle){      plugmain = reinterpret_cast<FF_Main_FuncPtr>(CFBundleGetFunctionPointerForName(                                                                                     theBundle, CFSTR("plugMain") )                                                   );    }else{      if(loud)::post("%s: couldn't load", libname.c_str());      return 0;    }    if(bundleURL != NULL) CFRelease( bundleURL );    if(theBundle != NULL) CFRelease( theBundle );    if(plugin != NULL)    CFRelease( plugin );#elif defined _WIN32    char buffer[MAXPDSTRING];    sys_bashfilename(libname.c_str(), buffer);    libname=buffer;    m_w32handle = LoadLibrary(libname.c_str());    if (!m_w32handle) {      if(loud)::post("%s: couldn't load", libname.c_str());//.........这里部分代码省略.........

//.........这里部分代码省略.........    } else {        dlFlags |= RTLD_LAZY;    }    if (loadHints & QLibrary::ExportExternalSymbolsHint) {        dlFlags |= RTLD_GLOBAL;    }#if !defined(Q_OS_CYGWIN)    else {#if defined(Q_OS_MAC)        if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4)#endif            dlFlags |= RTLD_LOCAL;    }#endif    // Provide access to RTLD_NODELETE flag on Unix    // From GNU documentation on RTLD_NODELETE:    // Do not unload the library during dlclose(). Consequently, the    // library's specific static variables are not reinitialized if the    // library is reloaded with dlopen() at a later time.#ifdef RTLD_NODELETE    if (loadHints & QLibrary::PreventUnloadHint) {        dlFlags |= RTLD_NODELETE;    }#endif#if defined(Q_OS_AIX)	// Not sure if any other platform actually support this thing.    if (loadHints & QLibrary::LoadArchiveMemberHint) {        dlFlags |= RTLD_MEMBER;    }#endif#endif // QT_HPUX_LD    // If the filename is an absolute path then we want to try that first as it is most likely    // what the callee wants. If we have been given a non-absolute path then lets try the    // native library name first to avoid unnecessary calls to dlopen().    if (fsEntry.isAbsolute()) {        suffixes.prepend(QString());        prefixes.prepend(QString());    } else {        suffixes.append(QString());        prefixes.append(QString());    }    bool retry = true;    for(int prefix = 0; retry && !pHnd && prefix < prefixes.size(); prefix++) {        for(int suffix = 0; retry && !pHnd && suffix < suffixes.size(); suffix++) {            if (!prefixes.at(prefix).isEmpty() && name.startsWith(prefixes.at(prefix)))                continue;            if (!suffixes.at(suffix).isEmpty() && name.endsWith(suffixes.at(suffix)))                continue;            if (loadHints & QLibrary::LoadArchiveMemberHint) {                attempt = name;                int lparen = attempt.indexOf(QLatin1Char('('));                if (lparen == -1)                    lparen = attempt.count();                attempt = path + prefixes.at(prefix) + attempt.insert(lparen, suffixes.at(suffix));            } else {                attempt = path + prefixes.at(prefix) + name + suffixes.at(suffix);            }#if defined(QT_HPUX_LD)            pHnd = (void*)shl_load(QFile::encodeName(attempt), dlFlags, 0);#else            pHnd = dlopen(QFile::encodeName(attempt), dlFlags);#endif            if (!pHnd && fileName.startsWith(QLatin1Char('/')) && QFile::exists(attempt)) {                // We only want to continue if dlopen failed due to that the shared library did not exist.                // However, we are only able to apply this check for absolute filenames (since they are                // not influenced by the content of LD_LIBRARY_PATH, /etc/ld.so.cache, DT_RPATH etc...)                // This is all because dlerror is flawed and cannot tell us the reason why it failed.                retry = false;            }        }    }#ifdef Q_OS_MAC    if (!pHnd) {        QByteArray utf8Bundle = fileName.toUtf8();        QCFType<CFURLRef> bundleUrl = CFURLCreateFromFileSystemRepresentation(NULL, reinterpret_cast<const UInt8*>(utf8Bundle.data()), utf8Bundle.length(), true);        QCFType<CFBundleRef> bundle = CFBundleCreate(NULL, bundleUrl);        if(bundle) {            QCFType<CFURLRef> url = CFBundleCopyExecutableURL(bundle);            char executableFile[FILENAME_MAX];            CFURLGetFileSystemRepresentation(url, true, reinterpret_cast<UInt8*>(executableFile), FILENAME_MAX);            attempt = QString::fromUtf8(executableFile);            pHnd = dlopen(QFile::encodeName(attempt), dlFlags);        }    }#endif#endif // QT_NO_DYNAMIC_LIBRARY    if (!pHnd) {        errorString = QLibrary::tr("Cannot load library %1: %2").arg(fileName).arg(qdlerror());    }    if (pHnd) {        qualifiedFileName = attempt;        errorString.clear();    }    return (pHnd != 0);}

static CFBundleRef findMe(){    CFURLRef    bundleURL;    CFBundleRef myBundle;    Boolean didLoad = false;    // Make a CFURLRef from the CFString representation of the     // bundle's path. See the Core Foundation URL Services chapter     // for details.    bundleURL = CFURLCreateWithFileSystemPath(                     kCFAllocatorDefault,                     CFSTR("/System/Library/Extensions/DVFamily.bundle"),                    kCFURLPOSIXPathStyle,                    true );        printf("Bundle URL: %p/n", bundleURL);    // Make a bundle instance using the URLRef.    myBundle = CFBundleCreate( kCFAllocatorDefault, bundleURL );    printf("Bundle: %p/n", myBundle);    // Try to load the executable from my bundle.    didLoad = CFBundleLoadExecutable( myBundle );    printf("loaded? %d/n", didLoad);        sDVFuncs.fDVCountDevices = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVCountDevices") );    sDVFuncs.fDVGetIndDevice = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVGetIndDevice") );    sDVFuncs.fDVSetDeviceName = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVSetDeviceName") );    sDVFuncs.fDVGetDeviceName = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVGetDeviceName") );    sDVFuncs.fDVOpenDriver = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVOpenDriver") );    sDVFuncs.fDVCloseDriver = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVCloseDriver") );// AVC Stuff    sDVFuncs.fDVDoAVCTransaction = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVDoAVCTransaction") );    sDVFuncs.fDVIsEnabled = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVIsEnabled") );    sDVFuncs.fDVGetDeviceStandard = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVGetDeviceStandard") );// Isoch I/O    sDVFuncs.fDVEnableRead = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVEnableRead") );    sDVFuncs.fDVDisableRead = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVDisableRead") );    sDVFuncs.fDVReadFrame = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVReadFrame") );    sDVFuncs.fDVReleaseFrame = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVReleaseFrame") );    sDVFuncs.fDVEnableWrite = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVEnableWrite") );    sDVFuncs.fDVDisableWrite = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVDisableWrite") );    sDVFuncs.fDVGetEmptyFrame = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVGetEmptyFrame") );    sDVFuncs.fDVWriteFrame = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVWriteFrame") );// Notifications    sDVFuncs.fDVNewNotification = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVNewNotification") );    sDVFuncs.fDVNotifyMeWhen = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVNotifyMeWhen") );    sDVFuncs.fDVCancelNotification = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVCancelNotification") );    sDVFuncs.fDVDisposeNotification = CFBundleGetFunctionPointerForName(                 myBundle, CFSTR("DVDisposeNotification") );    // Any CF objects returned from functions with "create" or     // "copy" in their names must be released by us!    CFRelease( bundleURL );    return myBundle;}

	mach_error_tload_bundle_package(		const char *bundlePackageFileSystemRepresentation ){	printf("LBP/n");	assert( bundlePackageFileSystemRepresentation );	assert( strlen( bundlePackageFileSystemRepresentation ) );		mach_error_t err = err_none;	mach_error("mach error on bundle load", err);	//	Morph the FSR into a URL.	CFURLRef bundlePackageURL = NULL;	if( !err ) {		bundlePackageURL = CFURLCreateFromFileSystemRepresentation(			kCFAllocatorDefault,			(const UInt8*)bundlePackageFileSystemRepresentation,			strlen(bundlePackageFileSystemRepresentation),			true );		if( bundlePackageURL == NULL )			err = err_load_bundle_url_from_path;	}	mach_error("mach error on bundle load", err);	//	Create bundle.	CFBundleRef bundle = NULL;	if( !err ) {		bundle = CFBundleCreate( kCFAllocatorDefault, bundlePackageURL );		if( bundle == NULL )			err = err_load_bundle_create_bundle;	}	mach_error("mach error on bundle load", err);	//	Discover the bundle's executable file.	CFURLRef bundleExecutableURL = NULL;	if( !err ) {		assert( bundle );		bundleExecutableURL = CFBundleCopyExecutableURL( bundle );		if( bundleExecutableURL == NULL )			err = err_load_bundle_package_executable_url;	}	mach_error("mach error on bundle load", err);	//	Morph the executable's URL into an FSR.	char bundleExecutableFileSystemRepresentation[PATH_MAX];	if( !err ) {		assert( bundleExecutableURL );		if( !CFURLGetFileSystemRepresentation(			bundleExecutableURL,			true,			(UInt8*)bundleExecutableFileSystemRepresentation,			sizeof(bundleExecutableFileSystemRepresentation) ) )		{			err = err_load_bundle_path_from_url;		}	}	mach_error("mach error on bundle load", err);	//	Do the real work.	if( !err ) {		assert( strlen(bundleExecutableFileSystemRepresentation) );		err = load_bundle_executable( bundleExecutableFileSystemRepresentation);	}		//	Clean up.	if( bundleExecutableURL )		CFRelease( bundleExecutableURL );	/*if( bundle )		CFRelease( bundle );*/	if( bundlePackageURL )		CFRelease( bundlePackageURL );		mach_error("mach error on bundle load", err);	return err;}

// hdll, pluginmain and audiomaster are set here// must be NULL beforehand!bool VSTPlugin::NewPlugin(const char *plugname){    FLEXT_ASSERT(!pluginmain && !audiomaster);    dllname = plugname;#if FLEXT_OS == FLEXT_OS_WIN    hdll = LoadLibraryEx(dllname.c_str(),NULL,0 /*DONT_RESOLVE_DLL_REFERENCES*/);/*    char buf[255],*c;    strcpy(buf,dllname.c_str());    for(c = buf; *c; ++c)         if(*c == '/')             *c = '//';    char *sl = strrchr(buf,'//');    if(sl) *sl = 0;    SetCurrentDirectory(buf);    hdll = LoadLibrary(dllname.c_str());*/    if(hdll) pluginmain = (PVSTMAIN)GetProcAddress(hdll,"main");    audiomaster = Master;  #elif FLEXT_OS == FLEXT_OS_MAC#if 1	CFStringRef fileNameString = CFStringCreateWithCString(NULL, fileName, kCFStringEncodingUTF8);	if(fileNameString == 0) goto bail;	CFURLRef url = CFURLCreateWithFileSystemPath(NULL, fileNameString, kCFURLPOSIXPathStyle, false);	CFRelease(fileNameString);	if(url == 0) goto bail;	hdll = CFBundleCreate(NULL, url);	CFRelease (url);	if(hdll && !CFBundleLoadExecutable(hdll)) goto bail;    PVSTMAIN mainaddr = PluginEntryProc)CFBundleGetFunctionPointerForName(hdll, CFSTR("VSTPluginMain"));	if(!mainaddr)		mainaddr = (PluginEntryProc)CFBundleGetFunctionPointerForName(hdll, CFSTR("main_macho"));#ifdef __CFM__    pluginmain = (PVSTMAIN)NewMachOFromCFM(mainaddr);    audiomaster = NewCFMFromMachO(Master);#else    pluginmain = (PVSTMAIN)mainaddr;    audiomaster = Master;#endif#else    short   resFileID;    FSSpec  spec;    OSErr err;    err = FSPathMakeFSSpec(dllname.c_str(),&spec,NULL);    resFileID = FSpOpenResFile(&spec, fsRdPerm);    short cResCB = Count1Resources('aEff');    for(int i = 0; i < cResCB; i++) {        Handle             codeH;        CFragConnectionID  connID;        Ptr                mainAddr;        Str255             errName;        Str255             fragName;        char               fragNameCStr[256];        short              resID;        OSType             resType;        codeH = Get1IndResource('aEff', short(i+1));        if(!codeH) continue;        GetResInfo(codeH, &resID, &resType, fragName);        DetachResource(codeH);        HLock(codeH);        err = GetMemFragment(*codeH,                             GetHandleSize(codeH),                             fragName,                             kPrivateCFragCopy,                             &connID, (Ptr *) & mainAddr, errName);        if(!err) {           #ifdef __CFM__           pluginmain = (PVSTMAIN)NewMachOFromCFM(mainAddr);           #else           pluginmain = (PVSTMAIN)mainAddr;           #endif        }    }    CloseResFile(resFileID);    audiomaster = #ifdef __CFM__        NewCFMFromMachO(Master);#else        Master;#endif#endif#else#error Platform not supported//.........这里部分代码省略.........

intTcl_MacOSXOpenVersionedBundleResources(    Tcl_Interp *interp,    const char *bundleName,    const char *bundleVersion,    int hasResourceFile,    int maxPathLen,    char *libraryPath){#ifdef HAVE_COREFOUNDATION    CFBundleRef bundleRef, versionedBundleRef = NULL;    CFStringRef bundleNameRef;    CFURLRef libURL;    libraryPath[0] = '/0';    bundleNameRef = CFStringCreateWithCString(NULL, bundleName,	    kCFStringEncodingUTF8);    bundleRef = CFBundleGetBundleWithIdentifier(bundleNameRef);    CFRelease(bundleNameRef);    if (bundleVersion && bundleRef) {	/*	 * Create bundle from bundleVersion subdirectory of 'Versions'.	 */	CFURLRef bundleURL = CFBundleCopyBundleURL(bundleRef);	if (bundleURL) {	    CFStringRef bundleVersionRef = CFStringCreateWithCString(NULL,		    bundleVersion, kCFStringEncodingUTF8);	    if (bundleVersionRef) {		CFStringRef bundleTailRef = CFURLCopyLastPathComponent(			bundleURL);		if (bundleTailRef) {		    if (CFStringCompare(bundleTailRef, bundleVersionRef, 0) ==			    kCFCompareEqualTo) {			versionedBundleRef = (CFBundleRef) CFRetain(bundleRef);		    }		    CFRelease(bundleTailRef);		}		if (!versionedBundleRef) {		    CFURLRef versURL = CFURLCreateCopyAppendingPathComponent(			    NULL, bundleURL, CFSTR("Versions"), TRUE);		    if (versURL) {			CFURLRef versionedBundleURL =				CFURLCreateCopyAppendingPathComponent(				NULL, versURL, bundleVersionRef, TRUE);			if (versionedBundleURL) {			    versionedBundleRef = CFBundleCreate(NULL,				    versionedBundleURL);			    CFRelease(versionedBundleURL);			}			CFRelease(versURL);		    }		}		CFRelease(bundleVersionRef);	    }	    CFRelease(bundleURL);	}	if (versionedBundleRef) {	    bundleRef = versionedBundleRef;	}    }    if (bundleRef) {	if (hasResourceFile) {	    /*	     * Dynamically acquire address for CFBundleOpenBundleResourceMap	     * symbol, since it is only present in full CoreFoundation on Mac	     * OS X and not in CFLite on pure Darwin.	     */	    static int initialized = FALSE;	    static short (*openresourcemap)(CFBundleRef) = NULL;	    if (!initialized) {#if TCL_DYLD_USE_DLFCN#if MAC_OS_X_VERSION_MIN_REQUIRED < 1040		if (tclMacOSXDarwinRelease >= 8)#endif		{		    const char *errMsg = nil;		    openresourcemap = dlsym(RTLD_NEXT,			    "CFBundleOpenBundleResourceMap");		    if (!openresourcemap) {			errMsg = dlerror();			TclLoadDbgMsg("dlsym() failed: %s", errMsg);		    }		}		if (!openresourcemap)#endif		{#if TCL_DYLD_USE_NSMODULE		    NSSymbol nsSymbol = NULL;		    if (NSIsSymbolNameDefinedWithHint(//.........这里部分代码省略.........

	mach_error_tmach_inject_bundle_pid(		const char	*bundlePackageFileSystemRepresentation,		pid_t		pid ){	assert( bundlePackageFileSystemRepresentation );	assert( pid > 0 );		mach_error_t	err = err_none;	    /*	//	Get the framework's bundle.	CFBundleRef frameworkBundle = NULL;	if( !err ) {		frameworkBundle = CFBundleGetBundleWithIdentifier(			CFSTR("com.flyingmeat.JSTalk"));		if( frameworkBundle == NULL )			err = err_mach_inject_bundle_couldnt_load_framework_bundle;	}		//	Find the injection bundle by name.	CFURLRef injectionURL = NULL;	if( !err ) {		injectionURL = CFBundleCopyResourceURL( frameworkBundle,			CFSTR("mach_inject_bundle_stub.bundle"), NULL, NULL );		if( !injectionURL )			err = err_mach_inject_bundle_couldnt_find_injection_bundle;	}	*/        CFStringRef filePath = CFStringCreateWithCString(nil, bundlePackageFileSystemRepresentation, kCFStringEncodingUTF8);    CFURLRef injectionURL = CFURLCreateWithFileSystemPath(nil, filePath, kCFURLPOSIXPathStyle, true);        //CFRelease(filePath);    	//	Create injection bundle instance.	CFBundleRef injectionBundle = NULL;	if( !err ) {		injectionBundle = CFBundleCreate( kCFAllocatorDefault, injectionURL );		if( !injectionBundle )			err = err_mach_inject_bundle_couldnt_load_injection_bundle;	}		//	Load the thread code injection.	void *injectionCode = injectEntry;    /*	if( !err ) {		injectionCode = CFBundleGetFunctionPointerForName( injectionBundle,			CFSTR( INJECT_ENTRY_SYMBOL ));		if( injectionCode == NULL )			err = err_mach_inject_bundle_couldnt_find_inject_entry_symbol;	}	*/    	//	Allocate and populate the parameter block.	mach_inject_bundle_stub_param *param = NULL;	size_t paramSize;	if( !err ) {		size_t bundlePathSize = strlen( bundlePackageFileSystemRepresentation )			+ 1;		paramSize = sizeof( ptrdiff_t ) + bundlePathSize;		param = malloc( paramSize );		bcopy( bundlePackageFileSystemRepresentation,			   param->bundlePackageFileSystemRepresentation,			   bundlePathSize );	}		//	Inject the code.	if( !err ) {		err = mach_inject( injectionCode, param, paramSize, pid, 0 );	}		//	Clean up.	if( param )		free( param );	if( injectionBundle )		CFRelease( injectionBundle );	if( injectionURL )		CFRelease( injectionURL );		return err;}

/* * LoadGlxBundle *  The Quartz mode X server needs to dynamically load the appropriate *  bundle before initializing GLX. */static void LoadGlxBundle(void){    CFBundleRef mainBundle;    CFStringRef bundleName;    CFURLRef    bundleURL;    CFBundleRef glxBundle;    // Get the main bundle for the application    mainBundle = CFBundleGetMainBundle();    // Choose the bundle to load    ErrorF("Loading GLX bundle ");    if (/*quartzUseAGL*/0) {        bundleName = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault,                                                     quartzOpenGLBundle,                                                     kCFStringEncodingASCII,                                                     kCFAllocatorNull);        ErrorF("%s (using Apple's OpenGL)/n", quartzOpenGLBundle);    } else {        bundleName = CFSTR("glxMesa.bundle");        CFRetain(bundleName);			// so we can release later        ErrorF("glxMesa.bundle (using Mesa)/n");    }    // Look for the appropriate GLX bundle in the main bundle by name    bundleURL = CFBundleCopyResourceURL(mainBundle, bundleName,                                        NULL, NULL);    if (!bundleURL) {        FatalError("Could not find GLX bundle.");    }    // Make a bundle instance using the URLRef    glxBundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);    if (!CFBundleLoadExecutable(glxBundle)) {        FatalError("Could not load GLX bundle.");    }    // Find the GLX init functions    __DarwinglXMesaProvider = (void *) CFBundleGetDataPointerForName(			       glxBundle, CFSTR("__glXMesaProvider"));    GlxPushProvider = (void *) CFBundleGetFunctionPointerForName(                                glxBundle, CFSTR("GlxPushProvider"));    GlxExtensionInit = (void *) CFBundleGetFunctionPointerForName(                                glxBundle, CFSTR("GlxExtensionInit"));    GlxWrapInitVisuals = (void *) CFBundleGetFunctionPointerForName(                                glxBundle, CFSTR("GlxWrapInitVisuals"));    if (!GlxExtensionInit || !GlxWrapInitVisuals) {        FatalError("Could not initialize GLX bundle.");    }    // Release the CF objects    CFRelease(bundleName);    CFRelease(bundleURL);}

CVST2KSPIPlugIn::CVST2KSPIPlugIn(CVST2KSPIModule* pModule, const std::string& sEffectPathName)	: CBasePlugIn(dynamic_cast<CBaseModule*>(pModule), giAudioMaxBufferSize, dynamic_cast<CBaseDSPEngine*>(new CEcho()), 0, COMPANY_NAME, PRODUCT_NAME),	mbUpdateGUISettings(true),	mbBypass(false), mbShowDemoExpiredDialog(false),	mbRegistered(false),	miNoiseMode(0), miNoiseCounter(0),	msEffectPathName(sEffectPathName),	mpVSTEffect(NULL){	dynamic_cast<CEcho*>(mpDSPEngine)->SetChannels(2);	mpDezipper->SetCallback(dynamic_cast<IBaseDezipperCallback*>(this));	mbCanProcess = true;	muiTimeWhenStarted = ITime::GetTimeMS();	miRandom = 0x123456;#ifdef WIN32	{		HMODULE hDLL;		// Load plug-in		std::string s2 = msEffectPathName;		ModifyPathName(s2);		hDLL = LoadLibrary(s2.c_str());		if (hDLL == NULL) {		}					VSTMainFunc mainFunc = (VSTMainFunc)(void*)GetProcAddress(hDLL, "VSTPluginMain");		if (mainFunc == NULL) {		}		try {			mpVSTEffect = mainFunc(audioMasterCallbackPlugIn);			mpVSTEffect->dispatcher(mpVSTEffect, effOpen, 0, 0, 0, 0.0);			mpVSTEffect->dispatcher(mpVSTEffect, effSetSampleRate, 0, 0, 0, 44100.0f);			mpVSTEffect->dispatcher(mpVSTEffect, effSetBlockSize, 0, 32, 0, 0.0);		}		catch(...) {			// Plug-in crashed			mpVSTEffect = NULL;		}	}#else	// WIN32	{		CFBundleRef BundleRef;		// Make a CFURLRef from the CFString representation of the bundle's path.		tchar pszPathName[1024];		strcpy(pszPathName, msEffectPathName.c_str());		ToUnix(pszPathName);		CFURLRef bundleURL = CFURLCreateWithFileSystemPath( 			kCFAllocatorDefault, 			__CFStringMakeConstantString(pszPathName),			kCFURLPOSIXPathStyle,			true );		if ( !bundleURL ) {		}		// Make a bundle instance using the URLRef.		BundleRef = CFBundleCreate( kCFAllocatorDefault, bundleURL );		// We don't need the URL anymore		CFRelease( bundleURL );			if ( !BundleRef ) {		}		if ( !CFBundleLoadExecutable( BundleRef ) )		{			CFRelease( BundleRef );			BundleRef = NULL;		}		VSTMainFunc mainFunc = (VSTMainFunc)CFBundleGetFunctionPointerForName( 					BundleRef, CFSTR("VSTPluginMain") );		if (mainFunc == NULL) {		}		try {			mpVSTEffect = mainFunc(audioMasterCallbackPlugIn);			mpVSTEffect->dispatcher(mpVSTEffect, effOpen, 0, 0, 0, 0.0);			mpVSTEffect->dispatcher(mpVSTEffect, effSetSampleRate, 0, 0, 0, 44100.0f);			mpVSTEffect->dispatcher(mpVSTEffect, effSetBlockSize, 0, 32, 0, 0.0);		}		catch(...) {			// Plug-in crashed			mpVSTEffect = NULL;		}	}#endif	// WIN32 / else}

bool CamulewebApp::GetTemplateDir(const wxString& templateName, wxString& templateDir){	wxString dir;	m_localTemplate = false;	DebugShow(wxT("looking for template: ") + templateName + wxT("/n"));#ifdef __WXMAC__	CFURLRef amuleBundleUrl;	OSStatus status = LSFindApplicationForInfo(		kLSUnknownCreator,		// This magic string is the bundle identifier in aMule.app's Info.plist		CFSTR("org.amule.aMule"),		NULL, NULL, &amuleBundleUrl);	if (status == noErr && amuleBundleUrl) {		CFBundleRef amuleBundle = CFBundleCreate(NULL, amuleBundleUrl);		CFRelease(amuleBundleUrl);		if (amuleBundle) {			CFURLRef webserverDirUrl = CFBundleCopyResourceURL(				amuleBundle,				CFSTR("webserver"),				NULL, NULL);			CFRelease(amuleBundle);			if (webserverDirUrl) {				CFURLRef absoluteURL =					CFURLCopyAbsoluteURL(webserverDirUrl);				CFRelease(webserverDirUrl);				if (absoluteURL) {					CFStringRef pathString =						CFURLCopyFileSystemPath(							absoluteURL,							kCFURLPOSIXPathStyle);					CFRelease(absoluteURL);					#if wxCHECK_VERSION(2, 9, 0)						dir = wxCFStringRef(pathString).						AsString(wxLocale::GetSystemEncoding());					#else						dir = wxMacCFStringHolder(pathString).						AsString(wxLocale::GetSystemEncoding());					#endif					if (CheckDirForTemplate(dir, templateName)) {						templateDir = dir;						return true;					}				}			}		}	}#endif	dir = GetConfigDir(wxT("remote.conf")) + wxT("webserver");	if (CheckDirForTemplate(dir, templateName)) {		templateDir = dir;		m_localTemplate = true;		return true;	}#ifdef WEBSERVERDIR	dir = wxT(WEBSERVERDIR);	if (CheckDirForTemplate(dir, templateName)) {		templateDir = dir;		return true;	}#endif		dir = wxStandardPaths::Get().GetResourcesDir();	// Returns 'aMule' when we use 'amule' elsewhere#if !defined(__WXMSW__) && !defined(__WXMAC__)	dir = dir.BeforeLast(wxFileName::GetPathSeparator());	dir = JoinPaths(dir, wxT("amule"));#endif	dir = JoinPaths(dir, wxT("webserver"));	if (CheckDirForTemplate(dir, templateName)) {		templateDir = dir;		return true;	}		// template not found. reverting to default	const wxChar* const defaultTemplateName = wxT("default");	if ( templateName == defaultTemplateName ) {		return false;	}	Show(wxT("Template ") + templateName + wxT(" not found, reverting to default/n/n"));	return GetTemplateDir(defaultTemplateName, templateDir);}