4285 lines
117 KiB
C
4285 lines
117 KiB
C
/*
|
|
*
|
|
* Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
|
|
* 2005 Lars Knoll & Zack Rusin, Trolltech
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of Keith Packard not be used in
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
* specific, written prior permission. Keith Packard makes no
|
|
* representations about the suitability of this software for any purpose. It
|
|
* is provided "as is" without express or implied warranty.
|
|
*
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
|
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
|
|
* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
|
|
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
#include <dix-config.h>
|
|
#endif
|
|
|
|
#include "fb.h"
|
|
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <assert.h>
|
|
|
|
#include "picturestr.h"
|
|
#include "mipict.h"
|
|
#include "fbpict.h"
|
|
|
|
#define mod(a,b) ((b) == 1 ? 0 : (a) >= 0 ? (a) % (b) : (b) - (-a) % (b))
|
|
|
|
#define SCANLINE_BUFFER_LENGTH 2048
|
|
|
|
typedef FASTCALL void (*fetchProc) (const FbBits * bits, int x, int width,
|
|
CARD32 *buffer, miIndexedPtr indexed);
|
|
|
|
/*
|
|
* All of the fetch functions
|
|
*/
|
|
|
|
static FASTCALL void
|
|
fbFetch_a8r8g8b8(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
memcpy(buffer, (const CARD32 *) bits + x, width * sizeof(CARD32));
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_x8r8g8b8(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD32 *pixel = (const CARD32 *) bits + x;
|
|
|
|
const CARD32 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
*buffer++ = *pixel++ | 0xff000000;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a8b8g8r8(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD32 *pixel = (CARD32 *) bits + x;
|
|
|
|
const CARD32 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
*buffer++ = ((*pixel & 0xff00ff00) |
|
|
((*pixel >> 16) & 0xff) | ((*pixel & 0xff) << 16));
|
|
++pixel;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_x8b8g8r8(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD32 *pixel = (CARD32 *) bits + x;
|
|
|
|
const CARD32 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
*buffer++ = 0xff000000 |
|
|
((*pixel & 0x0000ff00) |
|
|
((*pixel >> 16) & 0xff) | ((*pixel & 0xff) << 16));
|
|
++pixel;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_r8g8b8(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD8 *pixel = (const CARD8 *) bits + 3 * x;
|
|
|
|
const CARD8 *end = pixel + 3 * width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 b = Fetch24(pixel) | 0xff000000;
|
|
|
|
pixel += 3;
|
|
*buffer++ = b;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_b8g8r8(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD8 *pixel = (const CARD8 *) bits + 3 * x;
|
|
|
|
const CARD8 *end = pixel + 3 * width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 b = 0xff000000;
|
|
|
|
#if IMAGE_BYTE_ORDER == MSBFirst
|
|
b |= (*pixel++);
|
|
b |= (*pixel++ << 8);
|
|
b |= (*pixel++ << 16);
|
|
#else
|
|
b |= (*pixel++ << 16);
|
|
b |= (*pixel++ << 8);
|
|
b |= (*pixel++);
|
|
#endif
|
|
*buffer++ = b;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_r5g6b5(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD16 *pixel = (const CARD16 *) bits + x;
|
|
|
|
const CARD16 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r = (((p) << 3) & 0xf8) |
|
|
(((p) << 5) & 0xfc00) | (((p) << 8) & 0xf80000);
|
|
r |= (r >> 5) & 0x70007;
|
|
r |= (r >> 6) & 0x300;
|
|
*buffer++ = 0xff000000 | r;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_b5g6r5(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD16 *pixel = (const CARD16 *) bits + x;
|
|
|
|
const CARD16 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b;
|
|
|
|
b = ((p & 0xf800) | ((p & 0xe000) >> 5)) >> 8;
|
|
g = ((p & 0x07e0) | ((p & 0x0600) >> 6)) << 5;
|
|
r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
|
|
*buffer++ = (0xff000000 | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a1r5g5b5(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD16 *pixel = (const CARD16 *) bits + x;
|
|
|
|
const CARD16 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b, a;
|
|
|
|
a = (CARD32) ((CARD8) (0 - ((p & 0x8000) >> 15))) << 24;
|
|
r = ((p & 0x7c00) | ((p & 0x7000) >> 5)) << 9;
|
|
g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
|
|
b = ((p & 0x001c) | ((p & 0x001f) << 5)) >> 2;
|
|
*buffer++ = (a | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_x1r5g5b5(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD16 *pixel = (const CARD16 *) bits + x;
|
|
|
|
const CARD16 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b;
|
|
|
|
r = ((p & 0x7c00) | ((p & 0x7000) >> 5)) << 9;
|
|
g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
|
|
b = ((p & 0x001c) | ((p & 0x001f) << 5)) >> 2;
|
|
*buffer++ = (0xff000000 | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a1b5g5r5(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD16 *pixel = (const CARD16 *) bits + x;
|
|
|
|
const CARD16 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b, a;
|
|
|
|
a = (CARD32) ((CARD8) (0 - ((p & 0x8000) >> 15))) << 24;
|
|
b = ((p & 0x7c00) | ((p & 0x7000) >> 5)) >> 7;
|
|
g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
|
|
r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
|
|
*buffer++ = (a | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_x1b5g5r5(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD16 *pixel = (const CARD16 *) bits + x;
|
|
|
|
const CARD16 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b;
|
|
|
|
b = ((p & 0x7c00) | ((p & 0x7000) >> 5)) >> 7;
|
|
g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
|
|
r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
|
|
*buffer++ = (0xff000000 | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a4r4g4b4(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD16 *pixel = (const CARD16 *) bits + x;
|
|
|
|
const CARD16 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b, a;
|
|
|
|
a = ((p & 0xf000) | ((p & 0xf000) >> 4)) << 16;
|
|
r = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
|
|
g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
|
|
b = ((p & 0x000f) | ((p & 0x000f) << 4));
|
|
*buffer++ = (a | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_x4r4g4b4(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD16 *pixel = (const CARD16 *) bits + x;
|
|
|
|
const CARD16 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b;
|
|
|
|
r = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
|
|
g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
|
|
b = ((p & 0x000f) | ((p & 0x000f) << 4));
|
|
*buffer++ = (0xff000000 | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a4b4g4r4(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD16 *pixel = (const CARD16 *) bits + x;
|
|
|
|
const CARD16 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b, a;
|
|
|
|
a = ((p & 0xf000) | ((p & 0xf000) >> 4)) << 16;
|
|
b = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) >> 4;
|
|
g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
|
|
r = ((p & 0x000f) | ((p & 0x000f) << 4)) << 16;
|
|
*buffer++ = (a | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_x4b4g4r4(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD16 *pixel = (const CARD16 *) bits + x;
|
|
|
|
const CARD16 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b;
|
|
|
|
b = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) >> 4;
|
|
g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
|
|
r = ((p & 0x000f) | ((p & 0x000f) << 4)) << 16;
|
|
*buffer++ = (0xff000000 | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a8(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD8 *pixel = (const CARD8 *) bits + x;
|
|
|
|
const CARD8 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
*buffer++ = (*pixel++) << 24;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_r3g3b2(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD8 *pixel = (const CARD8 *) bits + x;
|
|
|
|
const CARD8 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b;
|
|
|
|
r = ((p & 0xe0) | ((p & 0xe0) >> 3) | ((p & 0xc0) >> 6)) << 16;
|
|
g = ((p & 0x1c) | ((p & 0x18) >> 3) | ((p & 0x1c) << 3)) << 8;
|
|
b = (((p & 0x03)) |
|
|
((p & 0x03) << 2) | ((p & 0x03) << 4) | ((p & 0x03) << 6));
|
|
*buffer++ = (0xff000000 | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_b2g3r3(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD8 *pixel = (const CARD8 *) bits + x;
|
|
|
|
const CARD8 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 r, g, b;
|
|
|
|
b = (((p & 0xc0)) |
|
|
((p & 0xc0) >> 2) | ((p & 0xc0) >> 4) | ((p & 0xc0) >> 6));
|
|
g = ((p & 0x38) | ((p & 0x38) >> 3) | ((p & 0x30) << 2)) << 8;
|
|
r = (((p & 0x07)) | ((p & 0x07) << 3) | ((p & 0x06) << 6)) << 16;
|
|
*buffer++ = (0xff000000 | r | g | b);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a2r2g2b2(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD8 *pixel = (const CARD8 *) bits + x;
|
|
|
|
const CARD8 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = ((p & 0xc0) * 0x55) << 18;
|
|
r = ((p & 0x30) * 0x55) << 12;
|
|
g = ((p & 0x0c) * 0x55) << 6;
|
|
b = ((p & 0x03) * 0x55);
|
|
*buffer++ = a | r | g | b;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a2b2g2r2(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD8 *pixel = (const CARD8 *) bits + x;
|
|
|
|
const CARD8 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = ((p & 0xc0) * 0x55) << 18;
|
|
b = ((p & 0x30) * 0x55) >> 6;
|
|
g = ((p & 0x0c) * 0x55) << 6;
|
|
r = ((p & 0x03) * 0x55) << 16;
|
|
*buffer++ = a | r | g | b;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_c8(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD8 *pixel = (const CARD8 *) bits + x;
|
|
|
|
const CARD8 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD32 p = *pixel++;
|
|
|
|
*buffer++ = indexed->rgba[p];
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_x4a4(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
const CARD8 *pixel = (const CARD8 *) bits + x;
|
|
|
|
const CARD8 *end = pixel + width;
|
|
|
|
while (pixel < end) {
|
|
CARD8 p = (*pixel++) & 0xf;
|
|
|
|
*buffer++ = (p | (p << 4)) << 24;
|
|
}
|
|
}
|
|
|
|
#define Fetch8(l,o) (((CARD8 *) (l))[(o) >> 2])
|
|
#if IMAGE_BYTE_ORDER == MSBFirst
|
|
#define Fetch4(l,o) ((o) & 2 ? Fetch8(l,o) & 0xf : Fetch8(l,o) >> 4)
|
|
#else
|
|
#define Fetch4(l,o) ((o) & 2 ? Fetch8(l,o) >> 4 : Fetch8(l,o) & 0xf)
|
|
#endif
|
|
|
|
static FASTCALL void
|
|
fbFetch_a4(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 p = Fetch4(bits, i + x);
|
|
|
|
p |= p << 4;
|
|
*buffer++ = p << 24;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_r1g2b1(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 p = Fetch4(bits, i + x);
|
|
|
|
CARD32 r, g, b;
|
|
|
|
r = ((p & 0x8) * 0xff) << 13;
|
|
g = ((p & 0x6) * 0x55) << 7;
|
|
b = ((p & 0x1) * 0xff);
|
|
*buffer++ = 0xff000000 | r | g | b;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_b1g2r1(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 p = Fetch4(bits, i + x);
|
|
|
|
CARD32 r, g, b;
|
|
|
|
b = ((p & 0x8) * 0xff) >> 3;
|
|
g = ((p & 0x6) * 0x55) << 7;
|
|
r = ((p & 0x1) * 0xff) << 16;
|
|
*buffer++ = 0xff000000 | r | g | b;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a1r1g1b1(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 p = Fetch4(bits, i + x);
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = ((p & 0x8) * 0xff) << 21;
|
|
r = ((p & 0x4) * 0xff) << 14;
|
|
g = ((p & 0x2) * 0xff) << 7;
|
|
b = ((p & 0x1) * 0xff);
|
|
*buffer++ = a | r | g | b;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a1b1g1r1(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 p = Fetch4(bits, i + x);
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = ((p & 0x8) * 0xff) << 21;
|
|
r = ((p & 0x4) * 0xff) >> 3;
|
|
g = ((p & 0x2) * 0xff) << 7;
|
|
b = ((p & 0x1) * 0xff) << 16;
|
|
*buffer++ = a | r | g | b;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_c4(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 p = Fetch4(bits, i + x);
|
|
|
|
*buffer++ = indexed->rgba[p];
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_a1(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 p = ((CARD32 *) bits)[(i + x) >> 5];
|
|
|
|
CARD32 a;
|
|
|
|
#if BITMAP_BIT_ORDER == MSBFirst
|
|
a = p >> (0x1f - ((i + x) & 0x1f));
|
|
#else
|
|
a = p >> ((i + x) & 0x1f);
|
|
#endif
|
|
a = a & 1;
|
|
a |= a << 1;
|
|
a |= a << 2;
|
|
a |= a << 4;
|
|
*buffer++ = a << 24;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbFetch_g1(const FbBits * bits, int x, int width, CARD32 *buffer,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 p = ((CARD32 *) bits)[(i + x) >> 5];
|
|
|
|
CARD32 a;
|
|
|
|
#if BITMAP_BIT_ORDER == MSBFirst
|
|
a = p >> (0x1f - ((i + x) & 0x1f));
|
|
#else
|
|
a = p >> ((i + x) & 0x1f);
|
|
#endif
|
|
a = a & 1;
|
|
*buffer++ = indexed->rgba[a];
|
|
}
|
|
}
|
|
|
|
static fetchProc
|
|
fetchProcForPicture(PicturePtr pict)
|
|
{
|
|
switch (pict->format) {
|
|
case PICT_a8r8g8b8:
|
|
return fbFetch_a8r8g8b8;
|
|
case PICT_x8r8g8b8:
|
|
return fbFetch_x8r8g8b8;
|
|
case PICT_a8b8g8r8:
|
|
return fbFetch_a8b8g8r8;
|
|
case PICT_x8b8g8r8:
|
|
return fbFetch_x8b8g8r8;
|
|
|
|
/* 24bpp formats */
|
|
case PICT_r8g8b8:
|
|
return fbFetch_r8g8b8;
|
|
case PICT_b8g8r8:
|
|
return fbFetch_b8g8r8;
|
|
|
|
/* 16bpp formats */
|
|
case PICT_r5g6b5:
|
|
return fbFetch_r5g6b5;
|
|
case PICT_b5g6r5:
|
|
return fbFetch_b5g6r5;
|
|
|
|
case PICT_a1r5g5b5:
|
|
return fbFetch_a1r5g5b5;
|
|
case PICT_x1r5g5b5:
|
|
return fbFetch_x1r5g5b5;
|
|
case PICT_a1b5g5r5:
|
|
return fbFetch_a1b5g5r5;
|
|
case PICT_x1b5g5r5:
|
|
return fbFetch_x1b5g5r5;
|
|
case PICT_a4r4g4b4:
|
|
return fbFetch_a4r4g4b4;
|
|
case PICT_x4r4g4b4:
|
|
return fbFetch_x4r4g4b4;
|
|
case PICT_a4b4g4r4:
|
|
return fbFetch_a4b4g4r4;
|
|
case PICT_x4b4g4r4:
|
|
return fbFetch_x4b4g4r4;
|
|
|
|
/* 8bpp formats */
|
|
case PICT_a8:
|
|
return fbFetch_a8;
|
|
case PICT_r3g3b2:
|
|
return fbFetch_r3g3b2;
|
|
case PICT_b2g3r3:
|
|
return fbFetch_b2g3r3;
|
|
case PICT_a2r2g2b2:
|
|
return fbFetch_a2r2g2b2;
|
|
case PICT_a2b2g2r2:
|
|
return fbFetch_a2b2g2r2;
|
|
case PICT_c8:
|
|
return fbFetch_c8;
|
|
case PICT_g8:
|
|
return fbFetch_c8;
|
|
case PICT_x4a4:
|
|
return fbFetch_x4a4;
|
|
|
|
/* 4bpp formats */
|
|
case PICT_a4:
|
|
return fbFetch_a4;
|
|
case PICT_r1g2b1:
|
|
return fbFetch_r1g2b1;
|
|
case PICT_b1g2r1:
|
|
return fbFetch_b1g2r1;
|
|
case PICT_a1r1g1b1:
|
|
return fbFetch_a1r1g1b1;
|
|
case PICT_a1b1g1r1:
|
|
return fbFetch_a1b1g1r1;
|
|
case PICT_c4:
|
|
return fbFetch_c4;
|
|
case PICT_g4:
|
|
return fbFetch_c4;
|
|
|
|
/* 1bpp formats */
|
|
case PICT_a1:
|
|
return fbFetch_a1;
|
|
case PICT_g1:
|
|
return fbFetch_g1;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Pixel wise fetching
|
|
*/
|
|
|
|
typedef FASTCALL CARD32 (*fetchPixelProc) (const FbBits * bits, int offset,
|
|
miIndexedPtr indexed);
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a8r8g8b8(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
return ((CARD32 *) bits)[offset];
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_x8r8g8b8(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
return ((CARD32 *) bits)[offset] | 0xff000000;
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a8b8g8r8(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD32 *) bits)[offset];
|
|
|
|
return ((pixel & 0xff000000) |
|
|
((pixel >> 16) & 0xff) |
|
|
(pixel & 0x0000ff00) | ((pixel & 0xff) << 16));
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_x8b8g8r8(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD32 *) bits)[offset];
|
|
|
|
return ((0xff000000) |
|
|
((pixel >> 16) & 0xff) |
|
|
(pixel & 0x0000ff00) | ((pixel & 0xff) << 16));
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_r8g8b8(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD8 *pixel = ((CARD8 *) bits) + (offset * 3);
|
|
|
|
#if IMAGE_BYTE_ORDER == MSBFirst
|
|
return (0xff000000 | (pixel[0] << 16) | (pixel[1] << 8) | (pixel[2]));
|
|
#else
|
|
return (0xff000000 | (pixel[2] << 16) | (pixel[1] << 8) | (pixel[0]));
|
|
#endif
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_b8g8r8(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD8 *pixel = ((CARD8 *) bits) + (offset * 3);
|
|
|
|
#if IMAGE_BYTE_ORDER == MSBFirst
|
|
return (0xff000000 | (pixel[2] << 16) | (pixel[1] << 8) | (pixel[0]));
|
|
#else
|
|
return (0xff000000 | (pixel[0] << 16) | (pixel[1] << 8) | (pixel[2]));
|
|
#endif
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_r5g6b5(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD16 *) bits)[offset];
|
|
|
|
CARD32 r, g, b;
|
|
|
|
r = ((pixel & 0xf800) | ((pixel & 0xe000) >> 5)) << 8;
|
|
g = ((pixel & 0x07e0) | ((pixel & 0x0600) >> 6)) << 5;
|
|
b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
|
|
return (0xff000000 | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_b5g6r5(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD16 *) bits)[offset];
|
|
|
|
CARD32 r, g, b;
|
|
|
|
b = ((pixel & 0xf800) | ((pixel & 0xe000) >> 5)) >> 8;
|
|
g = ((pixel & 0x07e0) | ((pixel & 0x0600) >> 6)) << 5;
|
|
r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
|
|
return (0xff000000 | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a1r5g5b5(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD16 *) bits)[offset];
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = (CARD32) ((CARD8) (0 - ((pixel & 0x8000) >> 15))) << 24;
|
|
r = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) << 9;
|
|
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
|
|
b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
|
|
return (a | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_x1r5g5b5(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD16 *) bits)[offset];
|
|
|
|
CARD32 r, g, b;
|
|
|
|
r = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) << 9;
|
|
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
|
|
b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
|
|
return (0xff000000 | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a1b5g5r5(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD16 *) bits)[offset];
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = (CARD32) ((CARD8) (0 - ((pixel & 0x8000) >> 15))) << 24;
|
|
b = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) >> 7;
|
|
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
|
|
r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
|
|
return (a | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_x1b5g5r5(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD16 *) bits)[offset];
|
|
|
|
CARD32 r, g, b;
|
|
|
|
b = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) >> 7;
|
|
g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
|
|
r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
|
|
return (0xff000000 | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a4r4g4b4(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD16 *) bits)[offset];
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = ((pixel & 0xf000) | ((pixel & 0xf000) >> 4)) << 16;
|
|
r = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
|
|
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
|
|
b = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
|
|
return (a | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_x4r4g4b4(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD16 *) bits)[offset];
|
|
|
|
CARD32 r, g, b;
|
|
|
|
r = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
|
|
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
|
|
b = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
|
|
return (0xff000000 | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a4b4g4r4(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD16 *) bits)[offset];
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = ((pixel & 0xf000) | ((pixel & 0xf000) >> 4)) << 16;
|
|
b = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) >> 4;
|
|
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
|
|
r = ((pixel & 0x000f) | ((pixel & 0x000f) << 4)) << 16;
|
|
return (a | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_x4b4g4r4(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD16 *) bits)[offset];
|
|
|
|
CARD32 r, g, b;
|
|
|
|
b = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) >> 4;
|
|
g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
|
|
r = ((pixel & 0x000f) | ((pixel & 0x000f) << 4)) << 16;
|
|
return (0xff000000 | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a8(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD8 *) bits)[offset];
|
|
|
|
return pixel << 24;
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_r3g3b2(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD8 *) bits)[offset];
|
|
|
|
CARD32 r, g, b;
|
|
|
|
r = ((pixel & 0xe0) | ((pixel & 0xe0) >> 3) | ((pixel & 0xc0) >> 6)) << 16;
|
|
g = ((pixel & 0x1c) | ((pixel & 0x18) >> 3) | ((pixel & 0x1c) << 3)) << 8;
|
|
b = (((pixel & 0x03)) |
|
|
((pixel & 0x03) << 2) | ((pixel & 0x03) << 4) | ((pixel & 0x03) << 6));
|
|
return (0xff000000 | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_b2g3r3(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD8 *) bits)[offset];
|
|
|
|
CARD32 r, g, b;
|
|
|
|
b = (((pixel & 0xc0)) |
|
|
((pixel & 0xc0) >> 2) | ((pixel & 0xc0) >> 4) | ((pixel & 0xc0) >> 6));
|
|
g = ((pixel & 0x38) | ((pixel & 0x38) >> 3) | ((pixel & 0x30) << 2)) << 8;
|
|
r = (((pixel & 0x07)) |
|
|
((pixel & 0x07) << 3) | ((pixel & 0x06) << 6)) << 16;
|
|
return (0xff000000 | r | g | b);
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a2r2g2b2(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD8 *) bits)[offset];
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = ((pixel & 0xc0) * 0x55) << 18;
|
|
r = ((pixel & 0x30) * 0x55) << 12;
|
|
g = ((pixel & 0x0c) * 0x55) << 6;
|
|
b = ((pixel & 0x03) * 0x55);
|
|
return a | r | g | b;
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a2b2g2r2(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD8 *) bits)[offset];
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = ((pixel & 0xc0) * 0x55) << 18;
|
|
b = ((pixel & 0x30) * 0x55) >> 6;
|
|
g = ((pixel & 0x0c) * 0x55) << 6;
|
|
r = ((pixel & 0x03) * 0x55) << 16;
|
|
return a | r | g | b;
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_c8(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD8 *) bits)[offset];
|
|
|
|
return indexed->rgba[pixel];
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_x4a4(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD8 *) bits)[offset];
|
|
|
|
return ((pixel & 0xf) | ((pixel & 0xf) << 4)) << 24;
|
|
}
|
|
|
|
#define Fetch8(l,o) (((CARD8 *) (l))[(o) >> 2])
|
|
#if IMAGE_BYTE_ORDER == MSBFirst
|
|
#define Fetch4(l,o) ((o) & 2 ? Fetch8(l,o) & 0xf : Fetch8(l,o) >> 4)
|
|
#else
|
|
#define Fetch4(l,o) ((o) & 2 ? Fetch8(l,o) >> 4 : Fetch8(l,o) & 0xf)
|
|
#endif
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a4(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = Fetch4(bits, offset);
|
|
|
|
pixel |= pixel << 4;
|
|
return pixel << 24;
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_r1g2b1(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = Fetch4(bits, offset);
|
|
|
|
CARD32 r, g, b;
|
|
|
|
r = ((pixel & 0x8) * 0xff) << 13;
|
|
g = ((pixel & 0x6) * 0x55) << 7;
|
|
b = ((pixel & 0x1) * 0xff);
|
|
return 0xff000000 | r | g | b;
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_b1g2r1(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = Fetch4(bits, offset);
|
|
|
|
CARD32 r, g, b;
|
|
|
|
b = ((pixel & 0x8) * 0xff) >> 3;
|
|
g = ((pixel & 0x6) * 0x55) << 7;
|
|
r = ((pixel & 0x1) * 0xff) << 16;
|
|
return 0xff000000 | r | g | b;
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a1r1g1b1(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = Fetch4(bits, offset);
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = ((pixel & 0x8) * 0xff) << 21;
|
|
r = ((pixel & 0x4) * 0xff) << 14;
|
|
g = ((pixel & 0x2) * 0xff) << 7;
|
|
b = ((pixel & 0x1) * 0xff);
|
|
return a | r | g | b;
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a1b1g1r1(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = Fetch4(bits, offset);
|
|
|
|
CARD32 a, r, g, b;
|
|
|
|
a = ((pixel & 0x8) * 0xff) << 21;
|
|
r = ((pixel & 0x4) * 0xff) >> 3;
|
|
g = ((pixel & 0x2) * 0xff) << 7;
|
|
b = ((pixel & 0x1) * 0xff) << 16;
|
|
return a | r | g | b;
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_c4(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = Fetch4(bits, offset);
|
|
|
|
return indexed->rgba[pixel];
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_a1(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD32 *) bits)[offset >> 5];
|
|
|
|
CARD32 a;
|
|
|
|
#if BITMAP_BIT_ORDER == MSBFirst
|
|
a = pixel >> (0x1f - (offset & 0x1f));
|
|
#else
|
|
a = pixel >> (offset & 0x1f);
|
|
#endif
|
|
a = a & 1;
|
|
a |= a << 1;
|
|
a |= a << 2;
|
|
a |= a << 4;
|
|
return a << 24;
|
|
}
|
|
|
|
static FASTCALL CARD32
|
|
fbFetchPixel_g1(const FbBits * bits, int offset, miIndexedPtr indexed)
|
|
{
|
|
CARD32 pixel = ((CARD32 *) bits)[offset >> 5];
|
|
|
|
CARD32 a;
|
|
|
|
#if BITMAP_BIT_ORDER == MSBFirst
|
|
a = pixel >> (0x1f - (offset & 0x1f));
|
|
#else
|
|
a = pixel >> (offset & 0x1f);
|
|
#endif
|
|
a = a & 1;
|
|
return indexed->rgba[a];
|
|
}
|
|
|
|
static fetchPixelProc
|
|
fetchPixelProcForPicture(PicturePtr pict)
|
|
{
|
|
switch (pict->format) {
|
|
case PICT_a8r8g8b8:
|
|
return fbFetchPixel_a8r8g8b8;
|
|
case PICT_x8r8g8b8:
|
|
return fbFetchPixel_x8r8g8b8;
|
|
case PICT_a8b8g8r8:
|
|
return fbFetchPixel_a8b8g8r8;
|
|
case PICT_x8b8g8r8:
|
|
return fbFetchPixel_x8b8g8r8;
|
|
|
|
/* 24bpp formats */
|
|
case PICT_r8g8b8:
|
|
return fbFetchPixel_r8g8b8;
|
|
case PICT_b8g8r8:
|
|
return fbFetchPixel_b8g8r8;
|
|
|
|
/* 16bpp formats */
|
|
case PICT_r5g6b5:
|
|
return fbFetchPixel_r5g6b5;
|
|
case PICT_b5g6r5:
|
|
return fbFetchPixel_b5g6r5;
|
|
|
|
case PICT_a1r5g5b5:
|
|
return fbFetchPixel_a1r5g5b5;
|
|
case PICT_x1r5g5b5:
|
|
return fbFetchPixel_x1r5g5b5;
|
|
case PICT_a1b5g5r5:
|
|
return fbFetchPixel_a1b5g5r5;
|
|
case PICT_x1b5g5r5:
|
|
return fbFetchPixel_x1b5g5r5;
|
|
case PICT_a4r4g4b4:
|
|
return fbFetchPixel_a4r4g4b4;
|
|
case PICT_x4r4g4b4:
|
|
return fbFetchPixel_x4r4g4b4;
|
|
case PICT_a4b4g4r4:
|
|
return fbFetchPixel_a4b4g4r4;
|
|
case PICT_x4b4g4r4:
|
|
return fbFetchPixel_x4b4g4r4;
|
|
|
|
/* 8bpp formats */
|
|
case PICT_a8:
|
|
return fbFetchPixel_a8;
|
|
case PICT_r3g3b2:
|
|
return fbFetchPixel_r3g3b2;
|
|
case PICT_b2g3r3:
|
|
return fbFetchPixel_b2g3r3;
|
|
case PICT_a2r2g2b2:
|
|
return fbFetchPixel_a2r2g2b2;
|
|
case PICT_a2b2g2r2:
|
|
return fbFetchPixel_a2b2g2r2;
|
|
case PICT_c8:
|
|
return fbFetchPixel_c8;
|
|
case PICT_g8:
|
|
return fbFetchPixel_c8;
|
|
case PICT_x4a4:
|
|
return fbFetchPixel_x4a4;
|
|
|
|
/* 4bpp formats */
|
|
case PICT_a4:
|
|
return fbFetchPixel_a4;
|
|
case PICT_r1g2b1:
|
|
return fbFetchPixel_r1g2b1;
|
|
case PICT_b1g2r1:
|
|
return fbFetchPixel_b1g2r1;
|
|
case PICT_a1r1g1b1:
|
|
return fbFetchPixel_a1r1g1b1;
|
|
case PICT_a1b1g1r1:
|
|
return fbFetchPixel_a1b1g1r1;
|
|
case PICT_c4:
|
|
return fbFetchPixel_c4;
|
|
case PICT_g4:
|
|
return fbFetchPixel_c4;
|
|
|
|
/* 1bpp formats */
|
|
case PICT_a1:
|
|
return fbFetchPixel_a1;
|
|
case PICT_g1:
|
|
return fbFetchPixel_g1;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* All the store functions
|
|
*/
|
|
|
|
typedef FASTCALL void (*storeProc) (FbBits * bits, const CARD32 *values, int x,
|
|
int width, miIndexedPtr indexed);
|
|
|
|
#define Splita(v) CARD32 a = ((v) >> 24), r = ((v) >> 16) & 0xff, g = ((v) >> 8) & 0xff, b = (v) & 0xff
|
|
#define Split(v) CARD32 r = ((v) >> 16) & 0xff, g = ((v) >> 8) & 0xff, b = (v) & 0xff
|
|
|
|
static FASTCALL void
|
|
fbStore_a8r8g8b8(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
memcpy(((CARD32 *) bits) + x, values, width * sizeof(CARD32));
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_x8r8g8b8(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD32 *pixel = (CARD32 *) bits + x;
|
|
|
|
for (i = 0; i < width; ++i)
|
|
*pixel++ = values[i] & 0xffffff;
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_a8b8g8r8(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD32 *pixel = (CARD32 *) bits + x;
|
|
|
|
for (i = 0; i < width; ++i)
|
|
*pixel++ =
|
|
(values[i] & 0xff00ff00) | ((values[i] >> 16) & 0xff) |
|
|
((values[i] & 0xff) << 16);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_x8b8g8r8(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD32 *pixel = (CARD32 *) bits + x;
|
|
|
|
for (i = 0; i < width; ++i)
|
|
*pixel++ =
|
|
(values[i] & 0x0000ff00) | ((values[i] >> 16) & 0xff) |
|
|
((values[i] & 0xff) << 16);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_r8g8b8(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD8 *pixel = ((CARD8 *) bits) + 3 * x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Store24(pixel, values[i]);
|
|
pixel += 3;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_b8g8r8(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD8 *pixel = ((CARD8 *) bits) + 3 * x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
#if IMAGE_BYTE_ORDER == MSBFirst
|
|
*pixel++ = Blue(values[i]);
|
|
*pixel++ = Green(values[i]);
|
|
*pixel++ = Red(values[i]);
|
|
#else
|
|
*pixel++ = Red(values[i]);
|
|
*pixel++ = Green(values[i]);
|
|
*pixel++ = Blue(values[i]);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_r5g6b5(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD16 *pixel = ((CARD16 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = values[i];
|
|
|
|
*pixel++ = ((s >> 3) & 0x001f) |
|
|
((s >> 5) & 0x07e0) | ((s >> 8) & 0xf800);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_b5g6r5(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD16 *pixel = ((CARD16 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Split(values[i]);
|
|
*pixel++ = (((b << 8) & 0xf800) | ((g << 3) & 0x07e0) | ((r >> 3)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_a1r5g5b5(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD16 *pixel = ((CARD16 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Splita(values[i]);
|
|
*pixel++ = (((a << 8) & 0x8000) |
|
|
((r << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((b >> 3)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_x1r5g5b5(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD16 *pixel = ((CARD16 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Split(values[i]);
|
|
*pixel++ = (((r << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((b >> 3)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_a1b5g5r5(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD16 *pixel = ((CARD16 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Splita(values[i]);
|
|
*pixel++ = (((a << 8) & 0x8000) |
|
|
((b << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((r >> 3)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_x1b5g5r5(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD16 *pixel = ((CARD16 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Split(values[i]);
|
|
*pixel++ = (((b << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((r >> 3)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_a4r4g4b4(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD16 *pixel = ((CARD16 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Splita(values[i]);
|
|
*pixel++ = (((a << 8) & 0xf000) |
|
|
((r << 4) & 0x0f00) | ((g) & 0x00f0) | ((b >> 4)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_x4r4g4b4(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD16 *pixel = ((CARD16 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Split(values[i]);
|
|
*pixel++ = (((r << 4) & 0x0f00) | ((g) & 0x00f0) | ((b >> 4)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_a4b4g4r4(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD16 *pixel = ((CARD16 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Splita(values[i]);
|
|
*pixel++ = (((a << 8) & 0xf000) |
|
|
((b << 4) & 0x0f00) | ((g) & 0x00f0) | ((r >> 4)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_x4b4g4r4(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD16 *pixel = ((CARD16 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Split(values[i]);
|
|
*pixel++ = (((b << 4) & 0x0f00) | ((g) & 0x00f0) | ((r >> 4)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_a8(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD8 *pixel = ((CARD8 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
*pixel++ = values[i] >> 24;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_r3g3b2(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD8 *pixel = ((CARD8 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Split(values[i]);
|
|
*pixel++ = (((r) & 0xe0) | ((g >> 3) & 0x1c) | ((b >> 6)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_b2g3r3(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD8 *pixel = ((CARD8 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Split(values[i]);
|
|
*pixel++ = (((b) & 0xe0) | ((g >> 3) & 0x1c) | ((r >> 6)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_a2r2g2b2(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD8 *pixel = ((CARD8 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Splita(values[i]);
|
|
*pixel++ = (((a) & 0xc0) |
|
|
((r >> 2) & 0x30) | ((g >> 4) & 0x0c) | ((b >> 6)));
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_c8(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD8 *pixel = ((CARD8 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
*pixel++ = miIndexToEnt24(indexed, values[i]);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_x4a4(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
CARD8 *pixel = ((CARD8 *) bits) + x;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
*pixel++ = values[i] >> 28;
|
|
}
|
|
}
|
|
|
|
#define Store8(l,o,v) (((CARD8 *) l)[(o) >> 3] = (v))
|
|
#if IMAGE_BYTE_ORDER == MSBFirst
|
|
#define Store4(l,o,v) Store8(l,o,((o) & 4 ? \
|
|
(Fetch8(l,o) & 0xf0) | (v) : \
|
|
(Fetch8(l,o) & 0x0f) | ((v) << 4)))
|
|
#else
|
|
#define Store4(l,o,v) Store8(l,o,((o) & 4 ? \
|
|
(Fetch8(l,o) & 0x0f) | ((v) << 4) : \
|
|
(Fetch8(l,o) & 0xf0) | (v)))
|
|
#endif
|
|
|
|
static FASTCALL void
|
|
fbStore_a4(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
Store4(bits, i + x, values[i] >> 28);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_r1g2b1(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 pixel;
|
|
|
|
Split(values[i]);
|
|
pixel = (((r >> 4) & 0x8) | ((g >> 5) & 0x6) | ((b >> 7)));
|
|
Store4(bits, i + x, pixel);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_b1g2r1(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 pixel;
|
|
|
|
Split(values[i]);
|
|
pixel = (((b >> 4) & 0x8) | ((g >> 5) & 0x6) | ((r >> 7)));
|
|
Store4(bits, i + x, pixel);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_a1r1g1b1(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 pixel;
|
|
|
|
Splita(values[i]);
|
|
pixel = (((a >> 4) & 0x8) |
|
|
((r >> 5) & 0x4) | ((g >> 6) & 0x2) | ((b >> 7)));
|
|
Store4(bits, i + x, pixel);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_a1b1g1r1(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 pixel;
|
|
|
|
Splita(values[i]);
|
|
pixel = (((a >> 4) & 0x8) |
|
|
((b >> 5) & 0x4) | ((g >> 6) & 0x2) | ((r >> 7)));
|
|
Store4(bits, i + x, pixel);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_c4(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 pixel;
|
|
|
|
pixel = miIndexToEnt24(indexed, values[i]);
|
|
Store4(bits, i + x, pixel);
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_a1(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 *pixel = ((CARD32 *) bits) + ((i + x) >> 5);
|
|
|
|
CARD32 mask = FbStipMask((i + x) & 0x1f, 1);
|
|
|
|
CARD32 v = values[i] & 0x80000000 ? mask : 0;
|
|
|
|
*pixel = (*pixel & ~mask) | v;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbStore_g1(FbBits * bits, const CARD32 *values, int x, int width,
|
|
miIndexedPtr indexed)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 *pixel = ((CARD32 *) bits) + ((i + x) >> 5);
|
|
|
|
CARD32 mask = FbStipMask((i + x) & 0x1f, 1);
|
|
|
|
CARD32 v = miIndexToEntY24(indexed, values[i]) ? mask : 0;
|
|
|
|
*pixel = (*pixel & ~mask) | v;
|
|
}
|
|
}
|
|
|
|
static storeProc
|
|
storeProcForPicture(PicturePtr pict)
|
|
{
|
|
switch (pict->format) {
|
|
case PICT_a8r8g8b8:
|
|
return fbStore_a8r8g8b8;
|
|
case PICT_x8r8g8b8:
|
|
return fbStore_x8r8g8b8;
|
|
case PICT_a8b8g8r8:
|
|
return fbStore_a8b8g8r8;
|
|
case PICT_x8b8g8r8:
|
|
return fbStore_x8b8g8r8;
|
|
|
|
/* 24bpp formats */
|
|
case PICT_r8g8b8:
|
|
return fbStore_r8g8b8;
|
|
case PICT_b8g8r8:
|
|
return fbStore_b8g8r8;
|
|
|
|
/* 16bpp formats */
|
|
case PICT_r5g6b5:
|
|
return fbStore_r5g6b5;
|
|
case PICT_b5g6r5:
|
|
return fbStore_b5g6r5;
|
|
|
|
case PICT_a1r5g5b5:
|
|
return fbStore_a1r5g5b5;
|
|
case PICT_x1r5g5b5:
|
|
return fbStore_x1r5g5b5;
|
|
case PICT_a1b5g5r5:
|
|
return fbStore_a1b5g5r5;
|
|
case PICT_x1b5g5r5:
|
|
return fbStore_x1b5g5r5;
|
|
case PICT_a4r4g4b4:
|
|
return fbStore_a4r4g4b4;
|
|
case PICT_x4r4g4b4:
|
|
return fbStore_x4r4g4b4;
|
|
case PICT_a4b4g4r4:
|
|
return fbStore_a4b4g4r4;
|
|
case PICT_x4b4g4r4:
|
|
return fbStore_x4b4g4r4;
|
|
|
|
/* 8bpp formats */
|
|
case PICT_a8:
|
|
return fbStore_a8;
|
|
case PICT_r3g3b2:
|
|
return fbStore_r3g3b2;
|
|
case PICT_b2g3r3:
|
|
return fbStore_b2g3r3;
|
|
case PICT_a2r2g2b2:
|
|
return fbStore_a2r2g2b2;
|
|
case PICT_c8:
|
|
return fbStore_c8;
|
|
case PICT_g8:
|
|
return fbStore_c8;
|
|
case PICT_x4a4:
|
|
return fbStore_x4a4;
|
|
|
|
/* 4bpp formats */
|
|
case PICT_a4:
|
|
return fbStore_a4;
|
|
case PICT_r1g2b1:
|
|
return fbStore_r1g2b1;
|
|
case PICT_b1g2r1:
|
|
return fbStore_b1g2r1;
|
|
case PICT_a1r1g1b1:
|
|
return fbStore_a1r1g1b1;
|
|
case PICT_a1b1g1r1:
|
|
return fbStore_a1b1g1r1;
|
|
case PICT_c4:
|
|
return fbStore_c4;
|
|
case PICT_g4:
|
|
return fbStore_c4;
|
|
|
|
/* 1bpp formats */
|
|
case PICT_a1:
|
|
return fbStore_a1;
|
|
case PICT_g1:
|
|
return fbStore_g1;
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Combine src and mask
|
|
*/
|
|
static FASTCALL void
|
|
fbCombineMaskU(CARD32 *src, const CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 a = mask[i] >> 24;
|
|
|
|
CARD32 s = src[i];
|
|
|
|
FbByteMul(s, a);
|
|
src[i] = s;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* All of the composing functions
|
|
*/
|
|
|
|
static FASTCALL void
|
|
fbCombineClear(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
memset(dest, 0, width * sizeof(CARD32));
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineSrcU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
memcpy(dest, src, width * sizeof(CARD32));
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineOverU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 ia = Alpha(~s);
|
|
|
|
FbByteMulAdd(d, ia, s);
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineOverReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 ia = Alpha(~dest[i]);
|
|
|
|
FbByteMulAdd(s, ia, d);
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineInU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 a = Alpha(dest[i]);
|
|
|
|
FbByteMul(s, a);
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineInReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 a = Alpha(src[i]);
|
|
|
|
FbByteMul(d, a);
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineOutU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 a = Alpha(~dest[i]);
|
|
|
|
FbByteMul(s, a);
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineOutReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 a = Alpha(~src[i]);
|
|
|
|
FbByteMul(d, a);
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineAtopU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 dest_a = Alpha(d);
|
|
|
|
CARD32 src_ia = Alpha(~s);
|
|
|
|
FbByteAddMul(s, dest_a, d, src_ia);
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineAtopReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 src_a = Alpha(s);
|
|
|
|
CARD32 dest_ia = Alpha(~d);
|
|
|
|
FbByteAddMul(s, dest_ia, d, src_a);
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineXorU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 src_ia = Alpha(~s);
|
|
|
|
CARD32 dest_ia = Alpha(~d);
|
|
|
|
FbByteAddMul(s, dest_ia, d, src_ia);
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineAddU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
FbByteAdd(d, s);
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineSaturateU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
CARD16 sa, da;
|
|
|
|
sa = s >> 24;
|
|
da = ~d >> 24;
|
|
if (sa > da) {
|
|
sa = FbIntDiv(da, sa);
|
|
FbByteMul(s, sa);
|
|
}
|
|
FbByteAdd(d, s);
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* All of the disjoint composing functions
|
|
|
|
The four entries in the first column indicate what source contributions
|
|
come from each of the four areas of the picture -- areas covered by neither
|
|
A nor B, areas covered only by A, areas covered only by B and finally
|
|
areas covered by both A and B.
|
|
|
|
Disjoint Conjoint
|
|
Fa Fb Fa Fb
|
|
(0,0,0,0) 0 0 0 0
|
|
(0,A,0,A) 1 0 1 0
|
|
(0,0,B,B) 0 1 0 1
|
|
(0,A,B,A) 1 min((1-a)/b,1) 1 max(1-a/b,0)
|
|
(0,A,B,B) min((1-b)/a,1) 1 max(1-b/a,0) 1
|
|
(0,0,0,A) max(1-(1-b)/a,0) 0 min(1,b/a) 0
|
|
(0,0,0,B) 0 max(1-(1-a)/b,0) 0 min(a/b,1)
|
|
(0,A,0,0) min(1,(1-b)/a) 0 max(1-b/a,0) 0
|
|
(0,0,B,0) 0 min(1,(1-a)/b) 0 max(1-a/b,0)
|
|
(0,0,B,A) max(1-(1-b)/a,0) min(1,(1-a)/b) min(1,b/a) max(1-a/b,0)
|
|
(0,A,0,B) min(1,(1-b)/a) max(1-(1-a)/b,0) max(1-b/a,0) min(1,a/b)
|
|
(0,A,B,0) min(1,(1-b)/a) min(1,(1-a)/b) max(1-b/a,0) max(1-a/b,0)
|
|
|
|
*/
|
|
|
|
#define CombineAOut 1
|
|
#define CombineAIn 2
|
|
#define CombineBOut 4
|
|
#define CombineBIn 8
|
|
|
|
#define CombineClear 0
|
|
#define CombineA (CombineAOut|CombineAIn)
|
|
#define CombineB (CombineBOut|CombineBIn)
|
|
#define CombineAOver (CombineAOut|CombineBOut|CombineAIn)
|
|
#define CombineBOver (CombineAOut|CombineBOut|CombineBIn)
|
|
#define CombineAAtop (CombineBOut|CombineAIn)
|
|
#define CombineBAtop (CombineAOut|CombineBIn)
|
|
#define CombineXor (CombineAOut|CombineBOut)
|
|
|
|
/* portion covered by a but not b */
|
|
static INLINE CARD8
|
|
fbCombineDisjointOutPart(CARD8 a, CARD8 b)
|
|
{
|
|
/* min (1, (1-b) / a) */
|
|
|
|
b = ~b; /* 1 - b */
|
|
if (b >= a) /* 1 - b >= a -> (1-b)/a >= 1 */
|
|
return 0xff; /* 1 */
|
|
return FbIntDiv(b, a); /* (1-b) / a */
|
|
}
|
|
|
|
/* portion covered by both a and b */
|
|
static INLINE CARD8
|
|
fbCombineDisjointInPart(CARD8 a, CARD8 b)
|
|
{
|
|
/* max (1-(1-b)/a,0) */
|
|
/* = - min ((1-b)/a - 1, 0) */
|
|
/* = 1 - min (1, (1-b)/a) */
|
|
|
|
b = ~b; /* 1 - b */
|
|
if (b >= a) /* 1 - b >= a -> (1-b)/a >= 1 */
|
|
return 0; /* 1 - 1 */
|
|
return ~FbIntDiv(b, a); /* 1 - (1-b) / a */
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointGeneralU(CARD32 *dest, const CARD32 *src, int width,
|
|
CARD8 combine)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 m, n, o, p;
|
|
|
|
CARD16 Fa, Fb, t, u, v;
|
|
|
|
CARD8 sa = s >> 24;
|
|
|
|
CARD8 da = d >> 24;
|
|
|
|
switch (combine & CombineA) {
|
|
default:
|
|
Fa = 0;
|
|
break;
|
|
case CombineAOut:
|
|
Fa = fbCombineDisjointOutPart(sa, da);
|
|
break;
|
|
case CombineAIn:
|
|
Fa = fbCombineDisjointInPart(sa, da);
|
|
break;
|
|
case CombineA:
|
|
Fa = 0xff;
|
|
break;
|
|
}
|
|
|
|
switch (combine & CombineB) {
|
|
default:
|
|
Fb = 0;
|
|
break;
|
|
case CombineBOut:
|
|
Fb = fbCombineDisjointOutPart(da, sa);
|
|
break;
|
|
case CombineBIn:
|
|
Fb = fbCombineDisjointInPart(da, sa);
|
|
break;
|
|
case CombineB:
|
|
Fb = 0xff;
|
|
break;
|
|
}
|
|
m = FbGen(s, d, 0, Fa, Fb, t, u, v);
|
|
n = FbGen(s, d, 8, Fa, Fb, t, u, v);
|
|
o = FbGen(s, d, 16, Fa, Fb, t, u, v);
|
|
p = FbGen(s, d, 24, Fa, Fb, t, u, v);
|
|
s = m | n | o | p;
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointOverU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD16 a = s >> 24;
|
|
|
|
if (a != 0x00) {
|
|
if (a != 0xff) {
|
|
CARD32 d = dest[i];
|
|
|
|
a = fbCombineDisjointOutPart(d >> 24, a);
|
|
FbByteMulAdd(d, a, s);
|
|
s = d;
|
|
}
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointInU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineDisjointGeneralU(dest, src, width, CombineAIn);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointInReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineDisjointGeneralU(dest, src, width, CombineBIn);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointOutU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineDisjointGeneralU(dest, src, width, CombineAOut);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointOutReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineDisjointGeneralU(dest, src, width, CombineBOut);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointAtopU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineDisjointGeneralU(dest, src, width, CombineAAtop);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointAtopReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineDisjointGeneralU(dest, src, width, CombineBAtop);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointXorU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineDisjointGeneralU(dest, src, width, CombineXor);
|
|
}
|
|
|
|
/* portion covered by a but not b */
|
|
static INLINE CARD8
|
|
fbCombineConjointOutPart(CARD8 a, CARD8 b)
|
|
{
|
|
/* max (1-b/a,0) */
|
|
/* = 1-min(b/a,1) */
|
|
|
|
/* min (1, (1-b) / a) */
|
|
|
|
if (b >= a) /* b >= a -> b/a >= 1 */
|
|
return 0x00; /* 0 */
|
|
return ~FbIntDiv(b, a); /* 1 - b/a */
|
|
}
|
|
|
|
/* portion covered by both a and b */
|
|
static INLINE CARD8
|
|
fbCombineConjointInPart(CARD8 a, CARD8 b)
|
|
{
|
|
/* min (1,b/a) */
|
|
|
|
if (b >= a) /* b >= a -> b/a >= 1 */
|
|
return 0xff; /* 1 */
|
|
return FbIntDiv(b, a); /* b/a */
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointGeneralU(CARD32 *dest, const CARD32 *src, int width,
|
|
CARD8 combine)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 m, n, o, p;
|
|
|
|
CARD16 Fa, Fb, t, u, v;
|
|
|
|
CARD8 sa = s >> 24;
|
|
|
|
CARD8 da = d >> 24;
|
|
|
|
switch (combine & CombineA) {
|
|
default:
|
|
Fa = 0;
|
|
break;
|
|
case CombineAOut:
|
|
Fa = fbCombineConjointOutPart(sa, da);
|
|
break;
|
|
case CombineAIn:
|
|
Fa = fbCombineConjointInPart(sa, da);
|
|
break;
|
|
case CombineA:
|
|
Fa = 0xff;
|
|
break;
|
|
}
|
|
|
|
switch (combine & CombineB) {
|
|
default:
|
|
Fb = 0;
|
|
break;
|
|
case CombineBOut:
|
|
Fb = fbCombineConjointOutPart(da, sa);
|
|
break;
|
|
case CombineBIn:
|
|
Fb = fbCombineConjointInPart(da, sa);
|
|
break;
|
|
case CombineB:
|
|
Fb = 0xff;
|
|
break;
|
|
}
|
|
m = FbGen(s, d, 0, Fa, Fb, t, u, v);
|
|
n = FbGen(s, d, 8, Fa, Fb, t, u, v);
|
|
o = FbGen(s, d, 16, Fa, Fb, t, u, v);
|
|
p = FbGen(s, d, 24, Fa, Fb, t, u, v);
|
|
s = m | n | o | p;
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointOverU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineConjointGeneralU(dest, src, width, CombineAOver);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointOverReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineConjointGeneralU(dest, src, width, CombineBOver);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointInU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineConjointGeneralU(dest, src, width, CombineAIn);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointInReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineConjointGeneralU(dest, src, width, CombineBIn);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointOutU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineConjointGeneralU(dest, src, width, CombineAOut);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointOutReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineConjointGeneralU(dest, src, width, CombineBOut);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointAtopU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineConjointGeneralU(dest, src, width, CombineAAtop);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointAtopReverseU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineConjointGeneralU(dest, src, width, CombineBAtop);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointXorU(CARD32 *dest, const CARD32 *src, int width)
|
|
{
|
|
fbCombineConjointGeneralU(dest, src, width, CombineXor);
|
|
}
|
|
|
|
static const CombineFuncU fbCombineFuncU[] = {
|
|
fbCombineClear,
|
|
fbCombineSrcU,
|
|
NULL, /* CombineDst */
|
|
fbCombineOverU,
|
|
fbCombineOverReverseU,
|
|
fbCombineInU,
|
|
fbCombineInReverseU,
|
|
fbCombineOutU,
|
|
fbCombineOutReverseU,
|
|
fbCombineAtopU,
|
|
fbCombineAtopReverseU,
|
|
fbCombineXorU,
|
|
fbCombineAddU,
|
|
fbCombineSaturateU,
|
|
NULL,
|
|
NULL,
|
|
fbCombineClear,
|
|
fbCombineSrcU,
|
|
NULL, /* CombineDst */
|
|
fbCombineDisjointOverU,
|
|
fbCombineSaturateU, /* DisjointOverReverse */
|
|
fbCombineDisjointInU,
|
|
fbCombineDisjointInReverseU,
|
|
fbCombineDisjointOutU,
|
|
fbCombineDisjointOutReverseU,
|
|
fbCombineDisjointAtopU,
|
|
fbCombineDisjointAtopReverseU,
|
|
fbCombineDisjointXorU,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
fbCombineClear,
|
|
fbCombineSrcU,
|
|
NULL, /* CombineDst */
|
|
fbCombineConjointOverU,
|
|
fbCombineConjointOverReverseU,
|
|
fbCombineConjointInU,
|
|
fbCombineConjointInReverseU,
|
|
fbCombineConjointOutU,
|
|
fbCombineConjointOutReverseU,
|
|
fbCombineConjointAtopU,
|
|
fbCombineConjointAtopReverseU,
|
|
fbCombineConjointXorU,
|
|
};
|
|
|
|
static FASTCALL void
|
|
fbCombineMaskC(CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 a = mask[i];
|
|
|
|
CARD32 x;
|
|
|
|
CARD16 xa;
|
|
|
|
if (!a) {
|
|
src[i] = 0;
|
|
continue;
|
|
}
|
|
|
|
x = src[i];
|
|
if (a == 0xffffffff) {
|
|
x = x >> 24;
|
|
x |= x << 8;
|
|
x |= x << 16;
|
|
mask[i] = x;
|
|
continue;
|
|
}
|
|
|
|
xa = x >> 24;
|
|
FbByteMulC(x, a);
|
|
src[i] = x;
|
|
FbByteMul(a, xa);
|
|
mask[i] = a;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineMaskValueC(CARD32 *src, const CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 a = mask[i];
|
|
|
|
CARD32 x;
|
|
|
|
if (!a) {
|
|
src[i] = 0;
|
|
continue;
|
|
}
|
|
|
|
if (a == 0xffffffff)
|
|
continue;
|
|
|
|
x = src[i];
|
|
FbByteMulC(x, a);
|
|
src[i] = x;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineMaskAlphaC(const CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 a = mask[i];
|
|
|
|
CARD32 x;
|
|
|
|
if (!a)
|
|
continue;
|
|
|
|
x = src[i] >> 24;
|
|
if (x == 0xff)
|
|
continue;
|
|
if (a == 0xffffffff) {
|
|
x = x >> 24;
|
|
x |= x << 8;
|
|
x |= x << 16;
|
|
mask[i] = x;
|
|
continue;
|
|
}
|
|
|
|
FbByteMul(a, x);
|
|
mask[i] = a;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineClearC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
memset(dest, 0, width * sizeof(CARD32));
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineSrcC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineMaskValueC(src, mask, width);
|
|
memcpy(dest, src, width * sizeof(CARD32));
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineOverC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 a = ~mask[i];
|
|
|
|
if (a != 0xffffffff) {
|
|
if (a) {
|
|
CARD32 d = dest[i];
|
|
|
|
FbByteMulAddC(d, a, s);
|
|
s = d;
|
|
}
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineOverReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskValueC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 a = ~d >> 24;
|
|
|
|
if (a) {
|
|
CARD32 s = src[i];
|
|
|
|
if (a != 0xff) {
|
|
FbByteMulAdd(s, a, d);
|
|
}
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineInC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskValueC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 d = dest[i];
|
|
|
|
CARD16 a = d >> 24;
|
|
|
|
CARD32 s = 0;
|
|
|
|
if (a) {
|
|
s = src[i];
|
|
if (a != 0xff) {
|
|
FbByteMul(s, a);
|
|
}
|
|
}
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineInReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskAlphaC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 a = mask[i];
|
|
|
|
if (a != 0xffffffff) {
|
|
CARD32 d = 0;
|
|
|
|
if (a) {
|
|
d = dest[i];
|
|
FbByteMulC(d, a);
|
|
}
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineOutC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskValueC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 d = dest[i];
|
|
|
|
CARD16 a = ~d >> 24;
|
|
|
|
CARD32 s = 0;
|
|
|
|
if (a) {
|
|
s = src[i];
|
|
if (a != 0xff) {
|
|
FbByteMul(s, a);
|
|
}
|
|
}
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineOutReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskAlphaC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 a = ~mask[i];
|
|
|
|
if (a != 0xffffffff) {
|
|
CARD32 d = 0;
|
|
|
|
if (a) {
|
|
d = dest[i];
|
|
FbByteMulC(d, a);
|
|
}
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineAtopC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 ad = ~mask[i];
|
|
|
|
CARD16 as = d >> 24;
|
|
|
|
FbByteAddMulC(d, ad, s, as);
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineAtopReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 ad = mask[i];
|
|
|
|
CARD16 as = ~d >> 24;
|
|
|
|
FbByteAddMulC(d, ad, s, as);
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineXorC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 d = dest[i];
|
|
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 ad = ~mask[i];
|
|
|
|
CARD16 as = ~d >> 24;
|
|
|
|
FbByteAddMulC(d, ad, s, as);
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineAddC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskValueC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s = src[i];
|
|
|
|
CARD32 d = dest[i];
|
|
|
|
FbByteAdd(d, s);
|
|
dest[i] = d;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineSaturateC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s, d;
|
|
|
|
CARD16 sa, sr, sg, sb, da;
|
|
|
|
CARD16 t, u, v;
|
|
|
|
CARD32 m, n, o, p;
|
|
|
|
d = dest[i];
|
|
s = src[i];
|
|
sa = (mask[i] >> 24);
|
|
sr = (mask[i] >> 16) & 0xff;
|
|
sg = (mask[i] >> 8) & 0xff;
|
|
sb = (mask[i]) & 0xff;
|
|
da = ~d >> 24;
|
|
|
|
if (sb <= da)
|
|
m = FbAdd(s, d, 0, t);
|
|
else
|
|
m = FbGen(s, d, 0, (da << 8) / sb, 0xff, t, u, v);
|
|
|
|
if (sg <= da)
|
|
n = FbAdd(s, d, 8, t);
|
|
else
|
|
n = FbGen(s, d, 8, (da << 8) / sg, 0xff, t, u, v);
|
|
|
|
if (sr <= da)
|
|
o = FbAdd(s, d, 16, t);
|
|
else
|
|
o = FbGen(s, d, 16, (da << 8) / sr, 0xff, t, u, v);
|
|
|
|
if (sa <= da)
|
|
p = FbAdd(s, d, 24, t);
|
|
else
|
|
p = FbGen(s, d, 24, (da << 8) / sa, 0xff, t, u, v);
|
|
|
|
dest[i] = m | n | o | p;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointGeneralC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width,
|
|
CARD8 combine)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s, d;
|
|
|
|
CARD32 m, n, o, p;
|
|
|
|
CARD32 Fa, Fb;
|
|
|
|
CARD16 t, u, v;
|
|
|
|
CARD32 sa;
|
|
|
|
CARD8 da;
|
|
|
|
s = src[i];
|
|
sa = mask[i];
|
|
d = dest[i];
|
|
da = d >> 24;
|
|
|
|
switch (combine & CombineA) {
|
|
default:
|
|
Fa = 0;
|
|
break;
|
|
case CombineAOut:
|
|
m = fbCombineDisjointOutPart((CARD8) (sa >> 0), da);
|
|
n = fbCombineDisjointOutPart((CARD8) (sa >> 8), da) << 8;
|
|
o = fbCombineDisjointOutPart((CARD8) (sa >> 16), da) << 16;
|
|
p = fbCombineDisjointOutPart((CARD8) (sa >> 24), da) << 24;
|
|
Fa = m | n | o | p;
|
|
break;
|
|
case CombineAIn:
|
|
m = fbCombineDisjointInPart((CARD8) (sa >> 0), da);
|
|
n = fbCombineDisjointInPart((CARD8) (sa >> 8), da) << 8;
|
|
o = fbCombineDisjointInPart((CARD8) (sa >> 16), da) << 16;
|
|
p = fbCombineDisjointInPart((CARD8) (sa >> 24), da) << 24;
|
|
Fa = m | n | o | p;
|
|
break;
|
|
case CombineA:
|
|
Fa = 0xffffffff;
|
|
break;
|
|
}
|
|
|
|
switch (combine & CombineB) {
|
|
default:
|
|
Fb = 0;
|
|
break;
|
|
case CombineBOut:
|
|
m = fbCombineDisjointOutPart(da, (CARD8) (sa >> 0));
|
|
n = fbCombineDisjointOutPart(da, (CARD8) (sa >> 8)) << 8;
|
|
o = fbCombineDisjointOutPart(da, (CARD8) (sa >> 16)) << 16;
|
|
p = fbCombineDisjointOutPart(da, (CARD8) (sa >> 24)) << 24;
|
|
Fb = m | n | o | p;
|
|
break;
|
|
case CombineBIn:
|
|
m = fbCombineDisjointInPart(da, (CARD8) (sa >> 0));
|
|
n = fbCombineDisjointInPart(da, (CARD8) (sa >> 8)) << 8;
|
|
o = fbCombineDisjointInPart(da, (CARD8) (sa >> 16)) << 16;
|
|
p = fbCombineDisjointInPart(da, (CARD8) (sa >> 24)) << 24;
|
|
Fb = m | n | o | p;
|
|
break;
|
|
case CombineB:
|
|
Fb = 0xffffffff;
|
|
break;
|
|
}
|
|
m = FbGen(s, d, 0, FbGet8(Fa, 0), FbGet8(Fb, 0), t, u, v);
|
|
n = FbGen(s, d, 8, FbGet8(Fa, 8), FbGet8(Fb, 8), t, u, v);
|
|
o = FbGen(s, d, 16, FbGet8(Fa, 16), FbGet8(Fb, 16), t, u, v);
|
|
p = FbGen(s, d, 24, FbGet8(Fa, 24), FbGet8(Fb, 24), t, u, v);
|
|
s = m | n | o | p;
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointOverC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineDisjointGeneralC(dest, src, mask, width, CombineAOver);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointInC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineDisjointGeneralC(dest, src, mask, width, CombineAIn);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointInReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineDisjointGeneralC(dest, src, mask, width, CombineBIn);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointOutC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineDisjointGeneralC(dest, src, mask, width, CombineAOut);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointOutReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineDisjointGeneralC(dest, src, mask, width, CombineBOut);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointAtopC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineDisjointGeneralC(dest, src, mask, width, CombineAAtop);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointAtopReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask,
|
|
int width)
|
|
{
|
|
fbCombineDisjointGeneralC(dest, src, mask, width, CombineBAtop);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineDisjointXorC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineDisjointGeneralC(dest, src, mask, width, CombineXor);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointGeneralC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width,
|
|
CARD8 combine)
|
|
{
|
|
int i;
|
|
|
|
fbCombineMaskC(src, mask, width);
|
|
for (i = 0; i < width; ++i) {
|
|
CARD32 s, d;
|
|
|
|
CARD32 m, n, o, p;
|
|
|
|
CARD32 Fa, Fb;
|
|
|
|
CARD16 t, u, v;
|
|
|
|
CARD32 sa;
|
|
|
|
CARD8 da;
|
|
|
|
s = src[i];
|
|
sa = mask[i];
|
|
d = dest[i];
|
|
da = d >> 24;
|
|
|
|
switch (combine & CombineA) {
|
|
default:
|
|
Fa = 0;
|
|
break;
|
|
case CombineAOut:
|
|
m = fbCombineConjointOutPart((CARD8) (sa >> 0), da);
|
|
n = fbCombineConjointOutPart((CARD8) (sa >> 8), da) << 8;
|
|
o = fbCombineConjointOutPart((CARD8) (sa >> 16), da) << 16;
|
|
p = fbCombineConjointOutPart((CARD8) (sa >> 24), da) << 24;
|
|
Fa = m | n | o | p;
|
|
break;
|
|
case CombineAIn:
|
|
m = fbCombineConjointInPart((CARD8) (sa >> 0), da);
|
|
n = fbCombineConjointInPart((CARD8) (sa >> 8), da) << 8;
|
|
o = fbCombineConjointInPart((CARD8) (sa >> 16), da) << 16;
|
|
p = fbCombineConjointInPart((CARD8) (sa >> 24), da) << 24;
|
|
Fa = m | n | o | p;
|
|
break;
|
|
case CombineA:
|
|
Fa = 0xffffffff;
|
|
break;
|
|
}
|
|
|
|
switch (combine & CombineB) {
|
|
default:
|
|
Fb = 0;
|
|
break;
|
|
case CombineBOut:
|
|
m = fbCombineConjointOutPart(da, (CARD8) (sa >> 0));
|
|
n = fbCombineConjointOutPart(da, (CARD8) (sa >> 8)) << 8;
|
|
o = fbCombineConjointOutPart(da, (CARD8) (sa >> 16)) << 16;
|
|
p = fbCombineConjointOutPart(da, (CARD8) (sa >> 24)) << 24;
|
|
Fb = m | n | o | p;
|
|
break;
|
|
case CombineBIn:
|
|
m = fbCombineConjointInPart(da, (CARD8) (sa >> 0));
|
|
n = fbCombineConjointInPart(da, (CARD8) (sa >> 8)) << 8;
|
|
o = fbCombineConjointInPart(da, (CARD8) (sa >> 16)) << 16;
|
|
p = fbCombineConjointInPart(da, (CARD8) (sa >> 24)) << 24;
|
|
Fb = m | n | o | p;
|
|
break;
|
|
case CombineB:
|
|
Fb = 0xffffffff;
|
|
break;
|
|
}
|
|
m = FbGen(s, d, 0, FbGet8(Fa, 0), FbGet8(Fb, 0), t, u, v);
|
|
n = FbGen(s, d, 8, FbGet8(Fa, 8), FbGet8(Fb, 8), t, u, v);
|
|
o = FbGen(s, d, 16, FbGet8(Fa, 16), FbGet8(Fb, 16), t, u, v);
|
|
p = FbGen(s, d, 24, FbGet8(Fa, 24), FbGet8(Fb, 24), t, u, v);
|
|
s = m | n | o | p;
|
|
dest[i] = s;
|
|
}
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointOverC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineConjointGeneralC(dest, src, mask, width, CombineAOver);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointOverReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask,
|
|
int width)
|
|
{
|
|
fbCombineConjointGeneralC(dest, src, mask, width, CombineBOver);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointInC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineConjointGeneralC(dest, src, mask, width, CombineAIn);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointInReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineConjointGeneralC(dest, src, mask, width, CombineBIn);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointOutC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineConjointGeneralC(dest, src, mask, width, CombineAOut);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointOutReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineConjointGeneralC(dest, src, mask, width, CombineBOut);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointAtopC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineConjointGeneralC(dest, src, mask, width, CombineAAtop);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointAtopReverseC(CARD32 *dest, CARD32 *src, CARD32 *mask,
|
|
int width)
|
|
{
|
|
fbCombineConjointGeneralC(dest, src, mask, width, CombineBAtop);
|
|
}
|
|
|
|
static FASTCALL void
|
|
fbCombineConjointXorC(CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
|
|
{
|
|
fbCombineConjointGeneralC(dest, src, mask, width, CombineXor);
|
|
}
|
|
|
|
static const CombineFuncC fbCombineFuncC[] = {
|
|
fbCombineClearC,
|
|
fbCombineSrcC,
|
|
NULL, /* Dest */
|
|
fbCombineOverC,
|
|
fbCombineOverReverseC,
|
|
fbCombineInC,
|
|
fbCombineInReverseC,
|
|
fbCombineOutC,
|
|
fbCombineOutReverseC,
|
|
fbCombineAtopC,
|
|
fbCombineAtopReverseC,
|
|
fbCombineXorC,
|
|
fbCombineAddC,
|
|
fbCombineSaturateC,
|
|
NULL,
|
|
NULL,
|
|
fbCombineClearC, /* 0x10 */
|
|
fbCombineSrcC,
|
|
NULL, /* Dest */
|
|
fbCombineDisjointOverC,
|
|
fbCombineSaturateC, /* DisjointOverReverse */
|
|
fbCombineDisjointInC,
|
|
fbCombineDisjointInReverseC,
|
|
fbCombineDisjointOutC,
|
|
fbCombineDisjointOutReverseC,
|
|
fbCombineDisjointAtopC,
|
|
fbCombineDisjointAtopReverseC,
|
|
fbCombineDisjointXorC, /* 0x1b */
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
fbCombineClearC,
|
|
fbCombineSrcC,
|
|
NULL, /* Dest */
|
|
fbCombineConjointOverC,
|
|
fbCombineConjointOverReverseC,
|
|
fbCombineConjointInC,
|
|
fbCombineConjointInReverseC,
|
|
fbCombineConjointOutC,
|
|
fbCombineConjointOutReverseC,
|
|
fbCombineConjointAtopC,
|
|
fbCombineConjointAtopReverseC,
|
|
fbCombineConjointXorC,
|
|
};
|
|
|
|
static const FbComposeFunctions composeFunctions = {
|
|
fbCombineFuncU,
|
|
fbCombineFuncC,
|
|
fbCombineMaskU
|
|
};
|
|
|
|
static void
|
|
fbFetchSolid(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
|
|
{
|
|
FbBits *bits;
|
|
|
|
FbStride stride;
|
|
|
|
int bpp;
|
|
|
|
int xoff, yoff;
|
|
|
|
CARD32 color;
|
|
|
|
CARD32 *end;
|
|
|
|
fetchPixelProc fetch = fetchPixelProcForPicture(pict);
|
|
|
|
miIndexedPtr indexed = (miIndexedPtr) pict->pFormat->index.devPrivate;
|
|
|
|
fbGetDrawable(pict->pDrawable, bits, stride, bpp, xoff, yoff);
|
|
bits += yoff * stride + (xoff * bpp >> FB_SHIFT);
|
|
|
|
color = fetch(bits, 0, indexed);
|
|
|
|
end = buffer + width;
|
|
while (buffer < end)
|
|
*buffer++ = color;
|
|
}
|
|
|
|
static void
|
|
fbFetch(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
|
|
{
|
|
FbBits *bits;
|
|
|
|
FbStride stride;
|
|
|
|
int bpp;
|
|
|
|
int xoff, yoff;
|
|
|
|
fetchProc fetch = fetchProcForPicture(pict);
|
|
|
|
miIndexedPtr indexed = (miIndexedPtr) pict->pFormat->index.devPrivate;
|
|
|
|
fbGetDrawable(pict->pDrawable, bits, stride, bpp, xoff, yoff);
|
|
x += xoff;
|
|
y += yoff;
|
|
|
|
bits += y * stride;
|
|
|
|
fetch(bits, x, width, buffer, indexed);
|
|
}
|
|
|
|
#define MOD(a,b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
|
|
#define DIV(a,b) ((((a) < 0) == ((b) < 0)) ? (a) / (b) :\
|
|
((a) - (b) + 1 - (((b) < 0) << 1)) / (b))
|
|
|
|
static CARD32
|
|
gradientPixel(const SourcePictPtr pGradient, xFixed_48_16 pos,
|
|
unsigned int spread)
|
|
{
|
|
int ipos = (pos * PICT_GRADIENT_STOPTABLE_SIZE - 1) >> 16;
|
|
|
|
/* calculate the actual offset. */
|
|
if (ipos < 0 || ipos >= PICT_GRADIENT_STOPTABLE_SIZE) {
|
|
if (pGradient->type == SourcePictTypeConical || spread == RepeatNormal) {
|
|
ipos = ipos % PICT_GRADIENT_STOPTABLE_SIZE;
|
|
ipos = ipos < 0 ? PICT_GRADIENT_STOPTABLE_SIZE + ipos : ipos;
|
|
|
|
}
|
|
else if (spread == RepeatReflect) {
|
|
const int limit = PICT_GRADIENT_STOPTABLE_SIZE * 2 - 1;
|
|
|
|
ipos = ipos % limit;
|
|
ipos = ipos < 0 ? limit + ipos : ipos;
|
|
ipos = ipos >= PICT_GRADIENT_STOPTABLE_SIZE ? limit - ipos : ipos;
|
|
|
|
}
|
|
else if (spread == RepeatPad) {
|
|
if (ipos < 0)
|
|
ipos = 0;
|
|
else if (ipos >= PICT_GRADIENT_STOPTABLE_SIZE)
|
|
ipos = PICT_GRADIENT_STOPTABLE_SIZE - 1;
|
|
}
|
|
else { /* RepeatNone */
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
assert(ipos >= 0);
|
|
assert(ipos < PICT_GRADIENT_STOPTABLE_SIZE);
|
|
|
|
return pGradient->linear.colorTable[ipos];
|
|
}
|
|
|
|
static void
|
|
fbFetchSourcePict(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
|
|
{
|
|
SourcePictPtr pGradient = pict->pSourcePict;
|
|
|
|
CARD32 *end = buffer + width;
|
|
|
|
if (pGradient->type == SourcePictTypeSolidFill) {
|
|
CARD32 color = pGradient->solidFill.color;
|
|
|
|
while (buffer < end) {
|
|
*buffer++ = color;
|
|
}
|
|
}
|
|
else if (pGradient->type == SourcePictTypeLinear) {
|
|
PictVector v, unit;
|
|
|
|
xFixed_32_32 l;
|
|
|
|
xFixed_48_16 dx, dy, a, b, off;
|
|
|
|
/* reference point is the center of the pixel */
|
|
v.vector[0] = IntToxFixed(x) + xFixed1 / 2;
|
|
v.vector[1] = IntToxFixed(y) + xFixed1 / 2;
|
|
v.vector[2] = xFixed1;
|
|
if (pict->transform) {
|
|
if (!PictureTransformPoint3d(pict->transform, &v))
|
|
return;
|
|
unit.vector[0] = pict->transform->matrix[0][0];
|
|
unit.vector[1] = pict->transform->matrix[1][0];
|
|
unit.vector[2] = pict->transform->matrix[2][0];
|
|
}
|
|
else {
|
|
unit.vector[0] = xFixed1;
|
|
unit.vector[1] = 0;
|
|
unit.vector[2] = 0;
|
|
}
|
|
|
|
dx = pGradient->linear.p2.x - pGradient->linear.p1.x;
|
|
dy = pGradient->linear.p2.y - pGradient->linear.p1.y;
|
|
l = dx * dx + dy * dy;
|
|
if (l != 0) {
|
|
a = (dx << 32) / l;
|
|
b = (dy << 32) / l;
|
|
off =
|
|
(-a * pGradient->linear.p1.x -
|
|
b * pGradient->linear.p1.y) >> 16;
|
|
}
|
|
if (l == 0 || (unit.vector[2] == 0 && v.vector[2] == xFixed1)) {
|
|
xFixed_48_16 inc, t;
|
|
|
|
/* affine transformation only */
|
|
if (l == 0) {
|
|
t = 0;
|
|
inc = 0;
|
|
}
|
|
else {
|
|
t = ((a * v.vector[0] + b * v.vector[1]) >> 16) + off;
|
|
inc = (a * unit.vector[0] + b * unit.vector[1]) >> 16;
|
|
}
|
|
while (buffer < end) {
|
|
*buffer++ = gradientPixel(pGradient, t, pict->repeatType);
|
|
t += inc;
|
|
}
|
|
}
|
|
else {
|
|
/* projective transformation */
|
|
while (buffer < end) {
|
|
xFixed_48_16 t;
|
|
|
|
if (v.vector[2] == 0) {
|
|
t = 0;
|
|
}
|
|
else {
|
|
xFixed_48_16 x, y;
|
|
|
|
x = ((xFixed_48_16) v.vector[0] << 16) / v.vector[2];
|
|
y = ((xFixed_48_16) v.vector[1] << 16) / v.vector[2];
|
|
t = ((a * x + b * y) >> 16) + off;
|
|
}
|
|
*buffer++ = gradientPixel(pGradient, t, pict->repeatType);
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
/* radial or conical */
|
|
Bool affine = TRUE;
|
|
|
|
double cx = 1.;
|
|
|
|
double cy = 0.;
|
|
|
|
double cz = 0.;
|
|
|
|
double rx = x;
|
|
|
|
double ry = y;
|
|
|
|
double rz = 1.;
|
|
|
|
if (pict->transform) {
|
|
PictVector v;
|
|
|
|
/* reference point is the center of the pixel */
|
|
v.vector[0] = IntToxFixed(x) + xFixed1 / 2;
|
|
v.vector[1] = IntToxFixed(y) + xFixed1 / 2;
|
|
v.vector[2] = xFixed1;
|
|
if (!PictureTransformPoint3d(pict->transform, &v))
|
|
return;
|
|
|
|
cx = pict->transform->matrix[0][0] / 65536.;
|
|
cy = pict->transform->matrix[1][0] / 65536.;
|
|
cz = pict->transform->matrix[2][0] / 65536.;
|
|
rx = v.vector[0] / 65536.;
|
|
ry = v.vector[1] / 65536.;
|
|
rz = v.vector[2] / 65536.;
|
|
affine = pict->transform->matrix[2][0] == 0 &&
|
|
v.vector[2] == xFixed1;
|
|
}
|
|
|
|
if (pGradient->type == SourcePictTypeRadial) {
|
|
if (affine) {
|
|
rx -= pGradient->radial.fx;
|
|
ry -= pGradient->radial.fy;
|
|
|
|
while (buffer < end) {
|
|
double b =
|
|
2 * (rx * pGradient->radial.dx +
|
|
ry * pGradient->radial.dy);
|
|
double c = -(rx * rx + ry * ry);
|
|
|
|
double det = (b * b) - (4 * pGradient->radial.a * c);
|
|
|
|
double s = (-b + sqrt(det)) / (2. * pGradient->radial.a);
|
|
|
|
*buffer = gradientPixel(pGradient,
|
|
(xFixed_48_16) ((s *
|
|
pGradient->radial.
|
|
m +
|
|
pGradient->radial.
|
|
b) * 65536),
|
|
pict->repeatType);
|
|
++buffer;
|
|
rx += cx;
|
|
ry += cy;
|
|
}
|
|
}
|
|
else {
|
|
while (buffer < end) {
|
|
double x, y;
|
|
|
|
double b, c, det, s;
|
|
|
|
if (rz != 0) {
|
|
x = rx / rz;
|
|
y = ry / rz;
|
|
}
|
|
else {
|
|
x = y = 0.;
|
|
}
|
|
x -= pGradient->radial.fx;
|
|
y -= pGradient->radial.fy;
|
|
b = 2 * (x * pGradient->radial.dx +
|
|
y * pGradient->radial.dy);
|
|
c = -(x * x + y * y);
|
|
det = (b * b) - (4 * pGradient->radial.a * c);
|
|
s = (-b + sqrt(det)) / (2. * pGradient->radial.a);
|
|
*buffer = gradientPixel(pGradient,
|
|
(xFixed_48_16) ((s *
|
|
pGradient->radial.
|
|
m +
|
|
pGradient->radial.
|
|
b) * 65536),
|
|
pict->repeatType);
|
|
++buffer;
|
|
rx += cx;
|
|
ry += cy;
|
|
rz += cz;
|
|
}
|
|
}
|
|
}
|
|
else { /* SourcePictTypeConical */
|
|
|
|
double a = pGradient->conical.angle / (180. * 65536);
|
|
|
|
if (affine) {
|
|
rx -= pGradient->conical.center.x / 65536.;
|
|
ry -= pGradient->conical.center.y / 65536.;
|
|
|
|
while (buffer < end) {
|
|
double angle = atan2(ry, rx) + a;
|
|
|
|
*buffer =
|
|
gradientPixel(pGradient,
|
|
(xFixed_48_16) (angle *
|
|
(65536. / (2 * M_PI))),
|
|
pict->repeatType);
|
|
++buffer;
|
|
rx += cx;
|
|
ry += cy;
|
|
}
|
|
}
|
|
else {
|
|
|
|
while (buffer < end) {
|
|
double x, y, angle;
|
|
|
|
if (rz != 0) {
|
|
x = rx / rz;
|
|
y = ry / rz;
|
|
}
|
|
else {
|
|
x = y = 0.;
|
|
}
|
|
x -= pGradient->conical.center.x / 65536.;
|
|
y -= pGradient->conical.center.y / 65536.;
|
|
angle = atan2(y, x) + a;
|
|
*buffer =
|
|
gradientPixel(pGradient,
|
|
(xFixed_48_16) (angle *
|
|
(65536. / (2 * M_PI))),
|
|
pict->repeatType);
|
|
++buffer;
|
|
rx += cx;
|
|
ry += cy;
|
|
rz += cz;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
fbFetchTransformed(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
|
|
{
|
|
FbBits *bits;
|
|
|
|
FbStride stride;
|
|
|
|
int bpp;
|
|
|
|
int xoff, yoff, dx, dy;
|
|
|
|
fetchPixelProc fetch;
|
|
|
|
PictVector v;
|
|
|
|
PictVector unit;
|
|
|
|
int i;
|
|
|
|
BoxRec box;
|
|
|
|
miIndexedPtr indexed = (miIndexedPtr) pict->pFormat->index.devPrivate;
|
|
|
|
Bool affine = TRUE;
|
|
|
|
fetch = fetchPixelProcForPicture(pict);
|
|
|
|
fbGetDrawable(pict->pDrawable, bits, stride, bpp, xoff, yoff);
|
|
x += xoff;
|
|
y += yoff;
|
|
|
|
dx = pict->pDrawable->x;
|
|
dy = pict->pDrawable->y;
|
|
|
|
/* reference point is the center of the pixel */
|
|
v.vector[0] = IntToxFixed(x - dx) + xFixed1 / 2;
|
|
v.vector[1] = IntToxFixed(y - dy) + xFixed1 / 2;
|
|
v.vector[2] = xFixed1;
|
|
|
|
/* when using convolution filters one might get here without a transform */
|
|
if (pict->transform) {
|
|
if (!PictureTransformPoint3d(pict->transform, &v))
|
|
return;
|
|
unit.vector[0] = pict->transform->matrix[0][0];
|
|
unit.vector[1] = pict->transform->matrix[1][0];
|
|
unit.vector[2] = pict->transform->matrix[2][0];
|
|
affine = v.vector[2] == xFixed1 && unit.vector[2] == 0;
|
|
}
|
|
else {
|
|
unit.vector[0] = xFixed1;
|
|
unit.vector[1] = 0;
|
|
unit.vector[2] = 0;
|
|
}
|
|
|
|
if (pict->filter == PictFilterNearest) {
|
|
if (pict->repeatType == RepeatNormal) {
|
|
if (REGION_NUM_RECTS(pict->pCompositeClip) == 1) {
|
|
for (i = 0; i < width; ++i) {
|
|
if (!v.vector[2]) {
|
|
buffer[i] = 0;
|
|
}
|
|
else {
|
|
if (!affine) {
|
|
y = MOD(DIV(v.vector[1], v.vector[2]),
|
|
pict->pDrawable->height);
|
|
x = MOD(DIV(v.vector[0], v.vector[2]),
|
|
pict->pDrawable->width);
|
|
}
|
|
else {
|
|
y = MOD(v.vector[1] >> 16, pict->pDrawable->height);
|
|
x = MOD(v.vector[0] >> 16, pict->pDrawable->width);
|
|
}
|
|
buffer[i] =
|
|
fetch(bits + (y + dy) * stride, x + dx, indexed);
|
|
}
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
else {
|
|
for (i = 0; i < width; ++i) {
|
|
if (!v.vector[2]) {
|
|
buffer[i] = 0;
|
|
}
|
|
else {
|
|
if (!affine) {
|
|
y = MOD(DIV(v.vector[1], v.vector[2]),
|
|
pict->pDrawable->height);
|
|
x = MOD(DIV(v.vector[0], v.vector[2]),
|
|
pict->pDrawable->width);
|
|
}
|
|
else {
|
|
y = MOD(v.vector[1] >> 16, pict->pDrawable->height);
|
|
x = MOD(v.vector[0] >> 16, pict->pDrawable->width);
|
|
}
|
|
if (POINT_IN_REGION(pict->pCompositeClip, x + dx, y + dy, &box))
|
|
buffer[i] =
|
|
fetch(bits + (y + dy) * stride, x + dx,
|
|
indexed);
|
|
else
|
|
buffer[i] = 0;
|
|
}
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (REGION_NUM_RECTS(pict->pCompositeClip) == 1) {
|
|
box = pict->pCompositeClip->extents;
|
|
for (i = 0; i < width; ++i) {
|
|
if (!v.vector[2]) {
|
|
buffer[i] = 0;
|
|
}
|
|
else {
|
|
if (!affine) {
|
|
y = DIV(v.vector[1], v.vector[2]);
|
|
x = DIV(v.vector[0], v.vector[2]);
|
|
}
|
|
else {
|
|
y = v.vector[1] >> 16;
|
|
x = v.vector[0] >> 16;
|
|
}
|
|
buffer[i] =
|
|
((x < box.x1 - dx) | (x >= box.x2 - dx) | (y <
|
|
box.y1 -
|
|
dy) | (y
|
|
>=
|
|
box.
|
|
y2
|
|
-
|
|
dy))
|
|
? 0 : fetch(bits + (y + dy) * stride, x + dx,
|
|
indexed);
|
|
}
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
else {
|
|
for (i = 0; i < width; ++i) {
|
|
if (!v.vector[2]) {
|
|
buffer[i] = 0;
|
|
}
|
|
else {
|
|
if (!affine) {
|
|
y = DIV(v.vector[1], v.vector[2]);
|
|
x = DIV(v.vector[0], v.vector[2]);
|
|
}
|
|
else {
|
|
y = v.vector[1] >> 16;
|
|
x = v.vector[0] >> 16;
|
|
}
|
|
if (POINT_IN_REGION(pict->pCompositeClip, x + dx, y + dy, &box))
|
|
buffer[i] =
|
|
fetch(bits + (y + dy) * stride, x + dx,
|
|
indexed);
|
|
else
|
|
buffer[i] = 0;
|
|
}
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (pict->filter == PictFilterBilinear) {
|
|
/* adjust vector for maximum contribution at 0.5, 0.5 of each texel. */
|
|
v.vector[0] -= v.vector[2] / 2;
|
|
v.vector[1] -= v.vector[2] / 2;
|
|
unit.vector[0] -= unit.vector[2] / 2;
|
|
unit.vector[1] -= unit.vector[2] / 2;
|
|
|
|
if (pict->repeatType == RepeatNormal) {
|
|
if (REGION_NUM_RECTS(pict->pCompositeClip) == 1) {
|
|
for (i = 0; i < width; ++i) {
|
|
if (!v.vector[2]) {
|
|
buffer[i] = 0;
|
|
}
|
|
else {
|
|
int x1, x2, y1, y2, distx, idistx, disty, idisty;
|
|
|
|
FbBits *b;
|
|
|
|
CARD32 tl, tr, bl, br, r;
|
|
|
|
CARD32 ft, fb;
|
|
|
|
if (!affine) {
|
|
xFixed_48_16 div;
|
|
|
|
div =
|
|
((xFixed_48_16) v.vector[0] << 16) /
|
|
v.vector[2];
|
|
x1 = div >> 16;
|
|
distx = ((xFixed) div >> 8) & 0xff;
|
|
div =
|
|
((xFixed_48_16) v.vector[1] << 16) /
|
|
v.vector[2];
|
|
y1 = div >> 16;
|
|
disty = ((xFixed) div >> 8) & 0xff;
|
|
}
|
|
else {
|
|
x1 = v.vector[0] >> 16;
|
|
distx = (v.vector[0] >> 8) & 0xff;
|
|
y1 = v.vector[1] >> 16;
|
|
disty = (v.vector[1] >> 8) & 0xff;
|
|
}
|
|
x2 = x1 + 1;
|
|
y2 = y1 + 1;
|
|
|
|
idistx = 256 - distx;
|
|
idisty = 256 - disty;
|
|
|
|
x1 = MOD(x1, pict->pDrawable->width);
|
|
x2 = MOD(x2, pict->pDrawable->width);
|
|
y1 = MOD(y1, pict->pDrawable->height);
|
|
y2 = MOD(y2, pict->pDrawable->height);
|
|
|
|
b = bits + (y1 + dy) * stride;
|
|
|
|
tl = fetch(b, x1 + dx, indexed);
|
|
tr = fetch(b, x2 + dx, indexed);
|
|
b = bits + (y2 + dy) * stride;
|
|
bl = fetch(b, x1 + dx, indexed);
|
|
br = fetch(b, x2 + dx, indexed);
|
|
|
|
ft = FbGet8(tl, 0) * idistx + FbGet8(tr, 0) * distx;
|
|
fb = FbGet8(bl, 0) * idistx + FbGet8(br, 0) * distx;
|
|
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
|
|
ft = FbGet8(tl, 8) * idistx + FbGet8(tr, 8) * distx;
|
|
fb = FbGet8(bl, 8) * idistx + FbGet8(br, 8) * distx;
|
|
r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
|
|
ft = FbGet8(tl, 16) * idistx + FbGet8(tr, 16) * distx;
|
|
fb = FbGet8(bl, 16) * idistx + FbGet8(br, 16) * distx;
|
|
r |= (((ft * idisty + fb * disty)) & 0xff0000);
|
|
ft = FbGet8(tl, 24) * idistx + FbGet8(tr, 24) * distx;
|
|
fb = FbGet8(bl, 24) * idistx + FbGet8(br, 24) * distx;
|
|
r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
|
|
buffer[i] = r;
|
|
}
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
else {
|
|
for (i = 0; i < width; ++i) {
|
|
if (!v.vector[2]) {
|
|
buffer[i] = 0;
|
|
}
|
|
else {
|
|
int x1, x2, y1, y2, distx, idistx, disty, idisty;
|
|
|
|
FbBits *b;
|
|
|
|
CARD32 tl, tr, bl, br, r;
|
|
|
|
CARD32 ft, fb;
|
|
|
|
if (!affine) {
|
|
xFixed_48_16 div;
|
|
|
|
div =
|
|
((xFixed_48_16) v.vector[0] << 16) /
|
|
v.vector[2];
|
|
x1 = div >> 16;
|
|
distx = ((xFixed) div >> 8) & 0xff;
|
|
div =
|
|
((xFixed_48_16) v.vector[1] << 16) /
|
|
v.vector[2];
|
|
y1 = div >> 16;
|
|
disty = ((xFixed) div >> 8) & 0xff;
|
|
}
|
|
else {
|
|
x1 = v.vector[0] >> 16;
|
|
distx = (v.vector[0] >> 8) & 0xff;
|
|
y1 = v.vector[1] >> 16;
|
|
disty = (v.vector[1] >> 8) & 0xff;
|
|
}
|
|
x2 = x1 + 1;
|
|
y2 = y1 + 1;
|
|
|
|
idistx = 256 - distx;
|
|
idisty = 256 - disty;
|
|
|
|
x1 = MOD(x1, pict->pDrawable->width);
|
|
x2 = MOD(x2, pict->pDrawable->width);
|
|
y1 = MOD(y1, pict->pDrawable->height);
|
|
y2 = MOD(y2, pict->pDrawable->height);
|
|
|
|
b = bits + (y1 + dy) * stride;
|
|
|
|
tl = POINT_IN_REGION(pict->pCompositeClip, x1 + dx,
|
|
y1 + dy, &box)
|
|
? fetch(b, x1 + dx, indexed) : 0;
|
|
tr = POINT_IN_REGION(pict->pCompositeClip, x2 + dx,
|
|
y1 + dy, &box)
|
|
? fetch(b, x2 + dx, indexed) : 0;
|
|
b = bits + (y2 + dy) * stride;
|
|
bl = POINT_IN_REGION(pict->pCompositeClip, x1 + dx,
|
|
y2 + dy, &box)
|
|
? fetch(b, x1 + dx, indexed) : 0;
|
|
br = POINT_IN_REGION(pict->pCompositeClip, x2 + dx,
|
|
y2 + dy, &box)
|
|
? fetch(b, x2 + dx, indexed) : 0;
|
|
|
|
ft = FbGet8(tl, 0) * idistx + FbGet8(tr, 0) * distx;
|
|
fb = FbGet8(bl, 0) * idistx + FbGet8(br, 0) * distx;
|
|
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
|
|
ft = FbGet8(tl, 8) * idistx + FbGet8(tr, 8) * distx;
|
|
fb = FbGet8(bl, 8) * idistx + FbGet8(br, 8) * distx;
|
|
r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
|
|
ft = FbGet8(tl, 16) * idistx + FbGet8(tr, 16) * distx;
|
|
fb = FbGet8(bl, 16) * idistx + FbGet8(br, 16) * distx;
|
|
r |= (((ft * idisty + fb * disty)) & 0xff0000);
|
|
ft = FbGet8(tl, 24) * idistx + FbGet8(tr, 24) * distx;
|
|
fb = FbGet8(bl, 24) * idistx + FbGet8(br, 24) * distx;
|
|
r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
|
|
buffer[i] = r;
|
|
}
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (REGION_NUM_RECTS(pict->pCompositeClip) == 1) {
|
|
box = pict->pCompositeClip->extents;
|
|
for (i = 0; i < width; ++i) {
|
|
if (!v.vector[2]) {
|
|
buffer[i] = 0;
|
|
}
|
|
else {
|
|
int x1, x2, y1, y2, distx, idistx, disty, idisty, x_off;
|
|
|
|
FbBits *b;
|
|
|
|
CARD32 tl, tr, bl, br, r;
|
|
|
|
Bool x1_out, x2_out, y1_out, y2_out;
|
|
|
|
CARD32 ft, fb;
|
|
|
|
if (!affine) {
|
|
xFixed_48_16 div;
|
|
|
|
div =
|
|
((xFixed_48_16) v.vector[0] << 16) /
|
|
v.vector[2];
|
|
x1 = div >> 16;
|
|
distx = ((xFixed) div >> 8) & 0xff;
|
|
div =
|
|
((xFixed_48_16) v.vector[1] << 16) /
|
|
v.vector[2];
|
|
y1 = div >> 16;
|
|
disty = ((xFixed) div >> 8) & 0xff;
|
|
}
|
|
else {
|
|
x1 = v.vector[0] >> 16;
|
|
distx = (v.vector[0] >> 8) & 0xff;
|
|
y1 = v.vector[1] >> 16;
|
|
disty = (v.vector[1] >> 8) & 0xff;
|
|
}
|
|
x2 = x1 + 1;
|
|
y2 = y1 + 1;
|
|
|
|
idistx = 256 - distx;
|
|
idisty = 256 - disty;
|
|
|
|
b = bits + (y1 + dy) * stride;
|
|
x_off = x1 + dx;
|
|
|
|
x1_out = (x1 < box.x1 - dx) | (x1 >= box.x2 - dx);
|
|
x2_out = (x2 < box.x1 - dx) | (x2 >= box.x2 - dx);
|
|
y1_out = (y1 < box.y1 - dy) | (y1 >= box.y2 - dy);
|
|
y2_out = (y2 < box.y1 - dy) | (y2 >= box.y2 - dy);
|
|
|
|
tl = x1_out | y1_out ? 0 : fetch(b, x_off, indexed);
|
|
tr = x2_out | y1_out ? 0 : fetch(b, x_off + 1, indexed);
|
|
b += stride;
|
|
bl = x1_out | y2_out ? 0 : fetch(b, x_off, indexed);
|
|
br = x2_out | y2_out ? 0 : fetch(b, x_off + 1, indexed);
|
|
|
|
ft = FbGet8(tl, 0) * idistx + FbGet8(tr, 0) * distx;
|
|
fb = FbGet8(bl, 0) * idistx + FbGet8(br, 0) * distx;
|
|
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
|
|
ft = FbGet8(tl, 8) * idistx + FbGet8(tr, 8) * distx;
|
|
fb = FbGet8(bl, 8) * idistx + FbGet8(br, 8) * distx;
|
|
r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
|
|
ft = FbGet8(tl, 16) * idistx + FbGet8(tr, 16) * distx;
|
|
fb = FbGet8(bl, 16) * idistx + FbGet8(br, 16) * distx;
|
|
r |= (((ft * idisty + fb * disty)) & 0xff0000);
|
|
ft = FbGet8(tl, 24) * idistx + FbGet8(tr, 24) * distx;
|
|
fb = FbGet8(bl, 24) * idistx + FbGet8(br, 24) * distx;
|
|
r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
|
|
buffer[i] = r;
|
|
}
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
else {
|
|
for (i = 0; i < width; ++i) {
|
|
if (!v.vector[2]) {
|
|
buffer[i] = 0;
|
|
}
|
|
else {
|
|
int x1, x2, y1, y2, distx, idistx, disty, idisty, x_off;
|
|
|
|
FbBits *b;
|
|
|
|
CARD32 tl, tr, bl, br, r;
|
|
|
|
CARD32 ft, fb;
|
|
|
|
if (!affine) {
|
|
xFixed_48_16 div;
|
|
|
|
div =
|
|
((xFixed_48_16) v.vector[0] << 16) /
|
|
v.vector[2];
|
|
x1 = div >> 16;
|
|
distx = ((xFixed) div >> 8) & 0xff;
|
|
div =
|
|
((xFixed_48_16) v.vector[1] << 16) /
|
|
v.vector[2];
|
|
y1 = div >> 16;
|
|
disty = ((xFixed) div >> 8) & 0xff;
|
|
}
|
|
else {
|
|
x1 = v.vector[0] >> 16;
|
|
distx = (v.vector[0] >> 8) & 0xff;
|
|
y1 = v.vector[1] >> 16;
|
|
disty = (v.vector[1] >> 8) & 0xff;
|
|
}
|
|
x2 = x1 + 1;
|
|
y2 = y1 + 1;
|
|
|
|
idistx = 256 - distx;
|
|
idisty = 256 - disty;
|
|
|
|
b = bits + (y1 + dy) * stride;
|
|
x_off = x1 + dx;
|
|
|
|
tl = POINT_IN_REGION(pict->pCompositeClip, x1 + dx,
|
|
y1 + dy, &box)
|
|
? fetch(b, x_off, indexed) : 0;
|
|
tr = POINT_IN_REGION(pict->pCompositeClip, x2 + dx,
|
|
y1 + dy, &box)
|
|
? fetch(b, x_off + 1, indexed) : 0;
|
|
b += stride;
|
|
bl = POINT_IN_REGION(pict->pCompositeClip, x1 + dx,
|
|
y2 + dy, &box)
|
|
? fetch(b, x_off, indexed) : 0;
|
|
br = POINT_IN_REGION(pict->pCompositeClip, x2 + dx,
|
|
y2 + dy, &box)
|
|
? fetch(b, x_off + 1, indexed) : 0;
|
|
|
|
ft = FbGet8(tl, 0) * idistx + FbGet8(tr, 0) * distx;
|
|
fb = FbGet8(bl, 0) * idistx + FbGet8(br, 0) * distx;
|
|
r = (((ft * idisty + fb * disty) >> 16) & 0xff);
|
|
ft = FbGet8(tl, 8) * idistx + FbGet8(tr, 8) * distx;
|
|
fb = FbGet8(bl, 8) * idistx + FbGet8(br, 8) * distx;
|
|
r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
|
|
ft = FbGet8(tl, 16) * idistx + FbGet8(tr, 16) * distx;
|
|
fb = FbGet8(bl, 16) * idistx + FbGet8(br, 16) * distx;
|
|
r |= (((ft * idisty + fb * disty)) & 0xff0000);
|
|
ft = FbGet8(tl, 24) * idistx + FbGet8(tr, 24) * distx;
|
|
fb = FbGet8(bl, 24) * idistx + FbGet8(br, 24) * distx;
|
|
r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
|
|
buffer[i] = r;
|
|
}
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (pict->filter == PictFilterConvolution) {
|
|
xFixed *params = pict->filter_params;
|
|
|
|
INT32 cwidth = xFixedToInt(params[0]);
|
|
|
|
INT32 cheight = xFixedToInt(params[1]);
|
|
|
|
int xoff = (params[0] - xFixed1) >> 1;
|
|
|
|
int yoff = (params[1] - xFixed1) >> 1;
|
|
|
|
params += 2;
|
|
for (i = 0; i < width; ++i) {
|
|
if (!v.vector[2]) {
|
|
buffer[i] = 0;
|
|
}
|
|
else {
|
|
int x1, x2, y1, y2, x, y;
|
|
|
|
INT32 srtot, sgtot, sbtot, satot;
|
|
|
|
xFixed *p = params;
|
|
|
|
if (!affine) {
|
|
xFixed_48_16 tmp;
|
|
|
|
tmp =
|
|
((xFixed_48_16) v.vector[0] << 16) / v.vector[2] - xoff;
|
|
x1 = xFixedToInt(tmp);
|
|
tmp =
|
|
((xFixed_48_16) v.vector[1] << 16) / v.vector[2] - yoff;
|
|
y1 = xFixedToInt(tmp);
|
|
}
|
|
else {
|
|
x1 = xFixedToInt(v.vector[0] - xoff);
|
|
y1 = xFixedToInt(v.vector[1] - yoff);
|
|
}
|
|
x2 = x1 + cwidth;
|
|
y2 = y1 + cheight;
|
|
|
|
srtot = sgtot = sbtot = satot = 0;
|
|
|
|
for (y = y1; y < y2; y++) {
|
|
int ty =
|
|
(pict->repeatType == RepeatNormal) ? MOD(y,
|
|
pict->
|
|
pDrawable->
|
|
height) : y;
|
|
for (x = x1; x < x2; x++) {
|
|
if (*p) {
|
|
int tx =
|
|
(pict->repeatType == RepeatNormal) ? MOD(x,
|
|
pict->
|
|
pDrawable->
|
|
width)
|
|
: x;
|
|
if (POINT_IN_REGION(pict->pCompositeClip, tx + dx, ty + dy,
|
|
&box)) {
|
|
FbBits *b = bits + (ty + dy) * stride;
|
|
|
|
CARD32 c = fetch(b, tx + dx, indexed);
|
|
|
|
srtot += Red(c) * *p;
|
|
sgtot += Green(c) * *p;
|
|
sbtot += Blue(c) * *p;
|
|
satot += Alpha(c) * *p;
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
|
|
satot >>= 16;
|
|
srtot >>= 16;
|
|
sgtot >>= 16;
|
|
sbtot >>= 16;
|
|
|
|
if (satot < 0)
|
|
satot = 0;
|
|
else if (satot > 0xff)
|
|
satot = 0xff;
|
|
if (srtot < 0)
|
|
srtot = 0;
|
|
else if (srtot > 0xff)
|
|
srtot = 0xff;
|
|
if (sgtot < 0)
|
|
sgtot = 0;
|
|
else if (sgtot > 0xff)
|
|
sgtot = 0xff;
|
|
if (sbtot < 0)
|
|
sbtot = 0;
|
|
else if (sbtot > 0xff)
|
|
sbtot = 0xff;
|
|
|
|
buffer[i] = ((satot << 24) |
|
|
(srtot << 16) | (sgtot << 8) | (sbtot));
|
|
}
|
|
v.vector[0] += unit.vector[0];
|
|
v.vector[1] += unit.vector[1];
|
|
v.vector[2] += unit.vector[2];
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
fbFetchExternalAlpha(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
|
|
{
|
|
int i;
|
|
|
|
CARD32 _alpha_buffer[SCANLINE_BUFFER_LENGTH];
|
|
|
|
CARD32 *alpha_buffer = _alpha_buffer;
|
|
|
|
if (!pict->alphaMap) {
|
|
fbFetchTransformed(pict, x, y, width, buffer);
|
|
return;
|
|
}
|
|
if (width > SCANLINE_BUFFER_LENGTH)
|
|
alpha_buffer = malloc(width * sizeof(CARD32));
|
|
|
|
fbFetchTransformed(pict, x, y, width, buffer);
|
|
fbFetchTransformed(pict->alphaMap, x - pict->alphaOrigin.x,
|
|
y - pict->alphaOrigin.y, width, alpha_buffer);
|
|
for (i = 0; i < width; ++i) {
|
|
int a = alpha_buffer[i] >> 24;
|
|
|
|
buffer[i] = (a << 24)
|
|
| (div_255(Red(buffer[i]) * a) << 16)
|
|
| (div_255(Green(buffer[i]) * a) << 8)
|
|
| (div_255(Blue(buffer[i]) * a));
|
|
}
|
|
|
|
if (alpha_buffer != _alpha_buffer)
|
|
free(alpha_buffer);
|
|
}
|
|
|
|
static void
|
|
fbStore(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
|
|
{
|
|
FbBits *bits;
|
|
|
|
FbStride stride;
|
|
|
|
int bpp;
|
|
|
|
int xoff, yoff;
|
|
|
|
storeProc store = storeProcForPicture(pict);
|
|
|
|
miIndexedPtr indexed = (miIndexedPtr) pict->pFormat->index.devPrivate;
|
|
|
|
fbGetDrawable(pict->pDrawable, bits, stride, bpp, xoff, yoff);
|
|
x += xoff;
|
|
y += yoff;
|
|
|
|
bits += y * stride;
|
|
store(bits, buffer, x, width, indexed);
|
|
}
|
|
|
|
static void
|
|
fbStoreExternalAlpha(PicturePtr pict, int x, int y, int width, CARD32 *buffer)
|
|
{
|
|
FbBits *bits, *alpha_bits;
|
|
|
|
FbStride stride, astride;
|
|
|
|
int bpp, abpp;
|
|
|
|
int xoff, yoff;
|
|
|
|
int ax, ay;
|
|
|
|
storeProc store;
|
|
|
|
storeProc astore;
|
|
|
|
miIndexedPtr indexed = (miIndexedPtr) pict->pFormat->index.devPrivate;
|
|
|
|
miIndexedPtr aindexed;
|
|
|
|
if (!pict->alphaMap) {
|
|
fbStore(pict, x, y, width, buffer);
|
|
return;
|
|
}
|
|
|
|
store = storeProcForPicture(pict);
|
|
astore = storeProcForPicture(pict->alphaMap);
|
|
aindexed = (miIndexedPtr) pict->alphaMap->pFormat->index.devPrivate;
|
|
|
|
ax = x;
|
|
ay = y;
|
|
|
|
fbGetDrawable(pict->pDrawable, bits, stride, bpp, xoff, yoff);
|
|
x += xoff;
|
|
y += yoff;
|
|
fbGetDrawable(pict->alphaMap->pDrawable, alpha_bits, astride, abpp, xoff,
|
|
yoff);
|
|
ax += xoff;
|
|
ay += yoff;
|
|
|
|
bits += y * stride;
|
|
alpha_bits += (ay - pict->alphaOrigin.y) * astride;
|
|
|
|
store(bits, buffer, x, width, indexed);
|
|
astore(alpha_bits, buffer, ax - pict->alphaOrigin.x, width, aindexed);
|
|
}
|
|
|
|
typedef void (*scanStoreProc) (PicturePtr, int, int, int, CARD32 *);
|
|
|
|
typedef void (*scanFetchProc) (PicturePtr, int, int, int, CARD32 *);
|
|
|
|
static void
|
|
fbCompositeRect(const FbComposeData * data, CARD32 *scanline_buffer)
|
|
{
|
|
CARD32 *src_buffer = scanline_buffer;
|
|
|
|
CARD32 *dest_buffer = src_buffer + data->width;
|
|
|
|
int i;
|
|
|
|
scanStoreProc store;
|
|
|
|
scanFetchProc fetchSrc = NULL, fetchMask = NULL, fetchDest = NULL;
|
|
|
|
if (data->op == PictOpClear)
|
|
fetchSrc = NULL;
|
|
else if (!data->src->pDrawable) {
|
|
if (data->src->pSourcePict)
|
|
fetchSrc = fbFetchSourcePict;
|
|
}
|
|
else if (data->src->alphaMap)
|
|
fetchSrc = fbFetchExternalAlpha;
|
|
else if (data->src->repeatType == RepeatNormal &&
|
|
data->src->pDrawable->width == 1 &&
|
|
data->src->pDrawable->height == 1)
|
|
fetchSrc = fbFetchSolid;
|
|
else if (!data->src->transform &&
|
|
data->src->filter != PictFilterConvolution)
|
|
fetchSrc = fbFetch;
|
|
else
|
|
fetchSrc = fbFetchTransformed;
|
|
|
|
if (data->mask && data->op != PictOpClear) {
|
|
if (!data->mask->pDrawable) {
|
|
if (data->mask->pSourcePict)
|
|
fetchMask = fbFetchSourcePict;
|
|
}
|
|
else if (data->mask->alphaMap)
|
|
fetchMask = fbFetchExternalAlpha;
|
|
else if (data->mask->repeatType == RepeatNormal
|
|
&& data->mask->pDrawable->width == 1 &&
|
|
data->mask->pDrawable->height == 1)
|
|
fetchMask = fbFetchSolid;
|
|
else if (!data->mask->transform &&
|
|
data->mask->filter != PictFilterConvolution)
|
|
fetchMask = fbFetch;
|
|
else
|
|
fetchMask = fbFetchTransformed;
|
|
}
|
|
else {
|
|
fetchMask = NULL;
|
|
}
|
|
|
|
if (data->dest->alphaMap) {
|
|
fetchDest = fbFetchExternalAlpha;
|
|
store = fbStoreExternalAlpha;
|
|
}
|
|
else {
|
|
fetchDest = fbFetch;
|
|
store = fbStore;
|
|
}
|
|
if (data->op == PictOpClear || data->op == PictOpSrc)
|
|
fetchDest = NULL;
|
|
|
|
if (fetchSrc && fetchMask && data->mask && data->mask->componentAlpha &&
|
|
PICT_FORMAT_RGB(data->mask->format)) {
|
|
CARD32 *mask_buffer = dest_buffer + data->width;
|
|
|
|
CombineFuncC compose = composeFunctions.combineC[data->op];
|
|
|
|
if (!compose)
|
|
return;
|
|
|
|
for (i = 0; i < data->height; ++i) {
|
|
/* fill first half of scanline with source */
|
|
fetchSrc(data->src, data->xSrc, data->ySrc + i, data->width,
|
|
src_buffer);
|
|
fetchMask(data->mask, data->xMask, data->yMask + i, data->width,
|
|
mask_buffer);
|
|
|
|
/* fill dest into second half of scanline */
|
|
if (fetchDest)
|
|
fetchDest(data->dest, data->xDest, data->yDest + i, data->width,
|
|
dest_buffer);
|
|
|
|
/* blend */
|
|
compose(dest_buffer, src_buffer, mask_buffer, data->width);
|
|
|
|
/* write back */
|
|
store(data->dest, data->xDest, data->yDest + i, data->width,
|
|
dest_buffer);
|
|
}
|
|
}
|
|
else {
|
|
|
|
CombineFuncU compose = composeFunctions.combineU[data->op];
|
|
|
|
if (!compose)
|
|
return;
|
|
|
|
if (fetchSrc == fbFetchSolid &&
|
|
(!fetchMask || fetchMask == fbFetchSolid)) {
|
|
fetchSrc(data->src, data->xSrc, data->ySrc, data->width,
|
|
src_buffer);
|
|
if (fetchMask) {
|
|
fetchMask(data->mask, data->xMask, data->yMask, data->width,
|
|
dest_buffer);
|
|
composeFunctions.combineMaskU(src_buffer, dest_buffer,
|
|
data->width);
|
|
}
|
|
fetchSrc = NULL;
|
|
fetchMask = NULL;
|
|
}
|
|
|
|
for (i = 0; i < data->height; ++i) {
|
|
/* fill first half of scanline with source */
|
|
if (fetchSrc) {
|
|
fetchSrc(data->src, data->xSrc, data->ySrc + i, data->width,
|
|
src_buffer);
|
|
|
|
/* add in mask */
|
|
if (fetchMask) {
|
|
fetchMask(data->mask, data->xMask, data->yMask + i,
|
|
data->width, dest_buffer);
|
|
composeFunctions.combineMaskU(src_buffer, dest_buffer,
|
|
data->width);
|
|
}
|
|
}
|
|
|
|
/* fill dest into second half of scanline */
|
|
if (fetchDest)
|
|
fetchDest(data->dest, data->xDest, data->yDest + i, data->width,
|
|
dest_buffer);
|
|
|
|
/* blend */
|
|
compose(dest_buffer, src_buffer, data->width);
|
|
|
|
/* write back */
|
|
store(data->dest, data->xDest, data->yDest + i, data->width,
|
|
dest_buffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
fbCompositeGeneral(CARD8 op,
|
|
PicturePtr pSrc,
|
|
PicturePtr pMask,
|
|
PicturePtr pDst,
|
|
INT16 xSrc,
|
|
INT16 ySrc,
|
|
INT16 xMask,
|
|
INT16 yMask,
|
|
INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)
|
|
{
|
|
RegionRec region;
|
|
|
|
int n;
|
|
|
|
BoxPtr pbox;
|
|
|
|
Bool srcRepeat = FALSE;
|
|
|
|
Bool maskRepeat = FALSE;
|
|
|
|
int w, h;
|
|
|
|
CARD32 _scanline_buffer[SCANLINE_BUFFER_LENGTH * 3];
|
|
|
|
CARD32 *scanline_buffer = _scanline_buffer;
|
|
|
|
FbComposeData compose_data;
|
|
|
|
if (pSrc->pDrawable)
|
|
srcRepeat = pSrc->repeatType == RepeatNormal && !pSrc->transform
|
|
&& (pSrc->pDrawable->width != 1 || pSrc->pDrawable->height != 1);
|
|
|
|
if (pMask && pMask->pDrawable)
|
|
maskRepeat = pMask->repeatType == RepeatNormal && !pMask->transform
|
|
&& (pMask->pDrawable->width != 1 || pMask->pDrawable->height != 1);
|
|
|
|
if (op == PictOpOver && !pMask && !pSrc->transform &&
|
|
!PICT_FORMAT_A(pSrc->format) && !pSrc->alphaMap)
|
|
op = PictOpSrc;
|
|
|
|
if (!miComputeCompositeRegion(®ion,
|
|
pSrc,
|
|
pMask,
|
|
pDst,
|
|
xSrc,
|
|
ySrc,
|
|
xMask, yMask, xDst, yDst, width, height))
|
|
return;
|
|
|
|
compose_data.op = op;
|
|
compose_data.src = pSrc;
|
|
compose_data.mask = pMask;
|
|
compose_data.dest = pDst;
|
|
if (width > SCANLINE_BUFFER_LENGTH)
|
|
scanline_buffer = malloc(width * 3 * sizeof(CARD32));
|
|
|
|
n = REGION_NUM_RECTS(®ion);
|
|
pbox = REGION_RECTS(®ion);
|
|
while (n--) {
|
|
h = pbox->y2 - pbox->y1;
|
|
compose_data.ySrc = pbox->y1 - yDst + ySrc;
|
|
compose_data.yMask = pbox->y1 - yDst + yMask;
|
|
compose_data.yDest = pbox->y1;
|
|
while (h) {
|
|
compose_data.height = h;
|
|
w = pbox->x2 - pbox->x1;
|
|
compose_data.xSrc = pbox->x1 - xDst + xSrc;
|
|
compose_data.xMask = pbox->x1 - xDst + xMask;
|
|
compose_data.xDest = pbox->x1;
|
|
if (maskRepeat) {
|
|
compose_data.yMask =
|
|
mod(compose_data.yMask, pMask->pDrawable->height);
|
|
if (compose_data.height >
|
|
pMask->pDrawable->height - compose_data.yMask)
|
|
compose_data.height =
|
|
pMask->pDrawable->height - compose_data.yMask;
|
|
}
|
|
if (srcRepeat) {
|
|
compose_data.ySrc =
|
|
mod(compose_data.ySrc, pSrc->pDrawable->height);
|
|
if (compose_data.height >
|
|
pSrc->pDrawable->height - compose_data.ySrc)
|
|
compose_data.height =
|
|
pSrc->pDrawable->height - compose_data.ySrc;
|
|
}
|
|
while (w) {
|
|
compose_data.width = w;
|
|
if (maskRepeat) {
|
|
compose_data.xMask =
|
|
mod(compose_data.xMask, pMask->pDrawable->width);
|
|
if (compose_data.width >
|
|
pMask->pDrawable->width - compose_data.xMask)
|
|
compose_data.width =
|
|
pMask->pDrawable->width - compose_data.xMask;
|
|
}
|
|
if (srcRepeat) {
|
|
compose_data.xSrc =
|
|
mod(compose_data.xSrc, pSrc->pDrawable->width);
|
|
if (compose_data.width >
|
|
pSrc->pDrawable->width - compose_data.xSrc)
|
|
compose_data.width =
|
|
pSrc->pDrawable->width - compose_data.xSrc;
|
|
}
|
|
fbCompositeRect(&compose_data, scanline_buffer);
|
|
w -= compose_data.width;
|
|
compose_data.xSrc += compose_data.width;
|
|
compose_data.xMask += compose_data.width;
|
|
compose_data.xDest += compose_data.width;
|
|
}
|
|
h -= compose_data.height;
|
|
compose_data.ySrc += compose_data.height;
|
|
compose_data.yMask += compose_data.height;
|
|
compose_data.yDest += compose_data.height;
|
|
}
|
|
pbox++;
|
|
}
|
|
REGION_UNINIT(®ion);
|
|
|
|
if (scanline_buffer != _scanline_buffer)
|
|
free(scanline_buffer);
|
|
}
|
|
|