OSErr DoPlayMovie(Boolean useOverlay)
{
Rect movieBounds;
OSErr err;
BailErr((err = GetAMovieFile(&mMovie)));
GetMovieBox(mMovie, &movieBounds);
mMovieController = NewMovieController(mMovie, &movieBounds, mcTopLeftMovie | mcNotVisible);
NormalizeMovieRect(mMovie);
GetMovieBox(mMovie, &movieBounds);
BailErr((err = InitializeMungData(movieBounds,
FrontWindow(),
useOverlay, /* overlay */
true, /* clamp */
false /* draw with QT Effect */
)));
// This is key, as we need to draw all frames in our
// offscreen gworld first. Once there, our custom
// decompressor component can perform overlay drawing
// or color clamping
SetMovieGWorld(mMovie, GetMungDataOffscreen(), nil);
// Our DrawCompleteProc calls BlitOneMungData which
SetupMovieDrawCompleteProc();
// ---------
SetMovieActive(mMovie, true);
#ifndef __APPLE_CC__
// Due to a bug in Jaguar, some QT functions are missing from
// /System/Library/CFMSupport/CarbonLib, so we must manually
// grab the function pointers from the QuickTime.framework
// for CFM Carbon applications. MachO Carbon applications do not
// have the problem.
GetMissingQTFunctionPointers();
#endif
InstallMovieIdlingEventLoopTimer(&mMovieTimerState);
// start the movie playing
MCDoAction(mMovieController, mcActionPrerollAndPlay, (void*)Long2Fix(1));
bail:
return err;
}
////////////////////////////////////////////////////////////////////////////////
// private
bool LLMediaImplQuickTime::load( const std::string url )
{
if ( url.empty() )
return false;
//In case std::string::c_str() makes a copy of the url data,
//make sure there is memory to hold it before allocating memory for handle.
//if fails, NewHandleClear(...) should return NULL.
const char* url_string = url.c_str() ;
Handle handle = NewHandleClear( ( Size )( url.length() + 1 ) );
if ( NULL == handle )
return false;
if(noErr != MemError() || NULL == *handle)
{
return false ;
}
BlockMove( url_string, *handle, ( Size )( url.length() + 1 ) );
//std::cout << "LLMediaImplQuickTime::load( " << url << " )" << std::endl;
// TODO: supposed to use NewMovieFromDataParams now
OSErr err = NewMovieFromDataRef( &mMovieHandle, newMovieActive | newMovieDontInteractWithUser | newMovieAsyncOK | newMovieIdleImportOK, nil, handle, URLDataHandlerSubType );
DisposeHandle( handle );
if ( noErr != err )
return false;
// do pre-roll actions (typically fired for streaming movies but not always)
PrePrerollMovie( mMovieHandle, 0, GetMoviePreferredRate( mMovieHandle ), moviePrePrerollCompleteCallback, ( void * )this );
// get movie rect (and check for min/max)
Rect movie_rect;
setMovieBoxEnhanced( &movie_rect );
// make a new movie controller
mMovieController = NewMovieController( mMovieHandle, &movie_rect, mcNotVisible | mcTopLeftMovie );
#if defined(__APPLE__) || defined(MACOSX)
setMediaDepth( 4 );
#else
setMediaDepth( 3 );
#endif
// tell manager about the media size
setMediaSize( movie_rect.right - movie_rect.left, movie_rect.bottom - movie_rect.top);
// movie controller
MCSetActionFilterWithRefCon( mMovieController, mcActionFilterCallBack, ( long )this );
SetMoviePlayHints( mMovieHandle, hintsAllowDynamicResize, hintsAllowDynamicResize );
// function that gets called when a frame is drawn
SetMovieDrawingCompleteProc( mMovieHandle, movieDrawingCallWhenChanged, movieDrawingCompleteCallback, ( long )this );
// emit an event to say that a media source was loaded
LLMediaEvent event( this );
mEventEmitter.update( &LLMediaObserver::onMediaLoaded, event );
// set up inital state
sizeChanged();
return true;
}
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;
}
boolean playeropenmovieinwindow ( ptrfilespec f ) {
//
// 2006-06-23 creedon: FSRef-zed
//
// 7.0b4 PBS: open a movie in the QuickTime Player window and display it. If the window isn't already open, open it.
//
short movieresref;
OSErr err;
hdlwindowinfo hinfo;
FSSpec fs;
if (macgetfsspec (f, &fs) != noErr)
return (false);
if (!findplayerwindow (&hinfo))
playeropencommand (); // If the Player window doesn't exist, create a new one.
getwindowinfo (playerwindow, &playerwindowinfo);
playerdisposecurrentmovie (); // make sure the current movie has been disposed
SetGWorld (GetWindowPort (playerwindow), nil);
err = OpenMovieFile ( &fs, &movieresref, fsRdPerm);
if (err != noErr)
return (false);
NewMovieFromFile (¤tmovie, movieresref, nil, nil, newMovieActive, nil);
CloseMovieFile (movieresref);
SetMovieGWorld (currentmovie, GetWindowPort (playerwindow), nil);
GetMovieBox (currentmovie, ¤tmovierect);
OffsetRect (¤tmovierect, -currentmovierect.left, -currentmovierect.top);
SetMovieBox (currentmovie, ¤tmovierect);
currentcontroller = NewMovieController (currentmovie, ¤tmovierect, mcTopLeftMovie);
MCGetControllerBoundsRect (currentcontroller, ¤tmovierect);
//MCSetActionFilterWithRefCon (currentcontroller, NewMCActionFilterWithRefConProc(playermoviecontrollereventfilter), (long) playerwindow);
SizeWindow (playerwindow, currentmovierect.right, currentmovierect.bottom, false);
(**playerwindowinfo).contentrect = currentmovierect;
AlignWindow (playerwindow, false, nil, nil); // position for optimal playback
//MCDoAction (currentcontroller, mcActionSetKeysEnabled, (void *) true); /*enable keyboard input*/ /*No!*/
MoviesTask (nil, 0);
MCIdle (currentcontroller);
return (true);
} // playeropenmovieinwindow
