示例#1
0
文件: macstuff.c 项目: AMDmi3/analog
static void *
my_temp_malloc(size_t size)
{
	OSErr result;
	struct my_block **block;
	long version;
	char *ret_ptr;

	size=(size+3)&~3;
	if (Gestalt(gestaltSystemVersion,&version) || version<0x700) return(nil);
	if (size>MY_BLOCK_SIZE) {
		if (TempFreeMem()<1024*1024+size) return(nil);
		block=(struct my_block **)TempNewHandle(size+sizeof(struct my_block **),&result);
		if (!block || !*block || result) return(nil);
		TempHLock((Handle)block,&result);
		(*block)->next=temp_mem_blocks;
		temp_mem_blocks=block;
		return((void *)&(*block)->storage);
		}
	if (size>my_cur_avail) {
		if (TempFreeMem()<1024*1024+MY_BLOCK_SIZE) return(nil);
		block=(struct my_block **)TempNewHandle(sizeof(struct my_block),&result);
		if (!block || !*block || result) return(nil);
		TempHLock((Handle)block,&result);
		(*block)->next=temp_mem_blocks;
		temp_mem_blocks=block;
		my_cur_block=(*block)->storage;
		my_cur_avail=MY_BLOCK_SIZE;
		}
	ret_ptr=my_cur_block;
	my_cur_block+=size;
	my_cur_avail-=size;
	return((void *)ret_ptr);
	}
