void _HYPlatformGraphicPane::_EndDraw (void)
{
UnlockPixels (GetGWorldPixMap(thePane));
SetGWorld (savedPort,savedDevice);
RGBForeColor (&saveFG);
RGBBackColor (&saveBG);
}
wxMemoryDC::~wxMemoryDC()
{
if ( m_selected.Ok() )
{
UnlockPixels( GetGWorldPixMap(MAC_WXHBITMAP(m_selected.GetHBITMAP())) );
}
};
void EraseRectAndAlpha(GWorldPtr gWorld, Rect *pRect)
{
PixMapHandle pixMap = GetGWorldPixMap(gWorld);
long rows;
Ptr rowBaseAddr;
LockPixels(pixMap);
rows = pRect->bottom - pRect->top;
rowBaseAddr = GetPixBaseAddr(pixMap) + (GetPixRowBytes(pixMap) & 0x3fff) * pRect->top + pRect->left * GetPixDepth(pixMap) / 8;
do
{
long cols;
UInt32 *baseAddr;
cols = pRect->right - pRect->left;
baseAddr = (UInt32*)rowBaseAddr;
rowBaseAddr += (**pixMap).rowBytes & 0x3fff;
do
{
*baseAddr++ = 0;
} while (--cols);
} while (--rows);
UnlockPixels(pixMap);
} // EraseRectAndAlpha
static void ROM_UnsetVideoMode(_THIS, SDL_Surface *current)
{
/* Free the current window, if any */
if ( SDL_Window != nil ) {
GWorldPtr memworld;
/* Handle OpenGL support */
Mac_GL_Quit(this);
memworld = (GWorldPtr)GetWRefCon(SDL_Window);
if ( memworld != nil ) {
UnlockPixels(GetGWorldPixMap(memworld));
DisposeGWorld(memworld);
}
if ( (current->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
#if USE_QUICKTIME
EndFullScreen(fullscreen_ctx, nil);
SDL_Window = nil;
#else
ROM_ShowMenuBar(this);
#endif
}
}
current->pixels = NULL;
current->flags &= ~(SDL_HWSURFACE|SDL_FULLSCREEN);
}
void wxMemoryDC::SelectObject( const wxBitmap& bitmap )
{
if ( m_selected.Ok() )
{
UnlockPixels( GetGWorldPixMap(MAC_WXHBITMAP(m_selected.GetHBITMAP())) );
}
m_selected = bitmap;
if (m_selected.Ok())
{
if ( m_selected.GetHBITMAP() )
{
m_macPort = (GrafPtr) m_selected.GetHBITMAP() ;
LockPixels( GetGWorldPixMap( (CGrafPtr) m_macPort ) ) ;
wxMask * mask = bitmap.GetMask() ;
if ( mask )
{
m_macMask = mask->GetMaskBitmap() ;
}
SetRectRgn( (RgnHandle) m_macBoundaryClipRgn , 0 , 0 , m_selected.GetWidth() , m_selected.GetHeight() ) ;
CopyRgn( (RgnHandle) m_macBoundaryClipRgn ,(RgnHandle) m_macCurrentClipRgn ) ;
m_ok = TRUE ;
}
else
{
m_ok = FALSE;
}
}
else
{
m_ok = FALSE;
}
}
// left here for compatability
ImageHandle EncodeTheRect(PixMapHandle thePixMap,Rect *theRect,short clearCol,short shadowCol)
{
EncodeRec theEncode=emptyEncodeRec;
BCRec theRec;
LockPixels(thePixMap);
theEncode.theRec=&theRec;
theRec.world=0L;
theRec.pixMap=thePixMap;
theRec.baseAddr=(unsigned char *)GetPixBaseAddr(thePixMap);
theRec.rowBytes=(**thePixMap).rowBytes&0x3FFF;
theEncode.theImage=0L;
theEncode.theRect=theRect;
theEncode.clearCol=clearCol;
theEncode.shadowCol=shadowCol;
theEncode.shrinkHandle=true;
theEncode.shrinkRect=true;
EckerEncodeTheRect(&theEncode);
UnlockPixels(thePixMap);
return theEncode.theImage;
}
TLevelWriter3gp::~TLevelWriter3gp()
{
#if 0
if (m_pixmap)
UnlockPixels(m_pixmap);
if (m_compressedData)
DisposeHandle(m_compressedData);
if (m_gworld)
DisposeGWorld(m_gworld);
#endif
QDErr err;
if (m_videoMedia)
if ((err = EndMediaEdits(m_videoMedia)) != noErr) {
} // throw TImageException(getFilePath(), "can't end edit media");
if (m_videoTrack)
if ((err = InsertMediaIntoTrack(m_videoTrack, 0, 0,
GetMediaDuration(m_videoMedia), fixed1))) {
} // throw TImageException(getFilePath(), "can't insert media into track");
short resId = movieInDataForkResID;
if (m_movie) {
FSSpec fspec;
long myFlags = 0L;
OSErr myErr = noErr;
//UCHAR myCancelled = FALSE;
const char *pStr = toString(m_path.getWideString()).c_str();
getFSSpecFromPosixPath(pStr, &fspec, true);
myFlags = createMovieFileDeleteCurFile; // |
//movieFileSpecValid | movieToFileOnlyExport;
myErr = ConvertMovieToFile(
m_movie, // the movie to convert
NULL, // all tracks in the movie
&fspec, // the output file
'3gpp', // the output file type
FOUR_CHAR_CODE('TVOD'), // the output file creator
smSystemScript, // the script
&resId, // no resource ID to be returned
myFlags, // export flags
m_myExporter); // no specific exp
}
DisposeHandle(m_hMovieData);
DisposeHandle(m_dataRef);
if (m_hSoundMovieData)
DisposeHandle(m_hSoundMovieData);
if (m_refNum)
CloseMovieFile(m_refNum);
DisposeMovie(m_movie);
}
void UnlockGraphics(void)
{
if (m_locked_context == nil)
return;
MCGContextRelease(m_locked_context);
m_locked_context = nil;
UnlockPixels();
}
void
Tk_FreePixmap(
Display *display, /* Display. */
Pixmap pixmap) /* Pixmap to destroy */
{
MacDrawable *macPix = (MacDrawable *) pixmap;
PixMapHandle pixels;
display->request++;
pixels = GetGWorldPixMap(macPix->portPtr);
UnlockPixels(pixels);
DisposeGWorld(macPix->portPtr);
ckfree((char *) macPix);
}
static void QT_EndAddVideoSamplesToMedia (void)
{
SCCompressSequenceEnd(qtdata->theComponent);
UnlockPixels(qtexport->thePixMap);
if (qtexport->theGWorld)
DisposeGWorld (qtexport->theGWorld);
if (qtexport->ibuf)
IMB_freeImBuf(qtexport->ibuf);
if (qtexport->ibuf2)
IMB_freeImBuf(qtexport->ibuf2);
}
// A handy routine which will return the colour of a pixel in a pixmap
// It's not effiecient enough to be called a lot as it works out some values every time even
// though they don't change.
short GPixelColour(PixMapHandle thePixMap,short x,short y)
{
Ptr pixBase;
short rowBytes,colour;
LockPixels(thePixMap);
pixBase=GetPixBaseAddr(thePixMap);
rowBytes=(**thePixMap).rowBytes & 0x3fff;
colour=(unsigned char)*(pixBase + y * rowBytes + x);
UnlockPixels(thePixMap);
return colour;
}
void mac_setfont(GWorldPtr world, Str255 fontname)
{
GDHandle oldGD;
GWorldPtr oldGW;
GetGWorld(&oldGW, &oldGD);
LockPixels(world->portPixMap);
{
short fontID;
SetGWorld( world, 0);
GetFNum(fontname, &fontID);
TextFont(fontID);
TextSize(14);
TextFace(extend/*|bold*/);
}
SetGWorld(oldGW, oldGD);
UnlockPixels(world->portPixMap);
}
PRIVATE GWorldPtr
gworld_from_pict (PicHandle ph)
{
GWorldPtr retval;
retval = NULL;
if (ph)
{
CGrafPtr save_port;
GDHandle save_device;
Rect r;
OSErr err;
GetGWorld (&save_port, &save_device);
save_port = MR (save_port);
save_device = MR (save_device);
r = HxX (ph, picFrame);
err = NewGWorld (&retval, 32, &r, NULL, NULL, keepLocal);
if (retval)
{
PixMapHandle pm;
retval = MR (retval);
SetGWorld (retval, NULL);
pm = GetGWorldPixMap (retval);
LockPixels (pm);
DrawPicture (ph, &r);
#if 0
#warning THIS INTERFERES WITH PICT PASTING
{
char *p;
EraseRect (&r);
p = GetPixBaseAddr (pm);
memset (p, 0x00, 4 * RECT_HEIGHT(&r) * RECT_WIDTH (&r));
memset (p, 0xFF, 4 * RECT_HEIGHT(&r) * RECT_WIDTH (&r) / 2);
}
#endif
UnlockPixels (pm);
}
SetGWorld (save_port, save_device);
}
return retval;
}
void dev_draw_text_gmode(PixMapHandle pixmap, int x, int y, const char* s, int len,
int pmask, int mode, int fgcolor, int bgcolor, int ton_mode)
{ //pixmap must be already locked
GDHandle oldGD;
GWorldPtr oldGW;
int color, trans, width;
Rect rect= {0,0,16,32},
destrect;
GetGWorld(&oldGW, &oldGD);
LockPixels(charbufWorld->portPixMap);
SetGWorld(charbufWorld,0);
trans=0;
if( fgcolor==trans ) trans++;
if( bgcolor==trans ) trans++;
if( fgcolor==trans ) trans++;
color= ( (mode&2)? bgcolor:trans );
dev_box(charbufWorld->portPixMap, rect, color, 0xFF);
color= ( (mode&1)? fgcolor:trans );
charbufWorld->fgColor= color;
TextMode(srcOr);
MoveTo(0,13);
DrawText(s,0,len);
if( ton_mode==2 ){
expand_horizontality(charbufWorld->portPixMap, len*8, 16);
}
width= len*8;
if( ton_mode==2 ) width*=2;
rect.right=width;
destrect.left=x; destrect.top=y;
destrect.right=x+width; destrect.bottom=destrect.top+16;
MyCopyBits(charbufWorld->portPixMap, pixmap,
rect, destrect, 0x11/*trans*/, trans, pmask,
0, 0, NULL);
SetGWorld(oldGW, oldGD);
UnlockPixels(charbufWorld->portPixMap);
}
PRIVATE SDL_Surface *
surface_from_gworld (GWorldPtr gp)
{
SDL_Surface *retval;
if (!gp)
retval = NULL;
else
{
int pixels_per_line;
int n_lines;
PixMapHandle pm;
enum { A = 0x00000000,
R = 0x0000FF00,
G = 0x00FF0000,
B = 0xFF000000 };
mac_pixel32 *ip;
sdl_pixel24 *op;
Rect r;
pm = GetGWorldPixMap (gp);
LockPixels (pm);
r = PIXMAP_BOUNDS (pm);
n_lines = RECT_HEIGHT (&r);
pixels_per_line = RECT_WIDTH (&r);
retval = SDL_AllocSurface (SDL_SWSURFACE, pixels_per_line, n_lines, 32,
R, G, B, A);
SDL_LockSurface (retval);
op = SDL_Surface_pixels (retval);
ip = (typeof (ip)) GetPixBaseAddr (pm);
memcpy (op, ip, n_lines * pixels_per_line * sizeof *ip);
#if 0
#warning THIS IS BROKEN
memset (op, 0x00, 4 * n_lines * pixels_per_line);
memset (op, 0xFF, 4 * n_lines * pixels_per_line / 2);
#endif
SDL_UnlockSurface (retval);
UnlockPixels (pm);
}
return retval;
}
void _HYPlatformGraphicPane::_CopyToClipboard (void)
{
_HYGraphicPane* parent = (_HYGraphicPane*)this;
#ifdef TARGET_API_MAC_CARBON
ClearCurrentScrap();
#else
ZeroScrap();
#endif
Rect bRect;
bRect.left = bRect.top = 0;
bRect.right = parent->w;
bRect.bottom = parent->h;
PicHandle pic = OpenPicture (&bRect);
GrafPtr topPort;
GetPort (&topPort);
LockPixels (GetGWorldPixMap(thePane));
#ifdef OPAQUE_TOOLBOX_STRUCTS
CopyBits (GetPortBitMapForCopyBits(thePane),GetPortBitMapForCopyBits(topPort),
&bRect,&bRect,srcCopy,(RgnHandle)nil);
#else
CopyBits ((BitMap*)*GetGWorldPixMap(thePane),
(BitMap*)&(topPort->portBits),&bRect,&bRect,
srcCopy,(RgnHandle)nil);
#endif
UnlockPixels (GetGWorldPixMap(thePane));
ClosePicture ();
HLock ((Handle)pic);
#ifdef TARGET_API_MAC_CARBON
ScrapRef theScrapRef;
GetCurrentScrap(&theScrapRef);
PutScrapFlavor(theScrapRef, 'PICT', kScrapFlavorMaskNone,GetHandleSize((Handle)pic),*pic);
#else
PutScrap (GetHandleSize((Handle)pic),'PICT',*pic);
#endif
KillPicture (pic);
}
bool LockGraphics(MCRegionRef p_area, MCGContextRef& r_context)
{
MCGRaster t_raster;
if (LockPixels(p_area, t_raster))
{
if (MCGContextCreateWithRaster(t_raster, m_locked_context))
{
// Set origin
MCGContextTranslateCTM(m_locked_context, -m_locked_area.x, -m_locked_area.y);
// Set clipping rect
MCGContextClipToRect(m_locked_context, MCRectangleToMCGRectangle(m_locked_area));
r_context = m_locked_context;
return true;
}
UnlockPixels();
}
return false;
}
short FindGWUnusedCol(GWorldPtr theWorld)
{
Ptr pixBase;
short rowBytes,colour,colCount[255],xCount,yCount;
short width,height;
PixMapHandle thePixMap=GetGWorldPixMap(theWorld);
LockPixels(thePixMap);
pixBase=GetPixBaseAddr(thePixMap);
rowBytes=(**thePixMap).rowBytes & 0x3fff;
width=(theWorld->portRect.right)-(theWorld->portRect.left);
height=(theWorld->portRect.bottom)-(theWorld->portRect.top);
// clear all the counts
for(xCount=0; xCount<=255; xCount++)
colCount[xCount]=0;
for (yCount=0; yCount<height; yCount++)
{
for(xCount=0; xCount<width; xCount++)
{
colour=(unsigned char)*(pixBase + yCount * rowBytes + xCount);
colCount[colour]++;
}
}
UnlockPixels(thePixMap);
// scan through for a 0 use col
for(xCount=0; xCount<=255; xCount++)
{
if (colCount[xCount]==0)
return xCount;
}
return -1; // not found
}
RgnHandle getWindowStructureRegion(WindowRef window, RgnHandle structureRegion)
{
/*------------------------------------------------------
Define the structural region of our window.
--------------------------------------------------------*/
static RgnHandle pictureRgn=NULL;
static Rect pictureRect;
Rect windowRect;
SetEmptyRgn(structureRegion);
if(!pictureRgn){//haven't Cached our region yet
PicHandle myPicture=GetPicture(kMaskPictureID);
GrafPtr origPort;
GDHandle origDev;
GWorldPtr pictMask;
PixMapHandle maskBitMap;
GetGWorld(&origPort,&origDev);
pictureRgn=NewRgn();
pictureRect=(*myPicture)->picFrame;
NewGWorld(&pictMask,1,&pictureRect,NULL,NULL,0);
maskBitMap=GetPortPixMap(pictMask);
LockPixels(maskBitMap);
SetGWorld(pictMask,NULL);
EraseRect(&pictureRect);
DrawPicture(myPicture,&pictureRect);
BitMapToRegion(pictureRgn,(BitMap*)*maskBitMap);//use the mask to create a region
InsetRgn(pictureRgn,1,1);
SetGWorld(origPort,origDev);
UnlockPixels(maskBitMap);
DisposeGWorld(pictMask);
ReleaseResource((Handle)myPicture);
}
getCurrentPortBounds(&windowRect);//how big is the window
CopyRgn(pictureRgn,structureRegion);//make a copy of our cached region
MapRgn(structureRegion,&pictureRect,&windowRect);//scale it to our actual window size
return structureRegion;
}
osg::Image* QuicktimeImportExport::doImport(unsigned char* data, unsigned int sizeData, const std::string& fileTypeHint)
{
GWorldPtr gworld = 0;
OSType pixelFormat;
int rowStride;
GraphicsImportComponent gicomp = 0;
Rect rectImage;
GDHandle origDevice = 0;
CGrafPtr origPort = 0;
ImageDescriptionHandle desc = 0;
int depth = 32;
unsigned int xsize, ysize;
unsigned char* imageData = 0;
// Data Handle for file data ( & load data from file )
Handle dataRef = getPtrDataRef(data, sizeData, fileTypeHint);
try {
OSErr err = noErr;
// GraphicsImporter - Get Importer for our filetype
GetGraphicsImporterForDataRef(dataRef, 'ptr ', &gicomp);
// GWorld - Get Texture Info
err = GraphicsImportGetNaturalBounds(gicomp, &rectImage);
if (err != noErr) {
throw QTImportExportException(err, "GraphicsImportGetNaturalBounds failed");
}
xsize = (unsigned int)(rectImage.right - rectImage.left);
ysize = (unsigned int)(rectImage.bottom - rectImage.top);
// ImageDescription - Get Image Description
err = GraphicsImportGetImageDescription(gicomp, &desc);
if (err != noErr) {
throw QTImportExportException(err, "GraphicsImportGetImageDescription failed");
}
// ImageDescription - Get Bit Depth
HLock(reinterpret_cast<char **>(desc));
// GWorld - Pixel Format stuff
pixelFormat = k32ARGBPixelFormat; // Make sure its forced...NOTE: i'm pretty sure this cannot be RGBA!
// GWorld - Row stride
rowStride = xsize * 4; // (width * depth_bpp / 8)
// GWorld - Allocate output buffer
imageData = new unsigned char[rowStride * ysize];
// GWorld - Actually Create IT!
QTNewGWorldFromPtr(&gworld, pixelFormat, &rectImage, 0, 0, 0, imageData, rowStride);
if (!gworld) {
throw QTImportExportException(-1, "QTNewGWorldFromPtr failed");
}
// Save old Graphics Device and Graphics Port to reset to later
GetGWorld (&origPort, &origDevice);
// GraphicsImporter - Set Destination GWorld (our buffer)
err = GraphicsImportSetGWorld(gicomp, gworld, 0);
if (err != noErr) {
throw QTImportExportException(err, "GraphicsImportSetGWorld failed");
}
// GraphicsImporter - Set Quality Level
err = GraphicsImportSetQuality(gicomp, codecLosslessQuality);
if (err != noErr) {
throw QTImportExportException(err, "GraphicsImportSetQuality failed");
}
// Lock pixels so that we can draw to our memory texture
if (!GetGWorldPixMap(gworld) || !LockPixels(GetGWorldPixMap(gworld))) {
throw QTImportExportException(0, "GetGWorldPixMap failed");
}
//*** Draw GWorld into our Memory Texture!
GraphicsImportDraw(gicomp);
// Clean up
UnlockPixels(GetGWorldPixMap(gworld));
SetGWorld(origPort, origDevice); // set graphics port to offscreen (we don't need it now)
DisposeGWorld(gworld);
CloseComponent(gicomp);
DisposeHandle(reinterpret_cast<char **>(desc));
DisposeHandle(dataRef);
}
catch (QTImportExportException& e)
{
setError(e.what());
if (gworld) {
UnlockPixels(GetGWorldPixMap(gworld));
SetGWorld(origPort, origDevice); // set graphics port to offscreen (we don't need it now)
DisposeGWorld(gworld);
}
if (gicomp)
CloseComponent(gicomp);
if (desc)
DisposeHandle(reinterpret_cast<char **>(desc));
if (imageData)
delete[] imageData;
if (dataRef)
DisposeHandle(dataRef);
return NULL;
}
unsigned int bytesPerPixel = depth / 8;
unsigned int glpixelFormat;
switch(bytesPerPixel) {
case 3 :
glpixelFormat = GL_RGB;
break;
case 4 :
glpixelFormat = GL_RGBA;
break;
default :
delete[] imageData;
setError("unknown pixelformat");
return NULL;
break;
}
unsigned char* swizzled = pepareBufferForOSG(imageData, bytesPerPixel, xsize, ysize);
delete[] imageData;
osg::Image* image = new osg::Image();
image->setFileName(fileTypeHint.c_str());
image->setImage(xsize,ysize,1,
bytesPerPixel,
glpixelFormat,
GL_UNSIGNED_BYTE,
swizzled,
osg::Image::USE_NEW_DELETE );
return image;
}
int main2()
{
mpeg3_t *file;
int i, result = 0;
unsigned char *output, **output_rows;
float *audio_output_f;
short *audio_output_i;
long total_samples = 0;
Rect sourceRect;
OSErr error;
PixMapHandle hPixmap;
Ptr gBaseLocation;
long targetRowBytes;
file = mpeg3_open("randomAlien.mpg");
if(file)
{
mpeg3_set_cpus(file, 1);
//audio_output_f = (float *) memoryAllocate(1,BUFSIZE * sizeof(float));
//audio_output_i = (short *) memoryAllocate(1,BUFSIZE * sizeof(short));
//mpeg3_set_sample(file, 11229518, 0);
//result = mpeg3_read_audio(file, audio_output_f, 0, 0, BUFSIZE, 0);
// result = mpeg3_read_audio(file, 0, audio_output_i, 1, BUFSIZE, 0);
// fwrite(audio_output_i, BUFSIZE, 1, stdout);
//mpeg3_set_frame(file, 1000, 0);
sourceRect.top = 0;
sourceRect.left = 0;
sourceRect.bottom = mpeg3_video_height(file, 0);
sourceRect.right = mpeg3_video_width(file, 0);
error = NewGWorld (&gpGWOffScreen, 32, &sourceRect, NULL, NULL, keepLocal);
if (error != noErr)
{
DebugStr ("\pUnable to allocate off screen image");
}
hPixmap = GetGWorldPixMap (gpGWOffScreen);
error = LockPixels (hPixmap);
gBaseLocation = GetPixBaseAddr(hPixmap);
targetRowBytes = ((**hPixmap).rowBytes & 0x3FFF)/4;
output_rows = (unsigned char **) memoryAllocate(1,sizeof(unsigned char*) * mpeg3_video_height(file, 0));
for(i = 0; i < mpeg3_video_height(file, 0); i++)
output_rows[i] = (unsigned char*) gBaseLocation + i * targetRowBytes*4;
for (i=0;i < mpeg3_video_frames(file, 0);i++) {
result = mpeg3_read_frame(file,
output_rows,
0,
0,
mpeg3_video_width(file, 0),
mpeg3_video_height(file, 0),
mpeg3_video_width(file, 0),
mpeg3_video_height(file, 0),
MPEG3_RGBAF8888,
0);
CopyBits (GetPortBitMapForCopyBits(gpGWOffScreen), GetPortBitMapForCopyBits(GetWindowPort(pWindow)), &sourceRect, &sourceRect, srcCopy, NULL);
}
UnlockPixels (hPixmap);
DisposeGWorld(gpGWOffScreen);
memoryFree(output_rows);
fprintf(stderr, "Audio streams: %d\n", mpeg3_total_astreams(file));
for(i = 0; i < mpeg3_total_astreams(file); i++)
{
fprintf(stderr, " Stream %d: channels %d sample rate %d total samples %ld\n",
i,
mpeg3_audio_channels(file, i),
mpeg3_sample_rate(file, i),
mpeg3_audio_samples(file, i));
}
fprintf(stderr, "Video streams: %d\n", mpeg3_total_vstreams(file));
for(i = 0; i < mpeg3_total_vstreams(file); i++)
{
fprintf(stderr, " Stream %d: width %d height %d frame rate %0.3f total frames %ld\n",
i,
mpeg3_video_width(file, i),
mpeg3_video_height(file, i),
mpeg3_frame_rate(file, i),
mpeg3_video_frames(file, i));
}
mpeg3_close(file);
}
/*
* PsychQTGetTextureFromMovie() -- Create an OpenGL texture map from a specific videoframe from given movie object.
*
* win = Window pointer of onscreen window for which a OpenGL texture should be created.
* moviehandle = Handle to the movie object.
* checkForImage = true == Just check if new image available, false == really retrieve the image, blocking if necessary.
* timeindex = When not in playback mode, this allows specification of a requested frame by presentation time.
* If set to -1, or if in realtime playback mode, this parameter is ignored and the next video frame is returned.
* out_texture = Pointer to the Psychtoolbox texture-record where the new texture should be stored.
* presentation_timestamp = A ptr to a double variable, where the presentation timestamp of the returned frame should be stored.
*
* Returns true (1) on success, false (0) if no new image available, -1 if no new image available and there won't be any in future.
*/
int PsychQTGetTextureFromMovie(PsychWindowRecordType *win, int moviehandle, int checkForImage, double timeindex, PsychWindowRecordType *out_texture, double *presentation_timestamp)
{
static TimeValue myNextTimeCached = -2;
static TimeValue nextFramesTimeCached = -2;
TimeValue myCurrTime;
TimeValue myNextTime;
TimeValue nextFramesTime=0;
short myFlags;
OSType myTypes[1];
OSErr error = noErr;
Movie theMovie;
CVOpenGLTextureRef newImage = NULL;
QTVisualContextRef theMoviecontext;
unsigned int failcount=0;
float lowerLeft[2];
float lowerRight[2];
float upperRight[2];
float upperLeft[2];
GLuint texid;
Rect rect;
float rate;
double targetdelta, realdelta, frames;
PsychRectType outRect;
if (!PsychIsOnscreenWindow(win)) {
PsychErrorExitMsg(PsychError_user, "Need onscreen window ptr!!!");
}
// Activate OpenGL context of target window:
PsychSetGLContext(win);
// Explicitely disable Apple's Client storage extensions. For now they are not really useful to us.
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
if (moviehandle < 0 || moviehandle >= PSYCH_MAX_MOVIES) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided.");
}
if ((timeindex!=-1) && (timeindex < 0 || timeindex >= 10000.0)) {
PsychErrorExitMsg(PsychError_user, "Invalid timeindex provided.");
}
if (NULL == out_texture && !checkForImage) {
PsychErrorExitMsg(PsychError_internal, "NULL-Ptr instead of out_texture ptr passed!!!");
}
// Fetch references to objects we need:
theMovie = movieRecordBANK[moviehandle].theMovie;
theMoviecontext = movieRecordBANK[moviehandle].QTMovieContext;
if (theMovie == NULL) {
PsychErrorExitMsg(PsychError_user, "Invalid moviehandle provided. No movie associated with this handle.");
}
// 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);
}
}
// Is movie actively playing (automatic async playback, possibly with synced sound)?
// If so, then we ignore the 'timeindex' parameter, because the automatic playback
// process determines which frames should be delivered to PTB when. This function will
// simply wait or poll for arrival/presence of a new frame that hasn't been fetched
// in previous calls.
if (0 == GetMovieRate(theMovie)) {
// Movie playback inactive. We are in "manual" mode: No automatic async playback,
// no synced audio output. The user just wants to manually fetch movie frames into
// textures for manual playback in a standard Matlab-loop.
// First pass - checking for new image?
if (checkForImage) {
// Image for specific point in time requested?
if (timeindex >= 0) {
// Yes. We try to retrieve the next possible image for requested timeindex.
myCurrTime = (TimeValue) ((timeindex * (double) GetMovieTimeScale(theMovie)) + 0.5f);
}
else {
// No. We just retrieve the next frame, given the current movie time.
myCurrTime = GetMovieTime(theMovie, NULL);
}
// Retrieve timeindex of the closest image sample after myCurrTime:
myFlags = nextTimeStep + nextTimeEdgeOK; // We want the next frame in the movie's media.
myTypes[0] = VisualMediaCharacteristic; // We want video samples.
GetMovieNextInterestingTime(theMovie, myFlags, 1, myTypes, myCurrTime, FloatToFixed(1), &myNextTime, &nextFramesTime);
error = GetMoviesError();
if (error != noErr) {
PsychErrorExitMsg(PsychError_internal, "Failed to fetch texture from movie for given timeindex!");
}
// Found useful event?
if (myNextTime == -1) {
if (PsychPrefStateGet_Verbosity() > 3) printf("PTB-WARNING: Bogus timevalue in movie track for movie %i. Trying to keep going.\n", moviehandle);
// No. Just push timestamp to current time plus a little bit in the hope
// this will get us unstuck:
myNextTime = myCurrTime + (TimeValue) 1;
nextFramesTime = (TimeValue) 0;
}
if (myNextTime != myNextTimeCached) {
// Set movies current time to myNextTime, so the next frame will be fetched from there:
SetMovieTimeValue(theMovie, myNextTime);
// nextFramesTime is the timeindex to which we need to advance for retrieval of next frame: (see code below)
nextFramesTime=myNextTime + nextFramesTime;
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: Current timevalue in movie track for movie %i is %lf secs.\n", moviehandle, (double) myNextTime / (double) GetMovieTimeScale(theMovie));
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: Next timevalue in movie track for movie %i is %lf secs.\n", moviehandle, (double) nextFramesTime / (double) GetMovieTimeScale(theMovie));
// Cache values for 2nd pass:
myNextTimeCached = myNextTime;
nextFramesTimeCached = nextFramesTime;
}
else {
// Somehow got stuck? Do nothing...
if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: Seem to be a bit stuck at timevalue [for movie %i] of %lf secs. Nudging a bit forward...\n", moviehandle, (double) myNextTime / (double) GetMovieTimeScale(theMovie));
// Nudge the timeindex a bit forware in the hope that this helps:
SetMovieTimeValue(theMovie, GetMovieTime(theMovie, NULL) + 1);
}
}
else {
// This is the 2nd pass: Image fetching. Use cached values from first pass:
// Caching in a static works because we're always called immediately for 2nd
// pass after successfull return from 1st pass, and we're not multi-threaded,
// i.e., don't need to be reentrant or thread-safe here:
myNextTime = myNextTimeCached;
nextFramesTime = nextFramesTimeCached;
myNextTimeCached = -2;
}
}
else {
// myNextTime unavailable if in autoplayback-mode:
myNextTime=-1;
}
// Presentation timestamp requested?
if (presentation_timestamp) {
// Already available?
if (myNextTime==-1) {
// Retrieve the exact presentation timestamp of the retrieved frame (in movietime):
myFlags = nextTimeStep + nextTimeEdgeOK; // We want the next frame in the movie's media.
myTypes[0] = VisualMediaCharacteristic; // We want video samples.
// We search backward for the closest available image for the current time. Either we get the current time
// if we happen to fetch a frame exactly when it becomes ready, or we get a bit earlier timestamp, which is
// the optimal presentation timestamp for this frame:
GetMovieNextInterestingTime(theMovie, myFlags, 1, myTypes, GetMovieTime(theMovie, NULL), FloatToFixed(-1), &myNextTime, NULL);
}
// Convert pts (in Quicktime ticks) to pts in seconds since start of movie and return it:
*presentation_timestamp = (double) myNextTime / (double) GetMovieTimeScale(theMovie);
}
// Allow quicktime visual context task to do its internal bookkeeping and cleanup work:
if (theMoviecontext) QTVisualContextTask(theMoviecontext);
// Perform decompress-operation:
if (checkForImage) MoviesTask(theMovie, 0);
// Should we just check for new image? If so, just return availability status:
if (checkForImage) {
if (PSYCH_USE_QT_GWORLDS) {
// We use GWorlds. In this case we either suceed immediately due to the
// synchronous nature of GWorld rendering, or we fail completely at end
// of non-looping movie:
if (IsMovieDone(theMovie) && movieRecordBANK[moviehandle].loopflag == 0) {
// No new frame available and there won't be any in the future, because this is a non-looping
// movie that has reached its end.
return(-1);
}
// Is this the special case of a movie without video, but only sound? In that case,
// we always return a 'false' because there ain't no image to return.
if (movieRecordBANK[moviehandle].QTMovieGWorld == NULL) return(false);
// Success!
return(true);
}
// Code which uses QTVisualContextTasks...
if (QTVisualContextIsNewImageAvailable(theMoviecontext, NULL)) {
// New frame ready!
return(true);
}
else if (IsMovieDone(theMovie) && movieRecordBANK[moviehandle].loopflag == 0) {
// No new frame available and there won't be any in the future, because this is a non-looping
// movie that has reached its end.
return(-1);
}
else {
// No new frame available yet:
return(false);
}
}
if (!PSYCH_USE_QT_GWORLDS) {
// Blocking wait-code for non-GWorld mode:
// Try up to 1000 iterations for arrival of requested image data in wait-mode:
failcount=0;
while ((failcount < 1000) && !QTVisualContextIsNewImageAvailable(theMoviecontext, NULL)) {
PsychWaitIntervalSeconds(0.005);
MoviesTask(theMovie, 0);
failcount++;
}
// No new frame available and there won't be any in the future, because this is a non-looping
// movie that has reached its end.
if ((failcount>=1000) && IsMovieDone(theMovie) && (movieRecordBANK[moviehandle].loopflag == 0)) {
return(-1);
}
// Fetch new OpenGL texture with the new movie image frame:
error = QTVisualContextCopyImageForTime(theMoviecontext, kCFAllocatorDefault, NULL, &newImage);
if ((error!=noErr) || newImage == NULL) {
PsychErrorExitMsg(PsychError_internal, "OpenGL<->Quicktime texture fetch failed!!!");
}
// Disable client storage, if it was enabled:
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
// Build a standard PTB texture record:
CVOpenGLTextureGetCleanTexCoords (newImage, lowerLeft, lowerRight, upperRight, upperLeft);
texid = CVOpenGLTextureGetName(newImage);
// Assign texture rectangle:
PsychMakeRect(outRect, upperLeft[0], upperLeft[1], lowerRight[0], lowerRight[1]);
// Set texture orientation as if it were an inverted Offscreen window: Upside-down.
out_texture->textureOrientation = (CVOpenGLTextureIsFlipped(newImage)) ? 3 : 4;
// Assign OpenGL texture id:
out_texture->textureNumber = texid;
// Store special texture object as part of the PTB texture record:
out_texture->targetSpecific.QuickTimeGLTexture = newImage;
}
else {
// Synchronous texture fetch code for GWorld rendering mode:
// At this point, the GWorld should contain the source image for creating a
// standard OpenGL texture:
// Disable client storage, if it was enabled:
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
// Build a standard PTB texture record:
// Assign texture rectangle:
GetMovieBox(theMovie, &rect);
// Hack: Need to extend rect by 4 pixels, because GWorlds are 4 pixels-aligned via
// image row padding:
rect.right = rect.right + 4;
PsychMakeRect(out_texture->rect, rect.left, rect.top, rect.right, rect.bottom);
// Set NULL - special texture object as part of the PTB texture record:
out_texture->targetSpecific.QuickTimeGLTexture = NULL;
// Set texture orientation as if it were an inverted Offscreen window: Upside-down.
out_texture->textureOrientation = 3;
// Setup a pointer to our GWorld as texture data pointer:
out_texture->textureMemorySizeBytes = 0;
// Quicktime textures are aligned on 4 Byte boundaries:
out_texture->textureByteAligned = 4;
// Lock GWorld:
if(!LockPixels(GetGWorldPixMap(movieRecordBANK[moviehandle].QTMovieGWorld))) {
// Locking surface failed! We abort.
PsychErrorExitMsg(PsychError_internal, "PsychQTGetTextureFromMovie(): Locking GWorld pixmap surface failed!!!");
}
// This will retrieve an OpenGL compatible pointer to the GWorlds pixel data and assign it to our texmemptr:
out_texture->textureMemory = (GLuint*) GetPixBaseAddr(GetGWorldPixMap(movieRecordBANK[moviehandle].QTMovieGWorld));
// Let PsychCreateTexture() do the rest of the job of creating, setting up and
// filling an OpenGL texture with GWorlds content:
PsychCreateTexture(out_texture);
// Undo hack from above after texture creation: Now we need the real width of the
// texture for proper texture coordinate assignments in drawing code et al.
rect.right = rect.right - 4;
PsychMakeRect(outRect, rect.left, rect.top, rect.right, rect.bottom);
// Unlock GWorld surface. We do a glFinish() before, for safety reasons...
//glFinish();
UnlockPixels(GetGWorldPixMap(movieRecordBANK[moviehandle].QTMovieGWorld));
// Ready to use the texture... We're done.
}
// Normalize texture rectangle and assign it:
PsychNormalizeRect(outRect, out_texture->rect);
rate = FixedToFloat(GetMovieRate(theMovie));
// Detection of dropped frames: This is a heuristic. We'll see how well it works out...
if (rate && presentation_timestamp) {
// Try to check for dropped frames in playback mode:
// Expected delta between successive presentation timestamps:
targetdelta = 1.0f / (movieRecordBANK[moviehandle].fps * rate);
// Compute real delta, given rate and playback direction:
if (rate>0) {
realdelta = *presentation_timestamp - movieRecordBANK[moviehandle].last_pts;
if (realdelta<0) realdelta = 0;
}
else {
realdelta = -1.0 * (*presentation_timestamp - movieRecordBANK[moviehandle].last_pts);
if (realdelta<0) realdelta = 0;
}
frames = realdelta / targetdelta;
// Dropped frames?
if (frames > 1 && movieRecordBANK[moviehandle].last_pts>=0) {
movieRecordBANK[moviehandle].nr_droppedframes += (int) (frames - 1 + 0.5);
}
movieRecordBANK[moviehandle].last_pts = *presentation_timestamp;
}
// Manually advance movie time, if in fetch mode:
if (0 == GetMovieRate(theMovie)) {
// We are in manual fetch mode: Need to manually advance movie time to next
// media sample:
if (nextFramesTime == myNextTime) {
// Invalid value? Try to hack something that gets us unstuck:
myNextTime = GetMovieTime(theMovie, NULL);
nextFramesTime = myNextTime + (TimeValue) 1;
}
SetMovieTimeValue(theMovie, nextFramesTime);
}
// 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);
}
}
return(TRUE);
}
static OSErr
data_proc (SGChannel c, Ptr p, long len, long *offset, long chRefCon,
TimeValue time, short writeType, long refCon)
{
GstOSXVideoSrc *self;
gint fps_n, fps_d;
GstClockTime duration, timestamp, latency;
CodecFlags flags;
ComponentResult err;
PixMapHandle hPixMap;
Rect portRect;
int pix_rowBytes;
void *pix_ptr;
int pix_height;
int pix_size;
self = GST_OSX_VIDEO_SRC (refCon);
if (self->buffer != NULL) {
gst_buffer_unref (self->buffer);
self->buffer = NULL;
}
err = DecompressSequenceFrameS (self->dec_seq, p, len, 0, &flags, NULL);
if (err != noErr) {
GST_ERROR_OBJECT (self, "DecompressSequenceFrameS returned %d", (int) err);
return err;
}
hPixMap = GetGWorldPixMap (self->world);
LockPixels (hPixMap);
GetPortBounds (self->world, &portRect);
pix_rowBytes = (int) GetPixRowBytes (hPixMap);
pix_ptr = GetPixBaseAddr (hPixMap);
pix_height = (portRect.bottom - portRect.top);
pix_size = pix_rowBytes * pix_height;
GST_DEBUG_OBJECT (self, "num=%5d, height=%d, rowBytes=%d, size=%d",
self->seq_num, pix_height, pix_rowBytes, pix_size);
fps_n = FRAMERATE;
fps_d = 1;
duration = gst_util_uint64_scale_int (GST_SECOND, fps_d, fps_n);
latency = duration;
timestamp = gst_clock_get_time (GST_ELEMENT_CAST (self)->clock);
timestamp -= gst_element_get_base_time (GST_ELEMENT_CAST (self));
if (timestamp > latency)
timestamp -= latency;
else
timestamp = 0;
self->buffer = gst_buffer_new_and_alloc (pix_size);
GST_BUFFER_OFFSET (self->buffer) = self->seq_num;
GST_BUFFER_TIMESTAMP (self->buffer) = timestamp;
memcpy (GST_BUFFER_DATA (self->buffer), pix_ptr, pix_size);
self->seq_num++;
UnlockPixels (hPixMap);
return noErr;
}
bool MCImageBitmapToPICT(MCImageBitmap *p_bitmap, MCMacSysPictHandle &r_pict)
{
#ifdef LIBGRAPHICS_BROKEN
bool t_success = true;
Pixmap drawdata = nil, drawmask = nil;
MCBitmap *maskimagealpha = nil;
t_success = MCImageSplitPixmaps(p_bitmap, drawdata, drawmask, maskimagealpha);
if (!t_success)
return false;
Rect t_rect;
SetRect(&t_rect, 0, 0, p_bitmap->width, p_bitmap->height);
GWorldPtr t_old_gworld;
GDHandle t_old_gdevice;
GetGWorld(&t_old_gworld, &t_old_gdevice);
PixMapHandle t_draw_pixmap;
t_draw_pixmap = GetGWorldPixMap((CGrafPtr)drawdata -> handle . pixmap);
GWorldPtr t_img_gworld;
t_img_gworld = NULL;
if (t_success)
{
QDErr t_err;
t_err = NewGWorld(&t_img_gworld, 32, &t_rect, NULL, NULL, 0);
if (t_err != noErr)
t_success = false;
}
if (t_success)
{
SetGWorld(t_img_gworld, GetGDevice());
PenMode(srcCopy);
ForeColor(blackColor);
BackColor(whiteColor);
if (maskimagealpha != NULL)
{
GWorldPtr t_alpha_gworld;
if (NewGWorldFromPtr(&t_alpha_gworld, 8, &t_rect, GetCTable(40), NULL, 0, maskimagealpha -> data, maskimagealpha -> bytes_per_line) == noErr)
{
const BitMap *t_dst_bits;
t_dst_bits = GetPortBitMapForCopyBits(t_img_gworld);
const BitMap *t_src_bits;
t_src_bits = GetPortBitMapForCopyBits((CGrafPtr)drawdata -> handle . pixmap);
const BitMap *t_mask_bits;
t_mask_bits = GetPortBitMapForCopyBits(t_alpha_gworld);
EraseRect(&t_rect);
CopyDeepMask(t_src_bits, t_mask_bits, t_dst_bits, &t_rect, &t_rect, &t_rect, srcCopy, NULL);
}
}
else if (drawmask != NULL)
{
PixMapHandle t_mask_pixmap;
t_mask_pixmap = GetGWorldPixMap((CGrafPtr)drawmask -> handle . pixmap);
EraseRect(&t_rect);
const BitMap *t_dst_bits;
t_dst_bits = GetPortBitMapForCopyBits(t_img_gworld);
const BitMap *t_src_bits;
LockPixels(t_draw_pixmap);
t_src_bits = (BitMap *)*t_draw_pixmap;
const BitMap *t_mask_bits;
LockPixels(t_mask_pixmap);
t_mask_bits = (BitMap *)*t_mask_pixmap;
CopyMask(t_src_bits, t_mask_bits, t_dst_bits, &t_rect, &t_rect, &t_rect);
UnlockPixels(t_mask_pixmap);
UnlockPixels(t_draw_pixmap);
}
else
{
const BitMap *t_dst_bits;
t_dst_bits = GetPortBitMapForCopyBits(t_img_gworld);
const BitMap *t_src_bits;
LockPixels(t_draw_pixmap);
t_src_bits = (BitMap *)*t_draw_pixmap;
CopyBits(t_src_bits, t_dst_bits, &t_rect, &t_rect, srcCopy, NULL);
UnlockPixels(t_draw_pixmap);
}
}
PicHandle t_handle;
t_handle = NULL;
if (t_success)
{
OpenCPicParams t_params;
t_params . srcRect = t_rect;
t_params . hRes = 72 << 16;
t_params . vRes = 72 << 16;
t_params . version = -2;
t_params . reserved1 = 0;
t_params . reserved2 = 0;
t_handle = OpenCPicture(&t_params);
if (t_handle == NULL)
t_success = false;
}
if (t_success)
{
GWorldPtr t_pict_gworld;
GDHandle t_pict_gdevice;
GetGWorld(&t_pict_gworld, &t_pict_gdevice);
PenMode(srcCopy);
ForeColor(blackColor);
BackColor(whiteColor);
const BitMap *t_dst_bits;
t_dst_bits = GetPortBitMapForCopyBits(t_pict_gworld);
const BitMap *t_src_bits;
t_src_bits = GetPortBitMapForCopyBits(t_img_gworld);
CopyBits(t_src_bits, t_dst_bits, &t_rect, &t_rect, srcCopy, NULL);
ClosePicture();
}
if (t_img_gworld != NULL)
DisposeGWorld(t_img_gworld);
SetGWorld(t_old_gworld, t_old_gdevice);
MCscreen->freepixmap(drawdata);
MCscreen->freepixmap(drawmask);
if (maskimagealpha != nil)
MCscreen->destroyimage(maskimagealpha);
if (t_success)
r_pict = (MCMacSysPictHandle)t_handle;
return t_success;
#else
return false;
#endif
}
PRIVATE GWorldPtr
gworld_from_surface (SDL_Surface *surfp)
{
GWorldPtr retval;
retval = NULL;
if (surfp)
{
QDErr err;
int surf_depth;
CTabHandle ctab;
ctab = NULL;
surf_depth = SDL_Surface_depth (surfp);
switch (surf_depth)
{
case 8:
ctab = ctab_from_surface (surfp);
break;
case 32:
break;
default:
warning_unexpected ("surf_depth = %d", surf_depth);
surf_depth = 0;
break;
}
if (surf_depth)
{
int n_lines;
int pixels_per_line;
Rect r;
n_lines = SDL_Surface_height (surfp);
pixels_per_line = SDL_Surface_width (surfp);
r.top = CWC (0);
r.left = CWC (0);
r.bottom = CW (n_lines);
r.right = CW (pixels_per_line);
{
CGrafPtr save_port;
GDHandle save_device;
GetGWorld (&save_port, &save_device);
save_port = MR (save_port);
save_device = MR (save_device);
err = NewGWorld (&retval, surf_depth, &r, ctab, NULL, keepLocal);
SetGWorld (save_port, save_device);
}
if (retval)
{
PixMapHandle pm;
retval = MR (retval);
pm = GetGWorldPixMap (retval);
LockPixels (pm);
SDL_LockSurface (surfp);
switch (surf_depth)
{
case 8:
{
uint8 *ip, *eip;
uint8 *op;
int rowbytes;
int pitch;
pitch = SDL_Surface_pitch (surfp);
rowbytes = PIXMAP_ROWBYTES (pm);
ip = SDL_Surface_pixels (surfp);
op = (typeof (op)) GetPixBaseAddr (pm);
eip = ip + n_lines * pitch;
for (; ip != eip; ip += pitch, op += rowbytes)
memcpy (op, ip, rowbytes);
break;
}
case 32:
{
sdl_pixel24 *ip;
mac_pixel32 *op;
op = (typeof (op)) GetPixBaseAddr (pm);
ip = SDL_Surface_pixels (surfp);
memcpy (op, ip, n_lines * pixels_per_line * sizeof *op);
break;
}
default:
warning_unexpected ("surf_depth = %d", surf_depth);
break;
}
SDL_UnlockSurface (surfp);
UnlockPixels (pm);
}
}
}
return retval;
}
GLuint platformLoadTextureFile(string theFilename, bool generateMipmaps, int *width, int *height)
{
#ifdef QuickTimeInstalled
GLuint textureName; // the "name" by which OpenGL knows the texture
unsigned char *pImageBuffer; // the buffer that contains the image data
GWorldPtr pGWorld; // a gworld to load the image into
int imageDepth;
FSSpec fsspecImage; // FSSpec of the image to load
#ifdef __APPLE__
CFURLRef imageURL;
FSRef imagefsRef;
#endif
OSStatus err = noErr; // err return value
long rowStride; // length, in bytes, of a pixel row in the image
GraphicsImportComponent giComp; // component for importing image
MatrixRecord matrix;
Rect rectImage; // rectangle of source image
PixMapHandle hPixMap; // handle to image pix map
ImageDescriptionHandle hImageDesc; // handle to image description used to get image depth
long imageWidth;
long imageHeight;
float imageAspect;
long textureWidth;
long textureHeight;
// get the full path to the texture file
string fileLocation;
fileLocation = pathToResourceDirectory() + theFilename;
#ifdef __APPLE__
// create a URL to the file from the C string
imageURL = CFURLCreateWithBytes (kCFAllocatorDefault, (UInt8 *)fileLocation.c_str(), fileLocation.length(), kCFStringEncodingASCII, NULL);
if (imageURL == NULL)
{
cout << "error getting URL for image file (image file may not exist): " << theFilename << endl;
return 0;
}
// get a FSRef from the URL
if (!CFURLGetFSRef(imageURL, &imagefsRef))
{
cout << "error getting FSRef for image file:: " << theFilename << endl;
CFRelease(imageURL);
return 0;
}
// get the FSSpec from the FSRef
if (FSGetCatalogInfo (&imagefsRef, kFSCatInfoNone, NULL, NULL, &fsspecImage, NULL))
{
cout << "error getting FSSpec for image file: " << theFilename << endl;
CFRelease(imageURL);
return 0;
}
// release the URL (not needed any more)
CFRelease(imageURL);
#endif
#ifdef _WIN32
// get an FSSpec from the pathname
if (NativePathNameToFSSpec ((char *)fileLocation.c_str(), &fsspecImage, kErrorIfFileNotFound))
{
cout << "error getting FSSpec for image file: " << fileLocation << endl;
return 0;
}
#endif
// save the onscreen graphics port
GDHandle origDevice;
CGrafPtr origPort;
GetGWorld (&origPort, &origDevice);
// get an importer for the file
err = GetGraphicsImporterForFileWithFlags (&fsspecImage, &giComp, kDontUseValidateToFindGraphicsImporter);
if (err != noErr) return 0;
// get the image bounds
err = GraphicsImportGetNaturalBounds (giComp, &rectImage);
if (err != noErr) return 0;
// create a handle for the image description and lock it
hImageDesc = (ImageDescriptionHandle) NewHandle (sizeof (ImageDescriptionHandle));
HLock ((Handle) hImageDesc);
// retrieve the image description
err = GraphicsImportGetImageDescription (giComp, &hImageDesc);
if (err != noErr) return 0;
// find width and height
imageWidth = (int) (rectImage.right - rectImage.left);
imageHeight = (int) (rectImage.bottom - rectImage.top);
// now calculate the aspect ratio (width/height), used to restore image correctly
imageAspect = ((float) imageWidth) / ((float) imageHeight);
// get the image's pixel depth
imageDepth = (**hImageDesc).depth;
// find nearest acceptable texture size (width and height) for the image
textureWidth = GetTextureDimFromImageDim (imageWidth);
textureHeight = GetTextureDimFromImageDim (imageHeight);
// pass the optimised (and scaled) size back out to the caller
*width = textureWidth;
*height = textureHeight;
// set texture rectangle for creation of GWorld
#ifdef __APPLE__
SetRect (&rectImage, 0, 0, (int) textureWidth, (int) textureHeight);
#endif
#ifdef _WIN32
MacSetRect (&rectImage, 0, 0, (int) textureWidth, (int) textureHeight);
#endif
// set stride in bytes width of image * 4 bytes per pixel
rowStride = textureWidth * 4;
// build new buffer exact size of image (stride * height)
pImageBuffer = (unsigned char *) NewPtr (rowStride * textureHeight);
// check we got the buffer we wanted
if (pImageBuffer == NULL)
{
// failed - release the component and return an error
CloseComponent(giComp);
return 0;
}
// create a new gworld using our unpadded buffer, setting the pixel type correctly for the expected image depth
#ifdef __BIG_ENDIAN__
QTNewGWorldFromPtr (&(pGWorld), k32ARGBPixelFormat, &rectImage, NULL, NULL, 0, pImageBuffer, rowStride);
#else
QTNewGWorldFromPtr (&(pGWorld), k32RGBAPixelFormat, &rectImage, NULL, NULL, 0, pImageBuffer, rowStride);
#endif
// could we allocate the GWorld?
if (pGWorld == NULL)
{
// failed - release the buffer, component and return an error
DisposePtr ((Ptr) pImageBuffer);
CloseComponent(giComp);
return 0;
}
// build a transformation matrix to scale the image to the texture size
// this also flips the image horizontally, so that texture coordinates map correctly
float horizontalScale = (float) textureWidth / (float) imageWidth;
float verticalScale = (float) textureHeight / (float) imageHeight;
SetIdentityMatrix (&matrix);
ScaleMatrix (&matrix, X2Fix(horizontalScale), X2Fix(-verticalScale), 0, 0);
TranslateMatrix (&matrix, 0, X2Fix((float)textureHeight));
// set the matrix as the importer matrix
err = GraphicsImportSetMatrix(giComp, &matrix);
// set the destination of the importer component
if (err == noErr) err = GraphicsImportSetGWorld (giComp, pGWorld, NULL);
// ensure lossless decompression (if the CODEC supports this)
if (err == noErr) err = GraphicsImportSetQuality(giComp, codecLosslessQuality);
if (err != noErr)
{
// failed - release the GWorld, buffer, component and return an error
DisposeGWorld (pGWorld);
DisposePtr ((Ptr) pImageBuffer);
CloseComponent(giComp);
return 0;
}
// get the address of the GWorld's pixmap
hPixMap = GetGWorldPixMap (pGWorld);
// if everything looks good draw the image to the locked pixmap
if ((hPixMap) && (LockPixels (hPixMap)))
GraphicsImportDraw (giComp);
else
{
// the pixmap doesn't exist, or we couldn't lock it
// release the GWorld, buffer, component and return an error
DisposeGWorld (pGWorld);
DisposePtr ((Ptr) pImageBuffer);
CloseComponent(giComp);
return 0;
}
// for images without an alpha channel, initialise the alpha bytes since QuickTime won't
if (imageDepth < 32)
{
#ifdef __BIG_ENDIAN__
for( unsigned char *p = pImageBuffer; p < pImageBuffer + (rowStride * textureHeight); p+=4)
*p = 0xFF;
#else
for( unsigned char *p = pImageBuffer+3; p < pImageBuffer + (rowStride * textureHeight) +3; p+=4)
*p = 0xFF;
#endif
}
// unlock the pixmap
UnlockPixels (hPixMap);
// dump the component
CloseComponent(giComp);
// set image width in groups (pixels), accounts for border this ensures proper image alignment row to row
glPixelStorei (GL_UNPACK_ROW_LENGTH, textureWidth);
// generate a "name" for the texture
glGenTextures (1, &textureName);
// create the texture in OpenGL
glBindTexture(GL_TEXTURE_2D, textureName);
// tell OpenGL about the texture and have GLU build mipmaps
#ifdef __BIG_ENDIAN__
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, textureWidth, textureHeight, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pImageBuffer);
#else
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, textureWidth, textureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, pImageBuffer);
#endif
if (generateMipmaps)
#ifdef __BIG_ENDIAN__
if (gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, textureWidth, textureHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, pImageBuffer) != 0)
#else
if (gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, textureWidth, textureHeight, GL_RGBA, GL_UNSIGNED_BYTE, pImageBuffer) != 0)
#endif
// good time to check for errors?
openGLCheckError();
// finished with the GWorld but not the image buffer (it's used by OpenGL as the "live" image buffer)
DisposeGWorld (pGWorld);
// restore the current graphics port we saved earlier
SetGWorld(origPort, origDevice);
// all done - return the texture name
return textureName;
#endif // QuickTimeInstalled
}
TQ3TextureObject
QutTexture_CreateTextureObjectFromPixmap(PixMapHandle thePixMap,
TQ3PixelType pixelType,
TQ3Boolean wantMipMaps)
{ TQ3Uns32 x, y, theWidth, theHeight, rowBytes, pixelBytes;
TQ3TextureObject qd3dTextureObject = NULL;
TQ3StorageObject qd3dMemoryStorage;
TQ3StoragePixmap qd3dPixMap;
TQ3Mipmap qd3dMipMap;
UInt16 *pixelPtr;
UInt8 *baseAddr;
OSType pixelFormat;
TQ3Endian byteOrder;
// Get the details we need from the PixMap
NoPurgePixels(thePixMap);
LockPixels(thePixMap);
theWidth = (*thePixMap)->bounds.right - (*thePixMap)->bounds.left;
theHeight = (*thePixMap)->bounds.bottom - (*thePixMap)->bounds.top;
rowBytes = (*thePixMap)->rowBytes & 0x7FFF;
pixelBytes = (*thePixMap)->pixelSize / 8;
baseAddr = (UInt8 *) GetPixBaseAddr(thePixMap);
#if OLDPIXMAPSTRUCT
pixelFormat = 0;
#else
pixelFormat = (*thePixMap)->pixelFormat;
#endif
// If this is a 16 bit alpha channel texture, set the alpha bits.
// We assume that black is transparent.
if (pixelType == kQ3PixelTypeARGB16)
{
for (y = 0; y < theHeight; y++)
{
for (x = 0; x < theWidth; x++)
{
pixelPtr = (UInt16 *) (baseAddr + (y * rowBytes) + (x * 2));
if (*pixelPtr != 0x0000)
*pixelPtr |= (1 << 15);
}
}
}
// Set the byte order
if ( (pixelFormat == k32BGRAPixelFormat) ||
(pixelFormat == k16LE555PixelFormat) )
{
byteOrder = kQ3EndianLittle;
}
else
{
byteOrder = kQ3EndianBig;
}
// Create a storage object based on the GWorld
qd3dMemoryStorage = Q3MemoryStorage_New(baseAddr, theHeight * rowBytes);
if (qd3dMemoryStorage != NULL)
{
// Create the appropriate type of texture. Note that if mip-maps are
// required, we create a QD3D PixMap. This might seem back to front,
// but QD3D automatically creates mip-maps for PixMaps.
//
// If mip-maps are not required, we create a QD3D MipMap by hand and
// signal that we don't want any other mip-maps to be created.
//
// We need to work around a bug in Q3MipmapTexture_New: if the rowByte
// for the pixel exactly matches the size of each row, the texture is
// distorted - we can fix this by using Q3PixmapTexture_New instead.
if (wantMipMaps || (rowBytes == theWidth * pixelBytes))
{
// Create a PixMap from the GWorld data
qd3dPixMap.image = qd3dMemoryStorage;
qd3dPixMap.width = theWidth;
qd3dPixMap.height = theHeight;
qd3dPixMap.rowBytes = rowBytes;
qd3dPixMap.pixelSize = (pixelType == kQ3PixelTypeARGB32 || pixelType == kQ3PixelTypeRGB32) ? 32 : 16;
qd3dPixMap.pixelType = pixelType;
qd3dPixMap.bitOrder = byteOrder;
qd3dPixMap.byteOrder = byteOrder;
qd3dTextureObject = Q3PixmapTexture_New(&qd3dPixMap);
}
else
{
// Create a MipMap from the GWorld data
qd3dMipMap.image = qd3dMemoryStorage;
qd3dMipMap.useMipmapping = kQ3False;
qd3dMipMap.pixelType = pixelType;
qd3dMipMap.bitOrder = byteOrder;
qd3dMipMap.byteOrder = byteOrder;
qd3dMipMap.reserved = 0;
qd3dMipMap.mipmaps[0].width = theWidth;
qd3dMipMap.mipmaps[0].height = theHeight;
qd3dMipMap.mipmaps[0].rowBytes = rowBytes;
qd3dMipMap.mipmaps[0].offset = 0;
qd3dTextureObject = Q3MipmapTexture_New(&qd3dMipMap);
}
Q3Object_Dispose(qd3dMemoryStorage);
}
// Clean up and return
UnlockPixels(thePixMap);
return(qd3dTextureObject);
}
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;
}
//-----------------------------------------------------------------------------
// QutTexture_CreateGWorldFromPICT : Create a GWorld from a PICT.
//-----------------------------------------------------------------------------
GWorldPtr
QutTexture_CreateGWorldFromPICT(PicHandle thePicture, TQ3PixelType pixelType)
{ GWorldPtr deepGWorld, theGWorld;
Boolean shouldDither;
GDHandle saveDevice;
CGrafPtr savePort;
TQ3Uns32 theDepth;
OSErr theErr;
// Work out the depth of GWorld, and if it should be dithered
if (pixelType == kQ3PixelTypeARGB16 || pixelType == kQ3PixelTypeRGB16)
theDepth = 16;
else
theDepth = 32;
shouldDither = (theDepth == 16);
// Create a GWorld to hold the image data
theErr = NewGWorld(&theGWorld, theDepth, &(*thePicture)->picFrame, NULL, NULL,
useTempMem | kQ3NativeEndianPixMap );
if (theErr != noErr || theGWorld == NULL)
return(NULL);
// If we should dither, create a deep GWorld
if (theDepth == 16 && shouldDither)
theErr = NewGWorld(&deepGWorld, 32, &(*thePicture)->picFrame, NULL, NULL,
useTempMem | kQ3NativeEndianPixMap );
else
deepGWorld = NULL;
// If we have a deep GWorld, draw the image into that and then
// copy it into the output GWorld. If we don't have a deep GWorld,
// just draw it directly into the output GWorld.
if (deepGWorld != NULL)
{
// Draw the picture into the deep GWorld
GetGWorld(&savePort, &saveDevice);
SetGWorld(deepGWorld, NULL);
LockPixels(GetGWorldPixMap(deepGWorld));
DrawPicture(thePicture, &(*thePicture)->picFrame);
UnlockPixels(GetGWorldPixMap(deepGWorld));
SetGWorld(savePort, saveDevice);
// Copy this into the output GWorld
GetGWorld(&savePort, &saveDevice);
SetGWorld(theGWorld, NULL);
LockPixels(GetGWorldPixMap(theGWorld));
CopyBits(GetPortBitMapForCopyBits(deepGWorld),
GetPortBitMapForCopyBits(theGWorld),
&(*thePicture)->picFrame,
&(*thePicture)->picFrame,
ditherCopy, NULL);
UnlockPixels(GetGWorldPixMap(theGWorld));
SetGWorld(savePort, saveDevice);
// Clean up
DisposeGWorld(deepGWorld);
deepGWorld = NULL;
}
else
{
// Draw the picture into the output GWorld
GetGWorld(&savePort, &saveDevice);
SetGWorld(theGWorld, NULL);
LockPixels(GetGWorldPixMap(theGWorld));
DrawPicture(thePicture, &(*thePicture)->picFrame);
UnlockPixels(GetGWorldPixMap(theGWorld));
SetGWorld(savePort, saveDevice);
}
return(theGWorld);
}
short LoadMapPICT(
PicHandle pict,
unsigned long mapID,
unsigned long mapSizeX,
unsigned long mapSizeY,
TQ3StoragePixmap *bMap)
{
unsigned long *textureMap;
unsigned long *textureMapAddr;
unsigned long *pictMap;
unsigned long pictMapAddr;
register unsigned long row;
register unsigned long col;
Rect rectGW;
GWorldPtr pGWorld;
PixMapHandle hPixMap;
unsigned long pictRowBytes;
QDErr err;
GDHandle oldGD;
GWorldPtr oldGW;
short success;
mapID; /* unused argument */
/* save current port */
GetGWorld(&oldGW, &oldGD);
/* create the GWorld */
SetRect(&rectGW, 0, 0, (unsigned short)mapSizeX, (unsigned short)mapSizeY);
err = NewGWorld(&pGWorld, 32, &rectGW, 0, 0, useTempMem);
if (err != noErr)
return 0;
success = 1;
hPixMap = GetGWorldPixMap(pGWorld);
pictMapAddr = (unsigned long)GetPixBaseAddr (hPixMap);
pictRowBytes = (unsigned long)(**hPixMap).rowBytes & 0x3fff;
/* put the PICT into the window */
SetGWorld(pGWorld, nil);
LockPixels(hPixMap);
EraseRect(&rectGW);
DrawPicture(pict, &rectGW);
/* allocate an area of memory for the texture */
textureMap = (unsigned long *)malloc(mapSizeX * mapSizeY * sizeof(unsigned long));
if (textureMap == NULL) {
success = 0;
goto bail;
}
/* bMap->image = (char *)textureMap; */
/* copy the PICT into the texture */
textureMapAddr = textureMap;
for (row = 0L; row < mapSizeY; row++) {
pictMap = (unsigned long *)(pictMapAddr + (pictRowBytes * row));
for (col = 0L; col < mapSizeX; col++) {
*textureMap++ = (*pictMap++ | 0xff000000L);
}
}
bMap->image = Q3MemoryStorage_New((const unsigned char *)textureMapAddr,
mapSizeX * mapSizeY * sizeof(unsigned long));
if (bMap->image == NULL) {
/* error */
success = 0;
goto bail;
}
UnlockPixels(hPixMap);
bMap->width = mapSizeX;
bMap->height = mapSizeY;
bMap->rowBytes = bMap->width * 4;
bMap->pixelSize = 32;
bMap->pixelType = kQ3PixelTypeRGB32;
bMap->bitOrder = kQ3EndianBig;
bMap->byteOrder = kQ3EndianBig;
/* Free junk */
bail:
SetGWorld(oldGW, oldGD);
DisposeGWorld(pGWorld);
if (textureMapAddr != NULL)
free(textureMapAddr);
return success;
}
