mirror of
https://github.com/kichikuou/xsystem35-sdl2.git
synced 2026-09-27 17:27:55 +03:00
326 lines
8.5 KiB
C
326 lines
8.5 KiB
C
/*
|
|
* image.c image操作
|
|
*
|
|
* Copyright (C) 1997-1998 Masaki Chikama (Wren) <chikama@kasumi.ipl.mech.nagoya-u.ac.jp>
|
|
* 1998- <masaki-c@is.aist-nara.ac.jp>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
#include "config.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "portab.h"
|
|
#include "system.h"
|
|
#include "image.h"
|
|
#include "cg.h"
|
|
#include "config.h"
|
|
#include "nact.h"
|
|
#include "alpha_plane.h"
|
|
#include "ags.h"
|
|
|
|
static void (*copy_from_alpha)(surface_t *, uint8_t *, uint8_t *, int, int, ALPHA_DIB_COPY_TYPE);
|
|
static void (*copy_to_alpha)(surface_t *, uint8_t *, uint8_t *, int, int, ALPHA_DIB_COPY_TYPE);
|
|
|
|
/******************************************************************************/
|
|
/* private methods image操作 16bpp */
|
|
/******************************************************************************/
|
|
|
|
static void image_copy_from_alpha16(surface_t *dib, uint8_t *sdata, uint8_t *ddata, int w, int h, ALPHA_DIB_COPY_TYPE flag) {
|
|
int x, y;
|
|
uint8_t *yls;
|
|
uint16_t *yld;
|
|
|
|
switch(flag) {
|
|
case TO_16H:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint8_t *)(sdata + y * dib->width);
|
|
yld = (uint16_t *)(ddata + y * dib->sdl_surface->pitch);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = (uint16_t)(*yls << 8) | (*yld & 0xff);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case TO_16L:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint8_t *)(sdata + y * dib->width);
|
|
yld = (uint16_t *)(ddata + y * dib->sdl_surface->pitch);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = (uint16_t)(*yls) | (*yld & 0xff00);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case TO_24R:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint8_t *)(sdata + y * dib->width);
|
|
yld = (uint16_t *)(ddata + y * dib->sdl_surface->pitch);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = PIX16(*yls, PIXG16(*yld), PIXB16(*yld));
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case TO_24G:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint8_t *)(sdata + y * dib->width);
|
|
yld = (uint16_t *)(ddata + y * dib->sdl_surface->pitch);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = PIX16(PIXR16(*yls), *yls, PIXB16(*yld));
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case TO_24B:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint8_t *)(sdata + y * dib->width);
|
|
yld = (uint16_t *)(ddata + y * dib->sdl_surface->pitch);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = PIX16(PIXR16(*yld), PIXG16(*yld), *yls);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void image_copy_to_alpha16(surface_t *dib, uint8_t *sdata, uint8_t *ddata, int w, int h, ALPHA_DIB_COPY_TYPE flag) {
|
|
int x, y;
|
|
uint8_t *yld;
|
|
uint16_t *yls;
|
|
|
|
switch(flag) {
|
|
case FROM_16H:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint16_t *)(sdata + y * dib->sdl_surface->pitch);
|
|
yld = (uint8_t *)(ddata + y * dib->width);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = (uint8_t)(*yls >> 8);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case FROM_16L:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint16_t *)(sdata + y * dib->sdl_surface->pitch);
|
|
yld = (uint8_t *)(ddata + y * dib->width);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = (uint8_t)(*yls);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case FROM_24R:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint16_t *)(sdata + y * dib->sdl_surface->pitch);
|
|
yld = (uint8_t *)(ddata + y * dib->width);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = PIXR16(*yls);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case FROM_24G:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint16_t *)(sdata + y * dib->sdl_surface->pitch);
|
|
yld = (uint8_t *)(ddata + y * dib->width);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = PIXG16(*yls);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case FROM_24B:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint16_t *)(sdata + y * dib->sdl_surface->pitch);
|
|
yld = (uint8_t *)(ddata + y * dib->width);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = PIXB16(*yls);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************/
|
|
/* private methods image操作 24/32bpp */
|
|
/******************************************************************************/
|
|
|
|
static void image_copy_from_alpha24(surface_t *dib, uint8_t *sdata, uint8_t *ddata, int w, int h, ALPHA_DIB_COPY_TYPE flag) {
|
|
int x, y;
|
|
uint8_t *yls;
|
|
uint32_t *yld;
|
|
|
|
switch(flag) {
|
|
case TO_16H:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint8_t *)(sdata + y * dib->width);
|
|
yld = (uint32_t *)(ddata + y * dib->sdl_surface->pitch);
|
|
for (x = 0; x < w; x++) {
|
|
/* *yld = */
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case TO_16L:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint8_t *)(sdata + y * dib->width);
|
|
yld = (uint32_t *)(ddata + y * dib->sdl_surface->pitch);
|
|
for (x = 0; x < w; x++) {
|
|
/* *yld = (uint16_t)(*yls) | (*yld & 0xff00); */
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case TO_24R:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint8_t *)(sdata + y * dib->width);
|
|
yld = (uint32_t *)(ddata + y * dib->sdl_surface->pitch);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = PIX24(*yls, PIXG24(*yld), PIXB24(*yld));
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case TO_24G:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint8_t *)(sdata + y * dib->width);
|
|
yld = (uint32_t *)(ddata + y * dib->sdl_surface->pitch);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = PIX24(PIXR24(*yls), *yls, PIXB24(*yld));
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case TO_24B:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint8_t *)(sdata + y * dib->width);
|
|
yld = (uint32_t *)(ddata + y * dib->sdl_surface->pitch);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = PIX24(PIXR24(*yld), PIXG24(*yld), *yls);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void image_copy_to_alpha24(surface_t *dib, uint8_t *sdata, uint8_t *ddata, int w, int h, ALPHA_DIB_COPY_TYPE flag) {
|
|
int x, y;
|
|
uint8_t *yld;
|
|
uint32_t *yls;
|
|
|
|
switch(flag) {
|
|
case FROM_16H:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint32_t *)(sdata + y * dib->sdl_surface->pitch);
|
|
yld = (uint8_t *)(ddata + y * dib->width);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = (uint8_t)(PIX16(PIXR24(*yls), PIXG24(*yls), PIXB24(*yls)) >> 8);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case FROM_16L:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint32_t *)(sdata + y * dib->sdl_surface->pitch);
|
|
yld = (uint8_t *)(ddata + y * dib->width);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = (uint8_t)(PIX16(PIXR24(*yls), PIXG24(*yls), PIXB24(*yls)));
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case FROM_24R:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint32_t *)(sdata + y * dib->sdl_surface->pitch);
|
|
yld = (uint8_t *)(ddata + y * dib->width);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = (uint8_t)PIXR24(*yls);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case FROM_24G:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint32_t *)(sdata + y * dib->sdl_surface->pitch);
|
|
yld = (uint8_t *)(ddata + y * dib->width);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = (uint8_t)PIXG24(*yls);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
case FROM_24B:
|
|
for (y = 0; y < h; y++) {
|
|
yls = (uint32_t *)(sdata + y * dib->sdl_surface->pitch);
|
|
yld = (uint8_t *)(ddata + y * dib->width);
|
|
for (x = 0; x < w; x++) {
|
|
*yld = (uint8_t)PIXB24(*yls);
|
|
yld++; yls++;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* dib の depth に応じた関数の設定
|
|
* depth: dib depth
|
|
*/
|
|
void image_setdepth(int depth) {
|
|
switch(depth) {
|
|
case 8:
|
|
break;
|
|
case 16:
|
|
copy_from_alpha = image_copy_from_alpha16;
|
|
copy_to_alpha = image_copy_to_alpha16;
|
|
break;
|
|
case 24:
|
|
case 32:
|
|
copy_from_alpha = image_copy_from_alpha24;
|
|
copy_to_alpha = image_copy_to_alpha24;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void image_copy_from_alpha(surface_t *dib, int sx, int sy, int w, int h, int dx, int dy, ALPHA_DIB_COPY_TYPE flag) {
|
|
uint8_t *sdata = GETOFFSET_ALPHA(dib, sx, sy);
|
|
uint8_t *ddata = GETOFFSET_PIXEL(dib, dx, dy);
|
|
|
|
copy_from_alpha(dib, sdata, ddata, w, h, flag);
|
|
}
|
|
|
|
void image_copy_to_alpha(surface_t *dib, int sx, int sy, int w, int h, int dx, int dy, ALPHA_DIB_COPY_TYPE flag) {
|
|
uint8_t *sdata = GETOFFSET_PIXEL(dib, sx, sy);
|
|
uint8_t *ddata = GETOFFSET_ALPHA(dib, dx, dy);
|
|
|
|
copy_to_alpha(dib, sdata, ddata, w, h, flag);
|
|
}
|