//--------------------------------------------------------
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
//--------------------------------------
}
//--------------------------------------------------------
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
//--------------------------------------
}
boolean playerstopmovie (void) {
/*
7.0b4 PBS: stop playing a movie.
*/
if (currentmovie != nil)
SetMovieActive (currentmovie, false);
return (true);
} /*playerstopmovie*/
//--------------------------------------------------------
void ofVideoPlayer::stop(){
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
StopMovie (moviePtr);
bPlaying = false;
SetMovieActive (moviePtr, false);
//--------------------------------------
#endif
//--------------------------------------
}
QuickTimeFileReader::~QuickTimeFileReader()
{
SVDEBUG << "QuickTimeFileReader::~QuickTimeFileReader" << endl;
if (m_decodeThread) {
m_cancelled = true;
m_decodeThread->wait();
delete m_decodeThread;
}
SetMovieActive(m_d->movie, FALSE);
DisposeMovie(m_d->movie);
delete[] m_d->data;
delete m_d;
}
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;
}
/*------------------------------------ deferred_End ---*/
static Pvoid
deferred_End(QtPtr xx)
{
EnterCallback();
if (xx->fCurrentMovie)
{
GoToEndOfMovie(xx->fCurrentMovie);
SetMovieActive(xx->fCurrentMovie, TRUE);
xx->fStopSignalled = true; /* pretend that we reached the end normally */
qtAdjustController(xx);
}
else
{
LOG_ERROR_1(OUTPUT_PREFIX "no movies loaded")
SignalError(xx);
}
ExitMaxMessageHandler()
} /* deferred_End */
//--------------------------------------------------------
void ofQuickTimePlayer::stop(){
if( !isLoaded() ){
ofLog(OF_LOG_ERROR, "ofQuickTimePlayer: movie not loaded!");
return;
}
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
StopMovie (moviePtr);
SetMovieActive (moviePtr, false);
bStarted = false;
//--------------------------------------
#endif
//--------------------------------------
bPlaying = false;
}
//--------------------------------------------------------
void ofVideoPlayer::stop(){
//--------------------------------------
#ifdef OF_VIDEO_PLAYER_QUICKTIME
//--------------------------------------
StopMovie (moviePtr);
SetMovieActive (moviePtr, false);
bStarted = false;
//--------------------------------------
#else
//--------------------------------------
gstUtils.setPaused(true);
//--------------------------------------
#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*/
static HRESULT QT_Process_Movie(QTSplitter* filter)
{
HRESULT hr = S_OK;
OSErr err;
WineDataRefRecord ptrDataRefRec;
Handle dataRef = NULL;
Track trk;
short id = 0;
DWORD tid;
LONGLONG time;
TRACE("Trying movie connect\n");
ptrDataRefRec.pReader = filter->pInputPin.pReader;
ptrDataRefRec.streamSubtype = filter->pInputPin.subType;
PtrToHand( &ptrDataRefRec, &dataRef, sizeof(WineDataRefRecord));
err = NewMovieFromDataRef(&filter->pQTMovie, newMovieActive|newMovieDontInteractWithUser|newMovieDontAutoUpdateClock|newMovieDontAskUnresolvedDataRefs|newMovieAsyncOK, &id, dataRef, 'WINE');
DisposeHandle(dataRef);
if (err != noErr)
{
FIXME("QuickTime cannot handle media type(%i)\n",err);
return VFW_E_TYPE_NOT_ACCEPTED;
}
PrePrerollMovie(filter->pQTMovie, 0, fixed1, NULL, NULL);
PrerollMovie(filter->pQTMovie, 0, fixed1);
GoToBeginningOfMovie(filter->pQTMovie);
SetMovieActive(filter->pQTMovie,TRUE);
if (GetMovieLoadState(filter->pQTMovie) < kMovieLoadStateLoaded)
MoviesTask(filter->pQTMovie,100);
trk = GetMovieIndTrackType(filter->pQTMovie, 1, VisualMediaCharacteristic, movieTrackCharacteristic | movieTrackEnabledOnly);
TRACE("%p is a video track\n",trk);
if (trk)
hr = QT_Process_Video_Track(filter, trk);
if (FAILED(hr))
return hr;
trk = GetMovieIndTrackType(filter->pQTMovie, 1, AudioMediaCharacteristic, movieTrackCharacteristic | movieTrackEnabledOnly);
TRACE("%p is a audio track\n",trk);
if (trk)
hr = QT_Process_Audio_Track(filter, trk);
time = GetMovieDuration(filter->pQTMovie);
filter->movie_scale = GetMovieTimeScale(filter->pQTMovie);
filter->sourceSeeking.llDuration = ((double)time / filter->movie_scale) * 10000000;
filter->sourceSeeking.llStop = filter->sourceSeeking.llDuration;
TRACE("Movie duration is %s\n",wine_dbgstr_longlong(filter->sourceSeeking.llDuration));
filter->loaderThread = CreateThread(NULL, 0, QTSplitter_loading_thread, filter, 0, &tid);
if (filter->loaderThread)
TRACE("Created loading thread 0x%08x\n", tid);
filter->splitterThread = CreateThread(NULL, 0, QTSplitter_thread, filter, 0, &tid);
if (filter->splitterThread)
TRACE("Created processing thread 0x%08x\n", tid);
else
hr = HRESULT_FROM_WIN32(GetLastError());
return hr;
}
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;
}
QuickTimeFileReader::QuickTimeFileReader(FileSource source,
DecodeMode decodeMode,
CacheMode mode,
size_t targetRate,
ProgressReporter *reporter) :
CodedAudioFileReader(mode, targetRate),
m_source(source),
m_path(source.getLocalFilename()),
m_d(new D),
m_reporter(reporter),
m_cancelled(false),
m_completion(0),
m_decodeThread(0)
{
m_channelCount = 0;
m_fileRate = 0;
Profiler profiler("QuickTimeFileReader::QuickTimeFileReader", true);
SVDEBUG << "QuickTimeFileReader: path is \"" << m_path << "\"" << endl;
long QTversion;
#ifdef WIN32
InitializeQTML(0); // FIXME should check QT version
#else
m_d->err = Gestalt(gestaltQuickTime,&QTversion);
if ((m_d->err != noErr) || (QTversion < 0x07000000)) {
m_error = QString("Failed to find compatible version of QuickTime (version 7 or above required)");
return;
}
#endif
EnterMovies();
Handle dataRef;
OSType dataRefType;
// CFStringRef URLString = CFStringCreateWithCString
// (0, m_path.toLocal8Bit().data(), 0);
QByteArray ba = m_path.toLocal8Bit();
CFURLRef url = CFURLCreateFromFileSystemRepresentation
(kCFAllocatorDefault,
(const UInt8 *)ba.data(),
(CFIndex)ba.length(),
false);
// m_d->err = QTNewDataReferenceFromURLCFString
m_d->err = QTNewDataReferenceFromCFURL
(url, 0, &dataRef, &dataRefType);
if (m_d->err) {
m_error = QString("Error creating data reference for QuickTime decoder: code %1").arg(m_d->err);
return;
}
short fileID = movieInDataForkResID;
short flags = 0;
m_d->err = NewMovieFromDataRef
(&m_d->movie, flags, &fileID, dataRef, dataRefType);
DisposeHandle(dataRef);
if (m_d->err) {
m_error = QString("Error creating new movie for QuickTime decoder: code %1").arg(m_d->err);
return;
}
Boolean isProtected = 0;
Track aTrack = GetMovieIndTrackType
(m_d->movie, 1, SoundMediaType,
movieTrackMediaType | movieTrackEnabledOnly);
if (aTrack) {
Media aMedia = GetTrackMedia(aTrack); // get the track media
if (aMedia) {
MediaHandler mh = GetMediaHandler(aMedia); // get the media handler we can query
if (mh) {
m_d->err = QTGetComponentProperty(mh,
kQTPropertyClass_DRM,
kQTDRMPropertyID_IsProtected,
sizeof(Boolean), &isProtected,nil);
} else {
m_d->err = 1;
}
} else {
m_d->err = 1;
}
} else {
m_d->err = 1;
}
if (m_d->err && m_d->err != kQTPropertyNotSupportedErr) {
m_error = QString("Error checking for DRM in QuickTime decoder: code %1").arg(m_d->err);
return;
} else if (!m_d->err && isProtected) {
m_error = QString("File is protected with DRM");
return;
} else if (m_d->err == kQTPropertyNotSupportedErr && !isProtected) {
std::cerr << "QuickTime: File is not protected with DRM" << std::endl;
}
if (m_d->movie) {
SetMovieActive(m_d->movie, TRUE);
m_d->err = GetMoviesError();
if (m_d->err) {
m_error = QString("Error in QuickTime decoder activation: code %1").arg(m_d->err);
return;
}
} else {
m_error = QString("Error in QuickTime decoder: Movie object not valid");
return;
}
m_d->err = MovieAudioExtractionBegin
(m_d->movie, 0, &m_d->extractionSessionRef);
if (m_d->err) {
m_error = QString("Error in QuickTime decoder extraction init: code %1").arg(m_d->err);
return;
}
m_d->err = MovieAudioExtractionGetProperty
(m_d->extractionSessionRef,
kQTPropertyClass_MovieAudioExtraction_Audio, kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription,
sizeof(m_d->asbd),
&m_d->asbd,
nil);
if (m_d->err) {
m_error = QString("Error in QuickTime decoder property get: code %1").arg(m_d->err);
return;
}
m_channelCount = m_d->asbd.mChannelsPerFrame;
m_fileRate = m_d->asbd.mSampleRate;
std::cerr << "QuickTime: " << m_channelCount << " channels, " << m_fileRate << " kHz" << std::endl;
m_d->asbd.mFormatFlags =
kAudioFormatFlagIsFloat |
kAudioFormatFlagIsPacked |
kAudioFormatFlagsNativeEndian;
m_d->asbd.mBitsPerChannel = sizeof(float) * 8;
m_d->asbd.mBytesPerFrame = sizeof(float) * m_d->asbd.mChannelsPerFrame;
m_d->asbd.mBytesPerPacket = m_d->asbd.mBytesPerFrame;
m_d->err = MovieAudioExtractionSetProperty
(m_d->extractionSessionRef,
kQTPropertyClass_MovieAudioExtraction_Audio,
kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription,
sizeof(m_d->asbd),
&m_d->asbd);
if (m_d->err) {
m_error = QString("Error in QuickTime decoder property set: code %1").arg(m_d->err);
m_channelCount = 0;
return;
}
m_d->buffer.mNumberBuffers = 1;
m_d->buffer.mBuffers[0].mNumberChannels = m_channelCount;
m_d->buffer.mBuffers[0].mDataByteSize =
sizeof(float) * m_channelCount * m_d->blockSize;
m_d->data = new float[m_channelCount * m_d->blockSize];
m_d->buffer.mBuffers[0].mData = m_d->data;
initialiseDecodeCache();
if (decodeMode == DecodeAtOnce) {
if (m_reporter) {
connect(m_reporter, SIGNAL(cancelled()), this, SLOT(cancelled()));
m_reporter->setMessage
(tr("Decoding %1...").arg(QFileInfo(m_path).fileName()));
}
while (1) {
UInt32 framesRead = m_d->blockSize;
UInt32 extractionFlags = 0;
m_d->err = MovieAudioExtractionFillBuffer
(m_d->extractionSessionRef, &framesRead, &m_d->buffer,
&extractionFlags);
if (m_d->err) {
m_error = QString("Error in QuickTime decoding: code %1")
.arg(m_d->err);
break;
}
//!!! progress?
// std::cerr << "Read " << framesRead << " frames (block size " << m_d->blockSize << ")" << std::endl;
// QuickTime buffers are interleaved unless specified otherwise
addSamplesToDecodeCache(m_d->data, framesRead);
if (framesRead < m_d->blockSize) break;
}
finishDecodeCache();
endSerialised();
m_d->err = MovieAudioExtractionEnd(m_d->extractionSessionRef);
if (m_d->err) {
m_error = QString("Error ending QuickTime extraction session: code %1").arg(m_d->err);
}
m_completion = 100;
} else {
if (m_reporter) m_reporter->setProgress(100);
if (m_channelCount > 0) {
m_decodeThread = new DecodeThread(this);
m_decodeThread->start();
}
}
std::cerr << "QuickTimeFileReader::QuickTimeFileReader: frame count is now " << getFrameCount() << ", error is \"\"" << m_error << "\"" << std::endl;
}
