mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
259 lines
9.3 KiB
C
259 lines
9.3 KiB
C
// After editing this file, run "go generate" in the parent directory.
|
|
|
|
// Copyright 2017 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// ---------------- Images
|
|
|
|
const uint32_t wuffs_base__pixel_format__bits_per_channel[16] = {
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40,
|
|
};
|
|
|
|
// --------
|
|
|
|
static inline uint32_t //
|
|
wuffs_base__swap_u32_argb_abgr(uint32_t u) {
|
|
uint32_t o = u & 0xFF00FF00;
|
|
uint32_t r = u & 0x00FF0000;
|
|
uint32_t b = u & 0x000000FF;
|
|
return o | (r >> 16) | (b << 16);
|
|
}
|
|
|
|
// --------
|
|
|
|
WUFFS_BASE__MAYBE_STATIC wuffs_base__color_u32_argb_premul //
|
|
wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* pb,
|
|
uint32_t x,
|
|
uint32_t y) {
|
|
if (!pb || (x >= pb->pixcfg.private_impl.width) ||
|
|
(y >= pb->pixcfg.private_impl.height)) {
|
|
return 0;
|
|
}
|
|
|
|
if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {
|
|
// TODO: support planar formats.
|
|
return 0;
|
|
}
|
|
|
|
size_t stride = pb->private_impl.planes[0].stride;
|
|
uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));
|
|
|
|
switch (pb->pixcfg.private_impl.pixfmt.repr) {
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
|
|
return wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)));
|
|
|
|
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {
|
|
uint8_t* palette = pb->private_impl.planes[3].ptr;
|
|
return wuffs_base__load_u32le__no_bounds_check(palette +
|
|
(4 * ((size_t)row[x])));
|
|
}
|
|
|
|
// Common formats above. Rarer formats below.
|
|
|
|
case WUFFS_BASE__PIXEL_FORMAT__Y:
|
|
return 0xFF000000 | (0x00010101 * ((uint32_t)(row[x])));
|
|
|
|
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: {
|
|
uint8_t* palette = pb->private_impl.planes[3].ptr;
|
|
return wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
|
wuffs_base__load_u32le__no_bounds_check(palette +
|
|
(4 * ((size_t)row[x]))));
|
|
}
|
|
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
|
|
return wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
|
|
wuffs_base__load_u16le__no_bounds_check(row + (2 * ((size_t)x))));
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGR:
|
|
return 0xFF000000 |
|
|
wuffs_base__load_u24le__no_bounds_check(row + (3 * ((size_t)x)));
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
|
return wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
|
wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))));
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
|
|
return 0xFF000000 |
|
|
wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)));
|
|
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGB:
|
|
return wuffs_base__swap_u32_argb_abgr(
|
|
0xFF000000 |
|
|
wuffs_base__load_u24le__no_bounds_check(row + (3 * ((size_t)x))));
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
|
|
return wuffs_base__swap_u32_argb_abgr(
|
|
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
|
wuffs_base__load_u32le__no_bounds_check(row +
|
|
(4 * ((size_t)x)))));
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
|
|
return wuffs_base__swap_u32_argb_abgr(
|
|
wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))));
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
|
return wuffs_base__swap_u32_argb_abgr(
|
|
0xFF000000 |
|
|
wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))));
|
|
|
|
default:
|
|
// TODO: support more formats.
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
|
wuffs_base__pixel_buffer__set_color_u32_at(
|
|
wuffs_base__pixel_buffer* pb,
|
|
uint32_t x,
|
|
uint32_t y,
|
|
wuffs_base__color_u32_argb_premul color) {
|
|
if (!pb) {
|
|
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
|
}
|
|
if ((x >= pb->pixcfg.private_impl.width) ||
|
|
(y >= pb->pixcfg.private_impl.height)) {
|
|
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
|
}
|
|
|
|
if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {
|
|
// TODO: support planar formats.
|
|
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
|
}
|
|
|
|
size_t stride = pb->private_impl.planes[0].stride;
|
|
uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));
|
|
|
|
switch (pb->pixcfg.private_impl.pixfmt.repr) {
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
|
|
wuffs_base__store_u32le__no_bounds_check(row + (4 * ((size_t)x)), color);
|
|
break;
|
|
|
|
// Common formats above. Rarer formats below.
|
|
|
|
case WUFFS_BASE__PIXEL_FORMAT__Y:
|
|
wuffs_base__store_u8__no_bounds_check(
|
|
row + ((size_t)x),
|
|
wuffs_base__color_u32_argb_premul__as__color_u8_gray(color));
|
|
break;
|
|
|
|
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
|
|
wuffs_base__store_u8__no_bounds_check(
|
|
row + ((size_t)x), wuffs_base__pixel_palette__closest_element(
|
|
wuffs_base__pixel_buffer__palette(pb),
|
|
pb->pixcfg.private_impl.pixfmt, color));
|
|
break;
|
|
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
|
|
wuffs_base__store_u16le__no_bounds_check(
|
|
row + (2 * ((size_t)x)),
|
|
wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(color));
|
|
break;
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGR:
|
|
wuffs_base__store_u24le__no_bounds_check(row + (3 * ((size_t)x)), color);
|
|
break;
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
|
wuffs_base__store_u32le__no_bounds_check(
|
|
row + (4 * ((size_t)x)),
|
|
wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(
|
|
color));
|
|
break;
|
|
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGB:
|
|
wuffs_base__store_u24le__no_bounds_check(
|
|
row + (3 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));
|
|
break;
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
|
|
wuffs_base__store_u32le__no_bounds_check(
|
|
row + (4 * ((size_t)x)),
|
|
wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(
|
|
wuffs_base__swap_u32_argb_abgr(color)));
|
|
break;
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
|
wuffs_base__store_u32le__no_bounds_check(
|
|
row + (4 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));
|
|
break;
|
|
|
|
default:
|
|
// TODO: support more formats.
|
|
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
|
}
|
|
|
|
return wuffs_base__make_status(NULL);
|
|
}
|
|
|
|
// --------
|
|
|
|
WUFFS_BASE__MAYBE_STATIC uint8_t //
|
|
wuffs_base__pixel_palette__closest_element(
|
|
wuffs_base__slice_u8 palette_slice,
|
|
wuffs_base__pixel_format palette_format,
|
|
wuffs_base__color_u32_argb_premul c) {
|
|
size_t n = palette_slice.len / 4;
|
|
if (n > 256) {
|
|
n = 256;
|
|
}
|
|
size_t best_index = 0;
|
|
uint64_t best_score = 0xFFFFFFFFFFFFFFFF;
|
|
|
|
// Work in 16-bit color.
|
|
uint32_t ca = 0x101 * (0xFF & (c >> 24));
|
|
uint32_t cr = 0x101 * (0xFF & (c >> 16));
|
|
uint32_t cg = 0x101 * (0xFF & (c >> 8));
|
|
uint32_t cb = 0x101 * (0xFF & (c >> 0));
|
|
|
|
switch (palette_format.repr) {
|
|
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {
|
|
bool nonpremul = palette_format.repr ==
|
|
WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL;
|
|
|
|
size_t i;
|
|
for (i = 0; i < n; i++) {
|
|
// Work in 16-bit color.
|
|
uint32_t pb = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 0]));
|
|
uint32_t pg = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 1]));
|
|
uint32_t pr = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 2]));
|
|
uint32_t pa = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 3]));
|
|
|
|
// Convert to premultiplied alpha.
|
|
if (nonpremul && (pa != 0xFFFF)) {
|
|
pb = (pb * pa) / 0xFFFF;
|
|
pg = (pg * pa) / 0xFFFF;
|
|
pr = (pr * pa) / 0xFFFF;
|
|
}
|
|
|
|
// These deltas are conceptually int32_t (signed) but after squaring,
|
|
// it's equivalent to work in uint32_t (unsigned).
|
|
pb -= cb;
|
|
pg -= cg;
|
|
pr -= cr;
|
|
pa -= ca;
|
|
uint64_t score = ((uint64_t)(pb * pb)) + ((uint64_t)(pg * pg)) +
|
|
((uint64_t)(pr * pr)) + ((uint64_t)(pa * pa));
|
|
if (best_score > score) {
|
|
best_score = score;
|
|
best_index = i;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return (uint8_t)best_index;
|
|
}
|