2011-01-12 23:21:17 +03:00
|
|
|
/*
|
|
|
|
* Copyright 2011 Sven Weidauer <sven.weidauer@gmail.com>
|
|
|
|
*
|
|
|
|
* This file is part of NetSurf, http://www.netsurf-browser.org/
|
|
|
|
*
|
|
|
|
* NetSurf is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; version 2 of the License.
|
|
|
|
*
|
|
|
|
* NetSurf is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2015-06-18 12:07:46 +03:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2011-01-12 23:21:17 +03:00
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2015-04-24 17:46:40 +03:00
|
|
|
/**
|
|
|
|
* \file
|
|
|
|
* Cocoa implementation of bitmap operations.
|
|
|
|
*/
|
2011-01-12 23:21:17 +03:00
|
|
|
|
2015-04-24 17:46:40 +03:00
|
|
|
#import <Cocoa/Cocoa.h>
|
2011-01-12 23:21:17 +03:00
|
|
|
|
2016-05-30 19:32:57 +03:00
|
|
|
#import "netsurf/browser_window.h"
|
2016-05-30 23:05:57 +03:00
|
|
|
#import "netsurf/plotters.h"
|
2016-05-27 01:01:03 +03:00
|
|
|
#import "netsurf/bitmap.h"
|
2015-04-24 17:46:40 +03:00
|
|
|
#import "content/urldb.h"
|
|
|
|
#import "content/content.h"
|
|
|
|
|
|
|
|
#import "cocoa/plotter.h"
|
|
|
|
#import "cocoa/bitmap.h"
|
2011-01-31 22:12:00 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
#define BITS_PER_SAMPLE (8)
|
|
|
|
#define SAMPLES_PER_PIXEL (4)
|
|
|
|
#define BITS_PER_PIXEL (BITS_PER_SAMPLE * SAMPLES_PER_PIXEL)
|
|
|
|
#define BYTES_PER_PIXEL (BITS_PER_PIXEL / 8)
|
|
|
|
#define RED_OFFSET (0)
|
|
|
|
#define GREEN_OFFSET (1)
|
|
|
|
#define BLUE_OFFSET (2)
|
|
|
|
#define ALPHA_OFFSET (3)
|
|
|
|
|
|
|
|
static CGImageRef cocoa_prepare_bitmap( void *bitmap );
|
2011-01-31 10:57:52 +03:00
|
|
|
static NSMapTable *cocoa_get_bitmap_cache( void );
|
2011-01-12 23:21:17 +03:00
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static int bitmap_get_width(void *bitmap)
|
2011-01-12 23:21:17 +03:00
|
|
|
{
|
|
|
|
NSCParameterAssert( NULL != bitmap );
|
|
|
|
NSBitmapImageRep *bmp = (NSBitmapImageRep *)bitmap;
|
|
|
|
return [bmp pixelsWide];
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static int bitmap_get_height(void *bitmap)
|
2011-01-12 23:21:17 +03:00
|
|
|
{
|
|
|
|
NSCParameterAssert( NULL != bitmap );
|
|
|
|
NSBitmapImageRep *bmp = (NSBitmapImageRep *)bitmap;
|
|
|
|
return [bmp pixelsHigh];
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static bool bitmap_get_opaque(void *bitmap)
|
2011-01-12 23:21:17 +03:00
|
|
|
{
|
|
|
|
NSCParameterAssert( NULL != bitmap );
|
|
|
|
NSBitmapImageRep *bmp = (NSBitmapImageRep *)bitmap;
|
|
|
|
return [bmp isOpaque];
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static void bitmap_destroy(void *bitmap)
|
2011-01-12 23:21:17 +03:00
|
|
|
{
|
|
|
|
NSCParameterAssert( NULL != bitmap );
|
|
|
|
|
|
|
|
NSMapTable *cache = cocoa_get_bitmap_cache();
|
|
|
|
CGImageRef image = NSMapGet( cache, bitmap );
|
|
|
|
if (NULL != image) {
|
|
|
|
CGImageRelease( image );
|
|
|
|
NSMapRemove( cache, bitmap );
|
|
|
|
}
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
NSBitmapImageRep *bmp = (NSBitmapImageRep *)bitmap;
|
|
|
|
[bmp release];
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static void *bitmap_create(int width, int height, unsigned int state)
|
2011-01-12 23:21:17 +03:00
|
|
|
{
|
2015-04-24 17:46:40 +03:00
|
|
|
NSBitmapImageRep *bmp = [[NSBitmapImageRep alloc]
|
|
|
|
initWithBitmapDataPlanes: NULL
|
|
|
|
pixelsWide: width
|
|
|
|
pixelsHigh: height
|
|
|
|
bitsPerSample: BITS_PER_SAMPLE
|
|
|
|
samplesPerPixel: SAMPLES_PER_PIXEL
|
|
|
|
hasAlpha: YES
|
|
|
|
isPlanar: NO
|
|
|
|
colorSpaceName: NSDeviceRGBColorSpace
|
|
|
|
bitmapFormat: NSAlphaNonpremultipliedBitmapFormat
|
|
|
|
bytesPerRow: BYTES_PER_PIXEL * width
|
|
|
|
bitsPerPixel: BITS_PER_PIXEL];
|
2011-01-12 23:21:17 +03:00
|
|
|
|
|
|
|
return bmp;
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static void bitmap_set_opaque(void *bitmap, bool opaque)
|
2011-01-12 23:21:17 +03:00
|
|
|
{
|
|
|
|
NSCParameterAssert( NULL != bitmap );
|
|
|
|
NSBitmapImageRep *bmp = (NSBitmapImageRep *)bitmap;
|
|
|
|
[bmp setOpaque: opaque ? YES : NO];
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static unsigned char *bitmap_get_buffer(void *bitmap)
|
2015-04-17 02:01:17 +03:00
|
|
|
{
|
|
|
|
NSCParameterAssert( NULL != bitmap );
|
|
|
|
NSBitmapImageRep *bmp = (NSBitmapImageRep *)bitmap;
|
|
|
|
return [bmp bitmapData];
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static size_t bitmap_get_rowstride(void *bitmap)
|
2015-04-17 02:01:17 +03:00
|
|
|
{
|
|
|
|
NSCParameterAssert( NULL != bitmap );
|
|
|
|
NSBitmapImageRep *bmp = (NSBitmapImageRep *)bitmap;
|
|
|
|
return [bmp bytesPerRow];
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static size_t bitmap_get_bpp(void *bitmap)
|
2015-04-17 02:01:17 +03:00
|
|
|
{
|
|
|
|
NSCParameterAssert( NULL != bitmap );
|
|
|
|
NSBitmapImageRep *bmp = (NSBitmapImageRep *)bitmap;
|
|
|
|
return [bmp bitsPerPixel] / 8;
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static bool bitmap_test_opaque(void *bitmap)
|
2011-01-12 23:21:17 +03:00
|
|
|
{
|
2011-01-25 21:48:26 +03:00
|
|
|
NSCParameterAssert( bitmap_get_bpp( bitmap ) == BYTES_PER_PIXEL );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
unsigned char *buf = bitmap_get_buffer( bitmap );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
const size_t height = bitmap_get_height( bitmap );
|
|
|
|
const size_t width = bitmap_get_width( bitmap );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
const size_t line_step = bitmap_get_rowstride( bitmap ) - BYTES_PER_PIXEL * width;
|
|
|
|
|
|
|
|
for (size_t y = 0; y < height; y++) {
|
|
|
|
for (size_t x = 0; x < height; x++) {
|
|
|
|
if (buf[ALPHA_OFFSET] != 0xFF) return false;
|
|
|
|
buf += BYTES_PER_PIXEL;
|
|
|
|
}
|
|
|
|
buf += line_step;
|
|
|
|
}
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
static bool bitmap_save(void *bitmap, const char *path, unsigned flags)
|
2011-01-12 23:21:17 +03:00
|
|
|
{
|
|
|
|
NSCParameterAssert( NULL != bitmap );
|
|
|
|
NSBitmapImageRep *bmp = (NSBitmapImageRep *)bitmap;
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
NSData *tiff = [bmp TIFFRepresentation];
|
|
|
|
return [tiff writeToFile: [NSString stringWithUTF8String: path] atomically: YES];
|
|
|
|
}
|
|
|
|
|
2015-06-18 12:12:11 +03:00
|
|
|
void cocoa_bitmap_modified(void *bitmap)
|
2011-01-12 23:21:17 +03:00
|
|
|
{
|
|
|
|
NSMapTable *cache = cocoa_get_bitmap_cache();
|
|
|
|
CGImageRef image = NSMapGet( cache, bitmap );
|
|
|
|
if (NULL != image) {
|
|
|
|
CGImageRelease( image );
|
|
|
|
NSMapRemove( cache, bitmap );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CGImageRef cocoa_get_cgimage( void *bitmap )
|
|
|
|
{
|
|
|
|
NSMapTable *cache = cocoa_get_bitmap_cache();
|
|
|
|
|
|
|
|
CGImageRef result = NSMapGet( cache, bitmap );
|
|
|
|
if (NULL == result) {
|
|
|
|
result = cocoa_prepare_bitmap( bitmap );
|
|
|
|
NSMapInsertKnownAbsent( cache, bitmap, result );
|
|
|
|
}
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2011-01-31 10:57:52 +03:00
|
|
|
static inline NSMapTable *cocoa_get_bitmap_cache( void )
|
2011-01-12 23:21:17 +03:00
|
|
|
{
|
|
|
|
static NSMapTable *cache = nil;
|
|
|
|
if (cache == nil) {
|
|
|
|
cache = NSCreateMapTable( NSNonOwnedPointerMapKeyCallBacks, NSNonOwnedPointerMapValueCallBacks, 0 );
|
|
|
|
}
|
|
|
|
return cache;
|
|
|
|
}
|
|
|
|
|
|
|
|
static CGImageRef cocoa_prepare_bitmap( void *bitmap )
|
|
|
|
{
|
|
|
|
NSCParameterAssert( NULL != bitmap );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
NSBitmapImageRep *bmp = (NSBitmapImageRep *)bitmap;
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
size_t w = [bmp pixelsWide];
|
|
|
|
size_t h = [bmp pixelsHigh];
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
CGImageRef original = [bmp CGImage];
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
if (h <= 1) return CGImageRetain( original );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
void *data = malloc( 4 * w * h );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
|
2015-04-24 17:46:40 +03:00
|
|
|
CGContextRef context = CGBitmapContextCreate( data, w, h, BITS_PER_SAMPLE,
|
|
|
|
BYTES_PER_PIXEL * w, colorSpace,
|
|
|
|
[bmp isOpaque] ? kCGImageAlphaNoneSkipLast
|
|
|
|
: kCGImageAlphaPremultipliedLast );
|
2011-01-12 23:21:17 +03:00
|
|
|
CGColorSpaceRelease( colorSpace );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
CGContextTranslateCTM( context, 0.0, h );
|
|
|
|
CGContextScaleCTM( context, 1.0, -1.0 );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
CGRect rect = CGRectMake( 0, 0, w, h );
|
|
|
|
CGContextClearRect( context, rect );
|
|
|
|
CGContextDrawImage( context, rect, original );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
CGImageRef result = CGBitmapContextCreateImage( context );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
CGContextRelease( context );
|
|
|
|
free( data );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
2011-01-12 23:21:17 +03:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2015-04-24 17:46:40 +03:00
|
|
|
static nserror bitmap_render(struct bitmap *bitmap, struct hlcache_handle *content)
|
|
|
|
{
|
|
|
|
int bwidth = bitmap_get_width( bitmap );
|
|
|
|
int bheight = bitmap_get_height( bitmap );
|
|
|
|
|
|
|
|
struct redraw_context ctx = {
|
|
|
|
.interactive = false,
|
|
|
|
.background_images = true,
|
|
|
|
.plot = &cocoa_plotters
|
|
|
|
};
|
|
|
|
|
|
|
|
CGColorSpaceRef cspace = CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB );
|
|
|
|
CGContextRef bitmapContext = CGBitmapContextCreate( bitmap_get_buffer( bitmap ),
|
|
|
|
bwidth, bheight,
|
|
|
|
bitmap_get_bpp( bitmap ) * 8 / 4,
|
|
|
|
bitmap_get_rowstride( bitmap ),
|
|
|
|
cspace, kCGImageAlphaNoneSkipLast );
|
|
|
|
CGColorSpaceRelease( cspace );
|
|
|
|
|
|
|
|
size_t width = MIN( content_get_width( content ), 1024 );
|
|
|
|
size_t height = ((width * bheight) + bwidth / 2) / bwidth;
|
|
|
|
|
|
|
|
CGContextTranslateCTM( bitmapContext, 0, bheight );
|
|
|
|
CGContextScaleCTM( bitmapContext, (CGFloat)bwidth / width, -(CGFloat)bheight / height );
|
|
|
|
|
|
|
|
[NSGraphicsContext setCurrentContext: [NSGraphicsContext graphicsContextWithGraphicsPort: bitmapContext flipped: YES]];
|
|
|
|
|
|
|
|
content_scaled_redraw( content, width, height, &ctx );
|
|
|
|
|
|
|
|
[NSGraphicsContext setCurrentContext: nil];
|
|
|
|
CGContextRelease( bitmapContext );
|
|
|
|
|
2015-06-18 12:07:46 +03:00
|
|
|
cocoa_bitmap_modified( bitmap );
|
2015-04-24 17:46:40 +03:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-04-17 01:52:19 +03:00
|
|
|
static struct gui_bitmap_table bitmap_table = {
|
|
|
|
.create = bitmap_create,
|
|
|
|
.destroy = bitmap_destroy,
|
|
|
|
.set_opaque = bitmap_set_opaque,
|
|
|
|
.get_opaque = bitmap_get_opaque,
|
|
|
|
.test_opaque = bitmap_test_opaque,
|
|
|
|
.get_buffer = bitmap_get_buffer,
|
|
|
|
.get_rowstride = bitmap_get_rowstride,
|
|
|
|
.get_width = bitmap_get_width,
|
|
|
|
.get_height = bitmap_get_height,
|
|
|
|
.get_bpp = bitmap_get_bpp,
|
|
|
|
.save = bitmap_save,
|
2015-06-18 12:07:46 +03:00
|
|
|
.modified = cocoa_bitmap_modified,
|
2015-04-24 17:46:40 +03:00
|
|
|
.render = bitmap_render,
|
2015-04-17 01:52:19 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_bitmap_table *cocoa_bitmap_table = &bitmap_table;
|