diff --git a/cmd/wuffs-c/internal/cgen/base/all-impl.c b/cmd/wuffs-c/internal/cgen/base/all-impl.c index 20dd253e..76d2cbd5 100644 --- a/cmd/wuffs-c/internal/cgen/base/all-impl.c +++ b/cmd/wuffs-c/internal/cgen/base/all-impl.c @@ -49,10 +49,6 @@ extern "C" { // !! INSERT base/all-private.h. -#ifdef __cplusplus -} // extern "C" -#endif - #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) const uint8_t wuffs_base__low_bits_mask__u8[9] = { @@ -100,9 +96,15 @@ const uint64_t wuffs_base__low_bits_mask__u64[65] = { // !! INSERT wuffs_base__status strings. +// !! INSERT base/image-impl.c. + #endif // !defined(WUFFS_CONFIG__MODULES) || // defined(WUFFS_CONFIG__MODULE__BASE) +#ifdef __cplusplus +} // extern "C" +#endif + #endif // WUFFS_IMPLEMENTATION // !! WUFFS MONOLITHIC RELEASE DISCARDS EVERYTHING BELOW. diff --git a/cmd/wuffs-c/internal/cgen/base/image-impl.c b/cmd/wuffs-c/internal/cgen/base/image-impl.c new file mode 100644 index 00000000..7cdd91e6 --- /dev/null +++ b/cmd/wuffs-c/internal/cgen/base/image-impl.c @@ -0,0 +1,67 @@ +// 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 + +static uint64_t // +wuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src) { + return wuffs_base__slice_u8__copy_from_slice(dst, src); +} + +void // +wuffs_base__pixel_swizzler__initialize(wuffs_base__pixel_swizzler* p, + wuffs_base__pixel_format dst_format, + wuffs_base__pixel_format src_format) { + if (!p) { + return; + } + + // TODO: support many more formats. + + uint64_t (*func)(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 src) = NULL; + + switch (src_format) { + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: + switch (dst_format) { + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: + func = wuffs_base__pixel_swizzler__copy_1_1; + break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: + // TODO: implement. + break; + default: + break; + } + break; + + default: + break; + } + + p->private_impl.func = func; +} + +uint64_t // +wuffs_base__pixel_swizzler__swizzle_packed(wuffs_base__pixel_swizzler* p, + wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src) { + if (p && p->private_impl.func) { + return (*(p->private_impl.func))(dst, src); + } + return 0; +} diff --git a/cmd/wuffs-c/internal/cgen/base/image-public.h b/cmd/wuffs-c/internal/cgen/base/image-public.h index fed0191c..0bdc1373 100644 --- a/cmd/wuffs-c/internal/cgen/base/image-public.h +++ b/cmd/wuffs-c/internal/cgen/base/image-public.h @@ -786,6 +786,7 @@ typedef struct { inline wuffs_base__status set_from_slice(wuffs_base__pixel_config* pixcfg, wuffs_base__slice_u8 pixbuf_memory); inline wuffs_base__slice_u8 palette(); + inline wuffs_base__pixel_format pixel_format(); inline wuffs_base__table_u8 plane(uint32_t p); #endif // __cplusplus @@ -856,6 +857,14 @@ wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) { return ((wuffs_base__slice_u8){}); } +static inline wuffs_base__pixel_format // +wuffs_base__pixel_buffer__pixel_format(wuffs_base__pixel_buffer* b) { + if (b) { + return b->pixcfg.private_impl.pixfmt; + } + return WUFFS_BASE__PIXEL_FORMAT__INVALID; +} + static inline wuffs_base__table_u8 // wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) { return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) @@ -876,6 +885,11 @@ wuffs_base__pixel_buffer::palette() { return wuffs_base__pixel_buffer__palette(this); } +inline wuffs_base__pixel_format // +wuffs_base__pixel_buffer::pixel_format() { + return wuffs_base__pixel_buffer__pixel_format(this); +} + inline wuffs_base__table_u8 // wuffs_base__pixel_buffer::plane(uint32_t p) { return wuffs_base__pixel_buffer__plane(this, p); @@ -900,3 +914,50 @@ typedef struct { #ifdef __cplusplus #endif // __cplusplus + +// -------- + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + // TODO: should the func type take restrict pointers? + uint64_t (*func)(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 src); + } private_impl; + +#ifdef __cplusplus + inline void initialize(wuffs_base__pixel_format dst_format, + wuffs_base__pixel_format src_format); + inline uint64_t swizzle_packed(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src); +#endif // __cplusplus + +} wuffs_base__pixel_swizzler; + +// TODO: should initialize (both the C and C++ methods) return a status? + +void // +wuffs_base__pixel_swizzler__initialize(wuffs_base__pixel_swizzler* p, + wuffs_base__pixel_format dst_format, + wuffs_base__pixel_format src_format); + +uint64_t // +wuffs_base__pixel_swizzler__swizzle_packed(wuffs_base__pixel_swizzler* p, + wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src); + +#ifdef __cplusplus + +inline void // +wuffs_base__pixel_swizzler::initialize(wuffs_base__pixel_format dst_format, + wuffs_base__pixel_format src_format) { + wuffs_base__pixel_swizzler__initialize(this, dst_format, src_format); +} + +uint64_t // +wuffs_base__pixel_swizzler::swizzle_packed(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src) { + wuffs_base__pixel_swizzler__swizzle_packed(this, dst, src); +} + +#endif // __cplusplus diff --git a/cmd/wuffs-c/internal/cgen/cgen.go b/cmd/wuffs-c/internal/cgen/cgen.go index 1bae140d..07c10f58 100644 --- a/cmd/wuffs-c/internal/cgen/cgen.go +++ b/cmd/wuffs-c/internal/cgen/cgen.go @@ -114,6 +114,7 @@ func Do(args []string) error { "// !! INSERT base/all-private.h.\n": insertBaseAllPrivateH, "// !! INSERT base/all-public.h.\n": insertBaseAllPublicH, "// !! INSERT base/copyright\n": insertBaseCopyright, + "// !! INSERT base/image-impl.c.\n": insertBaseImageImplC, "// !! INSERT wuffs_base__status strings.\n": func(b *buffer) error { for _, z := range builtin.Statuses { msg, _ := t.Unescape(z) @@ -296,6 +297,12 @@ func insertBaseCopyright(buf *buffer) error { return nil } +func insertBaseImageImplC(buf *buffer) error { + buf.writes(baseImageImplC) + buf.writeb('\n') + return nil +} + type gen struct { pkgPrefix string // e.g. "wuffs_jpeg__" pkgName string // e.g. "jpeg" diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index 12d1fe60..2ce47a23 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -17,10 +17,15 @@ package cgen const baseAllImplC = "" + - "#ifndef WUFFS_INCLUDE_GUARD__BASE\n#define WUFFS_INCLUDE_GUARD__BASE\n\n#if defined(WUFFS_IMPLEMENTATION) && !defined(WUFFS_CONFIG__MODULES)\n#define WUFFS_CONFIG__MODULES\n#define WUFFS_CONFIG__MODULE__BASE\n#endif\n\n// !! WUFFS MONOLITHIC RELEASE DISCARDS EVERYTHING ABOVE.\n\n// !! INSERT base/copyright\n\n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// !! INSERT base/all-public.h.\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n// WUFFS C HEADER ENDS HERE.\n#ifdef WUFFS_IMPLEMENTATION\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// !! INSERT base/all-private.h.\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE)\n\nconst uint8_t wuffs_base__low_bits_mask__u8[9] = {\n 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF,\n};\n\nconst uint16_t wuffs_base__low_bits_mask__u16[17] = {\n 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF,\n 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF," + - " 0x7FFF, 0xFFFF,\n};\n\nconst uint32_t wuffs_base__low_bits_mask__u32[33] = {\n 0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x0000001F,\n 0x0000003F, 0x0000007F, 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,\n 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF, 0x0001FFFF,\n 0x0003FFFF, 0x0007FFFF, 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,\n 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, 0x1FFFFFFF,\n 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF,\n};\n\nconst uint64_t wuffs_base__low_bits_mask__u64[65] = {\n 0x0000000000000000, 0x0000000000000001, 0x0000000000000003,\n 0x0000000000000007, 0x000000000000000F, 0x000000000000001F,\n 0x000000000000003F, 0x000000000000007F, 0x00000000000000FF,\n 0x00000000000001FF, 0x00000000000003FF, 0x00000000000007FF,\n 0x0000000000000FFF, 0x0000000000001FFF, 0x0000000000003FFF,\n 0x0000000000007FFF, 0x000000000000FFFF, 0x000000000001FFFF,\n 0x000000000003FFFF, 0x000000000007FFFF, 0x00000000000FFFFF,\n 0x00000000001FFFFF," + - " 0x00000000003FFFFF, 0x00000000007FFFFF,\n 0x0000000000FFFFFF, 0x0000000001FFFFFF, 0x0000000003FFFFFF,\n 0x0000000007FFFFFF, 0x000000000FFFFFFF, 0x000000001FFFFFFF,\n 0x000000003FFFFFFF, 0x000000007FFFFFFF, 0x00000000FFFFFFFF,\n 0x00000001FFFFFFFF, 0x00000003FFFFFFFF, 0x00000007FFFFFFFF,\n 0x0000000FFFFFFFFF, 0x0000001FFFFFFFFF, 0x0000003FFFFFFFFF,\n 0x0000007FFFFFFFFF, 0x000000FFFFFFFFFF, 0x000001FFFFFFFFFF,\n 0x000003FFFFFFFFFF, 0x000007FFFFFFFFFF, 0x00000FFFFFFFFFFF,\n 0x00001FFFFFFFFFFF, 0x00003FFFFFFFFFFF, 0x00007FFFFFFFFFFF,\n 0x0000FFFFFFFFFFFF, 0x0001FFFFFFFFFFFF, 0x0003FFFFFFFFFFFF,\n 0x0007FFFFFFFFFFFF, 0x000FFFFFFFFFFFFF, 0x001FFFFFFFFFFFFF,\n 0x003FFFFFFFFFFFFF, 0x007FFFFFFFFFFFFF, 0x00FFFFFFFFFFFFFF,\n 0x01FFFFFFFFFFFFFF, 0x03FFFFFFFFFFFFFF, 0x07FFFFFFFFFFFFFF,\n 0x0FFFFFFFFFFFFFFF, 0x1FFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFFF,\n 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,\n};\n\n// !! INSERT wuffs_base__status strings.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defi" + - "ned(WUFFS_CONFIG__MODULE__BASE)\n\n#endif // WUFFS_IMPLEMENTATION\n\n// !! WUFFS MONOLITHIC RELEASE DISCARDS EVERYTHING BELOW.\n\n#endif // WUFFS_INCLUDE_GUARD__BASE\n" + + "#ifndef WUFFS_INCLUDE_GUARD__BASE\n#define WUFFS_INCLUDE_GUARD__BASE\n\n#if defined(WUFFS_IMPLEMENTATION) && !defined(WUFFS_CONFIG__MODULES)\n#define WUFFS_CONFIG__MODULES\n#define WUFFS_CONFIG__MODULE__BASE\n#endif\n\n// !! WUFFS MONOLITHIC RELEASE DISCARDS EVERYTHING ABOVE.\n\n// !! INSERT base/copyright\n\n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// !! INSERT base/all-public.h.\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n// WUFFS C HEADER ENDS HERE.\n#ifdef WUFFS_IMPLEMENTATION\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// !! INSERT base/all-private.h.\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE)\n\nconst uint8_t wuffs_base__low_bits_mask__u8[9] = {\n 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF,\n};\n\nconst uint16_t wuffs_base__low_bits_mask__u16[17] = {\n 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF,\n 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF,\n};\n\nconst uint32_t wuffs_ba" + + "se__low_bits_mask__u32[33] = {\n 0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x0000001F,\n 0x0000003F, 0x0000007F, 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,\n 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF, 0x0001FFFF,\n 0x0003FFFF, 0x0007FFFF, 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,\n 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF, 0x1FFFFFFF,\n 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF,\n};\n\nconst uint64_t wuffs_base__low_bits_mask__u64[65] = {\n 0x0000000000000000, 0x0000000000000001, 0x0000000000000003,\n 0x0000000000000007, 0x000000000000000F, 0x000000000000001F,\n 0x000000000000003F, 0x000000000000007F, 0x00000000000000FF,\n 0x00000000000001FF, 0x00000000000003FF, 0x00000000000007FF,\n 0x0000000000000FFF, 0x0000000000001FFF, 0x0000000000003FFF,\n 0x0000000000007FFF, 0x000000000000FFFF, 0x000000000001FFFF,\n 0x000000000003FFFF, 0x000000000007FFFF, 0x00000000000FFFFF,\n 0x00000000001FFFFF, 0x00000000003FFFFF, 0x00000000007FFFFF,\n " + + " 0x0000000000FFFFFF, 0x0000000001FFFFFF, 0x0000000003FFFFFF,\n 0x0000000007FFFFFF, 0x000000000FFFFFFF, 0x000000001FFFFFFF,\n 0x000000003FFFFFFF, 0x000000007FFFFFFF, 0x00000000FFFFFFFF,\n 0x00000001FFFFFFFF, 0x00000003FFFFFFFF, 0x00000007FFFFFFFF,\n 0x0000000FFFFFFFFF, 0x0000001FFFFFFFFF, 0x0000003FFFFFFFFF,\n 0x0000007FFFFFFFFF, 0x000000FFFFFFFFFF, 0x000001FFFFFFFFFF,\n 0x000003FFFFFFFFFF, 0x000007FFFFFFFFFF, 0x00000FFFFFFFFFFF,\n 0x00001FFFFFFFFFFF, 0x00003FFFFFFFFFFF, 0x00007FFFFFFFFFFF,\n 0x0000FFFFFFFFFFFF, 0x0001FFFFFFFFFFFF, 0x0003FFFFFFFFFFFF,\n 0x0007FFFFFFFFFFFF, 0x000FFFFFFFFFFFFF, 0x001FFFFFFFFFFFFF,\n 0x003FFFFFFFFFFFFF, 0x007FFFFFFFFFFFFF, 0x00FFFFFFFFFFFFFF,\n 0x01FFFFFFFFFFFFFF, 0x03FFFFFFFFFFFFFF, 0x07FFFFFFFFFFFFFF,\n 0x0FFFFFFFFFFFFFFF, 0x1FFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFFF,\n 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,\n};\n\n// !! INSERT wuffs_base__status strings.\n\n// !! INSERT base/image-impl.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_C" + + "ONFIG__MODULE__BASE)\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WUFFS_IMPLEMENTATION\n\n// !! WUFFS MONOLITHIC RELEASE DISCARDS EVERYTHING BELOW.\n\n#endif // WUFFS_INCLUDE_GUARD__BASE\n" + + "" + +const baseImageImplC = "" + + "// ---------------- Images\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n return wuffs_base__slice_u8__copy_from_slice(dst, src);\n}\n\nvoid //\nwuffs_base__pixel_swizzler__initialize(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_format,\n wuffs_base__pixel_format src_format) {\n if (!p) {\n return;\n }\n\n // TODO: support many more formats.\n\n uint64_t (*func)(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 src) = NULL;\n\n switch (src_format) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n switch (dst_format) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n func = wuffs_base__pixel_swizzler__copy_1_1;\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n // TODO: implement.\n break;\n " + + " default:\n break;\n }\n break;\n\n default:\n break;\n }\n\n p->private_impl.func = func;\n}\n\nuint64_t //\nwuffs_base__pixel_swizzler__swizzle_packed(wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n if (p && p->private_impl.func) {\n return (*(p->private_impl.func))(dst, src);\n }\n return 0;\n}\n" + "" const baseCorePrivateH = "" + @@ -124,12 +129,16 @@ const baseImagePublicH = "" + "posal disposal) {\n wuffs_base__frame_config__update(this, bounds, duration, index, io_position,\n blend, disposal);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__frame_config::bounds() {\n return wuffs_base__frame_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__frame_config::width() {\n return wuffs_base__frame_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__frame_config::height() {\n return wuffs_base__frame_config__height(this);\n}\n\ninline wuffs_base__flicks //\nwuffs_base__frame_config::duration() {\n return wuffs_base__frame_config__duration(this);\n}\n\ninline uint64_t //\nwuffs_base__frame_config::index() {\n return wuffs_base__frame_config__index(this);\n}\n\ninline uint64_t //\nwuffs_base__frame_config::io_position() {\n return wuffs_base__frame_config__io_position(this);\n}\n\ninline wuffs_base__animation_blend //\nwuffs_base__frame_config::blend() {\n return wuffs_base__frame_config__blend(this);\n}\n\ninline wuffs_base__animation_disposal //\nwuffs_base__fr" + "ame_config::disposal() {\n return wuffs_base__frame_config__disposal(this);\n}\n\n#endif // __cplusplus\n\n" + "" + - "// --------\n\ntypedef struct {\n wuffs_base__pixel_config pixcfg;\n\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n // TODO: color spaces.\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory);\n inline wuffs_base__slice_u8 palette();\n inline wuffs_base__table_u8 plane(uint32_t p);\n#endif // __cplusplus\n\n} wuffs_base__pixel_buffer;\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,\n wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return wuffs_base__error__bad_receiver;\n }\n *b = ((wuffs_base__pixel_buffer){});\n if (!pixcfg) {\n " + - " return wuffs_base__error__bad_argument;\n }\n\n uint8_t* ptr = pixbuf_memory.ptr;\n uint64_t len = pixbuf_memory.len;\n if (wuffs_base__pixel_format__is_indexed(pixcfg->private_impl.pixfmt)) {\n // Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from\n // the start of pixbuf_memory. We split from the start, not the end, so\n // that the both chunks' pointers have the same alignment as the original\n // pointer, up to an alignment of 1024.\n if (len < 1024) {\n return wuffs_base__error__bad_argument_length_too_short;\n }\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n tab->ptr = ptr;\n tab->width = 1024;\n tab->height = 1;\n tab->stride = 1024;\n ptr += 1024;\n len -= 1024;\n }\n\n // TODO: don't assume 1 byte per pixel. Don't assume packed.\n uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n ((uint64_t)pixcfg->private_impl.height);\n if (wh > len) {\n return wuffs_base__erro" + - "r__bad_argument_length_too_short;\n }\n b->pixcfg = *pixcfg;\n wuffs_base__table_u8* tab = &b->private_impl.planes[0];\n tab->ptr = ptr;\n tab->width = pixcfg->private_impl.width;\n tab->height = pixcfg->private_impl.height;\n tab->stride = pixcfg->private_impl.width;\n return NULL;\n}\n\n// wuffs_base__pixel_buffer__palette returns the palette color data. If\n// non-empty, it will have length 1024.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {\n if (b &&\n wuffs_base__pixel_format__is_indexed(b->pixcfg.private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n if ((tab->width == 1024) && (tab->height == 1)) {\n return ((wuffs_base__slice_u8){\n .ptr = tab->ptr,\n .len = 1024,\n });\n }\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {\n re" + - "turn (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n ? b->private_impl.planes[p]\n : ((wuffs_base__table_u8){});\n}\n\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer::palette() {\n return wuffs_base__pixel_buffer__palette(this);\n}\n\ninline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer::plane(uint32_t p) {\n return wuffs_base__pixel_buffer__plane(this, p);\n}\n\n#endif // __cplusplus\n\n" + + "// --------\n\ntypedef struct {\n wuffs_base__pixel_config pixcfg;\n\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n // TODO: color spaces.\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory);\n inline wuffs_base__slice_u8 palette();\n inline wuffs_base__pixel_format pixel_format();\n inline wuffs_base__table_u8 plane(uint32_t p);\n#endif // __cplusplus\n\n} wuffs_base__pixel_buffer;\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,\n wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return wuffs_base__error__bad_receiver;\n }\n *b = (" + + "(wuffs_base__pixel_buffer){});\n if (!pixcfg) {\n return wuffs_base__error__bad_argument;\n }\n\n uint8_t* ptr = pixbuf_memory.ptr;\n uint64_t len = pixbuf_memory.len;\n if (wuffs_base__pixel_format__is_indexed(pixcfg->private_impl.pixfmt)) {\n // Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from\n // the start of pixbuf_memory. We split from the start, not the end, so\n // that the both chunks' pointers have the same alignment as the original\n // pointer, up to an alignment of 1024.\n if (len < 1024) {\n return wuffs_base__error__bad_argument_length_too_short;\n }\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n tab->ptr = ptr;\n tab->width = 1024;\n tab->height = 1;\n tab->stride = 1024;\n ptr += 1024;\n len -= 1024;\n }\n\n // TODO: don't assume 1 byte per pixel. Don't assume packed.\n uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n ((uint64_t)pixcfg->private_impl.heig" + + "ht);\n if (wh > len) {\n return wuffs_base__error__bad_argument_length_too_short;\n }\n b->pixcfg = *pixcfg;\n wuffs_base__table_u8* tab = &b->private_impl.planes[0];\n tab->ptr = ptr;\n tab->width = pixcfg->private_impl.width;\n tab->height = pixcfg->private_impl.height;\n tab->stride = pixcfg->private_impl.width;\n return NULL;\n}\n\n// wuffs_base__pixel_buffer__palette returns the palette color data. If\n// non-empty, it will have length 1024.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {\n if (b &&\n wuffs_base__pixel_format__is_indexed(b->pixcfg.private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n if ((tab->width == 1024) && (tab->height == 1)) {\n return ((wuffs_base__slice_u8){\n .ptr = tab->ptr,\n .len = 1024,\n });\n }\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer_" + + "_pixel_format(wuffs_base__pixel_buffer* b) {\n if (b) {\n return b->pixcfg.private_impl.pixfmt;\n }\n return WUFFS_BASE__PIXEL_FORMAT__INVALID;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {\n return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n ? b->private_impl.planes[p]\n : ((wuffs_base__table_u8){});\n}\n\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_slice(wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer::palette() {\n return wuffs_base__pixel_buffer__palette(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer::pixel_format() {\n return wuffs_base__pixel_buffer__pixel_format(this);\n}\n\ninline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer::plane(" + + "uint32_t p) {\n return wuffs_base__pixel_buffer__plane(this, p);\n}\n\n#endif // __cplusplus\n\n" + "" + - "// --------\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n uint8_t TODO;\n } private_impl;\n\n#ifdef __cplusplus\n#endif // __cplusplus\n\n} wuffs_base__decode_frame_options;\n\n#ifdef __cplusplus\n\n#endif // __cplusplus\n" + + "// --------\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n uint8_t TODO;\n } private_impl;\n\n#ifdef __cplusplus\n#endif // __cplusplus\n\n} wuffs_base__decode_frame_options;\n\n#ifdef __cplusplus\n\n#endif // __cplusplus\n\n" + + "" + + "// --------\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n // TODO: should the func type take restrict pointers?\n uint64_t (*func)(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 src);\n } private_impl;\n\n#ifdef __cplusplus\n inline void initialize(wuffs_base__pixel_format dst_format,\n wuffs_base__pixel_format src_format);\n inline uint64_t swizzle_packed(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src);\n#endif // __cplusplus\n\n} wuffs_base__pixel_swizzler;\n\n// TODO: should initialize (both the C and C++ methods) return a status?\n\nvoid //\nwuffs_base__pixel_swizzler__initialize(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_format,\n wuffs_base__pixel_format src_format);\n\nuint64_t //\nwuffs_base__pixel_swizzler__swizzle_packed(wuffs_base__pixel_swizz" + + "ler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src);\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__pixel_swizzler::initialize(wuffs_base__pixel_format dst_format,\n wuffs_base__pixel_format src_format) {\n wuffs_base__pixel_swizzler__initialize(this, dst_format, src_format);\n}\n\nuint64_t //\nwuffs_base__pixel_swizzler::swizzle_packed(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n wuffs_base__pixel_swizzler__swizzle_packed(this, dst, src);\n}\n\n#endif // __cplusplus\n" + "" const baseIOPrivateH = "" + diff --git a/cmd/wuffs-c/internal/cgen/gen.go b/cmd/wuffs-c/internal/cgen/gen.go index 530f2c17..000805bc 100644 --- a/cmd/wuffs-c/internal/cgen/gen.go +++ b/cmd/wuffs-c/internal/cgen/gen.go @@ -74,6 +74,8 @@ func genBase(out *bytes.Buffer) error { filename, varname string }{ {"base/all-impl.c", "baseAllImplC"}, + {"base/image-impl.c", "baseImageImplC"}, + {"base/core-private.h", "baseCorePrivateH"}, {"base/core-public.h", "baseCorePublicH"}, {"base/memory-private.h", "baseMemoryPrivateH"}, diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index 0d107389..05d709aa 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -71,6 +71,7 @@ var Types = []string{ "image_config", "pixel_buffer", "pixel_config", + "pixel_swizzler", "decode_frame_options", } @@ -303,7 +304,13 @@ var Funcs = []string{ // ---- pixel_buffer "pixel_buffer.palette() slice u8", + "pixel_buffer.pixel_format() u32", "pixel_buffer.plane(p u32[..3]) table u8", + + // ---- pixel_swizzler + + "pixel_swizzler.initialize!(dst_pixfmt u32, src_pixfmt u32)", + "pixel_swizzler.swizzle_packed!(dst slice u8, src slice u8) u64", } // The "T1" and "T2" types here are placeholders for generic "slice T" or diff --git a/lang/check/resolve.go b/lang/check/resolve.go index a784cf41..9fa9ed10 100644 --- a/lang/check/resolve.go +++ b/lang/check/resolve.go @@ -61,10 +61,11 @@ var ( typeExprIOWriter = a.NewTypeExpr(0, t.IDBase, t.IDIOWriter, nil, nil, nil) typeExprStatus = a.NewTypeExpr(0, t.IDBase, t.IDStatus, nil, nil, nil) - typeExprFrameConfig = a.NewTypeExpr(0, t.IDBase, t.IDFrameConfig, nil, nil, nil) - typeExprImageConfig = a.NewTypeExpr(0, t.IDBase, t.IDImageConfig, nil, nil, nil) - typeExprPixelBuffer = a.NewTypeExpr(0, t.IDBase, t.IDPixelBuffer, nil, nil, nil) - typeExprPixelConfig = a.NewTypeExpr(0, t.IDBase, t.IDPixelConfig, nil, nil, nil) + typeExprFrameConfig = a.NewTypeExpr(0, t.IDBase, t.IDFrameConfig, nil, nil, nil) + typeExprImageConfig = a.NewTypeExpr(0, t.IDBase, t.IDImageConfig, nil, nil, nil) + typeExprPixelBuffer = a.NewTypeExpr(0, t.IDBase, t.IDPixelBuffer, nil, nil, nil) + typeExprPixelConfig = a.NewTypeExpr(0, t.IDBase, t.IDPixelConfig, nil, nil, nil) + typeExprPixelSwizzler = a.NewTypeExpr(0, t.IDBase, t.IDPixelSwizzler, nil, nil, nil) typeExprDecodeFrameOptions = a.NewTypeExpr(0, t.IDBase, t.IDDecodeFrameOptions, nil, nil, nil) @@ -101,10 +102,11 @@ var builtInTypeMap = typeMap{ t.IDIOWriter: typeExprIOWriter, t.IDStatus: typeExprStatus, - t.IDFrameConfig: typeExprFrameConfig, - t.IDImageConfig: typeExprImageConfig, - t.IDPixelBuffer: typeExprPixelBuffer, - t.IDPixelConfig: typeExprPixelConfig, + t.IDFrameConfig: typeExprFrameConfig, + t.IDImageConfig: typeExprImageConfig, + t.IDPixelBuffer: typeExprPixelBuffer, + t.IDPixelConfig: typeExprPixelConfig, + t.IDPixelSwizzler: typeExprPixelSwizzler, t.IDDecodeFrameOptions: typeExprDecodeFrameOptions, } diff --git a/lang/token/list.go b/lang/token/list.go index de4b58c0..bdb04520 100644 --- a/lang/token/list.go +++ b/lang/token/list.go @@ -440,10 +440,11 @@ const ( IDBase = ID(0x131) IDThis = ID(0x132) - IDFrameConfig = ID(0x160) - IDImageConfig = ID(0x161) - IDPixelBuffer = ID(0x162) - IDPixelConfig = ID(0x163) + IDFrameConfig = ID(0x160) + IDImageConfig = ID(0x161) + IDPixelBuffer = ID(0x162) + IDPixelConfig = ID(0x163) + IDPixelSwizzler = ID(0x164) IDDecodeFrameOptions = ID(0x168) @@ -763,10 +764,11 @@ var builtInsByID = [nBuiltInIDs]string{ IDBase: "base", IDThis: "this", - IDFrameConfig: "frame_config", - IDImageConfig: "image_config", - IDPixelBuffer: "pixel_buffer", - IDPixelConfig: "pixel_config", + IDFrameConfig: "frame_config", + IDImageConfig: "image_config", + IDPixelBuffer: "pixel_buffer", + IDPixelConfig: "pixel_config", + IDPixelSwizzler: "pixel_swizzler", IDDecodeFrameOptions: "decode_frame_options", diff --git a/release/c/wuffs-unsupported-snapshot.h b/release/c/wuffs-unsupported-snapshot.h index 5d46ed65..d1a2f578 100644 --- a/release/c/wuffs-unsupported-snapshot.h +++ b/release/c/wuffs-unsupported-snapshot.h @@ -1983,6 +1983,7 @@ typedef struct { inline wuffs_base__status set_from_slice(wuffs_base__pixel_config* pixcfg, wuffs_base__slice_u8 pixbuf_memory); inline wuffs_base__slice_u8 palette(); + inline wuffs_base__pixel_format pixel_format(); inline wuffs_base__table_u8 plane(uint32_t p); #endif // __cplusplus @@ -2053,6 +2054,14 @@ wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) { return ((wuffs_base__slice_u8){}); } +static inline wuffs_base__pixel_format // +wuffs_base__pixel_buffer__pixel_format(wuffs_base__pixel_buffer* b) { + if (b) { + return b->pixcfg.private_impl.pixfmt; + } + return WUFFS_BASE__PIXEL_FORMAT__INVALID; +} + static inline wuffs_base__table_u8 // wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) { return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) @@ -2073,6 +2082,11 @@ wuffs_base__pixel_buffer::palette() { return wuffs_base__pixel_buffer__palette(this); } +inline wuffs_base__pixel_format // +wuffs_base__pixel_buffer::pixel_format() { + return wuffs_base__pixel_buffer__pixel_format(this); +} + inline wuffs_base__table_u8 // wuffs_base__pixel_buffer::plane(uint32_t p) { return wuffs_base__pixel_buffer__plane(this, p); @@ -2098,6 +2112,53 @@ typedef struct { #endif // __cplusplus +// -------- + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + // TODO: should the func type take restrict pointers? + uint64_t (*func)(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 src); + } private_impl; + +#ifdef __cplusplus + inline void initialize(wuffs_base__pixel_format dst_format, + wuffs_base__pixel_format src_format); + inline uint64_t swizzle_packed(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src); +#endif // __cplusplus + +} wuffs_base__pixel_swizzler; + +// TODO: should initialize (both the C and C++ methods) return a status? + +void // +wuffs_base__pixel_swizzler__initialize(wuffs_base__pixel_swizzler* p, + wuffs_base__pixel_format dst_format, + wuffs_base__pixel_format src_format); + +uint64_t // +wuffs_base__pixel_swizzler__swizzle_packed(wuffs_base__pixel_swizzler* p, + wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src); + +#ifdef __cplusplus + +inline void // +wuffs_base__pixel_swizzler::initialize(wuffs_base__pixel_format dst_format, + wuffs_base__pixel_format src_format) { + wuffs_base__pixel_swizzler__initialize(this, dst_format, src_format); +} + +uint64_t // +wuffs_base__pixel_swizzler::swizzle_packed(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src) { + wuffs_base__pixel_swizzler__swizzle_packed(this, dst, src); +} + +#endif // __cplusplus + #ifdef __cplusplus } // extern "C" #endif @@ -2642,6 +2703,7 @@ struct wuffs_gif__decoder__struct { uint32_t f_uncompressed_wi; uint8_t f_uncompressed[4096]; uint8_t f_palettes[2][1024]; + wuffs_base__pixel_swizzler f_swizzler; wuffs_base__utility f_util; wuffs_lzw__decoder f_lzw; @@ -3729,10 +3791,6 @@ wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) { // ---------------- Images -#ifdef __cplusplus -} // extern "C" -#endif - #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) const uint8_t wuffs_base__low_bits_mask__u8[9] = { @@ -3800,9 +3858,65 @@ const char* wuffs_base__error__check_wuffs_version_missing = const char* wuffs_base__error__disabled_by_previous_error = "?base: disabled by previous error"; +// ---------------- Images + +static uint64_t // +wuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src) { + return wuffs_base__slice_u8__copy_from_slice(dst, src); +} + +void // +wuffs_base__pixel_swizzler__initialize(wuffs_base__pixel_swizzler* p, + wuffs_base__pixel_format dst_format, + wuffs_base__pixel_format src_format) { + if (!p) { + return; + } + + // TODO: support many more formats. + + uint64_t (*func)(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 src) = NULL; + + switch (src_format) { + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: + switch (dst_format) { + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: + func = wuffs_base__pixel_swizzler__copy_1_1; + break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: + case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: + // TODO: implement. + break; + default: + break; + } + break; + + default: + break; + } + + p->private_impl.func = func; +} + +uint64_t // +wuffs_base__pixel_swizzler__swizzle_packed(wuffs_base__pixel_swizzler* p, + wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src) { + if (p && p->private_impl.func) { + return (*(p->private_impl.func))(dst, src); + } + return 0; +} + #endif // !defined(WUFFS_CONFIG__MODULES) || // defined(WUFFS_CONFIG__MODULE__BASE) +#ifdef __cplusplus +} // extern "C" +#endif + #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ADLER32) // ---------------- Status Codes Implementations @@ -9083,6 +9197,9 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, .f_palettes[self->private_impl.f_which_palette], .len = 1024, })); + wuffs_base__pixel_swizzler__initialize( + &self->private_impl.f_swizzler, + wuffs_base__pixel_buffer__pixel_format(a_dst), 1107558408); if (self->private_impl.f_previous_lzw_decode_ended_abruptly) { (memset(&self->private_impl.f_lzw, 0, sizeof((wuffs_lzw__decoder){})), wuffs_base__ignore_check_wuffs_version_status( @@ -9281,7 +9398,8 @@ label_0_continue:; v_dst = wuffs_base__slice_u8__subslice_i( v_dst, ((uint64_t)(self->private_impl.f_dst_x))); } - v_n64 = wuffs_base__slice_u8__copy_from_slice(v_dst, v_src); + v_n64 = wuffs_base__pixel_swizzler__swizzle_packed( + &self->private_impl.f_swizzler, v_dst, v_src); v_n = ((uint32_t)((v_n64 & 4294967295))); v_new_ri = wuffs_base__u32__sat_add(self->private_impl.f_uncompressed_ri, v_n); diff --git a/std/gif/decode_gif.wuffs b/std/gif/decode_gif.wuffs index 93ff7371..37b91dd6 100644 --- a/std/gif/decode_gif.wuffs +++ b/std/gif/decode_gif.wuffs @@ -114,6 +114,7 @@ pub struct decoder?( // palettes[0] and palettes[1] are the Global and Local Color Table. palettes array[2] array[4 * 256] base.u8, + swizzler base.pixel_swizzler, util base.utility, lzw lzw.decoder, ) @@ -584,6 +585,10 @@ pri func decoder.decode_id_part1!??(dst ptr base.pixel_buffer, src base.io_reade args.dst.palette().copy_from_slice!(s:this.palettes[this.which_palette][:]) + // TODO: a Wuffs (not just C) name for the + // WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL magic pixfmt constant. + this.swizzler.initialize!(dst_pixfmt:args.dst.pixel_format(), src_pixfmt:0x42040008) + // Other GIF implementations accept GIF files that aren't completely spec // compliant. For example, the test/data/gifplayer-muybridge.gif file // (created by the gifsicle program) is accepted by other GIF decoders. @@ -696,7 +701,7 @@ pri func decoder.copy_to_image_buffer!?(pb ptr base.pixel_buffer) { } else { dst = dst[this.dst_x as base.u64:] } - var n64 base.u64 = dst.copy_from_slice!(s:src) + var n64 base.u64 = this.swizzler.swizzle_packed!(dst:dst, src:src) n = (n64 & 0xFFFFFFFF) as base.u32 new_ri = this.uncompressed_ri ~sat+ n