void DisplayJPEGAndDisposeHandle( Handle imageData )
{
OSErr err;
Rect naturalBounds;
MatrixRecord matrix;
SInt32 gapH, gapV;
Fixed scaleH, scaleV;
Rect boundsRect;
GraphicsImportComponent grip;
Rect windowPortRect;
static char gifSentinel[] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
static char jpegSentinel[] = {0xFF,0xD9,0xFF,0xD9,0xFF,0xD9,0xFF,0xD9,0xFF,0xD9,0xFF,0xD9,0xFF,0xD9,0xFF,0xD9};
Ptr sentinel;
Size sentinelSize;
if( !imageData )
{
ofLogNotice() << "NO IMAGE DATA" << endl;
} else {
ofImage image;
//ofPixels pixels();
//pixels = imageData;
//image.setFromPixels((const unsigned char *)imageData);
//string image
//image.saveImage(ofToDataPath(ofGetTimestampString()+".jpg", OF_IMAGE_QUALITY_BEST));
ofLogError() << "WE HAVE DATA!" << endl;
}
return;
again:
ofLogError() << "Again called";
if( 'G' == **imageData ) {
grip = gripG;
// for GIF:
// FF FF FF FF will ensure that the bit parser aborts, since you can't
// have two consecutive all-ones symbols in the LZW codestream --
// you can sometimes have one (say, a 9-bit code), but after consuming
// it the code width increases (so we're now using 10-bit codes)
// and the all-ones code won't be valid for a while yet.
sentinel = gifSentinel;
sentinelSize = sizeof(gifSentinel);
}
else {
grip = gripJ;
// for JPEG:
// FF D9 FF D9 will ensure (a) that the bit-parser aborts, since FF D9
// is an "unstuffed" FF and hence illegal in the entropy-coded datastream,
// and (b) be long enough to stop overreads.
sentinel = jpegSentinel;
sentinelSize = sizeof(jpegSentinel);
}
//•• add sentinel pattern to the end of the handle.
err = PtrAndHand( sentinel, imageData, sentinelSize );
err = GraphicsImportSetDataHandle( grip, imageData );
if( err )
{
ofLogNotice() << "GraphicsImportSetDataHandle Error" << endl;
goto bail;
}
err = GraphicsImportGetNaturalBounds( grip, &naturalBounds );
if( err )
{
ofLogNotice() << "GraphicsImportGetNaturalBounds Error" << endl;
goto bail;
}
//GetPortBounds( GetWindowPort( window ), &windowPortRect );
gapH = windowPortRect.right - naturalBounds.right;
gapV = windowPortRect.bottom - naturalBounds.bottom;
if( gapH >= 0 ) {
gapH = ((UInt16)Random()) % gapH;
scaleH = fixed1;
}
else {
gapH = 0;
scaleH = FixDiv( windowPortRect.right, naturalBounds.right );
}
if( gapV >= 0 ) {
gapV = ((UInt16)Random()) % gapV;
scaleV = fixed1;
}
else {
gapV = 0;
scaleV = FixDiv( windowPortRect.bottom, naturalBounds.bottom );
}
// need to use smaller scale of the two, and then recalc the other gap.
if( scaleH > scaleV ) {
scaleH = scaleV;
gapH = windowPortRect.right - FixMul(scaleH, naturalBounds.right);
gapH = ((UInt16)Random()) % gapH;
} else if( scaleH < scaleV ) {
scaleV = scaleH;
gapV = windowPortRect.bottom - FixMul(scaleV, naturalBounds.bottom);
gapV = ((UInt16)Random()) % gapV;
}
SetIdentityMatrix( &matrix );
ScaleMatrix( &matrix, scaleH, scaleV, 0, 0 );
TranslateMatrix( &matrix, gapH<<16, gapV<<16 );
err = GraphicsImportSetMatrix( grip, &matrix );
if( err ) goto bail;
err = GraphicsImportDraw( grip );
if( err ) goto bail;
err = GraphicsImportGetBoundsRect( grip, &boundsRect );
if( err ) goto bail;
InsetRect( &boundsRect, -1, -1 );
//SetPortWindowPort( window );
FrameRect( &boundsRect );
if( scanForAnotherImageMarker(imageData))
{
ofLogError() << "again: scanForAnotherImageMarker" << endl;
goto again;
}
bail:
DisposeHandle( imageData );
//gDrewJPEG = true;
}
bool wxBitmapDataObject::SetData( const wxDataFormat& format, size_t nSize, const void *pBuf )
{
Clear();
if ((pBuf == NULL) || (nSize == 0))
return false;
#if wxMAC_USE_CORE_GRAPHICS
Handle picHandle = NULL ;
m_pictHandle = NewHandle( nSize );
memcpy( *(Handle) m_pictHandle, pBuf, nSize );
if ( format == s_pict )
{
// pict for IO expects a 512 byte header
picHandle = NewHandle( nSize + 512 );
memset( *picHandle , 0 , 512 );
memcpy( *picHandle+512, pBuf, nSize );
}
else
{
picHandle = (Handle) m_pictHandle;
}
CGImageRef cgImageRef = 0;
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
if ( UMAGetSystemVersion() >= 0x1040 )
{
CFDataRef data = NULL;
HLock( picHandle );
data = CFDataCreateWithBytesNoCopy( kCFAllocatorDefault, (const UInt8*) *picHandle, GetHandleSize(picHandle), kCFAllocatorNull);
CGImageSourceRef source = CGImageSourceCreateWithData( data, NULL );
if ( source )
{
cgImageRef = CGImageSourceCreateImageAtIndex(source, 0, NULL);
}
CFRelease( source );
CFRelease( data );
HUnlock( picHandle );
}
else
#endif
#ifndef __LP64__
{
// import from TIFF
GraphicsImportComponent importer = 0;
OSStatus err = OpenADefaultComponent(GraphicsImporterComponentType, s_pict == format ? kQTFileTypePicture : kQTFileTypeTIFF, &importer);
if (noErr == err)
{
if ( picHandle )
{
ComponentResult result = GraphicsImportSetDataHandle(importer, picHandle);
if ( result == noErr )
{
Rect frame;
GraphicsImportGetNaturalBounds( importer, &frame );
GraphicsImportCreateCGImage( importer, &cgImageRef, kGraphicsImportCreateCGImageUsingCurrentSettings );
}
}
CloseComponent( importer );
}
}
#endif
if ( format == s_pict )
{
DisposeHandle( picHandle );
}
if ( cgImageRef )
{
m_bitmap.Create( CGImageGetWidth(cgImageRef) , CGImageGetHeight(cgImageRef) );
CGRect r = CGRectMake( 0 , 0 , CGImageGetWidth(cgImageRef) , CGImageGetHeight(cgImageRef) );
// since our context is upside down we dont use CGContextDrawImage
HIViewDrawCGImage( (CGContextRef) m_bitmap.GetHBITMAP() , &r, cgImageRef ) ;
CGImageRelease(cgImageRef);
cgImageRef = NULL;
}
#else
PicHandle picHandle = (PicHandle)NewHandle( nSize );
memcpy( *picHandle, pBuf, nSize );
m_pictHandle = picHandle;
// ownership is transferred to the bitmap
m_pictCreated = false;
#ifndef __LP64__
Rect frame;
wxMacGetPictureBounds( picHandle, &frame );
#if wxUSE_METAFILE
wxMetafile mf;
mf.SetHMETAFILE( (WXHMETAFILE)m_pictHandle );
#endif
wxMemoryDC mdc;
m_bitmap.Create( frame.right - frame.left, frame.bottom - frame.top );
mdc.SelectObject( m_bitmap );
#if wxUSE_METAFILE
mf.Play( &mdc );
#endif
mdc.SelectObject( wxNullBitmap );
#endif
#endif
return m_bitmap.Ok();
}
static void QTDR_DrawFrame (short theTrackWidth, short theTrackHeight, long theNumSample, GWorldPtr theGWorld)
{
Handle myHandle = NULL;
char myData[kPICTFileHeaderSize];
static PicHandle myPicture = NULL;
static GWorldPtr myGWorld = NULL;
static GraphicsImportComponent myImporter = NULL;
Rect myRect;
RGBColor myColor;
ComponentResult myErr = noErr;
MacSetRect(&myRect, 0, 0, theTrackWidth, theTrackHeight);
if (myPicture == NULL) {
myErr = NewGWorld(&myGWorld, kPixelDepth, &myRect, NULL, NULL, (GWorldFlags)0);
if (myErr != noErr)
goto bail;
// read a picture from our resource file
myPicture = GetPicture(kPictureID);
if (myPicture == NULL)
goto bail;
// use Munger to prepend a 512-byte header onto the picture data; this converts the PICT
// resource data into in-memory PICT file data (see Ice Floe 14 for an explanation of this)
myHandle = (Handle)myPicture;
Munger(myHandle, 0, NULL, 0, myData, kPICTFileHeaderSize);
// get a graphics importer for the picture
myErr = OpenADefaultComponent(GraphicsImporterComponentType, kQTFileTypePicture, &myImporter);
if (myErr != noErr)
goto bail;
// configure the graphics importer
myErr = GraphicsImportSetGWorld(myImporter, myGWorld, NULL);
if (myErr != noErr)
goto bail;
myErr = GraphicsImportSetDataHandle(myImporter, myHandle);
if (myErr != noErr)
goto bail;
myErr = GraphicsImportSetBoundsRect(myImporter, &myRect);
if (myErr != noErr)
goto bail;
// draw the picture into the source GWorld
myErr = GraphicsImportDraw(myImporter);
if (myErr != noErr)
goto bail;
}
// set the blend amount (0 = fully transparent; 0xffff = fully opaque)
myColor.red = (theNumSample - 1) * (0xffff / kNumVideoFrames - 1);
myColor.green = (theNumSample - 1) * (0xffff / kNumVideoFrames - 1);
myColor.blue = (theNumSample - 1) * (0xffff / kNumVideoFrames - 1);
OpColor(&myColor);
// blend the picture (in the source GWorld) into the empty rectangle (in the destination GWorld)
CopyBits((BitMapPtr)*GetGWorldPixMap(myGWorld),
(BitMapPtr)*GetGWorldPixMap(theGWorld),
&myRect,
&myRect,
blend,
NULL);
if (theNumSample == kNumVideoFrames)
goto bail;
return;
bail:
if (myHandle != NULL)
DisposeHandle(myHandle);
if (myPicture != NULL)
ReleaseResource((Handle)myPicture);
if (myImporter != NULL)
CloseComponent(myImporter);
}
