int CSimplePlayerMFCApp::ExitInstance() { // Exit QuickTime and terminate QTML ExitMovies(); TerminateQTML(); return CWinApp::ExitInstance(); }
/* * void PsychQTExitMovies() - Shutdown handler. * * This routine is called by Screen('CloseAll') and on clear Screen time to * do final cleanup. It deletes all Quicktime textures and releases all Quicktime * movie objects. * */ void PsychQTExitMovies(void) { PsychWindowRecordType **windowRecordArray; int i, numWindows; // Release all Quicktime related OpenGL textures: PsychCreateVolatileWindowRecordPointerList(&numWindows, &windowRecordArray); for(i=0; i<numWindows; i++) { // Delete all Quicktime textures: if ((windowRecordArray[i]->windowType == kPsychTexture) && (windowRecordArray[i]->targetSpecific.QuickTimeGLTexture !=NULL)) { PsychCloseWindow(windowRecordArray[i]); } } PsychDestroyVolatileWindowRecordPointerList(windowRecordArray); // Release all movies: PsychQTDeleteAllMovies(); // Shutdown Quicktime toolbox: We skip this, because according to Apple its not necessary, // and for some reason it reliably hangs Matlab, so one has to force-quit it :-( // Don't do this: ExitMovies(); #if PSYCH_SYSTEM == PSYCH_WINDOWS // Shutdown Quicktime core system: ExitMovies(); // Shutdown Quicktime for Windows compatibility layer: TerminateQTML(); #endif return; }
/***************************************************************************** * Close: *****************************************************************************/ static void Close( vlc_object_t *p_this ) { decoder_t *p_dec = (decoder_t*)p_this; decoder_sys_t *p_sys = p_dec->p_sys; vlc_value_t lockval; /* get lock, avoid segfault */ var_Get( p_dec->p_libvlc, "qt_mutex", &lockval ); vlc_mutex_lock( lockval.p_address ); #ifdef SYS_DARWIN /* on OS X QT is not threadsafe */ vlc_mutex_lock( &p_dec->p_vlc->quicktime_lock ); #endif if( p_dec->fmt_out.i_cat == AUDIO_ES ) { int i_error; unsigned long ConvertedFrames=0; unsigned long ConvertedBytes=0; i_error = p_sys->SoundConverterEndConversion( p_sys->myConverter, NULL, &ConvertedFrames, &ConvertedBytes ); msg_Dbg( p_dec, "SoundConverterEndConversion => %d", i_error ); i_error = p_sys->SoundConverterClose( p_sys->myConverter ); msg_Dbg( p_dec, "SoundConverterClose => %d", i_error ); free( p_sys->p_buffer ); } else if( p_dec->fmt_out.i_cat == VIDEO_ES ) { free( p_sys->plane ); } #ifndef SYS_DARWIN FreeLibrary( p_sys->qtml ); msg_Dbg( p_dec, "FreeLibrary ok." ); #endif #ifdef SYS_DARWIN ExitMovies(); #endif #if 0 /* Segfault */ #ifdef LOADER Restore_LDT_Keeper( p_sys->ldt_fs ); msg_Dbg( p_dec, "Restore_LDT_Keeper" ); #endif #endif #ifdef SYS_DARWIN vlc_mutex_unlock( &p_dec->p_vlc->quicktime_lock ); #endif vlc_mutex_unlock( lockval.p_address ); free( p_sys ); }
MacOpMultimediaPlayer::~MacOpMultimediaPlayer() { ExitMovies(); if(movie) { DisposeMovie(movie); } }
static void QT_Destroy(QTSplitter *This) { IPin *connected = NULL; ULONG pinref; TRACE("Destroying\n"); EnterCriticalSection(&This->csReceive); /* Don't need to clean up output pins, disconnecting input pin will do that */ IPin_ConnectedTo(&This->pInputPin.pin.IPin_iface, &connected); if (connected) { IPin_Disconnect(connected); IPin_Release(connected); } pinref = IPin_Release(&This->pInputPin.pin.IPin_iface); if (pinref) { ERR("pinref should be null, is %u, destroying anyway\n", pinref); assert((LONG)pinref > 0); while (pinref) pinref = IPin_Release(&This->pInputPin.pin.IPin_iface); } if (This->pQTMovie) { DisposeMovie(This->pQTMovie); This->pQTMovie = NULL; } if (This->vContext) QTVisualContextRelease(This->vContext); if (This->aSession) MovieAudioExtractionEnd(This->aSession); ExitMovies(); LeaveCriticalSection(&This->csReceive); if (This->loaderThread) { WaitForSingleObject(This->loaderThread, INFINITE); CloseHandle(This->loaderThread); } if (This->splitterThread) { SetEvent(This->runEvent); WaitForSingleObject(This->splitterThread, INFINITE); CloseHandle(This->splitterThread); } CloseHandle(This->runEvent); This->csReceive.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&This->csReceive); CoTaskMemFree(This); }
//---------------------------------------- void closeQuicktime(){ if (bQuicktimeInitialized == true){ ExitMovies(); #ifdef TARGET_WIN32 TerminateQTML(); #endif bQuicktimeInitialized = false; } }
// ----------------------------------------------------------------------------------------- // platformWindup() // ----------------------------------------------------------------------------------------- // performs any platform-specific deinitialisation when the program terminates // used to shut down QuickTime // ----------------------------------------------------------------------------------------- void platformWindup(void) { #ifdef QuickTimeInstalled ExitMovies(); #ifdef _WIN32 TerminateQTML(); #endif #endif // QuickTimeInstalled }
void wxExitQT() { //Note that ExitMovies() is not necessary, but //the docs are fuzzy on whether or not TerminateQTML is ExitMovies(); #ifndef __WXMAC__ TerminateQTML(); #endif }
//////////////////////////////////////////////////////////////////////////////// // (static) super-uninitialization - called once at application closedown bool LLMediaImplQuickTime::closedown() { ExitMovies(); #ifdef WIN32 TerminateQTML(); #endif return true; }
void MIDI_Cleanup (void) { if (bMidiInited) { MIDI_Stop(); Con_Printf("%s: closing QuickTime.\n", __thisfunc__); ExitMovies (); bMidiInited = false; } }
~QTImportPlugin() { if (mInitialized) { ExitMovies(); #if defined(__WXMSW__) TerminateQTML(); #endif } mInitialized = false; }
int FAR PASCAL _export WEP(int nParameter) { // Cut the connections to QuickTime for Windows I_UNUSED(nParameter); if (QTInstall) { ExitMovies (); QTTerminate (); QTInstall = FALSE; } return 1; }
/***************************************************************************** * Close: *****************************************************************************/ static void Close( vlc_object_t *p_this ) { decoder_t *p_dec = (decoder_t*)p_this; decoder_sys_t *p_sys = p_dec->p_sys; /* get lock, avoid segfault */ vlc_mutex_lock( &qt_mutex ); if( p_dec->fmt_out.i_cat == AUDIO_ES ) { int i_error; unsigned long ConvertedFrames=0; unsigned long ConvertedBytes=0; i_error = p_sys->SoundConverterEndConversion( p_sys->myConverter, NULL, &ConvertedFrames, &ConvertedBytes ); msg_Dbg( p_dec, "SoundConverterEndConversion => %d", i_error ); i_error = p_sys->SoundConverterClose( p_sys->myConverter ); msg_Dbg( p_dec, "SoundConverterClose => %d", i_error ); free( p_sys->p_buffer ); } else if( p_dec->fmt_out.i_cat == VIDEO_ES ) { free( p_sys->plane ); } #ifndef __APPLE__ FreeLibrary( p_sys->qtml ); FreeLibrary( p_sys->qts ); msg_Dbg( p_dec, "FreeLibrary ok." ); #else ExitMovies(); #endif #if 0 /* Segfault */ #ifdef LOADER Restore_LDT_Keeper( p_sys->ldt_fs ); msg_Dbg( p_dec, "Restore_LDT_Keeper" ); #endif #endif vlc_mutex_unlock( &qt_mutex ); free( p_sys ); }
// uninit driver static void uninit(sh_video_t *sh){ if(OutBufferGWorld) { DisposeGWorld(OutBufferGWorld); OutBufferGWorld = NULL; } if(framedescHandle) { DisposeHandle((Handle)framedescHandle); framedescHandle = NULL; } if(imageSeq) { CDSequenceEnd(imageSeq); imageSeq = 0; } ExitMovies(); }
virtual ~wxQTTimer() { if(m_pbPlaying) *m_pbPlaying = false; StopMovie(m_movie); DisposeMovie(m_movie); Stop(); //Note that ExitMovies() is not necessary, but //the docs are fuzzy on whether or not TerminateQTML is ExitMovies(); #ifndef __WXMAC__ TerminateQTML(); #endif }
/* WinMain */ int CALLBACK WinMain ( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) { MSG msg; HANDLE hAccel; // Store our module handle ghModule = GetModuleHandle(NULL); // Initialize QuickTime Media Layer InitializeQTML(0); // Initialize QuickTime EnterMovies(); // Initialize the app if (!InitializeApp()) { MessageBox(ghwndMain, "MDI: InitializeApp failure!", "Error", MB_OK); return 0; } // Load our accelerator keys if (!(hAccel = LoadAccelerators (ghModule, MAKEINTRESOURCE(ACCEL_ID)))) MessageBox(ghwndMain, "MDI: Load Accel failure!", "Error", MB_OK); // Parse the command line for drag and drop ParseCmdLinePriv(NULL); // Loop for messages while (GetMessage(&msg, NULL, 0, 0)) { if (!TranslateAccelerator( ghwndMain, hAccel, &msg) && !TranslateMDISysAccel( ghwndClient, &msg) ) { TranslateMessage(&msg); DispatchMessage(&msg); } } // Deinitialize QuickTime ExitMovies(); // Deinitialize QTML TerminateQTML(); return TRUE; }
/** * Stops the MIDI player. * * Stops playing and frees any used resources before returning. As it * deinitilizes QuickTime, the #_quicktime_started flag is set to @c false. */ void MusicDriver_QtMidi::Stop() { if (!_quicktime_started) return; DEBUG(driver, 2, "qtmidi: stopping driver..."); switch (_quicktime_state) { case QT_STATE_IDLE: DEBUG(driver, 3, "qtmidi: stopping not needed, already idle"); /* Do nothing. */ break; case QT_STATE_PLAY: StopSong(); FALLTHROUGH; case QT_STATE_STOP: DisposeMovie(_quicktime_movie); } ExitMovies(); _quicktime_started = false; }
void quicktime_exit() { ExitMovies(); #ifdef WIN32 TerminateQTML(); #endif }
int CALLBACK WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR theCmdLine, int nCmdShow) { HANDLE myAccel; HWND myWindowFrame; MSG myMsg; WNDCLASSEX myWC; char myFileName[MAX_PATH]; DWORD myLength; OSErr myErr = noErr; ghInst = hInstance; gCmdLine = theCmdLine; if (hPrevInstance == NULL) { LoadString(hInstance, IDS_APPNAME, gAppName, sizeof(gAppName)); // register the frame window class myWC.cbSize = sizeof(WNDCLASSEX); myWC.style = CS_HREDRAW | CS_VREDRAW; myWC.lpfnWndProc = (WNDPROC)QTFrame_FrameWndProc; myWC.cbClsExtra = 0; myWC.cbWndExtra = 0; myWC.hInstance = hInstance; myWC.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPICON)); myWC.hCursor = LoadCursor(NULL, IDC_ARROW); myWC.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); myWC.lpszMenuName = gAppName; myWC.lpszClassName = gAppName; myWC.hIconSm = LoadImage(hInstance, MAKEINTRESOURCE(IDI_APPICON), IMAGE_ICON, 16, 16, 0); if (!RegisterClassEx(&myWC)) { if (!RegisterClass((LPWNDCLASS)&myWC.style)) return(0); } // register the movie child window class myWC.cbSize = sizeof(WNDCLASSEX); myWC.style = 0; myWC.lpfnWndProc = (WNDPROC)QTFrame_MovieWndProc; myWC.cbClsExtra = 0; myWC.cbWndExtra = 0; myWC.hInstance = hInstance; myWC.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_CHILDICON)); // to avoid having QuickTime VR "fight" with the system over the cursor, // we set the client area cursor to NULL; this means that for QuickTime // movies, we'll need to change the cursor to an arrow manually; see the // handling of the WM_MOUSEMOVE message in QTFrame_MovieWndProc myWC.hCursor = NULL; myWC.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); myWC.lpszMenuName = NULL; myWC.lpszClassName = gChildName; myWC.hIconSm = LoadImage(hInstance, MAKEINTRESOURCE(IDI_CHILDICON), IMAGE_ICON, 16, 16, 0); if (!RegisterClassEx(&myWC)) { if (!RegisterClass((LPWNDCLASS)&myWC.style)) return(0); } } // load accelerators myAccel = LoadAccelerators(hInstance, gAppName); // initialize QuickTime Media Layer and QuickTime; alert the user and return 0 if unsuccessful myErr = InitializeQTML(0L); if (myErr != noErr) { MessageBox(NULL, "QuickTime is not installed on this computer. Exiting.", gAppName, MB_OK | MB_APPLMODAL); return(0); } myErr = EnterMovies(); if (myErr != noErr) { MessageBox(NULL, "Could not initialize QuickTime. Exiting.", gAppName, MB_OK | MB_APPLMODAL); return(0); } // get the application's resource file, if it exists myLength = GetModuleFileName(NULL, myFileName, MAX_PATH); // NULL means: the current process if (myLength != 0) { NativePathNameToFSSpec(myFileName, &gAppFSSpec, kFullNativePath); gAppResFile = FSpOpenResFile(&gAppFSSpec, fsRdWrPerm); if (gAppResFile != kInvalidFileRefNum) UseResFile(gAppResFile); } // do any application-specific initialization that must occur before the frame window is created QTApp_Init(kInitAppPhase_BeforeCreateFrameWindow); // create the main frame window myWindowFrame = CreateWindow(gAppName, gAppName, WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL); ghWnd = myWindowFrame; // make sure we got a frame window if (myWindowFrame == NULL) return(0); // show the window ShowWindow(myWindowFrame, nCmdShow); UpdateWindow(myWindowFrame); // do any application-specific initialization that must occur after the frame window is created QTApp_Init(kInitAppPhase_AfterCreateFrameWindow); // get and process events until the user quits while (GetMessage(&myMsg, NULL, 0, 0)) { if (!TranslateMDISysAccel(ghWndMDIClient, &myMsg)) { if (!TranslateAccelerator(myWindowFrame, myAccel, &myMsg)) { TranslateMessage(&myMsg); DispatchMessage(&myMsg); } } } // close the application's resource file, if it was previously opened if (gAppResFile != kInvalidFileRefNum) CloseResFile(gAppResFile); // terminate the QuickTime Media Layer ExitMovies(); TerminateQTML(); return(myMsg.wParam); // returns the value from PostQuitMessage }
//--------------------------------------- void ofQuicktimeSoundPlayer::closeQuicktime(){ ExitMovies(); // TODO: a problem for video players? }
void QTCode_QTCleanUp() { /* Clean up */ ExitMovies(); TerminateQTML(); }
// uninit driver static void uninit(sh_video_t *sh){ #ifdef CONFIG_QUICKTIME ExitMovies(); #endif }
void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) { if (nlhs < 0) { mexErrMsgTxt("Too few output arguments."); return; } if (nlhs > 1) { mexErrMsgTxt("Too many output arguments."); return; } if (nrhs < 1) { mexErrMsgTxt("Too few input arguments."); return; } if (nrhs > 3) { mexErrMsgTxt("Too many input arguments."); return; } TimeValue duration; TimeRecord myTimeRecord; Rect bounds; OSErr result = 0; short resRefNum = -1; short actualResId = DoTheRightThing; FSSpec theFSSpec; GWorldPtr offWorld; Movie theMovie = nil; MovieController thePlayer = nil; MovieDrawingCompleteUPP myDrawCompleteProc; long frame_end; long myStep = 1; char location[PATH_BUFFER_SIZE]; long frame_count; mwSize cdims[2]; mxGetString(prhs[0], location, PATH_BUFFER_SIZE); if (nrhs > 2) { frame_start = rint(mxGetScalar(prhs[1])); frame_end = rint(mxGetScalar(prhs[2])); } else if (nrhs > 1) { frame_start = 1; frame_end = rint(mxGetScalar(prhs[1])); } else { frame_start = 1; frame_end = 0; } if (frame_start < 1) { mexErrMsgTxt("Error: the starting frame must be positive\n"); return; } if (frame_end < 0) { mexErrMsgTxt("Error: the ending frame must be positive\n"); return; } if (frame_end != 0 && frame_end < frame_start) { mexErrMsgTxt("Error: the ending frame must not be less than the starting frame\n"); return; } myDrawCompleteProc = NewMovieDrawingCompleteUPP(DrawCompleteProc); EnterMovies(); if (NativePathNameToFSSpec(location, &theFSSpec, 0) || OpenMovieFile(&theFSSpec, &resRefNum, 0) || NewMovieFromFile(&theMovie, resRefNum, &actualResId, 0, 0, 0)) { mexErrMsgTxt("Error: failed to open movie\n"); return; } if (resRefNum != -1) CloseMovieFile(resRefNum); GetMovieBox(theMovie, &bounds); QTNewGWorld(&offWorld, k32ARGBPixelFormat, &bounds, NULL, NULL, 0); LockPixels(GetGWorldPixMap(offWorld)); SetGWorld(offWorld, NULL); thePlayer = NewMovieController(theMovie, &bounds, mcTopLeftMovie | mcNotVisible); SetMovieGWorld(theMovie, offWorld, NULL); SetMovieActive(theMovie, true); SetMovieDrawingCompleteProc(theMovie, movieDrawingCallWhenChanged, myDrawCompleteProc, (long) offWorld); GetMovieTime(theMovie, &myTimeRecord); duration = GetMovieDuration(theMovie); // Compute the number of frames for allocation of output structure frame_count = 0; while ((frame_end == 0 || frame_count < frame_end) && GetMovieTime(theMovie, NULL) < duration) { frame_count++; MCDoAction(thePlayer, mcActionStep, (Ptr) myStep); } SetMovieTime(theMovie, &myTimeRecord); // Ignore frames greater than those in the file if (frame_end == 0 || frame_count < frame_end) frame_end = frame_count; cdims[0] = frame_end - frame_start + 1; // Indices are one-based cdims[1] = 1; plhs[0] = mxCreateCellArray(2, cdims); // Step through the movie and save the frame when in the chosen interval // Note: the step size seems to be handled as a short internally. // Using anything greater than 32758 will seek to an incorrect frame frame_num = 1; while (frame_num <= frame_end) { MCDoAction(thePlayer, mcActionStep, (Ptr) myStep); if (frame_num >= frame_start) { MCIdle(thePlayer); mxSetCell(plhs[0], frame_num - frame_start, framedata); } frame_num++; } UnlockPixels(GetGWorldPixMap (offWorld)); DisposeGWorld(offWorld); DisposeMovieController (thePlayer); DisposeMovie(theMovie); DisposeMovieDrawingCompleteUPP(myDrawCompleteProc); ExitMovies(); return; }
int main( int argc, char **argv ) { Movie movie; Track track; Media media; short refNum; short resID = 0; Boolean wasChanged; OSErr err = noErr; FSSpec fsspec; AudioFormatAtomPtr outAudioAtom; CmpSoundHeader outSoundInfo; SoundComponentData theInputFormat, theOutputFormat; SoundConverter mySoundConverter = NULL; // SCFillBufferData scFillBufferData = { NULL }; Ptr pDecomBuffer0 = NULL, pDecomBuffer1 = NULL; long kMaxOutputBuffer = 64 * 1024; long noFrames = 0, niFrames = 0, noBytes = 0, noSamples = 0; #define MAX_BUFFER_SIZE 256 * 1024 * 1024 /** Initialise MovieToolbox */ EnterMovies(); /** Open the movie file from the first argument */ printf( "opening audio file: '%s'\n", argv[1] ); path2fss( &fsspec, argv[1] ); err = OpenMovieFile( &fsspec, &refNum, fsRdPerm ); if ( err != noErr ) { printf( "failed to open audio: %d\n", GetMoviesError() ); exit( -1 ); } /** Instantiate the movie */ err = NewMovieFromFile( &movie, refNum, &resID, NULL, newMovieActive, &wasChanged ); if ( err ) { printf( "failed to instantiate movie\n" ); exit( -1 ); } CloseMovieFile( refNum ); refNum = 0; /** Get the first sound track */ track = GetMovieIndTrackType( movie, 1, SoundMediaType, movieTrackMediaType ); if ( track == NULL ) { printf( "failed to get sound track\n" ); exit( -1 ); } /** Get the sound track media */ media = GetTrackMedia( track ); if ( media == NULL ) { printf( "failed to get media from audio track\n" ); exit( -1 ); } Size size; Handle extension; SoundDescriptionHandle sourceSoundDescription; sourceSoundDescription = (SoundDescriptionHandle)NewHandle(0); /** Get the description of the sample data */ GetMediaSampleDescription( media, 1, (SampleDescriptionHandle)sourceSoundDescription ); err = GetMoviesError(); if ( err ) { printf( "failed to get description of sample data\n" ); exit( -1 ); } extension = NewHandle( 0 ); // get the "magic" decompression atom // This extension to the SoundDescription information stores // data specific to a given audio decompressor. Some audio // decompression algorithms require a set of out-of-stream // values to configure the decompressor. err = GetSoundDescriptionExtension( (SoundDescriptionHandle)sourceSoundDescription, &extension, siDecompressionParams ); if ( noErr == err ) { size = GetHandleSize( extension ); printf( "transferring data to audio buffer: %d bytes\n", size ); HLock( extension ); outAudioAtom = (AudioFormatAtom*)NewPtr( size ); err = MemError(); // copy the atom data to our buffer... BlockMoveData( *extension, outAudioAtom, size ); HUnlock( extension ); } else { // if it doesn't have an atom, that's ok outAudioAtom = NULL; err = noErr; } /** Setup our sound header */ outSoundInfo.format = (*sourceSoundDescription)->dataFormat; outSoundInfo.numChannels = (*sourceSoundDescription)->numChannels; outSoundInfo.sampleSize = (*sourceSoundDescription)->sampleSize; outSoundInfo.sampleRate = (*sourceSoundDescription)->sampleRate; outSoundInfo.compressionID = (*sourceSoundDescription)->compressionID; float db = ((float)outSoundInfo.sampleRate)/(1<<16); printf( "sample: %d\tchannels: %d\tsample size: %d\tsample rate: %f\tcompressionID: %d\n", outSoundInfo.format, outSoundInfo.numChannels, outSoundInfo.sampleSize, db, outSoundInfo.compressionID ); DisposeHandle( extension ); DisposeHandle( (Handle)sourceSoundDescription ); /** * Now that we've figured out what the audio file is, allocate buffers * and so on for conversion and playback */ printf( "initialising input/output conversion buffers\n" ); /** setup input/output format for sound converter */ theInputFormat.flags = 0; theInputFormat.format = outSoundInfo.format; theInputFormat.numChannels = outSoundInfo.numChannels; theInputFormat.sampleSize = outSoundInfo.sampleSize; theInputFormat.sampleRate = outSoundInfo. sampleRate; theInputFormat.sampleCount = 0; theInputFormat.buffer = NULL; theInputFormat.reserved = 0; theOutputFormat.flags = 0; theOutputFormat.format = kSoundNotCompressed; theOutputFormat.numChannels = theInputFormat.numChannels; theOutputFormat.sampleSize = theInputFormat.sampleSize; theOutputFormat.sampleRate = theInputFormat.sampleRate; theOutputFormat.sampleCount = 0; theOutputFormat.buffer = NULL; theOutputFormat.reserved = 0; // variableCompression means we're going to use the commonFrameSize field and the kExtendedSoundCommonFrameSizeValid flag // scFillBufferData.isSourceVBR = (outSoundInfo.compressionID == variableCompression ); err = SoundConverterOpen( &theInputFormat, &theOutputFormat, &mySoundConverter ); if ( err != noErr ) { printf( "failed to open sound converter\n" ); exit( -1 ); } else { printf( "opened sound converter ok\n" ); } // this isn't crucial or even required for decompression only, but it does tell // the sound converter that we're cool with VBR audio Ptr tptr = NewPtr( 1 ); tptr[0] = 1; SoundConverterSetInfo( mySoundConverter, siClientAcceptsVBR, tptr ); free( tptr ); /** * Set up the sound converters decompresson 'environment' by passing * in the 'magic' decompression atom */ err = SoundConverterSetInfo( mySoundConverter, siDecompressionParams, outAudioAtom ); if ( err != noErr ) { printf( "failed to set sound converter info\n" ); exit( -1 ); } else { printf( "set sound converter info ok\n" ); } if ( outAudioAtom ) { DisposePtr( (Ptr)outAudioAtom ); } if ( siUnknownInfoType == err ) { // clear this error, the decompressor didn't // need the decompression atom and that's OK err = noErr; } else { // BailErr(err); } /** * The input buffer has to be large enough so GetMediaSample isn't * going to fail, your mileage may vary */ Handle inputBuffer = NewHandle( MAX_BUFFER_SIZE ); // HLock( inputBuffer ); /** Start the sound conversion */ err = SoundConverterBeginConversion(mySoundConverter); // BailErr(err); /** Extract compressed audio from media track */ TimeValue tperSample = 0; err = GetMediaSample( media, inputBuffer, 0, &noBytes, 0, NULL, &tperSample, NULL, NULL, 0, &noSamples, NULL ); if ( err != noErr ) { printf( "failed to fetch media sample data: %d\n", GetMoviesError() ); exit( -1 ); } else { printf( "media sample: %d (%d) bytes / %ld samples / %d per sample\n", noBytes, GetHandleSize( inputBuffer ), noSamples, tperSample ); } unsigned long niBytes = 0; SoundConverterGetBufferSizes( mySoundConverter, noBytes * noSamples, &niFrames, &niBytes, &noBytes ); printf( "buffer sizes: frames: %d\tibytes: %d\tobytes: %d\n", niFrames, niBytes, noBytes ); /** Convert into uncompressed audio */ Ptr outputBuffer = NewPtr( noBytes * 1.2 ); SoundConverterConvertBuffer( mySoundConverter, inputBuffer, noSamples /* niFrames */, outputBuffer, &noFrames, &noBytes ); printf( "converted: %d frames / %d bytes\n", noFrames, noBytes ); /** Shutdown the sound converter */ err = SoundConverterEndConversion( mySoundConverter, outputBuffer, &noFrames, &noBytes ); printf( "converted final: %d frames / %d bytes\n", noFrames, noBytes ); // HUnlock( inputBuffer ); /** We now should have decompressed audio for the input file */ /** * So, generate visuals using a sliding sample grid at the * given framerate */ /** Create a new movie clip with audio and video tracks */ /** PROJECTM CRAP HERE -- stuff frames into QuickTime */ /** Close movie file */ /** Shutdown MovieToolbox */ ExitMovies(); return 0; }
// uninit driver static void uninit(sh_video_t *sh){ #ifdef MACOSX ExitMovies(); #endif }
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(); }
QuickPlayer::~QuickPlayer() { /* destructor code */ ExitMovies(); }
void ExitQuicktime() { ExitMovies(); }