/* write image file */
int BIWriteFile(
const char *fileName,
BIFileType fileType,
const BIImageInfo *imageInfo,
const unsigned char *bitmap)
{
int ourRtn = 0;
CGImageAlphaInfo alpha;
CGBitmapInfo bitmapInfo = 0;
CGContextRef bitmapContextRef = NULL;
CGImageRef imageRef = NULL;
CFURLRef fileURL = NULL;
CGImageDestinationRef imageDestRef = NULL;
CGColorSpaceRef rgbColorSpaceRef = NULL;
CFStringRef uti = NULL;
CFDictionaryRef propDict = NULL;
if(imageInfo->bitsPerPixel == 8) {
/* grayscale image */
rgbColorSpaceRef = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
alpha = kCGImageAlphaNone;
bitmapInfo = 0;
}
else {
/* RGB no alpha */
rgbColorSpaceRef = CGColorSpaceCreateDeviceRGB();
alpha = kCGImageAlphaNoneSkipLast;
bitmapInfo = kCGBitmapByteOrder32Big | alpha;
}
if(rgbColorSpaceRef == NULL) {
fprintf(stderr, "***BIWriteFile: Error on CGColorSpaceCreateWithName\n");
ourRtn = 1;
goto errOut;
}
/* A bitmap-oriented CGContextRef based on bitmap data */
bitmapContextRef = CGBitmapContextCreate((void *)bitmap,
imageInfo->imageWidth, imageInfo->imageHeight,
imageInfo->bitsPerComponent, imageInfo->bytesPerRow,
rgbColorSpaceRef,
bitmapInfo);
if(bitmapContextRef == NULL) {
fprintf(stderr, "***BIWriteFile: Error creating CGBitmapContext\n");
ourRtn = 1;
goto errOut;
}
/* CGContextRef --> CGImageRef */
imageRef = CGBitmapContextCreateImage(bitmapContextRef);
fileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(unsigned char*)fileName, strlen(fileName), FALSE);
if(fileURL == NULL) {
fprintf(stderr, "***BIWriteFile: Error on CFURLCreateFromFileSystemRepresentation\n");
ourRtn = 1;
goto errOut;
}
uti = BIGetUTI(fileURL, fileType);
if(uti == NULL) {
ourRtn = 1;
goto errOut;
}
imageDestRef = CGImageDestinationCreateWithURL(fileURL,
uti,
1, NULL );
if(imageDestRef == NULL) {
fprintf(stderr, "***BIWriteFile: Error on CGImageDestinationCreateWithURL\n");
ourRtn = 1;
goto errOut;
}
/* Some BIFileTypes require the specification of a "Lossless" property */
switch(fileType) {
case BI_FT_JPEG2000_Lossless:
case BI_FT_JPEG_Lossless:
{
CFStringRef key = kCGImageDestinationLossyCompressionQuality;
float valf = 1.0;
CFNumberRef val = CFNumberCreate(NULL, kCFNumberFloatType, &valf);
propDict = CFDictionaryCreate(NULL, (const void **)&key, (const void **)&val, 1,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
/*
* The docs say we should be able to set these properties like this,
* but that has no effect. We need to pass it as the 'properties' argument
* to CGImageDestinationAddImage(), below.
* See <rdar://problem/5670614>
*/
//CGImageDestinationSetProperties(imageDestRef, propDict);
CFRelease(val);
break;
}
default:
break;
}
CGImageDestinationAddImage(imageDestRef, imageRef, propDict);
/* Write the image to disk */
if(!CGImageDestinationFinalize(imageDestRef)) {
fprintf(stderr, "***BIWriteFile: Error on CGImageDestinationFinalize\n");
ourRtn = 1;
}
if(propDict != NULL) {
CFRelease(propDict);
}
errOut:
CFRELEASE(bitmapContextRef);
CFRELEASE(imageRef);
CFRELEASE(fileURL);
CFRELEASE(imageDestRef);
CFRELEASE(rgbColorSpaceRef);
return ourRtn;
}
/***********************************************************************
* create_cgimage_from_icon_bitmaps
*/
CGImageRef create_cgimage_from_icon_bitmaps(HDC hdc, HANDLE icon, HBITMAP hbmColor,
unsigned char *color_bits, int color_size, HBITMAP hbmMask,
unsigned char *mask_bits, int mask_size, int width,
int height, int istep)
{
int i, has_alpha = FALSE;
DWORD *ptr;
CGBitmapInfo alpha_format;
CGColorSpaceRef colorspace;
CFDataRef data;
CGDataProviderRef provider;
CGImageRef cgimage;
/* draw the cursor frame to a temporary buffer then create a CGImage from that */
memset(color_bits, 0x00, color_size);
SelectObject(hdc, hbmColor);
if (!DrawIconEx(hdc, 0, 0, icon, width, height, istep, NULL, DI_NORMAL))
{
WARN("Could not draw frame %d (walk past end of frames).\n", istep);
return NULL;
}
/* check if the cursor frame was drawn with an alpha channel */
for (i = 0, ptr = (DWORD*)color_bits; i < width * height; i++, ptr++)
if ((has_alpha = (*ptr & 0xff000000) != 0)) break;
if (has_alpha)
alpha_format = kCGImageAlphaFirst;
else
alpha_format = kCGImageAlphaNoneSkipFirst;
colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
if (!colorspace)
{
WARN("failed to create colorspace\n");
return NULL;
}
data = CFDataCreate(NULL, (UInt8*)color_bits, color_size);
if (!data)
{
WARN("failed to create data\n");
CGColorSpaceRelease(colorspace);
return NULL;
}
provider = CGDataProviderCreateWithCFData(data);
CFRelease(data);
if (!provider)
{
WARN("failed to create data provider\n");
CGColorSpaceRelease(colorspace);
return NULL;
}
cgimage = CGImageCreate(width, height, 8, 32, width * 4, colorspace,
alpha_format | kCGBitmapByteOrder32Little,
provider, NULL, FALSE, kCGRenderingIntentDefault);
CGDataProviderRelease(provider);
CGColorSpaceRelease(colorspace);
if (!cgimage)
{
WARN("failed to create image\n");
return NULL;
}
/* if no alpha channel was drawn then generate it from the mask */
if (!has_alpha)
{
unsigned int width_bytes = (width + 31) / 32 * 4;
CGImageRef cgmask, temp;
/* draw the cursor mask to a temporary buffer */
memset(mask_bits, 0xFF, mask_size);
SelectObject(hdc, hbmMask);
if (!DrawIconEx(hdc, 0, 0, icon, width, height, istep, NULL, DI_MASK))
{
WARN("Failed to draw frame mask %d.\n", istep);
CGImageRelease(cgimage);
return NULL;
}
data = CFDataCreate(NULL, (UInt8*)mask_bits, mask_size);
if (!data)
{
WARN("failed to create data\n");
CGImageRelease(cgimage);
return NULL;
}
provider = CGDataProviderCreateWithCFData(data);
CFRelease(data);
if (!provider)
{
WARN("failed to create data provider\n");
CGImageRelease(cgimage);
return NULL;
}
cgmask = CGImageMaskCreate(width, height, 1, 1, width_bytes, provider, NULL, FALSE);
CGDataProviderRelease(provider);
if (!cgmask)
{
WARN("failed to create mask\n");
CGImageRelease(cgimage);
return NULL;
}
temp = CGImageCreateWithMask(cgimage, cgmask);
CGImageRelease(cgmask);
CGImageRelease(cgimage);
if (!temp)
{
WARN("failed to create masked image\n");
return NULL;
}
cgimage = temp;
}
return cgimage;
}
static bool osx_prepare_text(const void *p_text, uindex_t p_length, const MCGFont &p_font)
{
OSStatus t_err;
t_err = noErr;
if (t_err == noErr)
if (s_layout == NULL)
t_err = ATSUCreateTextLayout(&s_layout);
if (t_err == noErr)
if (s_style == NULL)
t_err = ATSUCreateStyle(&s_style);
if (t_err == noErr)
if (s_colour_space == NULL)
s_colour_space = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
if (t_err == noErr)
if (s_colour == NULL)
{
// Components are grey and alpha
const float t_colour_components[] = {1.0, 1.0};
s_colour = CGColorCreate(s_colour_space, t_colour_components);
}
ATSUFontID t_font_id;
Fixed t_font_size;
Boolean t_font_is_italic;
ATSUTextMeasurement t_imposed_width;
if (t_err == noErr)
{
t_font_size = p_font . size << 16;
// MM-2013-09-16: [[ Bug 11283 ]] It appears that ATSUI doesn't like italic being passed as a style parameter to ATSUFONDtoFontID.
// Instead, set italic as an attribute tag.
uint8_t t_style;
t_style = p_font . style & ~italic;
t_font_is_italic = p_font . style & italic;
// MW-2013-12-05: [[ Bug 11535 ]] Set the imposed width to the fixed advance width
// if non-zero. Otherwise use the glyph advance.
if (p_font . fixed_advance != 0)
t_imposed_width = p_font . fixed_advance << 16;
else
t_imposed_width = kATSUseGlyphAdvance;
// if the specified font can't be found, just use the default
// MM-2013-09-16: [[ Bug 11283 ]] Do the same for font styles - if the font/style paring cannot be found, try font with no style.
t_err = ATSUFONDtoFontID((short)(intptr_t)p_font . fid, t_style, &t_font_id);
if (t_err != noErr)
t_err = ATSUFONDtoFontID((short)(intptr_t)p_font . fid, 0, &t_font_id);
if (t_err != noErr)
t_err = ATSUFONDtoFontID(0, t_style, &t_font_id);
if (t_err != noErr)
t_err = ATSUFONDtoFontID(0, 0, &t_font_id);
}
ATSUAttributeTag t_tags[] =
{
kATSUFontTag,
kATSUSizeTag,
kATSUQDItalicTag,
kATSUImposeWidthTag,
};
ByteCount t_sizes[] =
{
sizeof(ATSUFontID),
sizeof(Fixed),
sizeof(Boolean),
sizeof(ATSUTextMeasurement),
};
ATSUAttributeValuePtr t_attrs[] =
{
&t_font_id,
&t_font_size,
&t_font_is_italic,
&t_imposed_width,
};
if (t_err == noErr)
t_err = ATSUSetAttributes(s_style, sizeof(t_tags) / sizeof(ATSUAttributeTag), t_tags, t_sizes, t_attrs);
if (t_err == noErr)
t_err = ATSUSetTextPointerLocation(s_layout, (const UniChar *) p_text, 0, p_length / 2, p_length / 2);
if (t_err == noErr)
t_err = ATSUSetRunStyle(s_layout, s_style, 0, p_length / 2);
if (t_err == noErr)
t_err = ATSUSetTransientFontMatching(s_layout, true);
return t_err == noErr;
}
/* read image file */
int BIReadFile(
const char *fileName,
BIFileType fileType,
BIPadMode padMode,
unsigned padSize,
BIImageInfo *imageInfo, /* RETURNED */
unsigned char **bitmap) /* mallocd and RETURNED; caller must free */
{
CFURLRef fileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(unsigned char*)fileName, strlen(fileName), FALSE);
if(fileURL == NULL) {
fprintf(stderr, "***BIReadFile: Error on CFURLCreateFromFileSystemRepresentation\n");
return -1;
}
CFStringRef keys[1] = {kCGImageSourceTypeIdentifierHint};
CFStringRef values[1] = {BIGetUTI(fileURL, fileType)};
if(values[0] == NULL) {
return -1;
}
CFDictionaryRef optionsDict = NULL;
CGImageSourceRef imageSourceRef = NULL;
CGImageRef imageRef = NULL;
CGColorSpaceRef rgbColorSpaceRef = NULL;
CGContextRef bitmapContextRef = NULL;
CGBitmapInfo bitmapInfo = 0;
CGImageAlphaInfo alpha;
unsigned bytesPerPixel = 4;
optionsDict = CFDictionaryCreate( kCFAllocatorDefault,
(const void **)keys, (const void **)values, 1,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks );
/* subsequent errors to errOut: */
int ourRtn = 0;
/* source file --> CGImageRef */
imageSourceRef = CGImageSourceCreateWithURL(fileURL, optionsDict);
if(imageSourceRef == NULL) {
fprintf(stderr, "***BIReadFile: Error on CGImageSourceCreateWithURL\n");
ourRtn = 1;
goto errOut;
}
CFRELEASE(fileURL);
imageRef = CGImageSourceCreateImageAtIndex(imageSourceRef, 0, optionsDict );
if(imageRef == NULL) {
fprintf(stderr, "***BIReadFile: Error on CGImageSourceCreateImageAtIndex\n");
ourRtn = 1;
goto errOut;
}
imageInfo->imageWidth = CGImageGetWidth(imageRef);
imageInfo->imageHeight = CGImageGetHeight(imageRef);
imageInfo->bitsPerComponent = CGImageGetBitsPerComponent(imageRef);
imageInfo->bitsPerPixel = CGImageGetBitsPerPixel(imageRef);
if(imageInfo->bitsPerPixel == 8) {
/* the image is gray */
rgbColorSpaceRef = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
imageInfo->bytesPerRow = imageInfo->imageWidth;
alpha = kCGImageAlphaNone;
bitmapInfo = CGImageGetBitmapInfo(imageRef);
bytesPerPixel = 1;
}
else {
rgbColorSpaceRef = CGColorSpaceCreateDeviceRGB();
imageInfo->bytesPerRow = imageInfo->imageWidth * 4;
alpha = kCGImageAlphaPremultipliedLast;
bitmapInfo = kCGBitmapByteOrder32Big | alpha;
}
if(rgbColorSpaceRef == NULL) {
fprintf(stderr, "***BIReadFile: Error on CGColorSpaceCreateWithName\n");
ourRtn = 1;
goto errOut;
}
/* optionally pad */
imageInfo->effectHeight = imageInfo->imageHeight;
if(padMode != PM_None) {
if(padSize == 0) {
fprintf(stderr, "***Pad size of 0 invalid\n");
ourRtn = 1;
goto errOut;
}
unsigned padSizeBytes = padSize;
if(padMode == PM_Pixels) {
padSizeBytes *= bytesPerPixel;
}
imageInfo->bytesPerRow = ROUND_TO(imageInfo->bytesPerRow, padSizeBytes);
/* also round up row count */
imageInfo->effectHeight = ROUND_TO(imageInfo->imageHeight, padSize);
}
*bitmap = (unsigned char *)malloc(imageInfo->bytesPerRow * imageInfo->effectHeight);
bitmapContextRef = CGBitmapContextCreate(*bitmap,
imageInfo->imageWidth, imageInfo->imageHeight,
imageInfo->bitsPerComponent, imageInfo->bytesPerRow,
rgbColorSpaceRef,
bitmapInfo);
if(bitmapContextRef == NULL) {
fprintf(stderr, "***BIReadFile: Error creating CGBitmapContext\n");
ourRtn = 1;
goto errOut;
}
/* enable high quality interpolation */
CGContextSetInterpolationQuality(bitmapContextRef, kCGInterpolationHigh);
/* Draw into the context */
CGContextDrawImage(bitmapContextRef, CGRectMake(0, 0, imageInfo->imageWidth, imageInfo->imageHeight),
imageRef);
errOut:
CFRELEASE(optionsDict);
CFRELEASE(imageSourceRef);
CFRELEASE(imageRef);
CFRELEASE(rgbColorSpaceRef);
CFRELEASE(bitmapContextRef);
if(ourRtn) {
if(*bitmap) {
free(*bitmap);
*bitmap = NULL;
}
}
return ourRtn;
}
void process_1_image (args cli_flags, char *files) {
char *out_file_name = get_out_filename (files, cli_flags);
if (file_exists (out_file_name)) {
printf ("| Output file %s already exists. skipping... ", out_file_name);
return;
}
// Origional Image Properties struct
img_prop o = (img_prop) malloc (sizeof (image_properties));
// set all the vales in the imapg properties struct to -1
null_ip (o);
// Create a data provider
CGDataProviderRef source_image_provider = CGDataProviderCreateWithFilename (files);
// Check for a null returned value
if (source_image_provider == NULL) {
// something went wrong
printf ("error: Couldn't create CGDataProvider from URL.\n");
exit (0);
}
// get the information from the image exif here
o->image_rot = get_exif_rot (source_image_provider);
// Create the image in memory from the JPEG data
CGImageRef source_image = CGImageCreateWithJPEGDataProvider (source_image_provider, NULL, no, kCGRenderingIntentDefault);
/********************************************/
/* Getting the colour space **/
o->colorSpace = CGImageGetColorSpace(source_image);
/********************************************/
// populate the image info struct
pop_img_props (source_image, o);
// create a data provider from the decoded JPEG data
CGDataProviderRef image_data_provider = CGImageGetDataProvider (source_image);
// Create a pointer to the data section of the image in memory
CFDataRef source_data_ptr = CGDataProviderCopyData (image_data_provider);
// The vImage_Buffers we will use
vImage_Buffer *vImage_source = (vImage_Buffer*) malloc (sizeof (vImage_Buffer));
// Check for NULL
if (NULL == vImage_source) {
printf ("Cannot malloc vImage_source buffer\n");
exit (0);
}
if (o->bits_ppixel == 24) {
// convert from 24bit to 32bit by adding the alpha channel.
source_data_ptr = convert24_32bit (source_data_ptr, o);
}
// Setup the vImage Buffer for the image
setupBuffer (vImage_source, o->image_h, o->image_w, o->bytes_row);
// Assign the data to the vImage Buffer for the source
vImage_source->data = (void *) CFDataGetBytePtr (source_data_ptr);
// Check for NULL
if (vImage_source->data == NULL)
printf ("Unable to get the vimage.data pointer\n");
if (o->image_rot != 1 && o->image_rot != 4 && o->image_rot != 2) // rotate the image
rotate_image (vImage_source, o, NULL);
// flip the image
if (o->image_rot == 2 || o->image_rot == 4 || o->image_rot == 7 || o->image_rot == 5)
flip_image (vImage_source, o, NULL);
// Resize the images
resize_image (vImage_source, o, cli_flags);
// Create a colour space to be compared against
CGColorSpaceRef rgb = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
if (NULL == rgb) {
fprintf(stderr, "Unable to create the reference colourspace.\n");
exit(0);
}
// Convert the colourspace to RGB
if (!CFEqual(rgb, o->colorSpace) && !cli_flags->disableCC) {
vImage_source->data = convert_space(vImage_source->data, o->image_w, o->image_h);
if (NULL == vImage_source->data) exit(0);
}
// release the reference colour space
CGColorSpaceRelease(rgb);
// save the image
save_image (vImage_source, o, cli_flags->quality, out_file_name);
// Release the source provider
CGDataProviderRelease (source_image_provider);
source_image_provider = NULL;
// Release the source image
CGImageRelease (source_image);
source_image = NULL;
free(source_data_ptr);
// Free the filename created by get_out_filename ()
free (out_file_name);
out_file_name = NULL;
// free the image properties
free (o);
o = NULL;
// if there is info in the buffer
if (vImage_source->data != NULL) {
free (vImage_source->data);
vImage_source->data = NULL;
}
// free the buffer
free (vImage_source);
vImage_source = NULL;
} // Process 1 image
/*
* Given a display ID and a rectangle on that display, generate a CGImageRef
* containing the display contents.
*
* srcRect is display-origin relative.
*
* This function uses a full screen OpenGL read-only context.
* By using OpenGL, we can read the screen using a DMA transfer
* when it's in millions of colors mode, and we can correctly read
* a microtiled full screen OpenGL context, such as a game or full
* screen video display.
*
* Returns a CGImageRef. When you are done with the CGImageRef, release it
* using CFRelease().
* Returns NULL on an error.
*/
CGImageRef grabViaOpenGL(CGDirectDisplayID display, CGRect srcRect)
{
CGContextRef bitmap;
CGImageRef image;
void * data;
long bytewidth;
GLint width, height;
long bytes;
CGColorSpaceRef cSpace = CGColorSpaceCreateWithName (kCGColorSpaceGenericRGB);
CGLContextObj glContextObj;
CGLPixelFormatObj pixelFormatObj ;
long numPixelFormats ;
CGLPixelFormatAttribute attribs[] =
{
kCGLPFAFullScreen,
kCGLPFADisplayMask,
0, /* Display mask bit goes here */
0
} ;
if ( display == kCGNullDirectDisplay )
display = CGMainDisplayID();
attribs[2] = CGDisplayIDToOpenGLDisplayMask(display);
/* Build a full-screen GL context */
CGLChoosePixelFormat( attribs, &pixelFormatObj, (GLint *)&numPixelFormats );
if ( pixelFormatObj == NULL ) // No full screen context support
return NULL;
CGLCreateContext( pixelFormatObj, NULL, &glContextObj ) ;
CGLDestroyPixelFormat( pixelFormatObj ) ;
if ( glContextObj == NULL )
return NULL;
CGLSetCurrentContext( glContextObj ) ;
CGLSetFullScreen( glContextObj ) ;
glReadBuffer(GL_FRONT);
width = srcRect.size.width;
height = srcRect.size.height;
bytewidth = width * 4; // Assume 4 bytes/pixel for now
bytewidth = (bytewidth + 3) & ~3; // Align to 4 bytes
bytes = bytewidth * height; // width * height
/* Build bitmap context */
data = malloc(height * bytewidth);
if ( data == NULL )
{
CGLSetCurrentContext( NULL );
CGLClearDrawable( glContextObj ); // disassociate from full screen
CGLDestroyContext( glContextObj ); // and destroy the context
return NULL;
}
bitmap = CGBitmapContextCreate(data, width, height, 8, bytewidth,
cSpace, kCGImageAlphaNoneSkipFirst /* XRGB */);
CFRelease(cSpace);
/* Read framebuffer into our bitmap */
glFinish(); /* Finish all OpenGL commands */
glPixelStorei(GL_PACK_ALIGNMENT, 4); /* Force 4-byte alignment */
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
/*
* Fetch the data in XRGB format, matching the bitmap context.
*/
glReadPixels((GLint)srcRect.origin.x, (GLint)srcRect.origin.y, width, height,
GL_BGRA,
#ifdef __BIG_ENDIAN__
GL_UNSIGNED_INT_8_8_8_8_REV, // for PPC
#else
GL_UNSIGNED_INT_8_8_8_8, // for Intel! http://lists.apple.com/archives/quartz-dev/2006/May/msg00100.html
#endif
data);
/*
* glReadPixels generates a quadrant I raster, with origin in the lower left
* This isn't a problem for signal processing routines such as compressors,
* as they can simply use a negative 'advance' to move between scanlines.
* CGImageRef and CGBitmapContext assume a quadrant III raster, though, so we need to
* invert it. Pixel reformatting can also be done here.
*/
swizzleBitmap(data, bytewidth, height);
/* Make an image out of our bitmap; does a cheap vm_copy of the bitmap */
image = CGBitmapContextCreateImage(bitmap);
/* Get rid of bitmap */
CFRelease(bitmap);
free(data);
/* Get rid of GL context */
CGLSetCurrentContext( NULL );
CGLClearDrawable( glContextObj ); // disassociate from full screen
CGLDestroyContext( glContextObj ); // and destroy the context
/* Returned image has a reference count of 1 */
return image;
}
void nuiSoftwarePainter::Display(nglWindow* pWindow, const nuiRect& rRect)
{
if (!pWindow)
return;
const nglWindow::OSInfo* pInfo = pWindow->GetOSInfo();
NGL_ASSERT(pInfo);
if (!pInfo)
return;
//TestAgg((char*)&mBuffer[0], mWidth, mHeight);
int32 x, y, w, h;
x = ToBelow(rRect.Left());
y = ToBelow(rRect.Top());
w = ToBelow(rRect.GetWidth());
h = ToBelow(rRect.GetHeight());
int32 offset = (x + mWidth * y);
#ifdef _WIN32_
HDC hdc = GetDC(pInfo->GLWindowHandle);
BITMAPV5HEADER bminfo;
// BITMAPV5HEADER
bminfo.bV5Size = sizeof(BITMAPV5HEADER);
bminfo.bV5Width = (LONG)mWidth;
bminfo.bV5Height = -(LONG)mHeight;
bminfo.bV5Planes = 1;
bminfo.bV5BitCount = 32;
bminfo.bV5Compression = BI_RGB;
bminfo.bV5SizeImage = 0;
bminfo.bV5XPelsPerMeter = 0;
bminfo.bV5YPelsPerMeter = 0;
bminfo.bV5ClrUsed = 0;
bminfo.bV5ClrImportant =0;
bminfo.bV5RedMask = 0;
bminfo.bV5GreenMask = 0;
bminfo.bV5BlueMask = 0;
bminfo.bV5AlphaMask = 0;
bminfo.bV5CSType = LCS_WINDOWS_COLOR_SPACE;
bminfo.bV5Endpoints.ciexyzRed.ciexyzX = 0;
bminfo.bV5Endpoints.ciexyzRed.ciexyzY = 0;
bminfo.bV5Endpoints.ciexyzRed.ciexyzZ = 0;
bminfo.bV5Endpoints.ciexyzGreen.ciexyzX = 0;
bminfo.bV5Endpoints.ciexyzGreen.ciexyzY = 0;
bminfo.bV5Endpoints.ciexyzGreen.ciexyzZ = 0;
bminfo.bV5Endpoints.ciexyzBlue.ciexyzX = 0;
bminfo.bV5Endpoints.ciexyzBlue.ciexyzY = 0;
bminfo.bV5Endpoints.ciexyzBlue.ciexyzZ = 0;
bminfo.bV5GammaRed = 0;
bminfo.bV5GammaGreen = 0;
bminfo.bV5GammaBlue = 0;
bminfo.bV5Intent = LCS_GM_IMAGES;
bminfo.bV5ProfileData = 0;
bminfo.bV5ProfileSize = 0;
bminfo.bV5Reserved = 0;
RECT r;
GetClientRect(pInfo->GLWindowHandle, &r);
r.right = (LONG)mWidth;
r.bottom = (LONG)mHeight;
uint32* pBuffer = mpRasterizer->GetBuffer();
/*
for (uint32 i = 0; i < mWidth * mHeight; i++)
pBuffer[i] = rand();
*/
SetDIBitsToDevice(
hdc, // handle to DC
x, // x-coord of destination upper-left corner
y, // y-coord of destination upper-left corner
w, // width of destination rectangle
h, // height of destination rectangle
x, // x-coord of source upper-left corner
mHeight - h - y, // y-coord of source upper-left corner
0, // first scan line
(LONG)mHeight, // number of scan lines
pBuffer, // bitmap bits
(const BITMAPINFO*)&bminfo, // bitmap data
DIB_RGB_COLORS // usage options
);
ReleaseDC(pInfo->GLWindowHandle, hdc);
#elif (defined _CARBON_)
WindowRef win = pInfo->WindowHandle;
if (!win)
win = pInfo->Parent;
//CGContextRef myMemoryContext;
CGColorSpaceRef cspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
CGDataProviderRef provider = CGDataProviderCreateWithData(NULL, mpRasterizer->GetBuffer() + offset, mWidth * h * 4, NULL);
CGImageRef img = CGImageCreate(
w,
h,
8,
32,
mWidth * 4,
cspace,
kCGBitmapByteOrder32Host | kCGImageAlphaNoneSkipFirst,
provider,
NULL,
0,
kCGRenderingIntentDefault
);
CGContextRef myContext;
SetPortWindowPort (win);// 1
QDBeginCGContext (GetWindowPort (win), &myContext);
CGRect rect = CGRectMake(x, mHeight - h - y, w, h);
CGContextDrawImage(myContext, rect, img);
QDEndCGContext (GetWindowPort(win), &myContext);
#endif
}
int main(int argc, char* argv[])
{
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
Error("An incorrect version of BASS was loaded");
return 0;
}
// initialize BASS
if (!BASS_Init(-1,44100,0,win,NULL)) {
Error("Can't initialize device");
return 0;
}
if (!PlayFile()) { // start a file playing
BASS_Free();
return 0;
}
// create the window
Rect wr;
wr.left=200;
wr.right=wr.left+SPECWIDTH;
wr.top=200;
wr.bottom=wr.top+SPECHEIGHT;
CreateNewWindow(kMovableModalWindowClass,kWindowStandardHandlerAttribute,&wr,&win);
SetWindowTitleWithCFString(win,CFSTR("BASS spectrum example (click to toggle mode)"));
ChangeWindowAttributes(win,kWindowAsyncDragAttribute,kWindowNoAttributes);
{
EventTypeSpec etype={kEventClassWindow,kEventWindowDrawContent};
InstallWindowEventHandler(win,NewEventHandlerUPP(EventWindowDrawContent),1,&etype,0,NULL);
etype.eventKind=kEventWindowHandleContentClick;
InstallWindowEventHandler(win,NewEventHandlerUPP(EventWindowClick),1,&etype,0,NULL);
}
// create the bitmap
CGColorSpaceRef colorSpace=CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
specdc=CGBitmapContextCreate(specbuf,SPECWIDTH,SPECHEIGHT,8,SPECWIDTH*4,colorSpace,kCGImageAlphaNoneSkipLast);
CGColorSpaceRelease(colorSpace);
{ // setup palette
RGBQUAD *pal=(RGBQUAD*)palette;
int a;
memset(palette,0,sizeof(palette));
for (a=1;a<128;a++) {
pal[a].rgbGreen=256-2*a;
pal[a].rgbRed=2*a;
}
for (a=0;a<32;a++) {
pal[128+a].rgbBlue=8*a;
pal[128+32+a].rgbBlue=255;
pal[128+32+a].rgbRed=8*a;
pal[128+64+a].rgbRed=255;
pal[128+64+a].rgbBlue=8*(31-a);
pal[128+64+a].rgbGreen=8*a;
pal[128+96+a].rgbRed=255;
pal[128+96+a].rgbGreen=255;
pal[128+96+a].rgbBlue=8*a;
}
}
ShowWindow(win);
// setup update timer (40hz)
EventLoopTimerRef timer;
InstallEventLoopTimer(GetCurrentEventLoop(),kEventDurationNoWait,kEventDurationSecond/40,NewEventLoopTimerUPP(UpdateSpectrum),0,&timer);
RunApplicationEventLoop();
CGContextRelease(specdc);
DisposeWindow(win);
BASS_Free();
return 0;
}
CGColorSpaceRef CGColorSpaceCreateGenericRGB_wrap() { return CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); }
CGColorSpaceRef CGColorSpaceCreateGenericCMYK_wrap() { return CGColorSpaceCreateWithName(kCGColorSpaceGenericCMYK); }
CGColorSpaceRef CGColorSpaceCreateGenericGray_wrap() { return CGColorSpaceCreateWithName(kCGColorSpaceGenericGray); }
bool ImageIODecoder::readData( Mat& img )
{
uchar* data = img.data;
int step = img.step;
bool color = img.channels() > 1;
int bpp; // Bytes per pixel
int bit_depth = 8;
// Get Height, Width, and color information
if( !readHeader() )
return false;
CGContextRef context = NULL; // The bitmap context
CGColorSpaceRef colorSpace = NULL;
uchar* bitmap = NULL;
CGImageAlphaInfo alphaInfo;
// CoreGraphics will take care of converting to grayscale and back as long as the
// appropriate colorspace is set
if( color == CV_LOAD_IMAGE_GRAYSCALE )
{
colorSpace = CGColorSpaceCreateDeviceGray();
bpp = 1;
alphaInfo = kCGImageAlphaNone;
}
else if( color == CV_LOAD_IMAGE_COLOR )
{
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
colorSpace = CGColorSpaceCreateDeviceRGB();
#else
colorSpace = CGColorSpaceCreateWithName( kCGColorSpaceGenericRGBLinear );
#endif
bpp = 4; /* CG only has 8 and 32 bit color spaces, so we waste a byte */
alphaInfo = kCGImageAlphaNoneSkipLast;
}
if( !colorSpace )
return false;
bitmap = (uchar*)malloc( bpp * m_height * m_width );
if( !bitmap )
{
CGColorSpaceRelease( colorSpace );
return false;
}
context = CGBitmapContextCreate( (void *)bitmap,
m_width, /* width */
m_height, /* height */
bit_depth, /* bit depth */
bpp * m_width, /* bytes per row */
colorSpace, /* color space */
alphaInfo);
CGColorSpaceRelease( colorSpace );
if( !context )
{
free( bitmap );
return false;
}
// Copy the image data into the bitmap region
CGRect rect = {{0,0},{m_width,m_height}};
CGContextDrawImage( context, rect, imageRef );
uchar* bitdata = (uchar*)CGBitmapContextGetData( context );
if( !bitdata )
{
free( bitmap);
CGContextRelease( context );
return false;
}
// Move the bitmap (in RGB) into data (in BGR)
int bitmapIndex = 0;
if( color == CV_LOAD_IMAGE_COLOR )
{
uchar * base = data;
for (int y = 0; y < m_height; y++)
{
uchar * line = base + y * step;
for (int x = 0; x < m_width; x++)
{
// Blue channel
line[0] = bitdata[bitmapIndex + 2];
// Green channel
line[1] = bitdata[bitmapIndex + 1];
// Red channel
line[2] = bitdata[bitmapIndex + 0];
line += 3;
bitmapIndex += bpp;
}
}
}
else if( color == CV_LOAD_IMAGE_GRAYSCALE )
{
for (int y = 0; y < m_height; y++)
memcpy (data + y * step, bitmap + y * m_width, m_width);
}
free( bitmap );
CGContextRelease( context );
return true;
}
bool ImageIOEncoder::write( const Mat& img, const vector<int>& params )
{
int width = img.cols, height = img.rows;
int _channels = img.channels();
const uchar* data = img.data;
int step = img.step;
// Determine the appropriate UTI based on the filename extension
CFStringRef imageUTI = FilenameToUTI( m_filename.c_str() );
// Determine the Bytes Per Pixel
int bpp = (_channels == 1) ? 1 : 4;
// Write the data into a bitmap context
CGContextRef context;
CGColorSpaceRef colorSpace;
uchar* bitmapData = NULL;
if( bpp == 1 ) {
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
colorSpace = CGColorSpaceCreateDeviceGray();
#else
colorSpace = CGColorSpaceCreateWithName( kCGColorSpaceGenericGray );
#endif
}
else if( bpp == 4 ) {
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
colorSpace = CGColorSpaceCreateDeviceRGB();
#else
colorSpace = CGColorSpaceCreateWithName( kCGColorSpaceGenericRGBLinear );
#endif
}
if( !colorSpace )
return false;
bitmapData = (uchar*)malloc( bpp * height * width );
if( !bitmapData )
{
CGColorSpaceRelease( colorSpace );
return false;
}
context = CGBitmapContextCreate( bitmapData,
width,
height,
8,
bpp * width,
colorSpace,
(bpp == 1) ? kCGImageAlphaNone :
kCGImageAlphaNoneSkipLast );
CGColorSpaceRelease( colorSpace );
if( !context )
{
free( bitmapData );
return false;
}
// Copy pixel information from data into bitmapData
if (bpp == 4)
{
int bitmapIndex = 0;
const uchar * base = data;
for (int y = 0; y < height; y++)
{
const uchar * line = base + y * step;
for (int x = 0; x < width; x++)
{
// Blue channel
bitmapData[bitmapIndex + 2] = line[0];
// Green channel
bitmapData[bitmapIndex + 1] = line[1];
// Red channel
bitmapData[bitmapIndex + 0] = line[2];
line += 3;
bitmapIndex += bpp;
}
}
}
else if (bpp == 1)
{
for (int y = 0; y < height; y++)
memcpy (bitmapData + y * width, data + y * step, width);
}
// Turn the bitmap context into an imageRef
CGImageRef imageRef = CGBitmapContextCreateImage( context );
CGContextRelease( context );
if( !imageRef )
{
free( bitmapData );
return false;
}
// Write the imageRef to a file based on the UTI
CFURLRef imageURLRef = CFURLCreateFromFileSystemRepresentation( NULL,
(const UInt8*)m_filename.c_str(), m_filename.size(), false );
if( !imageURLRef )
{
CGImageRelease( imageRef );
free( bitmapData );
return false;
}
CGImageDestinationRef destRef = CGImageDestinationCreateWithURL( imageURLRef,
imageUTI,
1,
NULL);
CFRelease( imageURLRef );
if( !destRef )
{
CGImageRelease( imageRef );
free( bitmapData );
fprintf(stderr, "!destRef\n");
return false;
}
CGImageDestinationAddImage(destRef, imageRef, NULL);
if( !CGImageDestinationFinalize(destRef) )
{
fprintf(stderr, "Finalize failed\n");
return false;
}
CFRelease( destRef );
CGImageRelease( imageRef );
free( bitmapData );
return true;
}
Memsubfont*
mksubfont(XFont *f, char *name, int lo, int hi, int size, int antialias)
{
CFStringRef s;
CGColorSpaceRef color;
CGContextRef ctxt;
CTFontRef font;
CTFontDescriptorRef desc;
CGRect bbox;
Memimage *m, *mc, *m1;
int x, y, y0;
int i, height, ascent;
Fontchar *fc, *fc0;
Memsubfont *sf;
CGFloat whitef[] = { 1.0, 1.0 };
CGColorRef white;
s = c2mac(name);
desc = CTFontDescriptorCreateWithNameAndSize(s, size);
CFRelease(s);
if(desc == nil)
return nil;
font = CTFontCreateWithFontDescriptor(desc, 0, nil);
CFRelease(desc);
if(font == nil)
return nil;
bbox = CTFontGetBoundingBox(font);
x = (int)(bbox.size.width*2 + 0.99999999);
fontheight(f, size, &height, &ascent);
y = height;
y0 = height - ascent;
m = allocmemimage(Rect(0, 0, x*(hi+1-lo)+1, y+1), GREY8);
if(m == nil)
return nil;
mc = allocmemimage(Rect(0, 0, x+1, y+1), GREY8);
if(mc == nil){
freememimage(m);
return nil;
}
memfillcolor(m, DBlack);
memfillcolor(mc, DBlack);
fc = malloc((hi+2 - lo) * sizeof fc[0]);
sf = malloc(sizeof *sf);
if(fc == nil || sf == nil) {
freememimage(m);
freememimage(mc);
free(fc);
free(sf);
return nil;
}
fc0 = fc;
color = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
ctxt = CGBitmapContextCreate(byteaddr(mc, mc->r.min), Dx(mc->r), Dy(mc->r), 8,
mc->width*sizeof(u32int), color, kCGImageAlphaNone);
white = CGColorCreate(color, whitef);
CGColorSpaceRelease(color);
if(ctxt == nil) {
freememimage(m);
freememimage(mc);
free(fc);
free(sf);
return nil;
}
CGContextSetAllowsAntialiasing(ctxt, antialias);
CGContextSetTextPosition(ctxt, 0, 0); // XXX
#if OSX_VERSION >= 101400
CGContextSetAllowsFontSmoothing(ctxt, false);
#endif
x = 0;
for(i=lo; i<=hi; i++, fc++) {
char buf[20];
CFStringRef str;
CFDictionaryRef attrs;
CFAttributedStringRef attrString;
CTLineRef line;
CGRect r;
CGPoint p1;
CFStringRef keys[] = { kCTFontAttributeName, kCTForegroundColorAttributeName };
CFTypeRef values[] = { font, white };
sprint(buf, "%C", (Rune)mapUnicode(name, i));
str = c2mac(buf);
// See https://developer.apple.com/library/ios/documentation/StringsTextFonts/Conceptual/CoreText_Programming/LayoutOperations/LayoutOperations.html#//apple_ref/doc/uid/TP40005533-CH12-SW2
attrs = CFDictionaryCreate(kCFAllocatorDefault, (const void**)&keys,
(const void**)&values, sizeof(keys) / sizeof(keys[0]),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
attrString = CFAttributedStringCreate(kCFAllocatorDefault, str, attrs);
CFRelease(str);
CFRelease(attrs);
line = CTLineCreateWithAttributedString(attrString);
CGContextSetTextPosition(ctxt, 0, y0);
r = CTLineGetImageBounds(line, ctxt);
memfillcolor(mc, DBlack);
CTLineDraw(line, ctxt);
CFRelease(line);
fc->x = x;
fc->top = 0;
fc->bottom = Dy(m->r);
// fprint(2, "printed %#x: %g %g\n", mapUnicode(i), p1.x, p1.y);
p1 = CGContextGetTextPosition(ctxt);
if(p1.x <= 0 || mapUnicode(name, i) == 0xfffd) {
fc->width = 0;
fc->left = 0;
if(i == 0) {
drawpjw(m, fc, x, (int)(bbox.size.width + 0.99999999), y, y - y0);
x += fc->width;
}
continue;
}
memimagedraw(m, Rect(x, 0, x + p1.x, y), mc, ZP, memopaque, ZP, S);
fc->width = p1.x;
fc->left = 0;
x += p1.x;
}
fc->x = x;
// round up to 32-bit boundary
// so that in-memory data is same
// layout as in-file data.
if(x == 0)
x = 1;
if(y == 0)
y = 1;
if(antialias)
x += -x & 3;
else
x += -x & 31;
m1 = allocmemimage(Rect(0, 0, x, y), antialias ? GREY8 : GREY1);
memimagedraw(m1, m1->r, m, m->r.min, memopaque, ZP, S);
freememimage(m);
freememimage(mc);
sf->name = nil;
sf->n = hi+1 - lo;
sf->height = Dy(m1->r);
sf->ascent = Dy(m1->r) - y0;
sf->info = fc0;
sf->bits = m1;
return sf;
}
static void
fontheight(XFont *f, int size, int *height, int *ascent)
{
int i;
CFStringRef s;
CGRect bbox;
CTFontRef font;
CTFontDescriptorRef desc;
CGContextRef ctxt;
CGColorSpaceRef color;
s = c2mac(f->name);
desc = CTFontDescriptorCreateWithNameAndSize(s, size);
CFRelease(s);
if(desc == nil)
return;
font = CTFontCreateWithFontDescriptor(desc, 0, nil);
CFRelease(desc);
if(font == nil)
return;
color = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
ctxt = CGBitmapContextCreate(nil, 1, 1, 8, 1, color, kCGImageAlphaNone);
CGColorSpaceRelease(color);
CGContextSetTextPosition(ctxt, 0, 0);
for(i=0; i<nelem(lines); i++) {
CFStringRef keys[] = { kCTFontAttributeName };
CFTypeRef values[] = { font };
CFStringRef str;
CFDictionaryRef attrs;
CFAttributedStringRef attrString;
CGRect r;
CTLineRef line;
str = c2mac(lines[i]);
// See https://developer.apple.com/library/ios/documentation/StringsTextFonts/Conceptual/CoreText_Programming/LayoutOperations/LayoutOperations.html#//apple_ref/doc/uid/TP40005533-CH12-SW2
attrs = CFDictionaryCreate(kCFAllocatorDefault, (const void**)&keys,
(const void**)&values, sizeof(keys) / sizeof(keys[0]),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
attrString = CFAttributedStringCreate(kCFAllocatorDefault, str, attrs);
CFRelease(str);
CFRelease(attrs);
line = CTLineCreateWithAttributedString(attrString);
r = CTLineGetImageBounds(line, ctxt);
r.size.width += r.origin.x;
r.size.height += r.origin.y;
CFRelease(line);
// fprint(2, "%s: %g %g %g %g\n", lines[i], r.origin.x, r.origin.y, r.size.width, r.size.height);
if(i == 0)
bbox = r;
if(bbox.origin.x > r.origin.x)
bbox.origin.x = r.origin.x;
if(bbox.origin.y > r.origin.y)
bbox.origin.y = r.origin.y;
if(bbox.size.width < r.size.width)
bbox.size.width = r.size.width;
if(bbox.size.height < r.size.height)
bbox.size.height = r.size.height;
}
bbox.size.width -= bbox.origin.x;
bbox.size.height -= bbox.origin.y;
*height = bbox.size.height + 0.999999;
*ascent = *height - (-bbox.origin.y + 0.999999);
CGContextRelease(ctxt);
CFRelease(font);
}