static void SetupMovieDrawCompleteProc()
{
mMyDrawCompleteProc = NewMovieDrawingCompleteUPP(DrawCompleteProc);
if (mMyDrawCompleteProc)
{
SetMovieDrawingCompleteProc(mMovie,
movieDrawingCallWhenChanged,
mMyDrawCompleteProc,
(long)myMungData);
}
}
int stQuicktimeSetSemaphorefor(int index, int sqHandle) {
// interpreterProxy->signalSemaphoreWithIndex(state->semaIndex);
QuickTimeBitMapForSqueak *myBM;
if( ! (*findSurface)(sqHandle, &QuicktimeTargetDispatch, (int*) (&myBM)) ) {
/* i don't know what it is but certainly not MyBitmap */
return interpreterProxy->primitiveFail();
}
if ((myBM->movie == nil) || (*myBM->movie == 0xFFFFFFFFU))
return interpreterProxy->primitiveFail();
myBM->myDrawCompleteProc = NewMovieDrawingCompleteUPP(DrawCompleteProc);
SetMovieDrawingCompleteProc (myBM->movie,movieDrawingCallWhenChanged,myBM->myDrawCompleteProc,(long) index);
myBM->semaIndex = index;
return 0;
}
//---------------------------------------------------------------------------
bool ofQuickTimePlayer::loadMovie(string name){
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
initializeQuicktime(); // init quicktime
closeMovie(); // if we have a movie open, close it
bLoaded = false; // try to load now
if( name.substr(0, 7) == "http://" || name.substr(0,7) == "rtsp://" ){
if(! createMovieFromURL(name, moviePtr) ) return false;
}else{
name = ofToDataPath(name);
if( !createMovieFromPath((char *)name.c_str(), moviePtr) ) return false;
}
bool bDoWeAlreadyHaveAGworld = false;
if (width != 0 && height != 0){
bDoWeAlreadyHaveAGworld = true;
}
Rect movieRect;
GetMovieBox(moviePtr, &(movieRect));
if (bDoWeAlreadyHaveAGworld){
// is the gworld the same size, then lets *not* de-allocate and reallocate:
if (width == movieRect.right &&
height == movieRect.bottom){
SetMovieGWorld (moviePtr, offscreenGWorld, nil);
} else {
width = movieRect.right;
height = movieRect.bottom;
pixels.clear();
delete(offscreenGWorldPixels);
if ((offscreenGWorld)) DisposeGWorld((offscreenGWorld));
createImgMemAndGWorld();
}
} else {
width = movieRect.right;
height = movieRect.bottom;
createImgMemAndGWorld();
}
if (moviePtr == NULL){
return false;
}
//----------------- callback method
myDrawCompleteProc = NewMovieDrawingCompleteUPP (DrawCompleteProc);
SetMovieDrawingCompleteProc (moviePtr, movieDrawingCallWhenChanged, myDrawCompleteProc, (long)this);
// ------------- get the total # of frames:
nFrames = 0;
TimeValue curMovieTime;
curMovieTime = 0;
TimeValue duration;
//OSType whichMediaType = VIDEO_TYPE; // mingw chokes on this
OSType whichMediaType = FOUR_CHAR_CODE('vide');
short flags = nextTimeMediaSample + nextTimeEdgeOK;
while( curMovieTime >= 0 ) {
nFrames++;
GetMovieNextInterestingTime(moviePtr,flags,1,&whichMediaType,curMovieTime,0,&curMovieTime,&duration);
flags = nextTimeMediaSample;
}
nFrames--; // there's an extra time step at the end of themovie
// ------------- get some pixels in there ------
GoToBeginningOfMovie(moviePtr);
SetMovieActiveSegment(moviePtr, -1,-1);
MoviesTask(moviePtr,0);
#if defined(TARGET_OSX) && defined(__BIG_ENDIAN__)
convertPixels(offscreenGWorldPixels, pixels.getPixels(), width, height);
#endif
bStarted = false;
bLoaded = true;
bPlaying = false;
bHavePixelsChanged = false;
speed = 1;
return true;
//--------------------------------------
#endif
//--------------------------------------
}
//---------------------------------------------------------------------------
bool ofQuickTimePlayer::loadMovie(string name) {
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
initializeQuicktime(); // init quicktime
closeMovie(); // if we have a movie open, close it
bLoaded = false; // try to load now
// from : https://github.com/openframeworks/openFrameworks/issues/244
// http://developer.apple.com/library/mac/#documentation/QuickTime/RM/QTforWindows/QTforWindows/C-Chapter/3BuildingQuickTimeCa.html
// Apple's documentation *seems* to state that a Gworld should have been set prior to calling NewMovieFromFile
// So I set a dummy Gworld (1x1 pixel) before calling createMovieFromPath
// it avoids crash at the creation of objet ofVideoPlayer after a previous ofVideoPlayer have been deleted
#ifdef TARGET_WIN32
if (width != 0 && height != 0) {
pixels.clear();
delete [] offscreenGWorldPixels;
}
width = 1;
height = 1;
createImgMemAndGWorld();
#endif
if( name.substr(0, 7) == "http://" || name.substr(0,7) == "rtsp://" ) {
if(! createMovieFromURL(name, moviePtr) ) return false;
} else {
name = ofToDataPath(name);
if( !createMovieFromPath((char *)name.c_str(), moviePtr) ) return false;
}
bool bDoWeAlreadyHaveAGworld = false;
if (width != 0 && height != 0) {
bDoWeAlreadyHaveAGworld = true;
}
Rect movieRect;
GetMovieBox(moviePtr, &(movieRect));
if (bDoWeAlreadyHaveAGworld) {
// is the gworld the same size, then lets *not* de-allocate and reallocate:
if (width == movieRect.right &&
height == movieRect.bottom) {
SetMovieGWorld (moviePtr, offscreenGWorld, nil);
} else {
width = movieRect.right;
height = movieRect.bottom;
pixels.clear();
delete [] offscreenGWorldPixels;
if ((offscreenGWorld)) DisposeGWorld((offscreenGWorld));
createImgMemAndGWorld();
}
} else {
width = movieRect.right;
height = movieRect.bottom;
createImgMemAndGWorld();
}
if (moviePtr == NULL) {
return false;
}
//----------------- callback method
myDrawCompleteProc = NewMovieDrawingCompleteUPP (DrawCompleteProc);
SetMovieDrawingCompleteProc (moviePtr, movieDrawingCallWhenChanged, myDrawCompleteProc, (long)this);
// ------------- get the total # of frames:
nFrames = 0;
TimeValue curMovieTime;
curMovieTime = 0;
TimeValue duration;
//OSType whichMediaType = VIDEO_TYPE; // mingw chokes on this
OSType whichMediaType = FOUR_CHAR_CODE('vide');
short flags = nextTimeMediaSample + nextTimeEdgeOK;
while( curMovieTime >= 0 ) {
nFrames++;
GetMovieNextInterestingTime(moviePtr,flags,1,&whichMediaType,curMovieTime,0,&curMovieTime,&duration);
flags = nextTimeMediaSample;
}
nFrames--; // there's an extra time step at the end of themovie
// ------------- get some pixels in there ------
GoToBeginningOfMovie(moviePtr);
SetMovieActiveSegment(moviePtr, -1,-1);
MoviesTask(moviePtr,0);
#if defined(TARGET_OSX) && defined(__BIG_ENDIAN__)
convertPixels(offscreenGWorldPixels, pixels.getPixels(), width, height);
#endif
bStarted = false;
bLoaded = true;
bPlaying = false;
bHavePixelsChanged = false;
speed = 1;
return true;
//--------------------------------------
#endif
//--------------------------------------
}
//---------------------------------------------------------------------------
bool ofVideoPlayer::loadMovie(string name){
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
initializeQuicktime(); // init quicktime
closeMovie(); // if we have a movie open, close it
bLoaded = false; // try to load now
if( name.substr(0, 7) == "http://"){
if(! createMovieFromURL(name, moviePtr) ) return false;
}else{
name = ofToDataPath(name);
if( !createMovieFromPath((char *)name.c_str(), moviePtr) ) return false;
}
bool bDoWeAlreadyHaveAGworld = false;
if (width != 0 && height != 0){
bDoWeAlreadyHaveAGworld = true;
}
Rect movieRect;
GetMovieBox(moviePtr, &(movieRect));
if (bDoWeAlreadyHaveAGworld){
// is the gworld the same size, then lets *not* de-allocate and reallocate:
if (width == movieRect.right &&
height == movieRect.bottom){
SetMovieGWorld (moviePtr, offscreenGWorld, nil);
} else {
width = movieRect.right;
height = movieRect.bottom;
delete(pixels);
delete(offscreenGWorldPixels);
if ((offscreenGWorld)) DisposeGWorld((offscreenGWorld));
createImgMemAndGWorld();
}
} else {
width = movieRect.right;
height = movieRect.bottom;
createImgMemAndGWorld();
}
if (moviePtr == NULL){
return false;
}
//----------------- callback method
MovieDrawingCompleteUPP myDrawCompleteProc;
myDrawCompleteProc = NewMovieDrawingCompleteUPP (DrawCompleteProc);
SetMovieDrawingCompleteProc (moviePtr, movieDrawingCallWhenChanged, myDrawCompleteProc, (long)this);
// ------------- get some pixels in there ------
GoToBeginningOfMovie(moviePtr);
SetMovieActiveSegment(moviePtr, -1,-1);
MoviesTask(moviePtr,0);
convertPixels(offscreenGWorldPixels, pixels, width, height);
if (bUseTexture == true){
tex.loadData(pixels, width, height, GL_RGB);
}
bStarted = false;
bLoaded = true;
bPlaying = false;
bHavePixelsChanged = false;
speed = 1;
return true;
//--------------------------------------
#else
//--------------------------------------
bLoaded = false;
bPaused = false;
speed = 1.0f;
bHavePixelsChanged = false;
name = ofToDataPath(name);
fobsDecoder = new omnividea::fobs::Decoder(name.c_str());
omnividea::fobs::ReturnCode error = fobsDecoder->open();
width = fobsDecoder->getWidth();
height = fobsDecoder->getHeight();
pixels = new unsigned char[width*height*3];
if (!fobsDecoder->isVideoPresent()){
return false;
}
bLoaded = true;
if (bUseTexture){
// create the texture, set the pixels to black and
// upload them to the texture (so at least we see nothing black the callback)
tex.allocate(width,height,GL_RGB);
memset(pixels, 0, width*height*3);
tex.loadData(pixels, width, height, GL_RGB);
}
error = fobsDecoder->setFrame(0);
if(error == omnividea::fobs::NoFrameError) {
error = omnividea::fobs::OkCode;
printf("NoFrameError\n");
}
if(omnividea::fobs::isOk(error)){
// get some pixels in:
unsigned char *rgb = fobsDecoder->getRGB();
if(rgb == NULL) error = omnividea::fobs::GenericError;
if(isOk(error))
{
memcpy(pixels, rgb, width*height*3);
tex.loadData(pixels, width, height, GL_RGB);
}
}
iTotalFrames = (int)(fobsDecoder->getFrameRate()*fobsDecoder->getDurationSeconds());
positionPct = 0;
timeLastIdle = ofGetElapsedTimef();
durationMillis = fobsDecoder->getDurationSeconds() * 1000.0f;
return true;
//--------------------------------------
#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;
}
