static int quicktimedrv_save(screenshot_t *screenshot, const char *filename)
{
// align and center video
video_width = screenshot->width;
video_height = screenshot->height;
video_width = (video_width + 15) & ~15;
video_height = (video_height + 15) & ~15;
video_xoff = (video_width - screenshot->width) >> 1;
video_yoff = (video_height - screenshot->height) >> 1;
// create cfstring from filename
CFStringRef path = CFStringCreateWithCString(NULL, filename, kCFStringEncodingUTF8);
if (path == NULL) {
log_debug("quicktime: error creating CFString!");
return -1;
}
// create data reference
Handle dataRef;
OSType dataRefType;
OSErr theError = QTNewDataReferenceFromFullPathCFString(
path, kQTNativeDefaultPathStyle, 0, &dataRef, &dataRefType);
if (theError) {
log_debug("quicktime: error creating data reference for '%s'", filename);
return -1;
}
// Create a movie for this file (data ref)
theError = CreateMovieStorage(
dataRef, dataRefType, 'TVOD', smCurrentScript, createMovieFileDeleteCurFile,
&dataHandler, &movie);
if (theError) {
log_debug("quicktime: error creating movie storage for '%s'", filename);
return -1;
}
// dispose of the data reference handle - we no longer need it
DisposeHandle(dataRef);
// define time scale and host clock divider
divider = (TimeScale)CVGetHostClockFrequency() / timeScale;
// setup video
if (setup_video() != noErr) {
return -1;
}
// setup audio
if (audio_codec != -1) {
soundmovie_start(&quicktime_soundmovie_funcs);
}
// set initial time stamp
timestamp = CVGetCurrentHostTime() / divider;
return 0;
}
bool
qtCanvas::Impl::setupMovie()
{
OSErr err;
Handle dataRefH = nil;
OSType dataRefType = 0;
err = QTNewDataReferenceFromFullPathCFString(
mPath, (UInt32)kQTNativeDefaultPathStyle, 0,
&dataRefH, &dataRefType);
CheckError(err, "QTNewDataReferenceFromFullPathCFString");
CreateMovieStorage(dataRefH, dataRefType,
'TVOD', smSystemScript,
createMovieFileDeleteCurFile |
createMovieFileDontCreateResFile |
newMovieActive,
&mDataHandler, &mMovie);
CheckMoviesError("CreateMovieStorage");
CheckError((OSErr)((nil != mMovie) ? noErr : -1), "CreateMovieStorage movie");
return (err == noErr) && (GetMoviesError() == noErr) && (nil != mMovie);
}
quicktime_recorder* quicktime_recorder::create( const char *path2, int width,
int height, float fps ) {
OSErr err;
OSType dataRefType;
Handle dataRef = NULL;
impl *m = new impl(width, height);
std::string pathStd = path2;
#ifdef WIN32
for (std::string::iterator p = pathStd.begin(); p != pathStd.end(); ++p) if (*p == '/') *p = '\\';
#endif
CFStringRef cfPath = CFStringCreateWithCString(NULL, pathStd.c_str(), kCFStringEncodingISOLatin1);
err = QTNewDataReferenceFromFullPathCFString(cfPath, kQTNativeDefaultPathStyle, 0, &dataRef, &dataRefType);
CFRelease(cfPath);
if (err != noErr) {
delete m;
return NULL;
}
err = CreateMovieStorage(dataRef, dataRefType, FOUR_CHAR_CODE('TVOD'), smSystemScript,
createMovieFileDeleteCurFile | createMovieFileDontCreateResFile, &m->data_handler, &m->movie);
DisposeHandle(dataRef);
if (err != noErr) {
delete m;
return NULL;
}
m->track = NewMovieTrack(m->movie, FixRatio(m->width, 1), FixRatio(m->height, 1), kNoVolume);
err &= GetMoviesError();
TimeScale timeScale = (TimeScale)(fps * 100.0f);
m->media = NewTrackMedia(m->track, VideoMediaType, timeScale, nil, 0 );
err &= GetMoviesError();
if (err != noErr) {
delete m;
return NULL;
}
SetMovieTimeScale(m->movie, timeScale);
m->buffer = new unsigned char[4 * m->width * m->height];
Rect rect;
rect.left = rect.top = 0;
rect.right = m->width;
rect.bottom = m->height;
err = QTNewGWorldFromPtr(&m->gworld, k32BGRAPixelFormat, &rect, NULL, NULL, 0, m->buffer, 4 * m->width);
if (err != noErr) {
delete m;
return NULL;
}
m->pixmap = GetGWorldPixMap(m->gworld);
if (!m->pixmap) {
delete m;
return NULL;
}
LockPixels(m->pixmap);
long maxSize = 0;
err = GetMaxCompressionSize(m->pixmap, &rect, 0, codecNormalQuality, kPNGCodecType, anyCodec, &maxSize);
if (err != noErr) {
delete m;
return NULL;
}
m->handle = NewHandle(maxSize);
if (!m->handle) {
delete m;
return NULL;
}
HLockHi(m->handle);
m->ptr = *m->handle;
m->image_desc = (ImageDescriptionHandle)NewHandle(4);
if (!m->image_desc) {
delete m;
return NULL;
}
err = BeginMediaEdits( m->media );
if (err != noErr) {
delete m;
return NULL;
}
return new quicktime_recorder(m);
}
void MacQTStartRecording(char *path)
{
OSStatus err;
CFStringRef str;
CFURLRef url;
memset(&sqt, 0, sizeof(sqt));
// storage
str = CFStringCreateWithCString(kCFAllocatorDefault, path, MAC_PATH_ENCODING);
url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, str, kCFURLPOSIXPathStyle, false);
err = QTNewDataReferenceFromCFURL(url, 0, &(sqt.dataRef), &(sqt.dataRefType));
CheckError(err, 21);
CFRelease(url);
CFRelease(str);
err = CreateMovieStorage(sqt.dataRef, sqt.dataRefType, 'TVOD', smSystemScript, createMovieFileDeleteCurFile | newMovieActive, &(sqt.dataHandler), &(sqt.movie));
CheckError(err, 22);
// video
MacQTOpenVideoComponent(&(sqt.vci));
SCTemporalSettings ts;
err = SCGetInfo(sqt.vci, scTemporalSettingsType, &ts);
ts.frameRate = FixRatio(Memory.ROMFramesPerSecond, 1);
if (ts.keyFrameRate < 1)
ts.keyFrameRate = Memory.ROMFramesPerSecond;
sqt.keyFrame = sqt.keyFrameCount = ts.keyFrameRate;
sqt.frameSkip = sqt.frameSkipCount = (macQTMovFlag & 0xFF00) >> 8;
err = SCSetInfo(sqt.vci, scTemporalSettingsType, &ts);
sqt.frame.top = 0;
sqt.frame.left = 0;
sqt.frame.right = ((macQTMovFlag & kMovDoubleSize) ? 2 : 1) * SNES_WIDTH;
sqt.frame.bottom = ((macQTMovFlag & kMovDoubleSize) ? 2 : 1) * ((macQTMovFlag & kMovExtendedHeight) ? SNES_HEIGHT_EXTENDED : SNES_HEIGHT);
sqt.pw = sqt.ph = 0;
sqt.firstFrame = true;
Rect rct;
SetRect(&rct, 0, 0, SNES_WIDTH * 2, SNES_HEIGHT_EXTENDED * 2 + 4);
InitGWorld(&(sqt.bw), &rct, 16);
sqt.vTrack = NewMovieTrack(sqt.movie, FixRatio(sqt.frame.right, 1), FixRatio(sqt.frame.bottom, 1), kNoVolume);
CheckError(GetMoviesError(), 23);
sqt.vMedia = NewTrackMedia(sqt.vTrack, VideoMediaType, Memory.ROMFramesPerSecond, nil, 0);
CheckError(GetMoviesError(), 24);
err = BeginMediaEdits(sqt.vMedia);
CheckError(err, 25);
// sound
sqt.soundDesc = (SoundDescriptionHandle) NewHandleClear(sizeof(SoundDescription));
CheckError(MemError(), 26);
(**sqt.soundDesc).descSize = sizeof(SoundDescription);
#ifdef __BIG_ENDIAN__
(**sqt.soundDesc).dataFormat = Settings.SixteenBitSound ? k16BitBigEndianFormat : k8BitOffsetBinaryFormat;
#else
(**sqt.soundDesc).dataFormat = Settings.SixteenBitSound ? k16BitLittleEndianFormat : k8BitOffsetBinaryFormat;
#endif
(**sqt.soundDesc).numChannels = Settings.Stereo ? 2 : 1;
(**sqt.soundDesc).sampleSize = Settings.SixteenBitSound ? 16 : 8;
(**sqt.soundDesc).sampleRate = (UnsignedFixed) FixRatio(Settings.SoundPlaybackRate, 1);
sqt.samplesPerSec = Settings.SoundPlaybackRate / Memory.ROMFramesPerSecond;
sqt.soundBufferSize = sqt.samplesPerSec;
if (Settings.SixteenBitSound)
sqt.soundBufferSize <<= 1;
if (Settings.Stereo)
sqt.soundBufferSize <<= 1;
sqt.soundBuffer = NewHandleClear(sqt.soundBufferSize);
CheckError(MemError(), 27);
HLock(sqt.soundBuffer);
sqt.sTrack = NewMovieTrack(sqt.movie, 0, 0, kFullVolume);
CheckError(GetMoviesError(), 28);
sqt.sMedia = NewTrackMedia(sqt.sTrack, SoundMediaType, Settings.SoundPlaybackRate, nil, 0);
CheckError(GetMoviesError(), 29);
err = BeginMediaEdits(sqt.sMedia);
CheckError(err, 30);
}
