mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
std/handsum: add alpha channel support
This commit is contained in:
1 parent
38a5e853c9
commit
30ac5c2e89
10 files changed
+240
-48
No files matched your search
+23
-15
@@ -35,13 +35,13 @@ import (
|
||||
)
|
||||
|
||||
var (
|
||||
decodeFlag = flag.Bool("decode", false, "whether to decode the input")
|
||||
encodeFlag = flag.Bool("encode", false, "whether to encode the input")
|
||||
roundtripFlag = flag.Bool("roundtrip", false, "whether to encode-and-decode the input")
|
||||
decodeFlag = flag.Bool("decode", false, "")
|
||||
encodeFlag = flag.Bool("encode", false, "")
|
||||
roundtripFlag = flag.Bool("roundtrip", false, "")
|
||||
|
||||
bFlag = flag.String("b", "gray", "encoding background color: e.g. red, white, 9c27b0 or #ff8")
|
||||
cFlag = flag.String("c", "rgb", "encoding color: gray (1), rgb (3, default) or rgba (4)")
|
||||
qFlag = flag.Int("q", 3, "encoding quality: 0, 1, 2 or 3 (default)")
|
||||
bFlag = flag.String("b", "", "")
|
||||
cFlag = flag.String("c", "rgb", "")
|
||||
qFlag = flag.Int("q", 3, "")
|
||||
)
|
||||
|
||||
const usageStr = `handsum decodes and encodes the Handsum lossy image file format.
|
||||
@@ -64,19 +64,20 @@ For encode or roundtrip, the default color and quality is -c=rgb -q=3 (best
|
||||
quality; 147 bytes per file) but you can choose a lower setting. The -b flag
|
||||
sets a background color (in case the input has transparency). For example:
|
||||
|
||||
handsum -encode -b=darkblue -c=gray -q=2 foo.png > foo.handsum
|
||||
handsum -encode -b=darkblue -c=rgb -q=2 foo.png > foo.handsum
|
||||
|
||||
----
|
||||
|
||||
Flags:
|
||||
|
||||
-decode
|
||||
-encode
|
||||
-roundtrip
|
||||
-decode Whether to decode the input.
|
||||
-encode Whether to encode the input.
|
||||
-roundtrip Whether to encode-and-decode the input.
|
||||
|
||||
-b encoding background color: e.g. red, white, 9c27b0 or #ff8
|
||||
-c encoding color: gray (1), rgb (3, default) or rgba (4)
|
||||
-q encoding quality: 0, 1, 2 or 3 (default)
|
||||
-b Encoding background color: e.g. red, white, 9c27b0 or #ff8.
|
||||
The default is ff9e9e9e (for -c=1 or -c=3) or 00000000 (for -c=4).
|
||||
-c Encoding color: gray (1), rgb (3, default) or rgba (4).
|
||||
-q Encoding quality: 0, 1, 2 or 3 (default).
|
||||
`
|
||||
|
||||
func main() {
|
||||
@@ -99,6 +100,10 @@ func main1() error {
|
||||
}
|
||||
quality := handsum.Quality(max(0, min(3, *qFlag)))
|
||||
|
||||
if (color <= handsum.ColorRGB) && (*bFlag == "") {
|
||||
*bFlag = "ff9e9e9e"
|
||||
}
|
||||
|
||||
inFile := os.Stdin
|
||||
switch flag.NArg() {
|
||||
case 0:
|
||||
@@ -140,7 +145,7 @@ func encode(w io.Writer, inFile *os.File, color handsum.Color, quality handsum.Q
|
||||
return err
|
||||
}
|
||||
|
||||
if o, ok := src.(interface{ Opaque() bool }); ok && !o.Opaque() {
|
||||
if o, ok := src.(interface{ Opaque() bool }); !ok || !o.Opaque() {
|
||||
src = applyBackgroundColor(src)
|
||||
}
|
||||
|
||||
@@ -165,7 +170,10 @@ func roundtrip(inFile *os.File, color handsum.Color, quality handsum.Quality) er
|
||||
|
||||
func applyBackgroundColor(src image.Image) image.Image {
|
||||
backgroundColor, _ := parsecolor.Parse(*bFlag)
|
||||
r16, g16, b16, _ := backgroundColor.RGBA()
|
||||
r16, g16, b16, a16 := backgroundColor.RGBA()
|
||||
if (r16 == 0) && (g16 == 0) && (b16 == 0) && (a16 == 0) {
|
||||
return src
|
||||
}
|
||||
r8, g8, b8 := uint8(r16>>8), uint8(g16>>8), uint8(b16>>8)
|
||||
|
||||
bounds := src.Bounds()
|
||||
|
||||
+84
-15
@@ -165,7 +165,7 @@ var (
|
||||
|
||||
const (
|
||||
fileSizeHeader = 3
|
||||
fileSizeMax = 147
|
||||
fileSizeMax = 171
|
||||
)
|
||||
|
||||
func fileSize(c Color, q Quality) int {
|
||||
@@ -294,9 +294,8 @@ func Encode(w io.Writer, src image.Image, options *EncodeOptions) error {
|
||||
aspectRatio = byte(a-1) | 0x10
|
||||
}
|
||||
|
||||
dst := image.NewRGBA(image.Rectangle{Max: image.Point{X: 16, Y: 16}})
|
||||
draw.BiLinear.Scale(dst, dst.Bounds(), src, src.Bounds(), draw.Src, nil)
|
||||
|
||||
alphasQuadBlock := lowleveljpeg.QuadBlockU8{}
|
||||
dst := scaleSrc(src, &alphasQuadBlock)
|
||||
dstU8s := lowleveljpeg.Array6BlockU8{}
|
||||
dstU8s.ExtractFrom(dst, 0, 0)
|
||||
|
||||
@@ -319,10 +318,44 @@ func Encode(w io.Writer, src image.Image, options *EncodeOptions) error {
|
||||
bitOffset = encodeBlock(&buf, bitOffset, &dstU8s[i], q.numberOfCoefficients())
|
||||
}
|
||||
|
||||
if c >= ColorRGBA {
|
||||
alphasBlock := lowleveljpeg.BlockU8{}
|
||||
alphasBlock.DownsampleFrom(&alphasQuadBlock)
|
||||
bitOffset = encodeBlockQ3(&buf, bitOffset, &alphasBlock, QualityBest.numberOfCoefficients())
|
||||
}
|
||||
|
||||
_, err := w.Write(buf[:bitOffset/8])
|
||||
return err
|
||||
}
|
||||
|
||||
func scaleSrc(src image.Image, alphasQuadBlock *lowleveljpeg.QuadBlockU8) image.Image {
|
||||
if o, ok := src.(interface{ Opaque() bool }); ok && o.Opaque() {
|
||||
for i := range alphasQuadBlock {
|
||||
alphasQuadBlock[i] = 0xFF
|
||||
}
|
||||
dst := image.NewRGBA(image.Rectangle{Max: image.Point{X: 16, Y: 16}})
|
||||
draw.BiLinear.Scale(dst, dst.Bounds(), src, src.Bounds(), draw.Src, nil)
|
||||
return dst
|
||||
}
|
||||
|
||||
dst := image.NewNRGBA(image.Rectangle{Max: image.Point{X: 16, Y: 16}})
|
||||
draw.BiLinear.Scale(dst, dst.Bounds(), src, src.Bounds(), draw.Src, nil)
|
||||
|
||||
// Extract alphasQuadBlock (as a side effect of calling this function) and
|
||||
// set dst's alpha values to 0xFF.
|
||||
for i := range alphasQuadBlock {
|
||||
v := dst.Pix[(4*i)+3]
|
||||
dst.Pix[(4*i)+3] = 0xFF
|
||||
alphasQuadBlock[i] = v
|
||||
}
|
||||
|
||||
return &image.RGBA{ // Re-interpret NRGBA as RGBA.
|
||||
Pix: dst.Pix,
|
||||
Stride: dst.Stride,
|
||||
Rect: dst.Rect,
|
||||
}
|
||||
}
|
||||
|
||||
type encodeBlockFunc func(buf *[fileSizeMax]byte, bitOffset int, src *lowleveljpeg.BlockU8, nCoeffs int) int
|
||||
|
||||
var encodeBlockFuncs = [4]encodeBlockFunc{
|
||||
@@ -421,8 +454,10 @@ func DecodeConfig(r io.Reader) (image.Config, error) {
|
||||
}
|
||||
|
||||
cm := color.GrayModel
|
||||
if c > ColorGray {
|
||||
if c == ColorRGB {
|
||||
cm = color.RGBAModel
|
||||
} else if c == ColorRGBA {
|
||||
cm = color.NRGBAModel
|
||||
}
|
||||
|
||||
w, h := decodeWidthAndHeight(buf[2])
|
||||
@@ -440,7 +475,7 @@ func decodeColorSetting(buf1 byte, buf2 byte) (Color, bool) {
|
||||
case 2:
|
||||
return ColorRGB, true
|
||||
case 3:
|
||||
// TODO: return ColorRGBA, true
|
||||
return ColorRGBA, true
|
||||
}
|
||||
return 0, false
|
||||
}
|
||||
@@ -473,8 +508,12 @@ func Decode(r io.Reader) (image.Image, error) {
|
||||
|
||||
cbQuadBlockU8 := lowleveljpeg.QuadBlockU8{}
|
||||
crQuadBlockU8 := lowleveljpeg.QuadBlockU8{}
|
||||
aaQuadBlockU8 := lowleveljpeg.QuadBlockU8{}
|
||||
for i := range aaQuadBlockU8 {
|
||||
aaQuadBlockU8[i] = 0xFF
|
||||
}
|
||||
|
||||
if c > ColorGray {
|
||||
if c >= ColorRGB {
|
||||
cbBlockU8 := lowleveljpeg.BlockU8{}
|
||||
crBlockU8 := lowleveljpeg.BlockU8{}
|
||||
|
||||
@@ -485,10 +524,16 @@ func Decode(r io.Reader) (image.Image, error) {
|
||||
|
||||
cbQuadBlockU8.UpsampleFrom(&cbBlockU8)
|
||||
crQuadBlockU8.UpsampleFrom(&crBlockU8)
|
||||
|
||||
if c >= ColorRGBA {
|
||||
aaBlockU8 := lowleveljpeg.BlockU8{}
|
||||
bitOffset = decodeBlockQ3(aaBlockU8[:], 8, &buf, bitOffset, QualityBest.numberOfCoefficients())
|
||||
aaQuadBlockU8.UpsampleFrom(&aaBlockU8)
|
||||
}
|
||||
}
|
||||
|
||||
dstW, dstH := decodeWidthAndHeight(buf[2])
|
||||
return finishDecode(dstW, dstH, c == ColorGray, &lumaQuadBlockU8, &cbQuadBlockU8, &crQuadBlockU8), nil
|
||||
return finishDecode(dstW, dstH, c, &lumaQuadBlockU8, &cbQuadBlockU8, &crQuadBlockU8, &aaQuadBlockU8), nil
|
||||
}
|
||||
|
||||
func decodeWidthAndHeight(buf2 byte) (w int, h int) {
|
||||
@@ -613,10 +658,17 @@ func decodeBlockQ3(dst []byte, stride int, buf *[fileSizeMax]byte, bitOffset int
|
||||
return bitOffset
|
||||
}
|
||||
|
||||
func finishDecode(w int, h int, gray bool, yy *lowleveljpeg.QuadBlockU8, cb *lowleveljpeg.QuadBlockU8, cr *lowleveljpeg.QuadBlockU8) image.Image {
|
||||
func finishDecode(w int,
|
||||
h int,
|
||||
c Color,
|
||||
yy *lowleveljpeg.QuadBlockU8,
|
||||
cb *lowleveljpeg.QuadBlockU8,
|
||||
cr *lowleveljpeg.QuadBlockU8,
|
||||
aa *lowleveljpeg.QuadBlockU8) image.Image {
|
||||
|
||||
tmp := [1024]byte{}
|
||||
|
||||
if gray {
|
||||
if c == ColorGray {
|
||||
for i := range 256 {
|
||||
tmp[(4 * i)] = yy[i]
|
||||
}
|
||||
@@ -624,7 +676,7 @@ func finishDecode(w int, h int, gray bool, yy *lowleveljpeg.QuadBlockU8, cb *low
|
||||
for i := range 256 {
|
||||
tmp[(4*i)+0], tmp[(4*i)+1], tmp[(4*i)+2] =
|
||||
color.YCbCrToRGB(yy[i], cb[i], cr[i])
|
||||
tmp[(4*i)+3] = 0xFF
|
||||
tmp[(4*i)+3] = aa[i]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -635,15 +687,22 @@ func finishDecode(w int, h int, gray bool, yy *lowleveljpeg.QuadBlockU8, cb *low
|
||||
pix = scaleVertical(&tmp, uint32(h))
|
||||
}
|
||||
|
||||
if gray {
|
||||
if c == ColorGray {
|
||||
return &image.Gray{
|
||||
Pix: convertYxxxToY(pix),
|
||||
Stride: w,
|
||||
Rect: image.Rect(0, 0, w, h),
|
||||
}
|
||||
|
||||
} else if c == ColorRGB {
|
||||
return &image.RGBA{
|
||||
Pix: pix,
|
||||
Stride: 4 * w,
|
||||
Rect: image.Rect(0, 0, w, h),
|
||||
}
|
||||
}
|
||||
|
||||
return &image.RGBA{
|
||||
return &image.NRGBA{
|
||||
Pix: pix,
|
||||
Stride: 4 * w,
|
||||
Rect: image.Rect(0, 0, w, h),
|
||||
@@ -658,29 +717,33 @@ func scaleHorizontal(src *[1024]byte, w uint32) []byte {
|
||||
acc0 := uint32(0)
|
||||
acc1 := uint32(0)
|
||||
acc2 := uint32(0)
|
||||
acc3 := uint32(0)
|
||||
remainder := uint32(16)
|
||||
for srcx := range 16 {
|
||||
si := (64 * y) + (4 * srcx)
|
||||
s0 := uint32(src[si+0])
|
||||
s1 := uint32(src[si+1])
|
||||
s2 := uint32(src[si+2])
|
||||
s3 := uint32(src[si+3])
|
||||
|
||||
if remainder > w {
|
||||
remainder -= w
|
||||
acc0 += w * s0
|
||||
acc1 += w * s1
|
||||
acc2 += w * s2
|
||||
acc3 += w * s3
|
||||
|
||||
} else {
|
||||
acc0 += remainder * s0
|
||||
acc1 += remainder * s1
|
||||
acc2 += remainder * s2
|
||||
acc3 += remainder * s3
|
||||
|
||||
di := (4 * int(w) * y) + (4 * dstx)
|
||||
dst[di+0] = uint8((acc0 + 8) / 16)
|
||||
dst[di+1] = uint8((acc1 + 8) / 16)
|
||||
dst[di+2] = uint8((acc2 + 8) / 16)
|
||||
dst[di+3] = 0xFF
|
||||
dst[di+3] = uint8((acc3 + 8) / 16)
|
||||
dstx++
|
||||
|
||||
partial := w - remainder
|
||||
@@ -688,6 +751,7 @@ func scaleHorizontal(src *[1024]byte, w uint32) []byte {
|
||||
acc0 = partial * s0
|
||||
acc1 = partial * s1
|
||||
acc2 = partial * s2
|
||||
acc3 = partial * s3
|
||||
|
||||
remainder = 16 - partial
|
||||
}
|
||||
@@ -705,29 +769,33 @@ func scaleVertical(src *[1024]byte, h uint32) []byte {
|
||||
acc0 := uint32(0)
|
||||
acc1 := uint32(0)
|
||||
acc2 := uint32(0)
|
||||
acc3 := uint32(0)
|
||||
remainder := uint32(16)
|
||||
for srcy := range 16 {
|
||||
si := (64 * srcy) + (4 * x)
|
||||
s0 := uint32(src[si+0])
|
||||
s1 := uint32(src[si+1])
|
||||
s2 := uint32(src[si+2])
|
||||
s3 := uint32(src[si+3])
|
||||
|
||||
if remainder > h {
|
||||
remainder -= h
|
||||
acc0 += h * s0
|
||||
acc1 += h * s1
|
||||
acc2 += h * s2
|
||||
acc3 += h * s3
|
||||
|
||||
} else {
|
||||
acc0 += remainder * s0
|
||||
acc1 += remainder * s1
|
||||
acc2 += remainder * s2
|
||||
acc3 += remainder * s3
|
||||
|
||||
di := (64 * dsty) + (4 * x)
|
||||
dst[di+0] = uint8((acc0 + 8) / 16)
|
||||
dst[di+1] = uint8((acc1 + 8) / 16)
|
||||
dst[di+2] = uint8((acc2 + 8) / 16)
|
||||
dst[di+3] = 0xFF
|
||||
dst[di+3] = uint8((acc3 + 8) / 16)
|
||||
dsty++
|
||||
|
||||
partial := h - remainder
|
||||
@@ -735,6 +803,7 @@ func scaleVertical(src *[1024]byte, h uint32) []byte {
|
||||
acc0 = partial * s0
|
||||
acc1 = partial * s1
|
||||
acc2 = partial * s2
|
||||
acc3 = partial * s3
|
||||
|
||||
remainder = 16 - partial
|
||||
}
|
||||
|
||||
@@ -28,7 +28,7 @@ func testRoundTrip(tt *testing.T, src image.Image, pixelValue uint8, justCheckTh
|
||||
colors := []Color{
|
||||
ColorGray,
|
||||
ColorRGB,
|
||||
// TODO: ColorRGBA,
|
||||
ColorRGBA,
|
||||
}
|
||||
|
||||
for _, c := range colors {
|
||||
|
||||
@@ -50329,7 +50329,7 @@ WUFFS_HANDSUM__PAYLOAD_SIZES[4][4] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
}, {
|
||||
45u, 72u, 120u, 144u,
|
||||
}, {
|
||||
76u, 99u, 147u, 171u,
|
||||
69u, 96u, 144u, 168u,
|
||||
},
|
||||
};
|
||||
|
||||
@@ -50622,6 +50622,14 @@ wuffs_handsum__decoder__decode_block_q3(
|
||||
uint32_t a_y_offset,
|
||||
uint32_t a_x_offset);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_handsum__decoder__set_block_0xff(
|
||||
wuffs_handsum__decoder* self,
|
||||
uint32_t a_which,
|
||||
uint32_t a_y_offset,
|
||||
uint32_t a_x_offset);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_handsum__decoder__smooth_seams_16x16(
|
||||
@@ -50653,7 +50661,7 @@ wuffs_handsum__decoder__convert_yxxx_to_y(
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_handsum__decoder__convert_yccx_to_bgrx(
|
||||
wuffs_handsum__decoder__convert_ycca_to_bgra(
|
||||
wuffs_handsum__decoder* self);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -50953,7 +50961,7 @@ wuffs_handsum__decoder__do_decode_image_config(
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_color = ((v_c32 >> 7u) & 3u);
|
||||
if ((self->private_impl.f_color & 1u) == 1u) {
|
||||
if (self->private_impl.f_color == 1u) {
|
||||
status = wuffs_base__make_status(wuffs_handsum__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
@@ -50967,8 +50975,10 @@ wuffs_handsum__decoder__do_decode_image_config(
|
||||
}
|
||||
if (a_dst != NULL) {
|
||||
v_pixfmt = 536870920u;
|
||||
if (self->private_impl.f_color != 0u) {
|
||||
if (self->private_impl.f_color == 2u) {
|
||||
v_pixfmt = 2415954056u;
|
||||
} else if (self->private_impl.f_color > 2u) {
|
||||
v_pixfmt = 2164295816u;
|
||||
}
|
||||
wuffs_base__image_config__set(
|
||||
a_dst,
|
||||
@@ -51282,8 +51292,10 @@ wuffs_handsum__decoder__do_decode_frame(
|
||||
goto ok;
|
||||
}
|
||||
v_pixfmt = 536870920u;
|
||||
if (self->private_impl.f_color != 0u) {
|
||||
if (self->private_impl.f_color == 2u) {
|
||||
v_pixfmt = 2415954056u;
|
||||
} else if (self->private_impl.f_color > 2u) {
|
||||
v_pixfmt = 2164295816u;
|
||||
}
|
||||
v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
|
||||
wuffs_base__pixel_buffer__pixel_format(a_dst),
|
||||
@@ -51342,11 +51354,16 @@ wuffs_handsum__decoder__do_decode_frame(
|
||||
wuffs_handsum__decoder__decode_block_q3(self, 1u, 0u, 2u);
|
||||
}
|
||||
}
|
||||
if (self->private_impl.f_color < 3u) {
|
||||
wuffs_handsum__decoder__set_block_0xff(self, 1u, 0u, 3u);
|
||||
} else {
|
||||
wuffs_handsum__decoder__decode_block_q3(self, 1u, 0u, 3u);
|
||||
}
|
||||
wuffs_handsum__decoder__smooth_seams_16x16(self);
|
||||
if (self->private_impl.f_color != 0u) {
|
||||
wuffs_handsum__decoder__scale_and_bias_chroma_down(self);
|
||||
wuffs_handsum__decoder__upsample_chroma(self);
|
||||
wuffs_handsum__decoder__convert_yccx_to_bgrx(self);
|
||||
wuffs_handsum__decoder__convert_ycca_to_bgra(self);
|
||||
}
|
||||
v_which = 0u;
|
||||
if (self->private_impl.f_width < 16u) {
|
||||
@@ -51650,6 +51667,30 @@ wuffs_handsum__decoder__decode_block_q3(
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func handsum.decoder.set_block_0xff
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_handsum__decoder__set_block_0xff(
|
||||
wuffs_handsum__decoder* self,
|
||||
uint32_t a_which,
|
||||
uint32_t a_y_offset,
|
||||
uint32_t a_x_offset) {
|
||||
uint32_t v_y = 0;
|
||||
uint32_t v_x = 0;
|
||||
|
||||
v_y = 0u;
|
||||
while (v_y < 7u) {
|
||||
v_x = 0u;
|
||||
while (v_x < 7u) {
|
||||
self->private_data.f_buffers[a_which][(a_y_offset + v_y)][(a_x_offset + (4u * v_x))] = 255u;
|
||||
v_x += 1u;
|
||||
}
|
||||
v_y += 1u;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func handsum.decoder.smooth_seams_16x16
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -51856,6 +51897,11 @@ wuffs_handsum__decoder__upsample_chroma(
|
||||
(((uint32_t)(self->private_data.f_buffers[1u][v_y1][((4u * v_x0) + 2u)])) * 3u) +
|
||||
((uint32_t)(self->private_data.f_buffers[1u][v_y1][((4u * v_x1) + 2u)])) +
|
||||
8u) / 16u)));
|
||||
self->private_data.f_buffers[0u][v_y][((4u * v_x) + 3u)] = ((uint8_t)((((((uint32_t)(self->private_data.f_buffers[1u][v_y0][((4u * v_x0) + 3u)])) * 9u) +
|
||||
(((uint32_t)(self->private_data.f_buffers[1u][v_y0][((4u * v_x1) + 3u)])) * 3u) +
|
||||
(((uint32_t)(self->private_data.f_buffers[1u][v_y1][((4u * v_x0) + 3u)])) * 3u) +
|
||||
((uint32_t)(self->private_data.f_buffers[1u][v_y1][((4u * v_x1) + 3u)])) +
|
||||
8u) / 16u)));
|
||||
v_x += 1u;
|
||||
}
|
||||
v_y += 1u;
|
||||
@@ -51885,11 +51931,11 @@ wuffs_handsum__decoder__convert_yxxx_to_y(
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func handsum.decoder.convert_yccx_to_bgrx
|
||||
// -------- func handsum.decoder.convert_ycca_to_bgra
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_handsum__decoder__convert_yccx_to_bgrx(
|
||||
wuffs_handsum__decoder__convert_ycca_to_bgra(
|
||||
wuffs_handsum__decoder* self) {
|
||||
uint32_t v_y = 0;
|
||||
uint32_t v_x = 0;
|
||||
@@ -51947,9 +51993,11 @@ wuffs_handsum__decoder__scale_horizontal(
|
||||
uint32_t v_acc0 = 0;
|
||||
uint32_t v_acc1 = 0;
|
||||
uint32_t v_acc2 = 0;
|
||||
uint32_t v_acc3 = 0;
|
||||
uint32_t v_s0 = 0;
|
||||
uint32_t v_s1 = 0;
|
||||
uint32_t v_s2 = 0;
|
||||
uint32_t v_s3 = 0;
|
||||
uint32_t v_remainder = 0;
|
||||
uint32_t v_partial = 0;
|
||||
|
||||
@@ -51960,29 +52008,34 @@ wuffs_handsum__decoder__scale_horizontal(
|
||||
v_acc0 = 0u;
|
||||
v_acc1 = 0u;
|
||||
v_acc2 = 0u;
|
||||
v_acc3 = 0u;
|
||||
v_remainder = 16u;
|
||||
while (v_srcx < 16u) {
|
||||
v_s0 = ((uint32_t)(self->private_data.f_buffers[0u][v_y][((4u * v_srcx) + 0u)]));
|
||||
v_s1 = ((uint32_t)(self->private_data.f_buffers[0u][v_y][((4u * v_srcx) + 1u)]));
|
||||
v_s2 = ((uint32_t)(self->private_data.f_buffers[0u][v_y][((4u * v_srcx) + 2u)]));
|
||||
v_s3 = ((uint32_t)(self->private_data.f_buffers[0u][v_y][((4u * v_srcx) + 3u)]));
|
||||
if (v_remainder > self->private_impl.f_width) {
|
||||
v_remainder -= self->private_impl.f_width;
|
||||
v_acc0 += (self->private_impl.f_width * v_s0);
|
||||
v_acc1 += (self->private_impl.f_width * v_s1);
|
||||
v_acc2 += (self->private_impl.f_width * v_s2);
|
||||
v_acc3 += (self->private_impl.f_width * v_s3);
|
||||
} else {
|
||||
v_acc0 += (v_remainder * v_s0);
|
||||
v_acc1 += (v_remainder * v_s1);
|
||||
v_acc2 += (v_remainder * v_s2);
|
||||
v_acc3 += (v_remainder * v_s3);
|
||||
self->private_data.f_buffers[1u][v_y][((4u * v_dstx) + 0u)] = ((uint8_t)((((uint32_t)(v_acc0 + 8u)) / 16u)));
|
||||
self->private_data.f_buffers[1u][v_y][((4u * v_dstx) + 1u)] = ((uint8_t)((((uint32_t)(v_acc1 + 8u)) / 16u)));
|
||||
self->private_data.f_buffers[1u][v_y][((4u * v_dstx) + 2u)] = ((uint8_t)((((uint32_t)(v_acc2 + 8u)) / 16u)));
|
||||
self->private_data.f_buffers[1u][v_y][((4u * v_dstx) + 3u)] = 255u;
|
||||
self->private_data.f_buffers[1u][v_y][((4u * v_dstx) + 3u)] = ((uint8_t)((((uint32_t)(v_acc3 + 8u)) / 16u)));
|
||||
v_dstx = ((v_dstx + 1u) & 15u);
|
||||
v_partial = (self->private_impl.f_width - v_remainder);
|
||||
v_acc0 = (v_partial * v_s0);
|
||||
v_acc1 = (v_partial * v_s1);
|
||||
v_acc2 = (v_partial * v_s2);
|
||||
v_acc3 = (v_partial * v_s3);
|
||||
v_remainder = (16u - v_partial);
|
||||
}
|
||||
v_srcx += 1u;
|
||||
@@ -52004,9 +52057,11 @@ wuffs_handsum__decoder__scale_vertical(
|
||||
uint32_t v_acc0 = 0;
|
||||
uint32_t v_acc1 = 0;
|
||||
uint32_t v_acc2 = 0;
|
||||
uint32_t v_acc3 = 0;
|
||||
uint32_t v_s0 = 0;
|
||||
uint32_t v_s1 = 0;
|
||||
uint32_t v_s2 = 0;
|
||||
uint32_t v_s3 = 0;
|
||||
uint32_t v_remainder = 0;
|
||||
uint32_t v_partial = 0;
|
||||
|
||||
@@ -52017,29 +52072,34 @@ wuffs_handsum__decoder__scale_vertical(
|
||||
v_acc0 = 0u;
|
||||
v_acc1 = 0u;
|
||||
v_acc2 = 0u;
|
||||
v_acc3 = 0u;
|
||||
v_remainder = 16u;
|
||||
while (v_srcy < 16u) {
|
||||
v_s0 = ((uint32_t)(self->private_data.f_buffers[0u][v_srcy][((4u * v_x) + 0u)]));
|
||||
v_s1 = ((uint32_t)(self->private_data.f_buffers[0u][v_srcy][((4u * v_x) + 1u)]));
|
||||
v_s2 = ((uint32_t)(self->private_data.f_buffers[0u][v_srcy][((4u * v_x) + 2u)]));
|
||||
v_s3 = ((uint32_t)(self->private_data.f_buffers[0u][v_srcy][((4u * v_x) + 3u)]));
|
||||
if (v_remainder > self->private_impl.f_height) {
|
||||
v_remainder -= self->private_impl.f_height;
|
||||
v_acc0 += (self->private_impl.f_height * v_s0);
|
||||
v_acc1 += (self->private_impl.f_height * v_s1);
|
||||
v_acc2 += (self->private_impl.f_height * v_s2);
|
||||
v_acc3 += (self->private_impl.f_height * v_s3);
|
||||
} else {
|
||||
v_acc0 += (v_remainder * v_s0);
|
||||
v_acc1 += (v_remainder * v_s1);
|
||||
v_acc2 += (v_remainder * v_s2);
|
||||
v_acc3 += (v_remainder * v_s3);
|
||||
self->private_data.f_buffers[1u][v_dsty][((4u * v_x) + 0u)] = ((uint8_t)((((uint32_t)(v_acc0 + 8u)) / 16u)));
|
||||
self->private_data.f_buffers[1u][v_dsty][((4u * v_x) + 1u)] = ((uint8_t)((((uint32_t)(v_acc1 + 8u)) / 16u)));
|
||||
self->private_data.f_buffers[1u][v_dsty][((4u * v_x) + 2u)] = ((uint8_t)((((uint32_t)(v_acc2 + 8u)) / 16u)));
|
||||
self->private_data.f_buffers[1u][v_dsty][((4u * v_x) + 3u)] = 255u;
|
||||
self->private_data.f_buffers[1u][v_dsty][((4u * v_x) + 3u)] = ((uint8_t)((((uint32_t)(v_acc3 + 8u)) / 16u)));
|
||||
v_dsty = ((v_dsty + 1u) & 15u);
|
||||
v_partial = (self->private_impl.f_height - v_remainder);
|
||||
v_acc0 = (v_partial * v_s0);
|
||||
v_acc1 = (v_partial * v_s1);
|
||||
v_acc2 = (v_partial * v_s2);
|
||||
v_acc3 = (v_partial * v_s3);
|
||||
v_remainder = (16u - v_partial);
|
||||
}
|
||||
v_srcy += 1u;
|
||||
|
||||
@@ -73,7 +73,7 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
return "#bad header"
|
||||
}
|
||||
this.color = (c32 >> 7) & 3
|
||||
if (this.color & 1) == 1 {
|
||||
if this.color == 1 {
|
||||
return "#bad header"
|
||||
}
|
||||
this.quality = (c32 >> 5) & 3
|
||||
@@ -88,8 +88,10 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
|
||||
if args.dst <> nullptr {
|
||||
pixfmt = base.PIXEL_FORMAT__Y
|
||||
if this.color <> 0 {
|
||||
if this.color == 2 {
|
||||
pixfmt = base.PIXEL_FORMAT__BGRX
|
||||
} else if this.color > 2 {
|
||||
pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
}
|
||||
|
||||
args.dst.set!(
|
||||
@@ -178,8 +180,10 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
}
|
||||
|
||||
pixfmt = base.PIXEL_FORMAT__Y
|
||||
if this.color <> 0 {
|
||||
if this.color == 2 {
|
||||
pixfmt = base.PIXEL_FORMAT__BGRX
|
||||
} else if this.color > 2 {
|
||||
pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
}
|
||||
|
||||
status = this.swizzler.prepare!(
|
||||
@@ -239,12 +243,18 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
}
|
||||
}
|
||||
|
||||
if this.color < 3 {
|
||||
this.set_block_0xff!(which: 1, y_offset: 0, x_offset: 3)
|
||||
} else {
|
||||
this.decode_block_q3!(which: 1, y_offset: 0, x_offset: 3)
|
||||
}
|
||||
|
||||
this.smooth_seams_16x16!()
|
||||
|
||||
if this.color <> 0 {
|
||||
this.scale_and_bias_chroma_down!()
|
||||
this.upsample_chroma!()
|
||||
this.convert_yccx_to_bgrx!()
|
||||
this.convert_ycca_to_bgra!()
|
||||
}
|
||||
|
||||
which = 0
|
||||
@@ -607,6 +617,24 @@ pri func decoder.decode_block_q3!(which: base.u32[..= 1], y_offset: base.u32[..=
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.set_block_0xff!(which: base.u32[..= 1], y_offset: base.u32[..= 8], x_offset: base.u32[..= 32]) {
|
||||
var y : base.u32
|
||||
var x : base.u32
|
||||
|
||||
y = 0
|
||||
while y < 7 {
|
||||
x = 0
|
||||
while x < 7,
|
||||
inv y < 7,
|
||||
{
|
||||
this.buffers[args.which][args.y_offset + y][args.x_offset + (4 * x)] = 0xFF
|
||||
|
||||
x += 1
|
||||
}
|
||||
y += 1
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.smooth_seams_16x16!() {
|
||||
var i : base.u32
|
||||
var p0 : base.u8
|
||||
@@ -793,6 +821,12 @@ pri func decoder.upsample_chroma!() {
|
||||
((this.buffers[1][y1][(4 * x0) + 2] as base.u32) * 3) +
|
||||
(this.buffers[1][y1][(4 * x1) + 2] as base.u32) + 8) / 16) as base.u8
|
||||
|
||||
this.buffers[0][y][(4 * x) + 3] = ((
|
||||
((this.buffers[1][y0][(4 * x0) + 3] as base.u32) * 9) +
|
||||
((this.buffers[1][y0][(4 * x1) + 3] as base.u32) * 3) +
|
||||
((this.buffers[1][y1][(4 * x0) + 3] as base.u32) * 3) +
|
||||
(this.buffers[1][y1][(4 * x1) + 3] as base.u32) + 8) / 16) as base.u8
|
||||
|
||||
x += 1
|
||||
}
|
||||
y += 1
|
||||
@@ -817,7 +851,7 @@ pri func decoder.convert_yxxx_to_y!(which: base.u32[..= 1]) {
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.convert_yccx_to_bgrx!() {
|
||||
pri func decoder.convert_ycca_to_bgra!() {
|
||||
var y : base.u32
|
||||
var x : base.u32
|
||||
var yy1 : base.u32
|
||||
@@ -878,9 +912,11 @@ pri func decoder.scale_horizontal!() {
|
||||
var acc0 : base.u32
|
||||
var acc1 : base.u32
|
||||
var acc2 : base.u32
|
||||
var acc3 : base.u32
|
||||
var s0 : base.u32[..= 0xFF]
|
||||
var s1 : base.u32[..= 0xFF]
|
||||
var s2 : base.u32[..= 0xFF]
|
||||
var s3 : base.u32[..= 0xFF]
|
||||
var remainder : base.u32[..= 16]
|
||||
var partial : base.u32[..= 16]
|
||||
|
||||
@@ -891,6 +927,7 @@ pri func decoder.scale_horizontal!() {
|
||||
acc0 = 0
|
||||
acc1 = 0
|
||||
acc2 = 0
|
||||
acc3 = 0
|
||||
remainder = 16
|
||||
while srcx < 16,
|
||||
inv y < 16,
|
||||
@@ -898,12 +935,14 @@ pri func decoder.scale_horizontal!() {
|
||||
s0 = this.buffers[0][y][(4 * srcx) + 0] as base.u32
|
||||
s1 = this.buffers[0][y][(4 * srcx) + 1] as base.u32
|
||||
s2 = this.buffers[0][y][(4 * srcx) + 2] as base.u32
|
||||
s3 = this.buffers[0][y][(4 * srcx) + 3] as base.u32
|
||||
|
||||
if remainder > this.width {
|
||||
remainder -= this.width
|
||||
acc0 ~mod+= this.width * s0
|
||||
acc1 ~mod+= this.width * s1
|
||||
acc2 ~mod+= this.width * s2
|
||||
acc3 ~mod+= this.width * s3
|
||||
|
||||
} else {
|
||||
assert this.width >= remainder via "a >= b: b <= a"()
|
||||
@@ -911,11 +950,12 @@ pri func decoder.scale_horizontal!() {
|
||||
acc0 ~mod+= remainder * s0
|
||||
acc1 ~mod+= remainder * s1
|
||||
acc2 ~mod+= remainder * s2
|
||||
acc3 ~mod+= remainder * s3
|
||||
|
||||
this.buffers[1][y][(4 * dstx) + 0] = (((acc0 ~mod+ 8) / 16) & 0xFF) as base.u8
|
||||
this.buffers[1][y][(4 * dstx) + 1] = (((acc1 ~mod+ 8) / 16) & 0xFF) as base.u8
|
||||
this.buffers[1][y][(4 * dstx) + 2] = (((acc2 ~mod+ 8) / 16) & 0xFF) as base.u8
|
||||
this.buffers[1][y][(4 * dstx) + 3] = 0xFF
|
||||
this.buffers[1][y][(4 * dstx) + 3] = (((acc3 ~mod+ 8) / 16) & 0xFF) as base.u8
|
||||
dstx = (dstx + 1) & 15
|
||||
|
||||
partial = this.width - remainder
|
||||
@@ -923,6 +963,7 @@ pri func decoder.scale_horizontal!() {
|
||||
acc0 = partial * s0
|
||||
acc1 = partial * s1
|
||||
acc2 = partial * s2
|
||||
acc3 = partial * s3
|
||||
|
||||
remainder = 16 - partial
|
||||
}
|
||||
@@ -940,9 +981,11 @@ pri func decoder.scale_vertical!() {
|
||||
var acc0 : base.u32
|
||||
var acc1 : base.u32
|
||||
var acc2 : base.u32
|
||||
var acc3 : base.u32
|
||||
var s0 : base.u32[..= 0xFF]
|
||||
var s1 : base.u32[..= 0xFF]
|
||||
var s2 : base.u32[..= 0xFF]
|
||||
var s3 : base.u32[..= 0xFF]
|
||||
var remainder : base.u32[..= 16]
|
||||
var partial : base.u32[..= 16]
|
||||
|
||||
@@ -953,6 +996,7 @@ pri func decoder.scale_vertical!() {
|
||||
acc0 = 0
|
||||
acc1 = 0
|
||||
acc2 = 0
|
||||
acc3 = 0
|
||||
remainder = 16
|
||||
while srcy < 16,
|
||||
inv x < 16,
|
||||
@@ -960,12 +1004,14 @@ pri func decoder.scale_vertical!() {
|
||||
s0 = this.buffers[0][srcy][(4 * x) + 0] as base.u32
|
||||
s1 = this.buffers[0][srcy][(4 * x) + 1] as base.u32
|
||||
s2 = this.buffers[0][srcy][(4 * x) + 2] as base.u32
|
||||
s3 = this.buffers[0][srcy][(4 * x) + 3] as base.u32
|
||||
|
||||
if remainder > this.height {
|
||||
remainder -= this.height
|
||||
acc0 ~mod+= this.height * s0
|
||||
acc1 ~mod+= this.height * s1
|
||||
acc2 ~mod+= this.height * s2
|
||||
acc3 ~mod+= this.height * s3
|
||||
|
||||
} else {
|
||||
assert this.height >= remainder via "a >= b: b <= a"()
|
||||
@@ -973,11 +1019,12 @@ pri func decoder.scale_vertical!() {
|
||||
acc0 ~mod+= remainder * s0
|
||||
acc1 ~mod+= remainder * s1
|
||||
acc2 ~mod+= remainder * s2
|
||||
acc3 ~mod+= remainder * s3
|
||||
|
||||
this.buffers[1][dsty][(4 * x) + 0] = (((acc0 ~mod+ 8) / 16) & 0xFF) as base.u8
|
||||
this.buffers[1][dsty][(4 * x) + 1] = (((acc1 ~mod+ 8) / 16) & 0xFF) as base.u8
|
||||
this.buffers[1][dsty][(4 * x) + 2] = (((acc2 ~mod+ 8) / 16) & 0xFF) as base.u8
|
||||
this.buffers[1][dsty][(4 * x) + 3] = 0xFF
|
||||
this.buffers[1][dsty][(4 * x) + 3] = (((acc3 ~mod+ 8) / 16) & 0xFF) as base.u8
|
||||
dsty = (dsty + 1) & 15
|
||||
|
||||
partial = this.height - remainder
|
||||
@@ -985,6 +1032,7 @@ pri func decoder.scale_vertical!() {
|
||||
acc0 = partial * s0
|
||||
acc1 = partial * s1
|
||||
acc2 = partial * s2
|
||||
acc3 = partial * s3
|
||||
|
||||
remainder = 16 - partial
|
||||
}
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
þ×/ˆˆˆˆˆˆˆˆˆˆ‡xˆ‰˜y‰ˆxˆ§yˆˆy‡ˆ‰‡x‰ˆˆ‰ˆˆx™ˆy‡ˆ‰ˆˆ‰ˆˆB¥še¦‡evwgwˆ®{uè¯É«š™¸—¹
|
||||
@@ -0,0 +1 @@
|
||||
þ×oˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆiˆˆˆ‰˜Šˆˆˆ‰™ˆ˜yvˆ—‡×ˆ‡™˜‡¸†—ˆ˜ˆˆ˜ˆy˜‰y˜ˆy˜‰‰˜ˆy˜ˆ‰˜ˆ‰˜ˆˆ˜ˆx˜ˆ˜…g‰˜ˆ‰˜ˆ‰˜ˆ‰˜ˆ‰˜ˆ�*–dX´�F5ufgEeHwqˆ…f‰w†w�øˆû�ô�Øë˜\ÃܼØÉ!‹«‡ªŠ™
|
||||
@@ -0,0 +1 @@
|
||||
�ラッ㊧��㊧��㊨��㊧ィ�x㊧�jゥ㊧��w沿�援��劇�駐g�S㍽処絢ッ��ャv・左|叡芸�ハ��隗B��<未�
|
||||
Binary file not shown.
@@ -4,6 +4,10 @@ OK. c3528d19 test/data/49.bn4.nie
|
||||
OK. c3528d19 test/data/49.bn8.nie
|
||||
OK. e3bae566 test/data/49.bp4.nie
|
||||
OK. c3528d19 test/data/49.bp8.nie
|
||||
OK. bf3fd567 test/data/49.c3q1.handsum
|
||||
OK. 7cac72e5 test/data/49.c3q3.handsum
|
||||
OK. 2d906dc0 test/data/49.c4q1.handsum
|
||||
OK. dcf12bd3 test/data/49.c4q3.handsum
|
||||
OK. f2a0a3f6 test/data/49.png
|
||||
OK. d3bb0beb test/data/DCI-P3-D65.icc
|
||||
OK. 646e081a test/data/animated-red-blue.000000.nie
|
||||
|
||||
Reference in new issue
Block a user