void LoadAudioUnits() { ComponentDescription desc; Component component; desc.componentType = kAudioUnitType_Effect; //'aufx' desc.componentSubType = 0; desc.componentManufacturer = 0; desc.componentFlags = 0; desc.componentFlagsMask = 0; component = FindNextComponent(NULL, &desc); while (component != NULL) { ComponentDescription found; Handle nameHandle = NewHandle(0); GetComponentInfo(component, &found, nameHandle, 0, 0); HLock(nameHandle); int len = ((const char *)(*nameHandle))[0]; wxString name((const char *)(*nameHandle)+1, len); HUnlock(nameHandle); DisposeHandle(nameHandle); Effect::RegisterEffect(new AudioUnitEffect(name, component)); component = FindNextComponent (component, &desc); } }
void ComponentMover_c::Dispose () { if (pattern1) { pattern1 -> Dispose(); delete pattern1; pattern1 = nil; } if (pattern2) { pattern2 -> Dispose(); delete pattern2; pattern2 = nil; } //For pyGnome, let python/cython manage memory for this object. #ifndef pyGNOME if (timeFile) { timeFile -> Dispose (); delete timeFile; timeFile = nil; } if (fAveragedWindsHdl) { DisposeHandle((Handle)fAveragedWindsHdl); fAveragedWindsHdl = 0; } #endif CurrentMover_c::Dispose (); }
//---------------------------------------- // SaveSettingsPreference // Saves a preference for a specified key from QuickTime UserData OSErr SaveSettingsPreference(CFStringRef inKey, UserData inUserData) { CFDataRef theCFSettings; Handle hSettings; OSErr err; if (NULL == inUserData) return paramErr; hSettings = NewHandle(0); err = MemError(); if (noErr == err) { err = PutUserDataIntoHandle(inUserData, hSettings); if (noErr == err) { HLock(hSettings); theCFSettings = CFDataCreate(kCFAllocatorDefault, (UInt8 *)*hSettings, GetHandleSize(hSettings)); if (theCFSettings) { CFPreferencesSetAppValue(inKey, theCFSettings, kCFPreferencesCurrentApplication); CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication); CFRelease(theCFSettings); } } DisposeHandle(hSettings); } return err; }
CFDataRef copyIconDataForURL(CFURLRef URL) { CFDataRef data = NULL; if (URL) { FSRef ref; if (CFURLGetFSRef(URL, &ref)) { IconRef icon = NULL; SInt16 label_noOneCares; OSStatus err = GetIconRefFromFileInfo(&ref, /*inFileNameLength*/ 0U, /*inFileName*/ NULL, kFSCatInfoNone, /*inCatalogInfo*/ NULL, kIconServicesNoBadgeFlag | kIconServicesUpdateIfNeededFlag, &icon, &label_noOneCares); if (err != noErr) { NSLog(CFSTR("in copyIconDataForURL in CFGrowlAdditions: could not get icon for %@: GetIconRefFromFileInfo returned %li\n"), URL, (long)err); } else { IconFamilyHandle fam = NULL; err = IconRefToIconFamily(icon, kSelectorAllAvailableData, &fam); if (err != noErr) { NSLog(CFSTR("in copyIconDataForURL in CFGrowlAdditions: could not get icon for %@: IconRefToIconFamily returned %li\n"), URL, (long)err); } else { HLock((Handle)fam); data = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)*(Handle)fam, GetHandleSize((Handle)fam)); HUnlock((Handle)fam); DisposeHandle((Handle)fam); } ReleaseIconRef(icon); } } } return data; }
void ROM_VideoQuit(_THIS) { int i; /* Free current video mode */ ROM_UnsetVideoMode(this, this->screen); if ( SDL_Window ) { DisposeWindow(SDL_Window); SDL_Window = nil; } /* Free palette and restore original one */ if ( SDL_CTab != nil ) { DisposeHandle((Handle)SDL_CTab); SDL_CTab = nil; } if ( SDL_CPal != nil ) { DisposePalette(SDL_CPal); SDL_CPal = nil; } RestoreDeviceClut(GetMainDevice()); #if SDL_MACCLASSIC_GAMMA_SUPPORT Mac_QuitGamma(this); #endif /* Free list of video modes */ if ( SDL_modelist != NULL ) { for ( i=0; SDL_modelist[i]; ++i ) { SDL_free(SDL_modelist[i]); } SDL_free(SDL_modelist); SDL_modelist = NULL; } }
/* ============= InitMacStuff ============= */ void InitMacStuff( void ) { Handle menuBar; char dir[MAX_OSPATH]; // init toolbox MaxApplZone(); MoreMasters(); InitGraf(&qd.thePort); InitFonts(); FlushEvents(everyEvent, 0); SetEventMask( -1 ); InitWindows(); InitMenus(); TEInit(); InitDialogs(nil); InitCursor(); // init menu menuBar = GetNewMBar(rMenuBar); if(!menuBar) { Com_Error( ERR_FATAL, "MenuBar not found."); } SetMenuBar(menuBar); DisposeHandle(menuBar); AppendResMenu(GetMenuHandle(mApple),'DRVR'); DrawMenuBar(); Sys_InitConsole(); SetEventMask( -1 ); }
void findGraphicsExporterComponents(_List& compList, _SimpleList& compIndex) { ComponentDescription cd, cd2; Component c = 0; cd.componentType = GraphicsExporterComponentType; cd.componentSubType = 0; cd.componentManufacturer = 0; cd.componentFlags = 0; cd.componentFlagsMask = graphicsExporterIsBaseExporter; _String fileFormat; while( ( c = FindNextComponent( c, &cd ) ) != 0 ) { Handle cInfo = NewHandle(256); GetComponentInfo (c,&cd2,cInfo,nil,nil); (*cInfo)[**cInfo+1] = 0; fileFormat = (char*)(*cInfo+1); if (fileFormat.sLength) { compList&& &fileFormat; compIndex << (long)c; } DisposeHandle(cInfo); } }
extern char* vr_findVerRegName() { FSSpec regSpec; OSErr err; short foundVRefNum; long foundDirID; int bCreate = 0; /* quick exit if we have the info */ if ( verRegName != NULL ) return verRegName; err = FindFolder(kOnSystemDisk,'pref', false, &foundVRefNum, &foundDirID); if (err == noErr) { err = FSMakeFSSpec(foundVRefNum, foundDirID, MAC_VERREG, ®Spec); if (err == -43) /* if file doesn't exist */ { err = FSpCreate(®Spec, 'MOSS', 'REGS', smSystemScript); bCreate = 1; } if (err == noErr) { Handle thePath; short pathLen; err = FSpGetFullPath(®Spec, &pathLen, &thePath); if (err == noErr && thePath) { /* we have no idea if this moves memory, so better lock the handle */ #if defined(STANDALONE_REGISTRY) || defined(USE_STDIO_MODES) HLock(thePath); verRegName = (char *)XP_ALLOC(pathLen + 1); XP_STRNCPY(verRegName, *thePath, pathLen); verRegName[pathLen] = '\0'; #else /* Since we're now using NSPR, this HAS to be a unix path! */ const char* src; char* dst; HLock(thePath); verRegName = (char*)XP_ALLOC(pathLen + 2); src = *(char**)thePath; dst = verRegName; *dst++ = '/'; while (pathLen--) { char c = *src++; *dst++ = (c == ':') ? '/' : c; } *dst = '\0'; #endif } DisposeHandle(thePath); } } return verRegName; }
void GC_MacFreeTemporaryMemory() { # if defined(SHARED_LIBRARY_BUILD) /* if possible, collect all memory, and invoke all finalizers. */ perform_final_collection(); # endif if (theTemporaryMemory != NULL) { long totalMemoryUsed = 0; TemporaryMemoryHandle tempMemBlock = theTemporaryMemory; while (tempMemBlock != NULL) { TemporaryMemoryHandle nextBlock = (**tempMemBlock).nextBlock; totalMemoryUsed += GetHandleSize((Handle)tempMemBlock); DisposeHandle((Handle)tempMemBlock); tempMemBlock = nextBlock; } theTemporaryMemory = NULL; # if !defined(SHARED_LIBRARY_BUILD) if (GC_print_stats) { fprintf(stdout, "[total memory used: %ld bytes.]\n", totalMemoryUsed); fprintf(stdout, "[total collections: %ld.]\n", GC_gc_no); } # endif } }
QList<QByteArray> QMacPasteboardMimePict::convertFromMime(const QString &mime, QVariant variant, QString flav) { QList<QByteArray> ret; if (!resolveMimeQuickTimeSymbols()) return ret; if (!canConvert(mime, flav)) return ret; QCFType<CGImageRef> cgimage = qt_mac_createCGImageFromQImage(qvariant_cast<QImage>(variant)); Handle pic = NewHandle(0); GraphicsExportComponent graphicsExporter; ComponentResult result = OpenADefaultComponent(GraphicsExporterComponentType, kQTFileTypePicture, &graphicsExporter); if (!result) { unsigned long sizeWritten; result = ptrGraphicsExportSetInputCGImage(graphicsExporter, cgimage); if (!result) result = ptrGraphicsExportSetOutputHandle(graphicsExporter, pic); if (!result) result = ptrGraphicsExportDoExport(graphicsExporter, &sizeWritten); CloseComponent(graphicsExporter); } int size = GetHandleSize((Handle)pic); // Skip the Picture File header (512 bytes) and feed the raw data QByteArray ar(reinterpret_cast<char *>(*pic + 512), size - 512); ret.append(ar); DisposeHandle(pic); return ret; }
UInt32 OPL_DSNList::getSelectedItem() { OSStatus err; UInt32 retID = 0; UInt32 itemCount; Handle itemList = NewHandle(0); if (itemList == NULL) return 0; err = GetDataBrowserItems(m_itemView, kDataBrowserNoItem, false, kDataBrowserItemIsSelected, itemList); require_noerr(err, error); itemCount = GetHandleSize(itemList) / sizeof(DataBrowserItemID); if (itemCount != 0) { DataBrowserItemID *list = (DataBrowserItemID *) *itemList; retID = list[0]; } DisposeHandle(itemList); return retID; error: return 0; }
QVariant QMacPasteboardMimePict::convertToMime(const QString &mime, QList<QByteArray> data, QString flav) { if(data.count() > 1) qWarning("QMacPasteboardMimePict: Cannot handle multiple member data"); QVariant ret; if (!resolveMimeQuickTimeSymbols()) return ret; if(!canConvert(mime, flav)) return ret; const QByteArray &a = data.first(); // This function expects the 512 header (just to skip it, so create the extra space for it). Handle pic = NewHandle(a.size() + 512); memcpy(*pic + 512, a.constData(), a.size()); GraphicsImportComponent graphicsImporter; ComponentResult result = OpenADefaultComponent(GraphicsImporterComponentType, kQTFileTypePicture, &graphicsImporter); QCFType<CGImageRef> cgImage; if (!result) result = ptrGraphicsImportSetDataHandle(graphicsImporter, pic); if (!result) result = ptrGraphicsImportCreateCGImage(graphicsImporter, &cgImage, kGraphicsImportCreateCGImageUsingCurrentSettings); if (!result) ret = QVariant(QPixmap::fromMacCGImageRef(cgImage).toImage()); CloseComponent(graphicsImporter); DisposeHandle(pic); return ret; }
// Create the 'pasp' atom for video tracks. No guesswork required. // References http://www.uwasa.fi/~f76998/video/conversion/ void set_track_clean_aperture_ext(ImageDescriptionHandle imgDesc, Fixed displayW, Fixed displayH, Fixed pixelW, Fixed pixelH) { if (displayW == pixelW && displayH == pixelH) return; AVRational dar, invPixelSize, sar; dar = (AVRational) { displayW, displayH }; invPixelSize = (AVRational) { pixelH, pixelW }; sar = av_mul_q(dar, invPixelSize); av_reduce(&sar.num, &sar.den, sar.num, sar.den, fixed1); if (sar.num == sar.den) return; PixelAspectRatioImageDescriptionExtension **pasp = (PixelAspectRatioImageDescriptionExtension**)NewHandle(sizeof(PixelAspectRatioImageDescriptionExtension)); **pasp = (PixelAspectRatioImageDescriptionExtension) { EndianU32_NtoB(sar.num), EndianU32_NtoB(sar.den) }; AddImageDescriptionExtension(imgDesc, (Handle)pasp, kPixelAspectRatioImageDescriptionExtension); DisposeHandle((Handle)pasp); }
ComponentResult create_placeholder_track(Movie movie, Track *placeholderTrack, TimeValue duration, Handle dataRef, OSType dataRefType) { SampleDescriptionHandle sdH = NULL; Media placeholderMedia; TimeScale movieTimeScale; ComponentResult result = noErr; movieTimeScale = GetMovieTimeScale(movie); sdH = (SampleDescriptionHandle)NewHandleClear(sizeof(SampleDescription)); (*sdH)->descSize = sizeof(SampleDescription); *placeholderTrack = NewMovieTrack(movie, 0, 0, kNoVolume); placeholderMedia = NewTrackMedia(*placeholderTrack, BaseMediaType, movieTimeScale, dataRef, dataRefType); result = AddMediaSampleReference(placeholderMedia, 0, 1, duration, sdH, 1, 0, NULL); if(result != noErr) goto bail; result = InsertMediaIntoTrack(*placeholderTrack, -1, 0, duration, fixed1); bail: if (sdH) DisposeHandle((Handle) sdH); return(result); }
static PGPError sImportProc( PFLFileSpecRef ref, PGPByte const * data, PGPSize dataSize ) { const ExportedFileSpec * exportedData; MyData * newData = NULL; PGPError err = kPGPError_NoErr; (void) dataSize; exportedData = (const ExportedFileSpec *)data; newData = GetMyData( ref ); err = PGPReallocData( ref->memoryMgr, &newData, sizeof( *newData ), 0 ); if ( IsntPGPError( err ) ) { MyData * myData = (MyData *)newData; ref->data = (PGPByte *)newData; ref->dataSize = sizeof( *newData ); myData->specIsValid = FALSE; CopyPString( exportedData->name, myData->spec.name ); if( exportedData->aliasDataSize != 0 ) { AliasHandle alias; if( PtrToHand( &exportedData->aliasData[0], (Handle *) &alias, exportedData->aliasDataSize ) == noErr ) { FSSpec spec; short aliasCount = 1; Boolean needsUpdate; if( MatchAlias( NULL, kARMNoUI | kARMSearch, alias, &aliasCount, &spec, &needsUpdate, NULL, NULL ) == noErr ) { CInfoPBRec cpb; if( FSpGetCatInfo( &spec, &cpb ) == noErr ) { myData->specIsValid = TRUE; myData->spec.vRefNum = spec.vRefNum; myData->spec.parID = cpb.dirInfo.ioDrDirID; } } DisposeHandle( (Handle) alias ); } } } return( err ); }
/* convert icns(icons for MacOS X) to IPIcon */ OSErr XIconToIPIcon(const FSSpec *theFile,IPIconRec *ipIcon) { OSErr err; IconFamilyHandle theIconFamily; short refNum; long count; if (isIconServicesAvailable) { /* open icns file */ err=FSpOpenDF(theFile,fsRdPerm,&refNum); if (err!=noErr) return err; err=GetEOF(refNum,&count); if (err!=noErr) { FSClose(refNum); return err; } theIconFamily=(IconFamilyHandle)NewHandle(count); HLock((Handle)theIconFamily); err=FSRead(refNum,&count,*theIconFamily); HUnlock((Handle)theIconFamily); err=FSClose(refNum); /* convert IconFamily to IPIcon */ err=IconFamilyToIPIcon(theIconFamily,ipIcon); DisposeHandle((Handle)theIconFamily); return err; } else return -1; }
// ImageCodecGetCodecInfo // Your component receives the ImageCodecGetCodecInfo request whenever an application calls the Image Compression Manager's GetCodecInfo function. // Your component should return a formatted compressor information structure defining its capabilities. // Both compressors and decompressors may receive this request. pascal ComponentResult TextSubCodecGetCodecInfo(TextSubGlobals glob, CodecInfo *info) { OSErr err = noErr; ComponentDescription desc; short resid; GetComponentInfo((Component)glob->self, &desc, 0, 0, 0); if (desc.componentSubType == kSubFormatSSA) resid = kSSASubCodecResourceID; else resid = kTextSubCodecResourceID; if (info == NULL) { err = paramErr; } else { CodecInfo **tempCodecInfo; err = GetComponentResource((Component)glob->self, codecInfoResourceType, resid, (Handle *)&tempCodecInfo); if (err == noErr) { *info = **tempCodecInfo; DisposeHandle((Handle)tempCodecInfo); } } return err; }
OSErr TimeGridWindRect::Read(BFPB *bfpb) { char c, msg[256], fileName[256], newFileName[64]; long i, version, numTimes, numPoints; ClassID id; float val; Seconds time; Boolean bPathIsValid = true; OSErr err = 0; if (err = TimeGridVel::Read(bfpb)) return err; StartReadWriteSequence("TimeGridWindRect::Read()"); if (err = ReadMacValue(bfpb, &id)) return err; if (id != GetClassID ()) { TechError("TimeGridWindRect::Read()", "id != TYPE_TIMEGRIDWINDRECT", 0); return -1; } if (err = ReadMacValue(bfpb, &version)) return err; if (version > TimeGridWindRectREADWRITEVERSION) { printSaveFileVersionError(); return -1; } // anything here? done: if(err) { TechError("TimeGridWindRect::Read(char* path)", " ", 0); if(fTimeHdl) {DisposeHandle((Handle)fTimeHdl); fTimeHdl=0;} } return err; }
Handle QTDR_MakeResourceDataRef (FSSpecPtr theFile, OSType theResType, SInt16 theResID) { Handle myDataRef = NULL; OSType myResType; SInt16 myResID; OSErr myErr = noErr; myDataRef = QTDR_MakeFileDataRef(theFile); if (myDataRef == NULL) goto bail; // append the resource type and ID to the data reference myResType = EndianU32_NtoB(theResType); myResID = EndianS16_NtoB(theResID); myErr = PtrAndHand(&myResType, myDataRef, sizeof(myResType)); if (myErr == noErr) myErr = PtrAndHand(&myResID, myDataRef, sizeof(myResID)); bail: if (myErr != noErr) { if (myDataRef != NULL) DisposeHandle(myDataRef); myDataRef = NULL; } return(myDataRef); }
static void munger_test (handle_state h_s, offset_state offset_s, ptr_state ptr1_s, len_state len1_s, ptr_state ptr2_s, len_state len2_s) { Handle h; LONGINT offset; Ptr ptr1; LONGINT len1; Ptr ptr2; LONGINT len2; LONGINT retval; LONGINT d0; h = new_handle (h_s); offset = new_offset (offset_s, GetHandleSize (h)); ptr1 = new_ptr (ptr1_s); len1 = new_len (len1_s); ptr2 = new_ptr (ptr2_s); len2 = new_len (len2_s); dump_handle (h); retval = Munger_invoker (h, offset, ptr1, len1, ptr2, len2, &d0); dump_handle (h); dump_retval_d0 (retval, d0); if (h_s >= handle_nil_master) DisposeHandle (h); }
static OSErr QT_AddUserDataTextToMovie (Movie theMovie, char *theText, OSType theType) { UserData myUserData = NULL; Handle myHandle = NULL; long myLength = strlen(theText); OSErr myErr = noErr; // get the movie's user data list myUserData = GetMovieUserData(theMovie); if (myUserData == NULL) return(paramErr); // copy the specified text into a new handle myHandle = NewHandleClear(myLength); if (myHandle == NULL) return(MemError()); BlockMoveData(theText, *myHandle, myLength); // add the data to the movie's user data myErr = AddUserDataText(myUserData, myHandle, theType, 1, (short)GetScriptManagerVariable(smRegionCode)); // clean up DisposeHandle(myHandle); return(myErr); }
/******************************************************************************** Add a parameter of type typeAlias to an AERecord (or AppleEvent) using the provided FSRef. pFSRef input: Pointer to the FSRef to use. pKeyword input: The key for the data to be added to the record. pAERecord input: Pointer to the record (or event) to add the data to. RESULT CODES ____________ noErr 0 No error paramErr -50 The value of target or alias parameter, or of both, is NIL, or the alias record is corrupt memFullErr -108 Not enough room in heap zone */ pascal OSErr MoreAEOAddAliasParameterFromFSRef(const FSRefPtr pFSRef, const DescType pKeyword, AERecord *pAERecord ) { OSErr anErr = noErr; AliasHandle tAliasHandle; anErr = FSNewAlias( NULL, pFSRef, &tAliasHandle); if ( noErr == anErr && tAliasHandle == NULL ) { anErr = paramErr; } if ( noErr == anErr ) { char handleState; handleState = HGetState((Handle) tAliasHandle ); HLock((Handle) tAliasHandle ); anErr = AEPutParamPtr( pAERecord, pKeyword, typeAlias, *tAliasHandle, (*tAliasHandle)->aliasSize); HSetState( (Handle)tAliasHandle, handleState ); DisposeHandle( (Handle)tAliasHandle ); } return anErr; }//end MoreAEOAddAliasParameterFromFSRef
//-------------------------------------------------------------- bool createMovieFromURL(string urlIn, Movie &movie){ char * url = (char *)urlIn.c_str(); Handle urlDataRef; OSErr err; urlDataRef = NewHandle(strlen(url) + 1); if ( ( err = MemError()) != noErr){ ofLogError("ofQuickTimePlayer") << "createMovieFromURL(): couldn't create url handle from \"" << urlIn << "\": OSErr " << err; return false; } BlockMoveData(url, *urlDataRef, strlen(url) + 1); err = NewMovieFromDataRef(&movie, newMovieActive,nil, urlDataRef, URLDataHandlerSubType); DisposeHandle(urlDataRef); if(err != noErr){ ofLogError("ofQuickTimePlayer") << "createMovieFromURL(): couldn't load url \"" << urlIn << "\": OSErr " << err; return false; }else{ return true; } return false; }
short GetRectFromRes(Rect *outRect, short inResID) { Handle rectH; short reserr; if (!outRect) return eParam; // get rect for save bits message rectH = Get1Resource('RECT', inResID); reserr = ResError(); if (reserr == noErr && rectH != NULL) { *outRect = (Rect) **((Rect **)rectH); DisposeHandle(rectH); } else { ErrorHandler(reserr, nil); return reserr; } return 0; }
OSErr SpriteUtils_AddSpriteSampleToMedia (Media theMedia, QTAtomContainer theSample, TimeValue theDuration, Boolean isKeyFrame, TimeValue *theSampleTime) { SampleDescriptionHandle mySampleDesc = NULL; OSErr myErr = noErr; mySampleDesc = (SampleDescriptionHandle)NewHandleClear(sizeof(SpriteDescription)); if (mySampleDesc == NULL) { myErr = MemError(); goto bail; } myErr = AddMediaSample(theMedia, (Handle)theSample, 0, GetHandleSize(theSample), theDuration, mySampleDesc, 1, (short)(isKeyFrame ? 0 : mediaSampleNotSync), theSampleTime); bail: if (mySampleDesc != NULL) DisposeHandle((Handle) mySampleDesc); return(myErr); }
pascal OSErr FSpLocationFromFullPath(short fullPathLength, const void *fullPath, FSSpec *spec) { AliasHandle alias; OSErr result; Boolean wasChanged; Str32 nullString; /* Create a minimal alias from the full pathname */ nullString[0] = 0; /* null string to indicate no zone or server name */ result = NewAliasMinimalFromFullPath(fullPathLength, fullPath, nullString, nullString, &alias); if ( result == noErr ) { /* Let the Alias Manager resolve the alias. */ result = ResolveAlias(NULL, alias, spec, &wasChanged); /* work around Alias Mgr sloppy volume matching bug */ if ( spec->vRefNum == 0 ) { /* invalidate wrong FSSpec */ spec->parID = 0; spec->name[0] = 0; result = nsvErr; } DisposeHandle((Handle)alias); /* Free up memory used */ } return ( result ); }
// GetSettingsPreference // Returns a preference for a specified key as QuickTime UserData // It is your responsibility to dispose of the returned UserData OSErr GetSettingsPreference(CFStringRef inKey, UserData *outUserData) { CFPropertyListRef theCFSettings; Handle theHandle = NULL; UserData theUserData = NULL; OSErr err = paramErr; // read the new setttings from our preferences theCFSettings = CFPreferencesCopyAppValue(inKey, kCFPreferencesCurrentApplication); if (theCFSettings) { err = PtrToHand(CFDataGetBytePtr((CFDataRef)theCFSettings), &theHandle, CFDataGetLength((CFDataRef)theCFSettings)); CFRelease(theCFSettings); if (theHandle) { err = NewUserDataFromHandle(theHandle, &theUserData); if (theUserData) { *outUserData = theUserData; } DisposeHandle(theHandle); } } return err; }
void setUp() { Handle menuBar; OSErr anErr = noErr; long aLong; long response; anErr = Gestalt(gestaltSystemVersion, &response); // Carbon Porting guidelines say provide alternate menu bar/menu scheme for OS X // This is just one way of doing this, which is pretty static if (response >= 0x01000) menuBar = GetNewMBar(MENU_BAR_IDX); else menuBar = GetNewMBar(MENU_BAR_ID); if ( menuBar == nil || anErr != noErr ) ExitToShell(); SetMenuBar(menuBar); DisposeHandle(menuBar); DrawMenuBar(); // Install 'quit' event handler if ((Gestalt(gestaltAppleEventsAttr, &aLong) == noErr)) { anErr = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, NewAEEventHandlerUPP(AEQuitHandler), 0, false); if (anErr != noErr) ExitToShell(); } }
void ofxQtAudioRecorder::closeMovie(){ short movieResId = movieInDataForkResID; AddMovieResource(movie, movieResRefNum, &movieResId, NULL); OSErr err = GetMoviesError(); if(err != noErr){ printf("error adding movie resource\n"); return; } if(movieResRefNum != 0) { CloseMovieFile(movieResRefNum); } if(movie != NULL) { DisposeMovie(movie); } if(soundDesc != NULL) { DisposeHandle((Handle)soundDesc); soundDesc = NULL; } movie = NULL; movieResRefNum = 0; audioMedia = NULL; audioTrack = NULL; printf("closed movie file\n"); }
ComponentResult FFAvi_MovieImportFile(ff_global_ptr storage, const FSSpec *theFile, Movie theMovie, Track targetTrack, Track *usedTrack, TimeValue atTime, TimeValue *addedDuration, long inFlags, long *outFlags) { ComponentResult result; Handle dataRef = NULL; OSType dataRefType; FSRef theFileFSRef; *outFlags = 0; result = QTNewDataReferenceFromFSSpec(theFile, 0, &dataRef, &dataRefType); require_noerr(result,bail); result = MovieImportDataRef(storage->ci, dataRef, dataRefType, theMovie, targetTrack, usedTrack, atTime, addedDuration, inFlags, outFlags); require_noerr(result, bail); result = FSpMakeFSRef(theFile, &theFileFSRef); require_noerr(result, bail); bail: if(dataRef) DisposeHandle(dataRef); return result; } /* FFAvi_MovieImportFile() */