/*
core.c
The tool with multiple enhancements and manipulations of pictures
-26.11.2022
+03.12.2022
Copyright (C) 2014, 2015, 2022 Balthasar Szczepański
return 0;
}
-int get_palette (uint_fast16_t id, void **palette, ILuint frame)
+int get_palette (uint_fast16_t id, void *palette, ILuint frame)
{
if (id >= n_pictures)
return EINVAL;
ilActiveImage(frame);
if (ilGetInteger(IL_IMAGE_FORMAT) != IL_COLOUR_INDEX)
return EINVAL;
- *palette = ilGetPalette();
+ *((void **)palette) = ilGetPalette();
return 0;
}
void get_flags (struct IL_full_info *info, FLAG_TYPE *flags)
{
- *flags &= ~(HAS_ALPHA | IS_GRAY | IS_INDEXED | IS_MULTIPLE | IS_OVER_8BIT);
+ *flags &= ~(HAS_ALPHA | IS_GRAY | IS_INDEXED | IS_MULTIPLE | IS_OVER_8BIT | EFF_ALPHA | EFF_GRAY | EFF_INDEXED);
if (info->num_images > 0)
*flags |= IS_MULTIPLE;
switch (info->image_format)
{
case IL_COLOUR_INDEX:
- *flags |= IS_INDEXED;
+ *flags |= IS_INDEXED | EFF_INDEXED;
switch (info->palette_type)
{
case IL_PAL_BGR32:
break;
case IL_PAL_BGRA32:
case IL_PAL_RGBA32:
- *flags |= HAS_ALPHA;
+ *flags |= HAS_ALPHA | EFF_ALPHA;
break;
case IL_PAL_RGB24:
case IL_PAL_BGR24:
}
break;
case IL_LUMINANCE_ALPHA:
- *flags |= HAS_ALPHA;
+ *flags |= HAS_ALPHA | EFF_ALPHA;
case IL_LUMINANCE:
- *flags |= IS_GRAY;
+ *flags |= IS_GRAY | EFF_GRAY;
break;
case IL_RGBA:
case IL_BGRA:
- *flags |= HAS_ALPHA;
+ *flags |= HAS_ALPHA | EFF_ALPHA;
case IL_RGB:
case IL_BGR:
default:
return convert_picture(id, info, flags);
}
+int load_picture_mem (uint_fast16_t id, const void *address, ILuint size, struct IL_full_info *info, FLAG_TYPE *flags)
+{
+ if (id >= n_pictures)
+ return EINVAL;
+
+ // if(!(picture[id].open))
+ create_picture(id);
+
+ ilBindImage(picture[id].handle);
+ if (!ilLoadL(IL_TYPE_UNKNOWN, address, size))
+ return EIO;
+
+ return convert_picture(id, info, flags);
+}
+
int build_picture (uint_fast16_t id, ILint width, ILint height, ILint frames, struct IL_full_info *info, FLAG_TYPE *flags)
{
struct IL_full_info reference_info;
);
}
+int perform_action_1picture_1pixel (
+ uint_fast16_t id,
+ ILint x, ILint y, ILint f,
+ ACTION_F *function,
+ FLAG_TYPE flags,
+ void *data
+)
+{
+ return perform_action_1picture (
+ id,
+ x, y, f,
+ 1, 1, 1,
+ function,
+ flags | IN_WINDOW,
+ data
+ );
+}
+
int perform_action (
uint_fast16_t n,
uint_fast16_t *id,
if (r!=0)
break;
- p[i].flags &= ~(IS_GRAY|IS_INDEXED|IS_OVER_8BIT|IS_PALETTE_ONLY);
+ p[i].flags &= ~(HAS_ALPHA|IS_GRAY|IS_INDEXED|IS_OVER_8BIT|IS_PALETTE_ONLY|EFF_ALPHA|EFF_GRAY|EFF_INDEXED);
if (palette_only)
p[i].flags |= IS_PALETTE_ONLY;
switch (p[i].info.image_format)
{
case IL_COLOUR_INDEX:
- p[i].flags |= IS_INDEXED;
+ p[i].flags |= IS_INDEXED | EFF_INDEXED;
r = get_palette(p[i].id, &(p[i].palette), p[i].f_pict);
if (r!=0)
break;
p[i].flags |= IS_OVER_8BIT;
break;
case IL_PAL_BGRA32:
- p[i].flags |= HAS_ALPHA;
+ p[i].flags |= HAS_ALPHA | EFF_ALPHA;
p[i].alpha_offset = 3;
case IL_PAL_BGR24:
p[i].red_offset = 2;
p[i].blue_offset = 0;
break;
case IL_PAL_RGBA32:
- p[i].flags |= HAS_ALPHA;
+ p[i].flags |= HAS_ALPHA | EFF_ALPHA;
p[i].alpha_offset = 3;
case IL_PAL_RGB24:
default:
}
break;
case IL_LUMINANCE_ALPHA:
- p[i].flags |= HAS_ALPHA;
+ p[i].flags |= HAS_ALPHA | EFF_ALPHA;
p[i].alpha_offset = 1 * p[i].info.image_bpc;
case IL_LUMINANCE:
- p[i].flags |= IS_GRAY;
+ p[i].flags |= IS_GRAY | EFF_GRAY;
p[i].value_offset = 0 * p[i].info.image_bpc;
break;
case IL_BGRA:
- p[i].flags |= HAS_ALPHA;
+ p[i].flags |= HAS_ALPHA | EFF_ALPHA;
p[i].alpha_offset = 3 * p[i].info.image_bpc;
case IL_BGR:
p[i].red_offset = 2 * p[i].info.image_bpc;
p[i].blue_offset = 0 * p[i].info.image_bpc;
break;
case IL_RGBA:
- p[i].flags |= HAS_ALPHA;
+ p[i].flags |= HAS_ALPHA | EFF_ALPHA;
p[i].alpha_offset = 3 * p[i].info.image_bpc;
case IL_RGB:
default:
}
if (p[i].info.image_bpc > 1)
p[i].flags |= IS_OVER_8BIT;
+
+ if ((p[i].flags & IS_INDEXED) && (p[i].flags & CANNOT_BE_INDEXED))
+ p[i].flags &= ~EFF_INDEXED;
+ if ((p[i].flags & IS_GRAY) && (p[i].flags & CANNOT_BE_GRAY))
+ p[i].flags &= ~EFF_GRAY;
+ else if (!(p[i].flags & IS_GRAY) && (p[i].flags & MUST_BE_GRAY))
+ p[i].flags |= EFF_GRAY;
+ if ((!(p[i].flags & HAS_ALPHA)) && (p[i].flags & MUST_HAVE_ALPHA))
+ p[i].flags |= EFF_ALPHA;
+ else if ((p[i].flags & HAS_ALPHA) && (p[i].flags & CANNOT_HAVE_ALPHA))
+ p[i].flags &= ~EFF_ALPHA;
}
if (!skip_frame)
{
{
case IL_PAL_BGR32:
case IL_PAL_RGB32:
- p[i].flags |= IS_OVER_8BIT;
break;
case IL_PAL_BGRA32:
- p[i].flags |= HAS_ALPHA;
p[i].alpha_offset = 3;
case IL_PAL_BGR24:
p[i].red_offset = 2;
p[i].blue_offset = 0;
break;
case IL_PAL_RGBA32:
- p[i].flags |= HAS_ALPHA;
p[i].alpha_offset = 3;
case IL_PAL_RGB24:
default:
p[i].blue_offset = 2;
break;
}
+
+ if ((p[i].flags & IS_GRAY) && (p[i].flags & CANNOT_BE_GRAY))
+ p[i].flags &= ~EFF_GRAY;
+ else if (!(p[i].flags & IS_GRAY) && (p[i].flags & MUST_BE_GRAY))
+ p[i].flags |= EFF_GRAY;
+ if ((!(p[i].flags & HAS_ALPHA)) && (p[i].flags & MUST_HAVE_ALPHA))
+ p[i].flags |= EFF_ALPHA;
+ else if ((p[i].flags & HAS_ALPHA) && (p[i].flags & CANNOT_HAVE_ALPHA))
+ p[i].flags &= ~EFF_ALPHA;
}
if (!skip_frame)
{
return (ILubyte)(x >> (8 * (bytes-1)));
}
+int copy_pixels (ILuint n, struct PixelInfo *p, void *data)
+{
+ ILuint max = *((ILuint *)data);
+
+ if (n < 2)
+ return EINVAL;
+
+ if (p[0].flags & EFF_INDEXED)
+ {
+ if (!(p[1].flags & EFF_INDEXED))
+ return EINVAL;
+ p[1].index = p[0].index;
+ }
+ else if (p[0].flags & EFF_ALPHA)
+ {
+ if (p[0].flags & EFF_GRAY)
+ {
+ if (!(p[1].flags & EFF_GRAY))
+ return EINVAL;
+ p[1].value = copy_1p_alpha(p[0].value, p[1].value, p[0].alpha, max);
+ }
+ else
+ {
+ if (p[1].flags & EFF_GRAY)
+ return EINVAL;
+ p[1].red = copy_1p_alpha(p[0].red, p[1].red, p[0].alpha, max);
+ p[1].green = copy_1p_alpha(p[0].green, p[1].green, p[0].alpha, max);
+ p[1].blue = copy_1p_alpha(p[0].blue, p[1].blue, p[0].alpha, max);
+ }
+ if (p[1].flags & EFF_ALPHA)
+ p[1].alpha = copy_1p_alpha(max, p[1].alpha, p[0].alpha, max);
+ }
+ else
+ {
+ if (p[0].flags & EFF_GRAY)
+ {
+ if (!(p[1].flags & EFF_GRAY))
+ return EINVAL;
+ p[1].value = p[0].value;
+ }
+ else
+ {
+ if (p[1].flags & EFF_GRAY)
+ return EINVAL;
+ p[1].red = p[0].red;
+ p[1].green = p[0].green;
+ p[1].blue = p[0].blue;
+ }
+ if (p[1].flags & EFF_ALPHA)
+ p[1].alpha = max;
+ }
+
+ return 0;
+}
+
+int fill_color (ILuint n, struct PixelInfo *p, void *data)
+{
+ struct ColorInfo *d = data;
+
+ if (p->flags & EFF_INDEXED)
+ {
+ p->index = d->index;
+ }
+ else
+ {
+ if (p->flags & EFF_ALPHA)
+ p->alpha = d->alpha;
+ if (p->flags & EFF_GRAY)
+ p->value = d->value;
+ else
+ {
+ p->red = d->red;
+ p->green = d->green;
+ p->blue = d->blue;
+ }
+ }
+
+ return 0;
+}
+
+ILuint copy_1p_alpha (ILint64 src, ILint64 dst, ILint64 alpha, ILint64 max)
+{
+ ILint64 v = (src * alpha + dst * (max - alpha)) / max;
+ return (ILuint)v;
+}
+
+int palette_mix_index (ILuint n, struct PixelInfo *p, void *data)
+{
+ if (n < 3)
+ return EIO;
+
+ p[2].index = p[0].index * p[1].info.palette_num_cols + p[1].index;
+
+ return 0;
+}
+
+ILuint tsqrt(ILuint s)
+{
+ switch(s)
+ {
+ case 256:
+ return 16;
+ case 225:
+ return 15;
+ case 196:
+ return 14;
+ case 169:
+ return 13;
+ case 144:
+ return 12;
+ case 121:
+ return 11;
+ case 100:
+ return 10;
+ case 81:
+ return 9;
+ case 64:
+ return 8;
+ case 49:
+ return 7;
+ case 36:
+ return 6;
+ case 25:
+ return 5;
+ case 16:
+ return 4;
+ case 9:
+ return 3;
+ case 4:
+ return 2;
+ case 1:
+ return 1;
+ default: // not a square - please fail
+ return 0;
+ }
+}
+
+//unsigned short isqrt(unsigned s)
+//{
+// unsigned short r;
+// unsigned short b=0x0040;
+//
+// while(b>s)
+// b>>=2;
+// while(b)
+// {
+// if(s>=r+b)
+// {
+// s-=r+b;
+// r=(r>>1)+b;
+// }
+// else
+// r>>1;
+// b>>2;
+// }
+// return r;
+//}
+
+
// int action(
// ILuint n, struct PixelInfo *info, void *data
// )
bicyclesonthemoon.info / projects / ott / enhance / blobdiff