void * __sys_alloc(mem_size size, struct mem_pool_obj * )
{
    PoolHandlePtr slot;
    OSErr err;

    slot = NewPoolListSlot();
    assert ( slot != 0 );

    // (slot is dereferenced from poolList, and we dont want it to move)
    HLock( (Handle)poolList );

    // Allocate a new handle.
    // Use temporary memory if asked to.
    // Use application heap if temporary memory fails.
    if (use_temporary_memory)
        *slot = (PoolHandle)TempNewHandle( size, &err );
    if ( !use_temporary_memory || *slot == nil || err!=noErr )
        *slot = (PoolHandle)NewHandle( size );

    assert( *slot != 0 );
    HUnlock( (Handle)poolList );

    HLock( *slot );

    return(**slot);
}
示例#3
0
文件: MacOS.c 项目: LiaoPengyu/bdwgc
Ptr GC_MacTemporaryNewPtr(size_t size, Boolean clearMemory)
{
	static Boolean firstTime = true;
	OSErr result;
	TemporaryMemoryHandle tempMemBlock;
	Ptr tempPtr = nil;

	tempMemBlock = (TemporaryMemoryHandle)TempNewHandle(size + sizeof(TemporaryMemoryBlock), &result);
	if (tempMemBlock && result == noErr) {
		HLockHi((Handle)tempMemBlock);
		tempPtr = (**tempMemBlock).data;
		if (clearMemory) memset(tempPtr, 0, size);
		tempPtr = StripAddress(tempPtr);

		// keep track of the allocated blocks.
		(**tempMemBlock).nextBlock = theTemporaryMemory;
		theTemporaryMemory = tempMemBlock;
	}

#     if !defined(SHARED_LIBRARY_BUILD)
	// install an exit routine to clean up the memory used at the end.
	if (firstTime) {
		atexit(&GC_MacFreeTemporaryMemory);
		firstTime = false;
	}
#     endif

	return tempPtr;
}
示例#4
0
static Handle debuggetnewhandle (char * filename, unsigned long linenumber, unsigned long threadid, long ctbytes, boolean fltemp) {

    /*
    2.1b3 dmb: new fltemp parameter. if true, try temp memory first, then
    our heap.
    */

    register Handle h;
    OSErr err;
    long extrasize;

    extrasize = strlen(filename) + 1 + sizeof(long) + sizeof(long) + sizeof(long) + (2 * (sizeof(Handle))) + 4;

#ifdef MACVERSION
    if (fltemp) { /*try grabbing temp memory first*/

        h = TempNewHandle (ctbytes + extrasize, &err);

        if (h != nil) {

            debugaddmemhandle (h, ctbytes, filename, linenumber, threadid);

#ifdef fldebug

            ++cttemphandles;

            tempzone = HandleZone (h);

#endif

            return (h);
        }
    }
#endif

    if (hsafetycushion == nil) { /*don't allocate new stuff w/out safety cushion*/

        if (!getsafetycushion ())
            return (nil);
    }

    flholdsafetycushion = true;

#ifdef MACVERSION
    h = NewHandle (ctbytes);

    if (h != nil)
        debugaddmemhandle (h, ctbytes, filename, linenumber, threadid);
#endif
#ifdef WIN95VERSION
    h = debugfrontierAlloc (filename, linenumber, threadid, ctbytes);
#endif

    flholdsafetycushion = false;

    return (h);
} /*getnewhandle*/
示例#5
0
static Handle getnewhandle (long ctbytes, boolean fltemp) {

    /*
    2.1b3 dmb: new fltemp parameter. if true, try temp memory first, then
    our heap.
    */

    register Handle h;
    OSErr err;

#ifdef MACVERSION
    if (fltemp) { /*try grabbing temp memory first*/

        h = TempNewHandle (ctbytes, &err);

        if (h != nil) {

#ifdef fldebug

            ++cttemphandles;

            tempzone = HandleZone (h);

#endif

            return (h);
        }
    }
#endif

    if (hsafetycushion == nil) { /*don't allocate new stuff w/out safety cushion*/

        if (!getsafetycushion ())
            return (nil);
    }

    flholdsafetycushion = true;

    h = NewHandle (ctbytes);

    flholdsafetycushion = false;

    return (h);
} /*getnewhandle*/
示例#6
0
void MolDisplayWin::WriteQTMovie(wxString & filepath) {
	//Create a QuickTime movie using the standard animation codecs with normal quality, and 
	//temporal compression. The final file is flattened for cross platform compatability
	
	QTExport * QTOptions = new QTExport(this);
	//setup controls for the current data
	if (MainData->GetNumFrames() > 1) { //default to frame animation
		QTOptions->SetMovieChoice(0);
	} else {
		QTOptions->EnableFrameMovie(false);
	}
	if (MainData->cFrame->GetNumberNormalModes() <= 0) {
		QTOptions->EnableModeMovie(false);
	}
	
	if (QTOptions->ShowModal() != wxID_OK) {
		//user cancelled the operation
		QTOptions->Destroy();
		return;
	}
	//retrieve the value of each option
	int MovieType = QTOptions->GetMovieChoice();
	bool IncludeEPlot = QTOptions->AddEnergyPlot();
	int compressorChoice = QTOptions->GetCompressorChoice();
	int keyFrameRate = QTOptions->GetKeyFrameRate();
	if (keyFrameRate < 0) keyFrameRate = 0;
	
	QTOptions->Destroy();
	
	CodecType mCodec;
	switch (compressorChoice) {
		case 0:
			mCodec = kCinepakCodecType;
			break;
		case 1:
			mCodec = kGraphicsCodecType;
			break;
		case 2:
			mCodec = kAnimationCodecType;
			break;
		case 3:
		default:
			mCodec = kMPEG4VisualCodecType;
	}

	OSStatus s;
	OSErr myErr = myErr;
	FSSpec targetSpec;
	//ugh I need to get an FSSpec to hand to quicktime, but these calls only seem to work if
	//the file already exists...
	const char * t = filepath.mb_str(wxConvUTF8);
	FILE * temp = fopen(t, "wb");
	fclose(temp);

#ifdef __WXOSX_COCOA__
	//This function is not found in the wxCocoa implementation, it is probably possible to work around it
	//Otherwise the code appears to link and run currently. However, it is probably better to redue the
	//code to use the Cocoa qtKit framework rather than the old Carbon QT library.
	
	//This path is not tested as the current Cocoa code does not properly support the extended save dialog.
	//	void wxMacFilename2FSSpec( const wxString& path , FSSpec *spec )
	{
		OSStatus err = noErr;
		FSRef fsRef;
		wxMacPathToFSRef( filepath , &fsRef );
		err = FSGetCatalogInfo(&fsRef, kFSCatInfoNone, NULL, NULL, &targetSpec, NULL);
		verify_noerr( err );
	}
#else
	wxMacFilename2FSSpec(filepath, &targetSpec);
#endif
	
	Movie	theMovie = NULL;
		
	FSSpec tempSpec = targetSpec;
	strcpy((char *) &(tempSpec.name[1]), "MacMolPlt8933tempMovie");
	tempSpec.name[0] = 22;

	BeginOperation();
	ProgressInd->ChangeText("Creating movie...");
		
	myErr = EnterMovies();	//initialize the quicktime manager
	if (myErr != noErr) {
		FinishOperation();
		MessageAlert("Error initializing QuickTime!");
		return;
	}
		//Create the movie file and initialize file data
		//Use Quicktime creator code 'TVOD' instead of simpletext 'ttxt'
	short	resRefNum = 0;
	short	resId = 0;
	myErr = CreateMovieFile(&tempSpec, 'TVOD', smCurrentScript, createMovieFileDeleteCurFile,
							&resRefNum, &theMovie);
	if (myErr != noErr) {
		MessageAlert("Error creating movie file!");
	} else {
		bool KillEPlot = false;
		int width, height, savedEPlotWidth, savedEPlotHeight;
		glCanvas->GetClientSize(&width, &height);
		Rect lDisplayRect={0,0,0,0};
		lDisplayRect.right = width;
		lDisplayRect.bottom = height;
		Rect		gRect = lDisplayRect;

		Rect EPlotRect = lDisplayRect;
		//If we are including an energy plot add space for it here
		if (IncludeEPlot && (MovieType == 0)) {
			EPlotRect.left = EPlotRect.right;
			EPlotRect.right = EPlotRect.left + height;
			if (!energyPlotWindow) {
				energyPlotWindow = new EnergyPlotDialog(this);
				KillEPlot = true;
			} else {
				energyPlotWindow->GetSize(&savedEPlotWidth, &savedEPlotHeight);
			}
			gRect.right += height;
			width += height;
			energyPlotWindow->Show(false);
			energyPlotWindow->SetSize(height, height);
			energyPlotWindow->Update();	//This is needed to initialise the window if we just created it
		}

		LocalToGlobal ((Point *) &(gRect.top));
		LocalToGlobal ((Point *) &(gRect.bottom));
		WindowRef TempWindow;
		s = CreateNewWindow(kDocumentWindowClass, kWindowNoAttributes, &gRect, &TempWindow);
		if (s == noErr) {
													//Create the video track
			Track theTrack = NewMovieTrack (theMovie, FixRatio(width,1),
											FixRatio(height,1), kNoVolume);
			if ((noErr == GetMoviesError())&&theTrack) {
				Media theMedia = NewTrackMedia (theTrack, VideoMediaType,
												60, // Video Time Scale
												NULL, 0);
				if ((noErr == GetMoviesError())&&theMedia) {
					myErr = BeginMediaEdits (theMedia);
					if (myErr == noErr) {
						//create the actual movie frames
						GWorldPtr	lgWorld=NULL;
						
						if (! NewGWorld (&lgWorld, 0, &gRect, (CTabHandle) NULL, (GDHandle) NULL,
										 (GWorldFlags) (pixPurge + useTempMem))) {
							long MaxCompressedSize;
							ImageSequence seqID;
							ImageDescriptionHandle imageDesc = (ImageDescriptionHandle)NewHandle(4);
							PixMapHandle myPixMap = GetPortPixMap(lgWorld);
							LockPixels (myPixMap);
							myErr = CompressSequenceBegin(&seqID, myPixMap, NULL, &gRect, &gRect, 0,
														  mCodec, bestCompressionCodec, codecNormalQuality, codecNormalQuality, keyFrameRate, NULL,
														  codecFlagUpdatePreviousComp, imageDesc);
							GetMaxCompressionSize (myPixMap, &gRect,
												   0, codecNormalQuality, mCodec, (CompressorComponent) anyCodec, &MaxCompressedSize);
							Handle Buffer = TempNewHandle(MaxCompressedSize, &myErr);
							if (!Buffer)
								Buffer = NewHandle(MaxCompressedSize);
							if (Buffer) {
								qtData myqtData = {theMedia, imageDesc, seqID, lDisplayRect, gRect};
								if (MovieType == 0) {
									CreateFrameMovie(lgWorld, Buffer, myqtData, IncludeEPlot);
								} else {
									CreateModeMovie(lgWorld, Buffer, myqtData);
								}
								DisposeHandle(Buffer);
							}
							myErr = CDSequenceEnd(seqID);
							if (lgWorld != NULL) DisposeGWorld (lgWorld);
							if (imageDesc) DisposeHandle((Handle) imageDesc);
						}
						
						myErr = EndMediaEdits (theMedia);
					}
					myErr = InsertMediaIntoTrack (theTrack, 0,/* track start time */
						0,        /* media start time */
						GetMediaDuration (theMedia),
						FixRatio(1,1));
				}
				myErr = AddMovieResource (theMovie, resRefNum, &resId, NULL);
			}
			if (resRefNum) {
						//Create the actual file as a flat data fork so it can be placed on the www
				ProgressInd->ChangeText("Flattening movieÉ");
				FlattenMovie(theMovie, flattenAddMovieToDataFork, &targetSpec, 'TVOD', smCurrentScript, 
							 createMovieFileDeleteCurFile, &resId, NULL);
				CloseMovieFile (resRefNum);
			}
			DisposeWindow(TempWindow);
		}
		DisposeMovie (theMovie);
		DeleteMovieFile (&tempSpec);	//delete the temp file after disposing of the movie

		if (energyPlotWindow) {
			if (KillEPlot) {
				delete energyPlotWindow;
				energyPlotWindow = NULL;
			} else {
				energyPlotWindow->SetSize(savedEPlotWidth, savedEPlotHeight);
				energyPlotWindow->FrameChanged();
				energyPlotWindow->Show(true);
			}
		}
	}
	ExitMovies();	//Close out quicktime as we are done with it for now
	FinishOperation();
}