OSErr QTDR_PlayMovieFromRAM (Movie theMovie)
{
WindowPtr myWindow = NULL;
Rect myBounds = {50, 50, 100, 100};
Rect myRect;
StringPtr myTitle = QTUtils_ConvertCToPascalString(kWindowTitle);
OSErr myErr = memFullErr;
myWindow = NewCWindow(NULL, &myBounds, myTitle, false, 0, (WindowPtr)-1, false, 0);
if (myWindow == NULL)
goto bail;
myErr = noErr;
MacSetPort((GrafPtr)GetWindowPort(myWindow));
GetMovieBox(theMovie, &myRect);
MacOffsetRect(&myRect, -myRect.left, -myRect.top);
SetMovieBox(theMovie, &myRect);
if (!EmptyRect(&myRect))
SizeWindow(myWindow, myRect.right, myRect.bottom, false);
else
SizeWindow(myWindow, 200, 0, false);
MacShowWindow(myWindow);
SetMovieGWorld(theMovie, GetWindowPort(myWindow), NULL);
GoToBeginningOfMovie(theMovie);
MoviesTask(theMovie, 0);
StartMovie(theMovie);
myErr = GetMoviesError();
if (myErr != noErr)
goto bail;
while (!IsMovieDone(theMovie))
MoviesTask(theMovie, 0);
bail:
free(myTitle);
if (theMovie != NULL)
DisposeMovie(theMovie);
if (myWindow != NULL)
DisposeWindow(myWindow);
return(myErr);
}
//--------------------------------------------------------
void ofVideoPlayer::play(){
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
if (!bStarted){
start();
}else {
// ------------ lower level "startMovie"
// ------------ use desired speed & time (-1,1,etc) to Preroll...
bPlaying = true;
TimeValue timeNow;
timeNow = GetMovieTime(moviePtr, nil);
PrerollMovie(moviePtr, timeNow, X2Fix(speed));
SetMovieRate(moviePtr, X2Fix(speed));
MoviesTask(moviePtr, 0);
}
//--------------------------------------
#endif
//--------------------------------------
}
/** Internal helper function: Returns fps rate of movie and optionally
* the total number of video frames in the movie. Framecount is determined
* by stepping through the whole movie and counting frames. This can take
* significant time on big movie files.
*
* Always returns fps as a double. Only counts and returns full framecount,
* if *nrframes is non-NULL.
*/
double PsychDetermineMovieFramecountAndFps(Movie theMovie, int* nrframes)
{
// Count total number of videoframes: This code is derived from Apple
// example code.
long myCount = -1;
short myFlags;
TimeValue myTime = 0;
TimeValue myDuration = 0;
OSType myTypes[1];
// We want video samples.
myTypes[0] = VisualMediaCharacteristic;
// We want to begin with the first frame in the movie:
myFlags = nextTimeStep + nextTimeEdgeOK;
// We count either the first 3 frames if nrframes==NULL aka only
// fps requested, or if framecount is requested, we count all frames.
while (myTime >= 0 && (myCount<2 || nrframes!=NULL)) {
myCount++;
// look for the next frame in the track; when there are no more frames,
// myTime is set to -1, so we'll exit the while loop
GetMovieNextInterestingTime(theMovie, myFlags, 1, myTypes, myTime, FloatToFixed(1), &myTime, &myDuration);
// after the first interesting time, don't include the time we're currently at
myFlags = nextTimeStep;
}
// Return optional count of frames:
if (nrframes) *nrframes = (int) myCount;
GoToBeginningOfMovie(theMovie);
MoviesTask(theMovie, 0);
// Compute and return frame rate in fps as (Ticks per second / Duration of single frame in ticks):
return((double) GetMovieTimeScale(theMovie) / (double) myDuration);
}
/*
* PsychSetMovieTimeIndex() -- Set current playback time of movie.
*/
double PsychSetMovieTimeIndex(int moviehandle, double timeindex)
{
Movie theMovie;
double oldtime;
if (moviehandle < 0 || moviehandle >= PSYCH_MAX_MOVIES) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided!");
}
// Fetch references to objects we need:
theMovie = movieRecordBANK[moviehandle].theMovie;
if (theMovie == NULL) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided. No movie associated with this handle !!!");
}
// Retrieve current timeindex:
oldtime = (double) GetMovieTime(theMovie, NULL) / (double) GetMovieTimeScale(theMovie);
// Set new timeindex:
SetMovieTimeValue(theMovie, (TimeValue) (((timeindex * (double) GetMovieTimeScale(theMovie))) + 0.5f));
// Check if end of movie is reached. Rewind, if so...
if (IsMovieDone(theMovie) && movieRecordBANK[moviehandle].loopflag > 0) {
if (GetMovieRate(theMovie)>0) {
GoToBeginningOfMovie(theMovie);
} else {
GoToEndOfMovie(theMovie);
}
}
MoviesTask(theMovie, 0);
// Return old value:
return(oldtime);
}
static DWORD WINAPI QTSplitter_loading_thread(LPVOID data)
{
QTSplitter *This = (QTSplitter *)data;
if (This->pAudio_Pin)
{
/* according to QA1469 a movie has to be fully loaded before we
can reliably start the Extraction session.
If loaded earlier, then we only get an extraction session for
the part of the movie that is loaded at that time.
We are trying to load as much of the movie as we can before we
start extracting. However we can recreate the extraction session
again when we run out of loaded extraction frames. But we want
to try to minimize that.
*/
EnterCriticalSection(&This->csReceive);
while(This->pQTMovie && GetMovieLoadState(This->pQTMovie) < kMovieLoadStateComplete)
{
MoviesTask(This->pQTMovie, 100);
LeaveCriticalSection(&This->csReceive);
Sleep(0);
EnterCriticalSection(&This->csReceive);
}
LeaveCriticalSection(&This->csReceive);
}
return 0;
}
//---------------------------------------------------------------------------
void ofVideoPlayer::setPosition(float pct){
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
TimeRecord tr;
tr.base = GetMovieTimeBase(moviePtr);
long total = GetMovieDuration(moviePtr );
long newPos = (long)((float)total * pct);
SetMovieTimeValue(moviePtr, newPos);
MoviesTask(moviePtr,0);
//--------------------------------------
#else
//--------------------------------------
gstUtils.setPosition(pct);
//--------------------------------------
#endif
//--------------------------------------
}
void QTCode_ForceMovieRedraw(Movie theMovie)
{
OSErr err = noErr;
Rect movieRect;
RgnHandle clipRegion = NULL;
if (theMovie == NULL) goto bail;
clipRegion = NewRgn();
if (clipRegion == NULL) goto bail;
GetClip(clipRegion);
GetMovieBox(theMovie, &movieRect);
ClipRect(&movieRect);
UpdateMovie(theMovie);
MoviesTask(theMovie, 0);
SetClip(clipRegion);
/* Closure. Clean up if we have handles. */
bail:
if (clipRegion != NULL)
{
DisposeRgn(clipRegion);
}
}
//---------------------------------------------------------------------------
void ofQuickTimePlayer::update(){
if (bLoaded == true){
//--------------------------------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------------------------------
#if defined(TARGET_WIN32) || defined(QT_USE_MOVIETASK)
MoviesTask(moviePtr,0);
#endif
//--------------------------------------------------------------
#endif
//--------------------------------------------------------------
}
// ---------------------------------------------------
// on all platforms,
// do "new"ness ever time we idle...
// before "isFrameNew" was clearning,
// people had issues with that...
// and it was badly named so now, newness happens
// per-idle not per isNew call
// ---------------------------------------------------
if (bLoaded == true){
bIsFrameNew = bHavePixelsChanged;
if (bHavePixelsChanged == true) {
bHavePixelsChanged = false;
}
}
}
//--------------------------------------------------------
void ofQuickTimePlayer::start(){
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
if (bLoaded == true && bStarted == false){
SetMovieActive(moviePtr, true);
//------------------ set the movie rate to default
//------------------ and preroll, so the first frames come correct
TimeValue timeNow = GetMovieTime(moviePtr, 0);
Fixed playRate = GetMoviePreferredRate(moviePtr); //Not being used!
PrerollMovie(moviePtr, timeNow, X2Fix(speed));
SetMovieRate(moviePtr, X2Fix(speed));
setLoopState(currentLoopState);
// get some pixels in there right away:
MoviesTask(moviePtr,0);
#if defined(TARGET_OSX) && defined(__BIG_ENDIAN__)
convertPixels(offscreenGWorldPixels, pixels.getPixels(), width, height);
#endif
bHavePixelsChanged = true;
bStarted = true;
bPlaying = true;
}
//--------------------------------------
#endif
//--------------------------------------
}
boolean isplayerevent (void) {
/*
7.0b4 PBS: called from the main event loop.
QuickTime needs to catch some events.
Return true if the event is consumed by QuickTime
and should be ignored by the event loop.
*/
boolean fl = false;
if (currentmovie == nil) /*if no current movie, return right away*/
return (fl);
if (currentcontroller == nil) /*if no controller, return right away*/
return (fl);
if (MCIsPlayerEvent (currentcontroller, &shellevent))
fl = true; /*the event was consumed by QuickTime*/
MCIdle (currentcontroller);
MoviesTask (nil, 0);
return (fl);
} /*isplayerevent*/
//--------------------------------------------------------
void ofQuickTimePlayer::play(){
if( !isLoaded() ){
ofLog(OF_LOG_ERROR, "ofQuickTimePlayer::play - movie not loaded!");
return;
}
bPlaying = true;
bPaused = false;
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
if (!bStarted){
start();
}else {
// ------------ lower level "startMovie"
// ------------ use desired speed & time (-1,1,etc) to Preroll...
TimeValue timeNow;
timeNow = GetMovieTime(moviePtr, nil);
PrerollMovie(moviePtr, timeNow, X2Fix(speed));
SetMovieRate(moviePtr, X2Fix(speed));
MoviesTask(moviePtr, 0);
}
//--------------------------------------
#endif
//--------------------------------------
//this is if we set the speed first but it only can be set when we are playing.
setSpeed(speed);
}
//--------------------------------------------------------
void ofVideoPlayer::start(){
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
if (bLoaded == true && bStarted == false){
SetMovieActive(moviePtr, true);
//------------------ set the movie rate to default
//------------------ and preroll, so the first frames come correct
TimeValue timeNow = GetMovieTime(moviePtr, 0);
Fixed playRate = GetMoviePreferredRate(moviePtr); //Not being used!
PrerollMovie(moviePtr, timeNow, X2Fix(speed));
SetMovieRate(moviePtr, X2Fix(speed));
setLoopState(OF_LOOP_NORMAL);
// get some pixels in there right away:
MoviesTask(moviePtr,0);
convertPixels(offscreenGWorldPixels, pixels, width, height);
bHavePixelsChanged = true;
if (bUseTexture == true){
tex.loadData(pixels, width, height, GL_RGB);
}
bStarted = true;
bPlaying = true;
}
//--------------------------------------
#endif
//--------------------------------------
}
//
// MusicEvents
// Called in the event loop to keep track of MIDI music
//
void MIDI_Update (void)
{
if (midiTrack)
{
// pOx - adjust volume if changed
if (old_volume != bgmvolume.value)
MIDI_SetVolume (&bgmvolume);
// Let QuickTime get some time
MoviesTask (midiTrack, 0);
// If this song is looping, restart it
if (IsMovieDone (midiTrack))
{
if (bLooped)
{
GoToBeginningOfMovie (midiTrack);
StartMovie (midiTrack);
}
else
{
DisposeMovie (midiTrack);
midiTrack = NULL;
}
}
}
}
//---------------------------------------------------------------------------
void ofQuickTimePlayer::update() {
if (bLoaded == true) {
//--------------------------------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------------------------------
// is this necessary on windows with quicktime?
#ifdef TARGET_OSX
// call MoviesTask if we're not on the main thread
if ( CFRunLoopGetCurrent() != CFRunLoopGetMain() )
{
//ofLog( OF_LOG_NOTICE, "not on the main loop, calling MoviesTask") ;
MoviesTask(moviePtr,0);
}
#else
// on windows we always call MoviesTask
MoviesTask(moviePtr,0);
#endif
//--------------------------------------------------------------
#endif
//--------------------------------------------------------------
}
// ---------------------------------------------------
// on all platforms,
// do "new"ness ever time we idle...
// before "isFrameNew" was clearning,
// people had issues with that...
// and it was badly named so now, newness happens
// per-idle not per isNew call
// ---------------------------------------------------
if (bLoaded == true) {
bIsFrameNew = bHavePixelsChanged;
if (bHavePixelsChanged == true) {
bHavePixelsChanged = false;
}
}
}
/*
* PsychQTDeleteMovie() -- Delete a movie object and release all associated ressources.
*/
void PsychQTDeleteMovie(int moviehandle)
{
if (moviehandle < 0 || moviehandle >= PSYCH_MAX_MOVIES) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided!");
}
if (movieRecordBANK[moviehandle].theMovie == NULL) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided. No movie associated with this handle !!!");
}
// Stop movie playback immediately:
MoviesTask(movieRecordBANK[moviehandle].theMovie, 0);
StopMovie(movieRecordBANK[moviehandle].theMovie);
glFinish();
QTVisualContextTask(movieRecordBANK[moviehandle].QTMovieContext);
MoviesTask(movieRecordBANK[moviehandle].theMovie, 0);
QTVisualContextTask(movieRecordBANK[moviehandle].QTMovieContext);
glFinish();
// Delete movieobject for this handle:
DisposeMovie(movieRecordBANK[moviehandle].theMovie);
movieRecordBANK[moviehandle].theMovie=NULL;
// Delete GWorld if any:
if (movieRecordBANK[moviehandle].QTMovieGWorld) DisposeGWorld(movieRecordBANK[moviehandle].QTMovieGWorld);
movieRecordBANK[moviehandle].QTMovieGWorld = NULL;
// Delete visual context for this movie:
if (movieRecordBANK[moviehandle].QTMovieContext) QTVisualContextRelease(movieRecordBANK[moviehandle].QTMovieContext);
movieRecordBANK[moviehandle].QTMovieContext = NULL;
// Delete audio context for this movie:
QTAudioContextRelease(movieRecordBANK[moviehandle].QTAudioContext);
movieRecordBANK[moviehandle].QTAudioContext = NULL;
// Decrease counter:
if (numMovieRecords>0) numMovieRecords--;
return;
}
//---------------------------------------------------------------------------
void ofxAlphaVideoPlayer::idleMovie(){
if (bLoaded == true){
//--------------------------------------------------------------
#ifndef TARGET_LINUX // !linux = quicktime...
//--------------------------------------------------------------
#if defined(TARGET_WIN32) || defined(QT_USE_MOVIETASK)
MoviesTask(moviePtr,0);
#endif
//--------------------------------------------------------------
#else // linux.
//--------------------------------------------------------------
gstUtils.update();
if(gstUtils.isFrameNew()){
bHavePixelsChanged = true;
width = gstUtils.getWidth();
height = gstUtils.getHeight();
tex.loadData(gstUtils.getPixels(), width, height, GL_RGBA);
}
//--------------------------------------------------------------
#endif
//--------------------------------------------------------------
}
// ---------------------------------------------------
// on all platforms,
// do "new"ness ever time we idle...
// before "isFrameNew" was clearning,
// people had issues with that...
// and it was badly named so now, newness happens
// per-idle not per isNew call
// ---------------------------------------------------
if (bLoaded == true){
bIsFrameNew = bHavePixelsChanged;
if (bHavePixelsChanged == true) {
bHavePixelsChanged = false;
}
}
}
void wxOSXQuickTimeSoundData::SoundTask()
{
if(IsMovieDone(m_movie))
{
if (m_flags & wxSOUND_LOOP)
{
StopMovie(m_movie);
GoToBeginningOfMovie(m_movie);
StartMovie(m_movie);
}
else
Stop();
}
else
MoviesTask(m_movie, MOVIE_DELAY); //Give QT time to play movie
}
static void playerupdate (void) {
/*
*/
if (currentmovie == nil)
return;
BeginUpdate (playerwindow);
UpdateMovie (currentmovie);
EndUpdate (playerwindow);
MoviesTask (nil, 0);
MCIdle (currentcontroller);
} /*playerupdate*/
//---------------------------------------------------------------------------
void ofVideoPlayer::setFrame(int frame){
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
// frame 0 = first frame...
// this is the simple way...
//float durationPerFrame = getDuration() / getTotalNumFrames();
// seems that freezing, doing this and unfreezing seems to work alot
// better then just SetMovieTimeValue() ;
if (!bPaused) SetMovieRate(moviePtr, X2Fix(0));
// this is better with mpeg, etc:
double frameRate = 0;
double movieTimeScale = 0;
MovieGetStaticFrameRate(moviePtr, &frameRate);
movieTimeScale = GetMovieTimeScale(moviePtr);
if (frameRate > 0){
double frameDuration = 1 / frameRate;
TimeValue t = (TimeValue)(frame * frameDuration * movieTimeScale);
SetMovieTimeValue(moviePtr, t);
MoviesTask(moviePtr, 0);
}
if (!bPaused) SetMovieRate(moviePtr, X2Fix(speed));
//--------------------------------------
#else
//--------------------------------------
gstUtils.setFrame(frame);
//--------------------------------------
#endif
//--------------------------------------
}
boolean playerplaymovie (void) {
/*
7.0b4 PBS: play the movie that's loaded.
*/
if (currentmovie == nil)
return (false);
GoToBeginningOfMovie (currentmovie);
SetMovieActive (currentmovie, true);
MCDoAction (currentcontroller, mcActionPlay, (void *) true); /*Start playing.*/
MoviesTask (nil, 0);
return (true);
} /*playerplaymovie*/
void Notify()
{
if (m_pbPlaying && !*m_pbPlaying)
{
Shutdown();
}
if(IsMovieDone(m_movie))
{
if (!m_bLoop)
Shutdown();
else
{
StopMovie(m_movie);
GoToBeginningOfMovie(m_movie);
StartMovie(m_movie);
}
}
else
MoviesTask(m_movie, MOVIE_DELAY); //Give QT time to play movie
}
/**
* Checks whether the player is active.
*
* This function is called at regular intervals from OpenTTD's main loop, so
* we call @c MoviesTask() from here to let QuickTime do its work.
*/
bool MusicDriver_QtMidi::IsSongPlaying()
{
if (!_quicktime_started) return true;
switch (_quicktime_state) {
case QT_STATE_IDLE:
case QT_STATE_STOP:
/* Do nothing. */
break;
case QT_STATE_PLAY:
MoviesTask(_quicktime_movie, 0);
/* Check wether movie ended. */
if (IsMovieDone(_quicktime_movie) ||
(GetMovieTime(_quicktime_movie, NULL) >=
GetMovieDuration(_quicktime_movie))) {
_quicktime_state = QT_STATE_STOP;
}
}
return _quicktime_state == QT_STATE_PLAY;
}
void *
Thread_PlaySound_QuickTime(void *data)
{
int done = FALSE;
fQTPlaying = TRUE;
do {
listOLD *pl;
pthread_mutex_lock(&mutexQTAccess);
/* give CPU time to QT to process all running movies */
MoviesTask(NULL, 0);
/* check if there are any running movie left */
pl = &movielist;
done = TRUE;
do {
listOLD *next = pl->plNext;
if (pl->p != NULL) {
Movie *movie = (Movie *) pl->p;
if (IsMovieDone(*movie)) {
DisposeMovie(*movie);
free(movie);
ListDelete(pl);
} else
done = FALSE;
}
pl = next;
} while (pl != &movielist);
pthread_mutex_unlock(&mutexQTAccess);
} while (!done && fQTPlaying);
fQTPlaying = FALSE;
return NULL;
}
/*
* PsychQTPlaybackRate() - Start- and stop movieplayback, set playback parameters.
*
* moviehandle = Movie to start-/stop.
* playbackrate = zero == Stop playback, non-zero == Play movie with spec. rate,
* e.g., 1 = forward, 2 = double speed forward, -1 = backward, ...
* loop = 0 = Play once. 1 = Loop, aka rewind at end of movie and restart.
* soundvolume = 0 == Mute sound playback, between 0.0 and 1.0 == Set volume to 0 - 100 %.
* Returns Number of dropped frames to keep playback in sync.
*/
int PsychQTPlaybackRate(int moviehandle, double playbackrate, int loop, double soundvolume)
{
int dropped = 0;
Movie theMovie;
if (moviehandle < 0 || moviehandle >= PSYCH_MAX_MOVIES) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided!");
}
// Fetch references to objects we need:
theMovie = movieRecordBANK[moviehandle].theMovie;
if (theMovie == NULL) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided. No movie associated with this handle !!!");
}
if (playbackrate != 0) {
// Start playback of movie:
SetMovieAudioMute(theMovie, (soundvolume==0) ? TRUE : FALSE, 0);
SetMovieVolume(theMovie, (short) (soundvolume * 255.0));
movieRecordBANK[moviehandle].loopflag = loop;
movieRecordBANK[moviehandle].last_pts = -1.0;
movieRecordBANK[moviehandle].nr_droppedframes = 0;
SetMoviePreferredRate(theMovie, FloatToFixed(playbackrate));
StartMovie(theMovie);
MoviesTask(theMovie, 10000);
}
else {
// Stop playback of movie:
StopMovie(theMovie);
QTVisualContextTask(movieRecordBANK[moviehandle].QTMovieContext);
// Output count of dropped frames:
if ((dropped=movieRecordBANK[moviehandle].nr_droppedframes) > 0) {
if (PsychPrefStateGet_Verbosity()>2) printf("PTB-INFO: Movie playback had to drop %i frames of movie %i to keep playback in sync.\n", movieRecordBANK[moviehandle].nr_droppedframes, moviehandle);
}
}
return(dropped);
}
////////////////////////////////////////////////////////////////////////////////
// virtual
bool LLMediaImplQuickTime::updateMedia()
{
if ( ! mMovieHandle )
return false;
if ( ! mMovieController )
return false;
if ( ! mGWorldHandle )
return false;
// service QuickTime
MoviesTask( mMovieHandle, 0 );
MCIdle( mMovieController );
// update state machine (deals with transport controls for example)
processState();
// special code for looping - need to rewind at the end of the movie
if ( isLooping() )
{
// QT call to see if we are at the end - can't do with controller
if ( IsMovieDone( mMovieHandle ) )
{
// go back to start
rewind();
// kick off new play
MCDoAction( mMovieController, mcActionPrerollAndPlay, (void*)GetMoviePreferredRate( mMovieHandle ) );
// set the volume
MCDoAction( mMovieController, mcActionSetVolume, (void*)mCurVolume );
}
}
return true;
}
//---------------------------------------------------------------------------
void ofQuickTimePlayer::setPosition(float pct){
if( !isLoaded() ){
ofLog(OF_LOG_ERROR, "ofQuickTimePlayer: movie not loaded!");
return;
}
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
TimeRecord tr;
tr.base = GetMovieTimeBase(moviePtr);
long total = GetMovieDuration(moviePtr );
long newPos = (long)((float)total * pct);
SetMovieTimeValue(moviePtr, newPos);
MoviesTask(moviePtr,0);
//--------------------------------------
#endif
//--------------------------------------
}
void QuicktimeImageStream::run()
{
bool playing = false;
bool done = false;
while (!done) {
ThreadCommand cmd = getCmd();
OSG_DEBUG << "movietime: " << _movieData->getMovieTime() << " rate: " << _movieData->getMovieRate() << " state " << cmd << " playing: " << playing << " done " << done << " " << _wrIndex << "/" << _rdIndex << std::endl;
// Handle commands
{
if (cmd != THREAD_IDLE) {
OSG_DEBUG << "new cmd: " << cmd << std::endl;
switch (cmd) {
case THREAD_START: // Start or continue stream
applyLoopingMode();
_movieData->setMovieRate(1.0);
playing = true;
break;
case THREAD_STOP:
_movieData->setMovieRate(0);
OSG_INFO << "QT-ImageStream: stop at "<< std::endl;
playing = false;
break;
case THREAD_REWIND:
SetMovieRate(_movieData->getMovie(),0.0);
GoToBeginningOfMovie(_movieData->getMovie());
break;
case THREAD_FORWARD:
SetMovieRate(_movieData->getMovie(),0.0);
GoToEndOfMovie(_movieData->getMovie());
break;
case THREAD_SEEK:
_movieData->setMovieTime(_currentRate);
playing = true;
break;
case THREAD_SETRATE:
_movieData->setMovieRate(_currentRate);
playing = (_currentRate != 0.0);
break;
case THREAD_CLOSE:
_movieData->setMovieRate(0.0);
break;
case THREAD_QUIT: // TODO
_movieData->setMovieRate(0.0);
OSG_INFO << "QT-ImageStream: quit" << std::endl;
//playing = false;
done = true;
break;
default:
OSG_WARN << "QT-ImageStream: Unknown command " << cmd << std::endl;
break;
}
}
MoviesTask(_movieData->getMovie(),0);
_current = _movieData->getMovieTime();
}
if (_lastUpdate!= _current)
{
// force the texture to update the image
dirty();
// update internal time and take care of looping
_lastUpdate = _current;
}
if (playing)
{
OpenThreads::Thread::microSleep(16000);
}
else if (!done)
{
OpenThreads::Thread::microSleep(IDLE_TIMEOUT);
}
}
}
bool wxSound::DoPlay(unsigned flags) const
{
Stop();
Movie movie;
switch(m_type)
{
case wxSound_MEMORY:
{
if (!wxInitQT())
return false;
Handle myHandle, dataRef = nil;
MovieImportComponent miComponent;
Track targetTrack = nil;
TimeValue addedDuration = 0;
long outFlags = 0;
OSErr err;
ComponentResult result;
myHandle = NewHandleClear((Size)m_waveLength);
BlockMove(m_hSnd, *myHandle, m_waveLength);
err = PtrToHand(&myHandle, &dataRef, sizeof(Handle));
if (memcmp(&m_hSnd[8], "WAVE", 4) == 0)
miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeWave);
else if (memcmp(&m_hSnd[8], "AIFF", 4) == 0)
miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeAIFF);
else if (memcmp(&m_hSnd[8], "AIFC", 4) == 0)
miComponent = OpenDefaultComponent(MovieImportType, kQTFileTypeAIFC);
else
{
wxLogSysError(wxT("wxSound - Location in memory does not contain valid data"));
return false;
}
movie = NewMovie(0);
result = MovieImportDataRef(miComponent, dataRef,
HandleDataHandlerSubType, movie,
nil, &targetTrack,
nil, &addedDuration,
movieImportCreateTrack, &outFlags);
if (result != noErr)
{
wxLogSysError(wxString::Format(wxT("Couldn't import movie data\nError:%i"), (int)result));
}
SetMovieVolume(movie, kFullVolume);
GoToBeginningOfMovie(movie);
DisposeHandle(myHandle);
}
break;
case wxSound_RESOURCE:
{
SoundComponentData data;
unsigned long numframes, offset;
ParseSndHeader((SndListHandle)m_hSnd, &data, &numframes, &offset);
//m_waveLength = numFrames * data.numChannels;
SndChannelPtr pSndChannel;
SndNewChannel(&pSndChannel, sampledSynth,
initNoInterp
+ (data.numChannels == 1 ? initMono : initStereo), NULL);
if(SndPlay(pSndChannel, (SndListHandle) m_hSnd, flags & wxSOUND_ASYNC ? 1 : 0) != noErr)
return false;
if (flags & wxSOUND_ASYNC)
{
lastSoundTimer = ((wxSMTimer*&)m_pTimer)
= new wxSMTimer(pSndChannel, m_hSnd, flags & wxSOUND_LOOP ? 1 : 0,
&lastSoundIsPlaying);
lastSoundIsPlaying = true;
((wxTimer*)m_pTimer)->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
}
else
SndDisposeChannel(pSndChannel, TRUE);
return true;
}
break;
case wxSound_FILE:
{
if (!wxInitQT())
return false;
OSErr err = noErr ;
Handle dataRef = NULL;
OSType dataRefType;
err = QTNewDataReferenceFromFullPathCFString(wxMacCFStringHolder(m_sndname,wxLocale::GetSystemEncoding()),
(UInt32)kQTNativeDefaultPathStyle, 0, &dataRef, &dataRefType);
wxASSERT(err == noErr);
if (NULL != dataRef || err != noErr)
{
err = NewMovieFromDataRef( &movie, newMovieDontAskUnresolvedDataRefs , NULL, dataRef, dataRefType );
wxASSERT(err == noErr);
DisposeHandle(dataRef);
}
if (err != noErr)
{
wxLogSysError(
wxString::Format(wxT("wxSound - Could not open file: %s\nError:%i"), m_sndname.c_str(), err )
);
return false;
}
}
break;
default:
return false;
}//end switch(m_type)
//Start the movie!
StartMovie(movie);
if (flags & wxSOUND_ASYNC)
{
//Start timer and play movie asyncronously
lastSoundTimer = ((wxQTTimer*&)m_pTimer) =
new wxQTTimer(movie, flags & wxSOUND_LOOP ? 1 : 0,
&lastSoundIsPlaying);
lastSoundIsPlaying = true;
((wxQTTimer*)m_pTimer)->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
}
else
{
wxASSERT_MSG(!(flags & wxSOUND_LOOP), wxT("Can't loop and play syncronously at the same time"));
//Play movie until it ends, then exit
//Note that due to quicktime caching this may not always
//work 100% correctly
while (!IsMovieDone(movie))
MoviesTask(movie, 1);
DisposeMovie(movie);
}
return true;
}
//---------------------------------------------------------------------------
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
//--------------------------------------
}
static DWORD WINAPI QTSplitter_thread(LPVOID data)
{
QTSplitter *This = (QTSplitter *)data;
HRESULT hr = S_OK;
TimeValue next_time;
CVPixelBufferRef pixelBuffer = NULL;
OSStatus err;
TimeRecord tr;
WaitForSingleObject(This->runEvent, -1);
EnterCriticalSection(&This->csReceive);
if (!This->pQTMovie)
{
LeaveCriticalSection(&This->csReceive);
return 0;
}
This->state = State_Running;
/* Prime the pump: Needed for MPEG streams */
GetMovieNextInterestingTime(This->pQTMovie, nextTimeEdgeOK | nextTimeStep, 0, NULL, This->movie_time, 1, &next_time, NULL);
GetMovieTime(This->pQTMovie, &tr);
if (This->pAudio_Pin)
QT_Create_Extract_Session(This);
LeaveCriticalSection(&This->csReceive);
do
{
LONGLONG tStart=0, tStop=0;
LONGLONG mStart=0, mStop=0;
float time;
EnterCriticalSection(&This->csReceive);
if (!This->pQTMovie)
{
LeaveCriticalSection(&This->csReceive);
return 0;
}
GetMovieNextInterestingTime(This->pQTMovie, nextTimeStep, 0, NULL, This->movie_time, 1, &next_time, NULL);
if (next_time == -1)
{
TRACE("No next time\n");
LeaveCriticalSection(&This->csReceive);
break;
}
tr.value = SInt64ToWide(next_time);
SetMovieTime(This->pQTMovie, &tr);
MoviesTask(This->pQTMovie,0);
QTVisualContextTask(This->vContext);
TRACE("In loop at time %ld\n",This->movie_time);
TRACE("In Next time %ld\n",next_time);
mStart = This->movie_time;
mStop = next_time;
time = (float)(This->movie_time - This->movie_start) / This->movie_scale;
tStart = time * 10000000;
time = (float)(next_time - This->movie_start) / This->movie_scale;
tStop = time * 10000000;
/* Deliver Audio */
if (This->pAudio_Pin && This->pAudio_Pin->pin.pin.pConnectedTo && This->aSession)
{
int data_size=0;
BYTE* ptr;
IMediaSample *sample = NULL;
AudioBufferList aData;
UInt32 flags;
UInt32 frames;
WAVEFORMATEX* pvi;
float duration;
pvi = (WAVEFORMATEX*)This->pAudio_Pin->pmt->pbFormat;
hr = BaseOutputPinImpl_GetDeliveryBuffer(&This->pAudio_Pin->pin, &sample, NULL, NULL, 0);
if (FAILED(hr))
{
ERR("Audio: Unable to get delivery buffer (%x)\n", hr);
goto audio_error;
}
hr = IMediaSample_GetPointer(sample, &ptr);
if (FAILED(hr))
{
ERR("Audio: Unable to get pointer to buffer (%x)\n", hr);
goto audio_error;
}
duration = (float)next_time / This->movie_scale;
time = (float)This->movie_time / This->movie_scale;
duration -= time;
frames = pvi->nSamplesPerSec * duration;
TRACE("Need audio for %f seconds (%li frames)\n",duration,frames);
data_size = IMediaSample_GetSize(sample);
if (data_size < frames * pvi->nBlockAlign)
FIXME("Audio buffer is too small\n");
aData.mNumberBuffers = 1;
aData.mBuffers[0].mNumberChannels = pvi->nChannels;
aData.mBuffers[0].mDataByteSize = data_size;
aData.mBuffers[0].mData = ptr;
err = MovieAudioExtractionFillBuffer(This->aSession, &frames, &aData, &flags);
if (frames == 0)
{
TimeRecord etr;
/* Ran out of frames, Restart the extraction session */
TRACE("Restarting extraction session\n");
MovieAudioExtractionEnd(This->aSession);
This->aSession = NULL;
QT_Create_Extract_Session(This);
etr = tr;
etr.value = SInt64ToWide(This->movie_time);
MovieAudioExtractionSetProperty(This->aSession,
kQTPropertyClass_MovieAudioExtraction_Movie,
kQTMovieAudioExtractionMoviePropertyID_CurrentTime,
sizeof(TimeRecord), &etr );
frames = pvi->nSamplesPerSec * duration;
aData.mNumberBuffers = 1;
aData.mBuffers[0].mNumberChannels = pvi->nChannels;
aData.mBuffers[0].mDataByteSize = data_size;
aData.mBuffers[0].mData = ptr;
MovieAudioExtractionFillBuffer(This->aSession, &frames, &aData, &flags);
}
TRACE("Got %i frames\n",(int)frames);
IMediaSample_SetActualDataLength(sample, frames * pvi->nBlockAlign);
IMediaSample_SetMediaTime(sample, &mStart, &mStop);
IMediaSample_SetTime(sample, &tStart, &tStop);
hr = OutputQueue_Receive(This->pAudio_Pin->queue, sample);
TRACE("Audio Delivered (%x)\n",hr);
audio_error:
if (sample)
IMediaSample_Release(sample);
}
else
TRACE("Audio Pin not connected or no Audio\n");
/* Deliver Video */
if (This->pVideo_Pin && QTVisualContextIsNewImageAvailable(This->vContext,0))
{
err = QTVisualContextCopyImageForTime(This->vContext, NULL, NULL, &pixelBuffer);
if (err == noErr)
{
int data_size=0;
BYTE* ptr;
IMediaSample *sample = NULL;
hr = BaseOutputPinImpl_GetDeliveryBuffer(&This->pVideo_Pin->pin, &sample, NULL, NULL, 0);
if (FAILED(hr))
{
ERR("Video: Unable to get delivery buffer (%x)\n", hr);
goto video_error;
}
data_size = IMediaSample_GetSize(sample);
if (data_size < This->outputSize)
{
ERR("Sample size is too small %d < %d\n", data_size, This->outputSize)
;
hr = E_FAIL;
goto video_error;
}
hr = IMediaSample_GetPointer(sample, &ptr);
if (FAILED(hr))
{
ERR("Video: Unable to get pointer to buffer (%x)\n", hr);
goto video_error;
}
hr = AccessPixelBufferPixels( pixelBuffer, ptr);
if (FAILED(hr))
{
ERR("Failed to access Pixels\n");
goto video_error;
}
IMediaSample_SetActualDataLength(sample, This->outputSize);
IMediaSample_SetMediaTime(sample, &mStart, &mStop);
IMediaSample_SetTime(sample, &tStart, &tStop);
hr = OutputQueue_Receive(This->pVideo_Pin->queue, sample);
TRACE("Video Delivered (%x)\n",hr);
video_error:
if (sample)
IMediaSample_Release(sample);
if (pixelBuffer)
CVPixelBufferRelease(pixelBuffer);
}
}
else
TRACE("No video to deliver\n");
This->movie_time = next_time;
LeaveCriticalSection(&This->csReceive);
} while (hr == S_OK);
This->state = State_Stopped;
if (This->pAudio_Pin)
OutputQueue_EOS(This->pAudio_Pin->queue);
if (This->pVideo_Pin)
OutputQueue_EOS(This->pVideo_Pin->queue);
return hr;
}
