2008-08-02 18:31:32 +04:00
|
|
|
/*
|
2012-08-10 21:05:22 +04:00
|
|
|
* Copyright 2008, 2009, 2012 Chris Young <chris@unsatisfactorysoftware.co.uk>
|
2008-08-02 18:31:32 +04:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* 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/>.
|
|
|
|
*/
|
|
|
|
|
2011-01-07 02:56:03 +03:00
|
|
|
#include "amiga/os3support.h"
|
|
|
|
|
2008-08-02 18:31:32 +04:00
|
|
|
#include <proto/exec.h>
|
2011-01-07 02:17:17 +03:00
|
|
|
#ifdef __amigaos4__
|
|
|
|
#include <graphics/blitattr.h>
|
2009-02-25 22:56:04 +03:00
|
|
|
#include <graphics/composite.h>
|
2011-01-07 02:17:17 +03:00
|
|
|
#endif
|
2011-01-07 21:21:01 +03:00
|
|
|
#include <graphics/gfxbase.h>
|
2009-05-16 21:04:28 +04:00
|
|
|
#include <proto/datatypes.h>
|
|
|
|
#include <datatypes/pictureclass.h>
|
2009-05-16 18:50:30 +04:00
|
|
|
#include <proto/dos.h>
|
2009-05-16 21:04:28 +04:00
|
|
|
#include <proto/intuition.h>
|
2011-07-23 19:19:27 +04:00
|
|
|
#include <proto/utility.h>
|
2015-04-24 13:56:19 +03:00
|
|
|
#include <sys/param.h>
|
2014-10-16 12:55:01 +04:00
|
|
|
#include "assert.h"
|
|
|
|
|
2015-04-24 13:56:19 +03:00
|
|
|
#include "utils/nsoption.h"
|
2009-05-16 21:04:28 +04:00
|
|
|
#include "utils/messages.h"
|
2014-10-16 12:55:01 +04:00
|
|
|
#include "desktop/mouse.h"
|
|
|
|
#include "desktop/gui_window.h"
|
2015-04-17 00:36:29 +03:00
|
|
|
#include "image/bitmap.h"
|
2014-10-16 12:55:01 +04:00
|
|
|
|
|
|
|
#include "amiga/gui.h"
|
|
|
|
#include "amiga/bitmap.h"
|
|
|
|
#include "amiga/download.h"
|
2015-01-11 02:10:05 +03:00
|
|
|
#include "amiga/misc.h"
|
2015-01-20 23:36:14 +03:00
|
|
|
#include "amiga/rtg.h"
|
2008-08-02 18:31:32 +04:00
|
|
|
|
2016-01-21 23:30:02 +03:00
|
|
|
static APTR pool_bitmap = NULL;
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
/* exported function documented in amiga/bitmap.h */
|
|
|
|
void *amiga_bitmap_create(int width, int height, unsigned int state)
|
2008-08-02 18:31:32 +04:00
|
|
|
{
|
|
|
|
struct bitmap *bitmap;
|
2009-08-10 01:37:20 +04:00
|
|
|
|
2016-01-21 23:30:02 +03:00
|
|
|
bitmap = ami_misc_itempool_alloc(pool_bitmap, sizeof(struct bitmap));
|
|
|
|
if(bitmap == NULL) return NULL;
|
|
|
|
|
|
|
|
bitmap->pixdata = ami_misc_allocvec_clear(width*height*4, 0xff);
|
|
|
|
bitmap->width = width;
|
|
|
|
bitmap->height = height;
|
|
|
|
|
|
|
|
if(state & BITMAP_OPAQUE) bitmap->opaque = true;
|
|
|
|
else bitmap->opaque = false;
|
|
|
|
|
|
|
|
bitmap->nativebm = NULL;
|
|
|
|
bitmap->nativebmwidth = 0;
|
|
|
|
bitmap->nativebmheight = 0;
|
|
|
|
bitmap->native_mask = NULL;
|
|
|
|
bitmap->dto = NULL;
|
2012-08-08 21:41:16 +04:00
|
|
|
|
2008-08-02 18:31:32 +04:00
|
|
|
return bitmap;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
/* exported function documented in amiga/bitmap.h */
|
|
|
|
unsigned char *amiga_bitmap_get_buffer(void *bitmap)
|
2008-08-02 18:31:32 +04:00
|
|
|
{
|
2008-08-12 21:47:01 +04:00
|
|
|
struct bitmap *bm = bitmap;
|
|
|
|
return bm->pixdata;
|
2008-08-02 18:31:32 +04:00
|
|
|
}
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
/* exported function documented in amiga/bitmap.h */
|
|
|
|
size_t amiga_bitmap_get_rowstride(void *bitmap)
|
2008-08-02 18:31:32 +04:00
|
|
|
{
|
2008-08-12 21:47:01 +04:00
|
|
|
struct bitmap *bm = bitmap;
|
2008-08-15 21:22:52 +04:00
|
|
|
|
|
|
|
if(bm)
|
|
|
|
{
|
|
|
|
return ((bm->width)*4);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2008-08-02 18:31:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
/* exported function documented in amiga/bitmap.h */
|
|
|
|
void amiga_bitmap_destroy(void *bitmap)
|
2008-08-02 18:31:32 +04:00
|
|
|
{
|
2008-08-12 21:47:01 +04:00
|
|
|
struct bitmap *bm = bitmap;
|
|
|
|
|
2008-08-15 21:22:52 +04:00
|
|
|
if(bm)
|
|
|
|
{
|
2012-08-06 02:51:59 +04:00
|
|
|
if((bm->nativebm) && (bm->dto == NULL)) {
|
2015-01-20 23:36:14 +03:00
|
|
|
ami_rtg_freebitmap(bm->nativebm);
|
2012-08-06 02:51:59 +04:00
|
|
|
}
|
2012-08-05 18:16:02 +04:00
|
|
|
|
2012-08-06 02:51:59 +04:00
|
|
|
if(bm->dto) {
|
|
|
|
DisposeDTObject(bm->dto);
|
|
|
|
}
|
2012-08-10 22:31:16 +04:00
|
|
|
|
2012-08-10 00:59:47 +04:00
|
|
|
if(bm->native_mask) FreeRaster(bm->native_mask, bm->width, bm->height);
|
2008-08-15 21:22:52 +04:00
|
|
|
FreeVec(bm->pixdata);
|
|
|
|
bm->pixdata = NULL;
|
2012-08-10 00:59:47 +04:00
|
|
|
bm->nativebm = NULL;
|
|
|
|
bm->native_mask = NULL;
|
|
|
|
bm->dto = NULL;
|
|
|
|
|
2016-01-21 23:30:02 +03:00
|
|
|
ami_misc_itempool_free(pool_bitmap, bm, sizeof(struct bitmap));
|
2008-08-15 21:22:52 +04:00
|
|
|
bm = NULL;
|
|
|
|
}
|
2008-08-02 18:31:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
/* exported function documented in amiga/bitmap.h */
|
|
|
|
bool amiga_bitmap_save(void *bitmap, const char *path, unsigned flags)
|
2008-08-02 18:31:32 +04:00
|
|
|
{
|
2010-10-10 13:30:22 +04:00
|
|
|
int err = 0;
|
2009-05-16 21:04:28 +04:00
|
|
|
Object *dto = NULL;
|
2009-05-16 18:50:30 +04:00
|
|
|
|
2014-10-25 18:55:25 +04:00
|
|
|
if((dto = ami_datatype_object_from_bitmap(bitmap)))
|
2009-05-16 18:50:30 +04:00
|
|
|
{
|
2015-06-22 21:12:57 +03:00
|
|
|
if (flags & AMI_BITMAP_SCALE_ICON) {
|
|
|
|
IDoMethod(dto, PDTM_SCALE, 16, 16, 0);
|
|
|
|
|
|
|
|
if((DoDTMethod(dto, 0, 0, DTM_PROCLAYOUT, 0, 1)) == 0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-10 13:30:22 +04:00
|
|
|
err = SaveDTObjectA(dto, NULL, NULL, path, DTWM_IFF, FALSE, NULL);
|
2009-05-16 21:04:28 +04:00
|
|
|
DisposeDTObject(dto);
|
2009-05-16 18:50:30 +04:00
|
|
|
}
|
|
|
|
|
2010-10-10 13:30:22 +04:00
|
|
|
if(err == 0) return false;
|
|
|
|
else return true;
|
2008-08-02 18:31:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
/* exported function documented in amiga/bitmap.h */
|
|
|
|
void amiga_bitmap_modified(void *bitmap)
|
|
|
|
{
|
2008-12-28 18:55:52 +03:00
|
|
|
struct bitmap *bm = bitmap;
|
|
|
|
|
2012-08-05 18:16:02 +04:00
|
|
|
if((bm->nativebm) && (bm->dto == NULL))
|
2015-01-20 23:36:14 +03:00
|
|
|
ami_rtg_freebitmap(bm->nativebm);
|
2012-08-05 18:16:02 +04:00
|
|
|
|
|
|
|
if(bm->dto) DisposeDTObject(bm->dto);
|
2012-08-10 00:59:47 +04:00
|
|
|
if(bm->native_mask) FreeRaster(bm->native_mask, bm->width, bm->height);
|
2008-12-28 18:55:52 +03:00
|
|
|
bm->nativebm = NULL;
|
2012-08-05 18:16:02 +04:00
|
|
|
bm->dto = NULL;
|
|
|
|
bm->native_mask = NULL;
|
2008-08-02 18:31:32 +04:00
|
|
|
}
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
|
|
|
|
/* exported function documented in amiga/bitmap.h */
|
|
|
|
void amiga_bitmap_set_opaque(void *bitmap, bool opaque)
|
2008-08-02 18:31:32 +04:00
|
|
|
{
|
2008-12-27 21:32:20 +03:00
|
|
|
struct bitmap *bm = bitmap;
|
2008-08-02 18:31:32 +04:00
|
|
|
assert(bitmap);
|
2008-12-27 21:32:20 +03:00
|
|
|
bm->opaque = opaque;
|
2008-08-02 18:31:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
/* exported function documented in amiga/bitmap.h */
|
|
|
|
bool amiga_bitmap_test_opaque(void *bitmap)
|
2008-08-02 18:31:32 +04:00
|
|
|
{
|
2008-12-27 21:32:20 +03:00
|
|
|
struct bitmap *bm = bitmap;
|
|
|
|
uint32 p = bm->width * bm->height;
|
|
|
|
uint32 a = 0;
|
2011-03-10 00:51:49 +03:00
|
|
|
uint32 *bmi = (uint32 *) bm->pixdata;
|
2008-12-27 21:32:20 +03:00
|
|
|
|
2008-08-02 18:31:32 +04:00
|
|
|
assert(bitmap);
|
2008-12-27 21:32:20 +03:00
|
|
|
|
|
|
|
for(a=0;a<p;a+=4)
|
|
|
|
{
|
2012-08-10 21:05:22 +04:00
|
|
|
if ((*bmi & 0x000000ffU) != 0x000000ffU) return false;
|
2008-12-27 21:32:20 +03:00
|
|
|
bmi++;
|
|
|
|
}
|
|
|
|
return true;
|
2008-08-02 18:31:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
/* exported function documented in amiga/bitmap.h */
|
|
|
|
bool amiga_bitmap_get_opaque(void *bitmap)
|
2008-08-02 18:31:32 +04:00
|
|
|
{
|
2008-12-27 21:32:20 +03:00
|
|
|
struct bitmap *bm = bitmap;
|
2008-08-02 18:31:32 +04:00
|
|
|
assert(bitmap);
|
2008-12-27 21:32:20 +03:00
|
|
|
return bm->opaque;
|
2008-08-02 18:31:32 +04:00
|
|
|
}
|
2008-08-12 21:47:01 +04:00
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
/**
|
|
|
|
* get width of a bitmap.
|
|
|
|
*/
|
|
|
|
static int bitmap_get_width(void *bitmap)
|
2008-08-12 21:47:01 +04:00
|
|
|
{
|
|
|
|
struct bitmap *bm = bitmap;
|
|
|
|
|
2008-08-15 21:22:52 +04:00
|
|
|
if(bm)
|
|
|
|
{
|
|
|
|
return(bm->width);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2008-08-12 21:47:01 +04:00
|
|
|
}
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
/**
|
|
|
|
* get height of a bitmap.
|
|
|
|
*/
|
|
|
|
static int bitmap_get_height(void *bitmap)
|
2008-08-12 21:47:01 +04:00
|
|
|
{
|
|
|
|
struct bitmap *bm = bitmap;
|
|
|
|
|
2008-08-15 21:22:52 +04:00
|
|
|
if(bm)
|
|
|
|
{
|
|
|
|
return(bm->height);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2008-08-12 21:47:01 +04:00
|
|
|
}
|
|
|
|
|
2008-09-07 23:08:57 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Find the bytes per pixel of a bitmap
|
|
|
|
*
|
|
|
|
* \param vbitmap a bitmap, as returned by bitmap_create()
|
|
|
|
* \return bytes per pixel
|
|
|
|
*/
|
2015-04-17 00:36:29 +03:00
|
|
|
static size_t bitmap_get_bpp(void *vbitmap)
|
2008-08-12 21:47:01 +04:00
|
|
|
{
|
2008-09-07 23:08:57 +04:00
|
|
|
struct bitmap *bitmap = (struct bitmap *)vbitmap;
|
|
|
|
assert(bitmap);
|
|
|
|
return 4;
|
2008-08-12 21:47:01 +04:00
|
|
|
}
|
2009-02-25 22:56:04 +03:00
|
|
|
|
2015-04-25 15:13:30 +03:00
|
|
|
static void ami_bitmap_argb_to_rgba(struct bitmap *bm)
|
|
|
|
{
|
|
|
|
if(bm == NULL) return;
|
|
|
|
|
|
|
|
ULONG *data = (ULONG *)amiga_bitmap_get_buffer(bm);
|
|
|
|
for(int i = 0; i < ((amiga_bitmap_get_rowstride(bm) / sizeof(ULONG)) * bm->height); i++) {
|
|
|
|
data[i] = (data[i] << 8) | (data[i] >> 24);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-25 18:55:25 +04:00
|
|
|
#ifdef BITMAP_DUMP
|
2013-10-05 14:18:27 +04:00
|
|
|
void bitmap_dump(struct bitmap *bitmap)
|
|
|
|
{
|
|
|
|
int x,y;
|
|
|
|
ULONG *bm = (ULONG *)bitmap->pixdata;
|
|
|
|
|
2013-10-05 14:28:33 +04:00
|
|
|
printf("Width=%ld, Height=%ld, Opaque=%s\nnativebm=%lx, width=%ld, height=%ld\n",
|
|
|
|
bitmap->width, bitmap->height, bitmap->opaque ? "true" : "false",
|
|
|
|
bitmap->nativebm, bitmap->nativebmwidth, bitmap->nativebmheight);
|
2013-10-05 14:18:27 +04:00
|
|
|
|
|
|
|
for(y = 0; y < bitmap->height; y++) {
|
|
|
|
for(x = 0; x < bitmap->width; x++) {
|
|
|
|
printf("%lx ", bm[(y*bitmap->width) + x]);
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
}
|
2014-10-16 12:55:01 +04:00
|
|
|
#endif
|
2013-10-05 14:18:27 +04:00
|
|
|
|
2009-05-16 21:04:28 +04:00
|
|
|
Object *ami_datatype_object_from_bitmap(struct bitmap *bitmap)
|
|
|
|
{
|
|
|
|
Object *dto;
|
|
|
|
struct BitMapHeader *bmhd;
|
|
|
|
|
2014-10-16 12:55:01 +04:00
|
|
|
if((dto = NewDTObject(NULL,
|
2009-05-16 21:04:28 +04:00
|
|
|
DTA_SourceType,DTST_RAM,
|
|
|
|
DTA_GroupID,GID_PICTURE,
|
|
|
|
//DTA_BaseName,"ilbm",
|
|
|
|
PDTA_DestMode,PMODE_V43,
|
2014-10-16 12:55:01 +04:00
|
|
|
TAG_DONE)))
|
2009-05-16 21:04:28 +04:00
|
|
|
{
|
|
|
|
if(GetDTAttrs(dto,PDTA_BitMapHeader,&bmhd,TAG_DONE))
|
|
|
|
{
|
|
|
|
bmhd->bmh_Width = (UWORD)bitmap_get_width(bitmap);
|
|
|
|
bmhd->bmh_Height = (UWORD)bitmap_get_height(bitmap);
|
|
|
|
bmhd->bmh_Depth = (UBYTE)bitmap_get_bpp(bitmap) * 8;
|
2015-04-17 00:36:29 +03:00
|
|
|
if(!amiga_bitmap_get_opaque(bitmap)) bmhd->bmh_Masking = mskHasAlpha;
|
2009-05-16 21:04:28 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
SetDTAttrs(dto,NULL,NULL,
|
2009-05-16 21:30:25 +04:00
|
|
|
DTA_ObjName,bitmap->url,
|
|
|
|
DTA_ObjAnnotation,bitmap->title,
|
2009-05-16 21:04:28 +04:00
|
|
|
DTA_ObjAuthor,messages_get("NetSurf"),
|
|
|
|
DTA_NominalHoriz,bitmap_get_width(bitmap),
|
|
|
|
DTA_NominalVert,bitmap_get_height(bitmap),
|
|
|
|
PDTA_SourceMode,PMODE_V43,
|
|
|
|
TAG_DONE);
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
IDoMethod(dto, PDTM_WRITEPIXELARRAY, amiga_bitmap_get_buffer(bitmap),
|
|
|
|
PBPAFMT_RGBA, amiga_bitmap_get_rowstride(bitmap), 0, 0,
|
2015-02-01 00:17:14 +03:00
|
|
|
bitmap_get_width(bitmap), bitmap_get_height(bitmap));
|
2009-05-16 21:04:28 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return dto;
|
|
|
|
}
|
|
|
|
|
2011-07-02 23:38:54 +04:00
|
|
|
/* Quick way to get an object on disk into a struct bitmap */
|
|
|
|
struct bitmap *ami_bitmap_from_datatype(char *filename)
|
|
|
|
{
|
|
|
|
Object *dto;
|
2011-09-08 23:21:02 +04:00
|
|
|
struct bitmap *bm = NULL;
|
2011-07-02 23:38:54 +04:00
|
|
|
|
2014-10-25 18:55:25 +04:00
|
|
|
if((dto = NewDTObject(filename,
|
2011-07-02 23:38:54 +04:00
|
|
|
DTA_GroupID, GID_PICTURE,
|
|
|
|
PDTA_DestMode, PMODE_V43,
|
2013-10-12 18:43:52 +04:00
|
|
|
PDTA_PromoteMask, TRUE,
|
2014-10-25 18:55:25 +04:00
|
|
|
TAG_DONE))) {
|
2011-07-02 23:38:54 +04:00
|
|
|
struct BitMapHeader *bmh;
|
|
|
|
|
|
|
|
if(GetDTAttrs(dto, PDTA_BitMapHeader, &bmh, TAG_DONE))
|
|
|
|
{
|
2015-04-17 00:36:29 +03:00
|
|
|
bm = amiga_bitmap_create(bmh->bmh_Width, bmh->bmh_Height, 0);
|
2011-07-02 23:38:54 +04:00
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
IDoMethod(dto, PDTM_READPIXELARRAY, amiga_bitmap_get_buffer(bm),
|
|
|
|
PBPAFMT_RGBA, amiga_bitmap_get_rowstride(bm), 0, 0,
|
2011-07-02 23:38:54 +04:00
|
|
|
bmh->bmh_Width, bmh->bmh_Height);
|
2015-02-01 00:17:14 +03:00
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
amiga_bitmap_set_opaque(bm, amiga_bitmap_test_opaque(bm));
|
2011-07-02 23:38:54 +04:00
|
|
|
}
|
|
|
|
DisposeDTObject(dto);
|
|
|
|
}
|
|
|
|
|
|
|
|
return bm;
|
|
|
|
}
|
|
|
|
|
2015-03-01 14:48:21 +03:00
|
|
|
static inline struct BitMap *ami_bitmap_get_truecolour(struct bitmap *bitmap,int width,int height,struct BitMap *friendbm)
|
2009-02-25 22:56:04 +03:00
|
|
|
{
|
|
|
|
struct BitMap *tbm = NULL;
|
|
|
|
|
2009-03-08 15:52:44 +03:00
|
|
|
if(!bitmap) return NULL;
|
|
|
|
|
2009-02-25 22:56:04 +03:00
|
|
|
if(bitmap->nativebm)
|
|
|
|
{
|
|
|
|
if((bitmap->nativebmwidth == width) && (bitmap->nativebmheight==height))
|
|
|
|
{
|
|
|
|
tbm = bitmap->nativebm;
|
|
|
|
return tbm;
|
|
|
|
}
|
|
|
|
else if((bitmap->nativebmwidth == bitmap->width) && (bitmap->nativebmheight==bitmap->height))
|
|
|
|
{
|
|
|
|
tbm = bitmap->nativebm;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-01-20 23:36:14 +03:00
|
|
|
if(bitmap->nativebm) ami_rtg_freebitmap(bitmap->nativebm);
|
2009-02-25 22:56:04 +03:00
|
|
|
bitmap->nativebm = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!tbm)
|
|
|
|
{
|
2015-01-20 23:36:14 +03:00
|
|
|
if((tbm = ami_rtg_allocbitmap(bitmap->width, bitmap->height, 32, 0,
|
2014-10-25 18:55:25 +04:00
|
|
|
friendbm, AMI_BITMAP_FORMAT))) {
|
2015-01-20 23:46:36 +03:00
|
|
|
ami_rtg_writepixelarray(bitmap->pixdata, tbm, bitmap->width, bitmap->height,
|
|
|
|
bitmap->width * 4, AMI_BITMAP_FORMAT);
|
2009-05-30 18:10:04 +04:00
|
|
|
}
|
2009-02-25 22:56:04 +03:00
|
|
|
|
2012-03-22 13:34:34 +04:00
|
|
|
if(nsoption_int(cache_bitmaps) == 2)
|
2009-02-25 22:56:04 +03:00
|
|
|
{
|
|
|
|
bitmap->nativebm = tbm;
|
|
|
|
bitmap->nativebmwidth = bitmap->width;
|
|
|
|
bitmap->nativebmheight = bitmap->height;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if((bitmap->width != width) || (bitmap->height != height))
|
|
|
|
{
|
|
|
|
struct BitMap *scaledbm;
|
|
|
|
struct BitScaleArgs bsa;
|
|
|
|
|
2015-02-01 01:19:12 +03:00
|
|
|
scaledbm = ami_rtg_allocbitmap(width, height, 32, 0,
|
2009-08-10 01:37:20 +04:00
|
|
|
friendbm, AMI_BITMAP_FORMAT);
|
2013-01-30 22:23:48 +04:00
|
|
|
#ifdef __amigaos4__
|
2015-03-01 14:48:21 +03:00
|
|
|
if(__builtin_expect(GfxBase->LibNode.lib_Version >= 53, 1)) {
|
|
|
|
/* AutoDoc says v52, but this function isn't in OS4.0, so checking for v53 (OS4.1) */
|
2013-10-05 14:27:05 +04:00
|
|
|
uint32 flags = 0;
|
2012-03-22 13:34:34 +04:00
|
|
|
if(nsoption_bool(scale_quality)) flags |= COMPFLAG_SrcFilter;
|
2013-10-05 14:18:27 +04:00
|
|
|
|
2013-10-05 14:28:33 +04:00
|
|
|
CompositeTags(COMPOSITE_Src, tbm, scaledbm,
|
2013-10-12 17:14:59 +04:00
|
|
|
COMPTAG_ScaleX,COMP_FLOAT_TO_FIX((float)width/bitmap->width),
|
|
|
|
COMPTAG_ScaleY,COMP_FLOAT_TO_FIX((float)height/bitmap->height),
|
2009-06-24 01:29:44 +04:00
|
|
|
COMPTAG_Flags, flags,
|
2009-02-25 22:56:04 +03:00
|
|
|
COMPTAG_DestX,0,
|
|
|
|
COMPTAG_DestY,0,
|
|
|
|
COMPTAG_DestWidth,width,
|
|
|
|
COMPTAG_DestHeight,height,
|
|
|
|
COMPTAG_OffsetX,0,
|
|
|
|
COMPTAG_OffsetY,0,
|
2014-01-06 22:29:05 +04:00
|
|
|
COMPTAG_FriendBitMap, scrn->RastPort.BitMap,
|
2009-02-25 22:56:04 +03:00
|
|
|
TAG_DONE);
|
2015-03-01 14:48:21 +03:00
|
|
|
} else /* Do it the old-fashioned way. This is pretty slow, even on OS4.1 */
|
2013-01-30 22:23:48 +04:00
|
|
|
#endif
|
2009-02-25 22:56:04 +03:00
|
|
|
{
|
|
|
|
bsa.bsa_SrcX = 0;
|
|
|
|
bsa.bsa_SrcY = 0;
|
|
|
|
bsa.bsa_SrcWidth = bitmap->width;
|
|
|
|
bsa.bsa_SrcHeight = bitmap->height;
|
|
|
|
bsa.bsa_DestX = 0;
|
|
|
|
bsa.bsa_DestY = 0;
|
|
|
|
bsa.bsa_XSrcFactor = bitmap->width;
|
|
|
|
bsa.bsa_XDestFactor = width;
|
|
|
|
bsa.bsa_YSrcFactor = bitmap->height;
|
|
|
|
bsa.bsa_YDestFactor = height;
|
|
|
|
bsa.bsa_SrcBitMap = tbm;
|
|
|
|
bsa.bsa_DestBitMap = scaledbm;
|
|
|
|
bsa.bsa_Flags = 0;
|
|
|
|
|
|
|
|
BitMapScale(&bsa);
|
|
|
|
}
|
|
|
|
|
2015-01-20 23:36:14 +03:00
|
|
|
if(bitmap->nativebm != tbm) ami_rtg_freebitmap(bitmap->nativebm);
|
|
|
|
ami_rtg_freebitmap(tbm);
|
2009-02-25 22:56:04 +03:00
|
|
|
tbm = scaledbm;
|
|
|
|
bitmap->nativebm = NULL;
|
|
|
|
|
2012-03-22 13:34:34 +04:00
|
|
|
if(nsoption_int(cache_bitmaps) >= 1)
|
2009-02-25 22:56:04 +03:00
|
|
|
{
|
|
|
|
bitmap->nativebm = tbm;
|
|
|
|
bitmap->nativebmwidth = width;
|
|
|
|
bitmap->nativebmheight = height;
|
|
|
|
}
|
|
|
|
}
|
2015-02-02 21:53:16 +03:00
|
|
|
|
2015-02-01 00:45:23 +03:00
|
|
|
return tbm;
|
2009-02-25 22:56:04 +03:00
|
|
|
}
|
2012-08-05 18:16:02 +04:00
|
|
|
|
2012-08-11 20:19:54 +04:00
|
|
|
PLANEPTR ami_bitmap_get_mask(struct bitmap *bitmap, int width,
|
|
|
|
int height, struct BitMap *n_bm)
|
2012-08-10 00:59:47 +04:00
|
|
|
{
|
|
|
|
uint32 *bmi = (uint32 *) bitmap->pixdata;
|
|
|
|
UBYTE maskbit = 0;
|
2012-08-11 20:19:54 +04:00
|
|
|
ULONG bm_width;
|
2012-08-12 14:02:12 +04:00
|
|
|
int y, x, bpr;
|
2012-08-10 00:59:47 +04:00
|
|
|
|
|
|
|
if((height != bitmap->height) || (width != bitmap->width)) return NULL;
|
2015-04-17 00:36:29 +03:00
|
|
|
if(amiga_bitmap_get_opaque(bitmap) == true) return NULL;
|
2012-08-10 00:59:47 +04:00
|
|
|
if(bitmap->native_mask) return bitmap->native_mask;
|
|
|
|
|
2012-08-11 20:19:54 +04:00
|
|
|
bm_width = GetBitMapAttr(n_bm, BMA_WIDTH);
|
2012-08-12 14:02:12 +04:00
|
|
|
bpr = RASSIZE(bm_width, 1);
|
2012-08-11 20:19:54 +04:00
|
|
|
bitmap->native_mask = AllocRaster(bm_width, height);
|
2012-08-12 14:02:12 +04:00
|
|
|
SetMem(bitmap->native_mask, 0, bpr * height);
|
2012-08-10 21:05:22 +04:00
|
|
|
|
2012-08-10 00:59:47 +04:00
|
|
|
for(y=0; y<height; y++) {
|
|
|
|
for(x=0; x<width; x++) {
|
2012-08-10 21:21:57 +04:00
|
|
|
if ((*bmi & 0x000000ffU) <= (ULONG)nsoption_int(mask_alpha)) maskbit = 0;
|
2012-08-10 21:11:42 +04:00
|
|
|
else maskbit = 1;
|
2012-08-10 00:59:47 +04:00
|
|
|
bmi++;
|
2012-08-12 14:02:12 +04:00
|
|
|
bitmap->native_mask[(y*bpr) + (x/8)] |=
|
|
|
|
maskbit << (7 - (x % 8));
|
2012-08-10 00:59:47 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return bitmap->native_mask;
|
|
|
|
}
|
|
|
|
|
2015-03-01 14:48:21 +03:00
|
|
|
static inline struct BitMap *ami_bitmap_get_palettemapped(struct bitmap *bitmap,
|
2012-08-05 18:16:02 +04:00
|
|
|
int width, int height)
|
|
|
|
{
|
|
|
|
struct BitMap *dtbm;
|
|
|
|
|
2012-08-05 18:29:20 +04:00
|
|
|
/* Dispose the DataTypes object if we've performed a layout already,
|
|
|
|
and we need to scale, as scaling can only be performed before
|
|
|
|
the first GM_LAYOUT */
|
|
|
|
|
|
|
|
if(bitmap->dto &&
|
|
|
|
((bitmap->nativebmwidth != width) ||
|
|
|
|
(bitmap->nativebmheight != height))) {
|
|
|
|
DisposeDTObject(bitmap->dto);
|
|
|
|
bitmap->dto = NULL;
|
|
|
|
}
|
|
|
|
|
2012-08-05 19:16:18 +04:00
|
|
|
if(bitmap->dto == NULL) {
|
2012-08-05 18:16:02 +04:00
|
|
|
bitmap->dto = ami_datatype_object_from_bitmap(bitmap);
|
2012-08-05 18:29:20 +04:00
|
|
|
|
2012-08-05 19:16:18 +04:00
|
|
|
SetDTAttrs(bitmap->dto, NULL, NULL,
|
|
|
|
PDTA_Screen, scrn,
|
|
|
|
PDTA_ScaleQuality, nsoption_bool(scale_quality),
|
2012-08-05 19:22:41 +04:00
|
|
|
PDTA_DitherQuality, nsoption_int(dither_quality),
|
2012-08-06 00:46:14 +04:00
|
|
|
PDTA_FreeSourceBitMap, TRUE,
|
2012-08-05 19:16:18 +04:00
|
|
|
TAG_DONE);
|
2012-08-05 18:16:02 +04:00
|
|
|
|
2012-08-05 19:16:18 +04:00
|
|
|
if((bitmap->width != width) || (bitmap->height != height)) {
|
|
|
|
IDoMethod(bitmap->dto, PDTM_SCALE, width, height, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if((DoDTMethod(bitmap->dto, 0, 0, DTM_PROCLAYOUT, 0, 1)) == 0)
|
|
|
|
return NULL;
|
2012-08-05 18:29:20 +04:00
|
|
|
}
|
|
|
|
|
2012-08-05 19:16:18 +04:00
|
|
|
GetDTAttrs(bitmap->dto,
|
|
|
|
PDTA_DestBitMap, &dtbm,
|
|
|
|
TAG_END);
|
|
|
|
|
2012-08-05 18:29:20 +04:00
|
|
|
bitmap->nativebmwidth = width;
|
|
|
|
bitmap->nativebmheight = height;
|
2012-08-10 01:31:10 +04:00
|
|
|
|
2012-08-05 18:16:02 +04:00
|
|
|
return dtbm;
|
|
|
|
}
|
2012-08-08 00:28:55 +04:00
|
|
|
|
|
|
|
struct BitMap *ami_bitmap_get_native(struct bitmap *bitmap,
|
|
|
|
int width, int height, struct BitMap *friendbm)
|
|
|
|
{
|
2015-03-01 14:48:21 +03:00
|
|
|
if(__builtin_expect(ami_plot_screen_is_palettemapped() == true, 0)) {
|
2012-08-08 00:28:55 +04:00
|
|
|
return ami_bitmap_get_palettemapped(bitmap, width, height);
|
|
|
|
} else {
|
2012-08-08 00:34:52 +04:00
|
|
|
return ami_bitmap_get_truecolour(bitmap, width, height, friendbm);
|
2012-08-08 00:28:55 +04:00
|
|
|
}
|
|
|
|
}
|
2015-01-20 03:39:32 +03:00
|
|
|
|
2015-04-24 13:56:19 +03:00
|
|
|
static nserror bitmap_render(struct bitmap *bitmap, hlcache_handle *content)
|
|
|
|
{
|
|
|
|
int plot_width;
|
|
|
|
int plot_height;
|
2015-04-25 15:13:30 +03:00
|
|
|
struct MinList shared_pens;
|
|
|
|
struct gui_globals bm_globals;
|
2015-04-27 20:32:49 +03:00
|
|
|
struct gui_globals *temp_gg = glob;
|
2015-04-25 15:13:30 +03:00
|
|
|
|
2015-04-24 13:56:19 +03:00
|
|
|
struct redraw_context ctx = {
|
|
|
|
.interactive = false,
|
|
|
|
.background_images = true,
|
|
|
|
.plot = &amiplot
|
|
|
|
};
|
|
|
|
|
2015-04-25 15:13:30 +03:00
|
|
|
plot_width = MIN(content_get_width(content), bitmap->width);
|
2015-04-24 13:56:19 +03:00
|
|
|
plot_height = ((plot_width * bitmap->height) + (bitmap->width / 2)) /
|
|
|
|
bitmap->width;
|
|
|
|
|
2015-04-25 15:13:30 +03:00
|
|
|
ami_init_layers(&bm_globals, bitmap->width, bitmap->height);
|
2015-08-06 01:42:20 +03:00
|
|
|
ami_NewMinList(&shared_pens);
|
2015-04-25 15:13:30 +03:00
|
|
|
bm_globals.shared_pens = &shared_pens;
|
2015-04-24 13:56:19 +03:00
|
|
|
|
2015-04-25 15:13:30 +03:00
|
|
|
glob = &bm_globals;
|
|
|
|
ami_clearclipreg(&bm_globals);
|
2015-04-24 13:56:19 +03:00
|
|
|
|
|
|
|
content_scaled_redraw(content, plot_width, plot_height, &ctx);
|
|
|
|
|
|
|
|
#ifdef __amigaos4__
|
2015-04-25 15:13:30 +03:00
|
|
|
BltBitMapTags( BLITA_SrcX, 0,
|
|
|
|
BLITA_SrcY, 0,
|
|
|
|
BLITA_Width, bitmap->width,
|
|
|
|
BLITA_Height, bitmap->height,
|
|
|
|
BLITA_Source, bm_globals.bm,
|
|
|
|
BLITA_SrcType, BLITT_BITMAP,
|
|
|
|
BLITA_Dest, bitmap->pixdata,
|
|
|
|
BLITA_DestType, BLITT_ARGB32,
|
|
|
|
BLITA_DestBytesPerRow, 4 * bitmap->width,
|
|
|
|
BLITA_DestX, 0,
|
|
|
|
BLITA_DestY, 0,
|
2015-04-24 13:56:19 +03:00
|
|
|
TAG_DONE);
|
2015-04-25 15:13:30 +03:00
|
|
|
|
|
|
|
ami_bitmap_argb_to_rgba(bitmap);
|
|
|
|
#else
|
|
|
|
#warning FIXME for OS3
|
2015-04-24 13:56:19 +03:00
|
|
|
#endif
|
|
|
|
|
2015-04-25 15:13:30 +03:00
|
|
|
/**\todo In theory we should be able to move the bitmap to our native area
|
2015-04-27 20:32:49 +03:00
|
|
|
to try to avoid re-conversion (at the expense of memory) */
|
2015-04-25 15:13:30 +03:00
|
|
|
|
|
|
|
ami_free_layers(&bm_globals);
|
|
|
|
ami_plot_release_pens(&shared_pens);
|
|
|
|
amiga_bitmap_set_opaque(bitmap, true);
|
|
|
|
|
2015-04-27 20:32:49 +03:00
|
|
|
/* Restore previous render area. This is set when plotting starts,
|
|
|
|
* but if bitmap_render is called *during* a browser render then
|
|
|
|
* having an invalid pointer here causes NetSurf to crash.
|
|
|
|
*/
|
|
|
|
glob = temp_gg;
|
|
|
|
|
2015-04-25 15:13:30 +03:00
|
|
|
return NSERROR_OK;
|
2015-04-24 13:56:19 +03:00
|
|
|
}
|
|
|
|
|
2016-01-21 23:30:02 +03:00
|
|
|
void amiga_bitmap_fini(void)
|
|
|
|
{
|
|
|
|
if(pool_bitmap) ami_misc_itempool_delete(pool_bitmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool amiga_bitmap_init(void)
|
|
|
|
{
|
|
|
|
if((pool_bitmap = ami_misc_itempool_create(sizeof(struct bitmap)))) {
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-17 00:36:29 +03:00
|
|
|
static struct gui_bitmap_table bitmap_table = {
|
|
|
|
.create = amiga_bitmap_create,
|
|
|
|
.destroy = amiga_bitmap_destroy,
|
|
|
|
.set_opaque = amiga_bitmap_set_opaque,
|
|
|
|
.get_opaque = amiga_bitmap_get_opaque,
|
|
|
|
.test_opaque = amiga_bitmap_test_opaque,
|
|
|
|
.get_buffer = amiga_bitmap_get_buffer,
|
|
|
|
.get_rowstride = amiga_bitmap_get_rowstride,
|
|
|
|
.get_width = bitmap_get_width,
|
|
|
|
.get_height = bitmap_get_height,
|
|
|
|
.get_bpp = bitmap_get_bpp,
|
|
|
|
.save = amiga_bitmap_save,
|
|
|
|
.modified = amiga_bitmap_modified,
|
2015-04-24 13:56:19 +03:00
|
|
|
.render = bitmap_render,
|
2015-04-17 00:36:29 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct gui_bitmap_table *amiga_bitmap_table = &bitmap_table;
|