static int v4m_close(V4lState *s)
{
if(s->seqgrab)
CloseComponent(s->seqgrab);
s->seqgrab=NULL;
if (s->decomseq)
CDSequenceEnd(s->decomseq);
s->decomseq=NULL;
if (s->pgworld!=NULL)
DisposeGWorld(s->pgworld);
s->pgworld=NULL;
return 0;
}
// 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();
}
// ######################################################################
QuickTimeGrabber::Impl::~Impl()
{
const std::string summary = this->getSummary();
if (summary.size() > 0)
LINFO("%s", summary.c_str());
if (itsSeqGrab.it != 0)
SGStop(itsSeqGrab.it);
// clean up the bits
if (itsDrawSeq)
CDSequenceEnd(itsDrawSeq);
DisposeGWorld(itsGWorld);
}
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();
}
OSErr SpriteUtils_AssignImageGroupIDsToKeyFrame (QTAtomContainer theKeySample)
{
QTAtom myDefaultsAtom, myImagesContainerAtom;
ImageDescriptionHandle myFirstImageDesc = NULL;
ImageDescriptionHandle mySecondImageDesc = NULL;
short myFirstIndex, mySecondIndex, myNumImages;
CodecType myFirstImageType, mySecondImageType;
long myGroupID = 0, myTestID;
OSErr myErr = noErr;
myDefaultsAtom = QTFindChildByIndex(theKeySample, 0, kSpriteSharedDataAtomType, 1, NULL);
if (myDefaultsAtom == 0)
goto bail;
myImagesContainerAtom = QTFindChildByIndex(theKeySample, myDefaultsAtom, kSpriteImagesContainerAtomType, 1, NULL);
if (myImagesContainerAtom == 0)
goto bail;
myFirstImageDesc = (ImageDescriptionHandle)NewHandle(0);
if (myFirstImageDesc == NULL) {
myErr = memFullErr;
goto bail;
}
mySecondImageDesc = (ImageDescriptionHandle)NewHandle(0);
if (mySecondImageDesc == NULL) {
myErr = memFullErr;
goto bail;
}
myNumImages = QTCountChildrenOfType(theKeySample, myImagesContainerAtom, kSpriteImageAtomType);
for (myFirstIndex = 1; myFirstIndex <= myNumImages; myFirstIndex++) {
myErr = SpriteUtils_SetImageGroupID(theKeySample, myImagesContainerAtom, myFirstIndex, 0);
if (myErr != noErr)
goto bail;
}
for (myFirstIndex = 1; myFirstIndex <= (myNumImages - 1); myFirstIndex++) {
myErr = SpriteUtils_GetImageGroupID(theKeySample, myImagesContainerAtom, myFirstIndex, &myTestID);
if (myErr != noErr)
goto bail;
if (myTestID == 0) {
myGroupID++;
myErr = SpriteUtils_SetImageGroupID(theKeySample, myImagesContainerAtom, myFirstIndex, myGroupID);
if (myErr != noErr)
goto bail;
myErr = SpriteUtils_GetImageDescription(theKeySample, myImagesContainerAtom, myFirstIndex, myFirstImageDesc);
myFirstImageType = (**myFirstImageDesc).cType;
if (myErr != noErr)
goto bail;
for (mySecondIndex = (myFirstIndex + 1); mySecondIndex <= myNumImages; mySecondIndex++) {
myErr = SpriteUtils_GetImageGroupID(theKeySample, myImagesContainerAtom, mySecondIndex, &myTestID);
if (myErr != noErr)
goto bail;
if (myTestID == 0) {
myErr = SpriteUtils_GetImageDescription(theKeySample, myImagesContainerAtom, mySecondIndex, mySecondImageDesc);
if (myErr != noErr)
goto bail;
mySecondImageType = (**mySecondImageDesc).cType;
if (myFirstImageType == mySecondImageType) {
ImageSequence mySeqID;
Boolean isEquivalent;
myErr = DecompressSequenceBegin(&mySeqID, myFirstImageDesc, NULL, NULL, NULL, NULL, ditherCopy, (RgnHandle)NULL, 0, codecNormalQuality, anyCodec);
if (myErr != noErr)
goto bail;
CDSequenceEquivalentImageDescription(mySeqID, mySecondImageDesc, &isEquivalent);
CDSequenceEnd(mySeqID);
if (isEquivalent) {
myErr = SpriteUtils_SetImageGroupID(theKeySample, myImagesContainerAtom, mySecondIndex, myGroupID);
if (myErr != noErr)
goto bail;
}
}
}
}
}
}
// assign an ID to the last image
myErr = SpriteUtils_GetImageGroupID(theKeySample, myImagesContainerAtom, myNumImages, &myTestID);
if (myErr != noErr)
goto bail;
if (myTestID == 0) {
myGroupID++;
myErr = SpriteUtils_SetImageGroupID(theKeySample, myImagesContainerAtom, myNumImages, myGroupID);
}
bail:
if (myFirstImageDesc != NULL)
DisposeHandle((Handle)myFirstImageDesc);
if (mySecondImageDesc != NULL)
DisposeHandle((Handle)mySecondImageDesc);
return(myErr);
}
static GstStateChangeReturn
gst_osx_video_src_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn result;
GstOSXVideoSrc *self;
ComponentResult err;
result = GST_STATE_CHANGE_SUCCESS;
self = GST_OSX_VIDEO_SRC (element);
// ###: prepare_capture in READY->PAUSED?
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
{
ImageDescriptionHandle imageDesc;
Rect sourceRect;
MatrixRecord scaleMatrix;
if (!prepare_capture (self))
return GST_STATE_CHANGE_FAILURE;
// ###: should we start recording /after/ making the decompressionsequence?
// CocoaSequenceGrabber does it beforehand, so we do too, but it feels
// wrong.
err = SGStartRecord (self->seq_grab);
if (err != noErr) {
/* since we prepare here, we should also unprepare */
SGRelease (self->seq_grab);
GST_ERROR_OBJECT (self, "SGStartRecord returned %d", (int) err);
return GST_STATE_CHANGE_FAILURE;
}
imageDesc = (ImageDescriptionHandle) NewHandle (0);
err = SGGetChannelSampleDescription (self->video_chan,
(Handle) imageDesc);
if (err != noErr) {
SGStop (self->seq_grab);
SGRelease (self->seq_grab);
DisposeHandle ((Handle) imageDesc);
GST_ERROR_OBJECT (self, "SGGetChannelSampleDescription returned %d",
(int) err);
return GST_STATE_CHANGE_FAILURE;
}
GST_DEBUG_OBJECT (self, "actual capture resolution is %dx%d",
(int) (**imageDesc).width, (int) (**imageDesc).height);
SetRect (&sourceRect, 0, 0, (**imageDesc).width, (**imageDesc).height);
RectMatrix (&scaleMatrix, &sourceRect, &self->rect);
err = DecompressSequenceBegin (&self->dec_seq, imageDesc, self->world,
NULL, NULL, &scaleMatrix, srcCopy, NULL, 0, codecNormalQuality,
bestSpeedCodec);
if (err != noErr) {
SGStop (self->seq_grab);
SGRelease (self->seq_grab);
DisposeHandle ((Handle) imageDesc);
GST_ERROR_OBJECT (self, "DecompressSequenceBegin returned %d",
(int) err);
return GST_STATE_CHANGE_FAILURE;
}
DisposeHandle ((Handle) imageDesc);
break;
}
default:
break;
}
result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (result == GST_STATE_CHANGE_FAILURE)
return result;
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
SGStop (self->seq_grab);
err = CDSequenceEnd (self->dec_seq);
if (err != noErr)
GST_WARNING_OBJECT (self, "CDSequenceEnd returned %d", (int) err);
self->dec_seq = 0;
SGRelease (self->seq_grab);
break;
default:
break;
}
return result;
}
