Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
58608c4ee5 | ||
|
|
4aa672af48 | ||
|
|
f86c80e425 | ||
|
|
dda01f1a77 | ||
|
|
f3a7288357 | ||
|
|
0a8bded7f3 | ||
|
|
918b4e4535 | ||
|
|
92f74e91a7 | ||
|
|
bcecdef66b | ||
|
|
2f1b1a5311 | ||
|
|
425eefeb35 | ||
|
|
e1a6a7cd8c | ||
|
|
4e85543d9c | ||
|
|
4c04ac1127 | ||
|
|
8ef4c062d9 | ||
|
|
38b101d170 | ||
|
|
5d1473a2ca | ||
|
|
72d4a9e769 | ||
|
|
5f6a522563 | ||
|
|
4dedbedbbc | ||
|
|
a1aa15cacf | ||
|
|
ae6b366edb | ||
|
|
6acb5a4fdd | ||
|
|
3a9933f2a0 | ||
|
|
c2eb4f5b93 | ||
|
|
8397a35a50 | ||
|
|
e53497abe3 | ||
|
|
15285a6ab9 | ||
|
|
ac4d3e6420 | ||
|
|
8bd52a8791 | ||
|
|
1d8fb411ba | ||
|
|
ccbec18330 | ||
|
|
55cad41d6c | ||
|
|
f5c68a13cb | ||
|
|
f5d6ce3797 | ||
|
|
5e8b448c12 | ||
|
|
49a431f98d | ||
|
|
ede0590ead | ||
|
|
bb8623b472 | ||
|
|
010e0a69f4 | ||
|
|
a684928240 | ||
|
|
cdf3bbfb26 | ||
|
|
fe15c471df | ||
|
|
3b3331bbb3 | ||
|
|
e44920d382 | ||
|
|
3b882be500 | ||
|
|
6a8ee57ac0 | ||
|
|
66cfd3e02f | ||
|
|
161e4730d8 | ||
|
|
d5066c1aae | ||
|
|
8562375fd9 | ||
|
|
bb028ae764 | ||
|
|
29560a336b | ||
|
|
e0cdaeb54f | ||
|
|
e7ed1dd43e | ||
|
|
bfce0e0a16 | ||
|
|
417b03a0ad | ||
|
|
7dd0dd264b | ||
|
|
0d37acd6f6 | ||
|
|
6737565c20 | ||
|
|
3642d73714 | ||
|
|
37ac4def8e | ||
|
|
07c053af6f | ||
|
|
f0c2a40d66 | ||
|
|
ce9ab13ecd | ||
|
|
6c2a591e84 | ||
|
|
d40bf000a9 | ||
|
|
0045ce49f3 | ||
|
|
fa56d92410 | ||
|
|
8f1adea523 | ||
|
|
962a515dd2 | ||
|
|
8025bf1bd7 | ||
|
|
4d64aff554 | ||
|
|
54bdcc1b57 | ||
|
|
a4fa6a2554 | ||
|
|
22eed1fd8d | ||
|
|
c19e3b1cab | ||
|
|
9af2666aec | ||
|
|
9c3d27fb43 | ||
|
|
2373340f83 | ||
|
|
e847766b02 | ||
|
|
74c1dfce96 | ||
|
|
f4c2d4652e | ||
|
|
ca76a01ac2 | ||
|
|
00b329872a | ||
|
|
0a7168fd64 | ||
|
|
f854646586 | ||
|
|
f148f5c5b3 | ||
|
|
750df217dd | ||
|
|
744fbdd732 | ||
|
|
0854344580 | ||
|
|
d5075c7e94 | ||
|
|
16b51dd2a4 | ||
|
|
badce3ffa4 | ||
|
|
f40ef01244 | ||
|
|
8f9a4f40c2 | ||
|
|
c754f81634 | ||
|
|
a9a6332be2 | ||
|
|
d557bc3836 | ||
|
|
01a5b8842b | ||
|
|
35cb4df973 | ||
|
|
15b6285d1c | ||
|
|
6ea3144379 | ||
|
|
b003f9fe65 | ||
|
|
d259f7a579 | ||
|
|
2b7b6e12ea | ||
|
|
ca33506c01 | ||
|
|
0460bfcd7a | ||
|
|
9437d1a265 | ||
|
|
2e821791a9 | ||
|
|
e317f04bfd | ||
|
|
db5a407bab | ||
|
|
9323549eeb | ||
|
|
911049e9f9 | ||
|
|
ae9ca94501 | ||
|
|
d8ad363ef5 | ||
|
|
e6733aec19 | ||
|
|
ad1d983698 | ||
|
|
dbc209dd7e | ||
|
|
1a94a6f1b3 | ||
|
|
34e2786dd2 | ||
|
|
5a4dd303f0 | ||
|
|
62125d8967 | ||
|
|
eb6703425a | ||
|
|
6fb7697b4a | ||
|
|
55784030e4 | ||
|
|
feb050b418 | ||
|
|
f9c029c788 | ||
|
|
90d3232eae | ||
|
|
2945ef2b29 | ||
|
|
ea4c85bfa2 | ||
|
|
41fce8a8de | ||
|
|
9699c49f55 | ||
|
|
7f9f37ce5a | ||
|
|
774340ae27 | ||
|
|
7753368324 | ||
|
|
8eaa222592 | ||
|
|
1cf0df9da4 | ||
|
|
68acf24515 | ||
|
|
2453a8d52a | ||
|
|
bb7b75ff86 | ||
|
|
66bcef6fff | ||
|
|
7ee081f4b9 | ||
|
|
6f39b9641b | ||
|
|
550fabd15d | ||
|
|
a1d9c6a8e6 | ||
|
|
de45ab1d2b | ||
|
|
c8592d2b7a | ||
|
|
9d10438914 | ||
|
|
0d57d6a2e1 | ||
|
|
26d9ec41fd | ||
|
|
a66a083e82 | ||
|
|
cb2e49ab09 | ||
|
|
75faea996d | ||
|
|
1d19157668 | ||
|
|
bdfee5053c | ||
|
|
2f65d6fc74 | ||
|
|
226c476994 | ||
|
|
788479dd64 | ||
|
|
d3c7d103ca | ||
|
|
17b624c038 | ||
|
|
786fc74b92 | ||
|
|
a86fd7fa79 | ||
|
|
341dd50800 | ||
|
|
a83b5cabaf | ||
|
|
8a4f61501b | ||
|
|
592bc14ed1 | ||
|
|
f73f95b698 | ||
|
|
28a54baa19 | ||
|
|
b60a2cacd9 | ||
|
|
f7b1b87c70 | ||
|
|
13f2e44aca | ||
|
|
128d0386bd | ||
|
|
1b9a6cb85b | ||
|
|
77f855206d | ||
|
|
40ffa334ee |
No files matched your search
@@ -13,5 +13,7 @@
|
||||
Andrew Dassonville <dassonville.andrew@gmail.com>
|
||||
Google Inc.
|
||||
Jimmy Casey <casey.jimmy@gmail.com>
|
||||
Magnus Anderson <magnus@iastate.edu>
|
||||
Mike Kaufman <mkaufman@microsoft.com>
|
||||
Muhammad Aldo Firmansyah <TheCrott@users.noreply.github.com>
|
||||
Přemysl Eric Janouch <p@janouch.name>
|
||||
@@ -36,7 +36,9 @@ Andrew Dassonville <dassonville.andrew@gmail.com>
|
||||
Chris Palmer <chris@noncombatant.org>
|
||||
Jimmy Casey <casey.jimmy@gmail.com>
|
||||
Leo Neat <lneat@google.com>
|
||||
Magnus Anderson <magnus@iastate.edu>
|
||||
Mike Kaufman <mkaufman@microsoft.com>
|
||||
Muhammad Aldo Firmansyah <TheCrott@users.noreply.github.com>
|
||||
Nigel Tao <nigeltao@golang.org>
|
||||
Peter Kasting <pkasting@chromium.org>
|
||||
Přemysl Eric Janouch <p@janouch.name>
|
||||
@@ -37,7 +37,7 @@
|
||||
# gcc ./example/zcat/zcat.c
|
||||
# ./a.out < ./test/data/romeo.txt.gz
|
||||
|
||||
if [ ! -e release/c/wuffs-unsupported-snapshot.c ]; then
|
||||
if [ ! -e wuffs-root-directory.txt ]; then
|
||||
echo "$0 should be run from the Wuffs root directory."
|
||||
exit 1
|
||||
fi
|
||||
@@ -70,12 +70,19 @@ wuffs test -skipgen -mimic
|
||||
wuffs bench -skipgen -mimic -reps=1 -iterscale=1
|
||||
|
||||
./build-example.sh
|
||||
./build-fuzz.sh
|
||||
|
||||
# ----
|
||||
|
||||
echo "Running gen/bin/example-crc32"
|
||||
JSON_THINGS_CRC32=$(gen/bin/example-crc32 < test/data/json-things.formatted.json)
|
||||
if [ "$JSON_THINGS_CRC32" != "cdcc7e35" ]; then
|
||||
echo "example-crc32 failed on json-things data"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# ----
|
||||
|
||||
echo "Running gen/bin/example-jsonptr"
|
||||
JSON_THINGS_CRC32=$(gen/bin/example-jsonptr < test/data/json-things.unformatted.json | gen/bin/example-crc32)
|
||||
if [ "$JSON_THINGS_CRC32" != "cdcc7e35" ]; then
|
||||
@@ -83,8 +90,25 @@ if [ "$JSON_THINGS_CRC32" != "cdcc7e35" ]; then
|
||||
exit 1
|
||||
fi
|
||||
|
||||
./build-fuzz.sh
|
||||
# ----
|
||||
|
||||
echo "Running gen/bin/example-convert-to-nia"
|
||||
set +e
|
||||
script/print-nia-checksums.sh | \
|
||||
diff --unified test/nia-checksums-of-data.txt /dev/stdin
|
||||
if [ $? != 0 ]; then
|
||||
echo "Unexpected change in test/nia-checksums-of-data.txt"
|
||||
exit 1
|
||||
fi
|
||||
set -e
|
||||
|
||||
# ----
|
||||
|
||||
for f in gen/bin/fuzz-*; do
|
||||
echo "Running $f"
|
||||
$f test/data > /dev/null
|
||||
done
|
||||
|
||||
# ----
|
||||
|
||||
echo "DONE: build-all.sh"
|
||||
@@ -17,13 +17,19 @@
|
||||
|
||||
# See build-all.sh for commentary.
|
||||
|
||||
if [ ! -e release/c/wuffs-unsupported-snapshot.c ]; then
|
||||
if [ ! -e wuffs-root-directory.txt ]; then
|
||||
echo "$0 should be run from the Wuffs root directory."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
CC=${CC:-gcc}
|
||||
CXX=${CXX:-g++}
|
||||
LDFLAGS=${LDFLAGS:-}
|
||||
|
||||
# The "-fdata-sections -ffunction-sections -Wl,--gc-sections" produces smaller
|
||||
# binaries. See commit 41fce8a8 "Strip examples of unused data and functions".
|
||||
CFLAGS=${CFLAGS:--O3 -fdata-sections -ffunction-sections -Wl,--gc-sections}
|
||||
CXXFLAGS=${CXXFLAGS:--O3 -fdata-sections -ffunction-sections -Wl,--gc-sections}
|
||||
|
||||
mkdir -p gen/bin
|
||||
|
||||
@@ -41,30 +47,35 @@ for f in $sources; do
|
||||
|
||||
if [ $f = imageviewer ]; then
|
||||
# example/imageviewer is unusual in that needs additional libraries.
|
||||
echo "Building gen/bin/example-$f"
|
||||
$CXX -O3 example/$f/*.cc -lxcb -lxcb-image -o gen/bin/example-$f
|
||||
echo "Building (C++) gen/bin/example-$f"
|
||||
$CXX $CXXFLAGS example/$f/*.cc \
|
||||
$LDFLAGS -lxcb -lxcb-image -lxcb-render -lxcb-render-util \
|
||||
-o gen/bin/example-$f
|
||||
elif [ $f = "sdl-imageviewer" ]; then
|
||||
# example/sdl-imageviewer is unusual in that needs additional libraries.
|
||||
echo "Building gen/bin/example-$f"
|
||||
$CXX -O3 example/$f/*.cc -lSDL2 -lSDL2_image -o gen/bin/example-$f
|
||||
echo "Building (C++) gen/bin/example-$f"
|
||||
$CXX $CXXFLAGS example/$f/*.cc \
|
||||
$LDFLAGS -lSDL2 -lSDL2_image \
|
||||
-o gen/bin/example-$f
|
||||
elif [ $f = "toy-genlib" ]; then
|
||||
# example/toy-genlib is unusual in that it uses separately compiled
|
||||
# libraries (built by "wuffs genlib", e.g. by running build-all.sh) instead
|
||||
# of directly #include'ing Wuffs' .c files.
|
||||
if [ -e gen/lib/c/$CC-static/libwuffs.a ]; then
|
||||
echo "Building gen/bin/example-$f"
|
||||
$CC -O3 -static -I.. example/$f/*.c gen/lib/c/$CC-static/libwuffs.a -o gen/bin/example-$f
|
||||
echo "Building (C) gen/bin/example-$f"
|
||||
$CC $CFLAGS -static -I.. example/$f/*.c gen/lib/c/$CC-static/libwuffs.a \
|
||||
$LDFLAGS -o gen/bin/example-$f
|
||||
else
|
||||
echo "Skipping gen/bin/example-$f; run \"wuffs genlib\" first"
|
||||
fi
|
||||
elif [ -e example/$f/*.c ]; then
|
||||
echo "Building gen/bin/example-$f"
|
||||
$CC -O3 example/$f/*.c -o gen/bin/example-$f
|
||||
echo "Building (C) gen/bin/example-$f"
|
||||
$CC $CFLAGS example/$f/*.c $LDFLAGS -o gen/bin/example-$f
|
||||
elif [ $f = "jsonfindptrs" ]; then
|
||||
echo "Building gen/bin/example-$f"
|
||||
$CXX -O3 -std=c++17 example/$f/*.cc -o gen/bin/example-$f
|
||||
echo "Building (C++) gen/bin/example-$f"
|
||||
$CXX $CXXFLAGS -std=c++17 example/$f/*.cc $LDFLAGS -o gen/bin/example-$f
|
||||
elif [ -e example/$f/*.cc ]; then
|
||||
echo "Building gen/bin/example-$f"
|
||||
$CXX -O3 example/$f/*.cc -o gen/bin/example-$f
|
||||
echo "Building (C++) gen/bin/example-$f"
|
||||
$CXX $CXXFLAGS example/$f/*.cc $LDFLAGS -o gen/bin/example-$f
|
||||
fi
|
||||
done
|
||||
@@ -17,29 +17,43 @@
|
||||
|
||||
# See build-all.sh for commentary.
|
||||
|
||||
if [ ! -e release/c/wuffs-unsupported-snapshot.c ]; then
|
||||
if [ ! -e wuffs-root-directory.txt ]; then
|
||||
echo "$0 should be run from the Wuffs root directory."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
CC=${CC:-gcc}
|
||||
CXX=${CXX:-g++}
|
||||
LDFLAGS=${LDFLAGS:-}
|
||||
|
||||
# The "-fdata-sections -ffunction-sections -Wl,--gc-sections" produces smaller
|
||||
# binaries. See commit 41fce8a8 "Strip examples of unused data and functions".
|
||||
CFLAGS=${CFLAGS:--O3 -fdata-sections -ffunction-sections -Wl,--gc-sections}
|
||||
CXXFLAGS=${CXXFLAGS:--O3 -fdata-sections -ffunction-sections -Wl,--gc-sections}
|
||||
|
||||
mkdir -p gen/bin
|
||||
|
||||
sources=$@
|
||||
if [ $# -eq 0 ]; then
|
||||
sources=fuzz/c/std/*_fuzzer.c
|
||||
sources=fuzz/c/std/*_fuzzer.c*
|
||||
fi
|
||||
|
||||
for f in $sources; do
|
||||
f=${f%_fuzzer.c}
|
||||
f=${f%_fuzzer.cc}
|
||||
f=${f%/}
|
||||
f=${f##*/}
|
||||
if [ -z $f ]; then
|
||||
continue
|
||||
fi
|
||||
echo "Building gen/bin/fuzz-$f"
|
||||
|
||||
$CC -DWUFFS_CONFIG__FUZZLIB_MAIN fuzz/c/std/${f}_fuzzer.c -o gen/bin/fuzz-$f
|
||||
if [ -e fuzz/c/std/${f}_fuzzer.c ]; then
|
||||
echo "Building (C) gen/bin/fuzz-$f"
|
||||
$CC $CFLAGS -DWUFFS_CONFIG__FUZZLIB_MAIN fuzz/c/std/${f}_fuzzer.c \
|
||||
$LDFLAGS -o gen/bin/fuzz-$f
|
||||
elif [ -e fuzz/c/std/${f}_fuzzer.cc ]; then
|
||||
echo "Building (C++) gen/bin/fuzz-$f"
|
||||
$CXX $CXXFLAGS -DWUFFS_CONFIG__FUZZLIB_MAIN fuzz/c/std/${f}_fuzzer.cc \
|
||||
$LDFLAGS -o gen/bin/fuzz-$f
|
||||
fi
|
||||
done
|
||||
@@ -27,7 +27,7 @@ import (
|
||||
)
|
||||
|
||||
const (
|
||||
CcompilersDefault = "clang-9,gcc"
|
||||
CcompilersDefault = "clang,gcc"
|
||||
CcompilersUsage = `comma-separated list of C compilers`
|
||||
|
||||
FocusDefault = ""
|
||||
|
||||
@@ -61,7 +61,6 @@ import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
@@ -146,9 +145,9 @@ func walk(filename string, info os.FileInfo, err error) error {
|
||||
func do(r io.Reader, filename string) error {
|
||||
src, err := []byte(nil), error(nil)
|
||||
if r != nil {
|
||||
src, err = ioutil.ReadAll(r)
|
||||
src, err = io.ReadAll(r)
|
||||
} else {
|
||||
src, err = ioutil.ReadFile(filename)
|
||||
src, err = os.ReadFile(filename)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -180,7 +179,7 @@ func do(r io.Reader, filename string) error {
|
||||
const chmodSupported = runtime.GOOS != "windows"
|
||||
|
||||
func writeFile(filename string, b []byte) error {
|
||||
f, err := ioutil.TempFile(filepath.Dir(filename), filepath.Base(filename))
|
||||
f, err := os.CreateTemp(filepath.Dir(filename), filepath.Base(filename))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -124,7 +124,7 @@ Installation:
|
||||
|
||||
Like any other implemented-in-Go program, to install the ractool program:
|
||||
|
||||
go get github.com/google/wuffs/cmd/ractool
|
||||
go install github.com/google/wuffs/cmd/ractool
|
||||
|
||||
Extended Example:
|
||||
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -24,7 +25,6 @@ import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"go/format"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
)
|
||||
|
||||
@@ -36,7 +36,7 @@ func main() {
|
||||
}
|
||||
|
||||
func main1() error {
|
||||
src, err := ioutil.ReadFile("main.go")
|
||||
src, err := os.ReadFile("main.go")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -80,5 +80,5 @@ const usageStr = ` + "`")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return ioutil.WriteFile("data.go", formatted, 0644)
|
||||
return os.WriteFile("data.go", formatted, 0644)
|
||||
}
|
||||
@@ -125,7 +125,7 @@ Installation:
|
||||
|
||||
Like any other implemented-in-Go program, to install the ractool program:
|
||||
|
||||
go get github.com/google/wuffs/cmd/ractool
|
||||
go install github.com/google/wuffs/cmd/ractool
|
||||
|
||||
Extended Example:
|
||||
|
||||
@@ -251,7 +251,6 @@ import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"runtime"
|
||||
"strconv"
|
||||
@@ -415,7 +414,7 @@ func decode(inFile *os.File) error {
|
||||
// This seek-to-end error isn't fatal. The input might not actually be
|
||||
// seekable, despite being an *os.File: "cat foo | ractool -decode".
|
||||
// Instead, read all of the inFile into memory.
|
||||
if inBytes, err := ioutil.ReadAll(inFile); err != nil {
|
||||
if inBytes, err := io.ReadAll(inFile); err != nil {
|
||||
return err
|
||||
} else {
|
||||
rs = bytes.NewReader(inBytes)
|
||||
@@ -532,7 +531,7 @@ func encode(r io.Reader) error {
|
||||
|
||||
if *resourcesFlag != "" {
|
||||
for _, filename := range strings.Split(*resourcesFlag, ",") {
|
||||
resource, err := ioutil.ReadFile(filename)
|
||||
resource, err := os.ReadFile(filename)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -590,7 +589,7 @@ func makeTempFile() (io.ReadWriter, error) {
|
||||
return &bytes.Buffer{}, nil
|
||||
}
|
||||
|
||||
f, err := ioutil.TempFile(*tmpdirFlag, "ractool-")
|
||||
f, err := os.CreateTemp(*tmpdirFlag, "ractool-")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
@@ -18,13 +18,12 @@ import (
|
||||
"bytes"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/google/wuffs/internal/cgen/data"
|
||||
"github.com/google/wuffs/internal/cgen"
|
||||
|
||||
cf "github.com/google/wuffs/cmd/commonflags"
|
||||
)
|
||||
@@ -83,7 +82,7 @@ func doGenrelease(args []string) error {
|
||||
}
|
||||
relFilename := filename[len(baseDirSlash):]
|
||||
|
||||
s, err := ioutil.ReadFile(filename)
|
||||
s, err := os.ReadFile(filename)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -108,10 +107,10 @@ func doGenrelease(args []string) error {
|
||||
}
|
||||
|
||||
out.WriteString("#if defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n\n")
|
||||
out.WriteString(data.AuxBaseHh)
|
||||
out.WriteString(cgen.EmbeddedString_AuxBaseHh.Trim())
|
||||
out.WriteString("\n")
|
||||
for _, f := range data.AuxNonBaseHhFiles {
|
||||
out.WriteString(f)
|
||||
for _, f := range cgen.EmbeddedStrings_AuxNonBaseHhFiles {
|
||||
out.WriteString(f.Trim())
|
||||
out.WriteString("\n")
|
||||
}
|
||||
out.WriteString("#endif // defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n")
|
||||
@@ -127,10 +126,10 @@ func doGenrelease(args []string) error {
|
||||
}
|
||||
|
||||
out.WriteString("#if defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n\n")
|
||||
out.WriteString(data.AuxBaseCc)
|
||||
out.WriteString(cgen.EmbeddedString_AuxBaseCc.Trim())
|
||||
out.WriteString("\n")
|
||||
for _, f := range data.AuxNonBaseCcFiles {
|
||||
out.WriteString(f)
|
||||
for _, f := range cgen.EmbeddedStrings_AuxNonBaseCcFiles {
|
||||
out.WriteString(f.Trim())
|
||||
out.WriteString("\n")
|
||||
}
|
||||
out.WriteString("#endif // defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)\n\n")
|
||||
|
||||
@@ -18,7 +18,6 @@ import (
|
||||
"bufio"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
@@ -83,7 +82,7 @@ func doBenchTest(args []string, bench bool) error {
|
||||
func doBenchTest1(filename string, bench bool, ccompilers string, focus string,
|
||||
iterscale int, mimic bool, reps int) (failed bool, err error) {
|
||||
|
||||
workDir, err := ioutil.TempDir("", "wuffs-c")
|
||||
workDir, err := os.MkdirTemp("", "wuffs-c")
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
|
||||
@@ -37,7 +37,12 @@ func doGen(wuffsRoot string, args []string) error { return doGenGenlib(wuffsR
|
||||
func doGenlib(wuffsRoot string, args []string) error { return doGenGenlib(wuffsRoot, args, true) }
|
||||
|
||||
func doGenGenlib(wuffsRoot string, args []string, genlib bool) error {
|
||||
flags := flag.NewFlagSet("gen", flag.ExitOnError)
|
||||
flagSetName := `"wuffs gen <flags> std/pkg1 std/pkg2 etc"`
|
||||
if genlib {
|
||||
flagSetName = `"wuffs genlib <flags> std/pkg1 std/pkg2 etc"`
|
||||
}
|
||||
|
||||
flags := flag.NewFlagSet(flagSetName, flag.ExitOnError)
|
||||
genlinenumFlag := flags.Bool("genlinenum", cf.GenlinenumDefault, cf.GenlinenumUsage)
|
||||
langsFlag := flags.String("langs", langsDefault, langsUsage)
|
||||
skipgendepsFlag := flags.Bool("skipgendeps", skipgendepsDefault, skipgendepsUsage)
|
||||
|
||||
@@ -21,7 +21,6 @@ import (
|
||||
"bytes"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
@@ -53,6 +52,8 @@ The commands are:
|
||||
gen generate code for packages and dependencies
|
||||
genlib generate software libraries
|
||||
test test packages
|
||||
|
||||
Use "wuffs help <command>" for more information about a command.
|
||||
`)
|
||||
}
|
||||
|
||||
@@ -77,6 +78,13 @@ func main1() error {
|
||||
return c.do(wuffsRoot, args[1:])
|
||||
}
|
||||
}
|
||||
if (len(args) == 2) && (args[0] == "help") {
|
||||
for _, c := range commands {
|
||||
if args[1] == c.name {
|
||||
return c.do(wuffsRoot, []string{"-help"})
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
usage()
|
||||
os.Exit(1)
|
||||
@@ -142,14 +150,14 @@ func appendDir(dstQF []string, qualDirname string, suffix string, returnSubdirs
|
||||
}
|
||||
|
||||
func writeFile(filename string, contents []byte) error {
|
||||
if existing, err := ioutil.ReadFile(filename); err == nil && bytes.Equal(existing, contents) {
|
||||
if existing, err := os.ReadFile(filename); err == nil && bytes.Equal(existing, contents) {
|
||||
fmt.Println("gen unchanged: ", filename)
|
||||
return nil
|
||||
}
|
||||
if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := ioutil.WriteFile(filename, contents, 0644); err != nil {
|
||||
if err := os.WriteFile(filename, contents, 0644); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Println("gen wrote: ", filename)
|
||||
|
||||
@@ -29,16 +29,26 @@ func doBench(wuffsRoot string, args []string) error { return doBenchTest(wuffsRo
|
||||
func doTest(wuffsRoot string, args []string) error { return doBenchTest(wuffsRoot, args, false) }
|
||||
|
||||
func doBenchTest(wuffsRoot string, args []string, bench bool) error {
|
||||
flags := flag.NewFlagSet("test", flag.ExitOnError)
|
||||
flagSetName := `"wuffs test <flags> std/pkg1 std/pkg2 etc"`
|
||||
if bench {
|
||||
flagSetName = `"wuffs bench <flags> std/pkg1 std/pkg2 etc"`
|
||||
}
|
||||
|
||||
flags := flag.NewFlagSet(flagSetName, flag.ExitOnError)
|
||||
ccompilersFlag := flags.String("ccompilers", cf.CcompilersDefault, cf.CcompilersUsage)
|
||||
focusFlag := flags.String("focus", cf.FocusDefault, cf.FocusUsage)
|
||||
iterscaleFlag := flags.Int("iterscale", cf.IterscaleDefault, cf.IterscaleUsage)
|
||||
langsFlag := flags.String("langs", langsDefault, langsUsage)
|
||||
mimicFlag := flags.Bool("mimic", cf.MimicDefault, cf.MimicUsage)
|
||||
repsFlag := flags.Int("reps", cf.RepsDefault, cf.RepsUsage)
|
||||
skipgenFlag := flags.Bool("skipgen", skipgenDefault, skipgenUsage)
|
||||
skipgendepsFlag := flags.Bool("skipgendeps", skipgendepsDefault, skipgendepsUsage)
|
||||
|
||||
iterscaleFlag := (*int)(nil)
|
||||
repsFlag := (*int)(nil)
|
||||
if bench {
|
||||
iterscaleFlag = flags.Int("iterscale", cf.IterscaleDefault, cf.IterscaleUsage)
|
||||
repsFlag = flags.Int("reps", cf.RepsDefault, cf.RepsUsage)
|
||||
}
|
||||
|
||||
if err := flags.Parse(args); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -53,13 +63,15 @@ func doBenchTest(wuffsRoot string, args []string, bench bool) error {
|
||||
if !cf.IsAlphaNumericIsh(*focusFlag) {
|
||||
return fmt.Errorf("bad -focus flag value %q", *focusFlag)
|
||||
}
|
||||
if *iterscaleFlag < cf.IterscaleMin || cf.IterscaleMax < *iterscaleFlag {
|
||||
return fmt.Errorf("bad -iterscale flag value %d, outside the range [%d ..= %d]",
|
||||
*iterscaleFlag, cf.IterscaleMin, cf.IterscaleMax)
|
||||
}
|
||||
if *repsFlag < cf.RepsMin || cf.RepsMax < *repsFlag {
|
||||
return fmt.Errorf("bad -reps flag value %d, outside the range [%d ..= %d]",
|
||||
*repsFlag, cf.RepsMin, cf.RepsMax)
|
||||
if bench {
|
||||
if *iterscaleFlag < cf.IterscaleMin || cf.IterscaleMax < *iterscaleFlag {
|
||||
return fmt.Errorf("bad -iterscale flag value %d, outside the range [%d ..= %d]",
|
||||
*iterscaleFlag, cf.IterscaleMin, cf.IterscaleMax)
|
||||
}
|
||||
if *repsFlag < cf.RepsMin || cf.RepsMax < *repsFlag {
|
||||
return fmt.Errorf("bad -reps flag value %d, outside the range [%d ..= %d]",
|
||||
*repsFlag, cf.RepsMin, cf.RepsMax)
|
||||
}
|
||||
}
|
||||
|
||||
args = flags.Args()
|
||||
|
||||
@@ -29,7 +29,6 @@ import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
@@ -113,9 +112,9 @@ func walk(filename string, info os.FileInfo, err error) error {
|
||||
func do(r io.Reader, filename string) error {
|
||||
src, err := []byte(nil), error(nil)
|
||||
if r != nil {
|
||||
src, err = ioutil.ReadAll(r)
|
||||
src, err = io.ReadAll(r)
|
||||
} else {
|
||||
src, err = ioutil.ReadFile(filename)
|
||||
src, err = os.ReadFile(filename)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -160,7 +159,7 @@ func do(r io.Reader, filename string) error {
|
||||
const chmodSupported = runtime.GOOS != "windows"
|
||||
|
||||
func writeFile(filename string, b []byte) error {
|
||||
f, err := ioutil.TempFile(filepath.Dir(filename), filepath.Base(filename))
|
||||
f, err := os.CreateTemp(filepath.Dir(filename), filepath.Base(filename))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -38,7 +38,7 @@ The output of those benchmark programs is compatible with the
|
||||
[benchstat](https://godoc.org/golang.org/x/perf/cmd/benchstat) tool. For
|
||||
example, that tool can calculate confidence intervals based on multiple
|
||||
benchmark runs, or calculate p-values when comparing numbers before and after a
|
||||
code change. To install it, first install Go, then run `go get
|
||||
code change. To install it, first install Go, then run `go install
|
||||
golang.org/x/perf/cmd/benchstat`.
|
||||
|
||||
|
||||
|
||||
@@ -20,10 +20,10 @@
|
||||
- Added `example/json-to-cbor`.
|
||||
- Added `example/jsonfindptrs`.
|
||||
- Added `example/jsonptr`.
|
||||
- Added `example/sdl-imageviewer`.
|
||||
- Added `slice base.u8 peek/poke` methods.
|
||||
- Added `std/bmp`.
|
||||
- Added `std/cbor`.
|
||||
- Added `std/gif.config_decoder`.
|
||||
- Added `std/json`.
|
||||
- Added `std/nie`.
|
||||
- Added `std/png`.
|
||||
@@ -40,7 +40,7 @@
|
||||
- Added slice `uintptr_low_12_bits` method.
|
||||
- Added tokens.
|
||||
- Changed `gif.decoder_workbuf_len_max_incl_worst_case` from 1 to 0.
|
||||
- Changed default C compilers from `clang-5.0,gcc` to `clang-9,gcc`.
|
||||
- Changed default C compilers from `clang-5.0,gcc` to `clang,gcc`.
|
||||
- Changed the C formatting style; removed the `-cformatter` flag.
|
||||
- Changed what the `std/gif` benchmarks actually measure.
|
||||
- Made `wuffs_base__pixel_format` a struct.
|
||||
|
||||
@@ -22,15 +22,25 @@ test suite, you might also have to install C compilers like clang and gcc, as
|
||||
well as C libraries (and their .h files) like libjpeg and libpng, as some tests
|
||||
compare that Wuffs produces exactly the same output as these other libraries.
|
||||
|
||||
Running `go get -v github.com/google/wuffs/cmd/...` will download and install
|
||||
the Wuffs tools. Change `get` to `install` to re-install those programs without
|
||||
downloading, e.g. after you've modified their source code, or after a manually
|
||||
issued `git pull`. The Wuffs tools that you'll most often use are `wuffsfmt`
|
||||
Run `git clone https://github.com/google/wuffs.git` to get the latest Wuffs
|
||||
code, `cd` into its directory and run `go install -v ./cmd/wuffs*` to install
|
||||
the Wuffs tools. The Wuffs tools that you'll most often use are `wuffsfmt`
|
||||
(analogous to `clang-format`, `gofmt` or `rustfmt`) and `wuffs` (roughly
|
||||
analogous to `make`, `go` or `cargo`).
|
||||
|
||||
You should now be able to run `wuffs test`. If all goes well, you should see
|
||||
some output containing the word "PASS" multiple times.
|
||||
You should now be able to run `wuffs test`. If you only have the `gcc` C
|
||||
compiler installed, but not `clang`, then you can run `wuffs
|
||||
test -ccompilers=gcc` instead. If all goes well, you should see some output
|
||||
containing the word "PASS" multiple times.
|
||||
|
||||
Remember to re-run `go install etc` whenever you've modified the Wuffs *tools'*
|
||||
source code (i.e. `*.go` files) or after a manually issued `git pull`. If
|
||||
you're only modifying the Wuffs *standard library's* source code (i.e.
|
||||
`*.wuffs` files), re-running `go install etc` is unnecessary.
|
||||
|
||||
If you're modifying just one particular codec in the standard library, such as
|
||||
the `std/png/*.wuffs` files, then you can exclude unrelated tests by running
|
||||
`wuffs test std/png`.
|
||||
|
||||
|
||||
## Poking Around
|
||||
|
||||
@@ -61,3 +61,4 @@ Package-specific quirks:
|
||||
|
||||
- [GIF image decoder quirks](/std/gif/decode_quirks.wuffs)
|
||||
- [JSON decoder quirks](/std/json/decode_quirks.wuffs)
|
||||
- [ZLIB decoder quirks](/std/zlib/decode_quirks.wuffs)
|
||||
@@ -1,6 +1,6 @@
|
||||
# Naïve Image Formats: NIE, NII, NIA
|
||||
|
||||
Status: Draft (as of December 2020). There is no compatibility guarantee yet.
|
||||
Status: Draft (as of November 2021). There is no compatibility guarantee yet.
|
||||
|
||||
A companion document has further discussion of [NIE related
|
||||
work](/doc/spec/nie-related-work.md).
|
||||
@@ -18,13 +18,14 @@ images. The 16 byte header:
|
||||
is not valid UTF-8) denotes version 1. There are no other valid versions at
|
||||
this time.
|
||||
- The second byte must be an ASCII 'b'. This denotes that the payload is in
|
||||
BGRA order (in terms of the wire format, independent of CPU endianness).
|
||||
BGRA order (not RGBA), in terms of the wire format, independent of CPU
|
||||
endianness.
|
||||
- The third byte, either an ASCII 'n' or an ASCII 'p', denotes whether the
|
||||
payload contains non-premultiplied or premultiplied alpha.
|
||||
- The fourth byte, either an ASCII '4' or an ASCII '8', denotes whether there
|
||||
are 4 or 8 bytes per pixel.
|
||||
- Future format versions may allow other byte values, but in version 1, it
|
||||
must be '\xFF', then 'b' or 'r', then 'n' or 'p', then '4' or '8'.
|
||||
must be '\xFF', then 'b', then 'n' or 'p', then '4' or '8'.
|
||||
- 4 bytes little-endian `uint32` width. The high bit must not be set.
|
||||
- 4 bytes little-endian `uint32` height. The high bit must not be set.
|
||||
|
||||
@@ -369,4 +370,4 @@ in a long "E", "I" or "A" sound. It's definitely a hard "N", not a soft one.
|
||||
|
||||
---
|
||||
|
||||
Updated on December 2020.
|
||||
Updated on November 2021.
|
||||
@@ -661,7 +661,7 @@ Go programming language libraries:
|
||||
- [RAC](https://godoc.org/github.com/google/wuffs/lib/rac)
|
||||
- [RAC + Zlib](https://godoc.org/github.com/google/wuffs/lib/raczlib)
|
||||
|
||||
Command line tool, installable via `go get
|
||||
Command line tool, installable via `go install
|
||||
github.com/google/wuffs/cmd/ractool`:
|
||||
|
||||
- [ractool](https://godoc.org/github.com/google/wuffs/cmd/ractool)
|
||||
|
||||
@@ -82,9 +82,9 @@ reserved for impure effects.
|
||||
Expressions involving the standard arithmetic operators (e.g. `*`, `+`), will
|
||||
not compile if overflow is possible. Some of these operators have alternative
|
||||
'tilde' forms (e.g. `~mod*`, `~sat+`) which provide
|
||||
[modular](/doc/glossary.md#modular-arithmetic.md) and
|
||||
[saturating](/doc/glossary.md#saturating-arithmetic.md) arithmetic. By
|
||||
definition, these never overflow.
|
||||
[modular](/doc/glossary.md#modular-arithmetic) and
|
||||
[saturating](/doc/glossary.md#saturating-arithmetic) arithmetic. By definition,
|
||||
these never overflow.
|
||||
|
||||
The `as` operator, e.g. `x as T`, converts an expression `x` to the type `T`.
|
||||
|
||||
|
||||
@@ -46,6 +46,16 @@ for a C++ compiler $CXX, such as clang++ or g++.
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
|
||||
@@ -39,6 +39,16 @@ https://skia-review.googlesource.com/c/skia/+/290618
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -54,6 +64,7 @@ https://skia-review.googlesource.com/c/skia/+/290618
|
||||
#define WUFFS_CONFIG__MODULE__DEFLATE
|
||||
#define WUFFS_CONFIG__MODULE__GIF
|
||||
#define WUFFS_CONFIG__MODULE__LZW
|
||||
#define WUFFS_CONFIG__MODULE__NIE
|
||||
#define WUFFS_CONFIG__MODULE__PNG
|
||||
#define WUFFS_CONFIG__MODULE__WBMP
|
||||
#define WUFFS_CONFIG__MODULE__ZLIB
|
||||
@@ -118,11 +129,14 @@ wuffs_base__frame_config g_frame_config = {0};
|
||||
int32_t g_fourcc = 0;
|
||||
uint32_t g_width = 0;
|
||||
uint32_t g_height = 0;
|
||||
uint32_t g_num_animation_loops = 0;
|
||||
uint64_t g_num_printed_frames = 0;
|
||||
|
||||
wuffs_base__image_decoder* g_image_decoder = NULL;
|
||||
union {
|
||||
wuffs_bmp__decoder bmp;
|
||||
wuffs_gif__decoder gif;
|
||||
wuffs_nie__decoder nie;
|
||||
wuffs_png__decoder png;
|
||||
wuffs_wbmp__decoder wbmp;
|
||||
} g_potential_decoders;
|
||||
@@ -140,7 +154,7 @@ union {
|
||||
#endif
|
||||
|
||||
#ifndef WORKBUF_ARRAY_SIZE
|
||||
#define WORKBUF_ARRAY_SIZE (1024 * 1024)
|
||||
#define WORKBUF_ARRAY_SIZE (256 * 1024 * 1024)
|
||||
#endif
|
||||
|
||||
#ifndef PIXBUF_ARRAY_SIZE
|
||||
@@ -266,6 +280,16 @@ initialize_image_decoder() {
|
||||
&g_potential_decoders.gif);
|
||||
return NULL;
|
||||
|
||||
case WUFFS_BASE__FOURCC__NIE:
|
||||
status = wuffs_nie__decoder__initialize(
|
||||
&g_potential_decoders.nie, sizeof g_potential_decoders.nie,
|
||||
WUFFS_VERSION, WUFFS_INITIALIZE__DEFAULT_OPTIONS);
|
||||
TRY(wuffs_base__status__message(&status));
|
||||
g_image_decoder =
|
||||
wuffs_nie__decoder__upcast_as__wuffs_base__image_decoder(
|
||||
&g_potential_decoders.nie);
|
||||
return NULL;
|
||||
|
||||
case WUFFS_BASE__FOURCC__PNG:
|
||||
status = wuffs_png__decoder__initialize(
|
||||
&g_potential_decoders.png, sizeof g_potential_decoders.png,
|
||||
@@ -414,12 +438,10 @@ fill_rectangle(wuffs_base__rect_ie_u32 rect,
|
||||
wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(color);
|
||||
wuffs_base__table_u8 tab = wuffs_base__pixel_buffer__plane(&g_pixbuf, 0);
|
||||
|
||||
uint32_t y;
|
||||
for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {
|
||||
for (uint32_t y = rect.min_incl_y; y < rect.max_excl_y; y++) {
|
||||
uint8_t* p =
|
||||
tab.ptr + (y * tab.stride) + (rect.min_incl_x * BYTES_PER_PIXEL);
|
||||
uint32_t x;
|
||||
for (x = rect.min_incl_x; x < rect.max_excl_x; x++) {
|
||||
for (uint32_t x = rect.min_incl_x; x < rect.max_excl_x; x++) {
|
||||
wuffs_base__poke_u32le__no_bounds_check(p, nonpremul);
|
||||
p += BYTES_PER_PIXEL;
|
||||
}
|
||||
@@ -446,13 +468,13 @@ print_nia_duration(wuffs_base__flicks duration) {
|
||||
|
||||
void //
|
||||
print_nie_frame() {
|
||||
g_num_printed_frames++;
|
||||
print_nix_header(0x45AFC36E); // "nïE" as a u32le.
|
||||
wuffs_base__table_u8 tab = wuffs_base__pixel_buffer__plane(&g_pixbuf, 0);
|
||||
if (tab.width == tab.stride) {
|
||||
ignore_return_value(write(STDOUT_FD, tab.ptr, tab.width * tab.height));
|
||||
} else {
|
||||
size_t y;
|
||||
for (y = 0; y < tab.height; y++) {
|
||||
for (size_t y = 0; y < tab.height; y++) {
|
||||
ignore_return_value(
|
||||
write(STDOUT_FD, tab.ptr + (y * tab.stride), tab.width));
|
||||
break;
|
||||
@@ -471,30 +493,29 @@ print_nia_padding() {
|
||||
|
||||
void //
|
||||
print_nia_footer() {
|
||||
// For still (non-animated) images, the number of animation loops has no
|
||||
// practical effect: the pixels on screen do not change over time regardless
|
||||
// of its value. In the wire format encoding, there might be no explicit
|
||||
// "number of animation loops" value listed in the source bytes. Various
|
||||
// codec implementations may therefore choose an implicit default of 0 ("loop
|
||||
// forever") or 1 ("loop exactly once"). Either is equally valid.
|
||||
//
|
||||
// However, when comparing the output of this convert-to-NIA program (backed
|
||||
// by Wuffs' image codecs) with other convert-to-NIA programs, it is useful
|
||||
// to canonicalize still images' "number of animation loops" to 0.
|
||||
uint32_t n = g_num_animation_loops;
|
||||
if (g_num_printed_frames <= 1) {
|
||||
n = 0;
|
||||
}
|
||||
|
||||
uint8_t data[8];
|
||||
wuffs_base__poke_u32le__no_bounds_check(
|
||||
data + 0x00,
|
||||
wuffs_base__image_decoder__num_animation_loops(g_image_decoder));
|
||||
wuffs_base__poke_u32le__no_bounds_check(data + 0x00, n);
|
||||
wuffs_base__poke_u32le__no_bounds_check(data + 0x04, 0x80000000);
|
||||
ignore_return_value(write(STDOUT_FD, &data[0], 8));
|
||||
}
|
||||
|
||||
const char* //
|
||||
main1(int argc, char** argv) {
|
||||
TRY(parse_flags(argc, argv));
|
||||
if (g_flags.fail_if_unsandboxed && !g_sandboxed) {
|
||||
return "main: unsandboxed";
|
||||
}
|
||||
|
||||
g_src.data.ptr = g_src_buffer_array;
|
||||
g_src.data.len = SRC_BUFFER_ARRAY_SIZE;
|
||||
|
||||
TRY(load_image_type());
|
||||
TRY(load_image_config());
|
||||
if (!g_flags.first_frame_only) {
|
||||
print_nix_header(0x41AFC36E); // "nïA" as a u32le.
|
||||
}
|
||||
|
||||
convert_frames() {
|
||||
wuffs_base__flicks total_duration = 0;
|
||||
while (true) {
|
||||
// Decode the wuffs_base__frame_config.
|
||||
@@ -505,7 +526,7 @@ main1(int argc, char** argv) {
|
||||
if (dfc_status.repr == NULL) {
|
||||
break;
|
||||
} else if (dfc_status.repr == wuffs_base__note__end_of_data) {
|
||||
goto done;
|
||||
return NULL;
|
||||
} else if (dfc_status.repr != wuffs_base__suspension__short_read) {
|
||||
return wuffs_base__status__message(&dfc_status);
|
||||
}
|
||||
@@ -520,9 +541,6 @@ main1(int argc, char** argv) {
|
||||
return "main: animation frame duration overflow";
|
||||
}
|
||||
total_duration += duration;
|
||||
if (!g_flags.first_frame_only) {
|
||||
print_nia_duration(total_duration);
|
||||
}
|
||||
|
||||
if (wuffs_base__frame_config__index(&g_frame_config) == 0) {
|
||||
fill_rectangle(
|
||||
@@ -543,6 +561,7 @@ main1(int argc, char** argv) {
|
||||
|
||||
// Decode the frame (the pixels).
|
||||
wuffs_base__status df_status;
|
||||
const char* decode_frame_io_error_message = NULL;
|
||||
while (true) {
|
||||
df_status = wuffs_base__image_decoder__decode_frame(
|
||||
g_image_decoder, &g_pixbuf, &g_src,
|
||||
@@ -553,18 +572,57 @@ main1(int argc, char** argv) {
|
||||
if (df_status.repr != wuffs_base__suspension__short_read) {
|
||||
break;
|
||||
}
|
||||
TRY(read_more_src());
|
||||
decode_frame_io_error_message = read_more_src();
|
||||
if (decode_frame_io_error_message != NULL) {
|
||||
// Neuter the "short read" df_status so that convert_frames returns the
|
||||
// I/O error message instead.
|
||||
df_status.repr = NULL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
print_nie_frame();
|
||||
// Update g_num_animation_loops. It's rare in practice, but the animation
|
||||
// loop count can change over the course of decoding an image file.
|
||||
//
|
||||
// This program updates the global once per frame (even though the Wuffs
|
||||
// API also lets you call wuffs_base__image_decoder__num_animation_loops
|
||||
// just once, after the decoding is complete) to more closely match the
|
||||
// Chromium web browser. This program emits (via print_nia_footer) the
|
||||
// value from the final animation frame's update.
|
||||
//
|
||||
// Chromium image decoding uses two passes. (Wuffs' API lets you use a
|
||||
// single pass but Chromium also wraps other libraries). Its first pass
|
||||
// counts the number of animation frames (call it N). The second pass
|
||||
// decodes exactly N frames. In particular, if the animation loop count
|
||||
// would change between the end of frame N and the end of the file then
|
||||
// Chromium's design will not pick up that change, even if it's a valid
|
||||
// change in terms of the image file format.
|
||||
//
|
||||
// Specifically, for the test/data/artificial-gif/multiple-loop-counts.gif
|
||||
// file this program emits 31 (0x1F) to match Chromium, even though the
|
||||
// file arguably has a 41 (0x29) loop count after a complete decode.
|
||||
g_num_animation_loops =
|
||||
wuffs_base__image_decoder__num_animation_loops(g_image_decoder);
|
||||
|
||||
// Print a complete NIE frame (and surrounding bytes, for NIA).
|
||||
if (!g_flags.first_frame_only) {
|
||||
print_nia_duration(total_duration);
|
||||
}
|
||||
print_nie_frame();
|
||||
if (!g_flags.first_frame_only) {
|
||||
print_nia_padding();
|
||||
}
|
||||
|
||||
// Return early if there was an error decoding the frame.
|
||||
if (df_status.repr != NULL) {
|
||||
return wuffs_base__status__message(&df_status);
|
||||
} else if (decode_frame_io_error_message != NULL) {
|
||||
return decode_frame_io_error_message;
|
||||
} else if (g_flags.first_frame_only) {
|
||||
return NULL;
|
||||
}
|
||||
print_nia_padding();
|
||||
|
||||
// Dispose the frame.
|
||||
switch (wuffs_base__frame_config__disposal(&g_frame_config)) {
|
||||
case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND: {
|
||||
fill_rectangle(
|
||||
@@ -582,10 +640,29 @@ main1(int argc, char** argv) {
|
||||
}
|
||||
}
|
||||
}
|
||||
return "main: unreachable";
|
||||
}
|
||||
|
||||
done:
|
||||
print_nia_footer();
|
||||
return NULL;
|
||||
const char* //
|
||||
main1(int argc, char** argv) {
|
||||
TRY(parse_flags(argc, argv));
|
||||
if (g_flags.fail_if_unsandboxed && !g_sandboxed) {
|
||||
return "main: unsandboxed";
|
||||
}
|
||||
|
||||
g_src.data.ptr = g_src_buffer_array;
|
||||
g_src.data.len = SRC_BUFFER_ARRAY_SIZE;
|
||||
|
||||
TRY(load_image_type());
|
||||
TRY(load_image_config());
|
||||
if (!g_flags.first_frame_only) {
|
||||
print_nix_header(0x41AFC36E); // "nïA" as a u32le.
|
||||
}
|
||||
const char* ret = convert_frames();
|
||||
if (!g_flags.first_frame_only) {
|
||||
print_nia_footer();
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int //
|
||||
|
||||
@@ -42,12 +42,27 @@ for a C++ compiler $CXX, such as clang++ or g++.
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but it
|
||||
// demonstrates making all of Wuffs' functions have static storage. The
|
||||
// motivation is discussed in the "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
// formats. Without this macro definition, an optimizing compiler or linker may
|
||||
// very well discard Wuffs code for unused codecs, but listing the Wuffs
|
||||
// modules we use makes that process explicit. Preprocessing means that such
|
||||
// code simply isn't compiled.
|
||||
#define WUFFS_CONFIG__MODULES
|
||||
#define WUFFS_CONFIG__MODULE__BASE
|
||||
#define WUFFS_CONFIG__MODULE__CRC32
|
||||
|
||||
// If building this program in an environment that doesn't easily accommodate
|
||||
// relative includes, you can use the script/inline-c-relative-includes.go
|
||||
// program to generate a stand-alone C++ file.
|
||||
|
||||
@@ -71,6 +71,16 @@ micros_since_start(struct timespec* now) {
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -205,11 +215,9 @@ restore_background(wuffs_base__pixel_buffer* pb,
|
||||
wuffs_base__rect_ie_u32 bounds,
|
||||
wuffs_base__color_u32_argb_premul background_color) {
|
||||
size_t width4 = (size_t)(wuffs_base__pixel_config__width(&pb->pixcfg)) * 4;
|
||||
size_t y;
|
||||
for (y = bounds.min_incl_y; y < bounds.max_excl_y; y++) {
|
||||
size_t x;
|
||||
for (size_t y = bounds.min_incl_y; y < bounds.max_excl_y; y++) {
|
||||
uint8_t* d = g_curr_dst_buffer + (y * width4) + (bounds.min_incl_x * 4);
|
||||
for (x = bounds.min_incl_x; x < bounds.max_excl_x; x++) {
|
||||
for (size_t x = bounds.min_incl_x; x < bounds.max_excl_x; x++) {
|
||||
wuffs_base__poke_u32le__no_bounds_check(d, background_color);
|
||||
d += sizeof(wuffs_base__color_u32_argb_premul);
|
||||
}
|
||||
@@ -224,10 +232,8 @@ print_ascii_art(wuffs_base__pixel_buffer* pb) {
|
||||
uint8_t* d = g_curr_dst_buffer;
|
||||
uint8_t* p = g_printbuf.ptr;
|
||||
*p++ = '\n';
|
||||
uint32_t y;
|
||||
for (y = 0; y < height; y++) {
|
||||
uint32_t x;
|
||||
for (x = 0; x < width; x++) {
|
||||
for (uint32_t y = 0; y < height; y++) {
|
||||
for (uint32_t x = 0; x < width; x++) {
|
||||
wuffs_base__color_u32_argb_premul c =
|
||||
wuffs_base__peek_u32le__no_bounds_check(d);
|
||||
d += sizeof(wuffs_base__color_u32_argb_premul);
|
||||
@@ -255,10 +261,8 @@ print_color_art(wuffs_base__pixel_buffer* pb) {
|
||||
uint8_t* p = g_printbuf.ptr;
|
||||
*p++ = '\n';
|
||||
p += sprintf((char*)p, "%s", g_reset_color);
|
||||
uint32_t y;
|
||||
for (y = 0; y < height; y++) {
|
||||
uint32_t x;
|
||||
for (x = 0; x < width; x++) {
|
||||
for (uint32_t y = 0; y < height; y++) {
|
||||
for (uint32_t x = 0; x < width; x++) {
|
||||
wuffs_base__color_u32_argb_premul c =
|
||||
wuffs_base__peek_u32le__no_bounds_check(d);
|
||||
d += sizeof(wuffs_base__color_u32_argb_premul);
|
||||
@@ -406,10 +410,9 @@ play() {
|
||||
if (wuffs_base__frame_config__index(&fc) == 0) {
|
||||
wuffs_base__color_u32_argb_premul background_color =
|
||||
wuffs_base__frame_config__background_color(&fc);
|
||||
size_t i;
|
||||
size_t n = g_dst_len / sizeof(wuffs_base__color_u32_argb_premul);
|
||||
uint8_t* p = g_curr_dst_buffer;
|
||||
for (i = 0; i < n; i++) {
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
wuffs_base__poke_u32le__no_bounds_check(p, background_color);
|
||||
p += sizeof(wuffs_base__color_u32_argb_premul);
|
||||
}
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
imageviewer is a simple GUI program for viewing images. On Linux, GUI means
|
||||
X11. To run:
|
||||
|
||||
$CXX imageviewer.cc -lxcb -lxcb-image && \
|
||||
$CXX imageviewer.cc -lxcb -lxcb-image -lxcb-render -lxcb-render-util && \
|
||||
./a.out ../../test/data/bricks-*.gif; rm -f a.out
|
||||
|
||||
for a C++ compiler $CXX, such as clang++ or g++.
|
||||
@@ -29,10 +29,17 @@ stdin.
|
||||
|
||||
The Return key is equivalent to the Space key.
|
||||
|
||||
The ',' Comma and '.' Period keys cycle through background colors, which
|
||||
matters if the image has fully or partially transparent pixels.
|
||||
|
||||
The '1' to '8' keys change the magnification zoom (or minification zoom with
|
||||
the shift key). The '0' key toggles nearest neighbor and bilinear filtering.
|
||||
|
||||
The Escape key quits.
|
||||
*/
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <math.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
@@ -44,6 +51,16 @@ The Escape key quits.
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -71,10 +88,11 @@ The Escape key quits.
|
||||
// program to generate a stand-alone C file.
|
||||
#include "../../release/c/wuffs-unsupported-snapshot.c"
|
||||
|
||||
// X11 limits its image dimensions to uint16_t.
|
||||
#define MAX_INCL_DIMENSION 65535
|
||||
// X11 limits its image dimensions to uint16_t and some coordinates to int16_t.
|
||||
#define MAX_INCL_DIMENSION 32767
|
||||
|
||||
#define NUM_BACKGROUND_COLORS 3
|
||||
#define NUM_ZOOMS 8
|
||||
#define SRC_BUFFER_ARRAY_SIZE (64 * 1024)
|
||||
|
||||
wuffs_base__color_u32_argb_premul g_background_colors[NUM_BACKGROUND_COLORS] = {
|
||||
@@ -88,6 +106,121 @@ uint32_t g_height = 0;
|
||||
wuffs_aux::MemOwner g_pixbuf_mem_owner(nullptr, &free);
|
||||
wuffs_base__pixel_buffer g_pixbuf = {0};
|
||||
uint32_t g_background_color_index = 0;
|
||||
int32_t g_zoom = 0;
|
||||
bool g_filter = false;
|
||||
|
||||
struct {
|
||||
int remaining_argc;
|
||||
char** remaining_argv;
|
||||
|
||||
double screen_gamma;
|
||||
} g_flags = {0};
|
||||
|
||||
static const char* g_usage =
|
||||
"Usage: imageviewer -flags input0.gif input1.png\n"
|
||||
"\n"
|
||||
"Flags:\n"
|
||||
" -screen_gamma=N.N (default 2.2; 0 disables gamma correction)";
|
||||
|
||||
const char* //
|
||||
parse_flags(int argc, char** argv) {
|
||||
g_flags.screen_gamma = 2.2;
|
||||
|
||||
int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name.
|
||||
for (; c < argc; c++) {
|
||||
char* arg = argv[c];
|
||||
if (*arg++ != '-') {
|
||||
break;
|
||||
}
|
||||
|
||||
// A double-dash "--foo" is equivalent to a single-dash "-foo". As special
|
||||
// cases, a bare "-" is not a flag (some programs may interpret it as
|
||||
// stdin) and a bare "--" means to stop parsing flags.
|
||||
if (*arg == '\x00') {
|
||||
break;
|
||||
} else if (*arg == '-') {
|
||||
arg++;
|
||||
if (*arg == '\x00') {
|
||||
c++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!strncmp(arg, "screen_gamma=", 13)) {
|
||||
g_flags.screen_gamma = atof(arg + 13);
|
||||
continue;
|
||||
}
|
||||
|
||||
return g_usage;
|
||||
}
|
||||
|
||||
g_flags.remaining_argc = argc - c;
|
||||
g_flags.remaining_argv = argv + c;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
class MyDecodeImageCallbacks : public wuffs_aux::DecodeImageCallbacks {
|
||||
public:
|
||||
MyDecodeImageCallbacks() : m_combined_gamma(1.0) {}
|
||||
|
||||
private:
|
||||
std::string //
|
||||
HandleMetadata(const wuffs_base__more_information& minfo,
|
||||
wuffs_base__slice_u8 raw) override {
|
||||
if (minfo.flavor == WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED) {
|
||||
switch (minfo.metadata__fourcc()) {
|
||||
case WUFFS_BASE__FOURCC__GAMA:
|
||||
// metadata_parsed__gama returns the inverse gamma scaled by 1e5.
|
||||
m_combined_gamma =
|
||||
1e5 / (g_flags.screen_gamma * minfo.metadata_parsed__gama());
|
||||
break;
|
||||
}
|
||||
}
|
||||
return wuffs_aux::DecodeImageCallbacks::HandleMetadata(minfo, raw);
|
||||
}
|
||||
|
||||
void //
|
||||
Done(wuffs_aux::DecodeImageResult& result,
|
||||
wuffs_aux::sync_io::Input& input,
|
||||
wuffs_aux::IOBuffer& buffer,
|
||||
wuffs_base__image_decoder::unique_ptr image_decoder) override {
|
||||
// Apply basic color correction - gamma correction. Proper color correction
|
||||
// should also involve considering any CHRM, ICCP and SRGB metadata but
|
||||
// that requires a non-trivial amount of code (such as skcms, Skia's Color
|
||||
// Management System). To keep this example program simple, we only
|
||||
// consider GAMA metadata (and 8-bit color channels) here.
|
||||
//
|
||||
// This code also assumes that wuffs_aux::DecodeImageCallbacks defaults to
|
||||
// producing a WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL pixel buffer.
|
||||
if ((result.pixbuf.pixel_format().repr ==
|
||||
WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) &&
|
||||
((m_combined_gamma < 0.9999) || (1.0001 < m_combined_gamma))) {
|
||||
uint8_t lut[256];
|
||||
lut[0x00] = 0x00;
|
||||
lut[0xFF] = 0xFF;
|
||||
for (uint32_t i = 1; i < 0xFF; i++) {
|
||||
lut[i] =
|
||||
(uint8_t)(floor(255.0 * pow(i / 255.0, m_combined_gamma) + 0.5));
|
||||
}
|
||||
|
||||
wuffs_base__table_u8 t = result.pixbuf.plane(0);
|
||||
size_t w4 = t.width / 4;
|
||||
for (size_t y = 0; y < t.height; y++) {
|
||||
uint8_t* ptr = t.ptr + (y * t.stride);
|
||||
for (size_t x = 0; x < w4; x++) {
|
||||
ptr[0] = lut[ptr[0]];
|
||||
ptr[1] = lut[ptr[1]];
|
||||
ptr[2] = lut[ptr[2]];
|
||||
ptr += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// m_combined_gamma holds the product of the screen gamma and the image
|
||||
// file's inverse gamma.
|
||||
double m_combined_gamma;
|
||||
};
|
||||
|
||||
bool //
|
||||
load_image(const char* filename) {
|
||||
@@ -108,14 +241,22 @@ load_image(const char* filename) {
|
||||
g_pixbuf_mem_owner.reset();
|
||||
g_pixbuf = wuffs_base__null_pixel_buffer();
|
||||
|
||||
wuffs_aux::DecodeImageCallbacks callbacks;
|
||||
uint64_t dia_flags = 0;
|
||||
if (g_flags.screen_gamma > 0) {
|
||||
dia_flags |= wuffs_aux::DecodeImageArgFlags::REPORT_METADATA_GAMA;
|
||||
}
|
||||
|
||||
MyDecodeImageCallbacks callbacks;
|
||||
wuffs_aux::sync_io::FileInput input(file);
|
||||
wuffs_aux::DecodeImageResult res = wuffs_aux::DecodeImage(
|
||||
callbacks, input,
|
||||
callbacks, input, wuffs_aux::DecodeImageArgQuirks::DefaultValue(),
|
||||
wuffs_aux::DecodeImageArgFlags(dia_flags),
|
||||
// Use PIXEL_BLEND__SRC_OVER, not the default PIXEL_BLEND__SRC, because
|
||||
// we also pass a background color.
|
||||
WUFFS_BASE__PIXEL_BLEND__SRC_OVER,
|
||||
g_background_colors[g_background_color_index], MAX_INCL_DIMENSION);
|
||||
wuffs_aux::DecodeImageArgPixelBlend(WUFFS_BASE__PIXEL_BLEND__SRC_OVER),
|
||||
wuffs_aux::DecodeImageArgBackgroundColor(
|
||||
g_background_colors[g_background_color_index]),
|
||||
wuffs_aux::DecodeImageArgMaxInclDimension(MAX_INCL_DIMENSION));
|
||||
if (filename) {
|
||||
fclose(file);
|
||||
}
|
||||
@@ -158,18 +299,24 @@ load_image(const char* filename) {
|
||||
#if defined(__linux__)
|
||||
#define SUPPORTED_OPERATING_SYSTEM
|
||||
|
||||
#include <xcb/render.h>
|
||||
#include <xcb/xcb.h>
|
||||
#include <xcb/xcb_image.h>
|
||||
#include <xcb/xcb_renderutil.h>
|
||||
|
||||
#define XK_BackSpace 0xFF08
|
||||
#define XK_Escape 0xFF1B
|
||||
#define XK_Return 0xFF0D
|
||||
|
||||
uint32_t g_maximum_request_length = 0; // Measured in 4-byte units.
|
||||
xcb_atom_t g_atom_net_wm_name = XCB_NONE;
|
||||
xcb_atom_t g_atom_utf8_string = XCB_NONE;
|
||||
xcb_atom_t g_atom_wm_protocols = XCB_NONE;
|
||||
xcb_atom_t g_atom_wm_delete_window = XCB_NONE;
|
||||
xcb_pixmap_t g_pixmap = XCB_NONE;
|
||||
xcb_gcontext_t g_pixmap_gc = XCB_NONE;
|
||||
xcb_render_picture_t g_pixmap_picture = XCB_NONE;
|
||||
xcb_render_pictforminfo_t* g_pictforminfo = NULL;
|
||||
xcb_keysym_t* g_keysyms = NULL;
|
||||
xcb_get_keyboard_mapping_reply_t* g_keyboard_mapping = NULL;
|
||||
|
||||
@@ -199,13 +346,71 @@ make_window(xcb_connection_t* c, xcb_screen_t* s) {
|
||||
return w;
|
||||
}
|
||||
|
||||
void //
|
||||
apply_zoom_and_filter(xcb_connection_t* c) {
|
||||
static const xcb_render_fixed_t neg_zooms[NUM_ZOOMS] = {
|
||||
0x00010000, // 1/1 as 16.16 fixed point
|
||||
0x00020000, // 2/1
|
||||
0x00040000, // 4/1
|
||||
0x00080000, // 8/1
|
||||
0x00100000, // 16/1
|
||||
0x00200000, // 32/1
|
||||
0x00400000, // 64/1
|
||||
0x00800000, // 128/1
|
||||
};
|
||||
static const xcb_render_fixed_t pos_zooms[NUM_ZOOMS] = {
|
||||
0x00010000, // 1/1 as 16.16 fixed point
|
||||
0x00008000, // 1/2
|
||||
0x00004000, // 1/4
|
||||
0x00002000, // 1/8
|
||||
0x00001000, // 1/16
|
||||
0x00000800, // 1/32
|
||||
0x00000400, // 1/64
|
||||
0x00000200, // 1/128
|
||||
};
|
||||
|
||||
xcb_render_fixed_t z = g_zoom < 0
|
||||
? neg_zooms[((uint32_t)(-g_zoom)) % NUM_ZOOMS]
|
||||
: pos_zooms[((uint32_t)(+g_zoom)) % NUM_ZOOMS];
|
||||
xcb_render_set_picture_transform(c, g_pixmap_picture,
|
||||
((xcb_render_transform_t){
|
||||
z, 0, 0, //
|
||||
0, z, 0, //
|
||||
0, 0, 0x10000, //
|
||||
}));
|
||||
|
||||
uint16_t f_len = 7;
|
||||
const char* f_ptr = "nearest";
|
||||
if (g_filter && (g_zoom != 0)) {
|
||||
f_len = 8;
|
||||
f_ptr = "bilinear";
|
||||
}
|
||||
xcb_render_set_picture_filter(c, g_pixmap_picture, f_len, f_ptr, 0, NULL);
|
||||
}
|
||||
|
||||
// zoom_shift returns (a << g_zoom), roughly speaking, but saturates at an
|
||||
// arbitrary value called M.
|
||||
//
|
||||
// The final two arguments to xcb_render_composite have uint16_t type (and
|
||||
// UINT16_MAX is 65535), but in practice, values above M sometimes don't work
|
||||
// in that the xcb_render_composite call has no visible effect.
|
||||
//
|
||||
// Some xrender debugging could potentially derive a more accurate maximum but
|
||||
// for now, the M = 30000 round number will do.
|
||||
uint16_t //
|
||||
zoom_shift(uint32_t a) {
|
||||
uint16_t M = 30000;
|
||||
uint64_t b = g_zoom < 0
|
||||
? (((uint64_t)a) >> (((uint32_t)(-g_zoom)) % NUM_ZOOMS))
|
||||
: (((uint64_t)a) << (((uint32_t)(+g_zoom)) % NUM_ZOOMS));
|
||||
return (b < M) ? b : M;
|
||||
}
|
||||
|
||||
bool //
|
||||
load(xcb_connection_t* c,
|
||||
xcb_screen_t* s,
|
||||
xcb_window_t w,
|
||||
xcb_gcontext_t g,
|
||||
const char* filename) {
|
||||
load(xcb_connection_t* c, xcb_window_t w, const char* filename) {
|
||||
if (g_pixmap != XCB_NONE) {
|
||||
xcb_render_free_picture(c, g_pixmap_picture);
|
||||
xcb_free_gc(c, g_pixmap_gc);
|
||||
xcb_free_pixmap(c, g_pixmap);
|
||||
}
|
||||
|
||||
@@ -214,21 +419,83 @@ load(xcb_connection_t* c,
|
||||
}
|
||||
wuffs_base__table_u8 tab = g_pixbuf.plane(0);
|
||||
|
||||
xcb_create_pixmap(c, s->root_depth, g_pixmap, w, g_width, g_height);
|
||||
xcb_image_t* image = xcb_image_create_native(
|
||||
c, g_width, g_height, XCB_IMAGE_FORMAT_Z_PIXMAP, s->root_depth, NULL,
|
||||
tab.height * tab.stride, tab.ptr);
|
||||
xcb_image_put(c, g_pixmap, g, image, 0, 0, 0);
|
||||
xcb_image_destroy(image);
|
||||
xcb_create_pixmap(c, g_pictforminfo->depth, g_pixmap, w, g_width, g_height);
|
||||
xcb_create_gc(c, g_pixmap_gc, g_pixmap, 0, NULL);
|
||||
xcb_render_create_picture(c, g_pixmap_picture, g_pixmap, g_pictforminfo->id,
|
||||
0, NULL);
|
||||
apply_zoom_and_filter(c);
|
||||
|
||||
// Copy the pixels from the X11 client process (this process) to the X11
|
||||
// server process. For large images, this may involve multiple xcb_image_put
|
||||
// calls, each copying part of the pixels (a strip that has the same width
|
||||
// but smaller height), to avoid XCB_CONN_CLOSED_REQ_LEN_EXCEED.
|
||||
if (g_width > 0) {
|
||||
uint32_t max_strip_height = g_maximum_request_length / g_width;
|
||||
for (uint32_t y = 0; y < g_height;) {
|
||||
uint32_t h = g_height - y;
|
||||
if (h > max_strip_height) {
|
||||
h = max_strip_height;
|
||||
}
|
||||
|
||||
// Make libxcb-image interpret WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL as
|
||||
// XCB_PICT_STANDARD_ARGB_32 with byte_order XCB_IMAGE_ORDER_LSB_FIRST.
|
||||
xcb_image_t* unconverted =
|
||||
xcb_image_create(g_width, // width
|
||||
h, // height
|
||||
XCB_IMAGE_FORMAT_Z_PIXMAP, // format
|
||||
32, // xpad
|
||||
g_pictforminfo->depth, // depth
|
||||
32, // bpp
|
||||
32, // unit
|
||||
XCB_IMAGE_ORDER_LSB_FIRST, // byte_order
|
||||
XCB_IMAGE_ORDER_MSB_FIRST, // bit_order
|
||||
NULL, // base
|
||||
h * tab.stride, // bytes
|
||||
tab.ptr + (y * tab.stride)); // data
|
||||
|
||||
xcb_image_t* converted =
|
||||
xcb_image_native(c, unconverted, true); // true means to convert.
|
||||
if (converted != unconverted) {
|
||||
xcb_image_destroy(unconverted);
|
||||
}
|
||||
xcb_image_put(c, g_pixmap, g_pixmap_gc, converted, 0, y, 0);
|
||||
xcb_image_destroy(converted);
|
||||
|
||||
y += h;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
const char* status = parse_flags(argc, argv);
|
||||
if (status) {
|
||||
fprintf(stderr, "%s\n", status);
|
||||
return 1;
|
||||
}
|
||||
|
||||
xcb_connection_t* c = xcb_connect(NULL, NULL);
|
||||
|
||||
g_maximum_request_length = xcb_get_maximum_request_length(c);
|
||||
// Our X11 requests (especially xcb_image_put) also need a header, in terms
|
||||
// of wire format. 256 4-byte units should be big enough.
|
||||
const uint32_t max_req_len_adjustment = 256;
|
||||
if (g_maximum_request_length < max_req_len_adjustment) {
|
||||
printf("XCB failure (maximum request length is too short)\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
g_maximum_request_length -= max_req_len_adjustment;
|
||||
|
||||
const xcb_setup_t* z = xcb_get_setup(c);
|
||||
xcb_screen_t* s = xcb_setup_roots_iterator(z).data;
|
||||
|
||||
const xcb_render_query_pict_formats_reply_t* pict_formats =
|
||||
xcb_render_util_query_formats(c);
|
||||
g_pictforminfo = xcb_render_util_find_standard_format(
|
||||
pict_formats, XCB_PICT_STANDARD_ARGB_32);
|
||||
|
||||
{
|
||||
xcb_intern_atom_cookie_t cookie0 =
|
||||
xcb_intern_atom(c, 1, 12, "_NET_WM_NAME");
|
||||
@@ -252,24 +519,37 @@ main(int argc, char** argv) {
|
||||
}
|
||||
|
||||
xcb_window_t w = make_window(c, s);
|
||||
xcb_gcontext_t g = xcb_generate_id(c);
|
||||
xcb_create_gc(c, g, w, 0, NULL);
|
||||
xcb_render_picture_t p = xcb_generate_id(c);
|
||||
xcb_render_create_picture(
|
||||
c, p, w,
|
||||
xcb_render_util_find_visual_format(pict_formats, s->root_visual)->format,
|
||||
0, NULL);
|
||||
init_keymap(c, z);
|
||||
xcb_flush(c);
|
||||
g_pixmap = xcb_generate_id(c);
|
||||
|
||||
bool loaded = load(c, s, w, g, (argc > 1) ? argv[1] : NULL);
|
||||
int arg = 1;
|
||||
g_pixmap = xcb_generate_id(c);
|
||||
g_pixmap_gc = xcb_generate_id(c);
|
||||
g_pixmap_picture = xcb_generate_id(c);
|
||||
|
||||
bool loaded = load(
|
||||
c, w, (g_flags.remaining_argc > 0) ? g_flags.remaining_argv[0] : NULL);
|
||||
int arg = 0;
|
||||
|
||||
while (true) {
|
||||
xcb_generic_event_t* event = xcb_wait_for_event(c);
|
||||
bool reload = false;
|
||||
if (!event) {
|
||||
printf("XCB failure (error code %d)\n", xcb_connection_has_error(c));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
bool reload = false;
|
||||
switch (event->response_type & 0x7F) {
|
||||
case XCB_EXPOSE: {
|
||||
xcb_expose_event_t* e = (xcb_expose_event_t*)event;
|
||||
if (loaded && (e->count == 0)) {
|
||||
xcb_copy_area(c, g_pixmap, w, g, 0, 0, 0, 0, g_width, g_height);
|
||||
xcb_render_composite(c, XCB_RENDER_PICT_OP_SRC, g_pixmap_picture,
|
||||
XCB_NONE, p, 0, 0, 0, 0, 0, 0,
|
||||
zoom_shift(g_width), zoom_shift(g_height));
|
||||
xcb_flush(c);
|
||||
}
|
||||
break;
|
||||
@@ -288,14 +568,14 @@ main(int argc, char** argv) {
|
||||
case ' ':
|
||||
case XK_BackSpace:
|
||||
case XK_Return:
|
||||
if (argc <= 2) {
|
||||
if (g_flags.remaining_argc <= 1) {
|
||||
break;
|
||||
}
|
||||
arg += (i != XK_BackSpace) ? +1 : -1;
|
||||
if (arg == 0) {
|
||||
arg = argc - 1;
|
||||
} else if (arg == argc) {
|
||||
arg = 1;
|
||||
if (arg < 0) {
|
||||
arg = g_flags.remaining_argc - 1;
|
||||
} else if (arg == g_flags.remaining_argc) {
|
||||
arg = 0;
|
||||
}
|
||||
reload = true;
|
||||
break;
|
||||
@@ -307,6 +587,32 @@ main(int argc, char** argv) {
|
||||
g_background_color_index %= NUM_BACKGROUND_COLORS;
|
||||
reload = true;
|
||||
break;
|
||||
|
||||
case '0':
|
||||
case '1':
|
||||
case '2':
|
||||
case '3':
|
||||
case '4':
|
||||
case '5':
|
||||
case '6':
|
||||
case '7':
|
||||
case '8':
|
||||
if (i == '0') {
|
||||
g_filter = !g_filter;
|
||||
} else {
|
||||
int32_t z = i - '1';
|
||||
if (e->state & XCB_MOD_MASK_SHIFT) {
|
||||
z = -z;
|
||||
}
|
||||
if (g_zoom == z) {
|
||||
break;
|
||||
}
|
||||
g_zoom = z;
|
||||
}
|
||||
apply_zoom_and_filter(c);
|
||||
xcb_clear_area(c, 1, w, 0, 0, 0xFFFF, 0xFFFF);
|
||||
xcb_flush(c);
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@@ -324,7 +630,7 @@ main(int argc, char** argv) {
|
||||
free(event);
|
||||
|
||||
if (reload) {
|
||||
loaded = load(c, s, w, g, argv[arg]);
|
||||
loaded = load(c, w, g_flags.remaining_argv[arg]);
|
||||
xcb_clear_area(c, 1, w, 0, 0, 0xFFFF, 0xFFFF);
|
||||
xcb_flush(c);
|
||||
}
|
||||
|
||||
@@ -46,6 +46,16 @@ for a C++ compiler $CXX, such as clang++ or g++.
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -349,7 +359,7 @@ main1(int argc, char** argv) {
|
||||
wuffs_aux::sync_io::FileInput input(in);
|
||||
return wuffs_aux::DecodeJson(
|
||||
callbacks, input,
|
||||
wuffs_base__make_slice_u32(g_quirks.data(), g_quirks.size()))
|
||||
wuffs_aux::DecodeJsonArgQuirks(g_quirks.data(), g_quirks.size()))
|
||||
.error_message;
|
||||
}
|
||||
|
||||
|
||||
@@ -78,6 +78,16 @@ for a C++ compiler $CXX, such as clang++ or g++.
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -558,8 +568,9 @@ main1(int argc, char** argv) {
|
||||
wuffs_aux::sync_io::FileInput input(in);
|
||||
return wuffs_aux::DecodeJson(
|
||||
callbacks, input,
|
||||
wuffs_base__make_slice_u32(g_quirks.data(), g_quirks.size()),
|
||||
(g_flags.query_c_string ? g_flags.query_c_string : ""))
|
||||
wuffs_aux::DecodeJsonArgQuirks(g_quirks.data(), g_quirks.size()),
|
||||
wuffs_aux::DecodeJsonArgJsonPointer(
|
||||
g_flags.query_c_string ? g_flags.query_c_string : ""))
|
||||
.error_message;
|
||||
}
|
||||
|
||||
|
||||
@@ -114,6 +114,16 @@ for a C++ compiler $CXX, such as clang++ or g++.
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -1074,7 +1084,7 @@ write_dst(const void* s, size_t n) {
|
||||
return write_dst_slow(s, n);
|
||||
}
|
||||
|
||||
#define TRY_INDENT_WITH_LEADING_NEW_LINE \
|
||||
#define TRY_INDENT \
|
||||
do { \
|
||||
uint32_t adj = (g_num_input_blank_lines > 1) ? 1 : 0; \
|
||||
g_num_input_blank_lines = 0; \
|
||||
@@ -1086,20 +1096,6 @@ write_dst(const void* s, size_t n) {
|
||||
} \
|
||||
} while (false)
|
||||
|
||||
// TRY_INDENT_SANS_LEADING_NEW_LINE is used after comments, which print their
|
||||
// own "\n".
|
||||
#define TRY_INDENT_SANS_LEADING_NEW_LINE \
|
||||
do { \
|
||||
uint32_t adj = (g_num_input_blank_lines > 1) ? 1 : 0; \
|
||||
g_num_input_blank_lines = 0; \
|
||||
uint32_t indent = g_depth * g_bytes_per_indent_depth; \
|
||||
TRY(write_dst(g_two_new_lines_then_256_indent_bytes + 2 - adj, \
|
||||
adj + (indent & 0xFF))); \
|
||||
for (indent >>= 8; indent > 0; indent--) { \
|
||||
TRY(write_dst(g_two_new_lines_then_256_indent_bytes + 2, 0x100)); \
|
||||
} \
|
||||
} while (false)
|
||||
|
||||
// ----
|
||||
|
||||
const char* //
|
||||
@@ -1155,12 +1151,12 @@ handle_token(wuffs_base__token t, bool start_of_token_chain) {
|
||||
(g_ctx != context::in_dict_after_brace) &&
|
||||
!g_flags.compact_output) {
|
||||
if (g_is_after_comment) {
|
||||
TRY_INDENT_SANS_LEADING_NEW_LINE;
|
||||
TRY_INDENT;
|
||||
} else {
|
||||
if (g_flags.output_extra_comma) {
|
||||
TRY(write_dst(",", 1));
|
||||
}
|
||||
TRY_INDENT_WITH_LEADING_NEW_LINE;
|
||||
TRY_INDENT;
|
||||
}
|
||||
} else {
|
||||
g_num_input_blank_lines = 0;
|
||||
@@ -1181,7 +1177,7 @@ handle_token(wuffs_base__token t, bool start_of_token_chain) {
|
||||
// continuation of a multi-token chain.
|
||||
if (start_of_token_chain) {
|
||||
if (g_is_after_comment) {
|
||||
TRY_INDENT_SANS_LEADING_NEW_LINE;
|
||||
TRY_INDENT;
|
||||
} else if (g_ctx == context::in_dict_after_key) {
|
||||
TRY(write_dst(": ", g_flags.compact_output ? 1 : 2));
|
||||
} else if (g_ctx != context::none) {
|
||||
@@ -1190,7 +1186,7 @@ handle_token(wuffs_base__token t, bool start_of_token_chain) {
|
||||
TRY(write_dst(",", 1));
|
||||
}
|
||||
if (!g_flags.compact_output) {
|
||||
TRY_INDENT_WITH_LEADING_NEW_LINE;
|
||||
TRY_INDENT;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1336,11 +1332,16 @@ main1(int argc, char** argv) {
|
||||
if (g_flags.compact_output) {
|
||||
TRY(write_dst(g_src.data.ptr + g_cursor_index - token_length,
|
||||
token_length));
|
||||
if (!t.continued() &&
|
||||
(t.value_base_detail() &
|
||||
WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE)) {
|
||||
TRY(write_dst("\n", 1));
|
||||
}
|
||||
|
||||
} else {
|
||||
if (start_of_token_chain) {
|
||||
if (g_is_after_comment) {
|
||||
TRY_INDENT_SANS_LEADING_NEW_LINE;
|
||||
TRY_INDENT;
|
||||
} else if (g_ctx != context::none) {
|
||||
if (g_ctx == context::in_dict_after_key) {
|
||||
TRY(write_dst(":", 1));
|
||||
@@ -1349,16 +1350,11 @@ main1(int argc, char** argv) {
|
||||
(g_ctx != context::end_of_data)) {
|
||||
TRY(write_dst(",", 1));
|
||||
}
|
||||
TRY_INDENT_WITH_LEADING_NEW_LINE;
|
||||
TRY_INDENT;
|
||||
}
|
||||
}
|
||||
TRY(write_dst(g_src.data.ptr + g_cursor_index - token_length,
|
||||
token_length));
|
||||
if (!t.continued() &&
|
||||
(t.value_base_detail() &
|
||||
WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK)) {
|
||||
TRY(write_dst("\n", 1));
|
||||
}
|
||||
g_is_after_comment = true;
|
||||
}
|
||||
if (g_ctx == context::in_list_after_bracket) {
|
||||
@@ -1366,11 +1362,7 @@ main1(int argc, char** argv) {
|
||||
} else if (g_ctx == context::in_dict_after_brace) {
|
||||
g_ctx = context::in_dict_after_value;
|
||||
}
|
||||
g_num_input_blank_lines =
|
||||
(t.value_base_detail() &
|
||||
WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE)
|
||||
? 1
|
||||
: 0;
|
||||
g_num_input_blank_lines = 0;
|
||||
|
||||
} else {
|
||||
uint8_t* p = g_src.data.ptr + g_cursor_index - token_length;
|
||||
@@ -1468,8 +1460,7 @@ main(int argc, char** argv) {
|
||||
// Flags start with "-", unless it comes after a bare "--" arg.
|
||||
{
|
||||
bool dash_dash = false;
|
||||
int a;
|
||||
for (a = 1; a < argc; a++) {
|
||||
for (int a = 1; a < argc; a++) {
|
||||
char* arg = argv[a];
|
||||
if ((arg[0] == '-') && !dash_dash) {
|
||||
dash_dash = (arg[1] == '-') && (arg[2] == '\x00');
|
||||
|
||||
@@ -51,6 +51,16 @@ isn't otherwise doing anything.
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -80,6 +90,7 @@ isn't otherwise doing anything.
|
||||
|
||||
#include <SDL2/SDL.h>
|
||||
#include <SDL2/SDL_image.h>
|
||||
#include <SDL2/SDL_render.h>
|
||||
|
||||
// --------
|
||||
|
||||
@@ -229,6 +240,28 @@ bool g_load_via_sdl_image = false;
|
||||
bool //
|
||||
draw(SDL_Window* window) {
|
||||
SDL_Surface* ws = SDL_GetWindowSurface(window);
|
||||
if (!ws) {
|
||||
// Use an indirect approach, for exotic window pixel formats (e.g. X.org 10
|
||||
// bits per RGB channel), when we can't get the window surface directly.
|
||||
//
|
||||
// See https://github.com/google/wuffs/issues/51
|
||||
SDL_Renderer* r = SDL_CreateRenderer(window, -1, 0);
|
||||
if (!r) {
|
||||
fprintf(stderr, "main: SDL_CreateRenderer: %s\n", SDL_GetError());
|
||||
return false;
|
||||
}
|
||||
SDL_RenderClear(r);
|
||||
if (g_image) {
|
||||
SDL_Texture* texture = SDL_CreateTextureFromSurface(r, g_image);
|
||||
SDL_RenderCopy(r, texture, NULL, &g_image->clip_rect);
|
||||
SDL_DestroyTexture(texture);
|
||||
}
|
||||
SDL_RenderPresent(r);
|
||||
SDL_DestroyRenderer(r);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Use a direct approach.
|
||||
SDL_FillRect(ws, NULL, SDL_MapRGB(ws->format, 0x00, 0x00, 0x00));
|
||||
if (g_image) {
|
||||
SDL_BlitSurface(g_image, NULL, ws, NULL);
|
||||
|
||||
@@ -35,6 +35,16 @@ for a C compiler $CC, such as clang or gcc.
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
|
||||
@@ -337,8 +337,7 @@ main(int argc, char** argv) {
|
||||
fprintf(stderr, "FAIL: %s\n", z);
|
||||
return 1;
|
||||
}
|
||||
int i;
|
||||
for (i = 0; i < g_flags.remaining_argc; i++) {
|
||||
for (int i = 0; i < g_flags.remaining_argc; i++) {
|
||||
int v = visit(g_flags.remaining_argv[i]);
|
||||
if (v) {
|
||||
return v;
|
||||
|
||||
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
|
||||
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -262,8 +274,9 @@ fuzz_complex(wuffs_base__io_buffer* full_src, uint64_t hash) {
|
||||
wuffs_base__token_buffer tok = ((wuffs_base__token_buffer){
|
||||
.data = ((wuffs_base__slice_token){
|
||||
.ptr = tok_array,
|
||||
.len = (tok_limit < TOK_BUFFER_ARRAY_SIZE) ? tok_limit
|
||||
: TOK_BUFFER_ARRAY_SIZE,
|
||||
.len = (size_t)((tok_limit < TOK_BUFFER_ARRAY_SIZE)
|
||||
? tok_limit
|
||||
: TOK_BUFFER_ARRAY_SIZE),
|
||||
}),
|
||||
});
|
||||
|
||||
|
||||
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -73,8 +85,7 @@ void set_quirks(wuffs_gif__decoder* dec, uint64_t hash) {
|
||||
0,
|
||||
};
|
||||
|
||||
uint32_t i;
|
||||
for (i = 0; quirks[i]; i++) {
|
||||
for (uint32_t i = 0; quirks[i]; i++) {
|
||||
uint64_t bit = 1 << (i & 63);
|
||||
if (hash & bit) {
|
||||
wuffs_gif__decoder__set_quirk_enabled(dec, quirks[i], true);
|
||||
|
||||
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -50,6 +62,8 @@ It should print "PASS", amongst other information, and exit(0).
|
||||
// modules we use makes that process explicit. Preprocessing means that such
|
||||
// code simply isn't compiled.
|
||||
#define WUFFS_CONFIG__MODULES
|
||||
#define WUFFS_CONFIG__MODULE__AUX__BASE
|
||||
#define WUFFS_CONFIG__MODULE__AUX__JSON
|
||||
#define WUFFS_CONFIG__MODULE__BASE
|
||||
#define WUFFS_CONFIG__MODULE__JSON
|
||||
|
||||
@@ -225,32 +239,32 @@ buffer_limit(uint64_t hash, uint64_t min, uint64_t max) {
|
||||
return n;
|
||||
}
|
||||
|
||||
void set_quirks(wuffs_json__decoder* dec, uint64_t hash) {
|
||||
uint32_t quirks[] = {
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_A,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_CAPITAL_U,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_E,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_QUESTION_MARK,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_SINGLE_QUOTE,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_V,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_ZERO,
|
||||
WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK,
|
||||
WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE,
|
||||
WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA,
|
||||
WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS,
|
||||
WUFFS_JSON__QUIRK_ALLOW_LEADING_ASCII_RECORD_SEPARATOR,
|
||||
WUFFS_JSON__QUIRK_ALLOW_LEADING_UNICODE_BYTE_ORDER_MARK,
|
||||
WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER,
|
||||
WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE,
|
||||
0,
|
||||
};
|
||||
uint32_t g_quirks[] = {
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_A,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_CAPITAL_U,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_E,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_QUESTION_MARK,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_SINGLE_QUOTE,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_V,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS,
|
||||
WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_ZERO,
|
||||
WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK,
|
||||
WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE,
|
||||
WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA,
|
||||
WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS,
|
||||
WUFFS_JSON__QUIRK_ALLOW_LEADING_ASCII_RECORD_SEPARATOR,
|
||||
WUFFS_JSON__QUIRK_ALLOW_LEADING_UNICODE_BYTE_ORDER_MARK,
|
||||
WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER,
|
||||
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T,
|
||||
WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE,
|
||||
0,
|
||||
};
|
||||
|
||||
uint32_t i;
|
||||
for (i = 0; quirks[i]; i++) {
|
||||
void set_quirks(wuffs_json__decoder* dec, uint64_t hash) {
|
||||
for (uint32_t i = 0; g_quirks[i]; i++) {
|
||||
uint64_t bit = 1 << (i & 63);
|
||||
if (hash & bit) {
|
||||
wuffs_json__decoder__set_quirk_enabled(dec, quirks[i], true);
|
||||
wuffs_json__decoder__set_quirk_enabled(dec, g_quirks[i], true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -281,8 +295,9 @@ fuzz_complex(wuffs_base__io_buffer* full_src, uint64_t hash) {
|
||||
wuffs_base__token_buffer tok = ((wuffs_base__token_buffer){
|
||||
.data = ((wuffs_base__slice_token){
|
||||
.ptr = tok_array,
|
||||
.len = (tok_limit < TOK_BUFFER_ARRAY_SIZE) ? tok_limit
|
||||
: TOK_BUFFER_ARRAY_SIZE,
|
||||
.len = (size_t)((tok_limit < TOK_BUFFER_ARRAY_SIZE)
|
||||
? tok_limit
|
||||
: TOK_BUFFER_ARRAY_SIZE),
|
||||
}),
|
||||
});
|
||||
|
||||
@@ -413,8 +428,104 @@ fuzz_simple(wuffs_base__io_buffer* full_src) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#if defined(__cplusplus)
|
||||
#include <vector>
|
||||
|
||||
class Callbacks : public wuffs_aux::DecodeJsonCallbacks {
|
||||
public:
|
||||
Callbacks() : m_depth(0) {}
|
||||
|
||||
std::string AppendNull() override { return ""; }
|
||||
|
||||
std::string AppendBool(bool val) override { return ""; }
|
||||
|
||||
std::string AppendI64(int64_t val) override { return ""; }
|
||||
|
||||
std::string AppendF64(double val) override { return ""; }
|
||||
|
||||
std::string AppendTextString(std::string&& val) override { return ""; }
|
||||
|
||||
std::string Push(uint32_t flags) override {
|
||||
m_depth++;
|
||||
return "";
|
||||
}
|
||||
|
||||
std::string Pop(uint32_t flags) override {
|
||||
m_depth--;
|
||||
if (m_depth < 0) {
|
||||
fprintf(stderr, "negative depth\n");
|
||||
intentional_segfault();
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
void Done(wuffs_aux::DecodeJsonResult& result,
|
||||
wuffs_aux::sync_io::Input& input,
|
||||
wuffs_aux::IOBuffer& buffer) override {
|
||||
if (result.error_message.empty()) {
|
||||
if (m_depth != 0) {
|
||||
fprintf(stderr, "no error message but final depth is non-zero\n");
|
||||
intentional_segfault();
|
||||
}
|
||||
} else if (result.error_message.find("internal error:") !=
|
||||
std::string::npos) {
|
||||
fprintf(stderr, "internal errors shouldn't occur: \"%s\"\n",
|
||||
result.error_message.c_str());
|
||||
intentional_segfault();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
int64_t m_depth;
|
||||
};
|
||||
|
||||
void //
|
||||
fuzz_cpp(const uint8_t* in_ptr, size_t in_len, uint64_t hash) {
|
||||
static const char* json_pointers[16] = {
|
||||
"", //
|
||||
"", //
|
||||
"", //
|
||||
"", //
|
||||
"", //
|
||||
"", //
|
||||
"", //
|
||||
"", //
|
||||
"", //
|
||||
"", //
|
||||
"/", //
|
||||
"/2/3/4/5", //
|
||||
"/k0", //
|
||||
"/k0/1", //
|
||||
"/x/y", //
|
||||
"/~0/~1/~n", //
|
||||
};
|
||||
const char* json_pointer = json_pointers[hash & 15];
|
||||
hash = wuffs_base__u64__rotate_right(hash, 4);
|
||||
|
||||
std::vector<uint32_t> quirks;
|
||||
for (uint32_t i = 0; g_quirks[i]; i++) {
|
||||
uint64_t bit = 1 << (i & 63);
|
||||
if (hash & bit) {
|
||||
quirks.push_back(g_quirks[i]);
|
||||
}
|
||||
}
|
||||
|
||||
Callbacks callbacks;
|
||||
wuffs_aux::sync_io::MemoryInput input(in_ptr, in_len);
|
||||
wuffs_aux::DecodeJson(
|
||||
callbacks, input,
|
||||
wuffs_aux::DecodeJsonArgQuirks(quirks.data(), quirks.size()),
|
||||
wuffs_aux::DecodeJsonArgJsonPointer(json_pointer));
|
||||
}
|
||||
#endif // defined(__cplusplus)
|
||||
|
||||
const char* //
|
||||
fuzz(wuffs_base__io_buffer* full_src, uint64_t hash) {
|
||||
#if defined(__cplusplus)
|
||||
fuzz_cpp(full_src->reader_pointer(), full_src->reader_length(),
|
||||
wuffs_base__u64__rotate_right(hash, 32));
|
||||
#endif // defined(__cplusplus)
|
||||
|
||||
// Send 99.6% of inputs to fuzz_complex and the remainder to fuzz_simple. The
|
||||
// 0xA5 constant is arbitrary but non-zero. If the hash function maps the
|
||||
// empty input to 0, this still sends the empty input to fuzz_complex.
|
||||
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
|
||||
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
|
||||
@@ -16,10 +16,10 @@
|
||||
|
||||
bmp: test/data/*.bmp ../bmpsuite_corpus/*.bmp
|
||||
cbor: test/data/*.cbor
|
||||
gif: test/data/*.gif test/data/artificial/*.gif
|
||||
gzip: test/data/*.gz test/data/artificial/*.gz
|
||||
gif: test/data/*.gif test/data/artificial-gif/*.gif
|
||||
gzip: test/data/*.gz
|
||||
json: test/data/*.json ../rapidjson_corpus/* ../simdjson_corpus/* ../JSONTestSuite/test_*/*.json
|
||||
png: test/data/*.png ../pngsuite_corpus/*.png
|
||||
png: test/data/*.png test/data/artificial-png/*.png ../pngsuite_corpus/*.png
|
||||
wbmp: test/data/*.wbmp
|
||||
zlib: test/data/*.zlib
|
||||
|
||||
|
||||
@@ -42,6 +42,18 @@ It should print "PASS", amongst other information, and exit(0).
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
#if defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
#endif // defined(WUFFS_CONFIG__FUZZLIB_MAIN)
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
|
||||
@@ -1,9 +1,8 @@
|
||||
module github.com/google/wuffs
|
||||
|
||||
go 1.13
|
||||
go 1.16
|
||||
|
||||
require (
|
||||
github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
|
||||
golang.org/x/image v0.0.0-20200119044424-58c23975cae1 // indirect
|
||||
gopkg.in/russross/blackfriday.v2 v2.0.0 // indirect
|
||||
github.com/russross/blackfriday/v2 v2.1.0 // indirect
|
||||
golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d // indirect
|
||||
)
|
||||
@@ -1,7 +1,6 @@
|
||||
github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
|
||||
github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
|
||||
golang.org/x/image v0.0.0-20200119044424-58c23975cae1 h1:5h3ngYt7+vXCDZCup/HkCQgW5XwmSvR/nA2JmJ0RErg=
|
||||
golang.org/x/image v0.0.0-20200119044424-58c23975cae1/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
|
||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||
gopkg.in/russross/blackfriday.v2 v2.0.0 h1:+FlnIV8DSQnT7NZ43hcVKcdJdzZoeCmJj4Ql8gq5keA=
|
||||
gopkg.in/russross/blackfriday.v2 v2.0.0/go.mod h1:6sSBNz/GtOm/pJTuh5UmBK2ZHfmnxGbl2NZg1UliSOI=
|
||||
github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
|
||||
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
|
||||
golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d h1:RNPAfi2nHY7C2srAV8A49jpsYr0ADedCk1wq6fTMTvs=
|
||||
golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
|
||||
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
|
||||
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
|
||||
@@ -20,13 +20,14 @@ pointer. Anyway, here's what the output should look like:
|
||||
|
||||
```
|
||||
$ ./run.sh
|
||||
--- C Implementation Prints ---
|
||||
0
|
||||
12
|
||||
56789
|
||||
4294967295
|
||||
0
|
||||
3197704724
|
||||
--------
|
||||
------ Wuffs Impl Prints ------
|
||||
0
|
||||
12
|
||||
56789
|
||||
|
||||
@@ -12,67 +12,12 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// ----------------
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifndef USE_WUFFS
|
||||
uint32_t parse(char* p, size_t n) {
|
||||
uint32_t ret = 0;
|
||||
for (size_t i = 0; (i < n) && p[i]; i++) {
|
||||
ret = (10 * ret) + (p[i] - '0');
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
#else // #ifndef USE_WUFFS
|
||||
|
||||
// TODO: this 'rough edge' shouldn't be necessary. See
|
||||
// https://github.com/google/wuffs/issues/24
|
||||
#define WUFFS_CONFIG__MODULE__BASE
|
||||
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
#include "./parse.c"
|
||||
|
||||
uint32_t parse(char* p, size_t n) {
|
||||
wuffs_base__status status;
|
||||
wuffs_demo__parser* parser =
|
||||
(wuffs_demo__parser*)(malloc(sizeof__wuffs_demo__parser()));
|
||||
if (!parser) {
|
||||
printf("malloc failed\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
status = wuffs_demo__parser__initialize(parser, sizeof__wuffs_demo__parser(),
|
||||
WUFFS_VERSION, 0);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
printf("initialize: %s\n", wuffs_base__status__message(&status));
|
||||
free(parser);
|
||||
return 0;
|
||||
}
|
||||
|
||||
wuffs_base__io_buffer iobuf;
|
||||
iobuf.data.ptr = (uint8_t*)p;
|
||||
iobuf.data.len = n;
|
||||
iobuf.meta.wi = n;
|
||||
iobuf.meta.ri = 0;
|
||||
iobuf.meta.pos = 0;
|
||||
iobuf.meta.closed = true;
|
||||
|
||||
status = wuffs_demo__parser__parse(parser, &iobuf);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
printf("parse: %s\n", wuffs_base__status__message(&status));
|
||||
free(parser);
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t ret = wuffs_demo__parser__value(parser);
|
||||
free(parser);
|
||||
return ret;
|
||||
}
|
||||
#endif // #ifndef USE_WUFFS
|
||||
// See naive-parse.c and wuffs-parse.c for implementations of this function.
|
||||
uint32_t parse(char*, size_t);
|
||||
|
||||
void run(char* p) {
|
||||
size_t n = strlen(p) + 1; // +1 for the trailing NUL that ends a C string.
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
// Copyright 2019 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.
|
||||
@@ -12,10 +12,13 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:generate go run gen.go
|
||||
#include <inttypes.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
// Package data contains the files in the sibling "../base" and "../auxiliary"
|
||||
// directories: the hand-written C and C++ code that is the 'runtime library'
|
||||
// for Wuffs-transpiled-to-C. In this Go package, those files' contents are
|
||||
// provided as string constants.
|
||||
package data
|
||||
uint32_t parse(char* p, size_t n) {
|
||||
uint32_t ret = 0;
|
||||
for (size_t i = 0; (i < n) && p[i]; i++) {
|
||||
ret = (10 * ret) + (p[i] - '0');
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@@ -18,16 +18,14 @@
|
||||
CC=${CC:-gcc}
|
||||
|
||||
# You may need to run
|
||||
# go get github.com/google/wuffs/cmd/wuffs-c
|
||||
# go install github.com/google/wuffs/cmd/wuffs-c
|
||||
# beforehand, to install the wuffs-c compiler.
|
||||
wuffs-c gen -package_name demo < parse.wuffs > parse.c
|
||||
|
||||
$CC main.c
|
||||
./a.out
|
||||
echo --- C Implementation Prints ---
|
||||
$CC main.c naive-parse.c -o n.out
|
||||
./n.out
|
||||
|
||||
echo --------
|
||||
|
||||
$CC main.c -DUSE_WUFFS
|
||||
./a.out
|
||||
|
||||
rm a.out parse.c
|
||||
echo ------ Wuffs Impl Prints ------
|
||||
$CC main.c wuffs-parse.c -o w.out
|
||||
./w.out
|
||||
@@ -0,0 +1,87 @@
|
||||
// Copyright 2019 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.
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
// TODO: this 'rough edge' shouldn't be necessary. See
|
||||
// https://github.com/google/wuffs/issues/24
|
||||
#define WUFFS_CONFIG__MODULE__BASE
|
||||
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
#include "./parse.c"
|
||||
|
||||
uint32_t parse(char* p, size_t n) {
|
||||
wuffs_base__status status;
|
||||
|
||||
// This next line of code allocates a wuffs_demo__parser on the stack. Stack
|
||||
// allocation in C means uninitialized memory, so we need to call
|
||||
// wuffs_demo__parser__initialize afterwards.
|
||||
//
|
||||
// An alternative, allocating on the heap and initializing in a single
|
||||
// function call, is to say:
|
||||
//
|
||||
// wuffs_demo__parser* parser = wuffs_demo__parser__alloc();
|
||||
// if (!parser) {
|
||||
// // Out of memory.
|
||||
// return 0;
|
||||
// }
|
||||
// // No need to call wuffs_demo__parser__initialize, but don't forget to
|
||||
// // free(parser) before this function returns, taking extra care if this
|
||||
// // function has multiple return points. Wuffs has no destructor functions
|
||||
// // and Wuffs types never hold or own any resources in the RAII sense.
|
||||
// // Just free the memory.
|
||||
//
|
||||
// For stack allocation, the C compiler needs to know
|
||||
// sizeof(wuffs_demo__parser), but that compile-time value isn't guaranteed
|
||||
// to be stable across Wuffs versions. Stack allocation is therefore only
|
||||
// valid when the C file also #define's WUFFS_IMPLEMENTATION. When linking
|
||||
// against a separately built Wuffs library (and the Wuffs types in this
|
||||
// compilation are incomplete types), you'll have to use heap allocation.
|
||||
wuffs_demo__parser parser;
|
||||
|
||||
// Initialize (and check status). An error here means that bad arguments were
|
||||
// passed to wuffs_demo__parser__initialize.
|
||||
//
|
||||
// There are two other categories of not-OK status values, notes and
|
||||
// suspensions, but they won't be encountered in this example.
|
||||
status = wuffs_demo__parser__initialize(&parser, sizeof__wuffs_demo__parser(),
|
||||
WUFFS_VERSION, 0);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
printf("initialize: %s\n", wuffs_base__status__message(&status));
|
||||
return 0;
|
||||
}
|
||||
|
||||
// True means that the wuffs_base__io_buffer is closed - we are at the end of
|
||||
// the input. False would mean that there might be additional data in the
|
||||
// byte stream (that this buffer is not large enough to hold all at once).
|
||||
//
|
||||
// In general, Wuffs' coroutine and suspension status mechanisms let it parse
|
||||
// arbitrarily large data streams using fixed sized buffers, but that won't
|
||||
// be encountered in this example.
|
||||
wuffs_base__io_buffer iobuf =
|
||||
wuffs_base__ptr_u8__reader((uint8_t*)p, n, true);
|
||||
|
||||
// Parse (and check status). An error here means that we had invalid input
|
||||
// (i.e. "#not a digit" or "#too large").
|
||||
//
|
||||
// There are two other categories of not-OK status values, notes and
|
||||
// suspensions, but they won't be encountered in this example.
|
||||
status = wuffs_demo__parser__parse(&parser, &iobuf);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
printf("parse: %s\n", wuffs_base__status__message(&status));
|
||||
return 0;
|
||||
}
|
||||
|
||||
return wuffs_demo__parser__value(&parser);
|
||||
}
|
||||
@@ -1 +1,8 @@
|
||||
# C++ Auxiliary Code
|
||||
|
||||
This directory contains C++ [Auxiliary code](/doc/note/auxiliary-code.md).
|
||||
|
||||
After editing source code in this directory, see the [sibling `base`
|
||||
directory's README.md](/internal/cgen/base/README.md#making-changes) file for
|
||||
instructions on how to see those changes when generating the C/C++ form of
|
||||
Wuffs code.
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -27,6 +25,71 @@ namespace sync_io {
|
||||
|
||||
// --------
|
||||
|
||||
DynIOBuffer::DynIOBuffer(uint64_t max_incl)
|
||||
: m_buf(wuffs_base__empty_io_buffer()), m_max_incl(max_incl) {}
|
||||
|
||||
DynIOBuffer::~DynIOBuffer() {
|
||||
if (m_buf.data.ptr) {
|
||||
free(m_buf.data.ptr);
|
||||
}
|
||||
}
|
||||
|
||||
void //
|
||||
DynIOBuffer::drop() {
|
||||
if (m_buf.data.ptr) {
|
||||
free(m_buf.data.ptr);
|
||||
}
|
||||
m_buf = wuffs_base__empty_io_buffer();
|
||||
}
|
||||
|
||||
DynIOBuffer::GrowResult //
|
||||
DynIOBuffer::grow(uint64_t min_incl) {
|
||||
uint64_t n = round_up(min_incl, m_max_incl);
|
||||
if (n == 0) {
|
||||
return ((min_incl == 0) && (m_max_incl == 0))
|
||||
? DynIOBuffer::GrowResult::OK
|
||||
: DynIOBuffer::GrowResult::FailedMaxInclExceeded;
|
||||
} else if (n > m_buf.data.len) {
|
||||
uint8_t* ptr = static_cast<uint8_t*>(realloc(m_buf.data.ptr, n));
|
||||
if (!ptr) {
|
||||
return DynIOBuffer::GrowResult::FailedOutOfMemory;
|
||||
}
|
||||
m_buf.data.ptr = ptr;
|
||||
m_buf.data.len = n;
|
||||
}
|
||||
return DynIOBuffer::GrowResult::OK;
|
||||
}
|
||||
|
||||
// round_up rounds min_incl up, returning the smallest value x satisfying
|
||||
// (min_incl <= x) and (x <= max_incl) and some other constraints. It returns 0
|
||||
// if there is no such x.
|
||||
//
|
||||
// When max_incl <= 4096, the other constraints are:
|
||||
// - (x == max_incl)
|
||||
//
|
||||
// When max_incl > 4096, the other constraints are:
|
||||
// - (x == max_incl) or (x is a power of 2)
|
||||
// - (x >= 4096)
|
||||
uint64_t //
|
||||
DynIOBuffer::round_up(uint64_t min_incl, uint64_t max_incl) {
|
||||
if (min_incl > max_incl) {
|
||||
return 0;
|
||||
}
|
||||
uint64_t n = 4096;
|
||||
if (n >= max_incl) {
|
||||
return max_incl;
|
||||
}
|
||||
while (n < min_incl) {
|
||||
if (n >= (max_incl / 2)) {
|
||||
return max_incl;
|
||||
}
|
||||
n *= 2;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
Input::~Input() {}
|
||||
|
||||
IOBuffer* //
|
||||
@@ -101,6 +164,164 @@ MemoryInput::CopyIn(IOBuffer* dst) {
|
||||
|
||||
} // namespace sync_io
|
||||
|
||||
namespace private_impl {
|
||||
|
||||
struct ErrorMessages {
|
||||
const char* max_incl_metadata_length_exceeded;
|
||||
const char* out_of_memory;
|
||||
const char* unexpected_end_of_file;
|
||||
const char* unsupported_metadata;
|
||||
const char* unsupported_negative_advance;
|
||||
|
||||
// If adding new "const char*" typed fields to this struct, either add them
|
||||
// after existing fields or, if re-ordering fields, make sure that you update
|
||||
// all of the "const private_impl::ErrorMessages FooBarErrorMessages" values
|
||||
// in all of the sibling *.cc files.
|
||||
|
||||
static inline const char* resolve(const char* s) {
|
||||
return s ? s : "wuffs_aux::private_impl: unknown error";
|
||||
};
|
||||
};
|
||||
|
||||
std::string //
|
||||
AdvanceIOBufferTo(const ErrorMessages& error_messages,
|
||||
sync_io::Input& input,
|
||||
IOBuffer& io_buf,
|
||||
uint64_t absolute_position) {
|
||||
if (absolute_position < io_buf.reader_position()) {
|
||||
return error_messages.resolve(error_messages.unsupported_negative_advance);
|
||||
}
|
||||
while (true) {
|
||||
uint64_t relative_position = absolute_position - io_buf.reader_position();
|
||||
if (relative_position <= io_buf.reader_length()) {
|
||||
io_buf.meta.ri += (size_t)relative_position;
|
||||
break;
|
||||
} else if (io_buf.meta.closed) {
|
||||
return error_messages.resolve(error_messages.unexpected_end_of_file);
|
||||
}
|
||||
io_buf.meta.ri = io_buf.meta.wi;
|
||||
if (!input.BringsItsOwnIOBuffer()) {
|
||||
io_buf.compact();
|
||||
}
|
||||
std::string error_message = input.CopyIn(&io_buf);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
std::string //
|
||||
HandleMetadata(
|
||||
const ErrorMessages& error_messages,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
sync_io::DynIOBuffer& raw,
|
||||
wuffs_base__status (*tell_me_more_func)(void*,
|
||||
wuffs_base__io_buffer*,
|
||||
wuffs_base__more_information*,
|
||||
wuffs_base__io_buffer*),
|
||||
void* tell_me_more_receiver,
|
||||
std::string (*handle_metadata_func)(void*,
|
||||
const wuffs_base__more_information*,
|
||||
wuffs_base__slice_u8),
|
||||
void* handle_metadata_receiver) {
|
||||
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
|
||||
// Reset raw but keep its backing array (the raw.m_buf.data slice).
|
||||
raw.m_buf.meta = wuffs_base__empty_io_buffer_meta();
|
||||
|
||||
while (true) {
|
||||
minfo = wuffs_base__empty_more_information();
|
||||
wuffs_base__status status = (*tell_me_more_func)(
|
||||
tell_me_more_receiver, &raw.m_buf, &minfo, &io_buf);
|
||||
switch (minfo.flavor) {
|
||||
case 0:
|
||||
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM:
|
||||
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED:
|
||||
break;
|
||||
|
||||
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH: {
|
||||
wuffs_base__range_ie_u64 r = minfo.metadata_raw_passthrough__range();
|
||||
if (r.is_empty()) {
|
||||
break;
|
||||
}
|
||||
uint64_t num_to_copy = r.length();
|
||||
if (num_to_copy > (raw.m_max_incl - raw.m_buf.meta.wi)) {
|
||||
return error_messages.resolve(
|
||||
error_messages.max_incl_metadata_length_exceeded);
|
||||
} else if (num_to_copy > (raw.m_buf.data.len - raw.m_buf.meta.wi)) {
|
||||
switch (raw.grow(num_to_copy + raw.m_buf.meta.wi)) {
|
||||
case sync_io::DynIOBuffer::GrowResult::OK:
|
||||
break;
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
|
||||
return error_messages.resolve(
|
||||
error_messages.max_incl_metadata_length_exceeded);
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
|
||||
return error_messages.resolve(error_messages.out_of_memory);
|
||||
}
|
||||
}
|
||||
|
||||
if (io_buf.reader_position() > r.min_incl) {
|
||||
return error_messages.resolve(error_messages.unsupported_metadata);
|
||||
} else {
|
||||
std::string error_message =
|
||||
AdvanceIOBufferTo(error_messages, input, io_buf, r.min_incl);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
|
||||
while (true) {
|
||||
uint64_t n =
|
||||
wuffs_base__u64__min(num_to_copy, io_buf.reader_length());
|
||||
memcpy(raw.m_buf.writer_pointer(), io_buf.reader_pointer(), n);
|
||||
raw.m_buf.meta.wi += n;
|
||||
io_buf.meta.ri += n;
|
||||
num_to_copy -= n;
|
||||
if (num_to_copy == 0) {
|
||||
break;
|
||||
} else if (io_buf.meta.closed) {
|
||||
return error_messages.resolve(
|
||||
error_messages.unexpected_end_of_file);
|
||||
} else if (!input.BringsItsOwnIOBuffer()) {
|
||||
io_buf.compact();
|
||||
}
|
||||
std::string error_message = input.CopyIn(&io_buf);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
return error_messages.resolve(error_messages.unsupported_metadata);
|
||||
}
|
||||
|
||||
if (status.repr == nullptr) {
|
||||
break;
|
||||
} else if (status.repr != wuffs_base__suspension__even_more_information) {
|
||||
if (status.repr != wuffs_base__suspension__short_write) {
|
||||
return status.message();
|
||||
}
|
||||
switch (raw.grow(wuffs_base__u64__sat_add(raw.m_buf.data.len, 1))) {
|
||||
case sync_io::DynIOBuffer::GrowResult::OK:
|
||||
break;
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
|
||||
return error_messages.resolve(
|
||||
error_messages.max_incl_metadata_length_exceeded);
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
|
||||
return error_messages.resolve(error_messages.out_of_memory);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (*handle_metadata_func)(handle_metadata_receiver, &minfo,
|
||||
raw.m_buf.reader_slice());
|
||||
}
|
||||
|
||||
} // namespace private_impl
|
||||
|
||||
} // namespace wuffs_aux
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) ||
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -38,6 +36,63 @@ namespace sync_io {
|
||||
|
||||
// --------
|
||||
|
||||
// DynIOBuffer is an IOBuffer that is backed by a dynamically sized byte array.
|
||||
// It owns that backing array and will free it in its destructor.
|
||||
//
|
||||
// The array size can be explicitly extended (by calling the grow method) but,
|
||||
// unlike a C++ std::vector, there is no implicit extension (e.g. by calling
|
||||
// std::vector::insert) and its maximum size is capped by the max_incl
|
||||
// constructor argument.
|
||||
//
|
||||
// It contains an IOBuffer-typed field whose reader side provides access to
|
||||
// previously written bytes and whose writer side provides access to the
|
||||
// allocated but not-yet-written-to slack space. For Go programmers, this slack
|
||||
// space is roughly analogous to the s[len(s):cap(s)] space of a slice s.
|
||||
class DynIOBuffer {
|
||||
public:
|
||||
enum GrowResult {
|
||||
OK = 0,
|
||||
FailedMaxInclExceeded = 1,
|
||||
FailedOutOfMemory = 2,
|
||||
};
|
||||
|
||||
// m_buf holds the dynamically sized byte array and its read/write indexes:
|
||||
// - m_buf.meta.wi is roughly analogous to a Go slice's length.
|
||||
// - m_buf.data.len is roughly analogous to a Go slice's capacity. It is
|
||||
// also equal to the m_buf.data.ptr malloc/realloc size.
|
||||
//
|
||||
// Users should not modify the m_buf.data.ptr or m_buf.data.len fields (as
|
||||
// they are conceptually private to this class), but they can modify the
|
||||
// bytes referenced by that pointer-length pair (e.g. compactions).
|
||||
IOBuffer m_buf;
|
||||
|
||||
// m_max_incl is an inclusive upper bound on the backing array size.
|
||||
const uint64_t m_max_incl;
|
||||
|
||||
// Constructor and destructor.
|
||||
explicit DynIOBuffer(uint64_t max_incl);
|
||||
~DynIOBuffer();
|
||||
|
||||
// Drop frees the byte array and resets m_buf. The DynIOBuffer can still be
|
||||
// used after a drop call. It just restarts from zero.
|
||||
void drop();
|
||||
|
||||
// grow ensures that the byte array size is at least min_incl and at most
|
||||
// max_incl. It returns FailedMaxInclExceeded if that would require
|
||||
// allocating more than max_incl bytes, including the case where (min_incl >
|
||||
// max_incl). It returns FailedOutOfMemory if memory allocation failed.
|
||||
GrowResult grow(uint64_t min_incl);
|
||||
|
||||
private:
|
||||
// Delete the copy and assign constructors.
|
||||
DynIOBuffer(const DynIOBuffer&) = delete;
|
||||
DynIOBuffer& operator=(const DynIOBuffer&) = delete;
|
||||
|
||||
static uint64_t round_up(uint64_t min_incl, uint64_t max_incl);
|
||||
};
|
||||
|
||||
// --------
|
||||
|
||||
class Input {
|
||||
public:
|
||||
virtual ~Input();
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -34,10 +32,21 @@ DecodeCborCallbacks::Done(DecodeCborResult& result,
|
||||
sync_io::Input& input,
|
||||
IOBuffer& buffer) {}
|
||||
|
||||
DecodeCborArgQuirks::DecodeCborArgQuirks(wuffs_base__slice_u32 repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeCborArgQuirks::DecodeCborArgQuirks(uint32_t* ptr0, size_t len0)
|
||||
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
|
||||
|
||||
DecodeCborArgQuirks //
|
||||
DecodeCborArgQuirks::DefaultValue() {
|
||||
return DecodeCborArgQuirks(wuffs_base__empty_slice_u32());
|
||||
}
|
||||
|
||||
DecodeCborResult //
|
||||
DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks) {
|
||||
DecodeCborArgQuirks quirks) {
|
||||
// Prepare the wuffs_base__io_buffer and the resultant error_message.
|
||||
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
|
||||
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
|
||||
@@ -57,11 +66,11 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
// Prepare the low-level CBOR decoder.
|
||||
wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();
|
||||
if (!dec) {
|
||||
ret_error_message = "wuffs_aux::CborDecoder: out of memory";
|
||||
ret_error_message = "wuffs_aux::DecodeCbor: out of memory";
|
||||
goto done;
|
||||
}
|
||||
for (size_t i = 0; i < quirks.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.ptr[i], true);
|
||||
for (size_t i = 0; i < quirks.repr.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
|
||||
}
|
||||
|
||||
// Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.
|
||||
@@ -72,7 +81,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
|
||||
|
||||
// Prepare other state.
|
||||
uint32_t depth = 0;
|
||||
int32_t depth = 0;
|
||||
std::string str;
|
||||
int64_t extension_category = 0;
|
||||
uint64_t extension_detail = 0;
|
||||
@@ -99,17 +108,17 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
goto done;
|
||||
} else if (cursor_index != io_buf->meta.ri) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad cursor_index";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad cursor_index";
|
||||
goto done;
|
||||
} else if (io_buf->meta.closed) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: io_buf is closed";
|
||||
"wuffs_aux::DecodeCbor: internal error: io_buf is closed";
|
||||
goto done;
|
||||
}
|
||||
io_buf->compact();
|
||||
if (io_buf->meta.wi >= io_buf->data.len) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: io_buf is full";
|
||||
"wuffs_aux::DecodeCbor: internal error: io_buf is full";
|
||||
goto done;
|
||||
}
|
||||
cursor_index = io_buf->meta.ri;
|
||||
@@ -121,11 +130,19 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
|
||||
if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad WORKBUF_LEN";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad WORKBUF_LEN";
|
||||
goto done;
|
||||
}
|
||||
wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8();
|
||||
tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf);
|
||||
if ((tok_buf.meta.ri > tok_buf.meta.wi) ||
|
||||
(tok_buf.meta.wi > tok_buf.data.len) ||
|
||||
(io_buf->meta.ri > io_buf->meta.wi) ||
|
||||
(io_buf->meta.wi > io_buf->data.len)) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeCbor: internal error: bad buffer indexes";
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];
|
||||
@@ -133,7 +150,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
if ((io_buf->meta.ri < cursor_index) ||
|
||||
((io_buf->meta.ri - cursor_index) < token_len)) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad token indexes";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad token indexes";
|
||||
goto done;
|
||||
}
|
||||
uint8_t* token_ptr = io_buf->data.ptr + cursor_index;
|
||||
@@ -169,7 +186,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
}
|
||||
}
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad extended token";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad extended token";
|
||||
goto done;
|
||||
}
|
||||
|
||||
@@ -184,10 +201,20 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
goto done;
|
||||
}
|
||||
depth++;
|
||||
if (depth > WUFFS_CBOR__DECODER_DEPTH_MAX_INCL) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeCbor: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
|
||||
depth--;
|
||||
if (depth < 0) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeCbor: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
goto parsed_a_value;
|
||||
}
|
||||
|
||||
@@ -324,7 +351,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
|
||||
fail:
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: unexpected token";
|
||||
"wuffs_aux::DecodeCbor: internal error: unexpected token";
|
||||
goto done;
|
||||
|
||||
parsed_a_value:
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -70,6 +68,26 @@ class DecodeCborCallbacks {
|
||||
Done(DecodeCborResult& result, sync_io::Input& input, IOBuffer& buffer);
|
||||
};
|
||||
|
||||
// The FooArgBar types add structure to Foo's optional arguments. They wrap
|
||||
// inner representations for several reasons:
|
||||
// - It provides a home for the DefaultValue static method, for Foo callers
|
||||
// that want to override some but not all optional arguments.
|
||||
// - It provides the "Bar" name at Foo call sites, which can help self-
|
||||
// document Foo calls with many arguemnts.
|
||||
// - It provides some type safety against accidentally transposing or omitting
|
||||
// adjacent fundamentally-numeric-typed optional arguments.
|
||||
|
||||
// DecodeCborArgQuirks wraps an optional argument to DecodeCbor.
|
||||
struct DecodeCborArgQuirks {
|
||||
explicit DecodeCborArgQuirks(wuffs_base__slice_u32 repr0);
|
||||
explicit DecodeCborArgQuirks(uint32_t* ptr, size_t len);
|
||||
|
||||
// DefaultValue returns an empty slice.
|
||||
static DecodeCborArgQuirks DefaultValue();
|
||||
|
||||
wuffs_base__slice_u32 repr;
|
||||
};
|
||||
|
||||
// DecodeCbor calls callbacks based on the CBOR-formatted data in input.
|
||||
//
|
||||
// On success, the returned error_message is empty and cursor_position counts
|
||||
@@ -79,6 +97,6 @@ class DecodeCborCallbacks {
|
||||
DecodeCborResult //
|
||||
DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32());
|
||||
DecodeCborArgQuirks quirks = DecodeCborArgQuirks::DefaultValue());
|
||||
|
||||
} // namespace wuffs_aux
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2021 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -95,6 +93,12 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
|
||||
return wuffs_base__image_decoder::unique_ptr(nullptr, &free);
|
||||
}
|
||||
|
||||
std::string //
|
||||
DecodeImageCallbacks::HandleMetadata(const wuffs_base__more_information& minfo,
|
||||
wuffs_base__slice_u8 raw) {
|
||||
return "";
|
||||
}
|
||||
|
||||
wuffs_base__pixel_format //
|
||||
DecodeImageCallbacks::SelectPixfmt(
|
||||
const wuffs_base__image_config& image_config) {
|
||||
@@ -159,12 +163,16 @@ const char DecodeImage_BufferIsTooShort[] = //
|
||||
"wuffs_aux::DecodeImage: buffer is too short";
|
||||
const char DecodeImage_MaxInclDimensionExceeded[] = //
|
||||
"wuffs_aux::DecodeImage: max_incl_dimension exceeded";
|
||||
const char DecodeImage_MaxInclMetadataLengthExceeded[] = //
|
||||
"wuffs_aux::DecodeImage: max_incl_metadata_length exceeded";
|
||||
const char DecodeImage_OutOfMemory[] = //
|
||||
"wuffs_aux::DecodeImage: out of memory";
|
||||
const char DecodeImage_UnexpectedEndOfFile[] = //
|
||||
"wuffs_aux::DecodeImage: unexpected end of file";
|
||||
const char DecodeImage_UnsupportedImageFormat[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported image format";
|
||||
const char DecodeImage_UnsupportedMetadata[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported metadata";
|
||||
const char DecodeImage_UnsupportedPixelBlend[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported pixel blend";
|
||||
const char DecodeImage_UnsupportedPixelConfiguration[] = //
|
||||
@@ -172,38 +180,105 @@ const char DecodeImage_UnsupportedPixelConfiguration[] = //
|
||||
const char DecodeImage_UnsupportedPixelFormat[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported pixel format";
|
||||
|
||||
DecodeImageArgQuirks::DecodeImageArgQuirks(wuffs_base__slice_u32 repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgQuirks::DecodeImageArgQuirks(uint32_t* ptr0, size_t len0)
|
||||
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
|
||||
|
||||
DecodeImageArgQuirks //
|
||||
DecodeImageArgQuirks::DefaultValue() {
|
||||
return DecodeImageArgQuirks(wuffs_base__empty_slice_u32());
|
||||
}
|
||||
|
||||
DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {}
|
||||
|
||||
DecodeImageArgFlags //
|
||||
DecodeImageArgFlags::DefaultValue() {
|
||||
return DecodeImageArgFlags(0);
|
||||
}
|
||||
|
||||
DecodeImageArgPixelBlend::DecodeImageArgPixelBlend(
|
||||
wuffs_base__pixel_blend repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgPixelBlend //
|
||||
DecodeImageArgPixelBlend::DefaultValue() {
|
||||
return DecodeImageArgPixelBlend(WUFFS_BASE__PIXEL_BLEND__SRC);
|
||||
}
|
||||
|
||||
DecodeImageArgBackgroundColor::DecodeImageArgBackgroundColor(
|
||||
wuffs_base__color_u32_argb_premul repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgBackgroundColor //
|
||||
DecodeImageArgBackgroundColor::DefaultValue() {
|
||||
return DecodeImageArgBackgroundColor(1);
|
||||
}
|
||||
|
||||
DecodeImageArgMaxInclDimension::DecodeImageArgMaxInclDimension(uint32_t repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgMaxInclDimension //
|
||||
DecodeImageArgMaxInclDimension::DefaultValue() {
|
||||
return DecodeImageArgMaxInclDimension(1048575);
|
||||
}
|
||||
|
||||
DecodeImageArgMaxInclMetadataLength::DecodeImageArgMaxInclMetadataLength(
|
||||
uint64_t repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgMaxInclMetadataLength //
|
||||
DecodeImageArgMaxInclMetadataLength::DefaultValue() {
|
||||
return DecodeImageArgMaxInclMetadataLength(16777215);
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
namespace {
|
||||
|
||||
const private_impl::ErrorMessages DecodeImageErrorMessages = {
|
||||
DecodeImage_MaxInclMetadataLengthExceeded, //
|
||||
DecodeImage_OutOfMemory, //
|
||||
DecodeImage_UnexpectedEndOfFile, //
|
||||
DecodeImage_UnsupportedMetadata, //
|
||||
DecodeImage_UnsupportedImageFormat, //
|
||||
};
|
||||
|
||||
std::string //
|
||||
DecodeImageAdvanceIOBuf(sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
bool compactable,
|
||||
uint64_t min_excl_pos,
|
||||
uint64_t pos) {
|
||||
if ((pos <= min_excl_pos) || (pos < io_buf.reader_position())) {
|
||||
// Redirects must go forward.
|
||||
return DecodeImage_UnsupportedImageFormat;
|
||||
}
|
||||
while (true) {
|
||||
uint64_t relative_pos = pos - io_buf.reader_position();
|
||||
if (relative_pos <= io_buf.reader_length()) {
|
||||
io_buf.meta.ri += (size_t)relative_pos;
|
||||
break;
|
||||
} else if (io_buf.meta.closed) {
|
||||
return DecodeImage_UnexpectedEndOfFile;
|
||||
}
|
||||
io_buf.meta.ri = io_buf.meta.wi;
|
||||
if (compactable) {
|
||||
io_buf.compact();
|
||||
}
|
||||
std::string error_message = input.CopyIn(&io_buf);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
return "";
|
||||
DecodeImageAdvanceIOBufferTo(sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
uint64_t absolute_position) {
|
||||
return private_impl::AdvanceIOBufferTo(DecodeImageErrorMessages, input,
|
||||
io_buf, absolute_position);
|
||||
}
|
||||
|
||||
wuffs_base__status //
|
||||
DIHM0(void* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__more_information* a_minfo,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
return wuffs_base__image_decoder__tell_me_more(
|
||||
static_cast<wuffs_base__image_decoder*>(self), a_dst, a_minfo, a_src);
|
||||
}
|
||||
|
||||
std::string //
|
||||
DIHM1(void* self,
|
||||
const wuffs_base__more_information* minfo,
|
||||
wuffs_base__slice_u8 raw) {
|
||||
return static_cast<DecodeImageCallbacks*>(self)->HandleMetadata(*minfo, raw);
|
||||
}
|
||||
|
||||
std::string //
|
||||
DecodeImageHandleMetadata(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
sync_io::DynIOBuffer& raw_metadata_buf) {
|
||||
return private_impl::HandleMetadata(DecodeImageErrorMessages, input, io_buf,
|
||||
raw_metadata_buf, DIHM0,
|
||||
static_cast<void*>(image_decoder.get()),
|
||||
DIHM1, static_cast<void*>(&callbacks));
|
||||
}
|
||||
|
||||
DecodeImageResult //
|
||||
@@ -211,9 +286,12 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
wuffs_base__slice_u32 quirks,
|
||||
uint64_t flags,
|
||||
wuffs_base__pixel_blend pixel_blend,
|
||||
wuffs_base__color_u32_argb_premul background_color,
|
||||
uint32_t max_incl_dimension) {
|
||||
uint32_t max_incl_dimension,
|
||||
uint64_t max_incl_metadata_length) {
|
||||
// Check args.
|
||||
switch (pixel_blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
@@ -224,6 +302,7 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
}
|
||||
|
||||
wuffs_base__image_config image_config = wuffs_base__null_image_config();
|
||||
sync_io::DynIOBuffer raw_metadata_buf(max_incl_metadata_length);
|
||||
uint64_t start_pos = io_buf.reader_position();
|
||||
bool redirected = false;
|
||||
int32_t fourcc = 0;
|
||||
@@ -258,8 +337,12 @@ redirect:
|
||||
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
|
||||
}
|
||||
uint64_t pos = minfo.io_redirect__range().min_incl;
|
||||
std::string error_message = DecodeImageAdvanceIOBuf(
|
||||
input, io_buf, !input.BringsItsOwnIOBuffer(), start_pos, pos);
|
||||
if (pos <= start_pos) {
|
||||
// Redirects must go forward.
|
||||
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
|
||||
}
|
||||
std::string error_message =
|
||||
DecodeImageAdvanceIOBufferTo(input, io_buf, pos);
|
||||
if (!error_message.empty()) {
|
||||
return DecodeImageResult(std::move(error_message));
|
||||
}
|
||||
@@ -278,6 +361,36 @@ redirect:
|
||||
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
|
||||
}
|
||||
|
||||
// Apply quirks.
|
||||
for (size_t i = 0; i < quirks.len; i++) {
|
||||
image_decoder->set_quirk_enabled(quirks.ptr[i], true);
|
||||
}
|
||||
|
||||
// Apply flags.
|
||||
if (flags != 0) {
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_CHRM) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_EXIF) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__EXIF, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_GAMA) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__GAMA, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_ICCP) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__ICCP, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_KVP) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__KVP, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_SRGB) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__SRGB, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_XMP) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__XMP, true);
|
||||
}
|
||||
}
|
||||
|
||||
// Decode the image config.
|
||||
while (true) {
|
||||
wuffs_base__status id_dic_status =
|
||||
@@ -290,6 +403,12 @@ redirect:
|
||||
}
|
||||
redirected = true;
|
||||
goto redirect;
|
||||
} else if (id_dic_status.repr == wuffs_base__note__metadata_reported) {
|
||||
std::string error_message = DecodeImageHandleMetadata(
|
||||
image_decoder, callbacks, input, io_buf, raw_metadata_buf);
|
||||
if (!error_message.empty()) {
|
||||
return DecodeImageResult(std::move(error_message));
|
||||
}
|
||||
} else if (id_dic_status.repr != wuffs_base__suspension__short_read) {
|
||||
return DecodeImageResult(id_dic_status.message());
|
||||
} else if (io_buf.meta.closed) {
|
||||
@@ -302,6 +421,7 @@ redirect:
|
||||
}
|
||||
}
|
||||
} while (false);
|
||||
raw_metadata_buf.drop();
|
||||
|
||||
// Select the pixel format.
|
||||
uint32_t w = image_config.pixcfg.width();
|
||||
@@ -412,9 +532,12 @@ redirect:
|
||||
DecodeImageResult //
|
||||
DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__pixel_blend pixel_blend,
|
||||
wuffs_base__color_u32_argb_premul background_color,
|
||||
uint32_t max_incl_dimension) {
|
||||
DecodeImageArgQuirks quirks,
|
||||
DecodeImageArgFlags flags,
|
||||
DecodeImageArgPixelBlend pixel_blend,
|
||||
DecodeImageArgBackgroundColor background_color,
|
||||
DecodeImageArgMaxInclDimension max_incl_dimension,
|
||||
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length) {
|
||||
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
|
||||
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
|
||||
std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);
|
||||
@@ -427,8 +550,9 @@ DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
|
||||
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);
|
||||
DecodeImageResult result =
|
||||
DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,
|
||||
background_color, max_incl_dimension);
|
||||
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr,
|
||||
flags.repr, pixel_blend.repr, background_color.repr,
|
||||
max_incl_dimension.repr, max_incl_metadata_length.repr);
|
||||
callbacks.Done(result, input, *io_buf, std::move(image_decoder));
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2021 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -32,10 +30,11 @@ struct DecodeImageResult {
|
||||
// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always
|
||||
// called in this order:
|
||||
// 1. SelectDecoder
|
||||
// 2. SelectPixfmt
|
||||
// 3. AllocPixbuf
|
||||
// 4. AllocWorkbuf
|
||||
// 5. Done
|
||||
// 2. HandleMetadata
|
||||
// 3. SelectPixfmt
|
||||
// 4. AllocPixbuf
|
||||
// 5. AllocWorkbuf
|
||||
// 6. Done
|
||||
//
|
||||
// It may return early - the third callback might not be invoked if the second
|
||||
// one fails - but the final callback (Done) is always invoked.
|
||||
@@ -92,6 +91,22 @@ class DecodeImageCallbacks {
|
||||
virtual wuffs_base__image_decoder::unique_ptr //
|
||||
SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);
|
||||
|
||||
// HandleMetadata acknowledges image metadata. minfo.flavor will be one of:
|
||||
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH
|
||||
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED
|
||||
// If it is ETC__METADATA_RAW_ETC then raw contains the metadata bytes. Those
|
||||
// bytes should not be retained beyond the the HandleMetadata call.
|
||||
//
|
||||
// minfo.metadata__fourcc() will typically match one of the
|
||||
// DecodeImageArgFlags bits. For example, if (REPORT_METADATA_CHRM |
|
||||
// REPORT_METADATA_GAMA) was passed to DecodeImage then the metadata FourCC
|
||||
// will be either WUFFS_BASE__FOURCC__CHRM or WUFFS_BASE__FOURCC__GAMA.
|
||||
//
|
||||
// It returns an error message, or an empty string on success.
|
||||
virtual std::string //
|
||||
HandleMetadata(const wuffs_base__more_information& minfo,
|
||||
wuffs_base__slice_u8 raw);
|
||||
|
||||
// SelectPixfmt returns the destination pixel format for AllocPixbuf. It
|
||||
// should return wuffs_base__make_pixel_format(etc) called with one of:
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
|
||||
@@ -158,13 +173,116 @@ class DecodeImageCallbacks {
|
||||
|
||||
extern const char DecodeImage_BufferIsTooShort[];
|
||||
extern const char DecodeImage_MaxInclDimensionExceeded[];
|
||||
extern const char DecodeImage_MaxInclMetadataLengthExceeded[];
|
||||
extern const char DecodeImage_OutOfMemory[];
|
||||
extern const char DecodeImage_UnexpectedEndOfFile[];
|
||||
extern const char DecodeImage_UnsupportedImageFormat[];
|
||||
extern const char DecodeImage_UnsupportedMetadata[];
|
||||
extern const char DecodeImage_UnsupportedPixelBlend[];
|
||||
extern const char DecodeImage_UnsupportedPixelConfiguration[];
|
||||
extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
|
||||
// The FooArgBar types add structure to Foo's optional arguments. They wrap
|
||||
// inner representations for several reasons:
|
||||
// - It provides a home for the DefaultValue static method, for Foo callers
|
||||
// that want to override some but not all optional arguments.
|
||||
// - It provides the "Bar" name at Foo call sites, which can help self-
|
||||
// document Foo calls with many arguemnts.
|
||||
// - It provides some type safety against accidentally transposing or omitting
|
||||
// adjacent fundamentally-numeric-typed optional arguments.
|
||||
|
||||
// DecodeImageArgQuirks wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgQuirks {
|
||||
explicit DecodeImageArgQuirks(wuffs_base__slice_u32 repr0);
|
||||
explicit DecodeImageArgQuirks(uint32_t* ptr, size_t len);
|
||||
|
||||
// DefaultValue returns an empty slice.
|
||||
static DecodeImageArgQuirks DefaultValue();
|
||||
|
||||
wuffs_base__slice_u32 repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgFlags wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgFlags {
|
||||
explicit DecodeImageArgFlags(uint64_t repr0);
|
||||
|
||||
// DefaultValue returns 0.
|
||||
static DecodeImageArgFlags DefaultValue();
|
||||
|
||||
// TODO: support all of the REPORT_METADATA_ETC flags, not just CHRM, EXIF,
|
||||
// GAMA, ICCP, KVP, SRGB and XMP.
|
||||
|
||||
// Background Color.
|
||||
static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001;
|
||||
// Primary Chromaticities and White Point.
|
||||
static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002;
|
||||
// Exchangeable Image File Format.
|
||||
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004;
|
||||
// Gamma Correction.
|
||||
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008;
|
||||
// International Color Consortium Profile.
|
||||
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010;
|
||||
// Key-Value Pair.
|
||||
//
|
||||
// For PNG files, this includes iTXt, tEXt and zTXt chunks. In the
|
||||
// HandleMetadata callback, the raw argument contains UTF-8 strings.
|
||||
static constexpr uint64_t REPORT_METADATA_KVP = 0x0020;
|
||||
// Modification Time.
|
||||
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040;
|
||||
// Offset (2-Dimensional).
|
||||
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080;
|
||||
// Physical Dimensions.
|
||||
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100;
|
||||
// Standard Red Green Blue (Rendering Intent).
|
||||
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200;
|
||||
// Extensible Metadata Platform.
|
||||
static constexpr uint64_t REPORT_METADATA_XMP = 0x0400;
|
||||
|
||||
uint64_t repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgPixelBlend wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgPixelBlend {
|
||||
explicit DecodeImageArgPixelBlend(wuffs_base__pixel_blend repr0);
|
||||
|
||||
// DefaultValue returns WUFFS_BASE__PIXEL_BLEND__SRC.
|
||||
static DecodeImageArgPixelBlend DefaultValue();
|
||||
|
||||
wuffs_base__pixel_blend repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgBackgroundColor wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgBackgroundColor {
|
||||
explicit DecodeImageArgBackgroundColor(
|
||||
wuffs_base__color_u32_argb_premul repr0);
|
||||
|
||||
// DefaultValue returns 1, an invalid wuffs_base__color_u32_argb_premul.
|
||||
static DecodeImageArgBackgroundColor DefaultValue();
|
||||
|
||||
wuffs_base__color_u32_argb_premul repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgMaxInclDimension wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgMaxInclDimension {
|
||||
explicit DecodeImageArgMaxInclDimension(uint32_t repr0);
|
||||
|
||||
// DefaultValue returns 1048575 = 0x000F_FFFF, more than 1 million pixels.
|
||||
static DecodeImageArgMaxInclDimension DefaultValue();
|
||||
|
||||
uint32_t repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgMaxInclMetadataLength wraps an optional argument to
|
||||
// DecodeImage.
|
||||
struct DecodeImageArgMaxInclMetadataLength {
|
||||
explicit DecodeImageArgMaxInclMetadataLength(uint64_t repr0);
|
||||
|
||||
// DefaultValue returns 16777215 = 0x00FF_FFFF, one less than 16 MiB.
|
||||
static DecodeImageArgMaxInclMetadataLength DefaultValue();
|
||||
|
||||
uint64_t repr;
|
||||
};
|
||||
|
||||
// DecodeImage decodes the image data in input. A variety of image file formats
|
||||
// can be decoded, depending on what callbacks.SelectDecoder returns.
|
||||
//
|
||||
@@ -207,12 +325,20 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
// WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque.
|
||||
//
|
||||
// Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's
|
||||
// width or height is greater than max_incl_dimension.
|
||||
// width or height is greater than max_incl_dimension or if any opted-in (via
|
||||
// flags bits) metadata is longer than max_incl_metadata_length.
|
||||
DecodeImageResult //
|
||||
DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.
|
||||
uint32_t max_incl_dimension = 1048575); // 0x000F_FFFF
|
||||
DecodeImageArgQuirks quirks = DecodeImageArgQuirks::DefaultValue(),
|
||||
DecodeImageArgFlags flags = DecodeImageArgFlags::DefaultValue(),
|
||||
DecodeImageArgPixelBlend pixel_blend =
|
||||
DecodeImageArgPixelBlend::DefaultValue(),
|
||||
DecodeImageArgBackgroundColor background_color =
|
||||
DecodeImageArgBackgroundColor::DefaultValue(),
|
||||
DecodeImageArgMaxInclDimension max_incl_dimension =
|
||||
DecodeImageArgMaxInclDimension::DefaultValue(),
|
||||
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length =
|
||||
DecodeImageArgMaxInclMetadataLength::DefaultValue());
|
||||
|
||||
} // namespace wuffs_aux
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -34,9 +32,29 @@ DecodeJsonCallbacks::Done(DecodeJsonResult& result,
|
||||
sync_io::Input& input,
|
||||
IOBuffer& buffer) {}
|
||||
|
||||
const char DecodeJson_BadJsonPointer[] =
|
||||
const char DecodeJson_BadJsonPointer[] = //
|
||||
"wuffs_aux::DecodeJson: bad JSON Pointer";
|
||||
const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
|
||||
const char DecodeJson_NoMatch[] = //
|
||||
"wuffs_aux::DecodeJson: no match";
|
||||
|
||||
DecodeJsonArgQuirks::DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeJsonArgQuirks::DecodeJsonArgQuirks(uint32_t* ptr0, size_t len0)
|
||||
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
|
||||
|
||||
DecodeJsonArgQuirks //
|
||||
DecodeJsonArgQuirks::DefaultValue() {
|
||||
return DecodeJsonArgQuirks(wuffs_base__empty_slice_u32());
|
||||
}
|
||||
|
||||
DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeJsonArgJsonPointer //
|
||||
DecodeJsonArgJsonPointer::DefaultValue() {
|
||||
return DecodeJsonArgJsonPointer(std::string());
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
@@ -73,6 +91,14 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
|
||||
} \
|
||||
tok_status = \
|
||||
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \
|
||||
if ((tok_buf.meta.ri > tok_buf.meta.wi) || \
|
||||
(tok_buf.meta.wi > tok_buf.data.len) || \
|
||||
(io_buf->meta.ri > io_buf->meta.wi) || \
|
||||
(io_buf->meta.wi > io_buf->data.len)) { \
|
||||
ret_error_message = \
|
||||
"wuffs_aux::DecodeJson: internal error: bad buffer indexes"; \
|
||||
goto done; \
|
||||
} \
|
||||
} \
|
||||
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \
|
||||
uint64_t token_len = token.length(); \
|
||||
@@ -91,7 +117,8 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
|
||||
namespace {
|
||||
|
||||
// DecodeJson_SplitJsonPointer returns ("bar", 8) for ("/foo/bar/b~1z/qux", 5,
|
||||
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax.
|
||||
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax or i is
|
||||
// out of bounds.
|
||||
//
|
||||
// The string returned is unescaped. If calling it again, this time with i=8,
|
||||
// the "b~1z" substring would be returned as "b/z".
|
||||
@@ -100,6 +127,9 @@ DecodeJson_SplitJsonPointer(std::string& s,
|
||||
size_t i,
|
||||
bool allow_tilde_n_tilde_r_tilde_t) {
|
||||
std::string fragment;
|
||||
if (i > s.size()) {
|
||||
return std::make_pair(std::string(), 0);
|
||||
}
|
||||
while (i < s.size()) {
|
||||
char c = s[i];
|
||||
if (c == '/') {
|
||||
@@ -306,8 +336,8 @@ check_that_a_value_follows:
|
||||
continue;
|
||||
}
|
||||
|
||||
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so that
|
||||
// we're only peeking at the next token.
|
||||
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so
|
||||
// that we're only peeking at the next token.
|
||||
tok_buf.meta.ri--;
|
||||
cursor_index -= static_cast<size_t>(token_len);
|
||||
|
||||
@@ -331,8 +361,8 @@ done:
|
||||
DecodeJsonResult //
|
||||
DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks,
|
||||
std::string json_pointer) {
|
||||
DecodeJsonArgQuirks quirks,
|
||||
DecodeJsonArgJsonPointer json_pointer) {
|
||||
// Prepare the wuffs_base__io_buffer and the resultant error_message.
|
||||
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
|
||||
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
|
||||
@@ -360,9 +390,9 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
goto done;
|
||||
}
|
||||
bool allow_tilde_n_tilde_r_tilde_t = false;
|
||||
for (size_t i = 0; i < quirks.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.ptr[i], true);
|
||||
if (quirks.ptr[i] ==
|
||||
for (size_t i = 0; i < quirks.repr.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
|
||||
if (quirks.repr.ptr[i] ==
|
||||
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {
|
||||
allow_tilde_n_tilde_r_tilde_t = true;
|
||||
}
|
||||
@@ -377,17 +407,17 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8());
|
||||
|
||||
// Prepare other state.
|
||||
uint32_t depth = 0;
|
||||
int32_t depth = 0;
|
||||
std::string str;
|
||||
|
||||
// Walk the (optional) JSON Pointer.
|
||||
for (size_t i = 0; i < json_pointer.size();) {
|
||||
if (json_pointer[i] != '/') {
|
||||
for (size_t i = 0; i < json_pointer.repr.size();) {
|
||||
if (json_pointer.repr[i] != '/') {
|
||||
ret_error_message = DecodeJson_BadJsonPointer;
|
||||
goto done;
|
||||
}
|
||||
std::pair<std::string, size_t> split = DecodeJson_SplitJsonPointer(
|
||||
json_pointer, i + 1, allow_tilde_n_tilde_r_tilde_t);
|
||||
json_pointer.repr, i + 1, allow_tilde_n_tilde_r_tilde_t);
|
||||
i = split.second;
|
||||
if (i == 0) {
|
||||
ret_error_message = DecodeJson_BadJsonPointer;
|
||||
@@ -420,10 +450,20 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
goto done;
|
||||
}
|
||||
depth++;
|
||||
if (depth > WUFFS_JSON__DECODER_DEPTH_MAX_INCL) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeJson: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
|
||||
depth--;
|
||||
if (depth < 0) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeJson: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
goto parsed_a_value;
|
||||
}
|
||||
|
||||
@@ -538,7 +578,7 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
// loop running until WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN's
|
||||
// decode_tokens returns an ok status.
|
||||
if (!ret_error_message.empty() ||
|
||||
((depth == 0) && !json_pointer.empty())) {
|
||||
((depth == 0) && !json_pointer.repr.empty())) {
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -71,6 +69,36 @@ class DecodeJsonCallbacks {
|
||||
extern const char DecodeJson_BadJsonPointer[];
|
||||
extern const char DecodeJson_NoMatch[];
|
||||
|
||||
// The FooArgBar types add structure to Foo's optional arguments. They wrap
|
||||
// inner representations for several reasons:
|
||||
// - It provides a home for the DefaultValue static method, for Foo callers
|
||||
// that want to override some but not all optional arguments.
|
||||
// - It provides the "Bar" name at Foo call sites, which can help self-
|
||||
// document Foo calls with many arguemnts.
|
||||
// - It provides some type safety against accidentally transposing or omitting
|
||||
// adjacent fundamentally-numeric-typed optional arguments.
|
||||
|
||||
// DecodeJsonArgQuirks wraps an optional argument to DecodeJson.
|
||||
struct DecodeJsonArgQuirks {
|
||||
explicit DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0);
|
||||
explicit DecodeJsonArgQuirks(uint32_t* ptr, size_t len);
|
||||
|
||||
// DefaultValue returns an empty slice.
|
||||
static DecodeJsonArgQuirks DefaultValue();
|
||||
|
||||
wuffs_base__slice_u32 repr;
|
||||
};
|
||||
|
||||
// DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson.
|
||||
struct DecodeJsonArgJsonPointer {
|
||||
explicit DecodeJsonArgJsonPointer(std::string repr0);
|
||||
|
||||
// DefaultValue returns an empty string.
|
||||
static DecodeJsonArgJsonPointer DefaultValue();
|
||||
|
||||
std::string repr;
|
||||
};
|
||||
|
||||
// DecodeJson calls callbacks based on the JSON-formatted data in input.
|
||||
//
|
||||
// On success, the returned error_message is empty and cursor_position counts
|
||||
@@ -88,7 +116,8 @@ extern const char DecodeJson_NoMatch[];
|
||||
DecodeJsonResult //
|
||||
DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32(),
|
||||
std::string json_pointer = std::string());
|
||||
DecodeJsonArgQuirks quirks = DecodeJsonArgQuirks::DefaultValue(),
|
||||
DecodeJsonArgJsonPointer json_pointer =
|
||||
DecodeJsonArgJsonPointer::DefaultValue());
|
||||
|
||||
} // namespace wuffs_aux
|
||||
@@ -0,0 +1,36 @@
|
||||
# C Base Code
|
||||
|
||||
This directory (`base`) and its sibling
|
||||
([`auxiliary`](/internal/cgen/auxiliary)) contain C and C++ code respectively.
|
||||
This C/C++ code combines with the transpiled-to-C/C++ form of the Wuffs code in
|
||||
the top-level [`std`](/std) directory to create the "single file C/C++ library"
|
||||
form of the Wuffs standard library.
|
||||
|
||||
- From Wuffs-the-language's point of view, this directory contains
|
||||
implementations of the built-in `base` package types, such as [I/O
|
||||
buffers](/doc/note/io-input-output.md), [ranges and
|
||||
rects](/doc/note/ranges-and-rects.md) and [statuses](/doc/note/statuses.md).
|
||||
- From application code's point of view (Wuffs is for writing libraries not
|
||||
applications), this directory also contains helper functions for working with
|
||||
those `base` types, such as constructing an I/O buffer from a pointer and a
|
||||
length, that aren't relevant to Wuffs-the-language code.
|
||||
- This directory also contains some functionality (e.g. pixel conversion and
|
||||
string conversion) that, in the future, could possibly be Wuffs packages
|
||||
under `std`. For optimal performance, they sometimes require programming
|
||||
language features (e.g. function-pointer typed variables, SIMD acceleration)
|
||||
that are not yet available in Wuffs-the-language (or were not available at
|
||||
the time they were added). In the short term, it was more practical to
|
||||
implement them in carefully hand-written C/C++, in this directory. In the
|
||||
long term, they could migrate out of `base` to be under `std`, but any `base`
|
||||
API removal would require a Wuffs version number bump.
|
||||
|
||||
|
||||
## Making Changes
|
||||
|
||||
After editing source code in this directory, to see those changes when
|
||||
generating the C/C++ form of Wuffs' standard library:
|
||||
|
||||
go install github.com/google/wuffs/cmd/wuffs-c && wuffs gen base
|
||||
|
||||
This should modify the
|
||||
[`wuffs-unsupported-snapshot.c`](/release/c/wuffs-unsupported-snapshot.c) file.
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -31,13 +29,14 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
// Note that Clang also defines __GNUC__.
|
||||
#ifdef __cplusplus
|
||||
#if (__cplusplus >= 201103L) || defined(_MSC_VER)
|
||||
#include <memory>
|
||||
#define WUFFS_BASE__HAVE_EQ_DELETE
|
||||
#define WUFFS_BASE__HAVE_UNIQUE_PTR
|
||||
#elif defined(__GNUC__)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#elif defined(__GNUC__) || defined(__clang__)
|
||||
#warning "Wuffs' C++ code expects -std=c++11 or later"
|
||||
#endif
|
||||
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -177,14 +175,14 @@ wuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f) {
|
||||
// padded with implicit zeroes.
|
||||
//
|
||||
// For example, if num_digits is 3 and digits is "\x07\x08\x09":
|
||||
// - A decimal_point of -2 means ".00789"
|
||||
// - A decimal_point of -1 means ".0789"
|
||||
// - A decimal_point of +0 means ".789"
|
||||
// - A decimal_point of +1 means "7.89"
|
||||
// - A decimal_point of +2 means "78.9"
|
||||
// - A decimal_point of +3 means "789."
|
||||
// - A decimal_point of +4 means "7890."
|
||||
// - A decimal_point of +5 means "78900."
|
||||
// - A decimal_point of -2 means ".00789"
|
||||
// - A decimal_point of -1 means ".0789"
|
||||
// - A decimal_point of +0 means ".789"
|
||||
// - A decimal_point of +1 means "7.89"
|
||||
// - A decimal_point of +2 means "78.9"
|
||||
// - A decimal_point of +3 means "789."
|
||||
// - A decimal_point of +4 means "7890."
|
||||
// - A decimal_point of +5 means "78900."
|
||||
//
|
||||
// As above, a decimal_point higher than +2047 means that the overall value is
|
||||
// infinity, lower than -2047 means zero.
|
||||
@@ -529,10 +527,10 @@ wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(
|
||||
// wuffs_base__private_implementation__high_prec_dec__rounded_integer returns
|
||||
// the integral (non-fractional) part of h, provided that it is 18 or fewer
|
||||
// decimal digits. For 19 or more digits, it returns UINT64_MAX. Note that:
|
||||
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
|
||||
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
|
||||
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
|
||||
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
|
||||
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
|
||||
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
|
||||
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
|
||||
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
|
||||
// and that IEEE 754 double precision has 52 mantissa bits.
|
||||
//
|
||||
// That integral part is rounded-to-even: rounding 7.5 or 8.5 both give 8.
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -51,8 +49,9 @@
|
||||
goto suspend; \
|
||||
case n:;
|
||||
|
||||
// Clang also defines "__GNUC__".
|
||||
#if defined(__GNUC__)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))
|
||||
#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))
|
||||
#else
|
||||
@@ -210,7 +209,7 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,
|
||||
// --------
|
||||
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {
|
||||
wuffs_base__table_u8__row_u32(wuffs_base__table_u8 t, uint32_t y) {
|
||||
if (y < t.height) {
|
||||
return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width);
|
||||
}
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -35,7 +33,7 @@
|
||||
#define WUFFS_VERSION_MAJOR 0
|
||||
#define WUFFS_VERSION_MINOR 0
|
||||
#define WUFFS_VERSION_PATCH 0
|
||||
#define WUFFS_VERSION_PRE_RELEASE_LABEL "work.in.progress"
|
||||
#define WUFFS_VERSION_PRE_RELEASE_LABEL "unsupported.snapshot"
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 0
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 0
|
||||
#define WUFFS_VERSION_STRING "0.0.0+0.00000000"
|
||||
@@ -78,15 +76,18 @@
|
||||
// POPCNT. This is checked at runtime via cpuid, not at compile time.
|
||||
//
|
||||
// Likewise, "cpu_arch >= x86_avx2" also requires PCLMUL, POPCNT and SSE4.2.
|
||||
#if defined(__x86_64__) && !defined(__native_client__)
|
||||
#if defined(__i386__) || defined(__x86_64__)
|
||||
#if !defined(__native_client__)
|
||||
#include <cpuid.h>
|
||||
#include <x86intrin.h>
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_64
|
||||
#endif // defined(__x86_64__) && !defined(__native_client__)
|
||||
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
|
||||
#endif // !defined(__native_client__)
|
||||
#endif // defined(__i386__) || defined(__x86_64__)
|
||||
|
||||
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
|
||||
|
||||
#if defined(_M_X64)
|
||||
#if defined(_M_IX86) || defined(_M_X64)
|
||||
#if defined(__AVX__) || defined(__clang__)
|
||||
|
||||
// We need <intrin.h> for the __cpuid function.
|
||||
@@ -100,7 +101,8 @@
|
||||
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT
|
||||
#include <nmmintrin.h> // SSE4.2
|
||||
#include <wmmintrin.h> // AES, PCLMUL
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_64
|
||||
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
|
||||
|
||||
#else // defined(__AVX__) || defined(__clang__)
|
||||
|
||||
@@ -110,19 +112,22 @@
|
||||
// For MSVC's cl.exe (unlike clang or gcc), SIMD capability is a compile-time
|
||||
// property of the source file (e.g. a /arch:AVX or -mavx compiler flag), not
|
||||
// of individual functions (that can be conditionally selected at runtime).
|
||||
#pragma message("Wuffs with MSVC+X64 needs /arch:AVX for best performance")
|
||||
#pragma message("Wuffs with MSVC+IX86/X64 needs /arch:AVX for best performance")
|
||||
|
||||
#endif // defined(__AVX__) || defined(__clang__)
|
||||
#endif // defined(_M_X64)
|
||||
#endif // defined(_M_IX86) || defined(_M_X64)
|
||||
|
||||
#endif // (#if-chain ref AVOID_CPU_ARCH_1)
|
||||
#endif // (#if-chain ref AVOID_CPU_ARCH_0)
|
||||
|
||||
// --------
|
||||
|
||||
// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
|
||||
// static storage. The motivation is discussed in the "ALLOW STATIC
|
||||
// IMPLEMENTATION" section of
|
||||
// Define WUFFS_CONFIG__STATIC_FUNCTIONS (combined with WUFFS_IMPLEMENTATION)
|
||||
// to make all of Wuffs' functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#if defined(WUFFS_CONFIG__STATIC_FUNCTIONS)
|
||||
#define WUFFS_BASE__MAYBE_STATIC static
|
||||
@@ -152,7 +157,7 @@ wuffs_base__cpu_arch__have_arm_neon() {
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__cpu_arch__have_x86_avx2() {
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// GCC defines these macros but MSVC does not.
|
||||
// - bit_AVX2 = (1 << 5)
|
||||
const unsigned int avx2_ebx7 = 0x00000020;
|
||||
@@ -192,13 +197,13 @@ wuffs_base__cpu_arch__have_x86_avx2() {
|
||||
#else
|
||||
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
|
||||
#endif // defined(__GNUC__); defined(_MSC_VER)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__cpu_arch__have_x86_bmi2() {
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// GCC defines these macros but MSVC does not.
|
||||
// - bit_BMI2 = (1 << 8)
|
||||
const unsigned int bmi2_ebx7 = 0x00000100;
|
||||
@@ -222,13 +227,13 @@ wuffs_base__cpu_arch__have_x86_bmi2() {
|
||||
#else
|
||||
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
|
||||
#endif // defined(__GNUC__); defined(_MSC_VER)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// GCC defines these macros but MSVC does not.
|
||||
// - bit_PCLMUL = (1 << 1)
|
||||
// - bit_POPCNT = (1 << 23)
|
||||
@@ -254,7 +259,7 @@ wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
#else
|
||||
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
|
||||
#endif // defined(__GNUC__); defined(_MSC_VER)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -269,8 +274,9 @@ wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Clang also defines "__GNUC__".
|
||||
#if defined(__GNUC__)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused))
|
||||
#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result))
|
||||
#else
|
||||
@@ -468,7 +474,17 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
|
||||
// --------
|
||||
|
||||
// FourCC constants.
|
||||
// FourCC constants. Four Character Codes are literally four ASCII characters
|
||||
// (sometimes padded with ' ' spaces) that pack neatly into a signed or
|
||||
// unsigned 32-bit integer. ASCII letters are conventionally upper case.
|
||||
//
|
||||
// They are often used to identify video codecs (e.g. "H265") and pixel formats
|
||||
// (e.g. "YV12"). Wuffs uses them for that but also generally for naming
|
||||
// various things: compression formats (e.g. "BZ2 "), image metadata (e.g.
|
||||
// "EXIF"), file formats (e.g. "HTML"), etc.
|
||||
//
|
||||
// Wuffs' u32 values are big-endian ("JPEG" is 0x4A504547 not 0x4745504A) to
|
||||
// preserve ordering: "JPEG" < "MP3 " and 0x4A504547 < 0x4D503320.
|
||||
|
||||
// ¡ INSERT FourCCs.
|
||||
|
||||
@@ -731,7 +747,9 @@ wuffs_base__multiply_u64(uint64_t x, uint64_t y) {
|
||||
|
||||
// --------
|
||||
|
||||
#if defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#if (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__count_leading_zeroes_u64(uint64_t u) {
|
||||
@@ -775,7 +793,7 @@ wuffs_base__count_leading_zeroes_u64(uint64_t u) {
|
||||
return n;
|
||||
}
|
||||
|
||||
#endif // defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
|
||||
#endif // (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
|
||||
|
||||
// --------
|
||||
|
||||
@@ -1339,6 +1357,25 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
// wuffs_base__table_u8__subtable_ij returns t[ix:jx, iy:jy].
|
||||
//
|
||||
// It returns an empty table if i or j is out of bounds.
|
||||
static inline wuffs_base__table_u8 //
|
||||
wuffs_base__table_u8__subtable_ij(wuffs_base__table_u8 t,
|
||||
uint64_t ix,
|
||||
uint64_t iy,
|
||||
uint64_t jx,
|
||||
uint64_t jy) {
|
||||
if ((ix <= jx) && (jx <= SIZE_MAX) && (jx <= t.width) && //
|
||||
(iy <= jy) && (jy <= SIZE_MAX) && (jy <= t.height)) {
|
||||
return wuffs_base__make_table_u8(t.ptr + ix + (iy * t.stride), //
|
||||
((size_t)(jx - ix)), //
|
||||
((size_t)(jy - iy)), //
|
||||
t.stride); //
|
||||
}
|
||||
return wuffs_base__make_table_u8(NULL, 0, 0, 0);
|
||||
}
|
||||
|
||||
// wuffs_base__table__flattened_length returns the number of elements covered
|
||||
// by the 1-dimensional span that backs a 2-dimensional table. This counts the
|
||||
// elements inside the table and, when width != stride, the elements outside
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -139,13 +137,18 @@ wuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options) {
|
||||
ret.value = 0;
|
||||
return ret;
|
||||
} else if (negative) {
|
||||
if (r.value > 0x8000000000000000) {
|
||||
goto fail_out_of_bounds;
|
||||
if (r.value < 0x8000000000000000) {
|
||||
wuffs_base__result_i64 ret;
|
||||
ret.status.repr = NULL;
|
||||
ret.value = -(int64_t)(r.value);
|
||||
return ret;
|
||||
} else if (r.value == 0x8000000000000000) {
|
||||
wuffs_base__result_i64 ret;
|
||||
ret.status.repr = NULL;
|
||||
ret.value = INT64_MIN;
|
||||
return ret;
|
||||
}
|
||||
wuffs_base__result_i64 ret;
|
||||
ret.status.repr = NULL;
|
||||
ret.value = -(int64_t)(r.value);
|
||||
return ret;
|
||||
goto fail_out_of_bounds;
|
||||
} else if (r.value > 0x7FFFFFFFFFFFFFFF) {
|
||||
goto fail_out_of_bounds;
|
||||
} else {
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -117,11 +115,12 @@ wuffs_base__io_reader__set(wuffs_base__io_buffer* b,
|
||||
const uint8_t** ptr_io0_r,
|
||||
const uint8_t** ptr_io1_r,
|
||||
const uint8_t** ptr_io2_r,
|
||||
wuffs_base__slice_u8 data) {
|
||||
wuffs_base__slice_u8 data,
|
||||
uint64_t history_position) {
|
||||
b->data = data;
|
||||
b->meta.wi = data.len;
|
||||
b->meta.ri = 0;
|
||||
b->meta.pos = 0;
|
||||
b->meta.pos = history_position;
|
||||
b->meta.closed = false;
|
||||
|
||||
*ptr_iop_r = data.ptr;
|
||||
@@ -161,7 +160,7 @@ wuffs_base__io_writer__limit(uint8_t** ptr_io2_w,
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -169,7 +168,7 @@ wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
|
||||
return 0;
|
||||
}
|
||||
uint8_t* p = *ptr_iop_w;
|
||||
if ((size_t)(p - io1_w) < (size_t)(distance)) {
|
||||
if ((size_t)(p - io0_w) < (size_t)(distance)) {
|
||||
return 0;
|
||||
}
|
||||
uint8_t* q = p - distance;
|
||||
@@ -206,10 +205,10 @@ wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
|
||||
// The caller needs to prove that:
|
||||
// - length <= (io2_w - *ptr_iop_w)
|
||||
// - distance >= 1
|
||||
// - distance <= (*ptr_iop_w - io1_w)
|
||||
// - distance <= (*ptr_iop_w - io0_w)
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -241,11 +240,11 @@ wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,
|
||||
// The caller needs to prove that:
|
||||
// - (length + 8) <= (io2_w - *ptr_iop_w)
|
||||
// - distance == 1
|
||||
// - distance <= (*ptr_iop_w - io1_w)
|
||||
// - distance <= (*ptr_iop_w - io0_w)
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
|
||||
uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -281,11 +280,11 @@ wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fa
|
||||
// The caller needs to prove that:
|
||||
// - (length + 8) <= (io2_w - *ptr_iop_w)
|
||||
// - distance >= 8
|
||||
// - distance <= (*ptr_iop_w - io1_w)
|
||||
// - distance <= (*ptr_iop_w - io0_w)
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(
|
||||
uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -355,11 +354,12 @@ wuffs_base__io_writer__set(wuffs_base__io_buffer* b,
|
||||
uint8_t** ptr_io0_w,
|
||||
uint8_t** ptr_io1_w,
|
||||
uint8_t** ptr_io2_w,
|
||||
wuffs_base__slice_u8 data) {
|
||||
wuffs_base__slice_u8 data,
|
||||
uint64_t history_position) {
|
||||
b->data = data;
|
||||
b->meta.wi = 0;
|
||||
b->meta.ri = 0;
|
||||
b->meta.pos = 0;
|
||||
b->meta.pos = history_position;
|
||||
b->meta.closed = false;
|
||||
|
||||
*ptr_iop_w = data.ptr;
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2021 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -24,19 +22,23 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
|
||||
//
|
||||
// Keep it sorted by magic[1], then magic[0] descending and finally by
|
||||
// magic[2:]. When multiple entries match, the longest one wins.
|
||||
//
|
||||
// The fourcc field might be negated, in which case there's further
|
||||
// specialization (see § below).
|
||||
static struct {
|
||||
int32_t fourcc;
|
||||
const char* magic;
|
||||
} table[] = {
|
||||
{0x57424D50, "\x01\x00\x00"}, // WBMP
|
||||
{0x424D5020, "\x01\x42\x4D"}, // BMP
|
||||
{0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
|
||||
{0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
|
||||
{0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
|
||||
{0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF (see § below)
|
||||
{0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
|
||||
{0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
|
||||
{0x4A504547, "\x01\xFF\xD8"}, // JPEG
|
||||
{-0x30302020, "\x01\x00\x00"}, // '00 'be
|
||||
{+0x424D5020, "\x01\x42\x4D"}, // BMP
|
||||
{+0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
|
||||
{+0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
|
||||
{+0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
|
||||
{-0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF
|
||||
{+0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
|
||||
{+0x514F4920, "\x03\x71\x6F\x69\x66"}, // QOI
|
||||
{+0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
|
||||
{+0x4A504547, "\x01\xFF\xD8"}, // JPEG
|
||||
};
|
||||
static const size_t table_len = sizeof(table) / sizeof(table[0]);
|
||||
|
||||
@@ -77,19 +79,33 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
|
||||
return 0;
|
||||
|
||||
match:
|
||||
// Some FourCC values (see § above) are further specialized.
|
||||
if (fourcc == 0x52494646) { // 'RIFF'be
|
||||
if (prefix.len < 16) {
|
||||
return -1;
|
||||
}
|
||||
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
|
||||
if (x == 0x57454250) { // 'WEBP'be
|
||||
uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);
|
||||
if (y == 0x56503820) { // 'VP8 'be
|
||||
return 0x57503820; // 'WP8 'be
|
||||
} else if (y == 0x5650384C) { // 'VP8L'be
|
||||
return 0x5750384C; // 'WP8L'be
|
||||
// Negative FourCC values (see § above) are further specialized.
|
||||
if (fourcc < 0) {
|
||||
fourcc = -fourcc;
|
||||
|
||||
if (fourcc == 0x52494646) { // 'RIFF'be
|
||||
if (prefix.len < 12) {
|
||||
return -1;
|
||||
}
|
||||
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
|
||||
if (x == 0x57454250) { // 'WEBP'be
|
||||
return 0x57454250; // 'WEBP'be
|
||||
}
|
||||
|
||||
} else if (fourcc == 0x30302020) { // '00 'be
|
||||
// Binary data starting with multiple 0x00 NUL bytes is quite common.
|
||||
if (prefix.len < 4) {
|
||||
return -1;
|
||||
} else if ((prefix.ptr[2] != 0x00) &&
|
||||
((prefix.ptr[2] >= 0x80) || (prefix.ptr[3] != 0x00))) {
|
||||
// Roughly speaking, this could be a non-degenerate (non-0-width and
|
||||
// non-0-height) WBMP image.
|
||||
return 0x57424D50; // 'WBMP'be
|
||||
} else if (((prefix.ptr[2] == 0x01) || (prefix.ptr[2] == 0x02)) &&
|
||||
(prefix.ptr[3] == 0x00)) {
|
||||
return 0x49434F20; // 'ICO 'be
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return fourcc;
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -503,14 +501,23 @@ static inline uint32_t //
|
||||
wuffs_base__composite_nonpremul_nonpremul_u32_axxx(uint32_t dst_nonpremul,
|
||||
uint32_t src_nonpremul) {
|
||||
// Extract 16-bit color components.
|
||||
//
|
||||
// If the destination is transparent then SRC_OVER is equivalent to SRC: just
|
||||
// return src_nonpremul. This isn't just an optimization (skipping the rest
|
||||
// of the function's computation). It also preserves the nonpremul
|
||||
// distinction between e.g. transparent red and transparent blue that would
|
||||
// otherwise be lost by converting from nonpremul to premul and back.
|
||||
uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
|
||||
if (da == 0) {
|
||||
return src_nonpremul;
|
||||
}
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -547,14 +554,23 @@ static inline uint64_t //
|
||||
wuffs_base__composite_nonpremul_nonpremul_u64_axxx(uint64_t dst_nonpremul,
|
||||
uint64_t src_nonpremul) {
|
||||
// Extract components.
|
||||
//
|
||||
// If the destination is transparent then SRC_OVER is equivalent to SRC: just
|
||||
// return src_nonpremul. This isn't just an optimization (skipping the rest
|
||||
// of the function's computation). It also preserves the nonpremul
|
||||
// distinction between e.g. transparent red and transparent blue that would
|
||||
// otherwise be lost by converting from nonpremul to premul and back.
|
||||
uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
|
||||
if (da == 0) {
|
||||
return src_nonpremul;
|
||||
}
|
||||
uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
|
||||
uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
|
||||
uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
|
||||
uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -585,14 +601,14 @@ static inline uint32_t //
|
||||
wuffs_base__composite_nonpremul_premul_u32_axxx(uint32_t dst_nonpremul,
|
||||
uint32_t src_premul) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -629,14 +645,14 @@ static inline uint64_t //
|
||||
wuffs_base__composite_nonpremul_premul_u64_axxx(uint64_t dst_nonpremul,
|
||||
uint64_t src_premul) {
|
||||
// Extract components.
|
||||
uint64_t sa = 0xFFFF & (src_premul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_premul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_premul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_premul >> 0);
|
||||
uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
|
||||
uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
|
||||
uint64_t sa = 0xFFFF & (src_premul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_premul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_premul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_premul >> 0);
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -667,14 +683,14 @@ static inline uint32_t //
|
||||
wuffs_base__composite_premul_nonpremul_u32_axxx(uint32_t dst_premul,
|
||||
uint32_t src_nonpremul) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -699,14 +715,14 @@ static inline uint64_t //
|
||||
wuffs_base__composite_premul_nonpremul_u64_axxx(uint64_t dst_premul,
|
||||
uint64_t src_nonpremul) {
|
||||
// Extract components.
|
||||
uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
|
||||
uint64_t da = 0xFFFF & (dst_premul >> 48);
|
||||
uint64_t dr = 0xFFFF & (dst_premul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_premul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_premul >> 0);
|
||||
uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint64_t ia = 0xFFFF - sa;
|
||||
@@ -725,14 +741,14 @@ static inline uint32_t //
|
||||
wuffs_base__composite_premul_premul_u32_axxx(uint32_t dst_premul,
|
||||
uint32_t src_premul) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -812,7 +828,7 @@ wuffs_base__pixel_swizzler__swap_rgb_bgr(uint8_t* dst_ptr,
|
||||
}
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
|
||||
@@ -856,7 +872,7 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
|
||||
}
|
||||
return len;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
static uint64_t //
|
||||
@@ -1792,13 +1808,13 @@ wuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src_over(
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -1840,13 +1856,13 @@ wuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src_over(
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
|
||||
uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
|
||||
uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
|
||||
uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -1915,13 +1931,13 @@ wuffs_base__pixel_swizzler__bgr__bgra_premul__src_over(uint8_t* dst_ptr,
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -1993,13 +2009,13 @@ wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src_over(
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -2068,13 +2084,13 @@ wuffs_base__pixel_swizzler__bgr__rgba_premul__src_over(uint8_t* dst_ptr,
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -3135,7 +3151,7 @@ wuffs_base__pixel_swizzler__bgrw__bgrx(uint8_t* dst_ptr,
|
||||
}
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
|
||||
@@ -3188,7 +3204,7 @@ wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
|
||||
|
||||
return len;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
static uint64_t //
|
||||
@@ -3847,7 +3863,7 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(
|
||||
}
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
|
||||
@@ -3894,7 +3910,7 @@ wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
|
||||
|
||||
return len;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
static uint64_t //
|
||||
@@ -4182,7 +4198,7 @@ wuffs_base__pixel_swizzler__prepare__y(wuffs_base__pixel_swizzler* p,
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__xxxx__y__sse42;
|
||||
}
|
||||
@@ -4565,7 +4581,7 @@ wuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
|
||||
}
|
||||
@@ -4640,7 +4656,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -4821,7 +4837,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_premul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -4889,7 +4905,7 @@ wuffs_base__pixel_swizzler__prepare__rgb(wuffs_base__pixel_swizzler* p,
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
|
||||
}
|
||||
@@ -4940,7 +4956,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -5051,7 +5067,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_premul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -831,14 +829,24 @@ typedef struct wuffs_base__more_information__struct {
|
||||
inline wuffs_base__range_ie_u64 io_redirect__range() const;
|
||||
inline uint64_t io_seek__position() const;
|
||||
inline uint32_t metadata__fourcc() const;
|
||||
// Deprecated: use metadata_raw_passthrough__range.
|
||||
inline wuffs_base__range_ie_u64 metadata__range() const;
|
||||
inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const;
|
||||
inline int32_t metadata_parsed__chrm(uint32_t component) const;
|
||||
inline uint32_t metadata_parsed__gama() const;
|
||||
inline uint32_t metadata_parsed__srgb() const;
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_base__more_information;
|
||||
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT 1
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK 2
|
||||
// Deprecated: use
|
||||
// WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH.
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA 3
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH 3
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM 4
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED 5
|
||||
|
||||
static inline wuffs_base__more_information //
|
||||
wuffs_base__empty_more_information() {
|
||||
@@ -895,6 +903,8 @@ wuffs_base__more_information__metadata__fourcc(
|
||||
return m->w;
|
||||
}
|
||||
|
||||
// Deprecated: use
|
||||
// wuffs_base__more_information__metadata_raw_passthrough__range.
|
||||
static inline wuffs_base__range_ie_u64 //
|
||||
wuffs_base__more_information__metadata__range(
|
||||
const wuffs_base__more_information* m) {
|
||||
@@ -904,6 +914,103 @@ wuffs_base__more_information__metadata__range(
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__range_ie_u64 //
|
||||
wuffs_base__more_information__metadata_raw_passthrough__range(
|
||||
const wuffs_base__more_information* m) {
|
||||
wuffs_base__range_ie_u64 ret;
|
||||
ret.min_incl = m->y;
|
||||
ret.max_excl = m->z;
|
||||
return ret;
|
||||
}
|
||||
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_X 0
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_Y 1
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_X 2
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_Y 3
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_X 4
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_Y 5
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_X 6
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_Y 7
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__chrm returns chromaticity
|
||||
// values (scaled by 100000) like the PNG "cHRM" chunk. For example, the sRGB
|
||||
// color space corresponds to:
|
||||
// - ETC__CHRM__WHITE_X 31270
|
||||
// - ETC__CHRM__WHITE_Y 32900
|
||||
// - ETC__CHRM__RED_X 64000
|
||||
// - ETC__CHRM__RED_Y 33000
|
||||
// - ETC__CHRM__GREEN_X 30000
|
||||
// - ETC__CHRM__GREEN_Y 60000
|
||||
// - ETC__CHRM__BLUE_X 15000
|
||||
// - ETC__CHRM__BLUE_Y 6000
|
||||
//
|
||||
// See
|
||||
// https://ciechanow.ski/color-spaces/#chromaticity-and-white-point-coordinates
|
||||
static inline int32_t //
|
||||
wuffs_base__more_information__metadata_parsed__chrm(
|
||||
const wuffs_base__more_information* m,
|
||||
uint32_t component) {
|
||||
// After the flavor and the w field (holding a FourCC), a
|
||||
// wuffs_base__more_information holds 24 bytes of data in three uint64_t
|
||||
// typed fields (x, y and z). We pack the eight chromaticity values (wx, wy,
|
||||
// rx, ..., by), basically int24_t values, into 24 bytes like this:
|
||||
// - LSB MSB
|
||||
// - x: wx wx wx wy wy wy rx rx
|
||||
// - y: rx ry ry ry gx gx gx gy
|
||||
// - z: gy gy bx bx bx by by by
|
||||
uint32_t u = 0;
|
||||
switch (component & 7) {
|
||||
case 0:
|
||||
u = ((uint32_t)(m->x >> 0));
|
||||
break;
|
||||
case 1:
|
||||
u = ((uint32_t)(m->x >> 24));
|
||||
break;
|
||||
case 2:
|
||||
u = ((uint32_t)((m->x >> 48) | (m->y << 16)));
|
||||
break;
|
||||
case 3:
|
||||
u = ((uint32_t)(m->y >> 8));
|
||||
break;
|
||||
case 4:
|
||||
u = ((uint32_t)(m->y >> 32));
|
||||
break;
|
||||
case 5:
|
||||
u = ((uint32_t)((m->y >> 56) | (m->z << 8)));
|
||||
break;
|
||||
case 6:
|
||||
u = ((uint32_t)(m->z >> 16));
|
||||
break;
|
||||
case 7:
|
||||
u = ((uint32_t)(m->z >> 40));
|
||||
break;
|
||||
}
|
||||
// The left-right shifts sign-extend from 24-bit to 32-bit integers.
|
||||
return ((int32_t)(u << 8)) >> 8;
|
||||
}
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__gama returns inverse gamma
|
||||
// correction values (scaled by 100000) like the PNG "gAMA" chunk. For example,
|
||||
// for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2).
|
||||
static inline uint32_t //
|
||||
wuffs_base__more_information__metadata_parsed__gama(
|
||||
const wuffs_base__more_information* m) {
|
||||
return ((uint32_t)(m->x));
|
||||
}
|
||||
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__PERCEPTUAL 0
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__RELATIVE_COLORIMETRIC 1
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__SATURATION 2
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__ABSOLUTE_COLORIMETRIC 3
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__srgb returns the sRGB
|
||||
// rendering intent like the PNG "sRGB" chunk.
|
||||
static inline uint32_t //
|
||||
wuffs_base__more_information__metadata_parsed__srgb(
|
||||
const wuffs_base__more_information* m) {
|
||||
return m->x & 3;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
inline void //
|
||||
@@ -941,4 +1048,24 @@ wuffs_base__more_information::metadata__range() const {
|
||||
return wuffs_base__more_information__metadata__range(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__range_ie_u64 //
|
||||
wuffs_base__more_information::metadata_raw_passthrough__range() const {
|
||||
return wuffs_base__more_information__metadata_raw_passthrough__range(this);
|
||||
}
|
||||
|
||||
inline int32_t //
|
||||
wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const {
|
||||
return wuffs_base__more_information__metadata_parsed__chrm(this, component);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__more_information::metadata_parsed__gama() const {
|
||||
return wuffs_base__more_information__metadata_parsed__gama(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__more_information::metadata_parsed__srgb() const {
|
||||
return wuffs_base__more_information__metadata_parsed__srgb(this);
|
||||
}
|
||||
|
||||
#endif // __cplusplus
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@@ -98,9 +96,9 @@
|
||||
|
||||
// wuffs_base__ieee_754_bit_representation__etc converts between a double
|
||||
// precision numerical value and its IEEE 754 representations:
|
||||
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
|
||||
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
|
||||
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
|
||||
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
|
||||
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
|
||||
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
|
||||
//
|
||||
// For example, it converts between:
|
||||
// - +1.0 and 0x3C00, 0x3F80_0000 or 0x3FF0_0000_0000_0000.
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -1,5 +1,3 @@
|
||||
// After editing this file, run "go generate" in the ../data directory.
|
||||
|
||||
// Copyright 2020 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
|
||||
@@ -250,8 +250,8 @@ func (g *gen) writeBuiltinIOReader(b *buffer, recv *a.Expr, method t.ID, args []
|
||||
return nil
|
||||
|
||||
case t.IDPosition:
|
||||
b.printf("wuffs_base__u64__sat_add(%s->meta.pos, ((uint64_t)(%s%s - %s%s)))",
|
||||
recvName, iopPrefix, recvName, io0Prefix, recvName)
|
||||
b.printf("wuffs_base__u64__sat_add((%s ? %s->meta.pos : 0), ((uint64_t)(%s%s - %s%s)))",
|
||||
recvName, recvName, iopPrefix, recvName, io0Prefix, recvName)
|
||||
return nil
|
||||
|
||||
case t.IDSince:
|
||||
@@ -358,9 +358,13 @@ func (g *gen) writeBuiltinIOWriter(b *buffer, recv *a.Expr, method t.ID, args []
|
||||
b.printf("((uint64_t)(%s%s - %s%s))", iopPrefix, recvName, io0Prefix, recvName)
|
||||
return nil
|
||||
|
||||
case t.IDHistoryPosition:
|
||||
b.printf("(%s ? %s->meta.pos : 0)", recvName, recvName)
|
||||
return nil
|
||||
|
||||
case t.IDPosition:
|
||||
b.printf("wuffs_base__u64__sat_add(%s->meta.pos, ((uint64_t)(%s%s - %s%s)))",
|
||||
recvName, iopPrefix, recvName, io0Prefix, recvName)
|
||||
b.printf("wuffs_base__u64__sat_add((%s ? %s->meta.pos : 0), ((uint64_t)(%s%s - %s%s)))",
|
||||
recvName, recvName, iopPrefix, recvName, io0Prefix, recvName)
|
||||
return nil
|
||||
|
||||
case t.IDSince:
|
||||
@@ -1022,9 +1026,18 @@ func (g *gen) writeBuiltinTable(b *buffer, recv *a.Expr, method t.ID, args []*a.
|
||||
case t.IDWidth:
|
||||
field = "width"
|
||||
|
||||
case t.IDRow:
|
||||
case t.IDRowU32:
|
||||
// TODO: don't assume that the table is a table of base.u8.
|
||||
b.writes("wuffs_base__table_u8__row(")
|
||||
b.writes("wuffs_base__table_u8__row_u32(")
|
||||
if err := g.writeExpr(b, recv, false, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(", ")
|
||||
return g.writeArgs(b, args, depth)
|
||||
|
||||
case t.IDSubtable:
|
||||
// TODO: don't assume that the table is a table of base.u8.
|
||||
b.writes("wuffs_base__table_u8__subtable_ij(")
|
||||
if err := g.writeExpr(b, recv, false, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -22,7 +22,6 @@ import (
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"github.com/google/wuffs/internal/cgen/data"
|
||||
"github.com/google/wuffs/lang/builtin"
|
||||
"github.com/google/wuffs/lang/generate"
|
||||
"github.com/google/wuffs/lib/dumbindent"
|
||||
@@ -122,7 +121,7 @@ func Do(args []string) error {
|
||||
return nil, fmt.Errorf("base package shouldn't have any .wuffs files")
|
||||
}
|
||||
buf := make(buffer, 0, 128*1024)
|
||||
if err := expandBangBangInsert(&buf, data.BaseAllImplC, map[string]func(*buffer) error{
|
||||
if err := expandBangBangInsert(&buf, embedBaseAllImplC.Trim(), map[string]func(*buffer) error{
|
||||
"// ¡ INSERT InterfaceDeclarations.\n": insertInterfaceDeclarations,
|
||||
"// ¡ INSERT InterfaceDefinitions.\n": insertInterfaceDefinitions,
|
||||
"// ¡ INSERT base/all-private.h.\n": insertBaseAllPrivateH,
|
||||
@@ -200,8 +199,8 @@ const (
|
||||
)
|
||||
|
||||
const (
|
||||
maxIOBinds = 100
|
||||
maxTemp = 10000
|
||||
maxIOManips = 100
|
||||
maxTemp = 10000
|
||||
)
|
||||
|
||||
type status struct {
|
||||
@@ -270,24 +269,24 @@ func expandBangBangInsert(b *buffer, s string, m map[string]func(*buffer) error)
|
||||
}
|
||||
|
||||
func insertBaseAllPrivateH(buf *buffer) error {
|
||||
buf.writes(data.BaseFundamentalPrivateH)
|
||||
buf.writes(embedBaseFundamentalPrivateH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseRangePrivateH)
|
||||
buf.writes(embedBaseRangePrivateH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseIOPrivateH)
|
||||
buf.writes(embedBaseIOPrivateH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseTokenPrivateH)
|
||||
buf.writes(embedBaseTokenPrivateH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseMemoryPrivateH)
|
||||
buf.writes(embedBaseMemoryPrivateH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseImagePrivateH)
|
||||
buf.writes(embedBaseImagePrivateH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseStrConvPrivateH)
|
||||
buf.writes(embedBaseStrConvPrivateH.Trim())
|
||||
return nil
|
||||
}
|
||||
|
||||
func insertBaseAllPublicH(buf *buffer) error {
|
||||
if err := expandBangBangInsert(buf, data.BaseFundamentalPublicH, map[string]func(*buffer) error{
|
||||
if err := expandBangBangInsert(buf, embedBaseFundamentalPublicH.Trim(), map[string]func(*buffer) error{
|
||||
"// ¡ INSERT FourCCs.\n": func(b *buffer) error {
|
||||
for i, z := range builtin.FourCCs {
|
||||
if i != 0 {
|
||||
@@ -340,49 +339,52 @@ func insertBaseAllPublicH(buf *buffer) error {
|
||||
}
|
||||
buf.writeb('\n')
|
||||
|
||||
buf.writes(data.BaseRangePublicH)
|
||||
buf.writes(embedBaseRangePublicH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseIOPublicH)
|
||||
buf.writes(embedBaseIOPublicH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseTokenPublicH)
|
||||
buf.writes(embedBaseTokenPublicH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseMemoryPublicH)
|
||||
buf.writes(embedBaseMemoryPublicH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseImagePublicH)
|
||||
buf.writes(embedBaseImagePublicH.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseStrConvPublicH)
|
||||
buf.writes(embedBaseStrConvPublicH.Trim())
|
||||
return nil
|
||||
}
|
||||
|
||||
func insertBaseCopyright(buf *buffer) error {
|
||||
buf.writes(data.BaseCopyright)
|
||||
s := string(embedBaseAllImplC)
|
||||
if i := strings.Index(s, "\n\n"); i >= 0 {
|
||||
buf.writes(s[:i+1])
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func insertBaseFloatConvSubmoduleC(buf *buffer) error {
|
||||
buf.writes(data.BaseFloatConvSubmoduleDataC)
|
||||
buf.writes(embedBaseFloatConvSubmoduleDataC.Trim())
|
||||
buf.writeb('\n')
|
||||
buf.writes(data.BaseFloatConvSubmoduleCodeC)
|
||||
buf.writes(embedBaseFloatConvSubmoduleCodeC.Trim())
|
||||
return nil
|
||||
}
|
||||
|
||||
func insertBaseIntConvSubmoduleC(buf *buffer) error {
|
||||
buf.writes(data.BaseIntConvSubmoduleC)
|
||||
buf.writes(embedBaseIntConvSubmoduleC.Trim())
|
||||
return nil
|
||||
}
|
||||
|
||||
func insertBaseMagicSubmoduleC(buf *buffer) error {
|
||||
buf.writes(data.BaseMagicSubmoduleC)
|
||||
buf.writes(embedBaseMagicSubmoduleC.Trim())
|
||||
return nil
|
||||
}
|
||||
|
||||
func insertBasePixConvSubmoduleC(buf *buffer) error {
|
||||
buf.writes(data.BasePixConvSubmoduleC)
|
||||
buf.writes(embedBasePixConvSubmoduleC.Trim())
|
||||
return nil
|
||||
}
|
||||
|
||||
func insertBaseUTF8SubmoduleC(buf *buffer) error {
|
||||
buf.writes(data.BaseUTF8SubmoduleC)
|
||||
buf.writes(embedBaseUTF8SubmoduleC.Trim())
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
@@ -1,907 +0,0 @@
|
||||
// Code generated by running "go generate". DO NOT EDIT.
|
||||
|
||||
// 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.
|
||||
|
||||
package data
|
||||
|
||||
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 <stdbool.h>\n#include <stdint.h>\n#include <stdlib.h>\n#include <string.h>\n\n// Note that Clang also defines __GNUC__.\n#ifdef __cplusplus\n#if (__cplusplus >= 201103L) || defined(_MSC_VER)\n#include <memory>\n#define WUFFS_BASE__HAVE_EQ_DELETE\n#define WUFFS_BASE__HAVE_UNIQUE_PTR\n#elif defined(__GNUC__)\n#warning \"Wuffs' C++ code expects -std=c++11 or later\"\n#endif\n\nextern \"C\" {\n#endif\n\n// ¡ INSERT base/all-public.h.\n\n// ¡ INSERT InterfaceDeclarations.\n\n" +
|
||||
"" +
|
||||
"// ----------------\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" +
|
||||
"" +
|
||||
"// ----------------\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__CORE)\n\nconst uint8_t wuffs_base__low_bits_mask__u8[8] = {\n 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F,\n};\n\nconst uint16_t wuffs_base__low_bits_mask__u16[16] = {\n 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F,\n 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF,\n};\n\nconst uint32_t wuffs_base__low_bits_mask__u32[32] = {\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,\n};\n\nconst uint64_t wuffs_base__low_bits_mask__u64[64] = {\n 0x0000000000000000, 0x0000000000000001, 0x000000000" +
|
||||
"0000003,\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, 0x0003FFFFF" +
|
||||
"FFFFFFF,\n 0x0007FFFFFFFFFFFF, 0x000FFFFFFFFFFFFF, 0x001FFFFFFFFFFFFF,\n 0x003FFFFFFFFFFFFF, 0x007FFFFFFFFFFFFF, 0x00FFFFFFFFFFFFFF,\n 0x01FFFFFFFFFFFFFF, 0x03FFFFFFFFFFFFFF, 0x07FFFFFFFFFFFFFF,\n 0x0FFFFFFFFFFFFFFF, 0x1FFFFFFFFFFFFFFF, 0x3FFFFFFFFFFFFFFF,\n 0x7FFFFFFFFFFFFFFF,\n};\n\nconst uint32_t wuffs_base__pixel_format__bits_per_channel[16] = {\n 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\n 0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40,\n};\n\n// ¡ INSERT wuffs_base__status strings.\n\n// ¡ INSERT vtable names.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__CORE)\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__INTERFACES)\n\n// ¡ INSERT InterfaceDefinitions.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__INTERFACES)\n\n#if !define" +
|
||||
"d(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__FLOATCONV)\n\n// ¡ INSERT base/floatconv-submodule.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__FLOATCONV)\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__INTCONV)\n\n// ¡ INSERT base/intconv-submodule.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__INTCONV)\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__MAGIC)\n\n// ¡ INSERT base/magic-submodule.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__MAGIC)\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODUL" +
|
||||
"E__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__PIXCONV)\n\n// ¡ INSERT base/pixconv-submodule.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__PIXCONV)\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \\\n defined(WUFFS_CONFIG__MODULE__BASE__UTF8)\n\n// ¡ INSERT base/utf8-submodule.c.\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE) ||\n // defined(WUFFS_CONFIG__MODULE__BASE__UTF8)\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 BaseFundamentalPrivateH = "" +
|
||||
"// ---------------- Fundamentals\n\n// WUFFS_BASE__MAGIC is a magic number to check that initializers are called.\n// It's not foolproof, given C doesn't automatically zero memory before use,\n// but it should catch 99.99% of cases.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"wuffs\").\n#define WUFFS_BASE__MAGIC ((uint32_t)0x3CCB6C71)\n\n// WUFFS_BASE__DISABLED is a magic number to indicate that a non-recoverable\n// error was previously encountered.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"disabled\").\n#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)\n\n// Use switch cases for coroutine suspension points, similar to the technique\n// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html\n//\n// The implicit fallthrough is intentional.\n//\n// We use trivial macros instead of an explicit assignment and case statement\n// so that clang-format doesn't get confused by the unusual \"case\"s.\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;\n#define WUFFS_BASE__COROUTINE_SUSPENSION_" +
|
||||
"POINT(n) \\\n coro_susp_point = n; \\\n case n:;\n\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \\\n if (!status.repr) { \\\n goto ok; \\\n } else if (*status.repr != '$') { \\\n goto exit; \\\n } \\\n coro_susp_point = n; \\\n goto suspend; \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__ignore_status(wuffs_base__status z) {\n return wuffs_base__make_empty_struct();\n}\n\nstatic inline wuffs_base__status //\nwuffs_base__status__ensure_not_a_suspension(wuffs_base__status z) {\n if (z.repr && (*z.repr == '$')) {\n z.repr = wuffs_base__error__cannot_return_a_suspension;\n }\n return z;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__iterate_total_advance returns the exclusive pointer-offset at\n// which iteration should stop. The overall slice has length total_len, each\n// iteration's sub-slice has length iter_len and are placed iter_advance apart.\n//\n// The iter_advance may not be larger than iter_len. The iter_advance may be\n// smaller than iter_len, in which case the sub-slices will overlap.\n//\n// The return value r satisfies ((0 <= r) && (r <= total_len)).\n//\n// For example, if total_len = 15, iter_len = 5 and iter_advance = 3, there are\n// four iterations at offsets 0, 3, 6 and 9. This function returns 12.\n//\n// 0123456789012345\n// [....]\n// [....]\n// [....]\n// [....]\n// $\n// 0123456789012345\n//\n// For example, if total_len = 15, iter_len = 5 and iter_advance = 5, there are\n// three iterations at offsets 0, 5 and 10. This function returns 15.\n//\n// 0123456789012345\n// [....]\n// [....]\n// [....]\n// $\n// 0123456789012345\nstatic inline size_t //\nwuf" +
|
||||
"fs_base__iterate_total_advance(size_t total_len,\n size_t iter_len,\n size_t iter_advance) {\n if (total_len >= iter_len) {\n size_t n = total_len - iter_len;\n return ((n / iter_advance) * iter_advance) + iter_advance;\n }\n return 0;\n}\n\n" +
|
||||
"" +
|
||||
"// ---------------- Numeric Types\n\nextern const uint8_t wuffs_base__low_bits_mask__u8[8];\nextern const uint16_t wuffs_base__low_bits_mask__u16[16];\nextern const uint32_t wuffs_base__low_bits_mask__u32[32];\nextern const uint64_t wuffs_base__low_bits_mask__u64[64];\n\n#define WUFFS_BASE__LOW_BITS_MASK__U8(n) (wuffs_base__low_bits_mask__u8[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U16(n) (wuffs_base__low_bits_mask__u16[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U32(n) (wuffs_base__low_bits_mask__u32[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U64(n) (wuffs_base__low_bits_mask__u64[n])\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic inline void //\nwuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) {\n *x = wuffs_base__u8__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) {\n *x = wuffs_base__u8__sat_sub(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) {\n *x = wuffs_base__u16__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) {\n *x = wuffs_base__u16__sat_sub(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) {\n *x = wuffs_base__u32__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) {\n *x = wuffs_base__u32__sat_sub(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) {\n *x = wuffs_base__u64__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) {\n *x = wuffs_base__u64__sat_sub(*x, y);\n}\n\n" +
|
||||
"" +
|
||||
"// ---------------- Slices and Tables\n\n// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__prefix(wuffs_base__slice_u8 s, uint64_t up_to) {\n if (((uint64_t)(s.len)) > up_to) {\n s.len = ((size_t)up_to);\n }\n return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__suffix(wuffs_base__slice_u8 s, uint64_t up_to) {\n if (((uint64_t)(s.len)) > up_to) {\n s.ptr += ((uint64_t)(s.len)) - up_to;\n s.len = ((size_t)up_to);\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr, len)\n// where len is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t //\nwuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 s" +
|
||||
"rc) {\n size_t len = dst.len < src.len ? dst.len : src.len;\n if (len > 0) {\n memmove(dst.ptr, src.ptr, len);\n }\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {\n if (y < t.height) {\n return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width);\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\n" +
|
||||
"" +
|
||||
"// ---------------- Slices and Tables (Utility)\n\n#define wuffs_base__utility__empty_slice_u8 wuffs_base__empty_slice_u8\n" +
|
||||
""
|
||||
|
||||
const BaseFundamentalPublicH = "" +
|
||||
"// ---------------- Version\n\n// WUFFS_VERSION is the major.minor.patch version, as per https://semver.org/,\n// as a uint64_t. The major number is the high 32 bits. The minor number is the\n// middle 16 bits. The patch number is the low 16 bits. The pre-release label\n// and build metadata are part of the string representation (such as\n// \"1.2.3-beta+456.20181231\") but not the uint64_t representation.\n//\n// WUFFS_VERSION_PRE_RELEASE_LABEL (such as \"\", \"beta\" or \"rc.1\") being\n// non-empty denotes a developer preview, not a release version, and has no\n// backwards or forwards compatibility guarantees.\n//\n// WUFFS_VERSION_BUILD_METADATA_XXX, if non-zero, are the number of commits and\n// the last commit date in the repository used to build this library. Within\n// each major.minor branch, the commit count should increase monotonically.\n//\n// ¡ Some code generation programs can override WUFFS_VERSION.\n#define WUFFS_VERSION 0\n#define WUFFS_VERSION_MAJOR 0\n#define WUFFS_VERSION_MINOR 0\n#define WUFFS_VERSION_PATCH 0\n#de" +
|
||||
"fine WUFFS_VERSION_PRE_RELEASE_LABEL \"work.in.progress\"\n#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 0\n#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 0\n#define WUFFS_VERSION_STRING \"0.0.0+0.00000000\"\n\n" +
|
||||
"" +
|
||||
"// ---------------- Configuration\n\n// Define WUFFS_CONFIG__AVOID_CPU_ARCH to avoid any code tied to a specific CPU\n// architecture, such as SSE SIMD for the x86 CPU family.\n#if defined(WUFFS_CONFIG__AVOID_CPU_ARCH) // (#if-chain ref AVOID_CPU_ARCH_0)\n// No-op.\n#else // (#if-chain ref AVOID_CPU_ARCH_0)\n\n// The \"defined(__clang__)\" isn't redundant. While vanilla clang defines\n// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.\n#if defined(__GNUC__) || defined(__clang__)\n#define WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(arg) __attribute__((target(arg)))\n#else\n#define WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(arg)\n#endif // defined(__GNUC__) || defined(__clang__)\n\n#if defined(__GNUC__) // (#if-chain ref AVOID_CPU_ARCH_1)\n\n// To simplify Wuffs code, \"cpu_arch >= arm_xxx\" requires xxx but also\n// unaligned little-endian load/stores.\n#if defined(__ARM_FEATURE_UNALIGNED) && !defined(__native_client__) && \\\n defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)\n// Not all gcc versions define __ARM_A" +
|
||||
"CLE, even if they support crc32\n// intrinsics. Look for __ARM_FEATURE_CRC32 instead.\n#if defined(__ARM_FEATURE_CRC32)\n#include <arm_acle.h>\n#define WUFFS_BASE__CPU_ARCH__ARM_CRC32\n#endif // defined(__ARM_FEATURE_CRC32)\n#if defined(__ARM_NEON)\n#include <arm_neon.h>\n#define WUFFS_BASE__CPU_ARCH__ARM_NEON\n#endif // defined(__ARM_NEON)\n#endif // defined(__ARM_FEATURE_UNALIGNED) etc\n\n// Similarly, \"cpu_arch >= x86_sse42\" requires SSE4.2 but also PCLMUL and\n// POPCNT. This is checked at runtime via cpuid, not at compile time.\n//\n// Likewise, \"cpu_arch >= x86_avx2\" also requires PCLMUL, POPCNT and SSE4.2.\n#if defined(__x86_64__) && !defined(__native_client__)\n#include <cpuid.h>\n#include <x86intrin.h>\n#define WUFFS_BASE__CPU_ARCH__X86_64\n#endif // defined(__x86_64__) && !defined(__native_client__)\n\n#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)\n\n#if defined(_M_X64)\n#if defined(__AVX__) || defined(__clang__)\n\n// We need <intrin.h> for the __cpuid function.\n#include <intrin.h>\n// That's not enough for" +
|
||||
" X64 SIMD, with clang-cl, if we want to use\n// \"__attribute__((target(arg)))\" without e.g. \"/arch:AVX\".\n//\n// Some web pages suggest that <immintrin.h> is all you need, as it pulls in\n// the earlier SIMD families like SSE4.2, but that doesn't seem to work in\n// practice, possibly for the same reason that just <intrin.h> doesn't work.\n#include <immintrin.h> // AVX, AVX2, FMA, POPCNT\n#include <nmmintrin.h> // SSE4.2\n#include <wmmintrin.h> // AES, PCLMUL\n#define WUFFS_BASE__CPU_ARCH__X86_64\n\n#else // defined(__AVX__) || defined(__clang__)\n\n// clang-cl (which defines both __clang__ and _MSC_VER) supports\n// \"__attribute__((target(arg)))\".\n//\n// For MSVC's cl.exe (unlike clang or gcc), SIMD capability is a compile-time\n// property of the source file (e.g. a /arch:AVX or -mavx compiler flag), not\n// of individual functions (that can be conditionally selected at runtime).\n#pragma message(\"Wuffs with MSVC+X64 needs /arch:AVX for best performance\")\n\n#endif // defined(__AVX__) || defined(__clang__)\n#endif // defi" +
|
||||
"ned(_M_X64)\n\n#endif // (#if-chain ref AVOID_CPU_ARCH_1)\n#endif // (#if-chain ref AVOID_CPU_ARCH_0)\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have\n// static storage. The motivation is discussed in the \"ALLOW STATIC\n// IMPLEMENTATION\" section of\n// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt\n#if defined(WUFFS_CONFIG__STATIC_FUNCTIONS)\n#define WUFFS_BASE__MAYBE_STATIC static\n#else\n#define WUFFS_BASE__MAYBE_STATIC\n#endif // defined(WUFFS_CONFIG__STATIC_FUNCTIONS)\n\n" +
|
||||
"" +
|
||||
"// ---------------- CPU Architecture\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_arm_crc32() {\n#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)\n return true;\n#else\n return false;\n#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)\n}\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_arm_neon() {\n#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)\n return true;\n#else\n return false;\n#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)\n}\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_x86_avx2() {\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n // GCC defines these macros but MSVC does not.\n // - bit_AVX2 = (1 << 5)\n const unsigned int avx2_ebx7 = 0x00000020;\n // GCC defines these macros but MSVC does not.\n // - bit_PCLMUL = (1 << 1)\n // - bit_POPCNT = (1 << 23)\n // - bit_SSE4_2 = (1 << 20)\n const unsigned int avx2_ecx1 = 0x00900002;\n\n // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).\n#if defined(__GNUC__)\n unsigned int eax7 = 0;\n unsigned int ebx7 = 0;\n unsigned int ecx7 =" +
|
||||
" 0;\n unsigned int edx7 = 0;\n if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&\n ((ebx7 & avx2_ebx7) == avx2_ebx7)) {\n unsigned int eax1 = 0;\n unsigned int ebx1 = 0;\n unsigned int ecx1 = 0;\n unsigned int edx1 = 0;\n if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&\n ((ecx1 & avx2_ecx1) == avx2_ecx1)) {\n return true;\n }\n }\n#elif defined(_MSC_VER) // defined(__GNUC__)\n int x7[4];\n __cpuidex(x7, 7, 0);\n if ((((unsigned int)(x7[1])) & avx2_ebx7) == avx2_ebx7) {\n int x1[4];\n __cpuid(x1, 1);\n if ((((unsigned int)(x1[2])) & avx2_ecx1) == avx2_ecx1) {\n return true;\n }\n }\n#else\n#error \"WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler\"\n#endif // defined(__GNUC__); defined(_MSC_VER)\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n return false;\n}\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_x86_bmi2() {\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n // GCC defines these macros but MSVC does not.\n // - bit_BMI2 = (1 << 8)\n const u" +
|
||||
"nsigned int bmi2_ebx7 = 0x00000100;\n\n // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).\n#if defined(__GNUC__)\n unsigned int eax7 = 0;\n unsigned int ebx7 = 0;\n unsigned int ecx7 = 0;\n unsigned int edx7 = 0;\n if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&\n ((ebx7 & bmi2_ebx7) == bmi2_ebx7)) {\n return true;\n }\n#elif defined(_MSC_VER) // defined(__GNUC__)\n int x7[4];\n __cpuidex(x7, 7, 0);\n if ((((unsigned int)(x7[1])) & bmi2_ebx7) == bmi2_ebx7) {\n return true;\n }\n#else\n#error \"WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler\"\n#endif // defined(__GNUC__); defined(_MSC_VER)\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n return false;\n}\n\nstatic inline bool //\nwuffs_base__cpu_arch__have_x86_sse42() {\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n // GCC defines these macros but MSVC does not.\n // - bit_PCLMUL = (1 << 1)\n // - bit_POPCNT = (1 << 23)\n // - bit_SSE4_2 = (1 << 20)\n const unsigned int sse42_ecx1 = 0x00900002;\n\n // clan" +
|
||||
"g defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).\n#if defined(__GNUC__)\n unsigned int eax1 = 0;\n unsigned int ebx1 = 0;\n unsigned int ecx1 = 0;\n unsigned int edx1 = 0;\n if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&\n ((ecx1 & sse42_ecx1) == sse42_ecx1)) {\n return true;\n }\n#elif defined(_MSC_VER) // defined(__GNUC__)\n int x1[4];\n __cpuid(x1, 1);\n if ((((unsigned int)(x1[2])) & sse42_ecx1) == sse42_ecx1) {\n return true;\n }\n#else\n#error \"WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler\"\n#endif // defined(__GNUC__); defined(_MSC_VER)\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n return false;\n}\n\n" +
|
||||
"" +
|
||||
"// ---------------- Fundamentals\n\n// Wuffs assumes that:\n// - converting a uint32_t to a size_t will never overflow.\n// - converting a size_t to a uint64_t will never overflow.\n#if defined(__WORDSIZE)\n#if (__WORDSIZE != 32) && (__WORDSIZE != 64)\n#error \"Wuffs requires a word size of either 32 or 64 bits\"\n#endif\n#endif\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused))\n#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result))\n#else\n#define WUFFS_BASE__POTENTIALLY_UNUSED\n#define WUFFS_BASE__WARN_UNUSED_RESULT\n#endif\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// Options (bitwise or'ed together) for wuffs_foo__bar__initialize functions.\n\n#define WUFFS_INITIALIZE__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// WUFFS_INITIALIZE__ALREADY_ZEROED means that the \"self\" receiver struct value\n// has already been set to all zeroes.\n#define WUFFS_INITIALIZE__ALREADY_ZEROED ((uint32_t)0x00000001)\n\n// WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED means that, absent\n// WUFFS_INITIALIZE__ALREADY_ZEROED, only some of the \"self\" receiver struct\n// value will be set to all zeroes. Internal buffers, which tend to be a large\n// proportion of the struct's size, will be left uninitialized. Internal means\n// that the buffer is contained by the receiver struct, as opposed to being\n// passed as a separately allocated \"work buffer\".\n//\n// For more detail, see:\n// https://github.com/google/wuffs/blob/main/doc/note/initialization.md\n#define WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED \\\n ((uint32_t)0x00000002)\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__empty_struct is used when a Wuffs function returns an empty\n// struct. In C, if a function f returns void, you can't say \"x = f()\", but in\n// Wuffs, if a function g returns empty, you can say \"y = g()\".\ntypedef struct wuffs_base__empty_struct__struct {\n // private_impl is a placeholder field. It isn't explicitly used, except that\n // without it, the sizeof a struct with no fields can differ across C/C++\n // compilers, and it is undefined behavior in C99. For example, gcc says that\n // the sizeof an empty struct is 0, and g++ says that it is 1. This leads to\n // ABI incompatibility if a Wuffs .c file is processed by one compiler and\n // its .h file with another compiler.\n //\n // Instead, we explicitly insert an otherwise unused field, so that the\n // sizeof this struct is always 1.\n uint8_t private_impl;\n} wuffs_base__empty_struct;\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__make_empty_struct() {\n wuffs_base__empty_struct ret;\n ret.private_impl = 0;\n return " +
|
||||
"ret;\n}\n\n// wuffs_base__utility is a placeholder receiver type. It enables what Java\n// calls static methods, as opposed to regular methods.\ntypedef struct wuffs_base__utility__struct {\n // private_impl is a placeholder field. It isn't explicitly used, except that\n // without it, the sizeof a struct with no fields can differ across C/C++\n // compilers, and it is undefined behavior in C99. For example, gcc says that\n // the sizeof an empty struct is 0, and g++ says that it is 1. This leads to\n // ABI incompatibility if a Wuffs .c file is processed by one compiler and\n // its .h file with another compiler.\n //\n // Instead, we explicitly insert an otherwise unused field, so that the\n // sizeof this struct is always 1.\n uint8_t private_impl;\n} wuffs_base__utility;\n\ntypedef struct wuffs_base__vtable__struct {\n const char* vtable_name;\n const void* function_pointers;\n} wuffs_base__vtable;\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// See https://github.com/google/wuffs/blob/main/doc/note/statuses.md\ntypedef struct wuffs_base__status__struct {\n const char* repr;\n\n#ifdef __cplusplus\n inline bool is_complete() const;\n inline bool is_error() const;\n inline bool is_note() const;\n inline bool is_ok() const;\n inline bool is_suspension() const;\n inline const char* message() const;\n#endif // __cplusplus\n\n} wuffs_base__status;\n\n// ¡ INSERT wuffs_base__status names.\n\nstatic inline wuffs_base__status //\nwuffs_base__make_status(const char* repr) {\n wuffs_base__status z;\n z.repr = repr;\n return z;\n}\n\nstatic inline bool //\nwuffs_base__status__is_complete(const wuffs_base__status* z) {\n return (z->repr == NULL) || ((*z->repr != '$') && (*z->repr != '#'));\n}\n\nstatic inline bool //\nwuffs_base__status__is_error(const wuffs_base__status* z) {\n return z->repr && (*z->repr == '#');\n}\n\nstatic inline bool //\nwuffs_base__status__is_note(const wuffs_base__status* z) {\n return z->repr && (*z->repr != '$') && (*z->repr != '#');\n}\n\n" +
|
||||
"static inline bool //\nwuffs_base__status__is_ok(const wuffs_base__status* z) {\n return z->repr == NULL;\n}\n\nstatic inline bool //\nwuffs_base__status__is_suspension(const wuffs_base__status* z) {\n return z->repr && (*z->repr == '$');\n}\n\n// wuffs_base__status__message strips the leading '$', '#' or '@'.\nstatic inline const char* //\nwuffs_base__status__message(const wuffs_base__status* z) {\n if (z->repr) {\n if ((*z->repr == '$') || (*z->repr == '#') || (*z->repr == '@')) {\n return z->repr + 1;\n }\n }\n return z->repr;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__status::is_complete() const {\n return wuffs_base__status__is_complete(this);\n}\n\ninline bool //\nwuffs_base__status::is_error() const {\n return wuffs_base__status__is_error(this);\n}\n\ninline bool //\nwuffs_base__status::is_note() const {\n return wuffs_base__status__is_note(this);\n}\n\ninline bool //\nwuffs_base__status::is_ok() const {\n return wuffs_base__status__is_ok(this);\n}\n\ninline bool //\nwuffs_base__status::is_suspension() co" +
|
||||
"nst {\n return wuffs_base__status__is_suspension(this);\n}\n\ninline const char* //\nwuffs_base__status::message() const {\n return wuffs_base__status__message(this);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// WUFFS_BASE__RESULT is a result type: either a status (an error) or a value.\n//\n// A result with all fields NULL or zero is as valid as a zero-valued T.\n#define WUFFS_BASE__RESULT(T) \\\n struct { \\\n wuffs_base__status status; \\\n T value; \\\n }\n\ntypedef WUFFS_BASE__RESULT(double) wuffs_base__result_f64;\ntypedef WUFFS_BASE__RESULT(int64_t) wuffs_base__result_i64;\ntypedef WUFFS_BASE__RESULT(uint64_t) wuffs_base__result_u64;\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__transform__output is the result of transforming from a src slice\n// to a dst slice.\ntypedef struct wuffs_base__transform__output__struct {\n wuffs_base__status status;\n size_t num_dst;\n size_t num_src;\n} wuffs_base__transform__output;\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// FourCC constants.\n\n// ¡ INSERT FourCCs.\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// Quirks.\n\n// ¡ INSERT Quirks.\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef int64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000)\n#define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600)\n\n" +
|
||||
"" +
|
||||
"// ---------------- Numeric Types\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline int8_t //\nwuffs_base__i8__min(int8_t x, int8_t y) {\n return x < y ? x : y;\n}\n\nstatic inline int8_t //\nwuffs_base__i8__max(int8_t x, int8_t y) {\n return x > y ? x : y;\n}\n\nstatic inline int16_t //\nwuffs_base__i16__min(int16_t x, int16_t y) {\n return x < y ? x : y;\n}\n\nstatic inline int16_t //\nwuffs_base__i16__max(int16_t x, int16_t y) {\n return x > y ? x : y;\n}\n\nstatic inline int32_t //\nwuffs_base__i32__min(int32_t x, int32_t y) {\n return x < y ? x : y;\n}\n\nstatic inline " +
|
||||
"int32_t //\nwuffs_base__i32__max(int32_t x, int32_t y) {\n return x > y ? x : y;\n}\n\nstatic inline int64_t //\nwuffs_base__i64__min(int64_t x, int64_t y) {\n return x < y ? x : y;\n}\n\nstatic inline int64_t //\nwuffs_base__i64__max(int64_t x, int64_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint8_t //\nwuffs_base__u8__min(uint8_t x, uint8_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint8_t //\nwuffs_base__u8__max(uint8_t x, uint8_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__min(uint16_t x, uint16_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__max(uint16_t x, uint16_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__min(uint32_t x, uint32_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__max(uint32_t x, uint32_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__min(uint64_t x, uint64_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__m" +
|
||||
"ax(uint64_t x, uint64_t y) {\n return x > y ? x : y;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic inline uint8_t //\nwuffs_base__u8__rotate_left(uint8_t x, uint32_t n) {\n n &= 7;\n return ((uint8_t)(x << n)) | ((uint8_t)(x >> (8 - n)));\n}\n\nstatic inline uint8_t //\nwuffs_base__u8__rotate_right(uint8_t x, uint32_t n) {\n n &= 7;\n return ((uint8_t)(x >> n)) | ((uint8_t)(x << (8 - n)));\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__rotate_left(uint16_t x, uint32_t n) {\n n &= 15;\n return ((uint16_t)(x << n)) | ((uint16_t)(x >> (16 - n)));\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__rotate_right(uint16_t x, uint32_t n) {\n n &= 15;\n return ((uint16_t)(x >> n)) | ((uint16_t)(x << (16 - n)));\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__rotate_left(uint32_t x, uint32_t n) {\n n &= 31;\n return ((uint32_t)(x << n)) | ((uint32_t)(x >> (32 - n)));\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__rotate_right(uint32_t x, uint32_t n) {\n n &= 31;\n return ((uint32_t)(x >> n)) | ((uint32_t)(x << (32 - n)));\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__rotate_left(uint64_t x, uint32_t n) " +
|
||||
"{\n n &= 63;\n return ((uint64_t)(x << n)) | ((uint64_t)(x >> (64 - n)));\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__rotate_right(uint64_t x, uint32_t n) {\n n &= 63;\n return ((uint64_t)(x >> n)) | ((uint64_t)(x << (64 - n)));\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms\n// are per https://locklessinc.com/articles/sat_arithmetic/\n//\n// It is important that the underlying types are unsigned integers, as signed\n// integer arithmetic overflow is undefined behavior in C.\n\nstatic inline uint8_t //\nwuffs_base__u8__sat_add(uint8_t x, uint8_t y) {\n uint8_t res = (uint8_t)(x + y);\n res |= (uint8_t)(-(res < x));\n return res;\n}\n\nstatic inline uint8_t //\nwuffs_base__u8__sat_sub(uint8_t x, uint8_t y) {\n uint8_t res = (uint8_t)(x - y);\n res &= (uint8_t)(-(res <= x));\n return res;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__sat_add(uint16_t x, uint16_t y) {\n uint16_t res = (uint16_t)(x + y);\n res |= (uint16_t)(-(res < x));\n return res;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__sat_sub(uint16_t x, uint16_t y) {\n uint16_t res = (uint16_t)(x - y);\n res &= (uint16_t)(-(res <= x));\n return res;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__sat_add(uint32_t x, uint32_t y) {\n uint32" +
|
||||
"_t res = (uint32_t)(x + y);\n res |= (uint32_t)(-(res < x));\n return res;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {\n uint32_t res = (uint32_t)(x - y);\n res &= (uint32_t)(-(res <= x));\n return res;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__sat_add(uint64_t x, uint64_t y) {\n uint64_t res = (uint64_t)(x + y);\n res |= (uint64_t)(-(res < x));\n return res;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {\n uint64_t res = (uint64_t)(x - y);\n res &= (uint64_t)(-(res <= x));\n return res;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__multiply_u64__output__struct {\n uint64_t lo;\n uint64_t hi;\n} wuffs_base__multiply_u64__output;\n\n// wuffs_base__multiply_u64 returns x*y as a 128-bit value.\n//\n// The maximum inclusive output hi_lo is 0xFFFFFFFFFFFFFFFE_0000000000000001.\nstatic inline wuffs_base__multiply_u64__output //\nwuffs_base__multiply_u64(uint64_t x, uint64_t y) {\n#if defined(__SIZEOF_INT128__)\n __uint128_t z = ((__uint128_t)x) * ((__uint128_t)y);\n wuffs_base__multiply_u64__output o;\n o.lo = ((uint64_t)(z));\n o.hi = ((uint64_t)(z >> 64));\n return o;\n#else\n // TODO: consider using the _mul128 intrinsic if defined(_MSC_VER).\n uint64_t x0 = x & 0xFFFFFFFF;\n uint64_t x1 = x >> 32;\n uint64_t y0 = y & 0xFFFFFFFF;\n uint64_t y1 = y >> 32;\n uint64_t w0 = x0 * y0;\n uint64_t t = (x1 * y0) + (w0 >> 32);\n uint64_t w1 = t & 0xFFFFFFFF;\n uint64_t w2 = t >> 32;\n w1 += x0 * y1;\n wuffs_base__multiply_u64__output o;\n o.lo = x * y;\n o.hi = (x1 * y1) + w2 + (w1 >> 32);\n return o;\n#endif\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#if defined(__GNUC__) && (__SIZEOF_LONG__ == 8)\n\nstatic inline uint32_t //\nwuffs_base__count_leading_zeroes_u64(uint64_t u) {\n return u ? ((uint32_t)(__builtin_clzl(u))) : 64u;\n}\n\n#else\n// TODO: consider using the _BitScanReverse intrinsic if defined(_MSC_VER).\n\nstatic inline uint32_t //\nwuffs_base__count_leading_zeroes_u64(uint64_t u) {\n if (u == 0) {\n return 64;\n }\n\n uint32_t n = 0;\n if ((u >> 32) == 0) {\n n |= 32;\n u <<= 32;\n }\n if ((u >> 48) == 0) {\n n |= 16;\n u <<= 16;\n }\n if ((u >> 56) == 0) {\n n |= 8;\n u <<= 8;\n }\n if ((u >> 60) == 0) {\n n |= 4;\n u <<= 4;\n }\n if ((u >> 62) == 0) {\n n |= 2;\n u <<= 2;\n }\n if ((u >> 63) == 0) {\n n |= 1;\n u <<= 1;\n }\n return n;\n}\n\n#endif // defined(__GNUC__) && (__SIZEOF_LONG__ == 8)\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#define wuffs_base__peek_u8be__no_bounds_check \\\n wuffs_base__peek_u8__no_bounds_check\n#define wuffs_base__peek_u8le__no_bounds_check \\\n wuffs_base__peek_u8__no_bounds_check\n\nstatic inline uint8_t //\nwuffs_base__peek_u8__no_bounds_check(const uint8_t* p) {\n return p[0];\n}\n\nstatic inline uint16_t //\nwuffs_base__peek_u16be__no_bounds_check(const uint8_t* p) {\n return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0));\n}\n\nstatic inline uint16_t //\nwuffs_base__peek_u16le__no_bounds_check(const uint8_t* p) {\n return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8));\n}\n\nstatic inline uint32_t //\nwuffs_base__peek_u24be__no_bounds_check(const uint8_t* p) {\n return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__peek_u24le__no_bounds_check(const uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16);\n}\n\nstatic inline uint32_t //\nwuffs_base" +
|
||||
"__peek_u32be__no_bounds_check(const uint8_t* p) {\n return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__peek_u32le__no_bounds_check(const uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u40be__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) |\n ((uint64_t)(p[4]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u40le__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u48be__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[" +
|
||||
"1]) << 32) |\n ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) |\n ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u48le__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u56be__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 48) | ((uint64_t)(p[1]) << 40) |\n ((uint64_t)(p[2]) << 32) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 16) | ((uint64_t)(p[5]) << 8) |\n ((uint64_t)(p[6]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u56le__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |\n ((uint64_t)(p[" +
|
||||
"6]) << 48);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u64be__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) |\n ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) |\n ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) |\n ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__peek_u64le__no_bounds_check(const uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |\n ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#define wuffs_base__poke_u8be__no_bounds_check \\\n wuffs_base__poke_u8__no_bounds_check\n#define wuffs_base__poke_u8le__no_bounds_check \\\n wuffs_base__poke_u8__no_bounds_check\n\nstatic inline void //\nwuffs_base__poke_u8__no_bounds_check(uint8_t* p, uint8_t x) {\n p[0] = x;\n}\n\nstatic inline void //\nwuffs_base__poke_u16be__no_bounds_check(uint8_t* p, uint16_t x) {\n p[0] = (uint8_t)(x >> 8);\n p[1] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u16le__no_bounds_check(uint8_t* p, uint16_t x) {\n#if defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)\n // This seems to perform better on gcc 10 (but not clang 9). Clang also\n // defines \"__GNUC__\".\n memcpy(p, &x, 2);\n#else\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n#endif\n}\n\nstatic inline void //\nwuffs_base__poke_u24be__no_bounds_check(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 16);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u24le__no_bounds_chec" +
|
||||
"k(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n}\n\nstatic inline void //\nwuffs_base__poke_u32be__no_bounds_check(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 24);\n p[1] = (uint8_t)(x >> 16);\n p[2] = (uint8_t)(x >> 8);\n p[3] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u32le__no_bounds_check(uint8_t* p, uint32_t x) {\n#if defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)\n // This seems to perform better on gcc 10 (but not clang 9). Clang also\n // defines \"__GNUC__\".\n memcpy(p, &x, 4);\n#else\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n#endif\n}\n\nstatic inline void //\nwuffs_base__poke_u40be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 32);\n p[1] = (uint8_t)(x >> 24);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 8);\n p[4] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u40le__no_bounds_chec" +
|
||||
"k(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n}\n\nstatic inline void //\nwuffs_base__poke_u48be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 40);\n p[1] = (uint8_t)(x >> 32);\n p[2] = (uint8_t)(x >> 24);\n p[3] = (uint8_t)(x >> 16);\n p[4] = (uint8_t)(x >> 8);\n p[5] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u48le__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uint8_t)(x >> 40);\n}\n\nstatic inline void //\nwuffs_base__poke_u56be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 48);\n p[1] = (uint8_t)(x >> 40);\n p[2] = (uint8_t)(x >> 32);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 16);\n p[5] = (uint8_t)(x >> 8);\n p[6] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_" +
|
||||
"base__poke_u56le__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uint8_t)(x >> 40);\n p[6] = (uint8_t)(x >> 48);\n}\n\nstatic inline void //\nwuffs_base__poke_u64be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 56);\n p[1] = (uint8_t)(x >> 48);\n p[2] = (uint8_t)(x >> 40);\n p[3] = (uint8_t)(x >> 32);\n p[4] = (uint8_t)(x >> 24);\n p[5] = (uint8_t)(x >> 16);\n p[6] = (uint8_t)(x >> 8);\n p[7] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) {\n#if defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__)\n // This seems to perform better on gcc 10 (but not clang 9). Clang also\n // defines \"__GNUC__\".\n memcpy(p, &x, 8);\n#else\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uin" +
|
||||
"t8_t)(x >> 40);\n p[6] = (uint8_t)(x >> 48);\n p[7] = (uint8_t)(x >> 56);\n#endif\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// Load and Store functions are deprecated. Use Peek and Poke instead.\n\n#define wuffs_base__load_u8__no_bounds_check \\\n wuffs_base__peek_u8__no_bounds_check\n#define wuffs_base__load_u16be__no_bounds_check \\\n wuffs_base__peek_u16be__no_bounds_check\n#define wuffs_base__load_u16le__no_bounds_check \\\n wuffs_base__peek_u16le__no_bounds_check\n#define wuffs_base__load_u24be__no_bounds_check \\\n wuffs_base__peek_u24be__no_bounds_check\n#define wuffs_base__load_u24le__no_bounds_check \\\n wuffs_base__peek_u24le__no_bounds_check\n#define wuffs_base__load_u32be__no_bounds_check \\\n wuffs_base__peek_u32be__no_bounds_check\n#define wuffs_base__load_u32le__no_bounds_check \\\n wuffs_base__peek_u32le__no_bounds_check\n#define wuffs_base__load_u40be__no_bounds_check \\\n wuffs_base__peek_u40be__no_bounds_check\n#define wuffs_base__load_u40le__no_bounds_check \\\n wuffs_base__peek_u40le__no_bounds_check\n#define wuffs_base__load_u48be__no_bounds_check \\\n wuffs_base__peek_u48be__no_bounds_check\n#define wuffs_base__load_" +
|
||||
"u48le__no_bounds_check \\\n wuffs_base__peek_u48le__no_bounds_check\n#define wuffs_base__load_u56be__no_bounds_check \\\n wuffs_base__peek_u56be__no_bounds_check\n#define wuffs_base__load_u56le__no_bounds_check \\\n wuffs_base__peek_u56le__no_bounds_check\n#define wuffs_base__load_u64be__no_bounds_check \\\n wuffs_base__peek_u64be__no_bounds_check\n#define wuffs_base__load_u64le__no_bounds_check \\\n wuffs_base__peek_u64le__no_bounds_check\n\n#define wuffs_base__store_u8__no_bounds_check \\\n wuffs_base__poke_u8__no_bounds_check\n#define wuffs_base__store_u16be__no_bounds_check \\\n wuffs_base__poke_u16be__no_bounds_check\n#define wuffs_base__store_u16le__no_bounds_check \\\n wuffs_base__poke_u16le__no_bounds_check\n#define wuffs_base__store_u24be__no_bounds_check \\\n wuffs_base__poke_u24be__no_bounds_check\n#define wuffs_base__store_u24le__no_bounds_check \\\n wuffs_base__poke_u24le__no_bounds_check\n#define wuffs_base__store_u32be__no_bounds_check \\\n wuffs_base__poke_u32be__no_bounds_check\n#define wuffs_base__store_u32le__no_" +
|
||||
"bounds_check \\\n wuffs_base__poke_u32le__no_bounds_check\n#define wuffs_base__store_u40be__no_bounds_check \\\n wuffs_base__poke_u40be__no_bounds_check\n#define wuffs_base__store_u40le__no_bounds_check \\\n wuffs_base__poke_u40le__no_bounds_check\n#define wuffs_base__store_u48be__no_bounds_check \\\n wuffs_base__poke_u48be__no_bounds_check\n#define wuffs_base__store_u48le__no_bounds_check \\\n wuffs_base__poke_u48le__no_bounds_check\n#define wuffs_base__store_u56be__no_bounds_check \\\n wuffs_base__poke_u56be__no_bounds_check\n#define wuffs_base__store_u56le__no_bounds_check \\\n wuffs_base__poke_u56le__no_bounds_check\n#define wuffs_base__store_u64be__no_bounds_check \\\n wuffs_base__poke_u64be__no_bounds_check\n#define wuffs_base__store_u64le__no_bounds_check \\\n wuffs_base__poke_u64le__no_bounds_check\n\n" +
|
||||
"" +
|
||||
"// ---------------- Slices and Tables\n\n// WUFFS_BASE__SLICE is a 1-dimensional buffer.\n//\n// len measures a number of elements, not necessarily a size in bytes.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\n#define WUFFS_BASE__SLICE(T) \\\n struct { \\\n T* ptr; \\\n size_t len; \\\n }\n\n// WUFFS_BASE__TABLE is a 2-dimensional buffer.\n//\n// width, height and stride measure a number of elements, not necessarily a\n// size in bytes.\n//\n// A value with all fields NULL or zero is a valid, empty table.\n#define WUFFS_BASE__TABLE(T) \\\n struct { \\\n T* ptr; \\\n size_t width; \\\n size_t height; \\\n size_t stride; \\\n }\n\ntypedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8;\ntypedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16;\ntypedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32;\ntypedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64;\n\ntypedef WUFFS_BASE__TABLE(u" +
|
||||
"int8_t) wuffs_base__table_u8;\ntypedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16;\ntypedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32;\ntypedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__make_slice_u8(uint8_t* ptr, size_t len) {\n wuffs_base__slice_u8 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u16 //\nwuffs_base__make_slice_u16(uint16_t* ptr, size_t len) {\n wuffs_base__slice_u16 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u32 //\nwuffs_base__make_slice_u32(uint32_t* ptr, size_t len) {\n wuffs_base__slice_u32 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u64 //\nwuffs_base__make_slice_u64(uint64_t* ptr, size_t len) {\n wuffs_base__slice_u64 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__empty_slice_u8() {\n wuffs_base__slice_u8 ret;\n ret.ptr = NULL;\n" +
|
||||
" ret.len = 0;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u16 //\nwuffs_base__empty_slice_u16() {\n wuffs_base__slice_u16 ret;\n ret.ptr = NULL;\n ret.len = 0;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u32 //\nwuffs_base__empty_slice_u32() {\n wuffs_base__slice_u32 ret;\n ret.ptr = NULL;\n ret.len = 0;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u64 //\nwuffs_base__empty_slice_u64() {\n wuffs_base__slice_u64 ret;\n ret.ptr = NULL;\n ret.len = 0;\n return ret;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__make_table_u8(uint8_t* ptr,\n size_t width,\n size_t height,\n size_t stride) {\n wuffs_base__table_u8 ret;\n ret.ptr = ptr;\n ret.width = width;\n ret.height = height;\n ret.stride = stride;\n return ret;\n}\n\nstatic inline wuffs_base__table_u16 //\nwuffs_base__make_table_u16(uint16_t* ptr,\n size_t width,\n size_t height,\n size_t stride) " +
|
||||
"{\n wuffs_base__table_u16 ret;\n ret.ptr = ptr;\n ret.width = width;\n ret.height = height;\n ret.stride = stride;\n return ret;\n}\n\nstatic inline wuffs_base__table_u32 //\nwuffs_base__make_table_u32(uint32_t* ptr,\n size_t width,\n size_t height,\n size_t stride) {\n wuffs_base__table_u32 ret;\n ret.ptr = ptr;\n ret.width = width;\n ret.height = height;\n ret.stride = stride;\n return ret;\n}\n\nstatic inline wuffs_base__table_u64 //\nwuffs_base__make_table_u64(uint64_t* ptr,\n size_t width,\n size_t height,\n size_t stride) {\n wuffs_base__table_u64 ret;\n ret.ptr = ptr;\n ret.width = width;\n ret.height = height;\n ret.stride = stride;\n return ret;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__empty_table_u8() {\n wuffs_base__table_u8 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\nstatic inline wuffs_base__ta" +
|
||||
"ble_u16 //\nwuffs_base__empty_table_u16() {\n wuffs_base__table_u16 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\nstatic inline wuffs_base__table_u32 //\nwuffs_base__empty_table_u32() {\n wuffs_base__table_u32 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\nstatic inline wuffs_base__table_u64 //\nwuffs_base__empty_table_u64() {\n wuffs_base__table_u64 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__slice_u8__overlaps(wuffs_base__slice_u8 s, wuffs_base__slice_u8 t) {\n return ((s.ptr <= t.ptr) && (t.ptr < (s.ptr + s.len))) ||\n ((t.ptr <= s.ptr) && (s.ptr < (t.ptr + t.len)));\n}\n\n// wuffs_base__slice_u8__subslice_i returns s[i:].\n//\n// It returns an empty slice if i is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n " +
|
||||
" return wuffs_base__make_slice_u8(s.ptr + i, ((size_t)(s.len - i)));\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\n// wuffs_base__slice_u8__subslice_j returns s[:j].\n//\n// It returns an empty slice if j is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return wuffs_base__make_slice_u8(s.ptr, ((size_t)j));\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\n// wuffs_base__slice_u8__subslice_ij returns s[i:j].\n//\n// It returns an empty slice if i or j is out of bounds.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,\n uint64_t i,\n uint64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n return wuffs_base__make_slice_u8(s.ptr + i, ((size_t)(j - i)));\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\n// wuffs_base__table__flattened_length returns the number o" +
|
||||
"f elements covered\n// by the 1-dimensional span that backs a 2-dimensional table. This counts the\n// elements inside the table and, when width != stride, the elements outside\n// the table but between its rows.\n//\n// For example, consider a width 10, height 4, stride 10 table. Mark its first\n// and last (inclusive) elements with 'a' and 'z'. This function returns 40.\n//\n// a123456789\n// 0123456789\n// 0123456789\n// 012345678z\n//\n// Now consider the sub-table of that from (2, 1) inclusive to (8, 4) exclusive.\n//\n// a123456789\n// 01iiiiiioo\n// ooiiiiiioo\n// ooiiiiii8z\n//\n// This function (called with width 6, height 3, stride 10) returns 26: 18 'i'\n// inside elements plus 8 'o' outside elements. Note that 26 is less than a\n// naive (height * stride = 30) computation. Indeed, advancing 29 elements from\n// the first 'i' would venture past 'z', out of bounds of the original table.\n//\n// It does not check for overflow, but if the arguments come from a table that\n// exists in memory and each el" +
|
||||
"ement occupies a positive number of bytes then\n// the result should be bounded by the amount of allocatable memory (which\n// shouldn't overflow SIZE_MAX).\nstatic inline size_t //\nwuffs_base__table__flattened_length(size_t width,\n size_t height,\n size_t stride) {\n if (height == 0) {\n return 0;\n }\n return ((height - 1) * stride) + width;\n}\n\n" +
|
||||
"" +
|
||||
"// ---------------- Magic Numbers\n\n// wuffs_base__magic_number_guess_fourcc guesses the file format of some data,\n// given its opening bytes. It returns a positive FourCC value on success.\n//\n// It returns zero if nothing matches its hard-coded list of 'magic numbers'.\n//\n// It returns a negative value if a longer prefix is required for a conclusive\n// result. For example, seeing a single 'B' byte is not enough to discriminate\n// the BMP and BPG image file formats.\n//\n// It does not do a full validity check. Like any guess made from a short\n// prefix of the data, it may return false positives. Data that starts with 99\n// bytes of valid JPEG followed by corruption or truncation is an invalid JPEG\n// image overall, but this function will still return WUFFS_BASE__FOURCC__JPEG.\n//\n// Another source of false positives is that some 'magic numbers' are valid\n// ASCII data. A file starting with \"GIF87a and GIF89a are the two versions of\n// GIF\" will match GIF's 'magic number' even if it's plain text, not an image.\n//" +
|
||||
"\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__MAGIC sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC int32_t //\nwuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix);\n" +
|
||||
""
|
||||
|
||||
const BaseMemoryPrivateH = "" +
|
||||
"// ---------------- Memory Allocation\n" +
|
||||
""
|
||||
|
||||
const BaseMemoryPublicH = "" +
|
||||
"// ---------------- Memory Allocation\n\n// The memory allocation related functions in this section aren't used by Wuffs\n// per se, but they may be helpful to the code that uses Wuffs.\n\n// wuffs_base__malloc_slice_uxx wraps calling a malloc-like function, except\n// that it takes a uint64_t number of elements instead of a size_t size in\n// bytes, and it returns a slice (a pointer and a length) instead of just a\n// pointer.\n//\n// You can pass the C stdlib's malloc as the malloc_func.\n//\n// It returns an empty slice (containing a NULL ptr field) if (num_uxx *\n// sizeof(uintxx_t)) would overflow SIZE_MAX.\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) {\n if (malloc_func && (num_u8 <= (SIZE_MAX / sizeof(uint8_t)))) {\n void* p = (*malloc_func)((size_t)(num_u8 * sizeof(uint8_t)));\n if (p) {\n return wuffs_base__make_slice_u8((uint8_t*)(p), (size_t)num_u8);\n }\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\nstatic inline wuffs_base__s" +
|
||||
"lice_u16 //\nwuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) {\n if (malloc_func && (num_u16 <= (SIZE_MAX / sizeof(uint16_t)))) {\n void* p = (*malloc_func)((size_t)(num_u16 * sizeof(uint16_t)));\n if (p) {\n return wuffs_base__make_slice_u16((uint16_t*)(p), (size_t)num_u16);\n }\n }\n return wuffs_base__make_slice_u16(NULL, 0);\n}\n\nstatic inline wuffs_base__slice_u32 //\nwuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) {\n if (malloc_func && (num_u32 <= (SIZE_MAX / sizeof(uint32_t)))) {\n void* p = (*malloc_func)((size_t)(num_u32 * sizeof(uint32_t)));\n if (p) {\n return wuffs_base__make_slice_u32((uint32_t*)(p), (size_t)num_u32);\n }\n }\n return wuffs_base__make_slice_u32(NULL, 0);\n}\n\nstatic inline wuffs_base__slice_u64 //\nwuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) {\n if (malloc_func && (num_u64 <= (SIZE_MAX / sizeof(uint64_t)))) {\n void* p = (*malloc_func)((size_t)(num_u64 * sizeof(uint64_t))" +
|
||||
");\n if (p) {\n return wuffs_base__make_slice_u64((uint64_t*)(p), (size_t)num_u64);\n }\n }\n return wuffs_base__make_slice_u64(NULL, 0);\n}\n" +
|
||||
""
|
||||
|
||||
const BaseImagePrivateH = "" +
|
||||
"// ---------------- Images\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__limited_swizzle_u32_interleaved_from_reader(\n const wuffs_base__pixel_swizzler* p,\n uint32_t up_to_num_pixels,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r);\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_from_reader(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r);\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n uint64_t num_pixels);\n\n" +
|
||||
"" +
|
||||
"// ---------------- Images (Utility)\n\n#define wuffs_base__utility__make_pixel_format wuffs_base__make_pixel_format\n" +
|
||||
""
|
||||
|
||||
const BaseImagePublicH = "" +
|
||||
"// ---------------- Images\n\n// wuffs_base__color_u32_argb_premul is an 8 bit per channel premultiplied\n// Alpha, Red, Green, Blue color, as a uint32_t value. Its value is always\n// 0xAARRGGBB (Alpha most significant, Blue least), regardless of endianness.\ntypedef uint32_t wuffs_base__color_u32_argb_premul;\n\n// wuffs_base__color_u32_argb_premul__is_valid returns whether c's Red, Green\n// and Blue channels are all less than or equal to its Alpha channel. c uses\n// premultiplied alpha, so 50% opaque 100% saturated red is 0x7F7F_0000 and a\n// value like 0x7F80_0000 is invalid.\nstatic inline bool //\nwuffs_base__color_u32_argb_premul__is_valid(\n wuffs_base__color_u32_argb_premul c) {\n uint32_t a = 0xFF & (c >> 24);\n uint32_t r = 0xFF & (c >> 16);\n uint32_t g = 0xFF & (c >> 8);\n uint32_t b = 0xFF & (c >> 0);\n return (a >= r) && (a >= g) && (a >= b);\n}\n\nstatic inline uint16_t //\nwuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__color_u32_argb_premul c) {\n uint32_t r5 = 0xF800 & (c >" +
|
||||
"> 8);\n uint32_t g6 = 0x07E0 & (c >> 5);\n uint32_t b5 = 0x001F & (c >> 3);\n return (uint16_t)(r5 | g6 | b5);\n}\n\nstatic inline wuffs_base__color_u32_argb_premul //\nwuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(uint16_t rgb_565) {\n uint32_t b5 = 0x1F & (rgb_565 >> 0);\n uint32_t b = (b5 << 3) | (b5 >> 2);\n uint32_t g6 = 0x3F & (rgb_565 >> 5);\n uint32_t g = (g6 << 2) | (g6 >> 4);\n uint32_t r5 = 0x1F & (rgb_565 >> 11);\n uint32_t r = (r5 << 3) | (r5 >> 2);\n return 0xFF000000 | (r << 16) | (g << 8) | (b << 0);\n}\n\nstatic inline uint8_t //\nwuffs_base__color_u32_argb_premul__as__color_u8_gray(\n wuffs_base__color_u32_argb_premul c) {\n // Work in 16-bit color.\n uint32_t cr = 0x101 * (0xFF & (c >> 16));\n uint32_t cg = 0x101 * (0xFF & (c >> 8));\n uint32_t cb = 0x101 * (0xFF & (c >> 0));\n\n // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same\n // as those given by the JFIF specification.\n //\n // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We\n //" +
|
||||
" shift by 24, not just by 16, because the return value is 8-bit color, not\n // 16-bit color.\n uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768;\n return (uint8_t)(weighted_average >> 24);\n}\n\nstatic inline uint16_t //\nwuffs_base__color_u32_argb_premul__as__color_u16_gray(\n wuffs_base__color_u32_argb_premul c) {\n // Work in 16-bit color.\n uint32_t cr = 0x101 * (0xFF & (c >> 16));\n uint32_t cg = 0x101 * (0xFF & (c >> 8));\n uint32_t cb = 0x101 * (0xFF & (c >> 0));\n\n // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same\n // as those given by the JFIF specification.\n //\n // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16).\n uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768;\n return (uint16_t)(weighted_average >> 16);\n}\n\n// wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul converts\n// from non-premultiplied alpha to premultiplied alpha.\nstatic inline wuffs_base__color_u32_argb_premul //\nwuf" +
|
||||
"fs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n uint32_t argb_nonpremul) {\n // Multiplying by 0x101 (twice, once for alpha and once for color) converts\n // from 8-bit to 16-bit color. Shifting right by 8 undoes that.\n //\n // Working in the higher bit depth can produce slightly different (and\n // arguably slightly more accurate) results. For example, given 8-bit blue\n // and alpha of 0x80 and 0x81:\n //\n // - ((0x80 * 0x81 ) / 0xFF ) = 0x40 = 0x40\n // - ((0x8080 * 0x8181) / 0xFFFF) >> 8 = 0x4101 >> 8 = 0x41\n uint32_t a = 0xFF & (argb_nonpremul >> 24);\n uint32_t a16 = a * (0x101 * 0x101);\n\n uint32_t r = 0xFF & (argb_nonpremul >> 16);\n r = ((r * a16) / 0xFFFF) >> 8;\n uint32_t g = 0xFF & (argb_nonpremul >> 8);\n g = ((g * a16) / 0xFFFF) >> 8;\n uint32_t b = 0xFF & (argb_nonpremul >> 0);\n b = ((b * a16) / 0xFFFF) >> 8;\n\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\n// wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul converts\n// from premul" +
|
||||
"tiplied alpha to non-premultiplied alpha.\nstatic inline uint32_t //\nwuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n wuffs_base__color_u32_argb_premul c) {\n uint32_t a = 0xFF & (c >> 24);\n if (a == 0xFF) {\n return c;\n } else if (a == 0) {\n return 0;\n }\n uint32_t a16 = a * 0x101;\n\n uint32_t r = 0xFF & (c >> 16);\n r = ((r * (0x101 * 0xFFFF)) / a16) >> 8;\n uint32_t g = 0xFF & (c >> 8);\n g = ((g * (0x101 * 0xFFFF)) / a16) >> 8;\n uint32_t b = 0xFF & (c >> 0);\n b = ((b * (0x101 * 0xFFFF)) / a16) >> 8;\n\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\n// wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul converts\n// from 4x16LE non-premultiplied alpha to 4x8 premultiplied alpha.\nstatic inline wuffs_base__color_u32_argb_premul //\nwuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(\n uint64_t argb_nonpremul) {\n uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48)));\n\n uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32)));\n r16 =" +
|
||||
" (r16 * a16) / 0xFFFF;\n uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16)));\n g16 = (g16 * a16) / 0xFFFF;\n uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0)));\n b16 = (b16 * a16) / 0xFFFF;\n\n return ((a16 >> 8) << 24) | ((r16 >> 8) << 16) | ((g16 >> 8) << 8) |\n ((b16 >> 8) << 0);\n}\n\n// wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul converts\n// from 4x8 premultiplied alpha to 4x16LE non-premultiplied alpha.\nstatic inline uint64_t //\nwuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul(\n wuffs_base__color_u32_argb_premul c) {\n uint32_t a = 0xFF & (c >> 24);\n if (a == 0xFF) {\n uint64_t r16 = 0x101 * (0xFF & (c >> 16));\n uint64_t g16 = 0x101 * (0xFF & (c >> 8));\n uint64_t b16 = 0x101 * (0xFF & (c >> 0));\n return 0xFFFF000000000000u | (r16 << 32) | (g16 << 16) | (b16 << 0);\n } else if (a == 0) {\n return 0;\n }\n uint64_t a16 = a * 0x101;\n\n uint64_t r = 0xFF & (c >> 16);\n uint64_t r16 = (r * (0x101 * 0xFFFF)) / a16;\n uint64_t g = 0xFF" +
|
||||
" & (c >> 8);\n uint64_t g16 = (g * (0x101 * 0xFFFF)) / a16;\n uint64_t b = 0xFF & (c >> 0);\n uint64_t b16 = (b * (0x101 * 0xFFFF)) / a16;\n\n return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__color_u32__as__color_u64(uint32_t c) {\n uint64_t a16 = 0x101 * (0xFF & (c >> 24));\n uint64_t r16 = 0x101 * (0xFF & (c >> 16));\n uint64_t g16 = 0x101 * (0xFF & (c >> 8));\n uint64_t b16 = 0x101 * (0xFF & (c >> 0));\n return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__color_u64__as__color_u32(uint64_t c) {\n uint32_t a = ((uint32_t)(0xFF & (c >> 56)));\n uint32_t r = ((uint32_t)(0xFF & (c >> 40)));\n uint32_t g = ((uint32_t)(0xFF & (c >> 24)));\n uint32_t b = ((uint32_t)(0xFF & (c >> 8)));\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef uint8_t wuffs_base__pixel_blend;\n\n// wuffs_base__pixel_blend encodes how to blend source and destination pixels,\n// accounting for transparency. It encompasses the Porter-Duff compositing\n// operators as well as the other blending modes defined by PDF.\n//\n// TODO: implement the other modes.\n#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)\n#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__pixel_alpha_transparency is a pixel format's alpha channel\n// model. It is a property of the pixel format in general, not of a specific\n// pixel. An RGBA pixel format (with alpha) can still have fully opaque pixels.\ntypedef uint32_t wuffs_base__pixel_alpha_transparency;\n\n#define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__OPAQUE 0\n#define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__NONPREMULTIPLIED_ALPHA 1\n#define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__PREMULTIPLIED_ALPHA 2\n#define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__BINARY_ALPHA 3\n\n// Deprecated: use WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__NONPREMULTIPLIED_ALPHA\n// instead.\n#define WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__NON_PREMULTIPLIED_ALPHA 1\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__INDEX_PLANE 0\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3\n\n// A palette is 256 entries × 4 bytes per entry (e.g. BGRA).\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data.\n//\n// See https://github.com/google/wuffs/blob/main/doc/note/pixel-formats.md\n//\n// Do not manipulate its bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_format__num_planes instead.\ntypedef struct wuffs_base__pixel_format__struct {\n uint32_t repr;\n\n#ifdef __cplusplus\n inline bool is_valid() const;\n inline uint32_t bits_per_pixel() const;\n inline bool is_direct() const;\n inline bool is_indexed() const;\n inline bool is_interleaved() const;\n inline bool is_planar() const;\n inline uint32_t num_planes() const;\n inline wuffs_base__pixel_alpha_tran" +
|
||||
"sparency transparency() const;\n#endif // __cplusplus\n\n} wuffs_base__pixel_format;\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__make_pixel_format(uint32_t repr) {\n wuffs_base__pixel_format f;\n f.repr = repr;\n return f;\n}\n\n// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid\n// wuffs_base__pixel_format values are present.\n\n#define WUFFS_BASE__PIXEL_FORMAT__INVALID 0x00000000\n\n#define WUFFS_BASE__PIXEL_FORMAT__A 0x02000008\n\n#define WUFFS_BASE__PIXEL_FORMAT__Y 0x20000008\n#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE 0x2000000B\n#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE 0x2010000B\n#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x21000008\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL 0x22000008\n\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCR 0x40020888\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCRA_NONPREMUL 0x41038888\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCRK 0x50038888\n\n#define WUFFS_BASE__PIXEL_FORMAT__YCOCG 0x60020888\n#define WUFFS_BASE__PIXEL_FORMAT__YCOCGA_NONPREMUL 0x61038888\n#define WUFFS" +
|
||||
"_BASE__PIXEL_FORMAT__YCOCGK 0x70038888\n\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x81040008\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x82040008\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x83040008\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR_565 0x80000565\n#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x80000888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x81008888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE 0x8100BBBB\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x82008888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE 0x8200BBBB\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x83008888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x90008888\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB 0xA0000888\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL 0xA1008888\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE 0xA100BBBB\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL 0xA2008888\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE 0xA200BBBB\n#define WUFFS_BASE__PIXEL_F" +
|
||||
"ORMAT__RGBA_BINARY 0xA3008888\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX 0xB0008888\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY 0xC0020888\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK 0xD0038888\n\nextern const uint32_t wuffs_base__pixel_format__bits_per_channel[16];\n\nstatic inline bool //\nwuffs_base__pixel_format__is_valid(const wuffs_base__pixel_format* f) {\n return f->repr != 0;\n}\n\n// wuffs_base__pixel_format__bits_per_pixel returns the number of bits per\n// pixel for interleaved pixel formats, and returns 0 for planar pixel formats.\nstatic inline uint32_t //\nwuffs_base__pixel_format__bits_per_pixel(const wuffs_base__pixel_format* f) {\n if (((f->repr >> 16) & 0x03) != 0) {\n return 0;\n }\n return wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 0)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 4)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 8)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (f->repr >> 12)];\n}\n\nstatic inline bool //\n" +
|
||||
"wuffs_base__pixel_format__is_direct(const wuffs_base__pixel_format* f) {\n return ((f->repr >> 18) & 0x01) == 0;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_indexed(const wuffs_base__pixel_format* f) {\n return ((f->repr >> 18) & 0x01) != 0;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_interleaved(const wuffs_base__pixel_format* f) {\n return ((f->repr >> 16) & 0x03) == 0;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_planar(const wuffs_base__pixel_format* f) {\n return ((f->repr >> 16) & 0x03) != 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_format__num_planes(const wuffs_base__pixel_format* f) {\n return ((f->repr >> 16) & 0x03) + 1;\n}\n\nstatic inline wuffs_base__pixel_alpha_transparency //\nwuffs_base__pixel_format__transparency(const wuffs_base__pixel_format* f) {\n return (wuffs_base__pixel_alpha_transparency)((f->repr >> 24) & 0x03);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__pixel_format::is_valid() const {\n return wuffs_base__pixel_format__is_valid(this);\n}\n\n" +
|
||||
"inline uint32_t //\nwuffs_base__pixel_format::bits_per_pixel() const {\n return wuffs_base__pixel_format__bits_per_pixel(this);\n}\n\ninline bool //\nwuffs_base__pixel_format::is_direct() const {\n return wuffs_base__pixel_format__is_direct(this);\n}\n\ninline bool //\nwuffs_base__pixel_format::is_indexed() const {\n return wuffs_base__pixel_format__is_indexed(this);\n}\n\ninline bool //\nwuffs_base__pixel_format::is_interleaved() const {\n return wuffs_base__pixel_format__is_interleaved(this);\n}\n\ninline bool //\nwuffs_base__pixel_format::is_planar() const {\n return wuffs_base__pixel_format__is_planar(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_format::num_planes() const {\n return wuffs_base__pixel_format__num_planes(this);\n}\n\ninline wuffs_base__pixel_alpha_transparency //\nwuffs_base__pixel_format::transparency() const {\n return wuffs_base__pixel_format__transparency(this);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__pixel_subsampling encodes whether sample values cover one pixel\n// or cover multiple pixels.\n//\n// See https://github.com/google/wuffs/blob/main/doc/note/pixel-subsampling.md\n//\n// Do not manipulate its bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead.\ntypedef struct wuffs_base__pixel_subsampling__struct {\n uint32_t repr;\n\n#ifdef __cplusplus\n inline uint32_t bias_x(uint32_t plane) const;\n inline uint32_t denominator_x(uint32_t plane) const;\n inline uint32_t bias_y(uint32_t plane) const;\n inline uint32_t denominator_y(uint32_t plane) const;\n#endif // __cplusplus\n\n} wuffs_base__pixel_subsampling;\n\nstatic inline wuffs_base__pixel_subsampling //\nwuffs_base__make_pixel_subsampling(uint32_t repr) {\n wuffs_base__pixel_subsampling s;\n s.repr = repr;\n return s;\n}\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__NONE 0x00000000\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 0x000000\n#define WUFFS_BASE__PIXEL_SUBSAMPLIN" +
|
||||
"G__440 0x010100\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 0x101000\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 0x111100\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 0x303000\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 0x313100\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__bias_x(const wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 6;\n return (s->repr >> shift) & 0x03;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__denominator_x(\n const wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return ((s->repr >> shift) & 0x03) + 1;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__bias_y(const wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (s->repr >> shift) & 0x03;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__denominator_y(\n con" +
|
||||
"st wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return ((s->repr >> shift) & 0x03) + 1;\n}\n\n#ifdef __cplusplus\n\ninline uint32_t //\nwuffs_base__pixel_subsampling::bias_x(uint32_t plane) const {\n return wuffs_base__pixel_subsampling__bias_x(this, plane);\n}\n\ninline uint32_t //\nwuffs_base__pixel_subsampling::denominator_x(uint32_t plane) const {\n return wuffs_base__pixel_subsampling__denominator_x(this, plane);\n}\n\ninline uint32_t //\nwuffs_base__pixel_subsampling::bias_y(uint32_t plane) const {\n return wuffs_base__pixel_subsampling__bias_y(this, plane);\n}\n\ninline uint32_t //\nwuffs_base__pixel_subsampling::denominator_y(uint32_t plane) const {\n return wuffs_base__pixel_subsampling__denominator_y(this, plane);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__pixel_config__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 wuffs_base__pixel_format pixfmt;\n wuffs_base__pixel_subsampling pixsub;\n uint32_t width;\n uint32_t height;\n } private_impl;\n\n#ifdef __cplusplus\n inline void set(uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height);\n inline void invalidate();\n inline bool is_valid() const;\n inline wuffs_base__pixel_format pixel_format() const;\n inline wuffs_base__pixel_subsampling pixel_subsampling() const;\n inline wuffs_base__rect_ie_u32 bounds() const;\n inline uint32_t width() const;\n inline uint32_t height() const;\n inline uint64_t pixbuf_len() const;\n#endif // __cplusplus\n\n} wuffs_base__pixel_config;\n\nstatic inline wuffs_base__pixel_config //\nwuffs_base__null_pixel_config() {\n wuffs_base__pixel_config ret;\n ret.private_im" +
|
||||
"pl.pixfmt.repr = 0;\n ret.private_impl.pixsub.repr = 0;\n ret.private_impl.width = 0;\n ret.private_impl.height = 0;\n return ret;\n}\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__pixel_config__set(wuffs_base__pixel_config* c,\n uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height) {\n if (!c) {\n return;\n }\n if (pixfmt_repr) {\n uint64_t wh = ((uint64_t)width) * ((uint64_t)height);\n // TODO: handle things other than 1 byte per pixel.\n if (wh <= ((uint64_t)SIZE_MAX)) {\n c->private_impl.pixfmt.repr = pixfmt_repr;\n c->private_impl.pixsub.repr = pixsub_repr;\n c->private_impl.width = width;\n c->private_impl.height = height;\n return;\n }\n }\n\n c->private_impl.pixfmt.repr = 0;\n c->private_impl.pixsub.repr = 0;\n c->private_impl.width = 0;\n c->private_impl.height = 0;\n}\n\nstatic inline void " +
|
||||
" //\nwuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) {\n if (c) {\n c->private_impl.pixfmt.repr = 0;\n c->private_impl.pixsub.repr = 0;\n c->private_impl.width = 0;\n c->private_impl.height = 0;\n }\n}\n\nstatic inline bool //\nwuffs_base__pixel_config__is_valid(const wuffs_base__pixel_config* c) {\n return c && c->private_impl.pixfmt.repr;\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_config__pixel_format(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.pixfmt : wuffs_base__make_pixel_format(0);\n}\n\nstatic inline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config__pixel_subsampling(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.pixsub : wuffs_base__make_pixel_subsampling(0);\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config__bounds(const wuffs_base__pixel_config* c) {\n if (c) {\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = c->private_impl.width;\n r" +
|
||||
"et.max_excl_y = c->private_impl.height;\n return ret;\n }\n\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = 0;\n ret.max_excl_y = 0;\n return ret;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__width(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__height(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.height : 0;\n}\n\n// TODO: this is the right API for planar (not interleaved) pixbufs? Should it\n// allow decoding into a color model different from the format's intrinsic one?\n// For example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline uint64_t //\nwuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) {\n if (!c) {\n return 0;\n }\n if (wuffs_base__pixel_format__is_planar(&c->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return 0;\n }\n uint32_t bits_per" +
|
||||
"_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&c->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return 0;\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint64_t n =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n if (n > (UINT64_MAX / bytes_per_pixel)) {\n return 0;\n }\n n *= bytes_per_pixel;\n\n if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) {\n if (n >\n (UINT64_MAX - WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) {\n return 0;\n }\n n += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n }\n\n return n;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__pixel_config::set(uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height) {\n wuffs_base__pixel_config__set(this, pixfmt_repr, pixsub_" +
|
||||
"repr, width, height);\n}\n\ninline void //\nwuffs_base__pixel_config::invalidate() {\n wuffs_base__pixel_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__pixel_config::is_valid() const {\n return wuffs_base__pixel_config__is_valid(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_config::pixel_format() const {\n return wuffs_base__pixel_config__pixel_format(this);\n}\n\ninline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config::pixel_subsampling() const {\n return wuffs_base__pixel_config__pixel_subsampling(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config::bounds() const {\n return wuffs_base__pixel_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::width() const {\n return wuffs_base__pixel_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::height() const {\n return wuffs_base__pixel_config__height(this);\n}\n\ninline uint64_t //\nwuffs_base__pixel_config::pixbuf_len() const {\n return wuffs_base__pixel_config__pixbuf_len(this);" +
|
||||
"\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__image_config__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 uint64_t first_frame_io_position;\n bool first_frame_is_opaque;\n } private_impl;\n\n#ifdef __cplusplus\n inline void set(uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque);\n inline void invalidate();\n inline bool is_valid() const;\n inline uint64_t first_frame_io_position() const;\n inline bool first_frame_is_opaque() const;\n#endif // __cplusplus\n\n} wuffs_base__image_config;\n\nstatic inline wuffs_base__image_config //\nwuffs_base__null_image_config() {\n wuffs_base__image_config ret;\n ret.pixcfg = wuffs_base__null_pixel_config();\n ret.private_impl.first_frame_io_position = 0;\n ret.private_im" +
|
||||
"pl.first_frame_is_opaque = false;\n return ret;\n}\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__image_config__set(wuffs_base__image_config* c,\n uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n if (!c) {\n return;\n }\n if (pixfmt_repr) {\n c->pixcfg.private_impl.pixfmt.repr = pixfmt_repr;\n c->pixcfg.private_impl.pixsub.repr = pixsub_repr;\n c->pixcfg.private_impl.width = width;\n c->pixcfg.private_impl.height = height;\n c->private_impl.first_frame_io_position = first_frame_io_position;\n c->private_impl.first_frame_is_opaque = first_frame_is_opaque;\n return;\n }\n\n c->pixcfg.private_impl.pixfmt.repr = 0;\n c->pixcfg.private_impl.pixsub.repr = 0;\n c->pixcfg.private_impl.width" +
|
||||
" = 0;\n c->pixcfg.private_impl.height = 0;\n c->private_impl.first_frame_io_position = 0;\n c->private_impl.first_frame_is_opaque = 0;\n}\n\nstatic inline void //\nwuffs_base__image_config__invalidate(wuffs_base__image_config* c) {\n if (c) {\n c->pixcfg.private_impl.pixfmt.repr = 0;\n c->pixcfg.private_impl.pixsub.repr = 0;\n c->pixcfg.private_impl.width = 0;\n c->pixcfg.private_impl.height = 0;\n c->private_impl.first_frame_io_position = 0;\n c->private_impl.first_frame_is_opaque = 0;\n }\n}\n\nstatic inline bool //\nwuffs_base__image_config__is_valid(const wuffs_base__image_config* c) {\n return c && wuffs_base__pixel_config__is_valid(&(c->pixcfg));\n}\n\nstatic inline uint64_t //\nwuffs_base__image_config__first_frame_io_position(\n const wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_io_position : 0;\n}\n\nstatic inline bool //\nwuffs_base__image_config__first_frame_is_opaque(\n const wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_is_opaque : false;\n}" +
|
||||
"\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__image_config::set(uint32_t pixfmt_repr,\n uint32_t pixsub_repr,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n wuffs_base__image_config__set(this, pixfmt_repr, pixsub_repr, width, height,\n first_frame_io_position, first_frame_is_opaque);\n}\n\ninline void //\nwuffs_base__image_config::invalidate() {\n wuffs_base__image_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__image_config::is_valid() const {\n return wuffs_base__image_config__is_valid(this);\n}\n\ninline uint64_t //\nwuffs_base__image_config::first_frame_io_position() const {\n return wuffs_base__image_config__first_frame_io_position(this);\n}\n\ninline bool //\nwuffs_base__image_config::first_frame_is_opaque() const {\n return wuffs_base__image_config__first_frame_is_opaque(t" +
|
||||
"his);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__animation_disposal encodes, for an animated image, how to\n// dispose of a frame after displaying it:\n// - None means to draw the next frame on top of this one.\n// - Restore Background means to clear the frame's dirty rectangle to \"the\n// background color\" (in practice, this means transparent black) before\n// drawing the next frame.\n// - Restore Previous means to undo the current frame, so that the next frame\n// is drawn on top of the previous one.\ntypedef uint8_t wuffs_base__animation_disposal;\n\n#define WUFFS_BASE__ANIMATION_DISPOSAL__NONE ((wuffs_base__animation_disposal)0)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND \\\n ((wuffs_base__animation_disposal)1)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS \\\n ((wuffs_base__animation_disposal)2)\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__frame_config__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 wuffs_base__rect_ie_u32 bounds;\n wuffs_base__flicks duration;\n uint64_t index;\n uint64_t io_position;\n wuffs_base__animation_disposal disposal;\n bool opaque_within_bounds;\n bool overwrite_instead_of_blend;\n wuffs_base__color_u32_argb_premul background_color;\n } private_impl;\n\n#ifdef __cplusplus\n inline void set(wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_t io_position,\n wuffs_base__animation_disposal disposal,\n bool opaque_within_bounds,\n bool overwrite_instead_of_blend,\n wuffs_base__color_u32_argb_premul background_color);\n inline wuffs_base__rect_ie_u32 bounds() const;\n inline uint32_t width() const;\n inline uint32_t hei" +
|
||||
"ght() const;\n inline wuffs_base__flicks duration() const;\n inline uint64_t index() const;\n inline uint64_t io_position() const;\n inline wuffs_base__animation_disposal disposal() const;\n inline bool opaque_within_bounds() const;\n inline bool overwrite_instead_of_blend() const;\n inline wuffs_base__color_u32_argb_premul background_color() const;\n#endif // __cplusplus\n\n} wuffs_base__frame_config;\n\nstatic inline wuffs_base__frame_config //\nwuffs_base__null_frame_config() {\n wuffs_base__frame_config ret;\n ret.private_impl.bounds = wuffs_base__make_rect_ie_u32(0, 0, 0, 0);\n ret.private_impl.duration = 0;\n ret.private_impl.index = 0;\n ret.private_impl.io_position = 0;\n ret.private_impl.disposal = 0;\n ret.private_impl.opaque_within_bounds = false;\n ret.private_impl.overwrite_instead_of_blend = false;\n return ret;\n}\n\nstatic inline void //\nwuffs_base__frame_config__set(\n wuffs_base__frame_config* c,\n wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_" +
|
||||
"t io_position,\n wuffs_base__animation_disposal disposal,\n bool opaque_within_bounds,\n bool overwrite_instead_of_blend,\n wuffs_base__color_u32_argb_premul background_color) {\n if (!c) {\n return;\n }\n\n c->private_impl.bounds = bounds;\n c->private_impl.duration = duration;\n c->private_impl.index = index;\n c->private_impl.io_position = io_position;\n c->private_impl.disposal = disposal;\n c->private_impl.opaque_within_bounds = opaque_within_bounds;\n c->private_impl.overwrite_instead_of_blend = overwrite_instead_of_blend;\n c->private_impl.background_color = background_color;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__frame_config__bounds(const wuffs_base__frame_config* c) {\n if (c) {\n return c->private_impl.bounds;\n }\n\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = 0;\n ret.max_excl_y = 0;\n return ret;\n}\n\nstatic inline uint32_t //\nwuffs_base__frame_config__width(const wuffs_base__frame_config* c) {\n return c ? wuffs_base__re" +
|
||||
"ct_ie_u32__width(&c->private_impl.bounds) : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__frame_config__height(const wuffs_base__frame_config* c) {\n return c ? wuffs_base__rect_ie_u32__height(&c->private_impl.bounds) : 0;\n}\n\n// wuffs_base__frame_config__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks //\nwuffs_base__frame_config__duration(const wuffs_base__frame_config* c) {\n return c ? c->private_impl.duration : 0;\n}\n\n// wuffs_base__frame_config__index returns the index of this frame. The first\n// frame in an image has index 0, the second frame has index 1, and so on.\nstatic inline uint64_t //\nwuffs_base__frame_config__index(const wuffs_base__frame_config* c) {\n return c ? c->private_impl.index : 0;\n}\n\n// wuffs_base__frame_config__io_position returns the I/O stream position before\n// the frame config.\nstatic inline uint64_t //\nwuffs_base__frame_config__io_position(const wuffs_base__frame_config* c" +
|
||||
") {\n return c ? c->private_impl.io_position : 0;\n}\n\n// wuffs_base__frame_config__disposal returns, for an animated image, how to\n// dispose of this frame after displaying it.\nstatic inline wuffs_base__animation_disposal //\nwuffs_base__frame_config__disposal(const wuffs_base__frame_config* c) {\n return c ? c->private_impl.disposal : 0;\n}\n\n// wuffs_base__frame_config__opaque_within_bounds returns whether all pixels\n// within the frame's bounds are fully opaque. It makes no claim about pixels\n// outside the frame bounds but still inside the overall image. The two\n// bounding rectangles can differ for animated images.\n//\n// Its semantics are conservative. It is valid for a fully opaque frame to have\n// this value be false: a false negative.\n//\n// If true, drawing the frame with WUFFS_BASE__PIXEL_BLEND__SRC and\n// WUFFS_BASE__PIXEL_BLEND__SRC_OVER should be equivalent, in terms of\n// resultant pixels, but the former may be faster.\nstatic inline bool //\nwuffs_base__frame_config__opaque_within_bounds(\n const " +
|
||||
"wuffs_base__frame_config* c) {\n return c && c->private_impl.opaque_within_bounds;\n}\n\n// wuffs_base__frame_config__overwrite_instead_of_blend returns, for an\n// animated image, whether to ignore the previous image state (within the frame\n// bounds) when drawing this incremental frame. Equivalently, whether to use\n// WUFFS_BASE__PIXEL_BLEND__SRC instead of WUFFS_BASE__PIXEL_BLEND__SRC_OVER.\n//\n// The WebP spec (https://developers.google.com/speed/webp/docs/riff_container)\n// calls this the \"Blending method\" bit. WebP's \"Do not blend\" corresponds to\n// Wuffs' \"overwrite_instead_of_blend\".\nstatic inline bool //\nwuffs_base__frame_config__overwrite_instead_of_blend(\n const wuffs_base__frame_config* c) {\n return c && c->private_impl.overwrite_instead_of_blend;\n}\n\nstatic inline wuffs_base__color_u32_argb_premul //\nwuffs_base__frame_config__background_color(const wuffs_base__frame_config* c) {\n return c ? c->private_impl.background_color : 0;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__frame_config::set" +
|
||||
"(\n wuffs_base__rect_ie_u32 bounds,\n wuffs_base__flicks duration,\n uint64_t index,\n uint64_t io_position,\n wuffs_base__animation_disposal disposal,\n bool opaque_within_bounds,\n bool overwrite_instead_of_blend,\n wuffs_base__color_u32_argb_premul background_color) {\n wuffs_base__frame_config__set(this, bounds, duration, index, io_position,\n disposal, opaque_within_bounds,\n overwrite_instead_of_blend, background_color);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__frame_config::bounds() const {\n return wuffs_base__frame_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__frame_config::width() const {\n return wuffs_base__frame_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__frame_config::height() const {\n return wuffs_base__frame_config__height(this);\n}\n\ninline wuffs_base__flicks //\nwuffs_base__frame_config::duration() const {\n return wuffs_base__frame_config__duration(this);\n}\n\ninline uint64_t //\nwuffs_b" +
|
||||
"ase__frame_config::index() const {\n return wuffs_base__frame_config__index(this);\n}\n\ninline uint64_t //\nwuffs_base__frame_config::io_position() const {\n return wuffs_base__frame_config__io_position(this);\n}\n\ninline wuffs_base__animation_disposal //\nwuffs_base__frame_config::disposal() const {\n return wuffs_base__frame_config__disposal(this);\n}\n\ninline bool //\nwuffs_base__frame_config::opaque_within_bounds() const {\n return wuffs_base__frame_config__opaque_within_bounds(this);\n}\n\ninline bool //\nwuffs_base__frame_config::overwrite_instead_of_blend() const {\n return wuffs_base__frame_config__overwrite_instead_of_blend(this);\n}\n\ninline wuffs_base__color_u32_argb_premul //\nwuffs_base__frame_config::background_color() const {\n return wuffs_base__frame_config__background_color(this);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__pixel_buffer__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_interleaved(\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 primary_memory,\n wuffs_base__slice_u8 palette_memory);\n inline wuffs_base__status set_from_slice(\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory);\n inline wuffs_base__status set_from_table(\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 primary_memory);\n inline wuffs_base__slice_u8 palette();\n inline wuffs_base__slice_u8 palette_or_else(wuffs_base__slice_u8 fallback);\n inline wuffs_base__pixel_format pixel_format() const;\n inline wuffs_base__table" +
|
||||
"_u8 plane(uint32_t p);\n inline wuffs_base__color_u32_argb_premul color_u32_at(uint32_t x,\n uint32_t y) const;\n inline wuffs_base__status set_color_u32_at(\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color);\n inline wuffs_base__status set_color_u32_fill_rect(\n wuffs_base__rect_ie_u32 rect,\n wuffs_base__color_u32_argb_premul color);\n#endif // __cplusplus\n\n} wuffs_base__pixel_buffer;\n\nstatic inline wuffs_base__pixel_buffer //\nwuffs_base__null_pixel_buffer() {\n wuffs_base__pixel_buffer ret;\n ret.pixcfg = wuffs_base__null_pixel_config();\n ret.private_impl.planes[0] = wuffs_base__empty_table_u8();\n ret.private_impl.planes[1] = wuffs_base__empty_table_u8();\n ret.private_impl.planes[2] = wuffs_base__empty_table_u8();\n ret.private_impl.planes[3] = wuffs_base__empty_table_u8();\n return ret;\n}\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_interleaved(\n wuffs_base__pixel_buffer* pb,\n co" +
|
||||
"nst wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 primary_memory,\n wuffs_base__slice_u8 palette_memory) {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n memset(pb, 0, sizeof(*pb));\n if (!pixcfg ||\n wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt) &&\n (palette_memory.len <\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) {\n return wuffs_base__make_status(\n wuffs_base__error__bad_argument_length_too_short);\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint64_t bytes_per_pixel = bits_per" +
|
||||
"_pixel / 8;\n\n uint64_t width_in_bytes =\n ((uint64_t)pixcfg->private_impl.width) * bytes_per_pixel;\n if ((width_in_bytes > primary_memory.width) ||\n (pixcfg->private_impl.height > primary_memory.height)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n pb->pixcfg = *pixcfg;\n pb->private_impl.planes[0] = primary_memory;\n if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &pb->private_impl\n .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n tab->ptr = palette_memory.ptr;\n tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n tab->height = 1;\n tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n }\n return wuffs_base__make_status(NULL);\n}\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* pb,\n const wuffs_base__pixel_config* pixcfg,\n " +
|
||||
" wuffs_base__slice_u8 pixbuf_memory) {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n memset(pb, 0, sizeof(*pb));\n if (!pixcfg) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n if (wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\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 WU" +
|
||||
"FFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH byte\n // chunk (1024 bytes = 256 palette entries × 4 bytes per entry) from the\n // start of pixbuf_memory. We split from the start, not the end, so that\n // the both chunks' pointers have the same alignment as the original\n // pointer, up to an alignment of 1024.\n if (len < WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return wuffs_base__make_status(\n wuffs_base__error__bad_argument_length_too_short);\n }\n wuffs_base__table_u8* tab =\n &pb->private_impl\n .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n tab->ptr = ptr;\n tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n tab->height = 1;\n tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n ptr += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n len -= WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;\n }\n\n uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n " +
|
||||
" ((uint64_t)pixcfg->private_impl.height);\n size_t width = (size_t)(pixcfg->private_impl.width);\n if ((wh > (UINT64_MAX / bytes_per_pixel)) ||\n (width > (SIZE_MAX / bytes_per_pixel))) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n wh *= bytes_per_pixel;\n width = ((size_t)(width * bytes_per_pixel));\n if (wh > len) {\n return wuffs_base__make_status(\n wuffs_base__error__bad_argument_length_too_short);\n }\n\n pb->pixcfg = *pixcfg;\n wuffs_base__table_u8* tab = &pb->private_impl.planes[0];\n tab->ptr = ptr;\n tab->width = width;\n tab->height = pixcfg->private_impl.height;\n tab->stride = width;\n return wuffs_base__make_status(NULL);\n}\n\n// Deprecated: does not handle indexed pixel configurations. Use\n// wuffs_base__pixel_buffer__set_interleaved instead.\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* pb,\n const wuffs_base__pixel_config* pixcfg,\n " +
|
||||
" wuffs_base__table_u8 primary_memory) {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n memset(pb, 0, sizeof(*pb));\n if (!pixcfg ||\n wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt) ||\n wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint64_t width_in_bytes =\n ((uint64_t)pixcfg->private_impl.width) * bytes_per_pixel;\n if ((width_in_bytes > primary_memory.width) ||\n (pixcfg->private_impl.height > primary_memory.height)) {\n return wuffs_base__make_status(" +
|
||||
"wuffs_base__error__bad_argument);\n }\n\n pb->pixcfg = *pixcfg;\n pb->private_impl.planes[0] = primary_memory;\n return wuffs_base__make_status(NULL);\n}\n\n// wuffs_base__pixel_buffer__palette returns the palette color data. If\n// non-empty, it will have length\n// WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* pb) {\n if (pb &&\n wuffs_base__pixel_format__is_indexed(&pb->pixcfg.private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &pb->private_impl\n .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n if ((tab->width ==\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) &&\n (tab->height == 1)) {\n return wuffs_base__make_slice_u8(\n tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH);\n }\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette_or_else(wuffs" +
|
||||
"_base__pixel_buffer* pb,\n wuffs_base__slice_u8 fallback) {\n if (pb &&\n wuffs_base__pixel_format__is_indexed(&pb->pixcfg.private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &pb->private_impl\n .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n if ((tab->width ==\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) &&\n (tab->height == 1)) {\n return wuffs_base__make_slice_u8(\n tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH);\n }\n }\n return fallback;\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer__pixel_format(const wuffs_base__pixel_buffer* pb) {\n if (pb) {\n return pb->pixcfg.private_impl.pixfmt;\n }\n return wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__INVALID);\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* pb, uint32_t p) {\n if (pb && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) {\n " +
|
||||
" return pb->private_impl.planes[p];\n }\n\n wuffs_base__table_u8 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__color_u32_argb_premul //\nwuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* pb,\n uint32_t x,\n uint32_t y);\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_at(\n wuffs_base__pixel_buffer* pb,\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color);\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n wuffs_base__color_u32_argb_premul color);\n\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_interleaved(\n const wuffs_base__pixel_config* pixcfg_arg,\n wuffs_base__table_u8 primary_memory,\n wuffs_base__slice_" +
|
||||
"u8 palette_memory) {\n return wuffs_base__pixel_buffer__set_interleaved(\n this, pixcfg_arg, primary_memory, palette_memory);\n}\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_slice(\n const wuffs_base__pixel_config* pixcfg_arg,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg_arg,\n pixbuf_memory);\n}\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_table(\n const wuffs_base__pixel_config* pixcfg_arg,\n wuffs_base__table_u8 primary_memory) {\n return wuffs_base__pixel_buffer__set_from_table(this, pixcfg_arg,\n primary_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__slice_u8 //\nwuffs_base__pixel_buffer::palette_or_else(wuffs_base__slice_u8 fallback) {\n return wuffs_base__pixel_buffer__palette_or_else(this, fall" +
|
||||
"back);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer::pixel_format() const {\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\ninline wuffs_base__color_u32_argb_premul //\nwuffs_base__pixel_buffer::color_u32_at(uint32_t x, uint32_t y) const {\n return wuffs_base__pixel_buffer__color_u32_at(this, x, y);\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n wuffs_base__color_u32_argb_premul color);\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_color_u32_at(\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color) {\n return wuffs_base__pixel_buffer__set_color_u32_at(this, x, y, color);\n}\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_color_u32_fill_rect(\n wuffs_base__rect_ie_u32 rect,\n " +
|
||||
" wuffs_base__color_u32_argb_premul color) {\n return wuffs_base__pixel_buffer__set_color_u32_fill_rect(this, rect, color);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__decode_frame_options__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\n// wuffs_base__pixel_palette__closest_element returns the index of the palette\n// element that minimizes the sum of squared differences of the four ARGB\n// channels, working in premultiplied alpha. Ties favor the smaller index.\n//\n// The palette_slice.len may equal (N*4), for N less than 256, which means that\n// only the first N palette elements are considered. It returns 0 when N is 0.\n//\n// Applying this function on a per-pixel basis will not produce whole-of-image\n// dithering.\nWUFFS_BASE__MAYBE_STATIC uint8_t //\nwuffs_base__pixel_palette__closest_element(\n wuffs_base__slice_u8 palette_slice,\n wuffs_base__pixel_format palette_format,\n wuffs_base__color_u32_argb_premul c);\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// TODO: should the func type take restrict pointers?\ntypedef uint64_t (*wuffs_base__pixel_swizzler__func)(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len);\n\ntypedef uint64_t (*wuffs_base__pixel_swizzler__transparent_black_func)(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n uint64_t num_pixels,\n uint32_t dst_pixfmt_bytes_per_pixel);\n\ntypedef struct wuffs_base__pixel_swizzler__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 wuffs_base__pixel_swizzler__func func;\n wuffs_base__pixel_swizzler__transpa" +
|
||||
"rent_black_func transparent_black_func;\n uint32_t dst_pixfmt_bytes_per_pixel;\n uint32_t src_pixfmt_bytes_per_pixel;\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status prepare(wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__pixel_format src_pixfmt,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend);\n inline uint64_t swizzle_interleaved_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) const;\n#endif // __cplusplus\n\n} wuffs_base__pixel_swizzler;\n\n// wuffs_base__pixel_swizzler__prepare readies the pixel swizzler so that its\n// other methods may be called.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__PIXCONV sub-module, not\n// just WUFFS_CONFIG__MOD" +
|
||||
"ULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__pixel_format src_pixfmt,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend);\n\n// wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice converts pixels\n// from a source format to a destination format.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__PIXCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n " +
|
||||
" wuffs_base__slice_u8 src);\n\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_swizzler::prepare(wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__pixel_format src_pixfmt,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n return wuffs_base__pixel_swizzler__prepare(this, dst_pixfmt, dst_palette,\n src_pixfmt, src_palette, blend);\n}\n\nuint64_t //\nwuffs_base__pixel_swizzler::swizzle_interleaved_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) const {\n return wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(\n this, dst, dst_palette, src);\n}\n\n#endif // __cplusplus\n" +
|
||||
""
|
||||
|
||||
const BaseIOPrivateH = "" +
|
||||
"// ---------------- I/O\n\nstatic inline uint64_t //\nwuffs_base__io__count_since(uint64_t mark, uint64_t index) {\n if (index >= mark) {\n return index - mark;\n }\n return 0;\n}\n\n// TODO: drop the \"const\" in \"const uint8_t* ptr\". Some though required about\n// the base.io_reader.since method returning a mutable \"slice base.u8\".\n#if defined(__GNUC__)\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wcast-qual\"\n#endif\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__io__since(uint64_t mark, uint64_t index, const uint8_t* ptr) {\n if (index >= mark) {\n return wuffs_base__make_slice_u8(((uint8_t*)ptr) + mark,\n ((size_t)(index - mark)));\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n#if defined(__GNUC__)\n#pragma GCC diagnostic pop\n#endif\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic inline void //\nwuffs_base__io_reader__limit(const uint8_t** ptr_io2_r,\n const uint8_t* iop_r,\n uint64_t limit) {\n if (((uint64_t)(*ptr_io2_r - iop_r)) > limit) {\n *ptr_io2_r = iop_r + limit;\n }\n}\n\nstatic inline uint32_t //\nwuffs_base__io_reader__limited_copy_u32_to_slice(const uint8_t** ptr_iop_r,\n const uint8_t* io2_r,\n uint32_t length,\n wuffs_base__slice_u8 dst) {\n const uint8_t* iop_r = *ptr_iop_r;\n size_t n = dst.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(io2_r - iop_r))) {\n n = (size_t)(io2_r - iop_r);\n }\n if (n > 0) {\n memmove(dst.ptr, iop_r, n);\n *ptr_iop_r += n;\n }\n return (uint32_t)(n);\n}\n\n// wuffs_base__io_reader__match7 returns whether the io_reader's upcoming bytes\n// start with the given prefix (up to 7 bytes long). It is peek-like, not\n" +
|
||||
"// read-like, in that there are no side-effects.\n//\n// The low 3 bits of a hold the prefix length, n.\n//\n// The high 56 bits of a hold the prefix itself, in little-endian order. The\n// first prefix byte is in bits 8..=15, the second prefix byte is in bits\n// 16..=23, etc. The high (8 * (7 - n)) bits are ignored.\n//\n// There are three possible return values:\n// - 0 means success.\n// - 1 means inconclusive, equivalent to \"$short read\".\n// - 2 means failure.\nstatic inline uint32_t //\nwuffs_base__io_reader__match7(const uint8_t* iop_r,\n const uint8_t* io2_r,\n wuffs_base__io_buffer* r,\n uint64_t a) {\n uint32_t n = a & 7;\n a >>= 8;\n if ((io2_r - iop_r) >= 8) {\n uint64_t x = wuffs_base__peek_u64le__no_bounds_check(iop_r);\n uint32_t shift = 8 * (8 - n);\n return ((a << shift) == (x << shift)) ? 0 : 2;\n }\n for (; n > 0; n--) {\n if (iop_r >= io2_r) {\n return (r && r->meta.closed) ? 2 : 1;\n } else if (*iop_" +
|
||||
"r != ((uint8_t)(a))) {\n return 2;\n }\n iop_r++;\n a >>= 8;\n }\n return 0;\n}\n\nstatic inline wuffs_base__io_buffer* //\nwuffs_base__io_reader__set(wuffs_base__io_buffer* b,\n const uint8_t** ptr_iop_r,\n const uint8_t** ptr_io0_r,\n const uint8_t** ptr_io1_r,\n const uint8_t** ptr_io2_r,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = data.len;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n *ptr_iop_r = data.ptr;\n *ptr_io0_r = data.ptr;\n *ptr_io1_r = data.ptr;\n *ptr_io2_r = data.ptr + data.len;\n\n return b;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic inline uint64_t //\nwuffs_base__io_writer__copy_from_slice(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n wuffs_base__slice_u8 src) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = src.len;\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n if (n > 0) {\n memmove(iop_w, src.ptr, n);\n *ptr_iop_w += n;\n }\n return (uint64_t)(n);\n}\n\nstatic inline void //\nwuffs_base__io_writer__limit(uint8_t** ptr_io2_w,\n uint8_t* iop_w,\n uint64_t limit) {\n if (((uint64_t)(*ptr_io2_w - iop_w)) > limit) {\n *ptr_io2_w = iop_w + limit;\n }\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n " +
|
||||
" uint32_t distance) {\n if (!distance) {\n return 0;\n }\n uint8_t* p = *ptr_iop_w;\n if ((size_t)(p - io1_w) < (size_t)(distance)) {\n return 0;\n }\n uint8_t* q = p - distance;\n size_t n = (size_t)(io2_w - p);\n if ((size_t)(length) > n) {\n length = (uint32_t)(n);\n } else {\n n = (size_t)(length);\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // limited_copy_u32_from_history Wuffs method should also take an unroll hint\n // argument, and the cgen can look if that argument is the constant\n // expression '3'.\n //\n // See also wuffs_base__io_writer__limited_copy_u32_from_history_fast below.\n for (; n >= 3; n -= 3) {\n *p++ = *q++;\n *p++ = *q++;\n *p++ = *q++;\n }\n for (; n; n--) {\n *p++ = *q++;\n }\n *ptr_iop_w = p;\n return length;\n}\n\n// wuffs_base__io_w" +
|
||||
"riter__limited_copy_u32_from_history_fast is like the\n// wuffs_base__io_writer__limited_copy_u32_from_history function above, but has\n// stronger pre-conditions.\n//\n// The caller needs to prove that:\n// - length <= (io2_w - *ptr_iop_w)\n// - distance >= 1\n// - distance <= (*ptr_iop_w - io1_w)\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n uint32_t distance) {\n uint8_t* p = *ptr_iop_w;\n uint8_t* q = p - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *p++ = *q++;\n *p++ = *q++;\n *p++ = *q++;\n }\n for (; n; n--) {\n *p++ = *q++;\n }\n *ptr_iop_w = p;\n return length;\n}\n\n// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_dist" +
|
||||
"ance_1_fast\n// copies the previous byte (the one immediately before *ptr_iop_w), copying 8\n// byte chunks at a time. Each chunk contains 8 repetitions of the same byte.\n//\n// In terms of number of bytes copied, length is rounded up to a multiple of 8.\n// As a special case, a zero length rounds up to 8 (even though 0 is already a\n// multiple of 8), since there is always at least one 8 byte chunk copied.\n//\n// In terms of advancing *ptr_iop_w, length is not rounded up.\n//\n// The caller needs to prove that:\n// - (length + 8) <= (io2_w - *ptr_iop_w)\n// - distance == 1\n// - distance <= (*ptr_iop_w - io1_w)\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(\n uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n uint32_t distance) {\n uint8_t* p = *ptr_iop_w;\n uint64_t x = p[-1];\n x |= x << 8;\n x |= x << 16;\n x |= x << 32;\n uint32_t n = length;\n while (1) {\n wuffs_base__poke_u64le__no_bounds_check(" +
|
||||
"p, x);\n if (n <= 8) {\n p += n;\n break;\n }\n p += 8;\n n -= 8;\n }\n *ptr_iop_w = p;\n return length;\n}\n\n// wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast is\n// like the wuffs_base__io_writer__limited_copy_u32_from_history_fast function\n// above, but copies 8 byte chunks at a time.\n//\n// In terms of number of bytes copied, length is rounded up to a multiple of 8.\n// As a special case, a zero length rounds up to 8 (even though 0 is already a\n// multiple of 8), since there is always at least one 8 byte chunk copied.\n//\n// In terms of advancing *ptr_iop_w, length is not rounded up.\n//\n// The caller needs to prove that:\n// - (length + 8) <= (io2_w - *ptr_iop_w)\n// - distance >= 8\n// - distance <= (*ptr_iop_w - io1_w)\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(\n uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n uint32_t distance) {\n uint8_t* p = *ptr_iop_w;\n u" +
|
||||
"int8_t* q = p - distance;\n uint32_t n = length;\n while (1) {\n memcpy(p, q, 8);\n if (n <= 8) {\n p += n;\n break;\n }\n p += 8;\n q += 8;\n n -= 8;\n }\n *ptr_iop_w = p;\n return length;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_copy_u32_from_reader(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n uint32_t length,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = length;\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n const uint8_t* iop_r = *ptr_iop_r;\n if (n > ((size_t)(io2_r - iop_r))) {\n n = (size_t)(io2_r - iop_r);\n }\n if (n > 0) {\n memmove(iop_w, iop_r, n);\n *ptr_iop_w += n;\n *ptr_iop_r += n;\n }\n return (uint32_t)(n);\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__limited_co" +
|
||||
"py_u32_from_slice(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n uint32_t length,\n wuffs_base__slice_u8 src) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n if (n > 0) {\n memmove(iop_w, src.ptr, n);\n *ptr_iop_w += n;\n }\n return (uint32_t)(n);\n}\n\nstatic inline wuffs_base__io_buffer* //\nwuffs_base__io_writer__set(wuffs_base__io_buffer* b,\n uint8_t** ptr_iop_w,\n uint8_t** ptr_io0_w,\n uint8_t** ptr_io1_w,\n uint8_t** ptr_io2_w,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = 0;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n *ptr_iop_w = data.ptr;\n *ptr_io0_w = data.ptr;\n *ptr_io1_" +
|
||||
"w = data.ptr;\n *ptr_io2_w = data.ptr + data.len;\n\n return b;\n}\n\n" +
|
||||
"" +
|
||||
"// ---------------- I/O (Utility)\n\n#define wuffs_base__utility__empty_io_reader wuffs_base__empty_io_reader\n#define wuffs_base__utility__empty_io_writer wuffs_base__empty_io_writer\n" +
|
||||
""
|
||||
|
||||
const BaseIOPublicH = "" +
|
||||
"// ---------------- I/O\n//\n// See (/doc/note/io-input-output.md).\n\n// wuffs_base__io_buffer_meta is the metadata for a wuffs_base__io_buffer's\n// data.\ntypedef struct wuffs_base__io_buffer_meta__struct {\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n uint64_t pos; // Buffer position (relative to the start of stream).\n bool closed; // No further writes are expected.\n} wuffs_base__io_buffer_meta;\n\n// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus\n// additional metadata.\n//\n// A value with all fields zero is a valid, empty buffer.\ntypedef struct wuffs_base__io_buffer__struct {\n wuffs_base__slice_u8 data;\n wuffs_base__io_buffer_meta meta;\n\n#ifdef __cplusplus\n inline bool is_valid() const;\n inline void compact();\n inline size_t reader_length() const;\n inline uint8_t* reader_pointer() const;\n inline uint64_t reader_position() const;\n inline wuffs_base__slice_u8 reader_slice() const;\n inline size_t writer_length" +
|
||||
"() const;\n inline uint8_t* writer_pointer() const;\n inline uint64_t writer_position() const;\n inline wuffs_base__slice_u8 writer_slice() const;\n\n // Deprecated: use reader_position.\n inline uint64_t reader_io_position() const;\n // Deprecated: use writer_position.\n inline uint64_t writer_io_position() const;\n#endif // __cplusplus\n\n} wuffs_base__io_buffer;\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__make_io_buffer(wuffs_base__slice_u8 data,\n wuffs_base__io_buffer_meta meta) {\n wuffs_base__io_buffer ret;\n ret.data = data;\n ret.meta = meta;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer_meta //\nwuffs_base__make_io_buffer_meta(size_t wi,\n size_t ri,\n uint64_t pos,\n bool closed) {\n wuffs_base__io_buffer_meta ret;\n ret.wi = wi;\n ret.ri = ri;\n ret.pos = pos;\n ret.closed = closed;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__ptr_u8__reader(uint8_" +
|
||||
"t* ptr, size_t len, bool closed) {\n wuffs_base__io_buffer ret;\n ret.data.ptr = ptr;\n ret.data.len = len;\n ret.meta.wi = len;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = closed;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__ptr_u8__writer(uint8_t* ptr, size_t len) {\n wuffs_base__io_buffer ret;\n ret.data.ptr = ptr;\n ret.data.len = len;\n ret.meta.wi = 0;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = false;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__slice_u8__reader(wuffs_base__slice_u8 s, bool closed) {\n wuffs_base__io_buffer ret;\n ret.data.ptr = s.ptr;\n ret.data.len = s.len;\n ret.meta.wi = s.len;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = closed;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__slice_u8__writer(wuffs_base__slice_u8 s) {\n wuffs_base__io_buffer ret;\n ret.data.ptr = s.ptr;\n ret.data.len = s.len;\n ret.meta.wi = 0;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed =" +
|
||||
" false;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer //\nwuffs_base__empty_io_buffer() {\n wuffs_base__io_buffer ret;\n ret.data.ptr = NULL;\n ret.data.len = 0;\n ret.meta.wi = 0;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = false;\n return ret;\n}\n\nstatic inline wuffs_base__io_buffer_meta //\nwuffs_base__empty_io_buffer_meta() {\n wuffs_base__io_buffer_meta ret;\n ret.wi = 0;\n ret.ri = 0;\n ret.pos = 0;\n ret.closed = false;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__io_buffer__is_valid(const wuffs_base__io_buffer* buf) {\n if (buf) {\n if (buf->data.ptr) {\n return (buf->meta.ri <= buf->meta.wi) && (buf->meta.wi <= buf->data.len);\n } else {\n return (buf->meta.ri == 0) && (buf->meta.wi == 0) && (buf->data.len == 0);\n }\n }\n return false;\n}\n\n// wuffs_base__io_buffer__compact moves any written but unread bytes to the\n// start of the buffer.\nstatic inline void //\nwuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) {\n if (!buf || (buf->meta.ri == 0)) {\n " +
|
||||
" return;\n }\n buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri);\n size_t n = buf->meta.wi - buf->meta.ri;\n if (n != 0) {\n memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, n);\n }\n buf->meta.wi = n;\n buf->meta.ri = 0;\n}\n\n// Deprecated. Use wuffs_base__io_buffer__reader_position.\nstatic inline uint64_t //\nwuffs_base__io_buffer__reader_io_position(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0;\n}\n\nstatic inline size_t //\nwuffs_base__io_buffer__reader_length(const wuffs_base__io_buffer* buf) {\n return buf ? buf->meta.wi - buf->meta.ri : 0;\n}\n\nstatic inline uint8_t* //\nwuffs_base__io_buffer__reader_pointer(const wuffs_base__io_buffer* buf) {\n return buf ? (buf->data.ptr + buf->meta.ri) : NULL;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_buffer__reader_position(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0;\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs" +
|
||||
"_base__io_buffer__reader_slice(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__make_slice_u8(buf->data.ptr + buf->meta.ri,\n buf->meta.wi - buf->meta.ri)\n : wuffs_base__empty_slice_u8();\n}\n\n// Deprecated. Use wuffs_base__io_buffer__writer_position.\nstatic inline uint64_t //\nwuffs_base__io_buffer__writer_io_position(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\nstatic inline size_t //\nwuffs_base__io_buffer__writer_length(const wuffs_base__io_buffer* buf) {\n return buf ? buf->data.len - buf->meta.wi : 0;\n}\n\nstatic inline uint8_t* //\nwuffs_base__io_buffer__writer_pointer(const wuffs_base__io_buffer* buf) {\n return buf ? (buf->data.ptr + buf->meta.wi) : NULL;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_buffer__writer_position(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\nstatic inline wuffs_base__slice_u8 //\nw" +
|
||||
"uffs_base__io_buffer__writer_slice(const wuffs_base__io_buffer* buf) {\n return buf ? wuffs_base__make_slice_u8(buf->data.ptr + buf->meta.wi,\n buf->data.len - buf->meta.wi)\n : wuffs_base__empty_slice_u8();\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__io_buffer::is_valid() const {\n return wuffs_base__io_buffer__is_valid(this);\n}\n\ninline void //\nwuffs_base__io_buffer::compact() {\n wuffs_base__io_buffer__compact(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer::reader_io_position() const {\n return wuffs_base__io_buffer__reader_io_position(this);\n}\n\ninline size_t //\nwuffs_base__io_buffer::reader_length() const {\n return wuffs_base__io_buffer__reader_length(this);\n}\n\ninline uint8_t* //\nwuffs_base__io_buffer::reader_pointer() const {\n return wuffs_base__io_buffer__reader_pointer(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer::reader_position() const {\n return wuffs_base__io_buffer__reader_position(this);\n}\n\ninline wuffs_base__slice_u8 //\nwu" +
|
||||
"ffs_base__io_buffer::reader_slice() const {\n return wuffs_base__io_buffer__reader_slice(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer::writer_io_position() const {\n return wuffs_base__io_buffer__writer_io_position(this);\n}\n\ninline size_t //\nwuffs_base__io_buffer::writer_length() const {\n return wuffs_base__io_buffer__writer_length(this);\n}\n\ninline uint8_t* //\nwuffs_base__io_buffer::writer_pointer() const {\n return wuffs_base__io_buffer__writer_pointer(this);\n}\n\ninline uint64_t //\nwuffs_base__io_buffer::writer_position() const {\n return wuffs_base__io_buffer__writer_position(this);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__io_buffer::writer_slice() const {\n return wuffs_base__io_buffer__writer_slice(this);\n}\n\n#endif // __cplusplus\n" +
|
||||
""
|
||||
|
||||
const BaseRangePrivateH = "" +
|
||||
"// ---------------- Ranges and Rects\n\nstatic inline uint32_t //\nwuffs_base__range_ii_u32__get_min_incl(const wuffs_base__range_ii_u32* r) {\n return r->min_incl;\n}\n\nstatic inline uint32_t //\nwuffs_base__range_ii_u32__get_max_incl(const wuffs_base__range_ii_u32* r) {\n return r->max_incl;\n}\n\nstatic inline uint32_t //\nwuffs_base__range_ie_u32__get_min_incl(const wuffs_base__range_ie_u32* r) {\n return r->min_incl;\n}\n\nstatic inline uint32_t //\nwuffs_base__range_ie_u32__get_max_excl(const wuffs_base__range_ie_u32* r) {\n return r->max_excl;\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ii_u64__get_min_incl(const wuffs_base__range_ii_u64* r) {\n return r->min_incl;\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ii_u64__get_max_incl(const wuffs_base__range_ii_u64* r) {\n return r->max_incl;\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ie_u64__get_min_incl(const wuffs_base__range_ie_u64* r) {\n return r->min_incl;\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ie_u64__get_max_excl(const wuffs_base__range_" +
|
||||
"ie_u64* r) {\n return r->max_excl;\n}\n\n" +
|
||||
"" +
|
||||
"// ---------------- Ranges and Rects (Utility)\n\n#define wuffs_base__utility__empty_range_ii_u32 wuffs_base__empty_range_ii_u32\n#define wuffs_base__utility__empty_range_ie_u32 wuffs_base__empty_range_ie_u32\n#define wuffs_base__utility__empty_range_ii_u64 wuffs_base__empty_range_ii_u64\n#define wuffs_base__utility__empty_range_ie_u64 wuffs_base__empty_range_ie_u64\n#define wuffs_base__utility__empty_rect_ii_u32 wuffs_base__empty_rect_ii_u32\n#define wuffs_base__utility__empty_rect_ie_u32 wuffs_base__empty_rect_ie_u32\n#define wuffs_base__utility__make_range_ii_u32 wuffs_base__make_range_ii_u32\n#define wuffs_base__utility__make_range_ie_u32 wuffs_base__make_range_ie_u32\n#define wuffs_base__utility__make_range_ii_u64 wuffs_base__make_range_ii_u64\n#define wuffs_base__utility__make_range_ie_u64 wuffs_base__make_range_ie_u64\n#define wuffs_base__utility__make_rect_ii_u32 wuffs_base__make_rect_ii_u32\n#define wuffs_base__utility__make_rect_ie_u32 wuffs_base__make_rect_ie_u32\n" +
|
||||
""
|
||||
|
||||
const BaseRangePublicH = "" +
|
||||
"// ---------------- Ranges and Rects\n\n// See https://github.com/google/wuffs/blob/main/doc/note/ranges-and-rects.md\n\ntypedef struct wuffs_base__range_ii_u32__struct {\n uint32_t min_incl;\n uint32_t max_incl;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__range_ii_u32__struct s) const;\n inline wuffs_base__range_ii_u32__struct intersect(\n wuffs_base__range_ii_u32__struct s) const;\n inline wuffs_base__range_ii_u32__struct unite(\n wuffs_base__range_ii_u32__struct s) const;\n inline bool contains(uint32_t x) const;\n inline bool contains_range(wuffs_base__range_ii_u32__struct s) const;\n#endif // __cplusplus\n\n} wuffs_base__range_ii_u32;\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__empty_range_ii_u32() {\n wuffs_base__range_ii_u32 ret;\n ret.min_incl = 0;\n ret.max_incl = 0;\n return ret;\n}\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__make_range_ii_u32(uint32_t min_incl, uint32_t max_incl) {\n wuffs_base__range_ii_u32 ret;\n ret.min_incl = min" +
|
||||
"_incl;\n ret.max_incl = max_incl;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__is_empty(const wuffs_base__range_ii_u32* r) {\n return r->min_incl > r->max_incl;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__equals(const wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u32__is_empty(r) &&\n wuffs_base__range_ii_u32__is_empty(&s));\n}\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32__intersect(const wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32__unite(const wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii" +
|
||||
"_u32 s) {\n if (wuffs_base__range_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__max(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__contains(const wuffs_base__range_ii_u32* r,\n uint32_t x) {\n return (r->min_incl <= x) && (x <= r->max_incl);\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__contains_range(const wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__equals(\n &s, wuffs_base__range_ii_u32__intersect(r, s));\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ii_u32::is_empty() const {\n return wuffs_base__range_ii_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) const {\n return wuffs_base__range_" +
|
||||
"ii_u32__equals(this, s);\n}\n\ninline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32::intersect(wuffs_base__range_ii_u32 s) const {\n return wuffs_base__range_ii_u32__intersect(this, s);\n}\n\ninline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32::unite(wuffs_base__range_ii_u32 s) const {\n return wuffs_base__range_ii_u32__unite(this, s);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::contains(uint32_t x) const {\n return wuffs_base__range_ii_u32__contains(this, x);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::contains_range(wuffs_base__range_ii_u32 s) const {\n return wuffs_base__range_ii_u32__contains_range(this, s);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__range_ie_u32__struct {\n uint32_t min_incl;\n uint32_t max_excl;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__range_ie_u32__struct s) const;\n inline wuffs_base__range_ie_u32__struct intersect(\n wuffs_base__range_ie_u32__struct s) const;\n inline wuffs_base__range_ie_u32__struct unite(\n wuffs_base__range_ie_u32__struct s) const;\n inline bool contains(uint32_t x) const;\n inline bool contains_range(wuffs_base__range_ie_u32__struct s) const;\n inline uint32_t length() const;\n#endif // __cplusplus\n\n} wuffs_base__range_ie_u32;\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__empty_range_ie_u32() {\n wuffs_base__range_ie_u32 ret;\n ret.min_incl = 0;\n ret.max_excl = 0;\n return ret;\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__make_range_ie_u32(uint32_t min_incl, uint32_t max_excl) {\n wuffs_base__range_ie_u32 ret;\n ret.min_incl = min_incl;\n ret.max_excl = max_excl;\n return ret;\n}\n\nstatic inline bool " +
|
||||
" //\nwuffs_base__range_ie_u32__is_empty(const wuffs_base__range_ie_u32* r) {\n return r->min_incl >= r->max_excl;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u32__equals(const wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u32__is_empty(r) &&\n wuffs_base__range_ie_u32__is_empty(&s));\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32__intersect(const wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n wuffs_base__range_ie_u32 t;\n t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u32__min(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32__unite(const wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n if (wuffs_base__range_ie_u32__is_empty(r)) {\n return s" +
|
||||
";\n }\n if (wuffs_base__range_ie_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ie_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u32__max(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u32__contains(const wuffs_base__range_ie_u32* r,\n uint32_t x) {\n return (r->min_incl <= x) && (x < r->max_excl);\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u32__contains_range(const wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n return wuffs_base__range_ie_u32__equals(\n &s, wuffs_base__range_ie_u32__intersect(r, s));\n}\n\nstatic inline uint32_t //\nwuffs_base__range_ie_u32__length(const wuffs_base__range_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl, r->min_incl);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ie_u32::is_empty() const {\n return wuffs_base__range_ie_u32__is_empty(this);\n}\n\ninline bool //\nwuffs" +
|
||||
"_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) const {\n return wuffs_base__range_ie_u32__equals(this, s);\n}\n\ninline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32::intersect(wuffs_base__range_ie_u32 s) const {\n return wuffs_base__range_ie_u32__intersect(this, s);\n}\n\ninline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32::unite(wuffs_base__range_ie_u32 s) const {\n return wuffs_base__range_ie_u32__unite(this, s);\n}\n\ninline bool //\nwuffs_base__range_ie_u32::contains(uint32_t x) const {\n return wuffs_base__range_ie_u32__contains(this, x);\n}\n\ninline bool //\nwuffs_base__range_ie_u32::contains_range(wuffs_base__range_ie_u32 s) const {\n return wuffs_base__range_ie_u32__contains_range(this, s);\n}\n\ninline uint32_t //\nwuffs_base__range_ie_u32::length() const {\n return wuffs_base__range_ie_u32__length(this);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__range_ii_u64__struct {\n uint64_t min_incl;\n uint64_t max_incl;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__range_ii_u64__struct s) const;\n inline wuffs_base__range_ii_u64__struct intersect(\n wuffs_base__range_ii_u64__struct s) const;\n inline wuffs_base__range_ii_u64__struct unite(\n wuffs_base__range_ii_u64__struct s) const;\n inline bool contains(uint64_t x) const;\n inline bool contains_range(wuffs_base__range_ii_u64__struct s) const;\n#endif // __cplusplus\n\n} wuffs_base__range_ii_u64;\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__empty_range_ii_u64() {\n wuffs_base__range_ii_u64 ret;\n ret.min_incl = 0;\n ret.max_incl = 0;\n return ret;\n}\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__make_range_ii_u64(uint64_t min_incl, uint64_t max_incl) {\n wuffs_base__range_ii_u64 ret;\n ret.min_incl = min_incl;\n ret.max_incl = max_incl;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u64__is_e" +
|
||||
"mpty(const wuffs_base__range_ii_u64* r) {\n return r->min_incl > r->max_incl;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u64__equals(const wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u64__is_empty(r) &&\n wuffs_base__range_ii_u64__is_empty(&s));\n}\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64__intersect(const wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n wuffs_base__range_ii_u64 t;\n t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u64__min(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64__unite(const wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n if (wuffs_base__range_ii_u64__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u6" +
|
||||
"4__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ii_u64 t;\n t.min_incl = wuffs_base__u64__min(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u64__max(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u64__contains(const wuffs_base__range_ii_u64* r,\n uint64_t x) {\n return (r->min_incl <= x) && (x <= r->max_incl);\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u64__contains_range(const wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n return wuffs_base__range_ii_u64__equals(\n &s, wuffs_base__range_ii_u64__intersect(r, s));\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ii_u64::is_empty() const {\n return wuffs_base__range_ii_u64__is_empty(this);\n}\n\ninline bool //\nwuffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) const {\n return wuffs_base__range_ii_u64__equals(this, s);\n}\n\ninline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64::intersect(wuff" +
|
||||
"s_base__range_ii_u64 s) const {\n return wuffs_base__range_ii_u64__intersect(this, s);\n}\n\ninline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64::unite(wuffs_base__range_ii_u64 s) const {\n return wuffs_base__range_ii_u64__unite(this, s);\n}\n\ninline bool //\nwuffs_base__range_ii_u64::contains(uint64_t x) const {\n return wuffs_base__range_ii_u64__contains(this, x);\n}\n\ninline bool //\nwuffs_base__range_ii_u64::contains_range(wuffs_base__range_ii_u64 s) const {\n return wuffs_base__range_ii_u64__contains_range(this, s);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__range_ie_u64__struct {\n uint64_t min_incl;\n uint64_t max_excl;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__range_ie_u64__struct s) const;\n inline wuffs_base__range_ie_u64__struct intersect(\n wuffs_base__range_ie_u64__struct s) const;\n inline wuffs_base__range_ie_u64__struct unite(\n wuffs_base__range_ie_u64__struct s) const;\n inline bool contains(uint64_t x) const;\n inline bool contains_range(wuffs_base__range_ie_u64__struct s) const;\n inline uint64_t length() const;\n#endif // __cplusplus\n\n} wuffs_base__range_ie_u64;\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__empty_range_ie_u64() {\n wuffs_base__range_ie_u64 ret;\n ret.min_incl = 0;\n ret.max_excl = 0;\n return ret;\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__make_range_ie_u64(uint64_t min_incl, uint64_t max_excl) {\n wuffs_base__range_ie_u64 ret;\n ret.min_incl = min_incl;\n ret.max_excl = max_excl;\n return ret;\n}\n\nstatic inline bool " +
|
||||
" //\nwuffs_base__range_ie_u64__is_empty(const wuffs_base__range_ie_u64* r) {\n return r->min_incl >= r->max_excl;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u64__equals(const wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u64__is_empty(r) &&\n wuffs_base__range_ie_u64__is_empty(&s));\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64__intersect(const wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n wuffs_base__range_ie_u64 t;\n t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u64__min(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64__unite(const wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n if (wuffs_base__range_ie_u64__is_empty(r)) {\n return s" +
|
||||
";\n }\n if (wuffs_base__range_ie_u64__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ie_u64 t;\n t.min_incl = wuffs_base__u64__min(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u64__max(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u64__contains(const wuffs_base__range_ie_u64* r,\n uint64_t x) {\n return (r->min_incl <= x) && (x < r->max_excl);\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u64__contains_range(const wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n return wuffs_base__range_ie_u64__equals(\n &s, wuffs_base__range_ie_u64__intersect(r, s));\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ie_u64__length(const wuffs_base__range_ie_u64* r) {\n return wuffs_base__u64__sat_sub(r->max_excl, r->min_incl);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ie_u64::is_empty() const {\n return wuffs_base__range_ie_u64__is_empty(this);\n}\n\ninline bool //\nwuffs" +
|
||||
"_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) const {\n return wuffs_base__range_ie_u64__equals(this, s);\n}\n\ninline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64::intersect(wuffs_base__range_ie_u64 s) const {\n return wuffs_base__range_ie_u64__intersect(this, s);\n}\n\ninline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64::unite(wuffs_base__range_ie_u64 s) const {\n return wuffs_base__range_ie_u64__unite(this, s);\n}\n\ninline bool //\nwuffs_base__range_ie_u64::contains(uint64_t x) const {\n return wuffs_base__range_ie_u64__contains(this, x);\n}\n\ninline bool //\nwuffs_base__range_ie_u64::contains_range(wuffs_base__range_ie_u64 s) const {\n return wuffs_base__range_ie_u64__contains_range(this, s);\n}\n\ninline uint64_t //\nwuffs_base__range_ie_u64::length() const {\n return wuffs_base__range_ie_u64__length(this);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__rect_ii_u32__struct {\n uint32_t min_incl_x;\n uint32_t min_incl_y;\n uint32_t max_incl_x;\n uint32_t max_incl_y;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__rect_ii_u32__struct s) const;\n inline wuffs_base__rect_ii_u32__struct intersect(\n wuffs_base__rect_ii_u32__struct s) const;\n inline wuffs_base__rect_ii_u32__struct unite(\n wuffs_base__rect_ii_u32__struct s) const;\n inline bool contains(uint32_t x, uint32_t y) const;\n inline bool contains_rect(wuffs_base__rect_ii_u32__struct s) const;\n#endif // __cplusplus\n\n} wuffs_base__rect_ii_u32;\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__empty_rect_ii_u32() {\n wuffs_base__rect_ii_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_incl_x = 0;\n ret.max_incl_y = 0;\n return ret;\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__make_rect_ii_u32(uint32_t min_incl_x,\n uint32_t min_incl_y,\n " +
|
||||
"uint32_t max_incl_x,\n uint32_t max_incl_y) {\n wuffs_base__rect_ii_u32 ret;\n ret.min_incl_x = min_incl_x;\n ret.min_incl_y = min_incl_y;\n ret.max_incl_x = max_incl_x;\n ret.max_incl_y = max_incl_y;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__rect_ii_u32__is_empty(const wuffs_base__rect_ii_u32* r) {\n return (r->min_incl_x > r->max_incl_x) || (r->min_incl_y > r->max_incl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ii_u32__equals(const wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&\n r->max_incl_x == s.max_incl_x && r->max_incl_y == s.max_incl_y) ||\n (wuffs_base__rect_ii_u32__is_empty(r) &&\n wuffs_base__rect_ii_u32__is_empty(&s));\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32__intersect(const wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n wuffs_base__rect_ii_u32" +
|
||||
" t;\n t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);\n t.max_incl_x = wuffs_base__u32__min(r->max_incl_x, s.max_incl_x);\n t.max_incl_y = wuffs_base__u32__min(r->max_incl_y, s.max_incl_y);\n return t;\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32__unite(const wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n if (wuffs_base__rect_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ii_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__rect_ii_u32 t;\n t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y);\n t.max_incl_x = wuffs_base__u32__max(r->max_incl_x, s.max_incl_x);\n t.max_incl_y = wuffs_base__u32__max(r->max_incl_y, s.max_incl_y);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__rect_ii_u32__contains(const wuffs_base__rect_ii_u32* r,\n " +
|
||||
" uint32_t x,\n uint32_t y) {\n return (r->min_incl_x <= x) && (x <= r->max_incl_x) && (r->min_incl_y <= y) &&\n (y <= r->max_incl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ii_u32__contains_rect(const wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n return wuffs_base__rect_ii_u32__equals(\n &s, wuffs_base__rect_ii_u32__intersect(r, s));\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__rect_ii_u32::is_empty() const {\n return wuffs_base__rect_ii_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) const {\n return wuffs_base__rect_ii_u32__equals(this, s);\n}\n\ninline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32::intersect(wuffs_base__rect_ii_u32 s) const {\n return wuffs_base__rect_ii_u32__intersect(this, s);\n}\n\ninline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32::unite(wuffs_base__rect_ii_u32 s) const {\n return wuffs_base__rect_ii_u32__unite(this, s);" +
|
||||
"\n}\n\ninline bool //\nwuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) const {\n return wuffs_base__rect_ii_u32__contains(this, x, y);\n}\n\ninline bool //\nwuffs_base__rect_ii_u32::contains_rect(wuffs_base__rect_ii_u32 s) const {\n return wuffs_base__rect_ii_u32__contains_rect(this, s);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct wuffs_base__rect_ie_u32__struct {\n uint32_t min_incl_x;\n uint32_t min_incl_y;\n uint32_t max_excl_x;\n uint32_t max_excl_y;\n\n#ifdef __cplusplus\n inline bool is_empty() const;\n inline bool equals(wuffs_base__rect_ie_u32__struct s) const;\n inline wuffs_base__rect_ie_u32__struct intersect(\n wuffs_base__rect_ie_u32__struct s) const;\n inline wuffs_base__rect_ie_u32__struct unite(\n wuffs_base__rect_ie_u32__struct s) const;\n inline bool contains(uint32_t x, uint32_t y) const;\n inline bool contains_rect(wuffs_base__rect_ie_u32__struct s) const;\n inline uint32_t width() const;\n inline uint32_t height() const;\n#endif // __cplusplus\n\n} wuffs_base__rect_ie_u32;\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__empty_rect_ie_u32() {\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = 0;\n ret.max_excl_y = 0;\n return ret;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__make_rect_ie_u32(uint32_t min_incl_x,\n " +
|
||||
" uint32_t min_incl_y,\n uint32_t max_excl_x,\n uint32_t max_excl_y) {\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = min_incl_x;\n ret.min_incl_y = min_incl_y;\n ret.max_excl_x = max_excl_x;\n ret.max_excl_y = max_excl_y;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__is_empty(const wuffs_base__rect_ie_u32* r) {\n return (r->min_incl_x >= r->max_excl_x) || (r->min_incl_y >= r->max_excl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__equals(const wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&\n r->max_excl_x == s.max_excl_x && r->max_excl_y == s.max_excl_y) ||\n (wuffs_base__rect_ie_u32__is_empty(r) &&\n wuffs_base__rect_ie_u32__is_empty(&s));\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32__intersect(const wuffs_base__rect_ie_u32* r,\n " +
|
||||
" wuffs_base__rect_ie_u32 s) {\n wuffs_base__rect_ie_u32 t;\n t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);\n t.max_excl_x = wuffs_base__u32__min(r->max_excl_x, s.max_excl_x);\n t.max_excl_y = wuffs_base__u32__min(r->max_excl_y, s.max_excl_y);\n return t;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32__unite(const wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n if (wuffs_base__rect_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ie_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__rect_ie_u32 t;\n t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y);\n t.max_excl_x = wuffs_base__u32__max(r->max_excl_x, s.max_excl_x);\n t.max_excl_y = wuffs_base__u32__max(r->max_excl_y, s.max_excl_y);\n return t;\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__con" +
|
||||
"tains(const wuffs_base__rect_ie_u32* r,\n uint32_t x,\n uint32_t y) {\n return (r->min_incl_x <= x) && (x < r->max_excl_x) && (r->min_incl_y <= y) &&\n (y < r->max_excl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__contains_rect(const wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__equals(\n &s, wuffs_base__rect_ie_u32__intersect(r, s));\n}\n\nstatic inline uint32_t //\nwuffs_base__rect_ie_u32__width(const wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_x, r->min_incl_x);\n}\n\nstatic inline uint32_t //\nwuffs_base__rect_ie_u32__height(const wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_y, r->min_incl_y);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__rect_ie_u32::is_empty() const {\n return wuffs_base__rect_ie_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::equals(wuffs_bas" +
|
||||
"e__rect_ie_u32 s) const {\n return wuffs_base__rect_ie_u32__equals(this, s);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32::intersect(wuffs_base__rect_ie_u32 s) const {\n return wuffs_base__rect_ie_u32__intersect(this, s);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32::unite(wuffs_base__rect_ie_u32 s) const {\n return wuffs_base__rect_ie_u32__unite(this, s);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) const {\n return wuffs_base__rect_ie_u32__contains(this, x, y);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::contains_rect(wuffs_base__rect_ie_u32 s) const {\n return wuffs_base__rect_ie_u32__contains_rect(this, s);\n}\n\ninline uint32_t //\nwuffs_base__rect_ie_u32::width() const {\n return wuffs_base__rect_ie_u32__width(this);\n}\n\ninline uint32_t //\nwuffs_base__rect_ie_u32::height() const {\n return wuffs_base__rect_ie_u32__height(this);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// ---------------- More Information\n\n// wuffs_base__more_information holds additional fields, typically when a Wuffs\n// method returns a [note status](/doc/note/statuses.md).\n//\n// The flavor field follows the base38 namespace\n// convention](/doc/note/base38-and-fourcc.md). The other fields' semantics\n// depends on the flavor.\ntypedef struct wuffs_base__more_information__struct {\n uint32_t flavor;\n uint32_t w;\n uint64_t x;\n uint64_t y;\n uint64_t z;\n\n#ifdef __cplusplus\n inline void set(uint32_t flavor_arg,\n uint32_t w_arg,\n uint64_t x_arg,\n uint64_t y_arg,\n uint64_t z_arg);\n inline uint32_t io_redirect__fourcc() const;\n inline wuffs_base__range_ie_u64 io_redirect__range() const;\n inline uint64_t io_seek__position() const;\n inline uint32_t metadata__fourcc() const;\n inline wuffs_base__range_ie_u64 metadata__range() const;\n#endif // __cplusplus\n\n} wuffs_base__more_information;\n\n#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRE" +
|
||||
"CT 1\n#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK 2\n#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA 3\n\nstatic inline wuffs_base__more_information //\nwuffs_base__empty_more_information() {\n wuffs_base__more_information ret;\n ret.flavor = 0;\n ret.w = 0;\n ret.x = 0;\n ret.y = 0;\n ret.z = 0;\n return ret;\n}\n\nstatic inline void //\nwuffs_base__more_information__set(wuffs_base__more_information* m,\n uint32_t flavor,\n uint32_t w,\n uint64_t x,\n uint64_t y,\n uint64_t z) {\n if (!m) {\n return;\n }\n m->flavor = flavor;\n m->w = w;\n m->x = x;\n m->y = y;\n m->z = z;\n}\n\nstatic inline uint32_t //\nwuffs_base__more_information__io_redirect__fourcc(\n const wuffs_base__more_information* m) {\n return m->w;\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__more_information__io_redirect__range(\n const wuffs_base__more_informa" +
|
||||
"tion* m) {\n wuffs_base__range_ie_u64 ret;\n ret.min_incl = m->y;\n ret.max_excl = m->z;\n return ret;\n}\n\nstatic inline uint64_t //\nwuffs_base__more_information__io_seek__position(\n const wuffs_base__more_information* m) {\n return m->x;\n}\n\nstatic inline uint32_t //\nwuffs_base__more_information__metadata__fourcc(\n const wuffs_base__more_information* m) {\n return m->w;\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__more_information__metadata__range(\n const wuffs_base__more_information* m) {\n wuffs_base__range_ie_u64 ret;\n ret.min_incl = m->y;\n ret.max_excl = m->z;\n return ret;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__more_information::set(uint32_t flavor_arg,\n uint32_t w_arg,\n uint64_t x_arg,\n uint64_t y_arg,\n uint64_t z_arg) {\n wuffs_base__more_information__set(this, flavor_arg, w_arg, x_arg, y_arg,\n z_arg);" +
|
||||
"\n}\n\ninline uint32_t //\nwuffs_base__more_information::io_redirect__fourcc() const {\n return wuffs_base__more_information__io_redirect__fourcc(this);\n}\n\ninline wuffs_base__range_ie_u64 //\nwuffs_base__more_information::io_redirect__range() const {\n return wuffs_base__more_information__io_redirect__range(this);\n}\n\ninline uint64_t //\nwuffs_base__more_information::io_seek__position() const {\n return wuffs_base__more_information__io_seek__position(this);\n}\n\ninline uint32_t //\nwuffs_base__more_information::metadata__fourcc() const {\n return wuffs_base__more_information__metadata__fourcc(this);\n}\n\ninline wuffs_base__range_ie_u64 //\nwuffs_base__more_information::metadata__range() const {\n return wuffs_base__more_information__metadata__range(this);\n}\n\n#endif // __cplusplus\n" +
|
||||
""
|
||||
|
||||
const BaseStrConvPrivateH = "" +
|
||||
"// ---------------- String Conversions\n\n" +
|
||||
"" +
|
||||
"// ---------------- Unicode and UTF-8\n" +
|
||||
""
|
||||
|
||||
const BaseStrConvPublicH = "" +
|
||||
"// ---------------- String Conversions\n\n// Options (bitwise or'ed together) for wuffs_base__parse_number_xxx\n// functions. The XXX options apply to both integer and floating point. The FXX\n// options apply only to floating point.\n\n#define WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES means to accept\n// inputs like \"00\", \"0644\" and \"00.7\". By default, they are rejected.\n#define WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES \\\n ((uint32_t)0x00000001)\n\n// WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES means to accept inputs like\n// \"1__2\" and \"_3.141_592\". By default, they are rejected.\n#define WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES ((uint32_t)0x00000002)\n\n// WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA means to accept\n// \"1,5\" and not \"1.5\" as one-and-a-half.\n//\n// If the caller wants to accept either, it is responsible for canonicalizing\n// the input before calling wuffs_base__parse_numb" +
|
||||
"er_fxx. The caller also has\n// more context on e.g. exactly how to treat something like \"$1,234\".\n#define WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA \\\n ((uint32_t)0x00000010)\n\n// WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN means to reject inputs that\n// would lead to infinite or Not-a-Number floating point values. By default,\n// they are accepted.\n//\n// This affects the literal \"inf\" as input, but also affects inputs like\n// \"1e999\" that would overflow double-precision floating point.\n#define WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN ((uint32_t)0x00000020)\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// Options (bitwise or'ed together) for wuffs_base__render_number_xxx\n// functions. The XXX options apply to both integer and floating point. The FXX\n// options apply only to floating point.\n\n#define WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT means to render to the right side\n// (higher indexes) of the destination slice, leaving any untouched bytes on\n// the left side (lower indexes). The default is vice versa: rendering on the\n// left with slack on the right.\n#define WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT ((uint32_t)0x00000100)\n\n// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN means to render the leading\n// \"+\" for non-negative numbers: \"+0\" and \"+12.3\" instead of \"0\" and \"12.3\".\n#define WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN ((uint32_t)0x00000200)\n\n// WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA means to render\n// one-and-a-half as \"1,5\" instead of \"1.5\".\n#define WUFFS_BASE__RENDER_NUMBER_F" +
|
||||
"XX__DECIMAL_SEPARATOR_IS_A_COMMA \\\n ((uint32_t)0x00001000)\n\n// WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ETC means whether to never\n// (EXPONENT_ABSENT, equivalent to printf's \"%f\") or to always\n// (EXPONENT_PRESENT, equivalent to printf's \"%e\") render a floating point\n// number as \"1.23e+05\" instead of \"123000\".\n//\n// Having both bits set is the same has having neither bit set, where the\n// notation used depends on whether the exponent is sufficiently large: \"0.5\"\n// is preferred over \"5e-01\" but \"5e-09\" is preferred over \"0.000000005\".\n#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT ((uint32_t)0x00002000)\n#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT ((uint32_t)0x00004000)\n\n// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION means to render the\n// smallest number of digits so that parsing the resultant string will recover\n// the same double-precision floating point number.\n//\n// For example, double-precision cannot distinguish between 0.3 and\n// 0.2999999999999999888977697537484345957636" +
|
||||
"83319091796875, so when this bit\n// is set, rendering the latter will produce \"0.3\" but rendering\n// 0.3000000000000000444089209850062616169452667236328125 will produce\n// \"0.30000000000000004\".\n#define WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION \\\n ((uint32_t)0x00008000)\n\n" +
|
||||
"" +
|
||||
"// ---------------- IEEE 754 Floating Point\n\n// wuffs_base__ieee_754_bit_representation__etc converts between a double\n// precision numerical value and its IEEE 754 representations:\n// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.\n// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.\n// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.\n//\n// For example, it converts between:\n// - +1.0 and 0x3C00, 0x3F80_0000 or 0x3FF0_0000_0000_0000.\n// - +5.5 and 0x4580, 0x40B0_0000 or 0x4016_0000_0000_0000.\n// - -inf and 0xFC00, 0xFF80_0000 or 0xFFF0_0000_0000_0000.\n//\n// Converting from f64 to shorter formats (f16 or f32, represented in C as\n// uint16_t and uint32_t) may be lossy. Such functions have names that look\n// like etc_truncate, as converting finite numbers produce equal or smaller\n// (closer-to-zero) finite numbers. For example, 1048576.0 is a perfectly valid\n// f64 number, but converting it to a f16 (with truncation) produces 65504.0,\n// the" +
|
||||
" largest finite f16 number. Truncating a f64-typed value d to f32 does\n// not always produce the same result as the C-style cast ((float)d), as\n// casting can convert from finite numbers to infinite ones.\n//\n// Converting infinities or NaNs produces infinities or NaNs and always report\n// no loss, even though there a multiple NaN representations so that round-\n// tripping a f64-typed NaN may produce a different 64 bits. Nonetheless, the\n// etc_truncate functions preserve a NaN's \"quiet vs signaling\" bit.\n//\n// See https://en.wikipedia.org/wiki/Double-precision_floating-point_format\n\ntypedef struct wuffs_base__lossy_value_u16__struct {\n uint16_t value;\n bool lossy;\n} wuffs_base__lossy_value_u16;\n\ntypedef struct wuffs_base__lossy_value_u32__struct {\n uint32_t value;\n bool lossy;\n} wuffs_base__lossy_value_u32;\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u16 //\nwuffs_base__ieee_754_bit_representation__from_f64_to_u16_truncate(double f);\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u32 //\nwuffs_ba" +
|
||||
"se__ieee_754_bit_representation__from_f64_to_u32_truncate(double f);\n\nstatic inline uint64_t //\nwuffs_base__ieee_754_bit_representation__from_f64_to_u64(double f) {\n uint64_t u = 0;\n if (sizeof(uint64_t) == sizeof(double)) {\n memcpy(&u, &f, sizeof(uint64_t));\n }\n return u;\n}\n\nstatic inline double //\nwuffs_base__ieee_754_bit_representation__from_u16_to_f64(uint16_t u) {\n uint64_t v = ((uint64_t)(u & 0x8000)) << 48;\n\n do {\n uint64_t exp = (u >> 10) & 0x1F;\n uint64_t man = u & 0x3FF;\n if (exp == 0x1F) { // Infinity or NaN.\n exp = 2047;\n } else if (exp != 0) { // Normal.\n exp += 1008; // 1008 = 1023 - 15, the difference in biases.\n } else if (man != 0) { // Subnormal but non-zero.\n uint32_t clz = wuffs_base__count_leading_zeroes_u64(man);\n exp = 1062 - clz; // 1062 = 1008 + 64 - 10.\n man = 0x3FF & (man << (clz - 53));\n } else { // Zero.\n break;\n }\n v |= (exp << 52) | (man << 42);\n } while (0);\n\n double f = 0;\n if (sizeof(uint64_t) =" +
|
||||
"= sizeof(double)) {\n memcpy(&f, &v, sizeof(uint64_t));\n }\n return f;\n}\n\nstatic inline double //\nwuffs_base__ieee_754_bit_representation__from_u32_to_f64(uint32_t u) {\n float f = 0;\n if (sizeof(uint32_t) == sizeof(float)) {\n memcpy(&f, &u, sizeof(uint32_t));\n }\n return (double)f;\n}\n\nstatic inline double //\nwuffs_base__ieee_754_bit_representation__from_u64_to_f64(uint64_t u) {\n double f = 0;\n if (sizeof(uint64_t) == sizeof(double)) {\n memcpy(&f, &u, sizeof(uint64_t));\n }\n return f;\n}\n\n" +
|
||||
"" +
|
||||
"// ---------------- Parsing and Rendering Numbers\n\n// wuffs_base__parse_number_f64 parses the floating point number in s. For\n// example, if s contains the bytes \"1.5\" then it will return the double 1.5.\n//\n// It returns an error if s does not contain a floating point number.\n//\n// It does not necessarily return an error if the conversion is lossy, e.g. if\n// s is \"0.3\", which double-precision floating point cannot represent exactly.\n//\n// Similarly, the returned value may be infinite (and no error returned) even\n// if s was not \"inf\", when the input is nominally finite but sufficiently\n// larger than DBL_MAX, about 1.8e+308.\n//\n// It is similar to the C standard library's strtod function, but:\n// - Errors are returned in-band (in a result type), not out-of-band (errno).\n// - It takes a slice (a pointer and length), not a NUL-terminated C string.\n// - It does not take an optional endptr argument. It does not allow a partial\n// parse: it returns an error unless all of s is consumed.\n// - It does not all" +
|
||||
"ow whitespace, leading or otherwise.\n// - It does not allow hexadecimal floating point numbers.\n// - It is not affected by i18n / l10n settings such as environment variables.\n//\n// The options argument can change these, but by default, it:\n// - Allows \"inf\", \"+Infinity\" and \"-NAN\", case insensitive. Similarly,\n// without an explicit opt-out, it would successfully parse \"1e999\" as\n// infinity, even though it overflows double-precision floating point.\n// - Rejects underscores. With an explicit opt-in, \"_3.141_592\" would\n// successfully parse as an approximation to π.\n// - Rejects unnecessary leading zeroes: \"00\", \"0644\" and \"00.7\".\n// - Uses a dot '1.5' instead of a comma '1,5' for the decimal separator.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__FLOATCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64 //\nwuffs_base__parse_number_f64(wuffs_base__" +
|
||||
"slice_u8 s, uint32_t options);\n\n// wuffs_base__parse_number_i64 parses the ASCII integer in s. For example, if\n// s contains the bytes \"-123\" then it will return the int64_t -123.\n//\n// It returns an error if s does not contain an integer or if the integer\n// within would overflow an int64_t.\n//\n// It is similar to wuffs_base__parse_number_u64 but it returns a signed\n// integer, not an unsigned integer. It also allows a leading '+' or '-'.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64 //\nwuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options);\n\n// wuffs_base__parse_number_u64 parses the ASCII integer in s. For example, if\n// s contains the bytes \"123\" then it will return the uint64_t 123.\n//\n// It returns an error if s does not contain an integer or if the integer\n// within would overflow a uin" +
|
||||
"t64_t.\n//\n// It is similar to the C standard library's strtoull function, but:\n// - Errors are returned in-band (in a result type), not out-of-band (errno).\n// - It takes a slice (a pointer and length), not a NUL-terminated C string.\n// - It does not take an optional endptr argument. It does not allow a partial\n// parse: it returns an error unless all of s is consumed.\n// - It does not allow whitespace, leading or otherwise.\n// - It does not allow a leading '+' or '-'.\n// - It does not take a base argument (e.g. base 10 vs base 16). Instead, it\n// always accepts both decimal (e.g \"1234\", \"0d5678\") and hexadecimal (e.g.\n// \"0x9aBC\"). The caller is responsible for prior filtering of e.g. hex\n// numbers if they are unwanted. For example, Wuffs' JSON decoder will only\n// produce a wuffs_base__token for decimal numbers, not hexadecimal.\n// - It is not affected by i18n / l10n settings such as environment variables.\n//\n// The options argument can change these, but by default, it:\n// - Rejects " +
|
||||
"underscores. With an explicit opt-in, \"__0D_1_002\" would\n// successfully parse as \"one thousand and two\". Underscores are still\n// rejected inside the optional 2-byte opening \"0d\" or \"0X\" that denotes\n// base-10 or base-16.\n// - Rejects unnecessary leading zeroes: \"00\" and \"0644\".\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64 //\nwuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options);\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL is the string length of\n// \"-9223372036854775808\" and \"+9223372036854775807\", INT64_MIN and INT64_MAX.\n#define WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL 20\n\n// WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL is the string length of\n// \"+18446744073709551615\", UINT64_MAX.\n#define WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL 21\n\n// wuffs_base__render_number_f64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// For those familiar with C's printf or Go's fmt.Printf functions:\n// - \"%e\" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT option.\n// - \"%f\" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT option.\n// - \"%g\" means neither or both bits are set.\n//\n// The precision argument controls the number of digits rendered, excluding the\n// exponent (the \"e+05\" in \"1.23e+05\"):\n// - for \"%e\" and \"%f\" it is the number of digits after t" +
|
||||
"he decimal separator,\n// - for \"%g\" it is the number of significant digits (and trailing zeroes are\n// removed).\n//\n// A precision of 6 gives similar output to printf's defaults.\n//\n// A precision greater than 4095 is equivalent to 4095.\n//\n// The precision argument is ignored when the\n// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION option is set. This is\n// similar to Go's strconv.FormatFloat with a negative (i.e. non-sensical)\n// precision, but there is no corresponding feature in C's printf.\n//\n// Extreme values of x will be rendered as \"NaN\", \"Inf\" (or \"+Inf\" if the\n// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN option is set) or \"-Inf\".\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__FLOATCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_f64(wuffs_base__slice_u8 dst,\n double x,\n " +
|
||||
" uint32_t precision,\n uint32_t options);\n\n// wuffs_base__render_number_i64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// dst will never be too short if its length is at least 20, also known as\n// WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_i64(wuffs_base__slice_u8 dst,\n int64_t x,\n uint32_t options);\n\n// wuffs_base__render_number_u64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// dst will never be too sho" +
|
||||
"rt if its length is at least 21, also known as\n// WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_u64(wuffs_base__slice_u8 dst,\n uint64_t x,\n uint32_t options);\n\n" +
|
||||
"" +
|
||||
"// ---------------- Base-16\n\n// Options (bitwise or'ed together) for wuffs_base__base_16__xxx functions.\n\n#define WUFFS_BASE__BASE_16__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// wuffs_base__base_16__decode2 converts \"6A6b\" to \"jk\", where e.g. 'j' is\n// U+006A. There are 2 src bytes for every dst byte.\n//\n// It assumes that the src bytes are two hexadecimal digits (0-9, A-F, a-f),\n// repeated. It may write nonsense bytes if not, although it will not read or\n// write out of bounds.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__decode2(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n// wuffs_base__base_16__decode4 converts both \"\\\\x6A\\\\x6b\" and \"??6a??6B\" " +
|
||||
"to\n// \"jk\", where e.g. 'j' is U+006A. There are 4 src bytes for every dst byte.\n//\n// It assumes that the src bytes are two ignored bytes and then two hexadecimal\n// digits (0-9, A-F, a-f), repeated. It may write nonsense bytes if not,\n// although it will not read or write out of bounds.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__decode4(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n// wuffs_base__base_16__encode2 converts \"jk\" to \"6A6B\", where e.g. 'j' is\n// U+006A. There are 2 dst bytes for every src byte.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV" +
|
||||
" sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__encode2(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n// wuffs_base__base_16__encode4 converts \"jk\" to \"\\\\x6A\\\\x6B\", where e.g. 'j'\n// is U+006A. There are 4 dst bytes for every src byte.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__encode2(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n" +
|
||||
"" +
|
||||
"// ---------------- Base-64\n\n// Options (bitwise or'ed together) for wuffs_base__base_64__xxx functions.\n\n#define WUFFS_BASE__BASE_64__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// WUFFS_BASE__BASE_64__DECODE_ALLOW_PADDING means that, when decoding base-64,\n// the input may (but does not need to) be padded with '=' bytes so that the\n// overall encoded length in bytes is a multiple of 4. A successful decoding\n// will return a num_src that includes those padding bytes.\n//\n// Excess padding (e.g. three final '='s) will be rejected as bad data.\n#define WUFFS_BASE__BASE_64__DECODE_ALLOW_PADDING ((uint32_t)0x00000001)\n\n// WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING means that, when encoding base-64,\n// the output will be padded with '=' bytes so that the overall encoded length\n// in bytes is a multiple of 4.\n#define WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING ((uint32_t)0x00000002)\n\n// WUFFS_BASE__BASE_64__URL_ALPHABET means that, for base-64, the URL-friendly\n// and file-name-friendly alphabet be used, as per RFC 4648 sect" +
|
||||
"ion 5. When\n// this option bit is off, the standard alphabet from section 4 is used.\n#define WUFFS_BASE__BASE_64__URL_ALPHABET ((uint32_t)0x00000100)\n\n// wuffs_base__base_64__decode transforms base-64 encoded bytes from src to\n// arbitrary bytes in dst.\n//\n// It will not permit line breaks or other whitespace in src. Filtering those\n// out is the responsibility of the caller.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_64__decode(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n// wuffs_base__base_64__encode transforms arbitrary bytes from src to base-64\n// encoded bytes in dst.\n//\n// For modular builds that divide the base module into sub-modules, using this" +
|
||||
"\n// function requires the WUFFS_CONFIG__MODULE__BASE__INTCONV sub-module, not\n// just WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_64__encode(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options);\n\n" +
|
||||
"" +
|
||||
"// ---------------- Unicode and UTF-8\n\n#define WUFFS_BASE__UNICODE_CODE_POINT__MIN_INCL 0x00000000\n#define WUFFS_BASE__UNICODE_CODE_POINT__MAX_INCL 0x0010FFFF\n\n#define WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER 0x0000FFFD\n\n#define WUFFS_BASE__UNICODE_SURROGATE__MIN_INCL 0x0000D800\n#define WUFFS_BASE__UNICODE_SURROGATE__MAX_INCL 0x0000DFFF\n\n#define WUFFS_BASE__ASCII__MIN_INCL 0x00\n#define WUFFS_BASE__ASCII__MAX_INCL 0x7F\n\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH__MIN_INCL 1\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL 4\n\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_1__CODE_POINT__MIN_INCL 0x00000000\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_1__CODE_POINT__MAX_INCL 0x0000007F\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_2__CODE_POINT__MIN_INCL 0x00000080\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_2__CODE_POINT__MAX_INCL 0x000007FF\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_3__CODE_POINT__MIN_INCL 0x00000800\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_3__CODE_POINT__MAX_INCL 0x0000FFFF\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_4__CODE_POINT_" +
|
||||
"_MIN_INCL 0x00010000\n#define WUFFS_BASE__UTF_8__BYTE_LENGTH_4__CODE_POINT__MAX_INCL 0x0010FFFF\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__utf_8__next__output is the type returned by\n// wuffs_base__utf_8__next.\ntypedef struct wuffs_base__utf_8__next__output__struct {\n uint32_t code_point;\n uint32_t byte_length;\n\n#ifdef __cplusplus\n inline bool is_valid() const;\n#endif // __cplusplus\n\n} wuffs_base__utf_8__next__output;\n\nstatic inline wuffs_base__utf_8__next__output //\nwuffs_base__make_utf_8__next__output(uint32_t code_point,\n uint32_t byte_length) {\n wuffs_base__utf_8__next__output ret;\n ret.code_point = code_point;\n ret.byte_length = byte_length;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__utf_8__next__output__is_valid(\n const wuffs_base__utf_8__next__output* o) {\n if (o) {\n uint32_t cp = o->code_point;\n switch (o->byte_length) {\n case 1:\n return (cp <= 0x7F);\n case 2:\n return (0x080 <= cp) && (cp <= 0x7FF);\n case 3:\n // Avoid the 0xD800 ..= 0xDFFF surrogate range.\n return ((0x0800 <= cp) && (cp <= 0xD7FF)) ||\n " +
|
||||
" ((0xE000 <= cp) && (cp <= 0xFFFF));\n case 4:\n return (0x00010000 <= cp) && (cp <= 0x0010FFFF);\n }\n }\n return false;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__utf_8__next__output::is_valid() const {\n return wuffs_base__utf_8__next__output__is_valid(this);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__utf_8__encode writes the UTF-8 encoding of code_point to s and\n// returns the number of bytes written. If code_point is invalid, or if s is\n// shorter than the entire encoding, it returns 0 (and no bytes are written).\n//\n// s will never be too short if its length is at least 4, also known as\n// WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__utf_8__encode(wuffs_base__slice_u8 dst, uint32_t code_point);\n\n// wuffs_base__utf_8__next returns the next UTF-8 code point (and that code\n// point's byte length) at the start of the read-only slice (s_ptr, s_len).\n//\n// There are exactly two cases in which this function returns something where\n// wuffs_base__utf_8__next__output__is_valid is false:\n// - If s is empty then it returns {.code_point=0, .byte_len" +
|
||||
"gth=0}.\n// - If s is non-empty and starts with invalid UTF-8 then it returns\n// {.code_point=WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, .byte_length=1}.\n//\n// Otherwise, it returns something where\n// wuffs_base__utf_8__next__output__is_valid is true.\n//\n// In any case, it always returns an output that satisfies both of:\n// - (output.code_point <= WUFFS_BASE__UNICODE_CODE_POINT__MAX_INCL).\n// - (output.byte_length <= s_len).\n//\n// If s is a sub-slice of a larger slice of valid UTF-8, but that sub-slice\n// boundary occurs in the middle of a multi-byte UTF-8 encoding of a single\n// code point, then this function may return something invalid. It is the\n// caller's responsibility to split on or otherwise manage UTF-8 boundaries.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output //\nwuffs_base__utf_8__next(" +
|
||||
"const uint8_t* s_ptr, size_t s_len);\n\n// wuffs_base__utf_8__next_from_end is like wuffs_base__utf_8__next except that\n// it looks at the end of (s_ptr, s_len) instead of the start.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output //\nwuffs_base__utf_8__next_from_end(const uint8_t* s_ptr, size_t s_len);\n\n// wuffs_base__utf_8__longest_valid_prefix returns the largest n such that the\n// sub-slice s[..n] is valid UTF-8, where s is the read-only slice (s_ptr,\n// s_len).\n//\n// In particular, it returns s_len if and only if all of s is valid UTF-8.\n//\n// If s is a sub-slice of a larger slice of valid UTF-8, but that sub-slice\n// boundary occurs in the middle of a multi-byte UTF-8 encoding of a single\n// code point, then this function will return less than s_len. It is the\n// caller's responsibility to split on or " +
|
||||
"otherwise manage UTF-8 boundaries.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__utf_8__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len);\n\n// wuffs_base__ascii__longest_valid_prefix returns the largest n such that the\n// sub-slice s[..n] is valid ASCII, where s is the read-only slice (s_ptr,\n// s_len).\n//\n// In particular, it returns s_len if and only if all of s is valid ASCII.\n// Equivalently, when none of the bytes in s have the 0x80 high bit set.\n//\n// For modular builds that divide the base module into sub-modules, using this\n// function requires the WUFFS_CONFIG__MODULE__BASE__UTF8 sub-module, not just\n// WUFFS_CONFIG__MODULE__BASE__CORE.\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__ascii__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len);\n" +
|
||||
""
|
||||
|
||||
const BaseTokenPrivateH = "" +
|
||||
"// ---------------- Tokens\n\n" +
|
||||
"" +
|
||||
"// ---------------- Tokens (Utility)\n" +
|
||||
""
|
||||
|
||||
const BaseTokenPublicH = "" +
|
||||
"// ---------------- Tokens\n\n// wuffs_base__token is an element of a byte stream's tokenization.\n//\n// See https://github.com/google/wuffs/blob/main/doc/note/tokens.md\ntypedef struct wuffs_base__token__struct {\n uint64_t repr;\n\n#ifdef __cplusplus\n inline int64_t value() const;\n inline int64_t value_extension() const;\n inline int64_t value_major() const;\n inline int64_t value_base_category() const;\n inline uint64_t value_minor() const;\n inline uint64_t value_base_detail() const;\n inline int64_t value_base_detail__sign_extended() const;\n inline bool continued() const;\n inline uint64_t length() const;\n#endif // __cplusplus\n\n} wuffs_base__token;\n\nstatic inline wuffs_base__token //\nwuffs_base__make_token(uint64_t repr) {\n wuffs_base__token ret;\n ret.repr = repr;\n return ret;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#define WUFFS_BASE__TOKEN__LENGTH__MAX_INCL 0xFFFF\n\n#define WUFFS_BASE__TOKEN__VALUE__SHIFT 17\n#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT 17\n#define WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT 42\n#define WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT 17\n#define WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT 38\n#define WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT 17\n#define WUFFS_BASE__TOKEN__CONTINUED__SHIFT 16\n#define WUFFS_BASE__TOKEN__LENGTH__SHIFT 0\n\n#define WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS 46\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#define WUFFS_BASE__TOKEN__VBC__FILLER 0\n#define WUFFS_BASE__TOKEN__VBC__STRUCTURE 1\n#define WUFFS_BASE__TOKEN__VBC__STRING 2\n#define WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT 3\n#define WUFFS_BASE__TOKEN__VBC__LITERAL 4\n#define WUFFS_BASE__TOKEN__VBC__NUMBER 5\n#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED 6\n#define WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED 7\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#define WUFFS_BASE__TOKEN__VBD__FILLER__PUNCTUATION 0x00001\n#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_BLOCK 0x00002\n#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE 0x00004\n\n// COMMENT_ANY is a bit-wise or of COMMENT_BLOCK AND COMMENT_LINE.\n#define WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_ANY 0x00006\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH 0x00001\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP 0x00002\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE 0x00010\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST 0x00020\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT 0x00040\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE 0x01000\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST 0x02000\n#define WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT 0x04000\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// DEFINITELY_FOO means that the destination bytes (and also the source bytes,\n// for 1_DST_1_SRC_COPY) are in the FOO format. Definitely means that the lack\n// of the bit means \"maybe FOO\". It does not necessarily mean \"not FOO\".\n//\n// CHAIN_ETC means that decoding the entire token chain forms a UTF-8 or ASCII\n// string, not just this current token. CHAIN_ETC_UTF_8 therefore distinguishes\n// Unicode (UTF-8) strings from byte strings. MUST means that the the token\n// producer (e.g. parser) must verify this. SHOULD means that the token\n// consumer (e.g. renderer) should verify this.\n//\n// When a CHAIN_ETC_UTF_8 bit is set, the parser must ensure that non-ASCII\n// code points (with multi-byte UTF-8 encodings) do not straddle token\n// boundaries. Checking UTF-8 validity can inspect each token separately.\n//\n// The lack of any particular bit is conservative: it is valid for all-ASCII\n// strings, in a single- or multi-token chain, to have none of these bits set.\n#define WUFFS_BASE__TOKEN__VBD__STRING_" +
|
||||
"_DEFINITELY_UTF_8 0x00001\n#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8 0x00002\n#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_UTF_8 0x00004\n#define WUFFS_BASE__TOKEN__VBD__STRING__DEFINITELY_ASCII 0x00010\n#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_MUST_BE_ASCII 0x00020\n#define WUFFS_BASE__TOKEN__VBD__STRING__CHAIN_SHOULD_BE_ASCII 0x00040\n\n// CONVERT_D_DST_S_SRC means that multiples of S source bytes (possibly padded)\n// produces multiples of D destination bytes. For example,\n// CONVERT_1_DST_4_SRC_BACKSLASH_X means a source like \"\\\\x23\\\\x67\\\\xAB\", where\n// 12 src bytes encode 3 dst bytes.\n//\n// Post-processing may further transform those D destination bytes (e.g. treat\n// \"\\\\xFF\" as the Unicode code point U+00FF instead of the byte 0xFF), but that\n// is out of scope of this VBD's semantics.\n//\n// When src is the empty string, multiple conversion algorithms are applicable\n// (so these bits are not necessarily mutually exclusive), all producing the\n// same empty dst string.\n#define WU" +
|
||||
"FFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP 0x00100\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY 0x00200\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_2_SRC_HEXADECIMAL 0x00400\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_4_SRC_BACKSLASH_X 0x00800\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_STD 0x01000\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_3_DST_4_SRC_BASE_64_URL 0x02000\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_4_DST_5_SRC_ASCII_85 0x04000\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_HEX 0x08000\n#define WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_5_DST_8_SRC_BASE_32_STD 0x10000\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#define WUFFS_BASE__TOKEN__VBD__LITERAL__UNDEFINED 0x00001\n#define WUFFS_BASE__TOKEN__VBD__LITERAL__NULL 0x00002\n#define WUFFS_BASE__TOKEN__VBD__LITERAL__FALSE 0x00004\n#define WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE 0x00008\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// For a source string of \"123\" or \"0x9A\", it is valid for a tokenizer to\n// return any combination of:\n// - WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT.\n// - WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED.\n// - WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED.\n//\n// For a source string of \"+123\" or \"-0x9A\", only the first two are valid.\n//\n// For a source string of \"123.\", only the first one is valid.\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT 0x00001\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED 0x00002\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_UNSIGNED 0x00004\n\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF 0x00010\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_INF 0x00020\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_NAN 0x00040\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_NAN 0x00080\n\n// The number 300 might be represented as \"\\x01\\x2C\", \"\\x2C\\x01\\x00\\x00\" or\n// \"300\", which are big-en" +
|
||||
"dian, little-endian or text. For binary formats, the\n// token length (after adjusting for FORMAT_IGNORE_ETC) discriminates\n// e.g. u16 little-endian vs u32 little-endian.\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN 0x00100\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_LITTLE_ENDIAN 0x00200\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT 0x00400\n\n#define WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE 0x01000\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__token__value returns the token's high 46 bits, sign-extended. A\n// negative value means an extended token, non-negative means a simple token.\nstatic inline int64_t //\nwuffs_base__token__value(const wuffs_base__token* t) {\n return ((int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE__SHIFT;\n}\n\n// wuffs_base__token__value_extension returns a negative value if the token was\n// not an extended token.\nstatic inline int64_t //\nwuffs_base__token__value_extension(const wuffs_base__token* t) {\n return (~(int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE_EXTENSION__SHIFT;\n}\n\n// wuffs_base__token__value_major returns a negative value if the token was not\n// a simple token.\nstatic inline int64_t //\nwuffs_base__token__value_major(const wuffs_base__token* t) {\n return ((int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT;\n}\n\n// wuffs_base__token__value_base_category returns a negative value if the token\n// was not a simple token.\nstatic inline int64_t //\nwuffs_base__token__value_base_cat" +
|
||||
"egory(const wuffs_base__token* t) {\n return ((int64_t)(t->repr)) >> WUFFS_BASE__TOKEN__VALUE_BASE_CATEGORY__SHIFT;\n}\n\nstatic inline uint64_t //\nwuffs_base__token__value_minor(const wuffs_base__token* t) {\n return (t->repr >> WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) & 0x1FFFFFF;\n}\n\nstatic inline uint64_t //\nwuffs_base__token__value_base_detail(const wuffs_base__token* t) {\n return (t->repr >> WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT) & 0x1FFFFF;\n}\n\nstatic inline int64_t //\nwuffs_base__token__value_base_detail__sign_extended(\n const wuffs_base__token* t) {\n // The VBD is 21 bits in the middle of t->repr. Left shift the high (64 - 21\n // - ETC__SHIFT) bits off, then right shift (sign-extending) back down.\n uint64_t u = t->repr << (43 - WUFFS_BASE__TOKEN__VALUE_BASE_DETAIL__SHIFT);\n return ((int64_t)u) >> 43;\n}\n\nstatic inline bool //\nwuffs_base__token__continued(const wuffs_base__token* t) {\n return t->repr & 0x10000;\n}\n\nstatic inline uint64_t //\nwuffs_base__token__length(const wuffs_base__token*" +
|
||||
" t) {\n return (t->repr >> WUFFS_BASE__TOKEN__LENGTH__SHIFT) & 0xFFFF;\n}\n\n#ifdef __cplusplus\n\ninline int64_t //\nwuffs_base__token::value() const {\n return wuffs_base__token__value(this);\n}\n\ninline int64_t //\nwuffs_base__token::value_extension() const {\n return wuffs_base__token__value_extension(this);\n}\n\ninline int64_t //\nwuffs_base__token::value_major() const {\n return wuffs_base__token__value_major(this);\n}\n\ninline int64_t //\nwuffs_base__token::value_base_category() const {\n return wuffs_base__token__value_base_category(this);\n}\n\ninline uint64_t //\nwuffs_base__token::value_minor() const {\n return wuffs_base__token__value_minor(this);\n}\n\ninline uint64_t //\nwuffs_base__token::value_base_detail() const {\n return wuffs_base__token__value_base_detail(this);\n}\n\ninline int64_t //\nwuffs_base__token::value_base_detail__sign_extended() const {\n return wuffs_base__token__value_base_detail__sign_extended(this);\n}\n\ninline bool //\nwuffs_base__token::continued() const {\n return wuffs_base__token__continued" +
|
||||
"(this);\n}\n\ninline uint64_t //\nwuffs_base__token::length() const {\n return wuffs_base__token__length(this);\n}\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef WUFFS_BASE__SLICE(wuffs_base__token) wuffs_base__slice_token;\n\nstatic inline wuffs_base__slice_token //\nwuffs_base__make_slice_token(wuffs_base__token* ptr, size_t len) {\n wuffs_base__slice_token ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_token //\nwuffs_base__empty_slice_token() {\n wuffs_base__slice_token ret;\n ret.ptr = NULL;\n ret.len = 0;\n return ret;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__token_buffer_meta is the metadata for a\n// wuffs_base__token_buffer's data.\ntypedef struct wuffs_base__token_buffer_meta__struct {\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n uint64_t pos; // Position of the buffer start relative to the stream start.\n bool closed; // No further writes are expected.\n} wuffs_base__token_buffer_meta;\n\n// wuffs_base__token_buffer is a 1-dimensional buffer (a pointer and length)\n// plus additional metadata.\n//\n// A value with all fields zero is a valid, empty buffer.\ntypedef struct wuffs_base__token_buffer__struct {\n wuffs_base__slice_token data;\n wuffs_base__token_buffer_meta meta;\n\n#ifdef __cplusplus\n inline bool is_valid() const;\n inline void compact();\n inline uint64_t reader_length() const;\n inline wuffs_base__token* reader_pointer() const;\n inline wuffs_base__slice_token reader_slice() const;\n inline uint64_t reader_token_position() const;\n inline uint64_t writer_lengt" +
|
||||
"h() const;\n inline uint64_t writer_token_position() const;\n inline wuffs_base__token* writer_pointer() const;\n inline wuffs_base__slice_token writer_slice() const;\n#endif // __cplusplus\n\n} wuffs_base__token_buffer;\n\nstatic inline wuffs_base__token_buffer //\nwuffs_base__make_token_buffer(wuffs_base__slice_token data,\n wuffs_base__token_buffer_meta meta) {\n wuffs_base__token_buffer ret;\n ret.data = data;\n ret.meta = meta;\n return ret;\n}\n\nstatic inline wuffs_base__token_buffer_meta //\nwuffs_base__make_token_buffer_meta(size_t wi,\n size_t ri,\n uint64_t pos,\n bool closed) {\n wuffs_base__token_buffer_meta ret;\n ret.wi = wi;\n ret.ri = ri;\n ret.pos = pos;\n ret.closed = closed;\n return ret;\n}\n\nstatic inline wuffs_base__token_buffer //\nwuffs_base__slice_token__reader(wuffs_base__slice_token s, bool closed) {\n wuffs_base__token_buffer ret;\n ret.data.ptr = s.ptr;\n ret.data" +
|
||||
".len = s.len;\n ret.meta.wi = s.len;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = closed;\n return ret;\n}\n\nstatic inline wuffs_base__token_buffer //\nwuffs_base__slice_token__writer(wuffs_base__slice_token s) {\n wuffs_base__token_buffer ret;\n ret.data.ptr = s.ptr;\n ret.data.len = s.len;\n ret.meta.wi = 0;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = false;\n return ret;\n}\n\nstatic inline wuffs_base__token_buffer //\nwuffs_base__empty_token_buffer() {\n wuffs_base__token_buffer ret;\n ret.data.ptr = NULL;\n ret.data.len = 0;\n ret.meta.wi = 0;\n ret.meta.ri = 0;\n ret.meta.pos = 0;\n ret.meta.closed = false;\n return ret;\n}\n\nstatic inline wuffs_base__token_buffer_meta //\nwuffs_base__empty_token_buffer_meta() {\n wuffs_base__token_buffer_meta ret;\n ret.wi = 0;\n ret.ri = 0;\n ret.pos = 0;\n ret.closed = false;\n return ret;\n}\n\nstatic inline bool //\nwuffs_base__token_buffer__is_valid(const wuffs_base__token_buffer* buf) {\n if (buf) {\n if (buf->data.ptr) {\n return (buf->m" +
|
||||
"eta.ri <= buf->meta.wi) && (buf->meta.wi <= buf->data.len);\n } else {\n return (buf->meta.ri == 0) && (buf->meta.wi == 0) && (buf->data.len == 0);\n }\n }\n return false;\n}\n\n// wuffs_base__token_buffer__compact moves any written but unread tokens to the\n// start of the buffer.\nstatic inline void //\nwuffs_base__token_buffer__compact(wuffs_base__token_buffer* buf) {\n if (!buf || (buf->meta.ri == 0)) {\n return;\n }\n buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri);\n size_t n = buf->meta.wi - buf->meta.ri;\n if (n != 0) {\n memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri,\n n * sizeof(wuffs_base__token));\n }\n buf->meta.wi = n;\n buf->meta.ri = 0;\n}\n\nstatic inline uint64_t //\nwuffs_base__token_buffer__reader_length(const wuffs_base__token_buffer* buf) {\n return buf ? buf->meta.wi - buf->meta.ri : 0;\n}\n\nstatic inline wuffs_base__token* //\nwuffs_base__token_buffer__reader_pointer(const wuffs_base__token_buffer* buf) {\n return buf ? (buf->data.ptr + buf->meta" +
|
||||
".ri) : NULL;\n}\n\nstatic inline wuffs_base__slice_token //\nwuffs_base__token_buffer__reader_slice(const wuffs_base__token_buffer* buf) {\n return buf ? wuffs_base__make_slice_token(buf->data.ptr + buf->meta.ri,\n buf->meta.wi - buf->meta.ri)\n : wuffs_base__empty_slice_token();\n}\n\nstatic inline uint64_t //\nwuffs_base__token_buffer__reader_token_position(\n const wuffs_base__token_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0;\n}\n\nstatic inline uint64_t //\nwuffs_base__token_buffer__writer_length(const wuffs_base__token_buffer* buf) {\n return buf ? buf->data.len - buf->meta.wi : 0;\n}\n\nstatic inline wuffs_base__token* //\nwuffs_base__token_buffer__writer_pointer(const wuffs_base__token_buffer* buf) {\n return buf ? (buf->data.ptr + buf->meta.wi) : NULL;\n}\n\nstatic inline wuffs_base__slice_token //\nwuffs_base__token_buffer__writer_slice(const wuffs_base__token_buffer* buf) {\n return buf ? wuffs_base__make_slice_toke" +
|
||||
"n(buf->data.ptr + buf->meta.wi,\n buf->data.len - buf->meta.wi)\n : wuffs_base__empty_slice_token();\n}\n\nstatic inline uint64_t //\nwuffs_base__token_buffer__writer_token_position(\n const wuffs_base__token_buffer* buf) {\n return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__token_buffer::is_valid() const {\n return wuffs_base__token_buffer__is_valid(this);\n}\n\ninline void //\nwuffs_base__token_buffer::compact() {\n wuffs_base__token_buffer__compact(this);\n}\n\ninline uint64_t //\nwuffs_base__token_buffer::reader_length() const {\n return wuffs_base__token_buffer__reader_length(this);\n}\n\ninline wuffs_base__token* //\nwuffs_base__token_buffer::reader_pointer() const {\n return wuffs_base__token_buffer__reader_pointer(this);\n}\n\ninline wuffs_base__slice_token //\nwuffs_base__token_buffer::reader_slice() const {\n return wuffs_base__token_buffer__reader_slice(this);\n}\n\ninline uint64_t //\nwuff" +
|
||||
"s_base__token_buffer::reader_token_position() const {\n return wuffs_base__token_buffer__reader_token_position(this);\n}\n\ninline uint64_t //\nwuffs_base__token_buffer::writer_length() const {\n return wuffs_base__token_buffer__writer_length(this);\n}\n\ninline wuffs_base__token* //\nwuffs_base__token_buffer::writer_pointer() const {\n return wuffs_base__token_buffer__writer_pointer(this);\n}\n\ninline wuffs_base__slice_token //\nwuffs_base__token_buffer::writer_slice() const {\n return wuffs_base__token_buffer__writer_slice(this);\n}\n\ninline uint64_t //\nwuffs_base__token_buffer::writer_token_position() const {\n return wuffs_base__token_buffer__writer_token_position(this);\n}\n\n#endif // __cplusplus\n" +
|
||||
""
|
||||
|
||||
const BaseFloatConvSubmoduleCodeC = "" +
|
||||
"// ---------------- IEEE 754 Floating Point\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u16 //\nwuffs_base__ieee_754_bit_representation__from_f64_to_u16_truncate(double f) {\n uint64_t u = 0;\n if (sizeof(uint64_t) == sizeof(double)) {\n memcpy(&u, &f, sizeof(uint64_t));\n }\n uint16_t neg = ((uint16_t)((u >> 63) << 15));\n u &= 0x7FFFFFFFFFFFFFFF;\n uint64_t exp = u >> 52;\n uint64_t man = u & 0x000FFFFFFFFFFFFF;\n\n if (exp == 0x7FF) {\n if (man == 0) { // Infinity.\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg | 0x7C00;\n ret.lossy = false;\n return ret;\n }\n // NaN. Shift the 52 mantissa bits to 10 mantissa bits, keeping the most\n // significant mantissa bit (quiet vs signaling NaNs). Also set the low 9\n // bits of ret.value so that the 10-bit mantissa is non-zero.\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg | 0x7DFF | ((uint16_t)(man >> 42));\n ret.lossy = false;\n return ret;\n\n } else if (exp > 0x40E) { // Truncate to the largest finite f16." +
|
||||
"\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg | 0x7BFF;\n ret.lossy = true;\n return ret;\n\n } else if (exp <= 0x3E6) { // Truncate to zero.\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg;\n ret.lossy = (u != 0);\n return ret;\n\n } else if (exp <= 0x3F0) { // Normal f64, subnormal f16.\n // Convert from a 53-bit mantissa (after realizing the implicit bit) to a\n // 10-bit mantissa and then adjust for the exponent.\n man |= 0x0010000000000000;\n uint32_t shift = ((uint32_t)(1051 - exp)); // 1051 = 0x3F0 + 53 - 10.\n uint64_t shifted_man = man >> shift;\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg | ((uint16_t)shifted_man);\n ret.lossy = (shifted_man << shift) != man;\n return ret;\n }\n\n // Normal f64, normal f16.\n\n // Re-bias from 1023 to 15 and shift above f16's 10 mantissa bits.\n exp = (exp - 1008) << 10; // 1008 = 1023 - 15 = 0x3FF - 0xF.\n\n // Convert from a 52-bit mantissa (excluding the implicit bit) to a 10-bit\n // mantissa (again excluding" +
|
||||
" the implicit bit). We lose some information if\n // any of the bottom 42 bits are non-zero.\n wuffs_base__lossy_value_u16 ret;\n ret.value = neg | ((uint16_t)exp) | ((uint16_t)(man >> 42));\n ret.lossy = (man << 22) != 0;\n return ret;\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__lossy_value_u32 //\nwuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f) {\n uint64_t u = 0;\n if (sizeof(uint64_t) == sizeof(double)) {\n memcpy(&u, &f, sizeof(uint64_t));\n }\n uint32_t neg = ((uint32_t)(u >> 63)) << 31;\n u &= 0x7FFFFFFFFFFFFFFF;\n uint64_t exp = u >> 52;\n uint64_t man = u & 0x000FFFFFFFFFFFFF;\n\n if (exp == 0x7FF) {\n if (man == 0) { // Infinity.\n wuffs_base__lossy_value_u32 ret;\n ret.value = neg | 0x7F800000;\n ret.lossy = false;\n return ret;\n }\n // NaN. Shift the 52 mantissa bits to 23 mantissa bits, keeping the most\n // significant mantissa bit (quiet vs signaling NaNs). Also set the low 22\n // bits of ret.value so that the 23-bit mantissa is non-zero.\n " +
|
||||
" wuffs_base__lossy_value_u32 ret;\n ret.value = neg | 0x7FBFFFFF | ((uint32_t)(man >> 29));\n ret.lossy = false;\n return ret;\n\n } else if (exp > 0x47E) { // Truncate to the largest finite f32.\n wuffs_base__lossy_value_u32 ret;\n ret.value = neg | 0x7F7FFFFF;\n ret.lossy = true;\n return ret;\n\n } else if (exp <= 0x369) { // Truncate to zero.\n wuffs_base__lossy_value_u32 ret;\n ret.value = neg;\n ret.lossy = (u != 0);\n return ret;\n\n } else if (exp <= 0x380) { // Normal f64, subnormal f32.\n // Convert from a 53-bit mantissa (after realizing the implicit bit) to a\n // 23-bit mantissa and then adjust for the exponent.\n man |= 0x0010000000000000;\n uint32_t shift = ((uint32_t)(926 - exp)); // 926 = 0x380 + 53 - 23.\n uint64_t shifted_man = man >> shift;\n wuffs_base__lossy_value_u32 ret;\n ret.value = neg | ((uint32_t)shifted_man);\n ret.lossy = (shifted_man << shift) != man;\n return ret;\n }\n\n // Normal f64, normal f32.\n\n // Re-bias from 1023 to 127 and shi" +
|
||||
"ft above f32's 23 mantissa bits.\n exp = (exp - 896) << 23; // 896 = 1023 - 127 = 0x3FF - 0x7F.\n\n // Convert from a 52-bit mantissa (excluding the implicit bit) to a 23-bit\n // mantissa (again excluding the implicit bit). We lose some information if\n // any of the bottom 29 bits are non-zero.\n wuffs_base__lossy_value_u32 ret;\n ret.value = neg | ((uint32_t)exp) | ((uint32_t)(man >> 29));\n ret.lossy = (man << 35) != 0;\n return ret;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 2047\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 800\n\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL is the largest N\n// such that ((10 << N) < (1 << 64)).\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL 60\n\n// wuffs_base__private_implementation__high_prec_dec (abbreviated as HPD) is a\n// fixed precision floating point decimal number, augmented with ±infinity\n// values, but it cannot represent NaN (Not a Number).\n//\n// \"High precision\" means that the mantissa holds 800 decimal digits. 800 is\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION.\n//\n// An HPD isn't for general purpose arithmetic, only for conversions to and\n// from IEEE 754 double-precision floating point, where the largest and\n// smallest positive, finite values are approximately 1.8e+308 and 4.9e-324.\n// HPD exponents above +2047 mean infinity, below -2047 mean zero. The ±2047\n// bounds are further a" +
|
||||
"way from zero than ±(324 + 800), where 800 and 2047 is\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION and\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.\n//\n// digits[.. num_digits] are the number's digits in big-endian order. The\n// uint8_t values are in the range [0 ..= 9], not ['0' ..= '9'], where e.g. '7'\n// is the ASCII value 0x37.\n//\n// decimal_point is the index (within digits) of the decimal point. It may be\n// negative or be larger than num_digits, in which case the explicit digits are\n// padded with implicit zeroes.\n//\n// For example, if num_digits is 3 and digits is \"\\x07\\x08\\x09\":\n// - A decimal_point of -2 means \".00789\"\n// - A decimal_point of -1 means \".0789\"\n// - A decimal_point of +0 means \".789\"\n// - A decimal_point of +1 means \"7.89\"\n// - A decimal_point of +2 means \"78.9\"\n// - A decimal_point of +3 means \"789.\"\n// - A decimal_point of +4 means \"7890.\"\n// - A decimal_point of +5 means \"78900.\"\n//\n// As above, a decimal_point higher than +2047" +
|
||||
" means that the overall value is\n// infinity, lower than -2047 means zero.\n//\n// negative is a sign bit. An HPD can distinguish positive and negative zero.\n//\n// truncated is whether there are more than\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION digits, and at\n// least one of those extra digits are non-zero. The existence of long-tail\n// digits can affect rounding.\n//\n// The \"all fields are zero\" value is valid, and represents the number +0.\ntypedef struct wuffs_base__private_implementation__high_prec_dec__struct {\n uint32_t num_digits;\n int32_t decimal_point;\n bool negative;\n bool truncated;\n uint8_t digits[WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION];\n} wuffs_base__private_implementation__high_prec_dec;\n\n// wuffs_base__private_implementation__high_prec_dec__trim trims trailing\n// zeroes from the h->digits[.. h->num_digits] slice. They have no benefit,\n// since we explicitly track h->decimal_point.\n//\n// Preconditions:\n// - h is non-NULL.\nstatic inline void //\nwuffs_bas" +
|
||||
"e__private_implementation__high_prec_dec__trim(\n wuffs_base__private_implementation__high_prec_dec* h) {\n while ((h->num_digits > 0) && (h->digits[h->num_digits - 1] == 0)) {\n h->num_digits--;\n }\n}\n\n// wuffs_base__private_implementation__high_prec_dec__assign sets h to\n// represent the number x.\n//\n// Preconditions:\n// - h is non-NULL.\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__assign(\n wuffs_base__private_implementation__high_prec_dec* h,\n uint64_t x,\n bool negative) {\n uint32_t n = 0;\n\n // Set h->digits.\n if (x > 0) {\n // Calculate the digits, working right-to-left. After we determine n (how\n // many digits there are), copy from buf to h->digits.\n //\n // UINT64_MAX, 18446744073709551615, is 20 digits long. It can be faster to\n // copy a constant number of bytes than a variable number (20 instead of\n // n). Make buf large enough (and start writing to it from the middle) so\n // that can we always copy 20 bytes: the slice buf[(20-n) .. (40-n)].\n" +
|
||||
" uint8_t buf[40] = {0};\n uint8_t* ptr = &buf[20];\n do {\n uint64_t remaining = x / 10;\n x -= remaining * 10;\n ptr--;\n *ptr = (uint8_t)x;\n n++;\n x = remaining;\n } while (x > 0);\n memcpy(h->digits, ptr, 20);\n }\n\n // Set h's other fields.\n h->num_digits = n;\n h->decimal_point = (int32_t)n;\n h->negative = negative;\n h->truncated = false;\n wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\nstatic wuffs_base__status //\nwuffs_base__private_implementation__high_prec_dec__parse(\n wuffs_base__private_implementation__high_prec_dec* h,\n wuffs_base__slice_u8 s,\n uint32_t options) {\n if (!h) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n h->num_digits = 0;\n h->decimal_point = 0;\n h->negative = false;\n h->truncated = false;\n\n uint8_t* p = s.ptr;\n uint8_t* q = s.ptr + s.len;\n\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (;; p++) {\n if (p >= q) {\n return wuffs_base__make_status" +
|
||||
"(wuffs_base__error__bad_argument);\n } else if (*p != '_') {\n break;\n }\n }\n }\n\n // Parse sign.\n do {\n if (*p == '+') {\n p++;\n } else if (*p == '-') {\n h->negative = true;\n p++;\n } else {\n break;\n }\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (;; p++) {\n if (p >= q) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n } else if (*p != '_') {\n break;\n }\n }\n }\n } while (0);\n\n // Parse digits, up to (and including) a '.', 'E' or 'e'. Examples for each\n // limb in this if-else chain:\n // - \"0.789\"\n // - \"1002.789\"\n // - \".789\"\n // - Other (invalid input).\n uint32_t nd = 0;\n int32_t dp = 0;\n bool no_digits_before_separator = false;\n if (('0' == *p) &&\n !(options &\n WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES)) {\n p++;\n for (;; p++) {\n if (p >= q) {\n goto after_all;\n } else if (*p ==\n (" +
|
||||
"(options &\n WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n ? ','\n : '.')) {\n p++;\n goto after_sep;\n } else if ((*p == 'E') || (*p == 'e')) {\n p++;\n goto after_exp;\n } else if ((*p != '_') ||\n !(options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n }\n\n } else if (('0' <= *p) && (*p <= '9')) {\n if (*p == '0') {\n for (; (p < q) && (*p == '0'); p++) {\n }\n } else {\n h->digits[nd++] = (uint8_t)(*p - '0');\n dp = (int32_t)nd;\n p++;\n }\n\n for (;; p++) {\n if (p >= q) {\n goto after_all;\n } else if (('0' <= *p) && (*p <= '9')) {\n if (nd < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[nd++] = (uint8_t)(*p - '0');\n dp = (int32_t)nd;\n } else if ('0' != *p) {\n // Long-tail non-zeroes set t" +
|
||||
"he truncated bit.\n h->truncated = true;\n }\n } else if (*p ==\n ((options &\n WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n ? ','\n : '.')) {\n p++;\n goto after_sep;\n } else if ((*p == 'E') || (*p == 'e')) {\n p++;\n goto after_exp;\n } else if ((*p != '_') ||\n !(options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n }\n\n } else if (*p == ((options &\n WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n ? ','\n : '.')) {\n p++;\n no_digits_before_separator = true;\n\n } else {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\nafter_sep:\n for (;; p++) {\n if (p >= q) {\n goto after_all;\n } else if ('0' == *p) {\n if (nd == 0) {\n // Track leading " +
|
||||
"zeroes implicitly.\n dp--;\n } else if (nd <\n WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[nd++] = (uint8_t)(*p - '0');\n }\n } else if (('0' < *p) && (*p <= '9')) {\n if (nd < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[nd++] = (uint8_t)(*p - '0');\n } else {\n // Long-tail non-zeroes set the truncated bit.\n h->truncated = true;\n }\n } else if ((*p == 'E') || (*p == 'e')) {\n p++;\n goto after_exp;\n } else if ((*p != '_') ||\n !(options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n }\n\nafter_exp:\n do {\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (;; p++) {\n if (p >= q) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n } else if (*p != '_') {\n break;\n }\n }\n }\n\n int32_t ex" +
|
||||
"p_sign = +1;\n if (*p == '+') {\n p++;\n } else if (*p == '-') {\n exp_sign = -1;\n p++;\n }\n\n int32_t exp = 0;\n const int32_t exp_large =\n WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE +\n WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION;\n bool saw_exp_digits = false;\n for (; p < q; p++) {\n if ((*p == '_') &&\n (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n // No-op.\n } else if (('0' <= *p) && (*p <= '9')) {\n saw_exp_digits = true;\n if (exp < exp_large) {\n exp = (10 * exp) + ((int32_t)(*p - '0'));\n }\n } else {\n break;\n }\n }\n if (!saw_exp_digits) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n dp += exp_sign * exp;\n } while (0);\n\nafter_all:\n if (p != q) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n h->num_digits = nd;\n if (nd == 0) {\n if (no_digits_before_separator) {\n retu" +
|
||||
"rn wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n h->decimal_point = 0;\n } else if (dp <\n -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n h->decimal_point =\n -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE - 1;\n } else if (dp >\n +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n h->decimal_point =\n +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE + 1;\n } else {\n h->decimal_point = dp;\n }\n wuffs_base__private_implementation__high_prec_dec__trim(h);\n return wuffs_base__make_status(NULL);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits\n// returns the number of additional decimal digits when left-shifting by shift.\n//\n// See below for preconditions.\nstatic uint32_t //\nwuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t shift) {\n // Masking with 0x3F should be unnecessary (assuming the preconditions) but\n // it's cheap and ensures that we don't overflow the\n // wuffs_base__private_implementation__hpd_left_shift array.\n shift &= 63;\n\n uint32_t x_a = wuffs_base__private_implementation__hpd_left_shift[shift];\n uint32_t x_b = wuffs_base__private_implementation__hpd_left_shift[shift + 1];\n uint32_t num_new_digits = x_a >> 11;\n uint32_t pow5_a = 0x7FF & x_a;\n uint32_t pow5_b = 0x7FF & x_b;\n\n const uint8_t* pow5 =\n &wuffs_base__private_implementation__powers_of_5[pow5_a];\n uint32_t i = 0;\n uint32_t n = pow5_b - pow5_a;\n for (; i < n; i++) {\n if (i >" +
|
||||
"= h->num_digits) {\n return num_new_digits - 1;\n } else if (h->digits[i] == pow5[i]) {\n continue;\n } else if (h->digits[i] < pow5[i]) {\n return num_new_digits - 1;\n } else {\n return num_new_digits;\n }\n }\n return num_new_digits;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__private_implementation__high_prec_dec__rounded_integer returns\n// the integral (non-fractional) part of h, provided that it is 18 or fewer\n// decimal digits. For 19 or more digits, it returns UINT64_MAX. Note that:\n// - (1 << 53) is 9007199254740992, which has 16 decimal digits.\n// - (1 << 56) is 72057594037927936, which has 17 decimal digits.\n// - (1 << 59) is 576460752303423488, which has 18 decimal digits.\n// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.\n// and that IEEE 754 double precision has 52 mantissa bits.\n//\n// That integral part is rounded-to-even: rounding 7.5 or 8.5 both give 8.\n//\n// h's negative bit is ignored: rounding -8.6 returns 9.\n//\n// See below for preconditions.\nstatic uint64_t //\nwuffs_base__private_implementation__high_prec_dec__rounded_integer(\n wuffs_base__private_implementation__high_prec_dec* h) {\n if ((h->num_digits == 0) || (h->decimal_point < 0)) {\n return 0;\n } else if (h->decimal_point > 18) {\n return U" +
|
||||
"INT64_MAX;\n }\n\n uint32_t dp = (uint32_t)(h->decimal_point);\n uint64_t n = 0;\n uint32_t i = 0;\n for (; i < dp; i++) {\n n = (10 * n) + ((i < h->num_digits) ? h->digits[i] : 0);\n }\n\n bool round_up = false;\n if (dp < h->num_digits) {\n round_up = h->digits[dp] >= 5;\n if ((h->digits[dp] == 5) && (dp + 1 == h->num_digits)) {\n // We are exactly halfway. If we're truncated, round up, otherwise round\n // to even.\n round_up = h->truncated || //\n ((dp > 0) && (1 & h->digits[dp - 1]));\n }\n }\n if (round_up) {\n n++;\n }\n\n return n;\n}\n\n// wuffs_base__private_implementation__high_prec_dec__small_xshift shifts h's\n// number (where 'x' is 'l' or 'r' for left or right) by a small shift value.\n//\n// Preconditions:\n// - h is non-NULL.\n// - h->decimal_point is \"not extreme\".\n// - shift is non-zero.\n// - shift is \"a small shift\".\n//\n// \"Not extreme\" means within\n// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.\n//\n// \"A small shift\" means not more than\n/" +
|
||||
"/ WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL.\n//\n// wuffs_base__private_implementation__high_prec_dec__rounded_integer and\n// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits\n// have the same preconditions.\n//\n// wuffs_base__private_implementation__high_prec_dec__lshift keeps the first\n// two preconditions but not the last two. Its shift argument is signed and\n// does not need to be \"small\": zero is a no-op, positive means left shift and\n// negative means right shift.\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__small_lshift(\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t shift) {\n if (h->num_digits == 0) {\n return;\n }\n uint32_t num_new_digits =\n wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(\n h, shift);\n uint32_t rx = h->num_digits - 1; // Read index.\n uint32_t wx = h->num_digits - 1 + num_new_digits; // Write index.\n uint64_t n = 0;\n\n // Repeat: pick up " +
|
||||
"a digit, put down a digit, right to left.\n while (((int32_t)rx) >= 0) {\n n += ((uint64_t)(h->digits[rx])) << shift;\n uint64_t quo = n / 10;\n uint64_t rem = n - (10 * quo);\n if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[wx] = (uint8_t)rem;\n } else if (rem > 0) {\n h->truncated = true;\n }\n n = quo;\n wx--;\n rx--;\n }\n\n // Put down leading digits, right to left.\n while (n > 0) {\n uint64_t quo = n / 10;\n uint64_t rem = n - (10 * quo);\n if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[wx] = (uint8_t)rem;\n } else if (rem > 0) {\n h->truncated = true;\n }\n n = quo;\n wx--;\n }\n\n // Finish.\n h->num_digits += num_new_digits;\n if (h->num_digits >\n WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->num_digits = WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION;\n }\n h->decimal_point += (int32_t)num_new_digits;\n wuffs_base__private_implementation__high_pre" +
|
||||
"c_dec__trim(h);\n}\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__small_rshift(\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t shift) {\n uint32_t rx = 0; // Read index.\n uint32_t wx = 0; // Write index.\n uint64_t n = 0;\n\n // Pick up enough leading digits to cover the first shift.\n while ((n >> shift) == 0) {\n if (rx < h->num_digits) {\n // Read a digit.\n n = (10 * n) + h->digits[rx++];\n } else if (n == 0) {\n // h's number used to be zero and remains zero.\n return;\n } else {\n // Read sufficient implicit trailing zeroes.\n while ((n >> shift) == 0) {\n n = 10 * n;\n rx++;\n }\n break;\n }\n }\n h->decimal_point -= ((int32_t)(rx - 1));\n if (h->decimal_point <\n -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n // After the shift, h's number is effectively zero.\n h->num_digits = 0;\n h->decimal_point = 0;\n h->truncated = false;\n return;\n }\n\n // Repeat: pick up a digi" +
|
||||
"t, put down a digit, left to right.\n uint64_t mask = (((uint64_t)(1)) << shift) - 1;\n while (rx < h->num_digits) {\n uint8_t new_digit = ((uint8_t)(n >> shift));\n n = (10 * (n & mask)) + h->digits[rx++];\n h->digits[wx++] = new_digit;\n }\n\n // Put down trailing digits, left to right.\n while (n > 0) {\n uint8_t new_digit = ((uint8_t)(n >> shift));\n n = 10 * (n & mask);\n if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n h->digits[wx++] = new_digit;\n } else if (new_digit > 0) {\n h->truncated = true;\n }\n }\n\n // Finish.\n h->num_digits = wx;\n wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__lshift(\n wuffs_base__private_implementation__high_prec_dec* h,\n int32_t shift) {\n if (shift > 0) {\n while (shift > +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {\n wuffs_base__private_implementation__high_prec_dec__small_lshift(\n h, WUFFS_BASE__PRIVATE_I" +
|
||||
"MPLEMENTATION__HPD__SHIFT__MAX_INCL);\n shift -= WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n }\n wuffs_base__private_implementation__high_prec_dec__small_lshift(\n h, ((uint32_t)(+shift)));\n } else if (shift < 0) {\n while (shift < -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {\n wuffs_base__private_implementation__high_prec_dec__small_rshift(\n h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);\n shift += WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n }\n wuffs_base__private_implementation__high_prec_dec__small_rshift(\n h, ((uint32_t)(-shift)));\n }\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__private_implementation__high_prec_dec__round_etc rounds h's\n// number. For those functions that take an n argument, rounding produces at\n// most n digits (which is not necessarily at most n decimal places). Negative\n// n values are ignored, as well as any n greater than or equal to h's number\n// of digits. The etc__round_just_enough function implicitly chooses an n to\n// implement WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION.\n//\n// Preconditions:\n// - h is non-NULL.\n// - h->decimal_point is \"not extreme\".\n//\n// \"Not extreme\" means within\n// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__round_down(\n wuffs_base__private_implementation__high_prec_dec* h,\n int32_t n) {\n if ((n < 0) || (h->num_digits <= (uint32_t)n)) {\n return;\n }\n h->num_digits = (uint32_t)(n);\n wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\nstatic void //\nwuffs_base__private_implementation__hi" +
|
||||
"gh_prec_dec__round_up(\n wuffs_base__private_implementation__high_prec_dec* h,\n int32_t n) {\n if ((n < 0) || (h->num_digits <= (uint32_t)n)) {\n return;\n }\n\n for (n--; n >= 0; n--) {\n if (h->digits[n] < 9) {\n h->digits[n]++;\n h->num_digits = (uint32_t)(n + 1);\n return;\n }\n }\n\n // The number is all 9s. Change to a single 1 and adjust the decimal point.\n h->digits[0] = 1;\n h->num_digits = 1;\n h->decimal_point++;\n}\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__round_nearest(\n wuffs_base__private_implementation__high_prec_dec* h,\n int32_t n) {\n if ((n < 0) || (h->num_digits <= (uint32_t)n)) {\n return;\n }\n bool up = h->digits[n] >= 5;\n if ((h->digits[n] == 5) && ((n + 1) == ((int32_t)(h->num_digits)))) {\n up = h->truncated || //\n ((n > 0) && ((h->digits[n - 1] & 1) != 0));\n }\n\n if (up) {\n wuffs_base__private_implementation__high_prec_dec__round_up(h, n);\n } else {\n wuffs_base__private_implementation__high_prec_dec__round_do" +
|
||||
"wn(h, n);\n }\n}\n\nstatic void //\nwuffs_base__private_implementation__high_prec_dec__round_just_enough(\n wuffs_base__private_implementation__high_prec_dec* h,\n int32_t exp2,\n uint64_t mantissa) {\n // The magic numbers 52 and 53 in this function are because IEEE 754 double\n // precision has 52 mantissa bits.\n //\n // Let f be the floating point number represented by exp2 and mantissa (and\n // also the number in h): the number (mantissa * (2 ** (exp2 - 52))).\n //\n // If f is zero or a small integer, we can return early.\n if ((mantissa == 0) ||\n ((exp2 < 53) && (h->decimal_point >= ((int32_t)(h->num_digits))))) {\n return;\n }\n\n // The smallest normal f has an exp2 of -1022 and a mantissa of (1 << 52).\n // Subnormal numbers have the same exp2 but a smaller mantissa.\n static const int32_t min_incl_normal_exp2 = -1022;\n static const uint64_t min_incl_normal_mantissa = 0x0010000000000000ul;\n\n // Compute lower and upper bounds such that any number between them (possibly\n // inclusive) wil" +
|
||||
"l round to f. First, the lower bound. Our number f is:\n // ((mantissa + 0) * (2 ** ( exp2 - 52)))\n //\n // The next lowest floating point number is:\n // ((mantissa - 1) * (2 ** ( exp2 - 52)))\n // unless (mantissa - 1) drops the (1 << 52) bit and exp2 is not the\n // min_incl_normal_exp2. Either way, call it:\n // ((l_mantissa) * (2 ** (l_exp2 - 52)))\n //\n // The lower bound is halfway between them (noting that 52 became 53):\n // (((2 * l_mantissa) + 1) * (2 ** (l_exp2 - 53)))\n int32_t l_exp2 = exp2;\n uint64_t l_mantissa = mantissa - 1;\n if ((exp2 > min_incl_normal_exp2) && (mantissa <= min_incl_normal_mantissa)) {\n l_exp2 = exp2 - 1;\n l_mantissa = (2 * mantissa) - 1;\n }\n wuffs_base__private_implementation__high_prec_dec lower;\n wuffs_base__private_implementation__high_prec_dec__assign(\n &lower, (2 * l_mantissa) + 1, false);\n wuffs_base__private_implementation__high_prec_dec__lshift(&lower,\n " +
|
||||
"l_exp2 - 53);\n\n // Next, the upper bound. Our number f is:\n // ((mantissa + 0) * (2 ** (exp2 - 52)))\n //\n // The next highest floating point number is:\n // ((mantissa + 1) * (2 ** (exp2 - 52)))\n //\n // The upper bound is halfway between them (noting that 52 became 53):\n // (((2 * mantissa) + 1) * (2 ** (exp2 - 53)))\n wuffs_base__private_implementation__high_prec_dec upper;\n wuffs_base__private_implementation__high_prec_dec__assign(\n &upper, (2 * mantissa) + 1, false);\n wuffs_base__private_implementation__high_prec_dec__lshift(&upper, exp2 - 53);\n\n // The lower and upper bounds are possible outputs only if the original\n // mantissa is even, so that IEEE round-to-even would round to the original\n // mantissa and not its neighbors.\n bool inclusive = (mantissa & 1) == 0;\n\n // As we walk the digits, we want to know whether rounding up would fall\n // within the upper bound. This is tracked by upper_delta:\n // - When -1, the digits of h and upper are the same so far.\n // -" +
|
||||
" When +0, we saw a difference of 1 between h and upper on a previous\n // digit and subsequently only 9s for h and 0s for upper. Thus, rounding\n // up may fall outside of the bound if !inclusive.\n // - When +1, the difference is greater than 1 and we know that rounding up\n // falls within the bound.\n //\n // This is a state machine with three states. The numerical value for each\n // state (-1, +0 or +1) isn't important, other than their order.\n int upper_delta = -1;\n\n // We can now figure out the shortest number of digits required. Walk the\n // digits until h has distinguished itself from lower or upper.\n //\n // The zi and zd variables are indexes and digits, for z in l (lower), h (the\n // number) and u (upper).\n //\n // The lower, h and upper numbers may have their decimal points at different\n // places. In this case, upper is the longest, so we iterate ui starting from\n // 0 and iterate li and hi starting from either 0 or -1.\n int32_t ui = 0;\n for (;; ui++) {\n // Calculate hd, t" +
|
||||
"he middle number's digit.\n int32_t hi = ui - upper.decimal_point + h->decimal_point;\n if (hi >= ((int32_t)(h->num_digits))) {\n break;\n }\n uint8_t hd = (((uint32_t)hi) < h->num_digits) ? h->digits[hi] : 0;\n\n // Calculate ld, the lower bound's digit.\n int32_t li = ui - upper.decimal_point + lower.decimal_point;\n uint8_t ld = (((uint32_t)li) < lower.num_digits) ? lower.digits[li] : 0;\n\n // We can round down (truncate) if lower has a different digit than h or if\n // lower is inclusive and is exactly the result of rounding down (i.e. we\n // have reached the final digit of lower).\n bool can_round_down =\n (ld != hd) || //\n (inclusive && ((li + 1) == ((int32_t)(lower.num_digits))));\n\n // Calculate ud, the upper bound's digit, and update upper_delta.\n uint8_t ud = (((uint32_t)ui) < upper.num_digits) ? upper.digits[ui] : 0;\n if (upper_delta < 0) {\n if ((hd + 1) < ud) {\n // For example:\n // h = 12345???\n // upper = 12347???\n " +
|
||||
" upper_delta = +1;\n } else if (hd != ud) {\n // For example:\n // h = 12345???\n // upper = 12346???\n upper_delta = +0;\n }\n } else if (upper_delta == 0) {\n if ((hd != 9) || (ud != 0)) {\n // For example:\n // h = 1234598?\n // upper = 1234600?\n upper_delta = +1;\n }\n }\n\n // We can round up if upper has a different digit than h and either upper\n // is inclusive or upper is bigger than the result of rounding up.\n bool can_round_up =\n (upper_delta > 0) || //\n ((upper_delta == 0) && //\n (inclusive || ((ui + 1) < ((int32_t)(upper.num_digits)))));\n\n // If we can round either way, round to nearest. If we can round only one\n // way, do it. If we can't round, continue the loop.\n if (can_round_down) {\n if (can_round_up) {\n wuffs_base__private_implementation__high_prec_dec__round_nearest(\n h, hi + 1);\n return;\n } else {\n wuffs_base__private_implementat" +
|
||||
"ion__high_prec_dec__round_down(h,\n hi + 1);\n return;\n }\n } else {\n if (can_round_up) {\n wuffs_base__private_implementation__high_prec_dec__round_up(h, hi + 1);\n return;\n }\n }\n }\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__private_implementation__parse_number_f64_eisel_lemire produces\n// the IEEE 754 double-precision value for an exact mantissa and base-10\n// exponent. For example:\n// - when parsing \"12345.678e+02\", man is 12345678 and exp10 is -1.\n// - when parsing \"-12\", man is 12 and exp10 is 0. Processing the leading\n// minus sign is the responsibility of the caller, not this function.\n//\n// On success, it returns a non-negative int64_t such that the low 63 bits hold\n// the 11-bit exponent and 52-bit mantissa.\n//\n// On failure, it returns a negative value.\n//\n// The algorithm is based on an original idea by Michael Eisel that was refined\n// by Daniel Lemire. See\n// https://lemire.me/blog/2020/03/10/fast-float-parsing-in-practice/\n// and\n// https://nigeltao.github.io/blog/2020/eisel-lemire.html\n//\n// Preconditions:\n// - man is non-zero.\n// - exp10 is in the range [-307 ..= 288], the same range of the\n// wuffs_base__private_implementation__powers_of_10 array.\n//\n// The exp10 range (and th" +
|
||||
"e fact that man is in the range [1 ..= UINT64_MAX],\n// approximately [1 ..= 1.85e+19]) means that (man * (10 ** exp10)) is in the\n// range [1e-307 ..= 1.85e+307]. This is entirely within the range of normal\n// (neither subnormal nor non-finite) f64 values: DBL_MIN and DBL_MAX are\n// approximately 2.23e–308 and 1.80e+308.\nstatic int64_t //\nwuffs_base__private_implementation__parse_number_f64_eisel_lemire(\n uint64_t man,\n int32_t exp10) {\n // Look up the (possibly truncated) base-2 representation of (10 ** exp10).\n // The look-up table was constructed so that it is already normalized: the\n // table entry's mantissa's MSB (most significant bit) is on.\n const uint64_t* po10 =\n &wuffs_base__private_implementation__powers_of_10[exp10 + 307][0];\n\n // Normalize the man argument. The (man != 0) precondition means that a\n // non-zero bit exists.\n uint32_t clz = wuffs_base__count_leading_zeroes_u64(man);\n man <<= clz;\n\n // Calculate the return value's base-2 exponent. We might tweak it by ±1\n //" +
|
||||
" later, but its initial value comes from a linear scaling of exp10,\n // converting from power-of-10 to power-of-2, and adjusting by clz.\n //\n // The magic constants are:\n // - 1087 = 1023 + 64. The 1023 is the f64 exponent bias. The 64 is because\n // the look-up table uses 64-bit mantissas.\n // - 217706 is such that the ratio 217706 / 65536 ≈ 3.321930 is close enough\n // (over the practical range of exp10) to log(10) / log(2) ≈ 3.321928.\n // - 65536 = 1<<16 is arbitrary but a power of 2, so division is a shift.\n //\n // Equality of the linearly-scaled value and the actual power-of-2, over the\n // range of exp10 arguments that this function accepts, is confirmed by\n // script/print-mpb-powers-of-10.go\n uint64_t ret_exp2 =\n ((uint64_t)(((217706 * exp10) >> 16) + 1087)) - ((uint64_t)clz);\n\n // Multiply the two mantissas. Normalization means that both mantissas are at\n // least (1<<63), so the 128-bit product must be at least (1<<126). The high\n // 64 bits of the product, x_hi, mu" +
|
||||
"st therefore be at least (1<<62).\n //\n // As a consequence, x_hi has either 0 or 1 leading zeroes. Shifting x_hi\n // right by either 9 or 10 bits (depending on x_hi's MSB) will therefore\n // leave the top 10 MSBs (bits 54 ..= 63) off and the 11th MSB (bit 53) on.\n wuffs_base__multiply_u64__output x = wuffs_base__multiply_u64(man, po10[1]);\n uint64_t x_hi = x.hi;\n uint64_t x_lo = x.lo;\n\n // Before we shift right by at least 9 bits, recall that the look-up table\n // entry was possibly truncated. We have so far only calculated a lower bound\n // for the product (man * e), where e is (10 ** exp10). The upper bound would\n // add a further (man * 1) to the 128-bit product, which overflows the lower\n // 64-bit limb if ((x_lo + man) < man).\n //\n // If overflow occurs, that adds 1 to x_hi. Since we're about to shift right\n // by at least 9 bits, that carried 1 can be ignored unless the higher 64-bit\n // limb's low 9 bits are all on.\n //\n // For example, parsing \"9999999999999999999\" will take the if-t" +
|
||||
"rue branch\n // here, since:\n // - x_hi = 0x4563918244F3FFFF\n // - x_lo = 0x8000000000000000\n // - man = 0x8AC7230489E7FFFF\n if (((x_hi & 0x1FF) == 0x1FF) && ((x_lo + man) < man)) {\n // Refine our calculation of (man * e). Before, our approximation of e used\n // a \"low resolution\" 64-bit mantissa. Now use a \"high resolution\" 128-bit\n // mantissa. We've already calculated x = (man * bits_0_to_63_incl_of_e).\n // Now calculate y = (man * bits_64_to_127_incl_of_e).\n wuffs_base__multiply_u64__output y = wuffs_base__multiply_u64(man, po10[0]);\n uint64_t y_hi = y.hi;\n uint64_t y_lo = y.lo;\n\n // Merge the 128-bit x and 128-bit y, which overlap by 64 bits, to\n // calculate the 192-bit product of the 64-bit man by the 128-bit e.\n // As we exit this if-block, we only care about the high 128 bits\n // (merged_hi and merged_lo) of that 192-bit product.\n //\n // For example, parsing \"1.234e-45\" will take the if-true branch here,\n // since:\n // - x_hi = 0x70B7E3696DB29FFF\n" +
|
||||
" // - x_lo = 0xE040000000000000\n // - y_hi = 0x33718BBEAB0E0D7A\n // - y_lo = 0xA880000000000000\n uint64_t merged_hi = x_hi;\n uint64_t merged_lo = x_lo + y_hi;\n if (merged_lo < x_lo) {\n merged_hi++; // Carry the overflow bit.\n }\n\n // The \"high resolution\" approximation of e is still a lower bound. Once\n // again, see if the upper bound is large enough to produce a different\n // result. This time, if it does, give up instead of reaching for an even\n // more precise approximation to e.\n //\n // This three-part check is similar to the two-part check that guarded the\n // if block that we're now in, but it has an extra term for the middle 64\n // bits (checking that adding 1 to merged_lo would overflow).\n //\n // For example, parsing \"5.9604644775390625e-8\" will take the if-true\n // branch here, since:\n // - merged_hi = 0x7FFFFFFFFFFFFFFF\n // - merged_lo = 0xFFFFFFFFFFFFFFFF\n // - y_lo = 0x4DB3FFC120988200\n // - man = 0xD3C21BCEC" +
|
||||
"CEDA100\n if (((merged_hi & 0x1FF) == 0x1FF) && ((merged_lo + 1) == 0) &&\n (y_lo + man < man)) {\n return -1;\n }\n\n // Replace the 128-bit x with merged.\n x_hi = merged_hi;\n x_lo = merged_lo;\n }\n\n // As mentioned above, shifting x_hi right by either 9 or 10 bits will leave\n // the top 10 MSBs (bits 54 ..= 63) off and the 11th MSB (bit 53) on. If the\n // MSB (before shifting) was on, adjust ret_exp2 for the larger shift.\n //\n // Having bit 53 on (and higher bits off) means that ret_mantissa is a 54-bit\n // number.\n uint64_t msb = x_hi >> 63;\n uint64_t ret_mantissa = x_hi >> (msb + 9);\n ret_exp2 -= 1 ^ msb;\n\n // IEEE 754 rounds to-nearest with ties rounded to-even. Rounding to-even can\n // be tricky. If we're half-way between two exactly representable numbers\n // (x's low 73 bits are zero and the next 2 bits that matter are \"01\"), give\n // up instead of trying to pick the winner.\n //\n // Technically, we could tighten the condition by changing \"73\" to \"73 or 74,\n // depen" +
|
||||
"ding on msb\", but a flat \"73\" is simpler.\n //\n // For example, parsing \"1e+23\" will take the if-true branch here, since:\n // - x_hi = 0x54B40B1F852BDA00\n // - ret_mantissa = 0x002A5A058FC295ED\n if ((x_lo == 0) && ((x_hi & 0x1FF) == 0) && ((ret_mantissa & 3) == 1)) {\n return -1;\n }\n\n // If we're not halfway then it's rounding to-nearest. Starting with a 54-bit\n // number, carry the lowest bit (bit 0) up if it's on. Regardless of whether\n // it was on or off, shifting right by one then produces a 53-bit number. If\n // carrying up overflowed, shift again.\n ret_mantissa += ret_mantissa & 1;\n ret_mantissa >>= 1;\n // This if block is equivalent to (but benchmarks slightly faster than) the\n // following branchless form:\n // uint64_t overflow_adjustment = ret_mantissa >> 53;\n // ret_mantissa >>= overflow_adjustment;\n // ret_exp2 += overflow_adjustment;\n //\n // For example, parsing \"7.2057594037927933e+16\" will take the if-true\n // branch here, since:\n // - x_hi =" +
|
||||
" 0x7FFFFFFFFFFFFE80\n // - ret_mantissa = 0x0020000000000000\n if ((ret_mantissa >> 53) > 0) {\n ret_mantissa >>= 1;\n ret_exp2++;\n }\n\n // Starting with a 53-bit number, IEEE 754 double-precision normal numbers\n // have an implicit mantissa bit. Mask that away and keep the low 52 bits.\n ret_mantissa &= 0x000FFFFFFFFFFFFF;\n\n // Pack the bits and return.\n return ((int64_t)(ret_mantissa | (ret_exp2 << 52)));\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic wuffs_base__result_f64 //\nwuffs_base__private_implementation__parse_number_f64_special(\n wuffs_base__slice_u8 s,\n uint32_t options) {\n do {\n if (options & WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN) {\n goto fail;\n }\n\n uint8_t* p = s.ptr;\n uint8_t* q = s.ptr + s.len;\n\n for (; (p < q) && (*p == '_'); p++) {\n }\n if (p >= q) {\n goto fail;\n }\n\n // Parse sign.\n bool negative = false;\n do {\n if (*p == '+') {\n p++;\n } else if (*p == '-') {\n negative = true;\n p++;\n } else {\n break;\n }\n for (; (p < q) && (*p == '_'); p++) {\n }\n } while (0);\n if (p >= q) {\n goto fail;\n }\n\n bool nan = false;\n switch (p[0]) {\n case 'I':\n case 'i':\n if (((q - p) < 3) || //\n ((p[1] != 'N') && (p[1] != 'n')) || //\n ((p[2] != 'F') && (p[2] != 'f'))) {\n goto fail;\n }\n p += 3;\n\n if ((p >= q) || (*p == '_" +
|
||||
"')) {\n break;\n } else if (((q - p) < 5) || //\n ((p[0] != 'I') && (p[0] != 'i')) || //\n ((p[1] != 'N') && (p[1] != 'n')) || //\n ((p[2] != 'I') && (p[2] != 'i')) || //\n ((p[3] != 'T') && (p[3] != 't')) || //\n ((p[4] != 'Y') && (p[4] != 'y'))) {\n goto fail;\n }\n p += 5;\n\n if ((p >= q) || (*p == '_')) {\n break;\n }\n goto fail;\n\n case 'N':\n case 'n':\n if (((q - p) < 3) || //\n ((p[1] != 'A') && (p[1] != 'a')) || //\n ((p[2] != 'N') && (p[2] != 'n'))) {\n goto fail;\n }\n p += 3;\n\n if ((p >= q) || (*p == '_')) {\n nan = true;\n break;\n }\n goto fail;\n\n default:\n goto fail;\n }\n\n // Finish.\n for (; (p < q) && (*p == '_'); p++) {\n }\n if (p != q) {\n goto fail;\n }\n wuffs_base__result_f64 ret;\n" +
|
||||
" ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n (nan ? 0x7FFFFFFFFFFFFFFF : 0x7FF0000000000000) |\n (negative ? 0x8000000000000000 : 0));\n return ret;\n } while (0);\n\nfail:\n do {\n wuffs_base__result_f64 ret;\n ret.status.repr = wuffs_base__error__bad_argument;\n ret.value = 0;\n return ret;\n } while (0);\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64 //\nwuffs_base__private_implementation__high_prec_dec__to_f64(\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t options) {\n do {\n // powers converts decimal powers of 10 to binary powers of 2. For example,\n // (10000 >> 13) is 1. It stops before the elements exceed 60, also known\n // as WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL.\n static const uint32_t num_powers = 19;\n static const uint8_t powers[19] = {\n 0, 3, 6, 9, 13, 16, 19, 23, 26, 29, //\n 33, 36, 39, 43, 46, 49, 53, 56, 59, //\n };\n\n // Handl" +
|
||||
"e zero and obvious extremes. The largest and smallest positive\n // finite f64 values are approximately 1.8e+308 and 4.9e-324.\n if ((h->num_digits == 0) || (h->decimal_point < -326)) {\n goto zero;\n } else if (h->decimal_point > 310) {\n goto infinity;\n }\n\n // Try the fast Eisel-Lemire algorithm again. Calculating the (man, exp10)\n // pair from the high_prec_dec h is more correct but slower than the\n // approach taken in wuffs_base__parse_number_f64. The latter is optimized\n // for the common cases (e.g. assuming no underscores or a leading '+'\n // sign) rather than the full set of cases allowed by the Wuffs API.\n if (h->num_digits <= 19) {\n uint64_t man = 0;\n uint32_t i;\n for (i = 0; i < h->num_digits; i++) {\n man = (10 * man) + h->digits[i];\n }\n int32_t exp10 = h->decimal_point - ((int32_t)(h->num_digits));\n if ((man != 0) && (-307 <= exp10) && (exp10 <= 288)) {\n int64_t r =\n wuffs_base__private_implementation__parse" +
|
||||
"_number_f64_eisel_lemire(\n man, exp10);\n if (r >= 0) {\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n ((uint64_t)r) | (((uint64_t)(h->negative)) << 63));\n return ret;\n }\n }\n }\n\n // When Eisel-Lemire fails, fall back to Simple Decimal Conversion. See\n // https://nigeltao.github.io/blog/2020/parse-number-f64-simple.html\n //\n // Scale by powers of 2 until we're in the range [½ .. 1], which gives us\n // our exponent (in base-2). First we shift right, possibly a little too\n // far, ending with a value certainly below 1 and possibly below ½...\n const int32_t f64_bias = -1023;\n int32_t exp2 = 0;\n while (h->decimal_point > 0) {\n uint32_t n = (uint32_t)(+h->decimal_point);\n uint32_t shift =\n (n < num_powers)\n ? powers[n]\n : WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n\n " +
|
||||
" wuffs_base__private_implementation__high_prec_dec__small_rshift(h, shift);\n if (h->decimal_point <\n -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n goto zero;\n }\n exp2 += (int32_t)shift;\n }\n // ...then we shift left, putting us in [½ .. 1].\n while (h->decimal_point <= 0) {\n uint32_t shift;\n if (h->decimal_point == 0) {\n if (h->digits[0] >= 5) {\n break;\n }\n shift = (h->digits[0] < 2) ? 2 : 1;\n } else {\n uint32_t n = (uint32_t)(-h->decimal_point);\n shift = (n < num_powers)\n ? powers[n]\n : WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n }\n\n wuffs_base__private_implementation__high_prec_dec__small_lshift(h, shift);\n if (h->decimal_point >\n +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n goto infinity;\n }\n exp2 -= (int32_t)shift;\n }\n\n // We're in the range [½ .. 1] but f64 uses " +
|
||||
"[1 .. 2].\n exp2--;\n\n // The minimum normal exponent is (f64_bias + 1).\n while ((f64_bias + 1) > exp2) {\n uint32_t n = (uint32_t)((f64_bias + 1) - exp2);\n if (n > WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {\n n = WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n }\n wuffs_base__private_implementation__high_prec_dec__small_rshift(h, n);\n exp2 += (int32_t)n;\n }\n\n // Check for overflow.\n if ((exp2 - f64_bias) >= 0x07FF) { // (1 << 11) - 1.\n goto infinity;\n }\n\n // Extract 53 bits for the mantissa (in base-2).\n wuffs_base__private_implementation__high_prec_dec__small_lshift(h, 53);\n uint64_t man2 =\n wuffs_base__private_implementation__high_prec_dec__rounded_integer(h);\n\n // Rounding might have added one bit. If so, shift and re-check overflow.\n if ((man2 >> 53) != 0) {\n man2 >>= 1;\n exp2++;\n if ((exp2 - f64_bias) >= 0x07FF) { // (1 << 11) - 1.\n goto infinity;\n }\n }\n\n // Handle su" +
|
||||
"bnormal numbers.\n if ((man2 >> 52) == 0) {\n exp2 = f64_bias;\n }\n\n // Pack the bits and return.\n uint64_t exp2_bits =\n (uint64_t)((exp2 - f64_bias) & 0x07FF); // (1 << 11) - 1.\n uint64_t bits = (man2 & 0x000FFFFFFFFFFFFF) | // (1 << 52) - 1.\n (exp2_bits << 52) | //\n (h->negative ? 0x8000000000000000 : 0); // (1 << 63).\n\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(bits);\n return ret;\n } while (0);\n\nzero:\n do {\n uint64_t bits = h->negative ? 0x8000000000000000 : 0;\n\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(bits);\n return ret;\n } while (0);\n\ninfinity:\n do {\n if (options & WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN) {\n wuffs_base__result_f64 ret;\n ret.status.repr = wuffs_base__error__bad_argument" +
|
||||
";\n ret.value = 0;\n return ret;\n }\n\n uint64_t bits = h->negative ? 0xFFF0000000000000 : 0x7FF0000000000000;\n\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(bits);\n return ret;\n } while (0);\n}\n\nstatic inline bool //\nwuffs_base__private_implementation__is_decimal_digit(uint8_t c) {\n return ('0' <= c) && (c <= '9');\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64 //\nwuffs_base__parse_number_f64(wuffs_base__slice_u8 s, uint32_t options) {\n // In practice, almost all \"dd.ddddE±xxx\" numbers can be represented\n // losslessly by a uint64_t mantissa \"dddddd\" and an int32_t base-10\n // exponent, adjusting \"xxx\" for the position (if present) of the decimal\n // separator '.' or ','.\n //\n // This (u64 man, i32 exp10) data structure is superficially similar to the\n // \"Do It Yourself Floating Point\" type from Loitsch (†), but the exponent\n // here is base-10, not base-2.\n //\n // If s's number fits in " +
|
||||
"a (man, exp10), parse that pair with the\n // Eisel-Lemire algorithm. If not, or if Eisel-Lemire fails, parsing s with\n // the fallback algorithm is slower but comprehensive.\n //\n // † \"Printing Floating-Point Numbers Quickly and Accurately with Integers\"\n // (https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf).\n // Florian Loitsch is also the primary contributor to\n // https://github.com/google/double-conversion\n do {\n // Calculating that (man, exp10) pair needs to stay within s's bounds.\n // Provided that s isn't extremely long, work on a NUL-terminated copy of\n // s's contents. The NUL byte isn't a valid part of \"±dd.ddddE±xxx\".\n //\n // As the pointer p walks the contents, it's faster to repeatedly check \"is\n // *p a valid digit\" than \"is p within bounds and *p a valid digit\".\n if (s.len >= 256) {\n goto fallback;\n }\n uint8_t z[256];\n memcpy(&z[0], s.ptr, s.len);\n z[s.len] = 0;\n const uint8_t* p = &z[0];\n\n // Look for a leading minus " +
|
||||
"sign. Technically, we could also look for an\n // optional plus sign, but the \"script/process-json-numbers.c with -p\"\n // benchmark is noticably slower if we do. It's optional and, in practice,\n // usually absent. Let the fallback catch it.\n bool negative = (*p == '-');\n if (negative) {\n p++;\n }\n\n // After walking \"dd.dddd\", comparing p later with p now will produce the\n // number of \"d\"s and \".\"s.\n const uint8_t* const start_of_digits_ptr = p;\n\n // Walk the \"d\"s before a '.', 'E', NUL byte, etc. If it starts with '0',\n // it must be a single '0'. If it starts with a non-zero decimal digit, it\n // can be a sequence of decimal digits.\n //\n // Update the man variable during the walk. It's OK if man overflows now.\n // We'll detect that later.\n uint64_t man;\n if (*p == '0') {\n man = 0;\n p++;\n if (wuffs_base__private_implementation__is_decimal_digit(*p)) {\n goto fallback;\n }\n } else if (wuffs_base__private_implementation__is_decim" +
|
||||
"al_digit(*p)) {\n man = ((uint8_t)(*p - '0'));\n p++;\n for (; wuffs_base__private_implementation__is_decimal_digit(*p); p++) {\n man = (10 * man) + ((uint8_t)(*p - '0'));\n }\n } else {\n goto fallback;\n }\n\n // Walk the \"d\"s after the optional decimal separator ('.' or ','),\n // updating the man and exp10 variables.\n int32_t exp10 = 0;\n if (*p ==\n ((options & WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n ? ','\n : '.')) {\n p++;\n const uint8_t* first_after_separator_ptr = p;\n if (!wuffs_base__private_implementation__is_decimal_digit(*p)) {\n goto fallback;\n }\n man = (10 * man) + ((uint8_t)(*p - '0'));\n p++;\n for (; wuffs_base__private_implementation__is_decimal_digit(*p); p++) {\n man = (10 * man) + ((uint8_t)(*p - '0'));\n }\n exp10 = ((int32_t)(first_after_separator_ptr - p));\n }\n\n // Count the number of digits:\n // - for an input of \"314159\", digit_count " +
|
||||
"is 6.\n // - for an input of \"3.14159\", digit_count is 7.\n //\n // This is off-by-one if there is a decimal separator. That's OK for now.\n // We'll correct for that later. The \"script/process-json-numbers.c with\n // -p\" benchmark is noticably slower if we try to correct for that now.\n uint32_t digit_count = (uint32_t)(p - start_of_digits_ptr);\n\n // Update exp10 for the optional exponent, starting with 'E' or 'e'.\n if ((*p | 0x20) == 'e') {\n p++;\n int32_t exp_sign = +1;\n if (*p == '-') {\n p++;\n exp_sign = -1;\n } else if (*p == '+') {\n p++;\n }\n if (!wuffs_base__private_implementation__is_decimal_digit(*p)) {\n goto fallback;\n }\n int32_t exp_num = ((uint8_t)(*p - '0'));\n p++;\n // The rest of the exp_num walking has a peculiar control flow but, once\n // again, the \"script/process-json-numbers.c with -p\" benchmark is\n // sensitive to alternative formulations.\n if (wuffs_base__private_implementation__i" +
|
||||
"s_decimal_digit(*p)) {\n exp_num = (10 * exp_num) + ((uint8_t)(*p - '0'));\n p++;\n }\n if (wuffs_base__private_implementation__is_decimal_digit(*p)) {\n exp_num = (10 * exp_num) + ((uint8_t)(*p - '0'));\n p++;\n }\n while (wuffs_base__private_implementation__is_decimal_digit(*p)) {\n if (exp_num > 0x1000000) {\n goto fallback;\n }\n exp_num = (10 * exp_num) + ((uint8_t)(*p - '0'));\n p++;\n }\n exp10 += exp_sign * exp_num;\n }\n\n // The Wuffs API is that the original slice has no trailing data. It also\n // allows underscores, which we don't catch here but the fallback should.\n if (p != &z[s.len]) {\n goto fallback;\n }\n\n // Check that the uint64_t typed man variable has not overflowed, based on\n // digit_count.\n //\n // For reference:\n // - (1 << 63) is 9223372036854775808, which has 19 decimal digits.\n // - (1 << 64) is 18446744073709551616, which has 20 decimal digits.\n // - 19 nines, " +
|
||||
" 9999999999999999999, is 0x8AC7230489E7FFFF, which has 64\n // bits and 16 hexadecimal digits.\n // - 20 nines, 99999999999999999999, is 0x56BC75E2D630FFFFF, which has 67\n // bits and 17 hexadecimal digits.\n if (digit_count > 19) {\n // Even if we have more than 19 pseudo-digits, it's not yet definitely an\n // overflow. Recall that digit_count might be off-by-one (too large) if\n // there's a decimal separator. It will also over-report the number of\n // meaningful digits if the input looks something like \"0.000dddExxx\".\n //\n // We adjust by the number of leading '0's and '.'s and re-compare to 19.\n // Once again, technically, we could skip ','s too, but that perturbs the\n // \"script/process-json-numbers.c with -p\" benchmark.\n const uint8_t* q = start_of_digits_ptr;\n for (; (*q == '0') || (*q == '.'); q++) {\n }\n digit_count -= (uint32_t)(q - start_of_digits_ptr);\n if (digit_count > 19) {\n goto fallback;\n }\n }\n\n " +
|
||||
" // The wuffs_base__private_implementation__parse_number_f64_eisel_lemire\n // preconditions include that exp10 is in the range [-307 ..= 288].\n if ((exp10 < -307) || (288 < exp10)) {\n goto fallback;\n }\n\n // If both man and (10 ** exp10) are exactly representable by a double, we\n // don't need to run the Eisel-Lemire algorithm.\n if ((-22 <= exp10) && (exp10 <= 22) && ((man >> 53) == 0)) {\n double d = (double)man;\n if (exp10 >= 0) {\n d *= wuffs_base__private_implementation__f64_powers_of_10[+exp10];\n } else {\n d /= wuffs_base__private_implementation__f64_powers_of_10[-exp10];\n }\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = negative ? -d : +d;\n return ret;\n }\n\n // The wuffs_base__private_implementation__parse_number_f64_eisel_lemire\n // preconditions include that man is non-zero. Parsing \"0\" should be caught\n // by the \"If both man and (10 ** exp10)\" above, but \"0e99\" might not.\n if (man == 0) {\n " +
|
||||
" goto fallback;\n }\n\n // Our man and exp10 are in range. Run the Eisel-Lemire algorithm.\n int64_t r =\n wuffs_base__private_implementation__parse_number_f64_eisel_lemire(\n man, exp10);\n if (r < 0) {\n goto fallback;\n }\n wuffs_base__result_f64 ret;\n ret.status.repr = NULL;\n ret.value = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n ((uint64_t)r) | (((uint64_t)negative) << 63));\n return ret;\n } while (0);\n\nfallback:\n do {\n wuffs_base__private_implementation__high_prec_dec h;\n wuffs_base__status status =\n wuffs_base__private_implementation__high_prec_dec__parse(&h, s,\n options);\n if (status.repr) {\n return wuffs_base__private_implementation__parse_number_f64_special(\n s, options);\n }\n return wuffs_base__private_implementation__high_prec_dec__to_f64(&h,\n options);\n } while (0);\n" +
|
||||
"}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic inline size_t //\nwuffs_base__private_implementation__render_inf(wuffs_base__slice_u8 dst,\n bool neg,\n uint32_t options) {\n if (neg) {\n if (dst.len < 4) {\n return 0;\n }\n wuffs_base__poke_u32le__no_bounds_check(dst.ptr, 0x666E492D); // '-Inf'le.\n return 4;\n }\n\n if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n if (dst.len < 4) {\n return 0;\n }\n wuffs_base__poke_u32le__no_bounds_check(dst.ptr, 0x666E492B); // '+Inf'le.\n return 4;\n }\n\n if (dst.len < 3) {\n return 0;\n }\n wuffs_base__poke_u24le__no_bounds_check(dst.ptr, 0x666E49); // 'Inf'le.\n return 3;\n}\n\nstatic inline size_t //\nwuffs_base__private_implementation__render_nan(wuffs_base__slice_u8 dst) {\n if (dst.len < 3) {\n return 0;\n }\n wuffs_base__poke_u24le__no_bounds_check(dst.ptr, 0x4E614E); // 'NaN'le.\n return 3;\n}\n\nstatic size_t //\nwuffs_base__private_implementation__high_pre" +
|
||||
"c_dec__render_exponent_absent(\n wuffs_base__slice_u8 dst,\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t precision,\n uint32_t options) {\n size_t n = (h->negative ||\n (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))\n ? 1\n : 0;\n if (h->decimal_point <= 0) {\n n += 1;\n } else {\n n += (size_t)(h->decimal_point);\n }\n if (precision > 0) {\n n += precision + 1; // +1 for the '.'.\n }\n\n // Don't modify dst if the formatted number won't fit.\n if (n > dst.len) {\n return 0;\n }\n\n // Align-left or align-right.\n uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)\n ? &dst.ptr[dst.len - n]\n : &dst.ptr[0];\n\n // Leading \"±\".\n if (h->negative) {\n *ptr++ = '-';\n } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n *ptr++ = '+';\n }\n\n // Integral digits.\n if (h->decimal_point <= 0) {\n *ptr++ = '0';\n } else {\n uint32_t m =\n " +
|
||||
" wuffs_base__u32__min(h->num_digits, (uint32_t)(h->decimal_point));\n uint32_t i = 0;\n for (; i < m; i++) {\n *ptr++ = (uint8_t)('0' | h->digits[i]);\n }\n for (; i < (uint32_t)(h->decimal_point); i++) {\n *ptr++ = '0';\n }\n }\n\n // Separator and then fractional digits.\n if (precision > 0) {\n *ptr++ =\n (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n ? ','\n : '.';\n uint32_t i = 0;\n for (; i < precision; i++) {\n uint32_t j = ((uint32_t)(h->decimal_point)) + i;\n *ptr++ = (uint8_t)('0' | ((j < h->num_digits) ? h->digits[j] : 0));\n }\n }\n\n return n;\n}\n\nstatic size_t //\nwuffs_base__private_implementation__high_prec_dec__render_exponent_present(\n wuffs_base__slice_u8 dst,\n wuffs_base__private_implementation__high_prec_dec* h,\n uint32_t precision,\n uint32_t options) {\n int32_t exp = 0;\n if (h->num_digits > 0) {\n exp = h->decimal_point - 1;\n }\n bool negative_exp = exp < 0;\n if (negative_exp) {\n " +
|
||||
"exp = -exp;\n }\n\n size_t n = (h->negative ||\n (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))\n ? 4\n : 3; // Mininum 3 bytes: first digit and then \"e±\".\n if (precision > 0) {\n n += precision + 1; // +1 for the '.'.\n }\n n += (exp < 100) ? 2 : 3;\n\n // Don't modify dst if the formatted number won't fit.\n if (n > dst.len) {\n return 0;\n }\n\n // Align-left or align-right.\n uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)\n ? &dst.ptr[dst.len - n]\n : &dst.ptr[0];\n\n // Leading \"±\".\n if (h->negative) {\n *ptr++ = '-';\n } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n *ptr++ = '+';\n }\n\n // Integral digit.\n if (h->num_digits > 0) {\n *ptr++ = (uint8_t)('0' | h->digits[0]);\n } else {\n *ptr++ = '0';\n }\n\n // Separator and then fractional digits.\n if (precision > 0) {\n *ptr++ =\n (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATO" +
|
||||
"R_IS_A_COMMA)\n ? ','\n : '.';\n uint32_t i = 1;\n uint32_t j = wuffs_base__u32__min(h->num_digits, precision + 1);\n for (; i < j; i++) {\n *ptr++ = (uint8_t)('0' | h->digits[i]);\n }\n for (; i <= precision; i++) {\n *ptr++ = '0';\n }\n }\n\n // Exponent: \"e±\" and then 2 or 3 digits.\n *ptr++ = 'e';\n *ptr++ = negative_exp ? '-' : '+';\n if (exp < 10) {\n *ptr++ = '0';\n *ptr++ = (uint8_t)('0' | exp);\n } else if (exp < 100) {\n *ptr++ = (uint8_t)('0' | (exp / 10));\n *ptr++ = (uint8_t)('0' | (exp % 10));\n } else {\n int32_t e = exp / 100;\n exp -= e * 100;\n *ptr++ = (uint8_t)('0' | e);\n *ptr++ = (uint8_t)('0' | (exp / 10));\n *ptr++ = (uint8_t)('0' | (exp % 10));\n }\n\n return n;\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_f64(wuffs_base__slice_u8 dst,\n double x,\n uint32_t precision,\n uint32_t options) {\n // Decompose x (64 bits) into nega" +
|
||||
"tivity (1 bit), base-2 exponent (11 bits\n // with a -1023 bias) and mantissa (52 bits).\n uint64_t bits = wuffs_base__ieee_754_bit_representation__from_f64_to_u64(x);\n bool neg = (bits >> 63) != 0;\n int32_t exp2 = ((int32_t)(bits >> 52)) & 0x7FF;\n uint64_t man = bits & 0x000FFFFFFFFFFFFFul;\n\n // Apply the exponent bias and set the implicit top bit of the mantissa,\n // unless x is subnormal. Also take care of Inf and NaN.\n if (exp2 == 0x7FF) {\n if (man != 0) {\n return wuffs_base__private_implementation__render_nan(dst);\n }\n return wuffs_base__private_implementation__render_inf(dst, neg, options);\n } else if (exp2 == 0) {\n exp2 = -1022;\n } else {\n exp2 -= 1023;\n man |= 0x0010000000000000ul;\n }\n\n // Ensure that precision isn't too large.\n if (precision > 4095) {\n precision = 4095;\n }\n\n // Convert from the (neg, exp2, man) tuple to an HPD.\n wuffs_base__private_implementation__high_prec_dec h;\n wuffs_base__private_implementation__high_prec_dec__assign(&h, man, neg);\n if (" +
|
||||
"h.num_digits > 0) {\n wuffs_base__private_implementation__high_prec_dec__lshift(\n &h, exp2 - 52); // 52 mantissa bits.\n }\n\n // Handle the \"%e\" and \"%f\" formats.\n switch (options & (WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT |\n WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT)) {\n case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT: // The \"%\"f\" format.\n if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {\n wuffs_base__private_implementation__high_prec_dec__round_just_enough(\n &h, exp2, man);\n int32_t p = ((int32_t)(h.num_digits)) - h.decimal_point;\n precision = ((uint32_t)(wuffs_base__i32__max(0, p)));\n } else {\n wuffs_base__private_implementation__high_prec_dec__round_nearest(\n &h, ((int32_t)precision) + h.decimal_point);\n }\n return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(\n dst, &h, precision, options);\n\n case WUFFS_BASE__RENDER_NUMBER_FX" +
|
||||
"X__EXPONENT_PRESENT: // The \"%e\" format.\n if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {\n wuffs_base__private_implementation__high_prec_dec__round_just_enough(\n &h, exp2, man);\n precision = (h.num_digits > 0) ? (h.num_digits - 1) : 0;\n } else {\n wuffs_base__private_implementation__high_prec_dec__round_nearest(\n &h, ((int32_t)precision) + 1);\n }\n return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(\n dst, &h, precision, options);\n }\n\n // We have the \"%g\" format and so precision means the number of significant\n // digits, not the number of digits after the decimal separator. Perform\n // rounding and determine whether to use \"%e\" or \"%f\".\n int32_t e_threshold = 0;\n if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {\n wuffs_base__private_implementation__high_prec_dec__round_just_enough(\n &h, exp2, man);\n precision = h.num_digits;\n e_threshold = 6;\n }" +
|
||||
" else {\n if (precision == 0) {\n precision = 1;\n }\n wuffs_base__private_implementation__high_prec_dec__round_nearest(\n &h, ((int32_t)precision));\n e_threshold = ((int32_t)precision);\n int32_t nd = ((int32_t)(h.num_digits));\n if ((e_threshold > nd) && (nd >= h.decimal_point)) {\n e_threshold = nd;\n }\n }\n\n // Use the \"%e\" format if the exponent is large.\n int32_t e = h.decimal_point - 1;\n if ((e < -4) || (e_threshold <= e)) {\n uint32_t p = wuffs_base__u32__min(precision, h.num_digits);\n return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(\n dst, &h, (p > 0) ? (p - 1) : 0, options);\n }\n\n // Use the \"%f\" format otherwise.\n int32_t p = ((int32_t)precision);\n if (p > h.decimal_point) {\n p = ((int32_t)(h.num_digits));\n }\n precision = ((uint32_t)(wuffs_base__i32__max(0, p - h.decimal_point)));\n return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(\n dst, &h, precision, options);\n}\n" +
|
||||
""
|
||||
|
||||
const BaseFloatConvSubmoduleDataC = "" +
|
||||
"// ---------------- IEEE 754 Floating Point\n\n// The etc__hpd_left_shift and etc__powers_of_5 tables were printed by\n// script/print-hpd-left-shift.go. That script has an optional -comments flag,\n// whose output is not copied here, which prints further detail.\n//\n// These tables are used in\n// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits.\n\n// wuffs_base__private_implementation__hpd_left_shift[i] encodes the number of\n// new digits created after multiplying a positive integer by (1 << i): the\n// additional length in the decimal representation. For example, shifting \"234\"\n// by 3 (equivalent to multiplying by 8) will produce \"1872\". Going from a\n// 3-length string to a 4-length string means that 1 new digit was added (and\n// existing digits may have changed).\n//\n// Shifting by i can add either N or N-1 new digits, depending on whether the\n// original positive integer compares >= or < to the i'th power of 5 (as 10\n// equals 2 * 5). Comparison is lexicographic, not numerical.\n//\n// For " +
|
||||
"example, shifting by 4 (i.e. multiplying by 16) can add 1 or 2 new\n// digits, depending on a lexicographic comparison to (5 ** 4), i.e. \"625\":\n// - (\"1\" << 4) is \"16\", which adds 1 new digit.\n// - (\"5678\" << 4) is \"90848\", which adds 1 new digit.\n// - (\"624\" << 4) is \"9984\", which adds 1 new digit.\n// - (\"62498\" << 4) is \"999968\", which adds 1 new digit.\n// - (\"625\" << 4) is \"10000\", which adds 2 new digits.\n// - (\"625001\" << 4) is \"10000016\", which adds 2 new digits.\n// - (\"7008\" << 4) is \"112128\", which adds 2 new digits.\n// - (\"99\" << 4) is \"1584\", which adds 2 new digits.\n//\n// Thus, when i is 4, N is 2 and (5 ** i) is \"625\". This etc__hpd_left_shift\n// array encodes this as:\n// - etc__hpd_left_shift[4] is 0x1006 = (2 << 11) | 0x0006.\n// - etc__hpd_left_shift[5] is 0x1009 = (? << 11) | 0x0009.\n// where the ? isn't relevant for i == 4.\n//\n// The high 5 bits of etc__hpd_left_shift[i] is N, the higher of the two\n// possible number of new digits. The low 1" +
|
||||
"1 bits are an offset into the\n// etc__powers_of_5 array (of length 0x051C, so offsets fit in 11 bits). When i\n// is 4, its offset and the next one is 6 and 9, and etc__powers_of_5[6 .. 9]\n// is the string \"\\x06\\x02\\x05\", so the relevant power of 5 is \"625\".\n//\n// Thanks to Ken Thompson for the original idea.\nstatic const uint16_t wuffs_base__private_implementation__hpd_left_shift[65] = {\n 0x0000, 0x0800, 0x0801, 0x0803, 0x1006, 0x1009, 0x100D, 0x1812, 0x1817,\n 0x181D, 0x2024, 0x202B, 0x2033, 0x203C, 0x2846, 0x2850, 0x285B, 0x3067,\n 0x3073, 0x3080, 0x388E, 0x389C, 0x38AB, 0x38BB, 0x40CC, 0x40DD, 0x40EF,\n 0x4902, 0x4915, 0x4929, 0x513E, 0x5153, 0x5169, 0x5180, 0x5998, 0x59B0,\n 0x59C9, 0x61E3, 0x61FD, 0x6218, 0x6A34, 0x6A50, 0x6A6D, 0x6A8B, 0x72AA,\n 0x72C9, 0x72E9, 0x7B0A, 0x7B2B, 0x7B4D, 0x8370, 0x8393, 0x83B7, 0x83DC,\n 0x8C02, 0x8C28, 0x8C4F, 0x9477, 0x949F, 0x94C8, 0x9CF2, 0x051C, 0x051C,\n 0x051C, 0x051C,\n};\n\n// wuffs_base__private_implementation__powers_of_5 contains the powers of 5,\n" +
|
||||
"// concatenated together: \"5\", \"25\", \"125\", \"625\", \"3125\", etc.\nstatic const uint8_t wuffs_base__private_implementation__powers_of_5[0x051C] = {\n 5, 2, 5, 1, 2, 5, 6, 2, 5, 3, 1, 2, 5, 1, 5, 6, 2, 5, 7, 8, 1, 2, 5, 3, 9,\n 0, 6, 2, 5, 1, 9, 5, 3, 1, 2, 5, 9, 7, 6, 5, 6, 2, 5, 4, 8, 8, 2, 8, 1, 2,\n 5, 2, 4, 4, 1, 4, 0, 6, 2, 5, 1, 2, 2, 0, 7, 0, 3, 1, 2, 5, 6, 1, 0, 3, 5,\n 1, 5, 6, 2, 5, 3, 0, 5, 1, 7, 5, 7, 8, 1, 2, 5, 1, 5, 2, 5, 8, 7, 8, 9, 0,\n 6, 2, 5, 7, 6, 2, 9, 3, 9, 4, 5, 3, 1, 2, 5, 3, 8, 1, 4, 6, 9, 7, 2, 6, 5,\n 6, 2, 5, 1, 9, 0, 7, 3, 4, 8, 6, 3, 2, 8, 1, 2, 5, 9, 5, 3, 6, 7, 4, 3, 1,\n 6, 4, 0, 6, 2, 5, 4, 7, 6, 8, 3, 7, 1, 5, 8, 2, 0, 3, 1, 2, 5, 2, 3, 8, 4,\n 1, 8, 5, 7, 9, 1, 0, 1, 5, 6, 2, 5, 1, 1, 9, 2, 0, 9, 2, 8, 9, 5, 5, 0, 7,\n 8, 1, 2, 5, 5, 9, 6, 0, 4, 6, 4, 4, 7, 7, 5, 3, 9, 0, 6, 2, 5, 2, 9, 8, 0,\n 2, 3, 2, 2, 3, 8, 7, 6, 9, 5, 3, 1, 2, 5, 1, 4, 9, 0, 1, 1, 6, 1, 1, 9, 3,\n 8, 4, 7, 6, 5, 6, 2, 5, 7, 4, 5, 0, 5, 8, 0, 5, 9, 6, 9, 2, 3, 8, 2, 8, 1,\n 2, 5, " +
|
||||
"3, 7, 2, 5, 2, 9, 0, 2, 9, 8, 4, 6, 1, 9, 1, 4, 0, 6, 2, 5, 1, 8, 6,\n 2, 6, 4, 5, 1, 4, 9, 2, 3, 0, 9, 5, 7, 0, 3, 1, 2, 5, 9, 3, 1, 3, 2, 2, 5,\n 7, 4, 6, 1, 5, 4, 7, 8, 5, 1, 5, 6, 2, 5, 4, 6, 5, 6, 6, 1, 2, 8, 7, 3, 0,\n 7, 7, 3, 9, 2, 5, 7, 8, 1, 2, 5, 2, 3, 2, 8, 3, 0, 6, 4, 3, 6, 5, 3, 8, 6,\n 9, 6, 2, 8, 9, 0, 6, 2, 5, 1, 1, 6, 4, 1, 5, 3, 2, 1, 8, 2, 6, 9, 3, 4, 8,\n 1, 4, 4, 5, 3, 1, 2, 5, 5, 8, 2, 0, 7, 6, 6, 0, 9, 1, 3, 4, 6, 7, 4, 0, 7,\n 2, 2, 6, 5, 6, 2, 5, 2, 9, 1, 0, 3, 8, 3, 0, 4, 5, 6, 7, 3, 3, 7, 0, 3, 6,\n 1, 3, 2, 8, 1, 2, 5, 1, 4, 5, 5, 1, 9, 1, 5, 2, 2, 8, 3, 6, 6, 8, 5, 1, 8,\n 0, 6, 6, 4, 0, 6, 2, 5, 7, 2, 7, 5, 9, 5, 7, 6, 1, 4, 1, 8, 3, 4, 2, 5, 9,\n 0, 3, 3, 2, 0, 3, 1, 2, 5, 3, 6, 3, 7, 9, 7, 8, 8, 0, 7, 0, 9, 1, 7, 1, 2,\n 9, 5, 1, 6, 6, 0, 1, 5, 6, 2, 5, 1, 8, 1, 8, 9, 8, 9, 4, 0, 3, 5, 4, 5, 8,\n 5, 6, 4, 7, 5, 8, 3, 0, 0, 7, 8, 1, 2, 5, 9, 0, 9, 4, 9, 4, 7, 0, 1, 7, 7,\n 2, 9, 2, 8, 2, 3, 7, 9, 1, 5, 0, 3, 9, 0, 6, 2, 5, 4, 5, 4, 7, 4, 7, 3, 5,\n 0, " +
|
||||
"8, 8, 6, 4, 6, 4, 1, 1, 8, 9, 5, 7, 5, 1, 9, 5, 3, 1, 2, 5, 2, 2, 7, 3,\n 7, 3, 6, 7, 5, 4, 4, 3, 2, 3, 2, 0, 5, 9, 4, 7, 8, 7, 5, 9, 7, 6, 5, 6, 2,\n 5, 1, 1, 3, 6, 8, 6, 8, 3, 7, 7, 2, 1, 6, 1, 6, 0, 2, 9, 7, 3, 9, 3, 7, 9,\n 8, 8, 2, 8, 1, 2, 5, 5, 6, 8, 4, 3, 4, 1, 8, 8, 6, 0, 8, 0, 8, 0, 1, 4, 8,\n 6, 9, 6, 8, 9, 9, 4, 1, 4, 0, 6, 2, 5, 2, 8, 4, 2, 1, 7, 0, 9, 4, 3, 0, 4,\n 0, 4, 0, 0, 7, 4, 3, 4, 8, 4, 4, 9, 7, 0, 7, 0, 3, 1, 2, 5, 1, 4, 2, 1, 0,\n 8, 5, 4, 7, 1, 5, 2, 0, 2, 0, 0, 3, 7, 1, 7, 4, 2, 2, 4, 8, 5, 3, 5, 1, 5,\n 6, 2, 5, 7, 1, 0, 5, 4, 2, 7, 3, 5, 7, 6, 0, 1, 0, 0, 1, 8, 5, 8, 7, 1, 1,\n 2, 4, 2, 6, 7, 5, 7, 8, 1, 2, 5, 3, 5, 5, 2, 7, 1, 3, 6, 7, 8, 8, 0, 0, 5,\n 0, 0, 9, 2, 9, 3, 5, 5, 6, 2, 1, 3, 3, 7, 8, 9, 0, 6, 2, 5, 1, 7, 7, 6, 3,\n 5, 6, 8, 3, 9, 4, 0, 0, 2, 5, 0, 4, 6, 4, 6, 7, 7, 8, 1, 0, 6, 6, 8, 9, 4,\n 5, 3, 1, 2, 5, 8, 8, 8, 1, 7, 8, 4, 1, 9, 7, 0, 0, 1, 2, 5, 2, 3, 2, 3, 3,\n 8, 9, 0, 5, 3, 3, 4, 4, 7, 2, 6, 5, 6, 2, 5, 4, 4, 4, 0, 8, 9, 2, 0, 9, 8,\n " +
|
||||
"5, 0, 0, 6, 2, 6, 1, 6, 1, 6, 9, 4, 5, 2, 6, 6, 7, 2, 3, 6, 3, 2, 8, 1, 2,\n 5, 2, 2, 2, 0, 4, 4, 6, 0, 4, 9, 2, 5, 0, 3, 1, 3, 0, 8, 0, 8, 4, 7, 2, 6,\n 3, 3, 3, 6, 1, 8, 1, 6, 4, 0, 6, 2, 5, 1, 1, 1, 0, 2, 2, 3, 0, 2, 4, 6, 2,\n 5, 1, 5, 6, 5, 4, 0, 4, 2, 3, 6, 3, 1, 6, 6, 8, 0, 9, 0, 8, 2, 0, 3, 1, 2,\n 5, 5, 5, 5, 1, 1, 1, 5, 1, 2, 3, 1, 2, 5, 7, 8, 2, 7, 0, 2, 1, 1, 8, 1, 5,\n 8, 3, 4, 0, 4, 5, 4, 1, 0, 1, 5, 6, 2, 5, 2, 7, 7, 5, 5, 5, 7, 5, 6, 1, 5,\n 6, 2, 8, 9, 1, 3, 5, 1, 0, 5, 9, 0, 7, 9, 1, 7, 0, 2, 2, 7, 0, 5, 0, 7, 8,\n 1, 2, 5, 1, 3, 8, 7, 7, 7, 8, 7, 8, 0, 7, 8, 1, 4, 4, 5, 6, 7, 5, 5, 2, 9,\n 5, 3, 9, 5, 8, 5, 1, 1, 3, 5, 2, 5, 3, 9, 0, 6, 2, 5, 6, 9, 3, 8, 8, 9, 3,\n 9, 0, 3, 9, 0, 7, 2, 2, 8, 3, 7, 7, 6, 4, 7, 6, 9, 7, 9, 2, 5, 5, 6, 7, 6,\n 2, 6, 9, 5, 3, 1, 2, 5, 3, 4, 6, 9, 4, 4, 6, 9, 5, 1, 9, 5, 3, 6, 1, 4, 1,\n 8, 8, 8, 2, 3, 8, 4, 8, 9, 6, 2, 7, 8, 3, 8, 1, 3, 4, 7, 6, 5, 6, 2, 5, 1,\n 7, 3, 4, 7, 2, 3, 4, 7, 5, 9, 7, 6, 8, 0, 7, 0, 9, 4, 4, 1, 1, 9, 2, 4, 4,\n " +
|
||||
" 8, 1, 3, 9, 1, 9, 0, 6, 7, 3, 8, 2, 8, 1, 2, 5, 8, 6, 7, 3, 6, 1, 7, 3, 7,\n 9, 8, 8, 4, 0, 3, 5, 4, 7, 2, 0, 5, 9, 6, 2, 2, 4, 0, 6, 9, 5, 9, 5, 3, 3,\n 6, 9, 1, 4, 0, 6, 2, 5,\n};\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__private_implementation__powers_of_10 contains truncated\n// approximations to the powers of 10, ranging from 1e-307 to 1e+288 inclusive,\n// as 596 pairs of uint64_t values (a 128-bit mantissa).\n//\n// There's also an implicit third column (implied by a linear formula involving\n// the base-10 exponent) that is the base-2 exponent, biased by a magic\n// constant. That constant (1214 or 0x04BE) equals 1023 + 191. 1023 is the bias\n// for IEEE 754 double-precision floating point. 191 is ((3 * 64) - 1) and\n// wuffs_base__private_implementation__parse_number_f64_eisel_lemire works with\n// multiples-of-64-bit mantissas.\n//\n// For example, the third row holds the approximation to 1e-305:\n// 0xE0B62E29_29ABA83C_331ACDAB_FE94DE87 * (2 ** (0x0049 - 0x04BE))\n//\n// Similarly, 1e+4 is approximated by:\n// 0x9C400000_00000000_00000000_00000000 * (2 ** (0x044C - 0x04BE))\n//\n// Similarly, 1e+68 is approximated by:\n// 0xED63A231_D4C4FB27_4CA7AAA8_63EE4BDD * (2 ** (0x0520 - 0x04BE))\n//\n// This table" +
|
||||
" was generated by by script/print-mpb-powers-of-10.go\nstatic const uint64_t wuffs_base__private_implementation__powers_of_10[596][2] =\n {\n {0xA5D3B6D479F8E056, 0x8FD0C16206306BAB}, // 1e-307\n {0x8F48A4899877186C, 0xB3C4F1BA87BC8696}, // 1e-306\n {0x331ACDABFE94DE87, 0xE0B62E2929ABA83C}, // 1e-305\n {0x9FF0C08B7F1D0B14, 0x8C71DCD9BA0B4925}, // 1e-304\n {0x07ECF0AE5EE44DD9, 0xAF8E5410288E1B6F}, // 1e-303\n {0xC9E82CD9F69D6150, 0xDB71E91432B1A24A}, // 1e-302\n {0xBE311C083A225CD2, 0x892731AC9FAF056E}, // 1e-301\n {0x6DBD630A48AAF406, 0xAB70FE17C79AC6CA}, // 1e-300\n {0x092CBBCCDAD5B108, 0xD64D3D9DB981787D}, // 1e-299\n {0x25BBF56008C58EA5, 0x85F0468293F0EB4E}, // 1e-298\n {0xAF2AF2B80AF6F24E, 0xA76C582338ED2621}, // 1e-297\n {0x1AF5AF660DB4AEE1, 0xD1476E2C07286FAA}, // 1e-296\n {0x50D98D9FC890ED4D, 0x82CCA4DB847945CA}, // 1e-295\n {0xE50FF107BAB528A0, 0xA37FCE126597973C}, // 1e-294\n {0x1E53ED49A96272C8, " +
|
||||
"0xCC5FC196FEFD7D0C}, // 1e-293\n {0x25E8E89C13BB0F7A, 0xFF77B1FCBEBCDC4F}, // 1e-292\n {0x77B191618C54E9AC, 0x9FAACF3DF73609B1}, // 1e-291\n {0xD59DF5B9EF6A2417, 0xC795830D75038C1D}, // 1e-290\n {0x4B0573286B44AD1D, 0xF97AE3D0D2446F25}, // 1e-289\n {0x4EE367F9430AEC32, 0x9BECCE62836AC577}, // 1e-288\n {0x229C41F793CDA73F, 0xC2E801FB244576D5}, // 1e-287\n {0x6B43527578C1110F, 0xF3A20279ED56D48A}, // 1e-286\n {0x830A13896B78AAA9, 0x9845418C345644D6}, // 1e-285\n {0x23CC986BC656D553, 0xBE5691EF416BD60C}, // 1e-284\n {0x2CBFBE86B7EC8AA8, 0xEDEC366B11C6CB8F}, // 1e-283\n {0x7BF7D71432F3D6A9, 0x94B3A202EB1C3F39}, // 1e-282\n {0xDAF5CCD93FB0CC53, 0xB9E08A83A5E34F07}, // 1e-281\n {0xD1B3400F8F9CFF68, 0xE858AD248F5C22C9}, // 1e-280\n {0x23100809B9C21FA1, 0x91376C36D99995BE}, // 1e-279\n {0xABD40A0C2832A78A, 0xB58547448FFFFB2D}, // 1e-278\n {0x16C90C8F323F516C, 0xE2E69915B3FFF9F9}, // 1e-277\n {0xAE3DA" +
|
||||
"7D97F6792E3, 0x8DD01FAD907FFC3B}, // 1e-276\n {0x99CD11CFDF41779C, 0xB1442798F49FFB4A}, // 1e-275\n {0x40405643D711D583, 0xDD95317F31C7FA1D}, // 1e-274\n {0x482835EA666B2572, 0x8A7D3EEF7F1CFC52}, // 1e-273\n {0xDA3243650005EECF, 0xAD1C8EAB5EE43B66}, // 1e-272\n {0x90BED43E40076A82, 0xD863B256369D4A40}, // 1e-271\n {0x5A7744A6E804A291, 0x873E4F75E2224E68}, // 1e-270\n {0x711515D0A205CB36, 0xA90DE3535AAAE202}, // 1e-269\n {0x0D5A5B44CA873E03, 0xD3515C2831559A83}, // 1e-268\n {0xE858790AFE9486C2, 0x8412D9991ED58091}, // 1e-267\n {0x626E974DBE39A872, 0xA5178FFF668AE0B6}, // 1e-266\n {0xFB0A3D212DC8128F, 0xCE5D73FF402D98E3}, // 1e-265\n {0x7CE66634BC9D0B99, 0x80FA687F881C7F8E}, // 1e-264\n {0x1C1FFFC1EBC44E80, 0xA139029F6A239F72}, // 1e-263\n {0xA327FFB266B56220, 0xC987434744AC874E}, // 1e-262\n {0x4BF1FF9F0062BAA8, 0xFBE9141915D7A922}, // 1e-261\n {0x6F773FC3603DB4A9, 0x9D71AC8FADA6C9B5}, // 1e-260\n " +
|
||||
" {0xCB550FB4384D21D3, 0xC4CE17B399107C22}, // 1e-259\n {0x7E2A53A146606A48, 0xF6019DA07F549B2B}, // 1e-258\n {0x2EDA7444CBFC426D, 0x99C102844F94E0FB}, // 1e-257\n {0xFA911155FEFB5308, 0xC0314325637A1939}, // 1e-256\n {0x793555AB7EBA27CA, 0xF03D93EEBC589F88}, // 1e-255\n {0x4BC1558B2F3458DE, 0x96267C7535B763B5}, // 1e-254\n {0x9EB1AAEDFB016F16, 0xBBB01B9283253CA2}, // 1e-253\n {0x465E15A979C1CADC, 0xEA9C227723EE8BCB}, // 1e-252\n {0x0BFACD89EC191EC9, 0x92A1958A7675175F}, // 1e-251\n {0xCEF980EC671F667B, 0xB749FAED14125D36}, // 1e-250\n {0x82B7E12780E7401A, 0xE51C79A85916F484}, // 1e-249\n {0xD1B2ECB8B0908810, 0x8F31CC0937AE58D2}, // 1e-248\n {0x861FA7E6DCB4AA15, 0xB2FE3F0B8599EF07}, // 1e-247\n {0x67A791E093E1D49A, 0xDFBDCECE67006AC9}, // 1e-246\n {0xE0C8BB2C5C6D24E0, 0x8BD6A141006042BD}, // 1e-245\n {0x58FAE9F773886E18, 0xAECC49914078536D}, // 1e-244\n {0xAF39A475506A899E, 0xDA7F5BF590966848}, " +
|
||||
"// 1e-243\n {0x6D8406C952429603, 0x888F99797A5E012D}, // 1e-242\n {0xC8E5087BA6D33B83, 0xAAB37FD7D8F58178}, // 1e-241\n {0xFB1E4A9A90880A64, 0xD5605FCDCF32E1D6}, // 1e-240\n {0x5CF2EEA09A55067F, 0x855C3BE0A17FCD26}, // 1e-239\n {0xF42FAA48C0EA481E, 0xA6B34AD8C9DFC06F}, // 1e-238\n {0xF13B94DAF124DA26, 0xD0601D8EFC57B08B}, // 1e-237\n {0x76C53D08D6B70858, 0x823C12795DB6CE57}, // 1e-236\n {0x54768C4B0C64CA6E, 0xA2CB1717B52481ED}, // 1e-235\n {0xA9942F5DCF7DFD09, 0xCB7DDCDDA26DA268}, // 1e-234\n {0xD3F93B35435D7C4C, 0xFE5D54150B090B02}, // 1e-233\n {0xC47BC5014A1A6DAF, 0x9EFA548D26E5A6E1}, // 1e-232\n {0x359AB6419CA1091B, 0xC6B8E9B0709F109A}, // 1e-231\n {0xC30163D203C94B62, 0xF867241C8CC6D4C0}, // 1e-230\n {0x79E0DE63425DCF1D, 0x9B407691D7FC44F8}, // 1e-229\n {0x985915FC12F542E4, 0xC21094364DFB5636}, // 1e-228\n {0x3E6F5B7B17B2939D, 0xF294B943E17A2BC4}, // 1e-227\n {0xA705992CEECF9C42, 0x979CF3C" +
|
||||
"A6CEC5B5A}, // 1e-226\n {0x50C6FF782A838353, 0xBD8430BD08277231}, // 1e-225\n {0xA4F8BF5635246428, 0xECE53CEC4A314EBD}, // 1e-224\n {0x871B7795E136BE99, 0x940F4613AE5ED136}, // 1e-223\n {0x28E2557B59846E3F, 0xB913179899F68584}, // 1e-222\n {0x331AEADA2FE589CF, 0xE757DD7EC07426E5}, // 1e-221\n {0x3FF0D2C85DEF7621, 0x9096EA6F3848984F}, // 1e-220\n {0x0FED077A756B53A9, 0xB4BCA50B065ABE63}, // 1e-219\n {0xD3E8495912C62894, 0xE1EBCE4DC7F16DFB}, // 1e-218\n {0x64712DD7ABBBD95C, 0x8D3360F09CF6E4BD}, // 1e-217\n {0xBD8D794D96AACFB3, 0xB080392CC4349DEC}, // 1e-216\n {0xECF0D7A0FC5583A0, 0xDCA04777F541C567}, // 1e-215\n {0xF41686C49DB57244, 0x89E42CAAF9491B60}, // 1e-214\n {0x311C2875C522CED5, 0xAC5D37D5B79B6239}, // 1e-213\n {0x7D633293366B828B, 0xD77485CB25823AC7}, // 1e-212\n {0xAE5DFF9C02033197, 0x86A8D39EF77164BC}, // 1e-211\n {0xD9F57F830283FDFC, 0xA8530886B54DBDEB}, // 1e-210\n {0xD072DF63C324FD" +
|
||||
"7B, 0xD267CAA862A12D66}, // 1e-209\n {0x4247CB9E59F71E6D, 0x8380DEA93DA4BC60}, // 1e-208\n {0x52D9BE85F074E608, 0xA46116538D0DEB78}, // 1e-207\n {0x67902E276C921F8B, 0xCD795BE870516656}, // 1e-206\n {0x00BA1CD8A3DB53B6, 0x806BD9714632DFF6}, // 1e-205\n {0x80E8A40ECCD228A4, 0xA086CFCD97BF97F3}, // 1e-204\n {0x6122CD128006B2CD, 0xC8A883C0FDAF7DF0}, // 1e-203\n {0x796B805720085F81, 0xFAD2A4B13D1B5D6C}, // 1e-202\n {0xCBE3303674053BB0, 0x9CC3A6EEC6311A63}, // 1e-201\n {0xBEDBFC4411068A9C, 0xC3F490AA77BD60FC}, // 1e-200\n {0xEE92FB5515482D44, 0xF4F1B4D515ACB93B}, // 1e-199\n {0x751BDD152D4D1C4A, 0x991711052D8BF3C5}, // 1e-198\n {0xD262D45A78A0635D, 0xBF5CD54678EEF0B6}, // 1e-197\n {0x86FB897116C87C34, 0xEF340A98172AACE4}, // 1e-196\n {0xD45D35E6AE3D4DA0, 0x9580869F0E7AAC0E}, // 1e-195\n {0x8974836059CCA109, 0xBAE0A846D2195712}, // 1e-194\n {0x2BD1A438703FC94B, 0xE998D258869FACD7}, // 1e-193\n {0x7" +
|
||||
"B6306A34627DDCF, 0x91FF83775423CC06}, // 1e-192\n {0x1A3BC84C17B1D542, 0xB67F6455292CBF08}, // 1e-191\n {0x20CABA5F1D9E4A93, 0xE41F3D6A7377EECA}, // 1e-190\n {0x547EB47B7282EE9C, 0x8E938662882AF53E}, // 1e-189\n {0xE99E619A4F23AA43, 0xB23867FB2A35B28D}, // 1e-188\n {0x6405FA00E2EC94D4, 0xDEC681F9F4C31F31}, // 1e-187\n {0xDE83BC408DD3DD04, 0x8B3C113C38F9F37E}, // 1e-186\n {0x9624AB50B148D445, 0xAE0B158B4738705E}, // 1e-185\n {0x3BADD624DD9B0957, 0xD98DDAEE19068C76}, // 1e-184\n {0xE54CA5D70A80E5D6, 0x87F8A8D4CFA417C9}, // 1e-183\n {0x5E9FCF4CCD211F4C, 0xA9F6D30A038D1DBC}, // 1e-182\n {0x7647C3200069671F, 0xD47487CC8470652B}, // 1e-181\n {0x29ECD9F40041E073, 0x84C8D4DFD2C63F3B}, // 1e-180\n {0xF468107100525890, 0xA5FB0A17C777CF09}, // 1e-179\n {0x7182148D4066EEB4, 0xCF79CC9DB955C2CC}, // 1e-178\n {0xC6F14CD848405530, 0x81AC1FE293D599BF}, // 1e-177\n {0xB8ADA00E5A506A7C, 0xA21727DB38CB002F}, // 1e-176" +
|
||||
"\n {0xA6D90811F0E4851C, 0xCA9CF1D206FDC03B}, // 1e-175\n {0x908F4A166D1DA663, 0xFD442E4688BD304A}, // 1e-174\n {0x9A598E4E043287FE, 0x9E4A9CEC15763E2E}, // 1e-173\n {0x40EFF1E1853F29FD, 0xC5DD44271AD3CDBA}, // 1e-172\n {0xD12BEE59E68EF47C, 0xF7549530E188C128}, // 1e-171\n {0x82BB74F8301958CE, 0x9A94DD3E8CF578B9}, // 1e-170\n {0xE36A52363C1FAF01, 0xC13A148E3032D6E7}, // 1e-169\n {0xDC44E6C3CB279AC1, 0xF18899B1BC3F8CA1}, // 1e-168\n {0x29AB103A5EF8C0B9, 0x96F5600F15A7B7E5}, // 1e-167\n {0x7415D448F6B6F0E7, 0xBCB2B812DB11A5DE}, // 1e-166\n {0x111B495B3464AD21, 0xEBDF661791D60F56}, // 1e-165\n {0xCAB10DD900BEEC34, 0x936B9FCEBB25C995}, // 1e-164\n {0x3D5D514F40EEA742, 0xB84687C269EF3BFB}, // 1e-163\n {0x0CB4A5A3112A5112, 0xE65829B3046B0AFA}, // 1e-162\n {0x47F0E785EABA72AB, 0x8FF71A0FE2C2E6DC}, // 1e-161\n {0x59ED216765690F56, 0xB3F4E093DB73A093}, // 1e-160\n {0x306869C13EC3532C, 0xE0F218B8D25088B8" +
|
||||
"}, // 1e-159\n {0x1E414218C73A13FB, 0x8C974F7383725573}, // 1e-158\n {0xE5D1929EF90898FA, 0xAFBD2350644EEACF}, // 1e-157\n {0xDF45F746B74ABF39, 0xDBAC6C247D62A583}, // 1e-156\n {0x6B8BBA8C328EB783, 0x894BC396CE5DA772}, // 1e-155\n {0x066EA92F3F326564, 0xAB9EB47C81F5114F}, // 1e-154\n {0xC80A537B0EFEFEBD, 0xD686619BA27255A2}, // 1e-153\n {0xBD06742CE95F5F36, 0x8613FD0145877585}, // 1e-152\n {0x2C48113823B73704, 0xA798FC4196E952E7}, // 1e-151\n {0xF75A15862CA504C5, 0xD17F3B51FCA3A7A0}, // 1e-150\n {0x9A984D73DBE722FB, 0x82EF85133DE648C4}, // 1e-149\n {0xC13E60D0D2E0EBBA, 0xA3AB66580D5FDAF5}, // 1e-148\n {0x318DF905079926A8, 0xCC963FEE10B7D1B3}, // 1e-147\n {0xFDF17746497F7052, 0xFFBBCFE994E5C61F}, // 1e-146\n {0xFEB6EA8BEDEFA633, 0x9FD561F1FD0F9BD3}, // 1e-145\n {0xFE64A52EE96B8FC0, 0xC7CABA6E7C5382C8}, // 1e-144\n {0x3DFDCE7AA3C673B0, 0xF9BD690A1B68637B}, // 1e-143\n {0x06BEA10CA65C084E, 0x9C1" +
|
||||
"661A651213E2D}, // 1e-142\n {0x486E494FCFF30A62, 0xC31BFA0FE5698DB8}, // 1e-141\n {0x5A89DBA3C3EFCCFA, 0xF3E2F893DEC3F126}, // 1e-140\n {0xF89629465A75E01C, 0x986DDB5C6B3A76B7}, // 1e-139\n {0xF6BBB397F1135823, 0xBE89523386091465}, // 1e-138\n {0x746AA07DED582E2C, 0xEE2BA6C0678B597F}, // 1e-137\n {0xA8C2A44EB4571CDC, 0x94DB483840B717EF}, // 1e-136\n {0x92F34D62616CE413, 0xBA121A4650E4DDEB}, // 1e-135\n {0x77B020BAF9C81D17, 0xE896A0D7E51E1566}, // 1e-134\n {0x0ACE1474DC1D122E, 0x915E2486EF32CD60}, // 1e-133\n {0x0D819992132456BA, 0xB5B5ADA8AAFF80B8}, // 1e-132\n {0x10E1FFF697ED6C69, 0xE3231912D5BF60E6}, // 1e-131\n {0xCA8D3FFA1EF463C1, 0x8DF5EFABC5979C8F}, // 1e-130\n {0xBD308FF8A6B17CB2, 0xB1736B96B6FD83B3}, // 1e-129\n {0xAC7CB3F6D05DDBDE, 0xDDD0467C64BCE4A0}, // 1e-128\n {0x6BCDF07A423AA96B, 0x8AA22C0DBEF60EE4}, // 1e-127\n {0x86C16C98D2C953C6, 0xAD4AB7112EB3929D}, // 1e-126\n {0xE871C7BF07" +
|
||||
"7BA8B7, 0xD89D64D57A607744}, // 1e-125\n {0x11471CD764AD4972, 0x87625F056C7C4A8B}, // 1e-124\n {0xD598E40D3DD89BCF, 0xA93AF6C6C79B5D2D}, // 1e-123\n {0x4AFF1D108D4EC2C3, 0xD389B47879823479}, // 1e-122\n {0xCEDF722A585139BA, 0x843610CB4BF160CB}, // 1e-121\n {0xC2974EB4EE658828, 0xA54394FE1EEDB8FE}, // 1e-120\n {0x733D226229FEEA32, 0xCE947A3DA6A9273E}, // 1e-119\n {0x0806357D5A3F525F, 0x811CCC668829B887}, // 1e-118\n {0xCA07C2DCB0CF26F7, 0xA163FF802A3426A8}, // 1e-117\n {0xFC89B393DD02F0B5, 0xC9BCFF6034C13052}, // 1e-116\n {0xBBAC2078D443ACE2, 0xFC2C3F3841F17C67}, // 1e-115\n {0xD54B944B84AA4C0D, 0x9D9BA7832936EDC0}, // 1e-114\n {0x0A9E795E65D4DF11, 0xC5029163F384A931}, // 1e-113\n {0x4D4617B5FF4A16D5, 0xF64335BCF065D37D}, // 1e-112\n {0x504BCED1BF8E4E45, 0x99EA0196163FA42E}, // 1e-111\n {0xE45EC2862F71E1D6, 0xC06481FB9BCF8D39}, // 1e-110\n {0x5D767327BB4E5A4C, 0xF07DA27A82C37088}, // 1e-109\n " +
|
||||
"{0x3A6A07F8D510F86F, 0x964E858C91BA2655}, // 1e-108\n {0x890489F70A55368B, 0xBBE226EFB628AFEA}, // 1e-107\n {0x2B45AC74CCEA842E, 0xEADAB0ABA3B2DBE5}, // 1e-106\n {0x3B0B8BC90012929D, 0x92C8AE6B464FC96F}, // 1e-105\n {0x09CE6EBB40173744, 0xB77ADA0617E3BBCB}, // 1e-104\n {0xCC420A6A101D0515, 0xE55990879DDCAABD}, // 1e-103\n {0x9FA946824A12232D, 0x8F57FA54C2A9EAB6}, // 1e-102\n {0x47939822DC96ABF9, 0xB32DF8E9F3546564}, // 1e-101\n {0x59787E2B93BC56F7, 0xDFF9772470297EBD}, // 1e-100\n {0x57EB4EDB3C55B65A, 0x8BFBEA76C619EF36}, // 1e-99\n {0xEDE622920B6B23F1, 0xAEFAE51477A06B03}, // 1e-98\n {0xE95FAB368E45ECED, 0xDAB99E59958885C4}, // 1e-97\n {0x11DBCB0218EBB414, 0x88B402F7FD75539B}, // 1e-96\n {0xD652BDC29F26A119, 0xAAE103B5FCD2A881}, // 1e-95\n {0x4BE76D3346F0495F, 0xD59944A37C0752A2}, // 1e-94\n {0x6F70A4400C562DDB, 0x857FCAE62D8493A5}, // 1e-93\n {0xCB4CCD500F6BB952, 0xA6DFBD9FB8E5B88E}, // 1e-92\n " +
|
||||
" {0x7E2000A41346A7A7, 0xD097AD07A71F26B2}, // 1e-91\n {0x8ED400668C0C28C8, 0x825ECC24C873782F}, // 1e-90\n {0x728900802F0F32FA, 0xA2F67F2DFA90563B}, // 1e-89\n {0x4F2B40A03AD2FFB9, 0xCBB41EF979346BCA}, // 1e-88\n {0xE2F610C84987BFA8, 0xFEA126B7D78186BC}, // 1e-87\n {0x0DD9CA7D2DF4D7C9, 0x9F24B832E6B0F436}, // 1e-86\n {0x91503D1C79720DBB, 0xC6EDE63FA05D3143}, // 1e-85\n {0x75A44C6397CE912A, 0xF8A95FCF88747D94}, // 1e-84\n {0xC986AFBE3EE11ABA, 0x9B69DBE1B548CE7C}, // 1e-83\n {0xFBE85BADCE996168, 0xC24452DA229B021B}, // 1e-82\n {0xFAE27299423FB9C3, 0xF2D56790AB41C2A2}, // 1e-81\n {0xDCCD879FC967D41A, 0x97C560BA6B0919A5}, // 1e-80\n {0x5400E987BBC1C920, 0xBDB6B8E905CB600F}, // 1e-79\n {0x290123E9AAB23B68, 0xED246723473E3813}, // 1e-78\n {0xF9A0B6720AAF6521, 0x9436C0760C86E30B}, // 1e-77\n {0xF808E40E8D5B3E69, 0xB94470938FA89BCE}, // 1e-76\n {0xB60B1D1230B20E04, 0xE7958CB87392C2C2}, // 1e-75\n " +
|
||||
" {0xB1C6F22B5E6F48C2, 0x90BD77F3483BB9B9}, // 1e-74\n {0x1E38AEB6360B1AF3, 0xB4ECD5F01A4AA828}, // 1e-73\n {0x25C6DA63C38DE1B0, 0xE2280B6C20DD5232}, // 1e-72\n {0x579C487E5A38AD0E, 0x8D590723948A535F}, // 1e-71\n {0x2D835A9DF0C6D851, 0xB0AF48EC79ACE837}, // 1e-70\n {0xF8E431456CF88E65, 0xDCDB1B2798182244}, // 1e-69\n {0x1B8E9ECB641B58FF, 0x8A08F0F8BF0F156B}, // 1e-68\n {0xE272467E3D222F3F, 0xAC8B2D36EED2DAC5}, // 1e-67\n {0x5B0ED81DCC6ABB0F, 0xD7ADF884AA879177}, // 1e-66\n {0x98E947129FC2B4E9, 0x86CCBB52EA94BAEA}, // 1e-65\n {0x3F2398D747B36224, 0xA87FEA27A539E9A5}, // 1e-64\n {0x8EEC7F0D19A03AAD, 0xD29FE4B18E88640E}, // 1e-63\n {0x1953CF68300424AC, 0x83A3EEEEF9153E89}, // 1e-62\n {0x5FA8C3423C052DD7, 0xA48CEAAAB75A8E2B}, // 1e-61\n {0x3792F412CB06794D, 0xCDB02555653131B6}, // 1e-60\n {0xE2BBD88BBEE40BD0, 0x808E17555F3EBF11}, // 1e-59\n {0x5B6ACEAEAE9D0EC4, 0xA0B19D2AB70E6ED6}, // 1e-58\n {0x" +
|
||||
"F245825A5A445275, 0xC8DE047564D20A8B}, // 1e-57\n {0xEED6E2F0F0D56712, 0xFB158592BE068D2E}, // 1e-56\n {0x55464DD69685606B, 0x9CED737BB6C4183D}, // 1e-55\n {0xAA97E14C3C26B886, 0xC428D05AA4751E4C}, // 1e-54\n {0xD53DD99F4B3066A8, 0xF53304714D9265DF}, // 1e-53\n {0xE546A8038EFE4029, 0x993FE2C6D07B7FAB}, // 1e-52\n {0xDE98520472BDD033, 0xBF8FDB78849A5F96}, // 1e-51\n {0x963E66858F6D4440, 0xEF73D256A5C0F77C}, // 1e-50\n {0xDDE7001379A44AA8, 0x95A8637627989AAD}, // 1e-49\n {0x5560C018580D5D52, 0xBB127C53B17EC159}, // 1e-48\n {0xAAB8F01E6E10B4A6, 0xE9D71B689DDE71AF}, // 1e-47\n {0xCAB3961304CA70E8, 0x9226712162AB070D}, // 1e-46\n {0x3D607B97C5FD0D22, 0xB6B00D69BB55C8D1}, // 1e-45\n {0x8CB89A7DB77C506A, 0xE45C10C42A2B3B05}, // 1e-44\n {0x77F3608E92ADB242, 0x8EB98A7A9A5B04E3}, // 1e-43\n {0x55F038B237591ED3, 0xB267ED1940F1C61C}, // 1e-42\n {0x6B6C46DEC52F6688, 0xDF01E85F912E37A3}, // 1e-41\n {0x2323" +
|
||||
"AC4B3B3DA015, 0x8B61313BBABCE2C6}, // 1e-40\n {0xABEC975E0A0D081A, 0xAE397D8AA96C1B77}, // 1e-39\n {0x96E7BD358C904A21, 0xD9C7DCED53C72255}, // 1e-38\n {0x7E50D64177DA2E54, 0x881CEA14545C7575}, // 1e-37\n {0xDDE50BD1D5D0B9E9, 0xAA242499697392D2}, // 1e-36\n {0x955E4EC64B44E864, 0xD4AD2DBFC3D07787}, // 1e-35\n {0xBD5AF13BEF0B113E, 0x84EC3C97DA624AB4}, // 1e-34\n {0xECB1AD8AEACDD58E, 0xA6274BBDD0FADD61}, // 1e-33\n {0x67DE18EDA5814AF2, 0xCFB11EAD453994BA}, // 1e-32\n {0x80EACF948770CED7, 0x81CEB32C4B43FCF4}, // 1e-31\n {0xA1258379A94D028D, 0xA2425FF75E14FC31}, // 1e-30\n {0x096EE45813A04330, 0xCAD2F7F5359A3B3E}, // 1e-29\n {0x8BCA9D6E188853FC, 0xFD87B5F28300CA0D}, // 1e-28\n {0x775EA264CF55347D, 0x9E74D1B791E07E48}, // 1e-27\n {0x95364AFE032A819D, 0xC612062576589DDA}, // 1e-26\n {0x3A83DDBD83F52204, 0xF79687AED3EEC551}, // 1e-25\n {0xC4926A9672793542, 0x9ABE14CD44753B52}, // 1e-24\n {0x75B7053C" +
|
||||
"0F178293, 0xC16D9A0095928A27}, // 1e-23\n {0x5324C68B12DD6338, 0xF1C90080BAF72CB1}, // 1e-22\n {0xD3F6FC16EBCA5E03, 0x971DA05074DA7BEE}, // 1e-21\n {0x88F4BB1CA6BCF584, 0xBCE5086492111AEA}, // 1e-20\n {0x2B31E9E3D06C32E5, 0xEC1E4A7DB69561A5}, // 1e-19\n {0x3AFF322E62439FCF, 0x9392EE8E921D5D07}, // 1e-18\n {0x09BEFEB9FAD487C2, 0xB877AA3236A4B449}, // 1e-17\n {0x4C2EBE687989A9B3, 0xE69594BEC44DE15B}, // 1e-16\n {0x0F9D37014BF60A10, 0x901D7CF73AB0ACD9}, // 1e-15\n {0x538484C19EF38C94, 0xB424DC35095CD80F}, // 1e-14\n {0x2865A5F206B06FB9, 0xE12E13424BB40E13}, // 1e-13\n {0xF93F87B7442E45D3, 0x8CBCCC096F5088CB}, // 1e-12\n {0xF78F69A51539D748, 0xAFEBFF0BCB24AAFE}, // 1e-11\n {0xB573440E5A884D1B, 0xDBE6FECEBDEDD5BE}, // 1e-10\n {0x31680A88F8953030, 0x89705F4136B4A597}, // 1e-9\n {0xFDC20D2B36BA7C3D, 0xABCC77118461CEFC}, // 1e-8\n {0x3D32907604691B4C, 0xD6BF94D5E57A42BC}, // 1e-7\n {0xA63F9A49C2C1B10" +
|
||||
"F, 0x8637BD05AF6C69B5}, // 1e-6\n {0x0FCF80DC33721D53, 0xA7C5AC471B478423}, // 1e-5\n {0xD3C36113404EA4A8, 0xD1B71758E219652B}, // 1e-4\n {0x645A1CAC083126E9, 0x83126E978D4FDF3B}, // 1e-3\n {0x3D70A3D70A3D70A3, 0xA3D70A3D70A3D70A}, // 1e-2\n {0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC}, // 1e-1\n {0x0000000000000000, 0x8000000000000000}, // 1e0\n {0x0000000000000000, 0xA000000000000000}, // 1e1\n {0x0000000000000000, 0xC800000000000000}, // 1e2\n {0x0000000000000000, 0xFA00000000000000}, // 1e3\n {0x0000000000000000, 0x9C40000000000000}, // 1e4\n {0x0000000000000000, 0xC350000000000000}, // 1e5\n {0x0000000000000000, 0xF424000000000000}, // 1e6\n {0x0000000000000000, 0x9896800000000000}, // 1e7\n {0x0000000000000000, 0xBEBC200000000000}, // 1e8\n {0x0000000000000000, 0xEE6B280000000000}, // 1e9\n {0x0000000000000000, 0x9502F90000000000}, // 1e10\n {0x0000000000000000, 0xBA43B74000000000}, // 1e1" +
|
||||
"1\n {0x0000000000000000, 0xE8D4A51000000000}, // 1e12\n {0x0000000000000000, 0x9184E72A00000000}, // 1e13\n {0x0000000000000000, 0xB5E620F480000000}, // 1e14\n {0x0000000000000000, 0xE35FA931A0000000}, // 1e15\n {0x0000000000000000, 0x8E1BC9BF04000000}, // 1e16\n {0x0000000000000000, 0xB1A2BC2EC5000000}, // 1e17\n {0x0000000000000000, 0xDE0B6B3A76400000}, // 1e18\n {0x0000000000000000, 0x8AC7230489E80000}, // 1e19\n {0x0000000000000000, 0xAD78EBC5AC620000}, // 1e20\n {0x0000000000000000, 0xD8D726B7177A8000}, // 1e21\n {0x0000000000000000, 0x878678326EAC9000}, // 1e22\n {0x0000000000000000, 0xA968163F0A57B400}, // 1e23\n {0x0000000000000000, 0xD3C21BCECCEDA100}, // 1e24\n {0x0000000000000000, 0x84595161401484A0}, // 1e25\n {0x0000000000000000, 0xA56FA5B99019A5C8}, // 1e26\n {0x0000000000000000, 0xCECB8F27F4200F3A}, // 1e27\n {0x4000000000000000, 0x813F3978F8940984}, // 1e28\n {0x50000000" +
|
||||
"00000000, 0xA18F07D736B90BE5}, // 1e29\n {0xA400000000000000, 0xC9F2C9CD04674EDE}, // 1e30\n {0x4D00000000000000, 0xFC6F7C4045812296}, // 1e31\n {0xF020000000000000, 0x9DC5ADA82B70B59D}, // 1e32\n {0x6C28000000000000, 0xC5371912364CE305}, // 1e33\n {0xC732000000000000, 0xF684DF56C3E01BC6}, // 1e34\n {0x3C7F400000000000, 0x9A130B963A6C115C}, // 1e35\n {0x4B9F100000000000, 0xC097CE7BC90715B3}, // 1e36\n {0x1E86D40000000000, 0xF0BDC21ABB48DB20}, // 1e37\n {0x1314448000000000, 0x96769950B50D88F4}, // 1e38\n {0x17D955A000000000, 0xBC143FA4E250EB31}, // 1e39\n {0x5DCFAB0800000000, 0xEB194F8E1AE525FD}, // 1e40\n {0x5AA1CAE500000000, 0x92EFD1B8D0CF37BE}, // 1e41\n {0xF14A3D9E40000000, 0xB7ABC627050305AD}, // 1e42\n {0x6D9CCD05D0000000, 0xE596B7B0C643C719}, // 1e43\n {0xE4820023A2000000, 0x8F7E32CE7BEA5C6F}, // 1e44\n {0xDDA2802C8A800000, 0xB35DBF821AE4F38B}, // 1e45\n {0xD50B2037AD200000, 0xE0352F62A" +
|
||||
"19E306E}, // 1e46\n {0x4526F422CC340000, 0x8C213D9DA502DE45}, // 1e47\n {0x9670B12B7F410000, 0xAF298D050E4395D6}, // 1e48\n {0x3C0CDD765F114000, 0xDAF3F04651D47B4C}, // 1e49\n {0xA5880A69FB6AC800, 0x88D8762BF324CD0F}, // 1e50\n {0x8EEA0D047A457A00, 0xAB0E93B6EFEE0053}, // 1e51\n {0x72A4904598D6D880, 0xD5D238A4ABE98068}, // 1e52\n {0x47A6DA2B7F864750, 0x85A36366EB71F041}, // 1e53\n {0x999090B65F67D924, 0xA70C3C40A64E6C51}, // 1e54\n {0xFFF4B4E3F741CF6D, 0xD0CF4B50CFE20765}, // 1e55\n {0xBFF8F10E7A8921A4, 0x82818F1281ED449F}, // 1e56\n {0xAFF72D52192B6A0D, 0xA321F2D7226895C7}, // 1e57\n {0x9BF4F8A69F764490, 0xCBEA6F8CEB02BB39}, // 1e58\n {0x02F236D04753D5B4, 0xFEE50B7025C36A08}, // 1e59\n {0x01D762422C946590, 0x9F4F2726179A2245}, // 1e60\n {0x424D3AD2B7B97EF5, 0xC722F0EF9D80AAD6}, // 1e61\n {0xD2E0898765A7DEB2, 0xF8EBAD2B84E0D58B}, // 1e62\n {0x63CC55F49F88EB2F, 0x9B934C3B330C8577}, // 1e63\n " +
|
||||
" {0x3CBF6B71C76B25FB, 0xC2781F49FFCFA6D5}, // 1e64\n {0x8BEF464E3945EF7A, 0xF316271C7FC3908A}, // 1e65\n {0x97758BF0E3CBB5AC, 0x97EDD871CFDA3A56}, // 1e66\n {0x3D52EEED1CBEA317, 0xBDE94E8E43D0C8EC}, // 1e67\n {0x4CA7AAA863EE4BDD, 0xED63A231D4C4FB27}, // 1e68\n {0x8FE8CAA93E74EF6A, 0x945E455F24FB1CF8}, // 1e69\n {0xB3E2FD538E122B44, 0xB975D6B6EE39E436}, // 1e70\n {0x60DBBCA87196B616, 0xE7D34C64A9C85D44}, // 1e71\n {0xBC8955E946FE31CD, 0x90E40FBEEA1D3A4A}, // 1e72\n {0x6BABAB6398BDBE41, 0xB51D13AEA4A488DD}, // 1e73\n {0xC696963C7EED2DD1, 0xE264589A4DCDAB14}, // 1e74\n {0xFC1E1DE5CF543CA2, 0x8D7EB76070A08AEC}, // 1e75\n {0x3B25A55F43294BCB, 0xB0DE65388CC8ADA8}, // 1e76\n {0x49EF0EB713F39EBE, 0xDD15FE86AFFAD912}, // 1e77\n {0x6E3569326C784337, 0x8A2DBF142DFCC7AB}, // 1e78\n {0x49C2C37F07965404, 0xACB92ED9397BF996}, // 1e79\n {0xDC33745EC97BE906, 0xD7E77A8F87DAF7FB}, // 1e80\n {0x69A028BB3DED" +
|
||||
"71A3, 0x86F0AC99B4E8DAFD}, // 1e81\n {0xC40832EA0D68CE0C, 0xA8ACD7C0222311BC}, // 1e82\n {0xF50A3FA490C30190, 0xD2D80DB02AABD62B}, // 1e83\n {0x792667C6DA79E0FA, 0x83C7088E1AAB65DB}, // 1e84\n {0x577001B891185938, 0xA4B8CAB1A1563F52}, // 1e85\n {0xED4C0226B55E6F86, 0xCDE6FD5E09ABCF26}, // 1e86\n {0x544F8158315B05B4, 0x80B05E5AC60B6178}, // 1e87\n {0x696361AE3DB1C721, 0xA0DC75F1778E39D6}, // 1e88\n {0x03BC3A19CD1E38E9, 0xC913936DD571C84C}, // 1e89\n {0x04AB48A04065C723, 0xFB5878494ACE3A5F}, // 1e90\n {0x62EB0D64283F9C76, 0x9D174B2DCEC0E47B}, // 1e91\n {0x3BA5D0BD324F8394, 0xC45D1DF942711D9A}, // 1e92\n {0xCA8F44EC7EE36479, 0xF5746577930D6500}, // 1e93\n {0x7E998B13CF4E1ECB, 0x9968BF6ABBE85F20}, // 1e94\n {0x9E3FEDD8C321A67E, 0xBFC2EF456AE276E8}, // 1e95\n {0xC5CFE94EF3EA101E, 0xEFB3AB16C59B14A2}, // 1e96\n {0xBBA1F1D158724A12, 0x95D04AEE3B80ECE5}, // 1e97\n {0x2A8A6E45AE8EDC97, 0xBB445DA9CA612" +
|
||||
"81F}, // 1e98\n {0xF52D09D71A3293BD, 0xEA1575143CF97226}, // 1e99\n {0x593C2626705F9C56, 0x924D692CA61BE758}, // 1e100\n {0x6F8B2FB00C77836C, 0xB6E0C377CFA2E12E}, // 1e101\n {0x0B6DFB9C0F956447, 0xE498F455C38B997A}, // 1e102\n {0x4724BD4189BD5EAC, 0x8EDF98B59A373FEC}, // 1e103\n {0x58EDEC91EC2CB657, 0xB2977EE300C50FE7}, // 1e104\n {0x2F2967B66737E3ED, 0xDF3D5E9BC0F653E1}, // 1e105\n {0xBD79E0D20082EE74, 0x8B865B215899F46C}, // 1e106\n {0xECD8590680A3AA11, 0xAE67F1E9AEC07187}, // 1e107\n {0xE80E6F4820CC9495, 0xDA01EE641A708DE9}, // 1e108\n {0x3109058D147FDCDD, 0x884134FE908658B2}, // 1e109\n {0xBD4B46F0599FD415, 0xAA51823E34A7EEDE}, // 1e110\n {0x6C9E18AC7007C91A, 0xD4E5E2CDC1D1EA96}, // 1e111\n {0x03E2CF6BC604DDB0, 0x850FADC09923329E}, // 1e112\n {0x84DB8346B786151C, 0xA6539930BF6BFF45}, // 1e113\n {0xE612641865679A63, 0xCFE87F7CEF46FF16}, // 1e114\n {0x4FCB7E8F3F60C07E, 0x81F14FAE158C5F6E}, " +
|
||||
" // 1e115\n {0xE3BE5E330F38F09D, 0xA26DA3999AEF7749}, // 1e116\n {0x5CADF5BFD3072CC5, 0xCB090C8001AB551C}, // 1e117\n {0x73D9732FC7C8F7F6, 0xFDCB4FA002162A63}, // 1e118\n {0x2867E7FDDCDD9AFA, 0x9E9F11C4014DDA7E}, // 1e119\n {0xB281E1FD541501B8, 0xC646D63501A1511D}, // 1e120\n {0x1F225A7CA91A4226, 0xF7D88BC24209A565}, // 1e121\n {0x3375788DE9B06958, 0x9AE757596946075F}, // 1e122\n {0x0052D6B1641C83AE, 0xC1A12D2FC3978937}, // 1e123\n {0xC0678C5DBD23A49A, 0xF209787BB47D6B84}, // 1e124\n {0xF840B7BA963646E0, 0x9745EB4D50CE6332}, // 1e125\n {0xB650E5A93BC3D898, 0xBD176620A501FBFF}, // 1e126\n {0xA3E51F138AB4CEBE, 0xEC5D3FA8CE427AFF}, // 1e127\n {0xC66F336C36B10137, 0x93BA47C980E98CDF}, // 1e128\n {0xB80B0047445D4184, 0xB8A8D9BBE123F017}, // 1e129\n {0xA60DC059157491E5, 0xE6D3102AD96CEC1D}, // 1e130\n {0x87C89837AD68DB2F, 0x9043EA1AC7E41392}, // 1e131\n {0x29BABE4598C311FB, 0xB454E4A179DD1877}, // " +
|
||||
"1e132\n {0xF4296DD6FEF3D67A, 0xE16A1DC9D8545E94}, // 1e133\n {0x1899E4A65F58660C, 0x8CE2529E2734BB1D}, // 1e134\n {0x5EC05DCFF72E7F8F, 0xB01AE745B101E9E4}, // 1e135\n {0x76707543F4FA1F73, 0xDC21A1171D42645D}, // 1e136\n {0x6A06494A791C53A8, 0x899504AE72497EBA}, // 1e137\n {0x0487DB9D17636892, 0xABFA45DA0EDBDE69}, // 1e138\n {0x45A9D2845D3C42B6, 0xD6F8D7509292D603}, // 1e139\n {0x0B8A2392BA45A9B2, 0x865B86925B9BC5C2}, // 1e140\n {0x8E6CAC7768D7141E, 0xA7F26836F282B732}, // 1e141\n {0x3207D795430CD926, 0xD1EF0244AF2364FF}, // 1e142\n {0x7F44E6BD49E807B8, 0x8335616AED761F1F}, // 1e143\n {0x5F16206C9C6209A6, 0xA402B9C5A8D3A6E7}, // 1e144\n {0x36DBA887C37A8C0F, 0xCD036837130890A1}, // 1e145\n {0xC2494954DA2C9789, 0x802221226BE55A64}, // 1e146\n {0xF2DB9BAA10B7BD6C, 0xA02AA96B06DEB0FD}, // 1e147\n {0x6F92829494E5ACC7, 0xC83553C5C8965D3D}, // 1e148\n {0xCB772339BA1F17F9, 0xFA42A8B73ABBF48C}, // 1e14" +
|
||||
"9\n {0xFF2A760414536EFB, 0x9C69A97284B578D7}, // 1e150\n {0xFEF5138519684ABA, 0xC38413CF25E2D70D}, // 1e151\n {0x7EB258665FC25D69, 0xF46518C2EF5B8CD1}, // 1e152\n {0xEF2F773FFBD97A61, 0x98BF2F79D5993802}, // 1e153\n {0xAAFB550FFACFD8FA, 0xBEEEFB584AFF8603}, // 1e154\n {0x95BA2A53F983CF38, 0xEEAABA2E5DBF6784}, // 1e155\n {0xDD945A747BF26183, 0x952AB45CFA97A0B2}, // 1e156\n {0x94F971119AEEF9E4, 0xBA756174393D88DF}, // 1e157\n {0x7A37CD5601AAB85D, 0xE912B9D1478CEB17}, // 1e158\n {0xAC62E055C10AB33A, 0x91ABB422CCB812EE}, // 1e159\n {0x577B986B314D6009, 0xB616A12B7FE617AA}, // 1e160\n {0xED5A7E85FDA0B80B, 0xE39C49765FDF9D94}, // 1e161\n {0x14588F13BE847307, 0x8E41ADE9FBEBC27D}, // 1e162\n {0x596EB2D8AE258FC8, 0xB1D219647AE6B31C}, // 1e163\n {0x6FCA5F8ED9AEF3BB, 0xDE469FBD99A05FE3}, // 1e164\n {0x25DE7BB9480D5854, 0x8AEC23D680043BEE}, // 1e165\n {0xAF561AA79A10AE6A, 0xADA72CCC20054AE9}, // 1e166\n " +
|
||||
" {0x1B2BA1518094DA04, 0xD910F7FF28069DA4}, // 1e167\n {0x90FB44D2F05D0842, 0x87AA9AFF79042286}, // 1e168\n {0x353A1607AC744A53, 0xA99541BF57452B28}, // 1e169\n {0x42889B8997915CE8, 0xD3FA922F2D1675F2}, // 1e170\n {0x69956135FEBADA11, 0x847C9B5D7C2E09B7}, // 1e171\n {0x43FAB9837E699095, 0xA59BC234DB398C25}, // 1e172\n {0x94F967E45E03F4BB, 0xCF02B2C21207EF2E}, // 1e173\n {0x1D1BE0EEBAC278F5, 0x8161AFB94B44F57D}, // 1e174\n {0x6462D92A69731732, 0xA1BA1BA79E1632DC}, // 1e175\n {0x7D7B8F7503CFDCFE, 0xCA28A291859BBF93}, // 1e176\n {0x5CDA735244C3D43E, 0xFCB2CB35E702AF78}, // 1e177\n {0x3A0888136AFA64A7, 0x9DEFBF01B061ADAB}, // 1e178\n {0x088AAA1845B8FDD0, 0xC56BAEC21C7A1916}, // 1e179\n {0x8AAD549E57273D45, 0xF6C69A72A3989F5B}, // 1e180\n {0x36AC54E2F678864B, 0x9A3C2087A63F6399}, // 1e181\n {0x84576A1BB416A7DD, 0xC0CB28A98FCF3C7F}, // 1e182\n {0x656D44A2A11C51D5, 0xF0FDF2D3F3C30B9F}, // 1e183\n " +
|
||||
" {0x9F644AE5A4B1B325, 0x969EB7C47859E743}, // 1e184\n {0x873D5D9F0DDE1FEE, 0xBC4665B596706114}, // 1e185\n {0xA90CB506D155A7EA, 0xEB57FF22FC0C7959}, // 1e186\n {0x09A7F12442D588F2, 0x9316FF75DD87CBD8}, // 1e187\n {0x0C11ED6D538AEB2F, 0xB7DCBF5354E9BECE}, // 1e188\n {0x8F1668C8A86DA5FA, 0xE5D3EF282A242E81}, // 1e189\n {0xF96E017D694487BC, 0x8FA475791A569D10}, // 1e190\n {0x37C981DCC395A9AC, 0xB38D92D760EC4455}, // 1e191\n {0x85BBE253F47B1417, 0xE070F78D3927556A}, // 1e192\n {0x93956D7478CCEC8E, 0x8C469AB843B89562}, // 1e193\n {0x387AC8D1970027B2, 0xAF58416654A6BABB}, // 1e194\n {0x06997B05FCC0319E, 0xDB2E51BFE9D0696A}, // 1e195\n {0x441FECE3BDF81F03, 0x88FCF317F22241E2}, // 1e196\n {0xD527E81CAD7626C3, 0xAB3C2FDDEEAAD25A}, // 1e197\n {0x8A71E223D8D3B074, 0xD60B3BD56A5586F1}, // 1e198\n {0xF6872D5667844E49, 0x85C7056562757456}, // 1e199\n {0xB428F8AC016561DB, 0xA738C6BEBB12D16C}, // 1e200\n {0" +
|
||||
"xE13336D701BEBA52, 0xD106F86E69D785C7}, // 1e201\n {0xECC0024661173473, 0x82A45B450226B39C}, // 1e202\n {0x27F002D7F95D0190, 0xA34D721642B06084}, // 1e203\n {0x31EC038DF7B441F4, 0xCC20CE9BD35C78A5}, // 1e204\n {0x7E67047175A15271, 0xFF290242C83396CE}, // 1e205\n {0x0F0062C6E984D386, 0x9F79A169BD203E41}, // 1e206\n {0x52C07B78A3E60868, 0xC75809C42C684DD1}, // 1e207\n {0xA7709A56CCDF8A82, 0xF92E0C3537826145}, // 1e208\n {0x88A66076400BB691, 0x9BBCC7A142B17CCB}, // 1e209\n {0x6ACFF893D00EA435, 0xC2ABF989935DDBFE}, // 1e210\n {0x0583F6B8C4124D43, 0xF356F7EBF83552FE}, // 1e211\n {0xC3727A337A8B704A, 0x98165AF37B2153DE}, // 1e212\n {0x744F18C0592E4C5C, 0xBE1BF1B059E9A8D6}, // 1e213\n {0x1162DEF06F79DF73, 0xEDA2EE1C7064130C}, // 1e214\n {0x8ADDCB5645AC2BA8, 0x9485D4D1C63E8BE7}, // 1e215\n {0x6D953E2BD7173692, 0xB9A74A0637CE2EE1}, // 1e216\n {0xC8FA8DB6CCDD0437, 0xE8111C87C5C1BA99}, // 1e217\n {0x1D9" +
|
||||
"C9892400A22A2, 0x910AB1D4DB9914A0}, // 1e218\n {0x2503BEB6D00CAB4B, 0xB54D5E4A127F59C8}, // 1e219\n {0x2E44AE64840FD61D, 0xE2A0B5DC971F303A}, // 1e220\n {0x5CEAECFED289E5D2, 0x8DA471A9DE737E24}, // 1e221\n {0x7425A83E872C5F47, 0xB10D8E1456105DAD}, // 1e222\n {0xD12F124E28F77719, 0xDD50F1996B947518}, // 1e223\n {0x82BD6B70D99AAA6F, 0x8A5296FFE33CC92F}, // 1e224\n {0x636CC64D1001550B, 0xACE73CBFDC0BFB7B}, // 1e225\n {0x3C47F7E05401AA4E, 0xD8210BEFD30EFA5A}, // 1e226\n {0x65ACFAEC34810A71, 0x8714A775E3E95C78}, // 1e227\n {0x7F1839A741A14D0D, 0xA8D9D1535CE3B396}, // 1e228\n {0x1EDE48111209A050, 0xD31045A8341CA07C}, // 1e229\n {0x934AED0AAB460432, 0x83EA2B892091E44D}, // 1e230\n {0xF81DA84D5617853F, 0xA4E4B66B68B65D60}, // 1e231\n {0x36251260AB9D668E, 0xCE1DE40642E3F4B9}, // 1e232\n {0xC1D72B7C6B426019, 0x80D2AE83E9CE78F3}, // 1e233\n {0xB24CF65B8612F81F, 0xA1075A24E4421730}, // 1e234\n {0xDEE033F" +
|
||||
"26797B627, 0xC94930AE1D529CFC}, // 1e235\n {0x169840EF017DA3B1, 0xFB9B7CD9A4A7443C}, // 1e236\n {0x8E1F289560EE864E, 0x9D412E0806E88AA5}, // 1e237\n {0xF1A6F2BAB92A27E2, 0xC491798A08A2AD4E}, // 1e238\n {0xAE10AF696774B1DB, 0xF5B5D7EC8ACB58A2}, // 1e239\n {0xACCA6DA1E0A8EF29, 0x9991A6F3D6BF1765}, // 1e240\n {0x17FD090A58D32AF3, 0xBFF610B0CC6EDD3F}, // 1e241\n {0xDDFC4B4CEF07F5B0, 0xEFF394DCFF8A948E}, // 1e242\n {0x4ABDAF101564F98E, 0x95F83D0A1FB69CD9}, // 1e243\n {0x9D6D1AD41ABE37F1, 0xBB764C4CA7A4440F}, // 1e244\n {0x84C86189216DC5ED, 0xEA53DF5FD18D5513}, // 1e245\n {0x32FD3CF5B4E49BB4, 0x92746B9BE2F8552C}, // 1e246\n {0x3FBC8C33221DC2A1, 0xB7118682DBB66A77}, // 1e247\n {0x0FABAF3FEAA5334A, 0xE4D5E82392A40515}, // 1e248\n {0x29CB4D87F2A7400E, 0x8F05B1163BA6832D}, // 1e249\n {0x743E20E9EF511012, 0xB2C71D5BCA9023F8}, // 1e250\n {0x914DA9246B255416, 0xDF78E4B2BD342CF6}, // 1e251\n {0x1AD089B6C2F" +
|
||||
"7548E, 0x8BAB8EEFB6409C1A}, // 1e252\n {0xA184AC2473B529B1, 0xAE9672ABA3D0C320}, // 1e253\n {0xC9E5D72D90A2741E, 0xDA3C0F568CC4F3E8}, // 1e254\n {0x7E2FA67C7A658892, 0x8865899617FB1871}, // 1e255\n {0xDDBB901B98FEEAB7, 0xAA7EEBFB9DF9DE8D}, // 1e256\n {0x552A74227F3EA565, 0xD51EA6FA85785631}, // 1e257\n {0xD53A88958F87275F, 0x8533285C936B35DE}, // 1e258\n {0x8A892ABAF368F137, 0xA67FF273B8460356}, // 1e259\n {0x2D2B7569B0432D85, 0xD01FEF10A657842C}, // 1e260\n {0x9C3B29620E29FC73, 0x8213F56A67F6B29B}, // 1e261\n {0x8349F3BA91B47B8F, 0xA298F2C501F45F42}, // 1e262\n {0x241C70A936219A73, 0xCB3F2F7642717713}, // 1e263\n {0xED238CD383AA0110, 0xFE0EFB53D30DD4D7}, // 1e264\n {0xF4363804324A40AA, 0x9EC95D1463E8A506}, // 1e265\n {0xB143C6053EDCD0D5, 0xC67BB4597CE2CE48}, // 1e266\n {0xDD94B7868E94050A, 0xF81AA16FDC1B81DA}, // 1e267\n {0xCA7CF2B4191C8326, 0x9B10A4E5E9913128}, // 1e268\n {0xFD1C2F611F63A3F" +
|
||||
"0, 0xC1D4CE1F63F57D72}, // 1e269\n {0xBC633B39673C8CEC, 0xF24A01A73CF2DCCF}, // 1e270\n {0xD5BE0503E085D813, 0x976E41088617CA01}, // 1e271\n {0x4B2D8644D8A74E18, 0xBD49D14AA79DBC82}, // 1e272\n {0xDDF8E7D60ED1219E, 0xEC9C459D51852BA2}, // 1e273\n {0xCABB90E5C942B503, 0x93E1AB8252F33B45}, // 1e274\n {0x3D6A751F3B936243, 0xB8DA1662E7B00A17}, // 1e275\n {0x0CC512670A783AD4, 0xE7109BFBA19C0C9D}, // 1e276\n {0x27FB2B80668B24C5, 0x906A617D450187E2}, // 1e277\n {0xB1F9F660802DEDF6, 0xB484F9DC9641E9DA}, // 1e278\n {0x5E7873F8A0396973, 0xE1A63853BBD26451}, // 1e279\n {0xDB0B487B6423E1E8, 0x8D07E33455637EB2}, // 1e280\n {0x91CE1A9A3D2CDA62, 0xB049DC016ABC5E5F}, // 1e281\n {0x7641A140CC7810FB, 0xDC5C5301C56B75F7}, // 1e282\n {0xA9E904C87FCB0A9D, 0x89B9B3E11B6329BA}, // 1e283\n {0x546345FA9FBDCD44, 0xAC2820D9623BF429}, // 1e284\n {0xA97C177947AD4095, 0xD732290FBACAF133}, // 1e285\n {0x49ED8EABCCCC485D, 0" +
|
||||
"x867F59A9D4BED6C0}, // 1e286\n {0x5C68F256BFFF5A74, 0xA81F301449EE8C70}, // 1e287\n {0x73832EEC6FFF3111, 0xD226FC195C6A2F8C}, // 1e288\n};\n\n// wuffs_base__private_implementation__f64_powers_of_10 holds powers of 10 that\n// can be exactly represented by a float64 (what C calls a double).\nstatic const double wuffs_base__private_implementation__f64_powers_of_10[23] = {\n 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11,\n 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22,\n};\n" +
|
||||
""
|
||||
|
||||
const BaseIntConvSubmoduleC = "" +
|
||||
"// ---------------- Integer\n\n// wuffs_base__parse_number__foo_digits entries are 0x00 for invalid digits,\n// and (0x80 | v) for valid digits, where v is the 4 bit value.\n\nstatic const uint8_t wuffs_base__parse_number__decimal_digits[256] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.\n 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, // 0x30 ..= 0x37. '0'-'7'.\n 0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F. '8'-'9'.\n\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x40 ..= 0x47.\n 0x00, 0x00, 0x00, " +
|
||||
"0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x60 ..= 0x67.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x68 ..= 0x6F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.\n\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x80 ..= 0x87.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x88 ..= 0x8F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x90 ..= 0x97.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x98 ..= 0x9F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA0 ..= 0xA7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA8 ..= 0xAF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB0 ..= 0xB7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00," +
|
||||
" // 0xB8 ..= 0xBF.\n\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC0 ..= 0xC7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC8 ..= 0xCF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD0 ..= 0xD7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD8 ..= 0xDF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE0 ..= 0xE7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE8 ..= 0xEF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF0 ..= 0xF7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF8 ..= 0xFF.\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n};\n\nstatic const uint8_t wuffs_base__parse_number__hexadecimal_digits[256] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.\n 0x00, " +
|
||||
"0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.\n 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, // 0x30 ..= 0x37. '0'-'7'.\n 0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F. '8'-'9'.\n\n 0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00, // 0x40 ..= 0x47. 'A'-'F'.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.\n 0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00, // 0x60 ..= 0x67. 'a'-'f'.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x68 ..= 0x6F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.\n\n " +
|
||||
" 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x80 ..= 0x87.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x88 ..= 0x8F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x90 ..= 0x97.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x98 ..= 0x9F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA0 ..= 0xA7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xA8 ..= 0xAF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB0 ..= 0xB7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xB8 ..= 0xBF.\n\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC0 ..= 0xC7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xC8 ..= 0xCF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD0 ..= 0xD7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xD8 ..= 0xDF.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE0 ..= 0xE7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xE8 ..= 0xEF.\n 0x00, 0x00, 0x00, 0x00, 0x0" +
|
||||
"0, 0x00, 0x00, 0x00, // 0xF0 ..= 0xF7.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0xF8 ..= 0xFF.\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n};\n\nstatic const uint8_t wuffs_base__private_implementation__encode_base16[16] = {\n 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, // 0x00 ..= 0x07.\n 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, // 0x08 ..= 0x0F.\n};\n\n" +
|
||||
"" +
|
||||
"// --------\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64 //\nwuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options) {\n uint8_t* p = s.ptr;\n uint8_t* q = s.ptr + s.len;\n\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (; (p < q) && (*p == '_'); p++) {\n }\n }\n\n bool negative = false;\n if (p >= q) {\n goto fail_bad_argument;\n } else if (*p == '-') {\n p++;\n negative = true;\n } else if (*p == '+') {\n p++;\n }\n\n do {\n wuffs_base__result_u64 r = wuffs_base__parse_number_u64(\n wuffs_base__make_slice_u8(p, (size_t)(q - p)), options);\n if (r.status.repr != NULL) {\n wuffs_base__result_i64 ret;\n ret.status.repr = r.status.repr;\n ret.value = 0;\n return ret;\n } else if (negative) {\n if (r.value > 0x8000000000000000) {\n goto fail_out_of_bounds;\n }\n wuffs_base__result_i64 ret;\n ret.status.repr = NULL;\n ret.value = -(int64_t)(r.value);\n return ret;\n } else if (r.value > 0x7FFFFFFFFFFF" +
|
||||
"FFFF) {\n goto fail_out_of_bounds;\n } else {\n wuffs_base__result_i64 ret;\n ret.status.repr = NULL;\n ret.value = +(int64_t)(r.value);\n return ret;\n }\n } while (0);\n\nfail_bad_argument:\n do {\n wuffs_base__result_i64 ret;\n ret.status.repr = wuffs_base__error__bad_argument;\n ret.value = 0;\n return ret;\n } while (0);\n\nfail_out_of_bounds:\n do {\n wuffs_base__result_i64 ret;\n ret.status.repr = wuffs_base__error__out_of_bounds;\n ret.value = 0;\n return ret;\n } while (0);\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64 //\nwuffs_base__parse_number_u64(wuffs_base__slice_u8 s, uint32_t options) {\n uint8_t* p = s.ptr;\n uint8_t* q = s.ptr + s.len;\n\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (; (p < q) && (*p == '_'); p++) {\n }\n }\n\n if (p >= q) {\n goto fail_bad_argument;\n\n } else if (*p == '0') {\n p++;\n if (p >= q) {\n goto ok_zero;\n }\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n " +
|
||||
"if (*p == '_') {\n p++;\n for (; p < q; p++) {\n if (*p != '_') {\n if (options &\n WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES) {\n goto decimal;\n }\n goto fail_bad_argument;\n }\n }\n goto ok_zero;\n }\n }\n\n if ((*p == 'x') || (*p == 'X')) {\n p++;\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (; (p < q) && (*p == '_'); p++) {\n }\n }\n if (p < q) {\n goto hexadecimal;\n }\n\n } else if ((*p == 'd') || (*p == 'D')) {\n p++;\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES) {\n for (; (p < q) && (*p == '_'); p++) {\n }\n }\n if (p < q) {\n goto decimal;\n }\n }\n\n if (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES) {\n goto decimal;\n }\n goto fail_bad_argument;\n }\n\ndecimal:\n do {\n uint64_t v = wuffs_base__parse_number__decimal_digi" +
|
||||
"ts[*p++];\n if (v == 0) {\n goto fail_bad_argument;\n }\n v &= 0x0F;\n\n // UINT64_MAX is 18446744073709551615, which is ((10 * max10) + max1).\n const uint64_t max10 = 1844674407370955161u;\n const uint8_t max1 = 5;\n\n for (; p < q; p++) {\n if ((*p == '_') &&\n (options & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n continue;\n }\n uint8_t digit = wuffs_base__parse_number__decimal_digits[*p];\n if (digit == 0) {\n goto fail_bad_argument;\n }\n digit &= 0x0F;\n if ((v > max10) || ((v == max10) && (digit > max1))) {\n goto fail_out_of_bounds;\n }\n v = (10 * v) + ((uint64_t)(digit));\n }\n\n wuffs_base__result_u64 ret;\n ret.status.repr = NULL;\n ret.value = v;\n return ret;\n } while (0);\n\nhexadecimal:\n do {\n uint64_t v = wuffs_base__parse_number__hexadecimal_digits[*p++];\n if (v == 0) {\n goto fail_bad_argument;\n }\n v &= 0x0F;\n\n for (; p < q; p++) {\n if ((*p == '_') &&\n (options" +
|
||||
" & WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES)) {\n continue;\n }\n uint8_t digit = wuffs_base__parse_number__hexadecimal_digits[*p];\n if (digit == 0) {\n goto fail_bad_argument;\n }\n digit &= 0x0F;\n if ((v >> 60) != 0) {\n goto fail_out_of_bounds;\n }\n v = (v << 4) | ((uint64_t)(digit));\n }\n\n wuffs_base__result_u64 ret;\n ret.status.repr = NULL;\n ret.value = v;\n return ret;\n } while (0);\n\nok_zero:\n do {\n wuffs_base__result_u64 ret;\n ret.status.repr = NULL;\n ret.value = 0;\n return ret;\n } while (0);\n\nfail_bad_argument:\n do {\n wuffs_base__result_u64 ret;\n ret.status.repr = wuffs_base__error__bad_argument;\n ret.value = 0;\n return ret;\n } while (0);\n\nfail_out_of_bounds:\n do {\n wuffs_base__result_u64 ret;\n ret.status.repr = wuffs_base__error__out_of_bounds;\n ret.value = 0;\n return ret;\n } while (0);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__render_number__first_hundred contains the decimal encodings of\n// the first one hundred numbers [0 ..= 99].\nstatic const uint8_t wuffs_base__render_number__first_hundred[200] = {\n '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', //\n '0', '5', '0', '6', '0', '7', '0', '8', '0', '9', //\n '1', '0', '1', '1', '1', '2', '1', '3', '1', '4', //\n '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', //\n '2', '0', '2', '1', '2', '2', '2', '3', '2', '4', //\n '2', '5', '2', '6', '2', '7', '2', '8', '2', '9', //\n '3', '0', '3', '1', '3', '2', '3', '3', '3', '4', //\n '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', //\n '4', '0', '4', '1', '4', '2', '4', '3', '4', '4', //\n '4', '5', '4', '6', '4', '7', '4', '8', '4', '9', //\n '5', '0', '5', '1', '5', '2', '5', '3', '5', '4', //\n '5', '5', '5', '6', '5', '7', '5', '8', '5', '9', //\n '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', //\n '6', '5', '6', '6', '6', '7', '6', '8', '6', '9', //\n '" +
|
||||
"7', '0', '7', '1', '7', '2', '7', '3', '7', '4', //\n '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', //\n '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', //\n '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', //\n '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', //\n '9', '5', '9', '6', '9', '7', '9', '8', '9', '9', //\n};\n\nstatic size_t //\nwuffs_base__private_implementation__render_number_u64(wuffs_base__slice_u8 dst,\n uint64_t x,\n uint32_t options,\n bool neg) {\n uint8_t buf[WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL];\n uint8_t* ptr = &buf[0] + sizeof(buf);\n\n while (x >= 100) {\n size_t index = ((size_t)((x % 100) * 2));\n x /= 100;\n uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];\n uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];\n ptr -= 2;\n ptr[0] = s0;\n ptr[1] = s1;\n }\n\n if " +
|
||||
"(x < 10) {\n ptr -= 1;\n ptr[0] = (uint8_t)('0' + x);\n } else {\n size_t index = ((size_t)(x * 2));\n uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];\n uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];\n ptr -= 2;\n ptr[0] = s0;\n ptr[1] = s1;\n }\n\n if (neg) {\n ptr -= 1;\n ptr[0] = '-';\n } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n ptr -= 1;\n ptr[0] = '+';\n }\n\n size_t n = sizeof(buf) - ((size_t)(ptr - &buf[0]));\n if (n > dst.len) {\n return 0;\n }\n memcpy(dst.ptr + ((options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)\n ? (dst.len - n)\n : 0),\n ptr, n);\n return n;\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_i64(wuffs_base__slice_u8 dst,\n int64_t x,\n uint32_t options) {\n uint64_t u = (uint64_t)x;\n bool neg = x < 0;\n if (neg) {\n u = 1 + ~u;\n }\n return wuffs_base__private_imp" +
|
||||
"lementation__render_number_u64(dst, u, options,\n neg);\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__render_number_u64(wuffs_base__slice_u8 dst,\n uint64_t x,\n uint32_t options) {\n return wuffs_base__private_implementation__render_number_u64(dst, x, options,\n false);\n}\n\n" +
|
||||
"" +
|
||||
"// ---------------- Base-16\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__decode2(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n wuffs_base__transform__output o;\n size_t src_len2 = src.len / 2;\n size_t len;\n if (dst.len < src_len2) {\n len = dst.len;\n o.status.repr = wuffs_base__suspension__short_write;\n } else {\n len = src_len2;\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n } else if (src.len & 1) {\n o.status.repr = wuffs_base__error__bad_data;\n } else {\n o.status.repr = NULL;\n }\n }\n\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n while (n--) {\n *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[0]] << 4) |\n (wuffs_base__parse_number__hexadecimal_digits[s[1]] & 0x0F));\n d += 1;\n s += 2;\n }\n\n o.num_dst = len;\n o.num_s" +
|
||||
"rc = len * 2;\n return o;\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__decode4(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n wuffs_base__transform__output o;\n size_t src_len4 = src.len / 4;\n size_t len = dst.len < src_len4 ? dst.len : src_len4;\n if (dst.len < src_len4) {\n len = dst.len;\n o.status.repr = wuffs_base__suspension__short_write;\n } else {\n len = src_len4;\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n } else if (src.len & 1) {\n o.status.repr = wuffs_base__error__bad_data;\n } else {\n o.status.repr = NULL;\n }\n }\n\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n while (n--) {\n *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[2]] << 4) |\n (wuffs_base__parse_number__hexadecimal_digits[s[3]] & 0x0F));\n d += 1;\n " +
|
||||
" s += 4;\n }\n\n o.num_dst = len;\n o.num_src = len * 4;\n return o;\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__encode2(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n wuffs_base__transform__output o;\n size_t dst_len2 = dst.len / 2;\n size_t len;\n if (dst_len2 < src.len) {\n len = dst_len2;\n o.status.repr = wuffs_base__suspension__short_write;\n } else {\n len = src.len;\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n } else {\n o.status.repr = NULL;\n }\n }\n\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n while (n--) {\n uint8_t c = *s;\n d[0] = wuffs_base__private_implementation__encode_base16[c >> 4];\n d[1] = wuffs_base__private_implementation__encode_base16[c & 0x0F];\n d += 2;\n s += 1;\n }\n\n o.num_dst = len * 2;\n o.num_src = len;\n return o;\n}\n\nWUFFS_BA" +
|
||||
"SE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_16__encode4(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n wuffs_base__transform__output o;\n size_t dst_len4 = dst.len / 4;\n size_t len;\n if (dst_len4 < src.len) {\n len = dst_len4;\n o.status.repr = wuffs_base__suspension__short_write;\n } else {\n len = src.len;\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n } else {\n o.status.repr = NULL;\n }\n }\n\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n while (n--) {\n uint8_t c = *s;\n d[0] = '\\\\';\n d[1] = 'x';\n d[2] = wuffs_base__private_implementation__encode_base16[c >> 4];\n d[3] = wuffs_base__private_implementation__encode_base16[c & 0x0F];\n d += 4;\n s += 1;\n }\n\n o.num_dst = len * 4;\n o.num_src = len;\n return o;\n}\n\n" +
|
||||
"" +
|
||||
"// ---------------- Base-64\n\n// The two base-64 alphabets, std and url, differ only in the last two codes.\n// - std: \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"\n// - url: \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\"\n\nstatic const uint8_t wuffs_base__base_64__decode_std[256] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x00 ..= 0x07.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x08 ..= 0x0F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x10 ..= 0x17.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x18 ..= 0x1F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x20 ..= 0x27.\n 0x80, 0x80, 0x80, 0x3E, 0x80, 0x80, 0x80, 0x3F, // 0x28 ..= 0x2F.\n 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, // 0x30 ..= 0x37.\n 0x3C, 0x3D, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x38 ..= 0x3F.\n\n 0x80, 0x00, 0x01, 0x02," +
|
||||
" 0x03, 0x04, 0x05, 0x06, // 0x40 ..= 0x47.\n 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, // 0x48 ..= 0x4F.\n 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, // 0x50 ..= 0x57.\n 0x17, 0x18, 0x19, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x58 ..= 0x5F.\n 0x80, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, // 0x60 ..= 0x67.\n 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, // 0x68 ..= 0x6F.\n 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, // 0x70 ..= 0x77.\n 0x31, 0x32, 0x33, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x78 ..= 0x7F.\n\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x80 ..= 0x87.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x88 ..= 0x8F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x90 ..= 0x97.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x98 ..= 0x9F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xA0 ..= 0xA7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xA8 ..= 0xAF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // " +
|
||||
"0xB0 ..= 0xB7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xB8 ..= 0xBF.\n\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xC0 ..= 0xC7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xC8 ..= 0xCF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xD0 ..= 0xD7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xD8 ..= 0xDF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xE0 ..= 0xE7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xE8 ..= 0xEF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF0 ..= 0xF7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF8 ..= 0xFF.\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n};\n\nstatic const uint8_t wuffs_base__base_64__decode_url[256] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x00 ..= 0x07.\n 0x80, 0x80, 0x80, 0x80, " +
|
||||
"0x80, 0x80, 0x80, 0x80, // 0x08 ..= 0x0F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x10 ..= 0x17.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x18 ..= 0x1F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x20 ..= 0x27.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x3E, 0x80, 0x80, // 0x28 ..= 0x2F.\n 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, // 0x30 ..= 0x37.\n 0x3C, 0x3D, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x38 ..= 0x3F.\n\n 0x80, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, // 0x40 ..= 0x47.\n 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, // 0x48 ..= 0x4F.\n 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, // 0x50 ..= 0x57.\n 0x17, 0x18, 0x19, 0x80, 0x80, 0x80, 0x80, 0x3F, // 0x58 ..= 0x5F.\n 0x80, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, // 0x60 ..= 0x67.\n 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, // 0x68 ..= 0x6F.\n 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, // 0x70 ..= 0x77.\n 0x31, 0x32, 0x33, 0x80, 0x80, 0x80, 0x80, 0x80, // 0" +
|
||||
"x78 ..= 0x7F.\n\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x80 ..= 0x87.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x88 ..= 0x8F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x90 ..= 0x97.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0x98 ..= 0x9F.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xA0 ..= 0xA7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xA8 ..= 0xAF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xB0 ..= 0xB7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xB8 ..= 0xBF.\n\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xC0 ..= 0xC7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xC8 ..= 0xCF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xD0 ..= 0xD7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xD8 ..= 0xDF.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xE0 ..= 0xE7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xE8 ..= 0xEF.\n 0x80, 0x80" +
|
||||
", 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF0 ..= 0xF7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF8 ..= 0xFF.\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n};\n\nstatic const uint8_t wuffs_base__base_64__encode_std[64] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, // 0x00 ..= 0x07.\n 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, // 0x08 ..= 0x0F.\n 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, // 0x10 ..= 0x17.\n 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, // 0x18 ..= 0x1F.\n 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, // 0x20 ..= 0x27.\n 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, // 0x28 ..= 0x2F.\n 0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33, // 0x30 ..= 0x37.\n 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2B, 0x2F, // 0x38 ..= 0x3F.\n};\n\nstatic const uint8_t wuffs_base__base_64__encode_url[64" +
|
||||
"] = {\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, // 0x00 ..= 0x07.\n 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, // 0x08 ..= 0x0F.\n 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, // 0x10 ..= 0x17.\n 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, // 0x18 ..= 0x1F.\n 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, // 0x20 ..= 0x27.\n 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, // 0x28 ..= 0x2F.\n 0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33, // 0x30 ..= 0x37.\n 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2D, 0x5F, // 0x38 ..= 0x3F.\n};\n\n" +
|
||||
"" +
|
||||
"// --------\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_64__decode(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n const uint8_t* alphabet = (options & WUFFS_BASE__BASE_64__URL_ALPHABET)\n ? wuffs_base__base_64__decode_url\n : wuffs_base__base_64__decode_std;\n wuffs_base__transform__output o;\n uint8_t* d_ptr = dst.ptr;\n size_t d_len = dst.len;\n const uint8_t* s_ptr = src.ptr;\n size_t s_len = src.len;\n bool pad = false;\n\n while (s_len >= 4) {\n uint32_t s = wuffs_base__peek_u32le__no_bounds_check(s_ptr);\n uint32_t s0 = alphabet[0xFF & (s >> 0)];\n uint32_t s1 = alphabet[0xFF & (s >> 8)];\n uint32_t s2 = alphabet[0xFF & (s >> 16)];\n uint32_t s3 = alphabet[0xFF & (s >> 24)];\n\n if (((s0 | s1 | s2 | s3) & 0xC0) != 0) {\n if (s_len > 4) {\n o.status.repr = wuffs_base_" +
|
||||
"_error__bad_data;\n goto done;\n } else if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n goto done;\n } else if ((options & WUFFS_BASE__BASE_64__DECODE_ALLOW_PADDING) &&\n (s_ptr[3] == '=')) {\n pad = true;\n if (s_ptr[2] == '=') {\n goto src2;\n }\n goto src3;\n }\n o.status.repr = wuffs_base__error__bad_data;\n goto done;\n }\n\n if (d_len < 3) {\n o.status.repr = wuffs_base__suspension__short_write;\n goto done;\n }\n\n s_ptr += 4;\n s_len -= 4;\n s = (s0 << 18) | (s1 << 12) | (s2 << 6) | (s3 << 0);\n *d_ptr++ = (uint8_t)(s >> 16);\n *d_ptr++ = (uint8_t)(s >> 8);\n *d_ptr++ = (uint8_t)(s >> 0);\n d_len -= 3;\n }\n\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n goto done;\n }\n\n if (s_len == 0) {\n o.status.repr = NULL;\n goto done;\n } else if (s_len == 1) {\n o.status.repr = wuffs_base__error__bad_data;\n goto done;\n } else if (s" +
|
||||
"_len == 2) {\n goto src2;\n }\n\nsrc3:\n do {\n uint32_t s = wuffs_base__peek_u24le__no_bounds_check(s_ptr);\n uint32_t s0 = alphabet[0xFF & (s >> 0)];\n uint32_t s1 = alphabet[0xFF & (s >> 8)];\n uint32_t s2 = alphabet[0xFF & (s >> 16)];\n if ((s0 & 0xC0) || (s1 & 0xC0) || (s2 & 0xC3)) {\n o.status.repr = wuffs_base__error__bad_data;\n goto done;\n }\n if (d_len < 2) {\n o.status.repr = wuffs_base__suspension__short_write;\n goto done;\n }\n s_ptr += pad ? 4 : 3;\n s = (s0 << 18) | (s1 << 12) | (s2 << 6);\n *d_ptr++ = (uint8_t)(s >> 16);\n *d_ptr++ = (uint8_t)(s >> 8);\n o.status.repr = NULL;\n goto done;\n } while (0);\n\nsrc2:\n do {\n uint32_t s = wuffs_base__peek_u16le__no_bounds_check(s_ptr);\n uint32_t s0 = alphabet[0xFF & (s >> 0)];\n uint32_t s1 = alphabet[0xFF & (s >> 8)];\n if ((s0 & 0xC0) || (s1 & 0xCF)) {\n o.status.repr = wuffs_base__error__bad_data;\n goto done;\n }\n if (d_len < 1) {\n o.status.repr = wuffs_base__suspension__sho" +
|
||||
"rt_write;\n goto done;\n }\n s_ptr += pad ? 4 : 2;\n s = (s0 << 18) | (s1 << 12);\n *d_ptr++ = (uint8_t)(s >> 16);\n o.status.repr = NULL;\n goto done;\n } while (0);\n\ndone:\n o.num_dst = (size_t)(d_ptr - dst.ptr);\n o.num_src = (size_t)(s_ptr - src.ptr);\n return o;\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__transform__output //\nwuffs_base__base_64__encode(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src,\n bool src_closed,\n uint32_t options) {\n const uint8_t* alphabet = (options & WUFFS_BASE__BASE_64__URL_ALPHABET)\n ? wuffs_base__base_64__encode_url\n : wuffs_base__base_64__encode_std;\n wuffs_base__transform__output o;\n uint8_t* d_ptr = dst.ptr;\n size_t d_len = dst.len;\n const uint8_t* s_ptr = src.ptr;\n size_t s_len = src.len;\n\n do {\n while (s_len >= 3) {\n if (d_len < 4) {\n o.status.repr = wuffs_base__suspension__short_write;\n " +
|
||||
" goto done;\n }\n uint32_t s = wuffs_base__peek_u24be__no_bounds_check(s_ptr);\n s_ptr += 3;\n s_len -= 3;\n *d_ptr++ = alphabet[0x3F & (s >> 18)];\n *d_ptr++ = alphabet[0x3F & (s >> 12)];\n *d_ptr++ = alphabet[0x3F & (s >> 6)];\n *d_ptr++ = alphabet[0x3F & (s >> 0)];\n d_len -= 4;\n }\n\n if (!src_closed) {\n o.status.repr = wuffs_base__suspension__short_read;\n goto done;\n }\n\n if (s_len == 2) {\n if (d_len <\n ((options & WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING) ? 4 : 3)) {\n o.status.repr = wuffs_base__suspension__short_write;\n goto done;\n }\n uint32_t s = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(s_ptr)))\n << 8;\n s_ptr += 2;\n *d_ptr++ = alphabet[0x3F & (s >> 18)];\n *d_ptr++ = alphabet[0x3F & (s >> 12)];\n *d_ptr++ = alphabet[0x3F & (s >> 6)];\n if (options & WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING) {\n *d_ptr++ = '=';\n }\n o.status.repr = NULL;\n " +
|
||||
" goto done;\n\n } else if (s_len == 1) {\n if (d_len <\n ((options & WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING) ? 4 : 2)) {\n o.status.repr = wuffs_base__suspension__short_write;\n goto done;\n }\n uint32_t s = ((uint32_t)(wuffs_base__peek_u8__no_bounds_check(s_ptr)))\n << 16;\n s_ptr += 1;\n *d_ptr++ = alphabet[0x3F & (s >> 18)];\n *d_ptr++ = alphabet[0x3F & (s >> 12)];\n if (options & WUFFS_BASE__BASE_64__ENCODE_EMIT_PADDING) {\n *d_ptr++ = '=';\n *d_ptr++ = '=';\n }\n o.status.repr = NULL;\n goto done;\n\n } else {\n o.status.repr = NULL;\n goto done;\n }\n } while (0);\n\ndone:\n o.num_dst = (size_t)(d_ptr - dst.ptr);\n o.num_src = (size_t)(s_ptr - src.ptr);\n return o;\n}\n" +
|
||||
""
|
||||
|
||||
const BaseMagicSubmoduleC = "" +
|
||||
"// ---------------- Magic Numbers\n\nWUFFS_BASE__MAYBE_STATIC int32_t //\nwuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {\n // table holds the 'magic numbers' (which are actually variable length\n // strings). The strings may contain NUL bytes, so the \"const char* magic\"\n // value starts with the length-minus-1 of the 'magic number'.\n //\n // Keep it sorted by magic[1], then magic[0] descending and finally by\n // magic[2:]. When multiple entries match, the longest one wins.\n static struct {\n int32_t fourcc;\n const char* magic;\n } table[] = {\n {0x57424D50, \"\\x01\\x00\\x00\"}, // WBMP\n {0x424D5020, \"\\x01\\x42\\x4D\"}, // BMP\n {0x47494620, \"\\x03\\x47\\x49\\x46\\x38\"}, // GIF\n {0x54494646, \"\\x03\\x49\\x49\\x2A\\x00\"}, // TIFF (little-endian)\n {0x54494646, \"\\x03\\x4D\\x4D\\x00\\x2A\"}, // TIFF (big-endian)\n {0x52494646, \"\\x03\\x52\\x49\\x46\\x46\"}, // RIFF (see § below)\n {0x4E494520, \"\\x02\\x6E\\xC3\\xAF\"}, // NIE\n {0x504E4720, \"\\x03\\x89\\x50\\x" +
|
||||
"4E\\x47\"}, // PNG\n {0x4A504547, \"\\x01\\xFF\\xD8\"}, // JPEG\n };\n static const size_t table_len = sizeof(table) / sizeof(table[0]);\n\n if (prefix.len == 0) {\n return -1;\n }\n uint8_t pre_first_byte = prefix.ptr[0];\n\n int32_t fourcc = 0;\n size_t i;\n for (i = 0; i < table_len; i++) {\n uint8_t mag_first_byte = ((uint8_t)(table[i].magic[1]));\n if (pre_first_byte < mag_first_byte) {\n break;\n } else if (pre_first_byte > mag_first_byte) {\n continue;\n }\n fourcc = table[i].fourcc;\n\n uint8_t mag_remaining_len = ((uint8_t)(table[i].magic[0]));\n if (mag_remaining_len == 0) {\n goto match;\n }\n\n const char* mag_remaining_ptr = table[i].magic + 2;\n uint8_t* pre_remaining_ptr = prefix.ptr + 1;\n size_t pre_remaining_len = prefix.len - 1;\n if (pre_remaining_len < mag_remaining_len) {\n if (!memcmp(pre_remaining_ptr, mag_remaining_ptr, pre_remaining_len)) {\n return -1;\n }\n } else {\n if (!memcmp(pre_remaining_ptr, mag_remaining_ptr, mag_" +
|
||||
"remaining_len)) {\n goto match;\n }\n }\n }\n return 0;\n\nmatch:\n // Some FourCC values (see § above) are further specialized.\n if (fourcc == 0x52494646) { // 'RIFF'be\n if (prefix.len < 16) {\n return -1;\n }\n uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);\n if (x == 0x57454250) { // 'WEBP'be\n uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);\n if (y == 0x56503820) { // 'VP8 'be\n return 0x57503820; // 'WP8 'be\n } else if (y == 0x5650384C) { // 'VP8L'be\n return 0x5750384C; // 'WP8L'be\n }\n }\n }\n return fourcc;\n}\n" +
|
||||
""
|
||||
|
||||
const BasePixConvSubmoduleC = "" +
|
||||
"// ---------------- Pixel Swizzler\n\nstatic inline uint32_t //\nwuffs_base__swap_u32_argb_abgr(uint32_t u) {\n uint32_t o = u & 0xFF00FF00ul;\n uint32_t r = u & 0x00FF0000ul;\n uint32_t b = u & 0x000000FFul;\n return o | (r >> 16) | (b << 16);\n}\n\nstatic inline uint64_t //\nwuffs_base__swap_u64_argb_abgr(uint64_t u) {\n uint64_t o = u & 0xFFFF0000FFFF0000ull;\n uint64_t r = u & 0x0000FFFF00000000ull;\n uint64_t b = u & 0x000000000000FFFFull;\n return o | (r >> 32) | (b << 32);\n}\n\nstatic inline uint32_t //\nwuffs_base__color_u64__as__color_u32__swap_u32_argb_abgr(uint64_t c) {\n uint32_t a = ((uint32_t)(0xFF & (c >> 56)));\n uint32_t r = ((uint32_t)(0xFF & (c >> 40)));\n uint32_t g = ((uint32_t)(0xFF & (c >> 24)));\n uint32_t b = ((uint32_t)(0xFF & (c >> 8)));\n return (a << 24) | (b << 16) | (g << 8) | (r << 0);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__color_u32_argb_premul //\nwuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* pb,\n uint32_t x,\n uint32_t y) {\n if (!pb || (x >= pb->pixcfg.private_impl.width) ||\n (y >= pb->pixcfg.private_impl.height)) {\n return 0;\n }\n\n if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return 0;\n }\n\n size_t stride = pb->private_impl.planes[0].stride;\n const uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));\n\n switch (pb->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n return wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x)));\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {\n uint8_t* palette = pb->private_impl" +
|
||||
".planes[3].ptr;\n return wuffs_base__peek_u32le__no_bounds_check(palette +\n (4 * ((size_t)row[x])));\n }\n\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n return 0xFF000000 | (0x00010101 * ((uint32_t)(row[x])));\n case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:\n return 0xFF000000 | (0x00010101 * ((uint32_t)(row[(2 * x) + 1])));\n case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:\n return 0xFF000000 | (0x00010101 * ((uint32_t)(row[(2 * x) + 0])));\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: {\n uint8_t* palette = pb->private_impl.planes[3].ptr;\n return wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(palette +\n (4 * ((size_t)row[x]))));\n }\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_ba" +
|
||||
"se__peek_u16le__no_bounds_check(row + (2 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return 0xFF000000 |\n wuffs_base__peek_u24le__no_bounds_check(row + (3 * ((size_t)x)));\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n return wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n return wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u64le__no_bounds_check(row + (8 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return 0xFF000000 |\n wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x)));\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__swap_u32_argb_abgr(\n 0xFF000000 |\n wuffs_base__peek_u24le__no_bounds_check(row + (3 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n return wuffs" +
|
||||
"_base__swap_u32_argb_abgr(\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(row +\n (4 * ((size_t)x)))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n return wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__swap_u32_argb_abgr(\n 0xFF000000 |\n wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n\n default:\n // TODO: support more formats.\n break;\n }\n\n return 0;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_at(\n wuffs_base__pixel_buffer* pb,\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color) {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n if ((x >= pb->pixcfg.private_impl.width) ||\n (y >= pb->pixcfg.private_impl.height)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n size_t stride = pb->private_impl.planes[0].stride;\n uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));\n\n switch (pb->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n wuffs_base__poke_u32le__no_bounds_check(row + (4 * ((size_t)x)), color);\n break;\n" +
|
||||
"\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n wuffs_base__poke_u8__no_bounds_check(\n row + ((size_t)x),\n wuffs_base__color_u32_argb_premul__as__color_u8_gray(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:\n wuffs_base__poke_u16le__no_bounds_check(\n row + (2 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u16_gray(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:\n wuffs_base__poke_u16be__no_bounds_check(\n row + (2 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u16_gray(color));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n wuffs_base__poke_u8__no_bounds_check(\n row + ((size_t)x), wuffs_base__pixel_palette__closest_element(\n wuffs_base__pixel_buffer__p" +
|
||||
"alette(pb),\n pb->pixcfg.private_impl.pixfmt, color));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n wuffs_base__poke_u16le__no_bounds_check(\n row + (2 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n wuffs_base__poke_u24le__no_bounds_check(row + (3 * ((size_t)x)), color);\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n wuffs_base__poke_u32le__no_bounds_check(\n row + (4 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n wuffs_base__poke_u64le__no_bounds_check(\n row + (8 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul(\n color));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n wuffs_base__poke_u24le__no_bounds_c" +
|
||||
"heck(\n row + (3 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n wuffs_base__poke_u32le__no_bounds_check(\n row + (4 * ((size_t)x)),\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n wuffs_base__swap_u32_argb_abgr(color)));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n wuffs_base__poke_u32le__no_bounds_check(\n row + (4 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));\n break;\n\n default:\n // TODO: support more formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n return wuffs_base__make_status(NULL);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic inline void //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect__xx(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n uint16_t color) {\n size_t stride = pb->private_impl.planes[0].stride;\n uint32_t width = wuffs_base__rect_ie_u32__width(&rect);\n if ((stride == (2 * ((uint64_t)width))) && (rect.min_incl_x == 0)) {\n uint8_t* ptr =\n pb->private_impl.planes[0].ptr + (stride * ((size_t)rect.min_incl_y));\n uint32_t height = wuffs_base__rect_ie_u32__height(&rect);\n size_t n;\n for (n = ((size_t)width) * ((size_t)height); n > 0; n--) {\n wuffs_base__poke_u16le__no_bounds_check(ptr, color);\n ptr += 2;\n }\n return;\n }\n\n uint32_t y;\n for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {\n uint8_t* ptr = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)) +\n (2 * ((size_t)rect.min_incl_x));\n uint32_t n;\n for (n = width; n > 0; n--) {\n wuffs_base__poke_u16le__no_bounds_check(ptr, color);\n ptr += 2;\n " +
|
||||
" }\n }\n}\n\nstatic inline void //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect__xxx(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n uint32_t color) {\n size_t stride = pb->private_impl.planes[0].stride;\n uint32_t width = wuffs_base__rect_ie_u32__width(&rect);\n if ((stride == (3 * ((uint64_t)width))) && (rect.min_incl_x == 0)) {\n uint8_t* ptr =\n pb->private_impl.planes[0].ptr + (stride * ((size_t)rect.min_incl_y));\n uint32_t height = wuffs_base__rect_ie_u32__height(&rect);\n size_t n;\n for (n = ((size_t)width) * ((size_t)height); n > 0; n--) {\n wuffs_base__poke_u24le__no_bounds_check(ptr, color);\n ptr += 3;\n }\n return;\n }\n\n uint32_t y;\n for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {\n uint8_t* ptr = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)) +\n (3 * ((size_t)rect.min_incl_x));\n uint32_t n;\n for (n = width; n > 0; n--) {\n wuffs_base__poke_u24le__no_bounds_check(ptr, color);\n ptr += 3;\n " +
|
||||
" }\n }\n}\n\nstatic inline void //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxx(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n uint32_t color) {\n size_t stride = pb->private_impl.planes[0].stride;\n uint32_t width = wuffs_base__rect_ie_u32__width(&rect);\n if ((stride == (4 * ((uint64_t)width))) && (rect.min_incl_x == 0)) {\n uint8_t* ptr =\n pb->private_impl.planes[0].ptr + (stride * ((size_t)rect.min_incl_y));\n uint32_t height = wuffs_base__rect_ie_u32__height(&rect);\n size_t n;\n for (n = ((size_t)width) * ((size_t)height); n > 0; n--) {\n wuffs_base__poke_u32le__no_bounds_check(ptr, color);\n ptr += 4;\n }\n return;\n }\n\n uint32_t y;\n for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {\n uint8_t* ptr = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)) +\n (4 * ((size_t)rect.min_incl_x));\n uint32_t n;\n for (n = width; n > 0; n--) {\n wuffs_base__poke_u32le__no_bounds_check(ptr, color);\n ptr += 4;\n " +
|
||||
" }\n }\n}\n\nstatic inline void //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxxxxxx(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n uint64_t color) {\n size_t stride = pb->private_impl.planes[0].stride;\n uint32_t width = wuffs_base__rect_ie_u32__width(&rect);\n if ((stride == (8 * ((uint64_t)width))) && (rect.min_incl_x == 0)) {\n uint8_t* ptr =\n pb->private_impl.planes[0].ptr + (stride * ((size_t)rect.min_incl_y));\n uint32_t height = wuffs_base__rect_ie_u32__height(&rect);\n size_t n;\n for (n = ((size_t)width) * ((size_t)height); n > 0; n--) {\n wuffs_base__poke_u64le__no_bounds_check(ptr, color);\n ptr += 8;\n }\n return;\n }\n\n uint32_t y;\n for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {\n uint8_t* ptr = pb->private_impl.planes[0].ptr + (stride * ((size_t)y)) +\n (8 * ((size_t)rect.min_incl_x));\n uint32_t n;\n for (n = width; n > 0; n--) {\n wuffs_base__poke_u64le__no_bounds_check(ptr, color);\n ptr += 8;" +
|
||||
"\n }\n }\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_fill_rect(\n wuffs_base__pixel_buffer* pb,\n wuffs_base__rect_ie_u32 rect,\n wuffs_base__color_u32_argb_premul color) {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n } else if (wuffs_base__rect_ie_u32__is_empty(&rect)) {\n return wuffs_base__make_status(NULL);\n }\n wuffs_base__rect_ie_u32 bounds =\n wuffs_base__pixel_config__bounds(&pb->pixcfg);\n if (!wuffs_base__rect_ie_u32__contains_rect(&bounds, rect)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n switch (pb->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n wuffs_base__pixel_buffer__set_color_u32_fill_r" +
|
||||
"ect__xxxx(pb, rect, color);\n return wuffs_base__make_status(NULL);\n\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xx(\n pb, rect,\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(color));\n return wuffs_base__make_status(NULL);\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xxx(pb, rect, color);\n return wuffs_base__make_status(NULL);\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxx(\n pb, rect,\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n color));\n return wuffs_base__make_status(NULL);\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxxxxxx(\n pb, rect,\n wuffs_base__color_u32_argb_premul__as__color_u64_argb_no" +
|
||||
"npremul(\n color));\n return wuffs_base__make_status(NULL);\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxx(\n pb, rect,\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n wuffs_base__swap_u32_argb_abgr(color)));\n return wuffs_base__make_status(NULL);\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n wuffs_base__pixel_buffer__set_color_u32_fill_rect__xxxx(\n pb, rect, wuffs_base__swap_u32_argb_abgr(color));\n return wuffs_base__make_status(NULL);\n }\n\n uint32_t y;\n for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {\n uint32_t x;\n for (x = rect.min_incl_x; x < rect.max_excl_x; x++) {\n wuffs_base__pixel_buffer__set_color_u32_at(pb, x, y, color);\n }\n }\n return wuffs_base__make_status(NULL);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nWUFFS_BASE__MAYBE_STATIC uint8_t //\nwuffs_base__pixel_palette__closest_element(\n wuffs_base__slice_u8 palette_slice,\n wuffs_base__pixel_format palette_format,\n wuffs_base__color_u32_argb_premul c) {\n size_t n = palette_slice.len / 4;\n if (n > (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n n = (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4);\n }\n size_t best_index = 0;\n uint64_t best_score = 0xFFFFFFFFFFFFFFFF;\n\n // Work in 16-bit color.\n uint32_t ca = 0x101 * (0xFF & (c >> 24));\n uint32_t cr = 0x101 * (0xFF & (c >> 16));\n uint32_t cg = 0x101 * (0xFF & (c >> 8));\n uint32_t cb = 0x101 * (0xFF & (c >> 0));\n\n switch (palette_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {\n bool nonpremul = palette_format.repr ==\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL;\n\n size_t i;\n" +
|
||||
" for (i = 0; i < n; i++) {\n // Work in 16-bit color.\n uint32_t pb = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 0]));\n uint32_t pg = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 1]));\n uint32_t pr = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 2]));\n uint32_t pa = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 3]));\n\n // Convert to premultiplied alpha.\n if (nonpremul && (pa != 0xFFFF)) {\n pb = (pb * pa) / 0xFFFF;\n pg = (pg * pa) / 0xFFFF;\n pr = (pr * pa) / 0xFFFF;\n }\n\n // These deltas are conceptually int32_t (signed) but after squaring,\n // it's equivalent to work in uint32_t (unsigned).\n pb -= cb;\n pg -= cg;\n pr -= cr;\n pa -= ca;\n uint64_t score = ((uint64_t)(pb * pb)) + ((uint64_t)(pg * pg)) +\n ((uint64_t)(pr * pr)) + ((uint64_t)(pa * pa));\n if (best_score > score) {\n best_score = score;\n best_index = i;\n " +
|
||||
"}\n }\n break;\n }\n }\n\n return (uint8_t)best_index;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic inline uint32_t //\nwuffs_base__composite_nonpremul_nonpremul_u32_axxx(uint32_t dst_nonpremul,\n uint32_t src_nonpremul) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));\n uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));\n uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));\n uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));\n uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));\n uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));\n uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));\n uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));\n\n // Convert dst from nonpremul to premul.\n dr = (dr * da) / 0xFFFF;\n dg = (dg * da) / 0xFFFF;\n db = (db * da) / 0xFFFF;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n dr = ((sr * sa) + (dr * ia)) / 0xF" +
|
||||
"FFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert dst from premul to nonpremul.\n if (da != 0) {\n dr = (dr * 0xFFFF) / da;\n dg = (dg * 0xFFFF) / da;\n db = (db * 0xFFFF) / da;\n }\n\n // Convert from 16-bit color to 8-bit color.\n da >>= 8;\n dr >>= 8;\n dg >>= 8;\n db >>= 8;\n\n // Combine components.\n return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);\n}\n\nstatic inline uint64_t //\nwuffs_base__composite_nonpremul_nonpremul_u64_axxx(uint64_t dst_nonpremul,\n uint64_t src_nonpremul) {\n // Extract components.\n uint64_t sa = 0xFFFF & (src_nonpremul >> 48);\n uint64_t sr = 0xFFFF & (src_nonpremul >> 32);\n uint64_t sg = 0xFFFF & (src_nonpremul >> 16);\n uint64_t sb = 0xFFFF & (src_nonpremul >> 0);\n uint64_t da = 0xFFFF & (dst_nonpremul >> 48);\n uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);\n uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);\n uint64_t db = 0xFFFF & (dst_nonpremul >> 0);\n\n // Convert ds" +
|
||||
"t from nonpremul to premul.\n dr = (dr * da) / 0xFFFF;\n dg = (dg * da) / 0xFFFF;\n db = (db * da) / 0xFFFF;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint64_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert dst from premul to nonpremul.\n if (da != 0) {\n dr = (dr * 0xFFFF) / da;\n dg = (dg * 0xFFFF) / da;\n db = (db * 0xFFFF) / da;\n }\n\n // Combine components.\n return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);\n}\n\nstatic inline uint32_t //\nwuffs_base__composite_nonpremul_premul_u32_axxx(uint32_t dst_nonpremul,\n uint32_t src_premul) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));\n uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));\n uint32_t sg = 0x101 * (0xFF & (src_premul >> 8)" +
|
||||
");\n uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));\n uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));\n uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));\n uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));\n uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));\n\n // Convert dst from nonpremul to premul.\n dr = (dr * da) / 0xFFFF;\n dg = (dg * da) / 0xFFFF;\n db = (db * da) / 0xFFFF;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert dst from premul to nonpremul.\n if (da != 0) {\n dr = (dr * 0xFFFF) / da;\n dg = (dg * 0xFFFF) / da;\n db = (db * 0xFFFF) / da;\n }\n\n // Convert from 16-bit color to 8-bit color.\n da >>= 8;\n dr >>= 8;\n dg >>= 8;\n db >>= 8;\n\n // Combine components.\n return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);\n}\n" +
|
||||
"\nstatic inline uint64_t //\nwuffs_base__composite_nonpremul_premul_u64_axxx(uint64_t dst_nonpremul,\n uint64_t src_premul) {\n // Extract components.\n uint64_t sa = 0xFFFF & (src_premul >> 48);\n uint64_t sr = 0xFFFF & (src_premul >> 32);\n uint64_t sg = 0xFFFF & (src_premul >> 16);\n uint64_t sb = 0xFFFF & (src_premul >> 0);\n uint64_t da = 0xFFFF & (dst_nonpremul >> 48);\n uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);\n uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);\n uint64_t db = 0xFFFF & (dst_nonpremul >> 0);\n\n // Convert dst from nonpremul to premul.\n dr = (dr * da) / 0xFFFF;\n dg = (dg * da) / 0xFFFF;\n db = (db * da) / 0xFFFF;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint64_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert dst from premul to nonpremul.\n " +
|
||||
" if (da != 0) {\n dr = (dr * 0xFFFF) / da;\n dg = (dg * 0xFFFF) / da;\n db = (db * 0xFFFF) / da;\n }\n\n // Combine components.\n return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);\n}\n\nstatic inline uint32_t //\nwuffs_base__composite_premul_nonpremul_u32_axxx(uint32_t dst_premul,\n uint32_t src_nonpremul) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));\n uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));\n uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));\n uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));\n uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));\n uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));\n uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));\n uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n" +
|
||||
" dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 8-bit color.\n da >>= 8;\n dr >>= 8;\n dg >>= 8;\n db >>= 8;\n\n // Combine components.\n return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);\n}\n\nstatic inline uint64_t //\nwuffs_base__composite_premul_nonpremul_u64_axxx(uint64_t dst_premul,\n uint64_t src_nonpremul) {\n // Extract components.\n uint64_t sa = 0xFFFF & (src_nonpremul >> 48);\n uint64_t sr = 0xFFFF & (src_nonpremul >> 32);\n uint64_t sg = 0xFFFF & (src_nonpremul >> 16);\n uint64_t sb = 0xFFFF & (src_nonpremul >> 0);\n uint64_t da = 0xFFFF & (dst_premul >> 48);\n uint64_t dr = 0xFFFF & (dst_premul >> 32);\n uint64_t dg = 0xFFFF & (dst_premul >> 16);\n uint64_t db = 0xFFFF & (dst_premul >> 0);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint64_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul)" +
|
||||
".\n da = sa + ((da * ia) / 0xFFFF);\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Combine components.\n return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);\n}\n\nstatic inline uint32_t //\nwuffs_base__composite_premul_premul_u32_axxx(uint32_t dst_premul,\n uint32_t src_premul) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));\n uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));\n uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));\n uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));\n uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));\n uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));\n uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));\n uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n da =" +
|
||||
" sa + ((da * ia) / 0xFFFF);\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert from 16-bit color to 8-bit color.\n da >>= 8;\n dr >>= 8;\n dg >>= 8;\n db >>= 8;\n\n // Combine components.\n return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__squash_align4_bgr_565_8888(uint8_t* dst_ptr,\n size_t dst_len,\n const uint8_t* src_ptr,\n size_t src_len,\n bool nonpremul) {\n size_t len = (dst_len < src_len ? dst_len : src_len) / 4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n--) {\n uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s);\n if (nonpremul) {\n argb =\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb);\n }\n uint32_t b5 = 0x1F & (argb >> (8 - 5));\n uint32_t g6 = 0x3F & (argb >> (16 - 6));\n uint32_t r5 = 0x1F & (argb >> (24 - 5));\n uint32_t alpha = argb & 0xFF000000;\n wuffs_base__poke_u32le__no_bounds_check(\n d, alpha | (r5 << 11) | (g6 << 5) | (b5 << 0));\n s += 4;\n " +
|
||||
" d += 4;\n }\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__swap_rgb_bgr(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t len = (dst_len < src_len ? dst_len : src_len) / 3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n--) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n d[0] = s2;\n d[1] = s1;\n d[2] = s0;\n s += 3;\n d += 3;\n }\n return len;\n}\n\n// ‼ WUFFS MULTI-FILE SECTION +x86_sse42\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\nWUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2\")\nstatic uint64_t //\nwuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,\n size_t dst_len,\n " +
|
||||
" uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t len = (dst_len < src_len ? dst_len : src_len) / 4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n __m128i shuffle = _mm_set_epi8(+0x0F, +0x0C, +0x0D, +0x0E, //\n +0x0B, +0x08, +0x09, +0x0A, //\n +0x07, +0x04, +0x05, +0x06, //\n +0x03, +0x00, +0x01, +0x02);\n\n while (n >= 4) {\n __m128i x;\n x = _mm_lddqu_si128((const __m128i*)(const void*)s);\n x = _mm_shuffle_epi8(x, shuffle);\n _mm_storeu_si128((__m128i*)(void*)d, x);\n\n s += 4 * 4;\n d += 4 * 4;\n n -= 4;\n }\n\n while (n--) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n uint8_t s3 = s[3];\n d[0] = s2;\n d[1" +
|
||||
"] = s1;\n d[2] = s0;\n d[3] = s3;\n s += 4;\n d += 4;\n }\n return len;\n}\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n// ‼ WUFFS MULTI-FILE SECTION -x86_sse42\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__swap_rgbx_bgrx(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t len = (dst_len < src_len ? dst_len : src_len) / 4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n--) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n uint8_t s3 = s[3];\n d[0] = s2;\n d[1] = s1;\n d[2] = s0;\n d[3] = s3;\n s += 4;\n d += 4;\n }\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_1_1(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t len = (dst_len < src_len) ? dst_len : src_len;\n if (len > 0) {\n memmove(dst_ptr, src_ptr, len);\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_2_2(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;\n if (len > 0) {\n " +
|
||||
" memmove(dst_ptr, src_ptr, len * 2);\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_3_3(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len3 < src_len3) ? dst_len3 : src_len3;\n if (len > 0) {\n memmove(dst_ptr, src_ptr, len * 3);\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_4_4(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_l" +
|
||||
"en / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n if (len > 0) {\n memmove(dst_ptr, src_ptr, len * 4);\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_8_8(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;\n if (len > 0) {\n memmove(dst_ptr, src_ptr, len * 8);\n }\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgr(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t b5 = s[0] >> 3;\n uint32_t g6 = s[1] >> 2;\n uint32_t r5 = s[2] >> 3;\n uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);\n\n s += 1 * 3;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgrx(uint8_t* dst_ptr,\n " +
|
||||
" size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t b5 = s[0] >> 3;\n uint32_t g6 = s[1] >> 2;\n uint32_t r5 = s[2] >> 3;\n uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const u" +
|
||||
"int8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8" +
|
||||
"_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))));\n\n s += 1 * 8;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sr = 0x101 * ((uint32_t)s[2]);\n " +
|
||||
" uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sb = 0x101 * ((uint32_t)s[0]);\n\n // Convert from 565 color to 16-bit color.\n uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));\n uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);\n uint32_t dr = (0x8421 * old_r5) >> 4;\n uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);\n uint32_t dg = (0x1041 * old_g6) >> 2;\n uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);\n uint32_t db = (0x8421 * old_b5) >> 4;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 565 color and combine the components.\n uint32_t new_r5 = 0x1F & (dr >> 11);\n uint32_t new_g6 = 0x3F & (dg >> 10);\n uint32_t new_b5 = 0x1F & (db >> 11);\n uint32_t new_rgb_565 = (new_r5 << 11) | (n" +
|
||||
"ew_g6 << 5) | (new_b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));\n uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));\n uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));\n uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));\n\n // Convert f" +
|
||||
"rom 565 color to 16-bit color.\n uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));\n uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);\n uint32_t dr = (0x8421 * old_r5) >> 4;\n uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);\n uint32_t dg = (0x1041 * old_g6) >> 2;\n uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);\n uint32_t db = (0x8421 * old_b5) >> 4;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 565 color and combine the components.\n uint32_t new_r5 = 0x1F & (dr >> 11);\n uint32_t new_g6 = 0x3F & (dg >> 10);\n uint32_t new_b5 = 0x1F & (db >> 11);\n uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_" +
|
||||
"565);\n\n s += 1 * 8;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_premul__src(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2), wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));\n\n s += 1 * 4;\n d += 1 * 2;\n n" +
|
||||
" -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__bgra_premul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sr = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sb = 0x101 * ((uint32_t)s[0]);\n\n // Convert from 565 color to 16-bit color.\n uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));\n uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);\n uint32_t dr = (0x8421 * old_r5) >> 4;\n uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);\n uint32_t dg = (0x1041 * old_g6) >> 2;" +
|
||||
"\n uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);\n uint32_t db = (0x8421 * old_b5) >> 4;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert from 16-bit color to 565 color and combine the components.\n uint32_t new_r5 = 0x1F & (dr >> 11);\n uint32_t new_g6 = 0x3F & (dg >> 10);\n uint32_t new_b5 = 0x1F & (db >> 11);\n uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__rgb(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n s" +
|
||||
"ize_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t r5 = s[0] >> 3;\n uint32_t g6 = s[1] >> 2;\n uint32_t b5 = s[2] >> 3;\n uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);\n\n s += 1 * 3;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_l" +
|
||||
"en4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__swap_u32_argb_abgr(\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))));\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color compon" +
|
||||
"ents.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sb = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sr = 0x101 * ((uint32_t)s[0]);\n\n // Convert from 565 color to 16-bit color.\n uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));\n uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);\n uint32_t dr = (0x8421 * old_r5) >> 4;\n uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);\n uint32_t dg = (0x1041 * old_g6) >> 2;\n uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);\n uint32_t db = (0x8421 * old_b5) >> 4;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 565 color and combine the components.\n uint32_t new_r5 = 0x1F & (dr >> 11);\n uint32_t new_g6 = 0x3F & (dg " +
|
||||
">> 10);\n uint32_t new_b5 = 0x1F & (db >> 11);\n uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__rgba_premul__src(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(" +
|
||||
"\n d + (0 * 2),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__rgba_premul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sb = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sr = 0x101 * ((uint32_t)s[0]);\n\n // Convert from 565 color to 16-bit color.\n uint32_t old_rgb" +
|
||||
"_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));\n uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);\n uint32_t dr = (0x8421 * old_r5) >> 4;\n uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);\n uint32_t dg = (0x1041 * old_g6) >> 2;\n uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);\n uint32_t db = (0x8421 * old_b5) >> 4;\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert from 16-bit color to 565 color and combine the components.\n uint32_t new_r5 = 0x1F & (dr >> 11);\n uint32_t new_g6 = 0x3F & (dg >> 10);\n uint32_t new_b5 = 0x1F & (db >> 11);\n uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);\n\n s += 1 * 4;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nst" +
|
||||
"atic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__y(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t len = (dst_len2 < src_len) ? dst_len2 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t y5 = s[0] >> 3;\n uint32_t y6 = s[0] >> 2;\n uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);\n\n s += 1 * 1;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__y_16be(uint8_t* dst_ptr,\n size_t dst_len,\n " +
|
||||
" uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t y5 = s[0] >> 3;\n uint32_t y6 = s[0] >> 2;\n uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0);\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);\n\n s += 1 * 2;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__index__src(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n " +
|
||||
" const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len2 = dst_len / 2;\n size_t len = (dst_len2 < src_len) ? dst_len2 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4)));\n wuffs_base__poke_u16le__no_bounds_check(\n d + (1 * 2), wuffs_base__peek_u16le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[1] * 4)));\n wuffs_base__poke_u16le__no_bounds_check(\n d + (2 * 2), wuffs_base__peek_u16le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[2] * 4)));\n wuffs_base__poke_u16le" +
|
||||
"__no_bounds_check(\n d + (3 * 2), wuffs_base__peek_u16le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 2;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4)));\n\n s += 1 * 1;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__index_bgra_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len2 = dst_len / 2;\n size_t len = (dst_len2 < src_len) ? dst_len2 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: u" +
|
||||
"nroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n wuffs_base__poke_u16le__no_bounds_check(\n d + (0 * 2),\n wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(\n wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0)));\n\n s += 1 * 1;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr_565__index_binary_alpha__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len2 = dst_len / 2;\n size_t len = (dst_len2 < src_len) ? dst_len2 : src_len" +
|
||||
";\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)s0);\n }\n\n s += 1 * 1;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgr_565(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)));\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n\n s += 1 * 2;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src(uint8_t* dst_ptr,\n " +
|
||||
" size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 =\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_" +
|
||||
"ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 =\n wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n\n s += 1 * 8;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_" +
|
||||
"t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sr = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sb = 0x101 * ((uint32_t)s[0]);\n uint32_t dr = 0x101 * ((uint32_t)d[2]);\n uint32_t dg = 0x101 * ((uint32_t)d[1]);\n uint32_t db = 0x101 * ((uint32_t)d[0]);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 8-bit color.\n d[0] = (uint8_t)(db >> 8);\n d[1] = (uint8_t)(dg >> 8);\n d[2] = (uint8_t)(dr >> 8);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src_over(\n uint8_t* dst_ptr,\n size_t dst_le" +
|
||||
"n,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));\n uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));\n uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));\n uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));\n uint32_t dr = 0x101 * ((uint32_t)d[2]);\n uint32_t dg = 0x101 * ((uint32_t)d[1]);\n uint32_t db = 0x101 * ((uint32_t)d[0]);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia" +
|
||||
")) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 8-bit color.\n d[0] = (uint8_t)(db >> 8);\n d[1] = (uint8_t)(dg >> 8);\n d[2] = (uint8_t)(dr >> 8);\n\n s += 1 * 8;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_premul__src(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n u" +
|
||||
"int8_t s2 = s[2];\n d[0] = s0;\n d[1] = s1;\n d[2] = s2;\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__bgra_premul__src_over(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sr = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sb = 0x101 * ((" +
|
||||
"uint32_t)s[0]);\n uint32_t dr = 0x101 * ((uint32_t)d[2]);\n uint32_t dg = 0x101 * ((uint32_t)d[1]);\n uint32_t db = 0x101 * ((uint32_t)d[0]);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n // Convert from 16-bit color to 8-bit color.\n d[0] = (uint8_t)(db >> 8);\n d[1] = (uint8_t)(dg >> 8);\n d[2] = (uint8_t)(dr >> 8);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n " +
|
||||
" size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = sr" +
|
||||
"c_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sb = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sr = 0x101 * ((uint32_t)s[0]);\n uint32_t dr = 0x101 * ((uint32_t)d[2]);\n uint32_t dg = 0x101 * ((uint32_t)d[1]);\n uint32_t db = 0x101 * ((uint32_t)d[0]);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 8-bit color.\n d[0] = (uint8_t)(db >> 8);\n d[1] = (uint8_t)(dg >> 8);\n d[2] = (uint8_t)(dr >> 8);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__rgba_premul__src(uint8_t* dst_ptr,\n " +
|
||||
" size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n d[0] = s2;\n d[1] = s1;\n d[2] = s0;\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgr__rgba_premul__src_over(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n " +
|
||||
" size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n // Extract 16-bit color components.\n uint32_t sa = 0x101 * ((uint32_t)s[3]);\n uint32_t sb = 0x101 * ((uint32_t)s[2]);\n uint32_t sg = 0x101 * ((uint32_t)s[1]);\n uint32_t sr = 0x101 * ((uint32_t)s[0]);\n uint32_t dr = 0x101 * ((uint32_t)d[2]);\n uint32_t dg = 0x101 * ((uint32_t)d[1]);\n uint32_t db = 0x101 * ((uint32_t)d[0]);\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (premul) over dst (premul).\n dr = sr + ((dr * ia) / 0xFFFF);\n dg = sg + ((dg * ia) / 0xFFFF);\n db = sb + ((db * ia) / 0xFFFF);\n\n /" +
|
||||
"/ Convert from 16-bit color to 8-bit color.\n d[0] = (uint8_t)(db >> 8);\n d[1] = (uint8_t)(dg >> 8);\n d[2] = (uint8_t)(dr >> 8);\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__composite_nonpremul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8" +
|
||||
"_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__color_u64__as__color_u32(\n wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint64_t d0 = wuffs_base__color_u32__as__color_u64(" +
|
||||
"\n wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));\n uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u64__as__color_u32(\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0)));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u32_argb_premul__as__" +
|
||||
"color_u32_argb_nonpremul(s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_nonpremul_premul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len" +
|
||||
",\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__composite_nonpremul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__rgba_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t ds" +
|
||||
"t_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__composite_nonpremul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_le" +
|
||||
"n4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u3" +
|
||||
"2le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_nonpremul_premul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n uint8_t s3 = s[3];\n d[0] = s0;\n d[1] = s0;\n d[2] = s1;\n d[3] = s1;\n d[4] = s2;\n d[5] = s2;\n d[6] = s3;\n d[7] = s3;\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_le" +
|
||||
"n / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8),\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n siz" +
|
||||
"e_t n = len;\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8),\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));\n\n s += 1 * 8;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t s0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * " +
|
||||
"4))));\n wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0);\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), wuffs_base__composite_nonpremul_premul_u64_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler" +
|
||||
"__bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len8 = dst_len / 8;\n size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4)));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8),\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));\n\n s += 1 * 1;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremu" +
|
||||
"l_4x16le__rgba_nonpremul__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n uint8_t s3 = s[3];\n d[0] = s2;\n d[1] = s2;\n d[2] = s1;\n d[3] = s1;\n d[4] = s0;\n d[5] = s0;\n d[6] = s3;\n d[7] = s3;\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len" +
|
||||
"4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 =\n wuffs_base__color_u32__as__color_u64(wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8),\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t " +
|
||||
"s0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(\n wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));\n wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0);\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));\n uint64_t s0 =\n wuffs_base__color_u32__as__color_u64(wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le" +
|
||||
"__no_bounds_check(s + (0 * 4))));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), wuffs_base__composite_nonpremul_premul_u64_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 =" +
|
||||
" dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(s0));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bo" +
|
||||
"unds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint64_t d0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));\n uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4" +
|
||||
"),\n wuffs_base__color_u64__as__color_u32(\n wuffs_base__composite_premul_nonpremul_u64_axxx(d0, s0)));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_premul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_premul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__p" +
|
||||
"ixel_swizzler__bgra_premul__index_bgra_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src(\n " +
|
||||
"uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len " +
|
||||
"= (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint64_t" +
|
||||
" s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__swap_u32_argb_abgr(\n wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(\n s0)));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint64_t d0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));\n uint64_t s0 = wuffs_base__swap_u64_argb_abgr(\n wuffs_base__peek_u64le__no_bound" +
|
||||
"s_check(s + (0 * 8)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u64__as__color_u32(\n wuffs_base__composite_premul_nonpremul_u64_axxx(d0, s0)));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__rgba_premul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__swap_u32_argb_abgr(\n wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_premul_u32_axxx(d0," +
|
||||
" s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__bgr(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n 0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(s + (0 * 3)));\n\n s += 1 * 3;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__bgr_565(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* d" +
|
||||
"st_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))));\n\n s += 1 * 2;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__bgrx(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const u" +
|
||||
"int8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n 0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n// ‼ WUFFS MULTI-FILE SECTION +x86_sse42\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\nWUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2\")\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n " +
|
||||
" size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n __m128i shuffle = _mm_set_epi8(+0x00, +0x09, +0x0A, +0x0B, //\n +0x00, +0x06, +0x07, +0x08, //\n +0x00, +0x03, +0x04, +0x05, //\n +0x00, +0x00, +0x01, +0x02);\n __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00);\n\n while (n >= 6) {\n __m128i x;\n x = _mm_lddqu_si128((const __m128i*)(const void*)s);\n x = _mm_shuffle_epi8(x, shuffle);\n x = _mm_or_si128(x, or_ff);\n _mm_storeu_si128((__m128i*)(void*)d, x);\n\n s += 4 * 3;\n d += 4 * 4;\n n -= 4;\n }\n\n whi" +
|
||||
"le (n >= 1) {\n uint8_t b0 = s[0];\n uint8_t b1 = s[1];\n uint8_t b2 = s[2];\n d[0] = b2;\n d[1] = b1;\n d[2] = b0;\n d[3] = 0xFF;\n\n s += 1 * 3;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n// ‼ WUFFS MULTI-FILE SECTION -x86_sse42\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__rgb(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint8_t b0 = s[0];\n uint8_t b1 = s[1];\n uint8_t b2 = s[2];\n d[0] = b2;\n d[1] = b1;\n d[2] = b0;\n d[3] = 0xF" +
|
||||
"F;\n\n s += 1 * 3;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw__rgbx(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint8_t b0 = s[0];\n uint8_t b1 = s[1];\n uint8_t b2 = s[2];\n d[0] = b2;\n d[1] = b1;\n d[2] = b0;\n d[3] = 0xFF;\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw_4x16le__bgr(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n d[0] = s0;\n d[1] = s0;\n d[2] = s1;\n d[3] = s1;\n d[4] = s2;\n d[5] = s2;\n d[6] = 0xFF;\n d[7] = 0xFF;\n\n s += 1 * 3;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw_4x16le__bgr_565(uint8_t* dst_ptr,\n " +
|
||||
" size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8),\n wuffs_base__color_u32__as__color_u64(\n wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))));\n\n s += 1 * 2;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw_4x16le__bgrx(uint8_t* dst_ptr,\n size_t dst_len,\n " +
|
||||
" uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n d[0] = s0;\n d[1] = s0;\n d[2] = s1;\n d[3] = s1;\n d[4] = s2;\n d[5] = s2;\n d[6] = 0xFF;\n d[7] = 0xFF;\n\n s += 1 * 4;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgrw_4x16le__rgb(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n " +
|
||||
" const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len3 = src_len / 3;\n size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n uint8_t s2 = s[2];\n d[0] = s2;\n d[1] = s2;\n d[2] = s1;\n d[3] = s1;\n d[4] = s0;\n d[5] = s0;\n d[6] = 0xFF;\n d[7] = 0xFF;\n\n s += 1 * 3;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n\n size_t n = len;\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__color_u64__as__color_u32__swap_u32_argb_abgr(\n wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n" +
|
||||
" size_t src_len8 = src_len / 8;\n size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint64_t d0 = wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));\n uint64_t s0 = wuffs_base__swap_u64_argb_abgr(\n wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__color_u64__as__color_u32(\n wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0)));\n\n s += 1 * 8;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__rgbw__bgr_565(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4),\n wuffs_base__swap_u32_argb_abgr(\n wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(\n wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))));\n\n s += 1 * 2;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index__src(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len3 = dst_len / 3;\n size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n // The comparison in the while condition is \">\", not \">=\", because with\n // \">=\", the last 4-byte store could write past the end of the dst slice.\n //\n // Each 4-byte store writes one too many bytes, but a subsequent store\n // will overwrite that with the correct byte. There is always" +
|
||||
" another\n // store, whether a 4-byte store in this loop or a 1-byte store in the\n // next loop.\n while (n > loop_unroll_count) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (1 * 3), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[1] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (2 * 3), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[2] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (3 * 3), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 3;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n " +
|
||||
" ((size_t)s[0] * 4));\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n\n s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index_bgra_nonpremul__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len3 = dst_len / 3;\n size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 =\n wuffs_base__peek_u24le__no_bounds_check(d + (0 * 3)) | 0xFF000000;\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n wuffs_base__poke_u24le__no_bou" +
|
||||
"nds_check(\n d + (0 * 3), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len3 = dst_len / 3;\n size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n }\n uint32_t s1 = wuffs_base__peek_u32le__no_bound" +
|
||||
"s_check(dst_palette_ptr +\n ((size_t)s[1] * 4));\n if (s1) {\n wuffs_base__poke_u24le__no_bounds_check(d + (1 * 3), s1);\n }\n uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[2] * 4));\n if (s2) {\n wuffs_base__poke_u24le__no_bounds_check(d + (2 * 3), s2);\n }\n uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[3] * 4));\n if (s3) {\n wuffs_base__poke_u24le__no_bounds_check(d + (3 * 3), s3);\n }\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 3;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);\n }\n\n" +
|
||||
" s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__xxxx(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len4 = src_len / 4;\n size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__poke_u24le__no_bounds_check(\n d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));\n\n s += 1 * 4;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__y(uint8_t* dst_ptr,\n size_t dst_len,\n " +
|
||||
" uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n d[0] = s0;\n d[1] = s0;\n d[2] = s0;\n\n s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__y_16be(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len3 = dst_len / 3;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len3 < src_len2)" +
|
||||
" ? dst_len3 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n d[0] = s0;\n d[1] = s0;\n d[2] = s0;\n\n s += 1 * 2;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index__src(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (1 * 4), wuffs_base__" +
|
||||
"peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[1] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (2 * 4), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[2] * 4)));\n wuffs_base__poke_u32le__no_bounds_check(\n d + (3 * 4), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 4;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4)));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len" +
|
||||
") {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0);\n }\n uint32_t s1 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[1] * 4));\n if (s1) {\n wuffs_base__poke_u32le__no_bounds_check(d + (1 * 4), s1);\n }\n uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[2] * 4));\n if (s2) {\n wuffs_base__poke_u32le" +
|
||||
"__no_bounds_check(d + (2 * 4), s2);\n }\n uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[3] * 4));\n if (s3) {\n wuffs_base__poke_u32le__no_bounds_check(d + (3 * 4), s3);\n }\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 4;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0);\n }\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n// ‼ WUFFS MULTI-FILE SECTION +x86_sse42\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\nWUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2\")\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,\n size_t dst_len,\n " +
|
||||
" uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n __m128i shuffle = _mm_set_epi8(+0x03, +0x03, +0x03, +0x03, //\n +0x02, +0x02, +0x02, +0x02, //\n +0x01, +0x01, +0x01, +0x01, //\n +0x00, +0x00, +0x00, +0x00);\n __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00, //\n -0x01, +0x00, +0x00, +0x00);\n\n while (n >= 4) {\n __m128i x;\n x = _mm_cvtsi32_si128((int)(wuffs_base__peek_u32le__no_bounds_check(s)));\n x = _mm_s" +
|
||||
"huffle_epi8(x, shuffle);\n x = _mm_or_si128(x, or_ff);\n _mm_storeu_si128((__m128i*)(void*)d, x);\n\n s += 4 * 1;\n d += 4 * 4;\n n -= 4;\n }\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0]));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)\n// ‼ WUFFS MULTI-FILE SECTION -x86_sse42\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__y(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_ch" +
|
||||
"eck(\n d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0]));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__y_16be(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len4 = dst_len / 4;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n wuffs_base__poke_u32le__no_bounds_check(\n d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0]));\n\n s += 1 * 2;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxxxxxx__index__src(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len8 = dst_len / 8;\n size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), wuffs_base__color_u32__as__color_u64(\n wuffs_base__peek_u32le__no_bounds_check(\n dst_palette_ptr + ((size_t)s[0] * 4))));\n\n s += 1 * 1;\n d += 1 * 8;\n n -=" +
|
||||
" 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxxxxxx__index_binary_alpha__src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n if (dst_palette_len !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return 0;\n }\n size_t dst_len8 = dst_len / 8;\n size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), wuffs_base__color_u32__as__color_u64(s0));\n }\n\n s += 1 * 1;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxxxxxx__y(uint8_t* dst_ptr,\n " +
|
||||
" size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), 0xFFFF000000000000 | (0x010101010101 * (uint64_t)s[0]));\n\n s += 1 * 1;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxxxxxx__y_16be(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n " +
|
||||
" size_t src_len) {\n size_t dst_len8 = dst_len / 8;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint64_t s0 =\n ((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(s + (0 * 2))));\n wuffs_base__poke_u64le__no_bounds_check(\n d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0));\n\n s += 1 * 2;\n d += 1 * 8;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__y__y_16be(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n size_t src_len) {\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len < src_len2) ? dst_len : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n d[0] = s[0];\n\n s += 1 * 2;\n d += 1 * 1;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__y_16le__y_16be(uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n const uint8_t* src_ptr,\n " +
|
||||
" size_t src_len) {\n size_t dst_len2 = dst_len / 2;\n size_t src_len2 = src_len / 2;\n size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;\n uint8_t* d = dst_ptr;\n const uint8_t* s = src_ptr;\n size_t n = len;\n\n while (n >= 1) {\n uint8_t s0 = s[0];\n uint8_t s1 = s[1];\n d[0] = s1;\n d[1] = s0;\n\n s += 1 * 2;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__transparent_black_src(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n uint64_t num_pixels,\n uint32_t dst_pixfmt_bytes_per_pixel) {\n uint64_t n = ((uint64_t)dst_len) / dst_pixfmt_bytes_per_pixel;\n if (n > num_pixels) {\n n = num_pixels;\n }\n memset(dst_ptr, 0, ((size_t)(n * dst_pixfmt_bytes_per_pixel)));\n return n;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__transparent_black_src_over(\n uint8_t* dst_ptr,\n size_t dst_len,\n uint8_t* dst_palette_ptr,\n size_t dst_palette_len,\n uint64_t num_pixels,\n uint32_t dst_pixfmt_bytes_per_pixel) {\n uint64_t n = ((uint64_t)dst_len) / dst_pixfmt_bytes_per_pixel;\n if (n > num_pixels) {\n n = num_pixels;\n }\n return n;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__y(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n return wuffs_base__pixel_swizzler__copy_1_1;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__y;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__xxx__y;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BA" +
|
||||
"SE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__xxxx__y__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__xxxx__y;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__xxxxxxxx__y;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__y_16be(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n " +
|
||||
" wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n return wuffs_base__pixel_swizzler__y__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:\n return wuffs_base__pixel_swizzler__y_16le__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:\n return wuffs_base__pixel_swizzler__copy_2_2;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__xxx__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__xxx" +
|
||||
"x__y_16be;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__xxxxxxxx__y_16be;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_1_1;\n }\n return NULL;" +
|
||||
"\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__squash_align4_bgr_565_8888(\n dst_palette.ptr, dst_palette.len, src_palette.ptr,\n src_palette.len, true) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgr_565__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgr_565__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n " +
|
||||
" dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxx__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_O" +
|
||||
"VER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxxxxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__P" +
|
||||
"ALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgra_premul__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PI" +
|
||||
"XEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n if (wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n return wuffs_base__pixel_swizzler__bgra_premul__ind" +
|
||||
"ex_bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_1_1;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n if (wuff" +
|
||||
"s_base__pixel_swizzler__squash_align4_bgr_565_8888(\n dst_palette.ptr, dst_palette.len, src_palette.ptr,\n src_palette.len, false) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over;\n " +
|
||||
" }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_sw" +
|
||||
"izzler__xxxxxxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxxxxxx__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(\n dst_palette.ptr, dst_palette." +
|
||||
"len, NULL, 0, src_palette.ptr,\n src_palette.len) !=\n (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n }\n return NULL;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgr_565(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__copy_2_2;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__bgr__bgr_565;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL" +
|
||||
":\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return wuffs_base__pixel_swizzler__bgrw__bgr_565;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__bgr_565;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__rgbw__bgr_565;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n " +
|
||||
"wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__copy_3_3;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return wuffs_base__pixel_swizzler__bgrw__bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__swap_rgb_bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch" +
|
||||
"__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__bgrw__rgb;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgra_nonpremul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src;\n case WUFFS_" +
|
||||
"BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__b" +
|
||||
"gra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n retur" +
|
||||
"n wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgra_nonpremul_4x16le(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__src_over;\n }\n " +
|
||||
" return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_8_8;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x" +
|
||||
"16le__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src_over;\n }\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT" +
|
||||
"__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgra_premul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n " +
|
||||
" return wuffs_base__pixel_swizzler__bgr_565__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__S" +
|
||||
"RC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n " +
|
||||
" return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_premul__src_over;\n }\n return NULL;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgrx(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__bgrx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__xxx__xxxx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n " +
|
||||
" case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n return wuffs_base__pixel_swizzler__bgrw__bgrx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__bgrx;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return wuffs_base__pixel_swizzler__copy_4_4;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__bgrw__rgbx;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__rgb(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 " +
|
||||
"src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n return wuffs_base__pixel_swizzler__bgr_565__rgb;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return wuffs_base__pixel_swizzler__swap_rgb_bgr;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__bgrw__rgb;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n return wuffs_base__pixel_swizzler__bgrw_4x16le__rgb;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__pixel_swizzler__copy_3_3;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_" +
|
||||
"PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__pixel_swizzler__bgrw__bgr;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__rgba_nonpremul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src;\n case WUFFS_B" +
|
||||
"ASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src_over;\n }\n " +
|
||||
" return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return" +
|
||||
" wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n // TODO.\n break;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__rgba_premul(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr_565__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_" +
|
||||
"BASE__PIXEL_FORMAT__BGR:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgr__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgr__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src_over;\n }\n " +
|
||||
" return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n#if defined(WUFFS_BASE__CPU_ARCH__X86_64)\n if (wuffs_base__cpu_arch__have_x86_sse42()) {\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;\n }\n#endif\n return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__rgba_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return w" +
|
||||
"uffs_base__pixel_swizzler__copy_4_4;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__bgra_premul__bgra_premul__src_over;\n }\n return NULL;\n }\n return NULL;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__status //\nwuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_pixfmt,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__pixel_format src_pixfmt,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n if (!p) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n p->private_impl.func = NULL;\n p->private_impl.transparent_black_func = NULL;\n p->private_impl.dst_pixfmt_bytes_per_pixel = 0;\n p->private_impl.src_pixfmt_bytes_per_pixel = 0;\n\n wuffs_base__pixel_swizzler__func func = NULL;\n wuffs_base__pixel_swizzler__transparent_black_func transparent_black_func =\n NULL;\n\n uint32_t dst_pixfmt_bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&dst_pixfmt);\n if ((dst_pixfmt_bits_per_pixel == " +
|
||||
"0) ||\n ((dst_pixfmt_bits_per_pixel & 7) != 0)) {\n return wuffs_base__make_status(\n wuffs_base__error__unsupported_pixel_swizzler_option);\n }\n\n uint32_t src_pixfmt_bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&src_pixfmt);\n if ((src_pixfmt_bits_per_pixel == 0) ||\n ((src_pixfmt_bits_per_pixel & 7) != 0)) {\n return wuffs_base__make_status(\n wuffs_base__error__unsupported_pixel_swizzler_option);\n }\n\n // TODO: support many more formats.\n\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n transparent_black_func =\n wuffs_base__pixel_swizzler__transparent_black_src;\n break;\n\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n transparent_black_func =\n wuffs_base__pixel_swizzler__transparent_black_src_over;\n break;\n }\n\n switch (src_pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n func = wuffs_base__pixel_swizzler__prepare__y(p, dst_pixfmt, dst_palette,\n src_palette" +
|
||||
", blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:\n func = wuffs_base__pixel_swizzler__prepare__y_16be(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n func = wuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n func = wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n func = wuffs_base__pixel_swizzler__prepare__bgr_565(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n func = wuffs_base__pixel_swizzler__prepare__bgr(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n func = wuffs_ba" +
|
||||
"se__pixel_swizzler__prepare__bgra_nonpremul(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:\n func = wuffs_base__pixel_swizzler__prepare__bgra_nonpremul_4x16le(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n func = wuffs_base__pixel_swizzler__prepare__bgra_premul(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n func = wuffs_base__pixel_swizzler__prepare__bgrx(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n func = wuffs_base__pixel_swizzler__prepare__rgb(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n func = wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n " +
|
||||
" break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n func = wuffs_base__pixel_swizzler__prepare__rgba_premul(\n p, dst_pixfmt, dst_palette, src_palette, blend);\n break;\n }\n\n p->private_impl.func = func;\n p->private_impl.transparent_black_func = transparent_black_func;\n p->private_impl.dst_pixfmt_bytes_per_pixel = dst_pixfmt_bits_per_pixel / 8;\n p->private_impl.src_pixfmt_bytes_per_pixel = src_pixfmt_bits_per_pixel / 8;\n return wuffs_base__make_status(\n func ? NULL : wuffs_base__error__unsupported_pixel_swizzler_option);\n}\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__limited_swizzle_u32_interleaved_from_reader(\n const wuffs_base__pixel_swizzler* p,\n uint32_t up_to_num_pixels,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r) {\n if (p && p->private_impl.func) {\n const uint8_t* iop_r = *ptr_iop_r;\n uint64_t src_len = wuffs_base__u64__min(\n ((uint64_t)up_to_num_pi" +
|
||||
"xels) *\n ((uint64_t)p->private_impl.src_pixfmt_bytes_per_pixel),\n ((uint64_t)(io2_r - iop_r)));\n uint64_t n =\n (*p->private_impl.func)(dst.ptr, dst.len, dst_palette.ptr,\n dst_palette.len, iop_r, (size_t)src_len);\n *ptr_iop_r += n * p->private_impl.src_pixfmt_bytes_per_pixel;\n return n;\n }\n return 0;\n}\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_from_reader(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n const uint8_t** ptr_iop_r,\n const uint8_t* io2_r) {\n if (p && p->private_impl.func) {\n const uint8_t* iop_r = *ptr_iop_r;\n uint64_t src_len = ((uint64_t)(io2_r - iop_r));\n uint64_t n =\n (*p->private_impl.func)(dst.ptr, dst.len, dst_palette.ptr,\n dst_palette.len, iop_r, (size_t)src_len);\n *ptr_iop_r += n * p->private_impl.src_pixfmt_bytes_per_pixel;\n return n;\n }\n return 0;\n}\n\nWUF" +
|
||||
"FS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (p && p->private_impl.func) {\n return (*p->private_impl.func)(dst.ptr, dst.len, dst_palette.ptr,\n dst_palette.len, src.ptr, src.len);\n }\n return 0;\n}\n\nWUFFS_BASE__MAYBE_STATIC uint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n uint64_t num_pixels) {\n if (p && p->private_impl.transparent_black_func) {\n return (*p->private_impl.transparent_black_func)(\n dst.ptr, dst.len, dst_palette.ptr, dst_palette.len, num_pixels,\n p->private_impl.dst_pixfmt_bytes_per_pixel);\n }\n return 0;\n}\n" +
|
||||
""
|
||||
|
||||
const BaseUTF8SubmoduleC = "" +
|
||||
"// ---------------- Unicode and UTF-8\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__utf_8__encode(wuffs_base__slice_u8 dst, uint32_t code_point) {\n if (code_point <= 0x7F) {\n if (dst.len >= 1) {\n dst.ptr[0] = (uint8_t)(code_point);\n return 1;\n }\n\n } else if (code_point <= 0x07FF) {\n if (dst.len >= 2) {\n dst.ptr[0] = (uint8_t)(0xC0 | ((code_point >> 6)));\n dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));\n return 2;\n }\n\n } else if (code_point <= 0xFFFF) {\n if ((dst.len >= 3) && ((code_point < 0xD800) || (0xDFFF < code_point))) {\n dst.ptr[0] = (uint8_t)(0xE0 | ((code_point >> 12)));\n dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 6) & 0x3F));\n dst.ptr[2] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));\n return 3;\n }\n\n } else if (code_point <= 0x10FFFF) {\n if (dst.len >= 4) {\n dst.ptr[0] = (uint8_t)(0xF0 | ((code_point >> 18)));\n dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 12) & 0x3F));\n dst.ptr[2] = (uint8_t)(0x80 |" +
|
||||
" ((code_point >> 6) & 0x3F));\n dst.ptr[3] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));\n return 4;\n }\n }\n\n return 0;\n}\n\n// wuffs_base__utf_8__byte_length_minus_1 is the byte length (minus 1) of a\n// UTF-8 encoded code point, based on the encoding's initial byte.\n// - 0x00 is 1-byte UTF-8 (ASCII).\n// - 0x01 is the start of 2-byte UTF-8.\n// - 0x02 is the start of 3-byte UTF-8.\n// - 0x03 is the start of 4-byte UTF-8.\n// - 0x40 is a UTF-8 tail byte.\n// - 0x80 is invalid UTF-8.\n//\n// RFC 3629 (UTF-8) gives this grammar for valid UTF-8:\n// UTF8-1 = %x00-7F\n// UTF8-2 = %xC2-DF UTF8-tail\n// UTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /\n// %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )\n// UTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /\n// %xF4 %x80-8F 2( UTF8-tail )\n// UTF8-tail = %x80-BF\nstatic const uint8_t wuffs_base__utf_8__byte_length_minus_1[256] = {\n // 0 1 2 3 4 5 " +
|
||||
" 6 7\n // 8 9 A B C D E F\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00 ..= 0x07.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x08 ..= 0x0F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x10 ..= 0x17.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x18 ..= 0x1F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ..= 0x27.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x28 ..= 0x2F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x30 ..= 0x37.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x38 ..= 0x3F.\n\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x40 ..= 0x47.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x48 ..= 0x4F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x50 ..= 0x57.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x58 ..= 0x5F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x60 ..= 0x67.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00" +
|
||||
", 0x00, 0x00, // 0x68 ..= 0x6F.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x70 ..= 0x77.\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x78 ..= 0x7F.\n\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x80 ..= 0x87.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x88 ..= 0x8F.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x90 ..= 0x97.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x98 ..= 0x9F.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xA0 ..= 0xA7.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xA8 ..= 0xAF.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xB0 ..= 0xB7.\n 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0xB8 ..= 0xBF.\n\n 0x80, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xC0 ..= 0xC7.\n 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xC8 ..= 0xCF.\n 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xD0 ..= 0xD7.\n 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, // 0xD8 ..= 0" +
|
||||
"xDF.\n 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xE0 ..= 0xE7.\n 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xE8 ..= 0xEF.\n 0x03, 0x03, 0x03, 0x03, 0x03, 0x80, 0x80, 0x80, // 0xF0 ..= 0xF7.\n 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, // 0xF8 ..= 0xFF.\n // 0 1 2 3 4 5 6 7\n // 8 9 A B C D E F\n};\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output //\nwuffs_base__utf_8__next(const uint8_t* s_ptr, size_t s_len) {\n if (s_len == 0) {\n return wuffs_base__make_utf_8__next__output(0, 0);\n }\n uint32_t c = s_ptr[0];\n switch (wuffs_base__utf_8__byte_length_minus_1[c & 0xFF]) {\n case 0:\n return wuffs_base__make_utf_8__next__output(c, 1);\n\n case 1:\n if (s_len < 2) {\n break;\n }\n c = wuffs_base__peek_u16le__no_bounds_check(s_ptr);\n if ((c & 0xC000) != 0x8000) {\n break;\n }\n c = (0x0007C0 & (c << 6)) | (0x00003F & (c >> 8));\n return wuffs_base__make_utf_8__n" +
|
||||
"ext__output(c, 2);\n\n case 2:\n if (s_len < 3) {\n break;\n }\n c = wuffs_base__peek_u24le__no_bounds_check(s_ptr);\n if ((c & 0xC0C000) != 0x808000) {\n break;\n }\n c = (0x00F000 & (c << 12)) | (0x000FC0 & (c >> 2)) |\n (0x00003F & (c >> 16));\n if ((c <= 0x07FF) || ((0xD800 <= c) && (c <= 0xDFFF))) {\n break;\n }\n return wuffs_base__make_utf_8__next__output(c, 3);\n\n case 3:\n if (s_len < 4) {\n break;\n }\n c = wuffs_base__peek_u32le__no_bounds_check(s_ptr);\n if ((c & 0xC0C0C000) != 0x80808000) {\n break;\n }\n c = (0x1C0000 & (c << 18)) | (0x03F000 & (c << 4)) |\n (0x000FC0 & (c >> 10)) | (0x00003F & (c >> 24));\n if ((c <= 0xFFFF) || (0x110000 <= c)) {\n break;\n }\n return wuffs_base__make_utf_8__next__output(c, 4);\n }\n\n return wuffs_base__make_utf_8__next__output(\n WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, 1);\n}\n\nWUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__out" +
|
||||
"put //\nwuffs_base__utf_8__next_from_end(const uint8_t* s_ptr, size_t s_len) {\n if (s_len == 0) {\n return wuffs_base__make_utf_8__next__output(0, 0);\n }\n const uint8_t* ptr = &s_ptr[s_len - 1];\n if (*ptr < 0x80) {\n return wuffs_base__make_utf_8__next__output(*ptr, 1);\n\n } else if (*ptr < 0xC0) {\n const uint8_t* too_far = &s_ptr[(s_len > 4) ? (s_len - 4) : 0];\n uint32_t n = 1;\n while (ptr != too_far) {\n ptr--;\n n++;\n if (*ptr < 0x80) {\n break;\n } else if (*ptr < 0xC0) {\n continue;\n }\n wuffs_base__utf_8__next__output o = wuffs_base__utf_8__next(ptr, n);\n if (o.byte_length != n) {\n break;\n }\n return o;\n }\n }\n\n return wuffs_base__make_utf_8__next__output(\n WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, 1);\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__utf_8__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len) {\n // TODO: possibly optimize the all-ASCII case (4 or 8 bytes at a time).\n //\n // TODO: possibly opti" +
|
||||
"mize this by manually inlining the\n // wuffs_base__utf_8__next calls.\n size_t original_len = s_len;\n while (s_len > 0) {\n wuffs_base__utf_8__next__output o = wuffs_base__utf_8__next(s_ptr, s_len);\n if ((o.code_point > 0x7F) && (o.byte_length == 1)) {\n break;\n }\n s_ptr += o.byte_length;\n s_len -= o.byte_length;\n }\n return original_len - s_len;\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t //\nwuffs_base__ascii__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len) {\n // TODO: possibly optimize this by checking 4 or 8 bytes at a time.\n const uint8_t* original_ptr = s_ptr;\n const uint8_t* p = s_ptr;\n const uint8_t* q = s_ptr + s_len;\n for (; (p != q) && ((*p & 0x80) == 0); p++) {\n }\n return (size_t)(p - original_ptr);\n}\n" +
|
||||
""
|
||||
|
||||
const AuxBaseCc = "" +
|
||||
"// ---------------- Auxiliary - Base\n\n// Auxiliary code is discussed at\n// https://github.com/google/wuffs/blob/main/doc/note/auxiliary-code.md\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__BASE)\n\nnamespace wuffs_aux {\n\nnamespace sync_io {\n\n" +
|
||||
"" +
|
||||
"// --------\n\nInput::~Input() {}\n\nIOBuffer* //\nInput::BringsItsOwnIOBuffer() {\n return nullptr;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nFileInput::FileInput(FILE* f) : m_f(f) {}\n\nstd::string //\nFileInput::CopyIn(IOBuffer* dst) {\n if (!m_f) {\n return \"wuffs_aux::sync_io::FileInput: nullptr file\";\n } else if (!dst) {\n return \"wuffs_aux::sync_io::FileInput: nullptr IOBuffer\";\n } else if (dst->meta.closed) {\n return \"wuffs_aux::sync_io::FileInput: end of file\";\n } else {\n dst->compact();\n size_t n = fread(dst->writer_pointer(), 1, dst->writer_length(), m_f);\n dst->meta.wi += n;\n dst->meta.closed = feof(m_f);\n if (ferror(m_f)) {\n return \"wuffs_aux::sync_io::FileInput: error reading file\";\n }\n }\n return \"\";\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nMemoryInput::MemoryInput(const char* ptr, size_t len)\n : m_io(wuffs_base__ptr_u8__reader(\n static_cast<uint8_t*>(static_cast<void*>(const_cast<char*>(ptr))),\n len,\n true)) {}\n\nMemoryInput::MemoryInput(const uint8_t* ptr, size_t len)\n : m_io(wuffs_base__ptr_u8__reader(const_cast<uint8_t*>(ptr), len, true)) {}\n\nIOBuffer* //\nMemoryInput::BringsItsOwnIOBuffer() {\n return &m_io;\n}\n\nstd::string //\nMemoryInput::CopyIn(IOBuffer* dst) {\n if (!dst) {\n return \"wuffs_aux::sync_io::MemoryInput: nullptr IOBuffer\";\n } else if (dst->meta.closed) {\n return \"wuffs_aux::sync_io::MemoryInput: end of file\";\n } else if (wuffs_base__slice_u8__overlaps(dst->data, m_io.data)) {\n // Treat m_io's data as immutable, so don't compact dst or otherwise write\n // to it.\n return \"wuffs_aux::sync_io::MemoryInput: overlapping buffers\";\n } else {\n dst->compact();\n size_t nd = dst->writer_length();\n size_t ns = m_io.reader_length();\n size_t n = (nd < ns) ? nd : ns;\n " +
|
||||
" memcpy(dst->writer_pointer(), m_io.reader_pointer(), n);\n m_io.meta.ri += n;\n dst->meta.wi += n;\n dst->meta.closed = m_io.reader_length() == 0;\n }\n return \"\";\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\n} // namespace sync_io\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__AUX__BASE)\n" +
|
||||
""
|
||||
|
||||
const AuxBaseHh = "" +
|
||||
"// ---------------- Auxiliary - Base\n\n// Auxiliary code is discussed at\n// https://github.com/google/wuffs/blob/main/doc/note/auxiliary-code.md\n\n#include <stdio.h>\n\n#include <string>\n\nnamespace wuffs_aux {\n\nusing IOBuffer = wuffs_base__io_buffer;\n\n// MemOwner represents ownership of some memory. Dynamically allocated memory\n// (e.g. from malloc or new) is typically paired with free or delete, invoked\n// when the std::unique_ptr is destroyed. Statically allocated memory might use\n// MemOwner(nullptr, &free), even if that statically allocated memory is not\n// nullptr, since calling free(nullptr) is a no-op.\nusing MemOwner = std::unique_ptr<void, decltype(&free)>;\n\nnamespace sync_io {\n\n" +
|
||||
"" +
|
||||
"// --------\n\nclass Input {\n public:\n virtual ~Input();\n\n virtual IOBuffer* BringsItsOwnIOBuffer();\n virtual std::string CopyIn(IOBuffer* dst) = 0;\n};\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// FileInput is an Input that reads from a file source.\n//\n// It does not take responsibility for closing the file when done.\nclass FileInput : public Input {\n public:\n FileInput(FILE* f);\n\n virtual std::string CopyIn(IOBuffer* dst);\n\n private:\n FILE* m_f;\n\n // Delete the copy and assign constructors.\n FileInput(const FileInput&) = delete;\n FileInput& operator=(const FileInput&) = delete;\n};\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// MemoryInput is an Input that reads from an in-memory source.\n//\n// It does not take responsibility for freeing the memory when done.\nclass MemoryInput : public Input {\n public:\n MemoryInput(const char* ptr, size_t len);\n MemoryInput(const uint8_t* ptr, size_t len);\n\n virtual IOBuffer* BringsItsOwnIOBuffer();\n virtual std::string CopyIn(IOBuffer* dst);\n\n private:\n IOBuffer m_io;\n\n // Delete the copy and assign constructors.\n MemoryInput(const MemoryInput&) = delete;\n MemoryInput& operator=(const MemoryInput&) = delete;\n};\n\n" +
|
||||
"" +
|
||||
"// --------\n\n} // namespace sync_io\n\n} // namespace wuffs_aux\n" +
|
||||
""
|
||||
|
||||
const AuxCborCc = "" +
|
||||
"// ---------------- Auxiliary - CBOR\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__CBOR)\n\n#include <utility>\n\nnamespace wuffs_aux {\n\nDecodeCborResult::DecodeCborResult(std::string&& error_message0,\n uint64_t cursor_position0)\n : error_message(std::move(error_message0)),\n cursor_position(cursor_position0) {}\n\nDecodeCborCallbacks::~DecodeCborCallbacks() {}\n\nvoid //\nDecodeCborCallbacks::Done(DecodeCborResult& result,\n sync_io::Input& input,\n IOBuffer& buffer) {}\n\nDecodeCborResult //\nDecodeCbor(DecodeCborCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks) {\n // Prepare the wuffs_base__io_buffer and the resultant error_message.\n wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();\n wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();\n std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);\n if (!io_buf) {\n fallback_" +
|
||||
"io_array = std::unique_ptr<uint8_t[]>(new uint8_t[4096]);\n fallback_io_buf = wuffs_base__ptr_u8__writer(fallback_io_array.get(), 4096);\n io_buf = &fallback_io_buf;\n }\n // cursor_index is discussed at\n // https://nigeltao.github.io/blog/2020/jsonptr.html#the-cursor-index\n size_t cursor_index = 0;\n std::string ret_error_message;\n std::string io_error_message;\n\n do {\n // Prepare the low-level CBOR decoder.\n wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();\n if (!dec) {\n ret_error_message = \"wuffs_aux::CborDecoder: out of memory\";\n goto done;\n }\n for (size_t i = 0; i < quirks.len; i++) {\n dec->set_quirk_enabled(quirks.ptr[i], true);\n }\n\n // Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.\n wuffs_base__token tok_array[256];\n wuffs_base__token_buffer tok_buf =\n wuffs_base__slice_token__writer(wuffs_base__make_slice_token(\n &tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));\n wuffs_base__status tok_status = " +
|
||||
"wuffs_base__make_status(nullptr);\n\n // Prepare other state.\n uint32_t depth = 0;\n std::string str;\n int64_t extension_category = 0;\n uint64_t extension_detail = 0;\n\n // Valid token's VBCs range in 0 ..= 15. Values over that are for tokens\n // from outside of the base package, such as the CBOR package.\n constexpr int64_t EXT_CAT__CBOR_TAG = 16;\n\n // Loop, doing these two things:\n // 1. Get the next token.\n // 2. Process that token.\n while (true) {\n // 1. Get the next token.\n\n while (tok_buf.meta.ri >= tok_buf.meta.wi) {\n if (tok_status.repr == nullptr) {\n // No-op.\n } else if (tok_status.repr == wuffs_base__suspension__short_write) {\n tok_buf.compact();\n } else if (tok_status.repr == wuffs_base__suspension__short_read) {\n // Read from input to io_buf.\n if (!io_error_message.empty()) {\n ret_error_message = std::move(io_error_message);\n goto done;\n } else if (cursor_index != io_" +
|
||||
"buf->meta.ri) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: bad cursor_index\";\n goto done;\n } else if (io_buf->meta.closed) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: io_buf is closed\";\n goto done;\n }\n io_buf->compact();\n if (io_buf->meta.wi >= io_buf->data.len) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: io_buf is full\";\n goto done;\n }\n cursor_index = io_buf->meta.ri;\n io_error_message = input.CopyIn(io_buf);\n } else {\n ret_error_message = tok_status.message();\n goto done;\n }\n\n if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: bad WORKBUF_LEN\";\n goto done;\n }\n wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8(" +
|
||||
");\n tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf);\n }\n\n wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];\n uint64_t token_len = token.length();\n if ((io_buf->meta.ri < cursor_index) ||\n ((io_buf->meta.ri - cursor_index) < token_len)) {\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: bad token indexes\";\n goto done;\n }\n uint8_t* token_ptr = io_buf->data.ptr + cursor_index;\n cursor_index += static_cast<size_t>(token_len);\n\n // 2. Process that token.\n\n uint64_t vbd = token.value_base_detail();\n\n if (extension_category != 0) {\n int64_t ext = token.value_extension();\n if ((ext >= 0) && !token.continued()) {\n extension_detail = (extension_detail\n << WUFFS_BASE__TOKEN__VALUE_EXTENSION__NUM_BITS) |\n static_cast<uint64_t>(ext);\n switch (extension_category) {\n case WUFFS_BASE__TOKEN__VBC__IN" +
|
||||
"LINE_INTEGER_SIGNED:\n extension_category = 0;\n ret_error_message =\n callbacks.AppendI64(static_cast<int64_t>(extension_detail));\n goto parsed_a_value;\n case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED:\n extension_category = 0;\n ret_error_message = callbacks.AppendU64(extension_detail);\n goto parsed_a_value;\n case EXT_CAT__CBOR_TAG:\n extension_category = 0;\n ret_error_message = callbacks.AppendCborTag(extension_detail);\n if (!ret_error_message.empty()) {\n goto done;\n }\n continue;\n }\n }\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: bad extended token\";\n goto done;\n }\n\n switch (token.value_base_category()) {\n case WUFFS_BASE__TOKEN__VBC__FILLER:\n continue;\n\n case WUFFS_BASE__TOKEN__VBC__STRUCTURE: {\n if (vbd & WUFFS_" +
|
||||
"BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n ret_error_message = callbacks.Push(static_cast<uint32_t>(vbd));\n if (!ret_error_message.empty()) {\n goto done;\n }\n depth++;\n continue;\n }\n ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));\n depth--;\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__STRING: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {\n // No-op.\n } else if (vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(token_ptr));\n str.append(ptr, static_cast<size_t>(token_len));\n } else {\n goto fail;\n }\n if (token.continued()) {\n continue;\n }\n ret_error_message =\n (vbd & WUFFS_BASE__T" +
|
||||
"OKEN__VBD__STRING__CHAIN_MUST_BE_UTF_8)\n ? callbacks.AppendTextString(std::move(str))\n : callbacks.AppendByteString(std::move(str));\n str.clear();\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {\n uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];\n size_t n = wuffs_base__utf_8__encode(\n wuffs_base__make_slice_u8(\n &u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),\n static_cast<uint32_t>(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(&u[0]));\n str.append(ptr, n);\n if (token.continued()) {\n continue;\n }\n goto fail;\n }\n\n case WUFFS_BASE__TOKEN__VBC__LITERAL: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL) {\n ret_error_message = callbacks.AppendNull();\n } else if (vbd & WUFFS_BASE__TOKEN__VBD_" +
|
||||
"_LITERAL__UNDEFINED) {\n ret_error_message = callbacks.AppendUndefined();\n } else {\n ret_error_message = callbacks.AppendBool(\n vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE);\n }\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__NUMBER: {\n const uint64_t cfp_fbbe_fifb =\n WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT |\n WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_BINARY_BIG_ENDIAN |\n WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_IGNORE_FIRST_BYTE;\n if ((vbd & cfp_fbbe_fifb) == cfp_fbbe_fifb) {\n double f;\n switch (token_len) {\n case 3:\n f = wuffs_base__ieee_754_bit_representation__from_u16_to_f64(\n wuffs_base__peek_u16be__no_bounds_check(token_ptr + 1));\n break;\n case 5:\n f = wuffs_base__ieee_754_bit_representation__from_u32_to_f64(\n wuffs_base__peek" +
|
||||
"_u32be__no_bounds_check(token_ptr + 1));\n break;\n case 9:\n f = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n wuffs_base__peek_u64be__no_bounds_check(token_ptr + 1));\n break;\n default:\n goto fail;\n }\n ret_error_message = callbacks.AppendF64(f);\n goto parsed_a_value;\n }\n goto fail;\n }\n\n case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED: {\n if (token.continued()) {\n extension_category = WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_SIGNED;\n extension_detail =\n static_cast<uint64_t>(token.value_base_detail__sign_extended());\n continue;\n }\n ret_error_message =\n callbacks.AppendI64(token.value_base_detail__sign_extended());\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED: {\n if (token.continu" +
|
||||
"ed()) {\n extension_category =\n WUFFS_BASE__TOKEN__VBC__INLINE_INTEGER_UNSIGNED;\n extension_detail = vbd;\n continue;\n }\n ret_error_message = callbacks.AppendU64(vbd);\n goto parsed_a_value;\n }\n }\n\n if (token.value_major() == WUFFS_CBOR__TOKEN_VALUE_MAJOR) {\n uint64_t value_minor = token.value_minor();\n if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__MINUS_1_MINUS_X) {\n if (token_len == 9) {\n ret_error_message = callbacks.AppendMinus1MinusX(\n wuffs_base__peek_u64be__no_bounds_check(token_ptr + 1));\n goto parsed_a_value;\n }\n } else if (value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__SIMPLE_VALUE) {\n ret_error_message =\n callbacks.AppendCborSimpleValue(static_cast<uint8_t>(\n value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK));\n goto parsed_a_value;\n } else if (value_minor & WUFFS_CBOR__TOKE" +
|
||||
"N_VALUE_MINOR__TAG) {\n if (token.continued()) {\n extension_category = EXT_CAT__CBOR_TAG;\n extension_detail =\n value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK;\n continue;\n }\n ret_error_message = callbacks.AppendCborTag(\n value_minor & WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK);\n if (!ret_error_message.empty()) {\n goto done;\n }\n continue;\n }\n }\n\n fail:\n ret_error_message =\n \"wuffs_aux::CborDecoder: internal error: unexpected token\";\n goto done;\n\n parsed_a_value:\n if (!ret_error_message.empty() || (depth == 0)) {\n goto done;\n }\n }\n } while (false);\n\ndone:\n DecodeCborResult result(\n std::move(ret_error_message),\n wuffs_base__u64__sat_add(io_buf->meta.pos, cursor_index));\n callbacks.Done(result, input, *io_buf);\n return result;\n}\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n " +
|
||||
"// defined(WUFFS_CONFIG__MODULE__AUX__CBOR)\n" +
|
||||
""
|
||||
|
||||
const AuxCborHh = "" +
|
||||
"// ---------------- Auxiliary - CBOR\n\nnamespace wuffs_aux {\n\nstruct DecodeCborResult {\n DecodeCborResult(std::string&& error_message0, uint64_t cursor_position0);\n\n std::string error_message;\n uint64_t cursor_position;\n};\n\nclass DecodeCborCallbacks {\n public:\n virtual ~DecodeCborCallbacks();\n\n // AppendXxx are called for leaf nodes: literals, numbers, strings, etc.\n\n virtual std::string AppendNull() = 0;\n virtual std::string AppendUndefined() = 0;\n virtual std::string AppendBool(bool val) = 0;\n virtual std::string AppendF64(double val) = 0;\n virtual std::string AppendI64(int64_t val) = 0;\n virtual std::string AppendU64(uint64_t val) = 0;\n virtual std::string AppendByteString(std::string&& val) = 0;\n virtual std::string AppendTextString(std::string&& val) = 0;\n virtual std::string AppendMinus1MinusX(uint64_t val) = 0;\n virtual std::string AppendCborSimpleValue(uint8_t val) = 0;\n virtual std::string AppendCborTag(uint64_t val) = 0;\n\n // Push and Pop are called for container nodes: CBOR arrays (" +
|
||||
"lists) and CBOR\n // maps (dictionaries).\n //\n // The flags bits combine exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_DICT\n // and exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT\n\n virtual std::string Push(uint32_t flags) = 0;\n virtual std::string Pop(uint32_t flags) = 0;\n\n // Done is always the last Callback method called by DecodeCbor, whether or\n // not parsing the input as CBOR encountered an error. Even when successful,\n // trailing data may remain in input and buffer.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as DecodeCbor may then de-allocate the backing array.\n //\n // The default Done implementation is a no-op.\n virtual void //\n Done(DecodeCborResult& result, sync_io::Input& input, IOBuffer& buffer);\n}" +
|
||||
";\n\n// DecodeCbor calls callbacks based on the CBOR-formatted data in input.\n//\n// On success, the returned error_message is empty and cursor_position counts\n// the number of bytes consumed. On failure, error_message is non-empty and\n// cursor_position is the location of the error. That error may be a content\n// error (invalid CBOR) or an input error (e.g. network failure).\nDecodeCborResult //\nDecodeCbor(DecodeCborCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32());\n\n} // namespace wuffs_aux\n" +
|
||||
""
|
||||
|
||||
const AuxImageCc = "" +
|
||||
"// ---------------- Auxiliary - Image\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__IMAGE)\n\n#include <utility>\n\nnamespace wuffs_aux {\n\nDecodeImageResult::DecodeImageResult(MemOwner&& pixbuf_mem_owner0,\n wuffs_base__pixel_buffer pixbuf0,\n std::string&& error_message0)\n : pixbuf_mem_owner(std::move(pixbuf_mem_owner0)),\n pixbuf(pixbuf0),\n error_message(std::move(error_message0)) {}\n\nDecodeImageResult::DecodeImageResult(std::string&& error_message0)\n : pixbuf_mem_owner(nullptr, &free),\n pixbuf(wuffs_base__null_pixel_buffer()),\n error_message(std::move(error_message0)) {}\n\nDecodeImageCallbacks::~DecodeImageCallbacks() {}\n\nDecodeImageCallbacks::AllocPixbufResult::AllocPixbufResult(\n MemOwner&& mem_owner0,\n wuffs_base__pixel_buffer pixbuf0)\n : mem_owner(std::move(mem_owner0)), pixbuf(pixbuf0), error_message(\"\") {}\n\nDecodeImageCallbacks::AllocPixbufResult::AllocPixbufResult(\n std:" +
|
||||
":string&& error_message0)\n : mem_owner(nullptr, &free),\n pixbuf(wuffs_base__null_pixel_buffer()),\n error_message(std::move(error_message0)) {}\n\nDecodeImageCallbacks::AllocWorkbufResult::AllocWorkbufResult(\n MemOwner&& mem_owner0,\n wuffs_base__slice_u8 workbuf0)\n : mem_owner(std::move(mem_owner0)), workbuf(workbuf0), error_message(\"\") {}\n\nDecodeImageCallbacks::AllocWorkbufResult::AllocWorkbufResult(\n std::string&& error_message0)\n : mem_owner(nullptr, &free),\n workbuf(wuffs_base__empty_slice_u8()),\n error_message(std::move(error_message0)) {}\n\nwuffs_base__image_decoder::unique_ptr //\nDecodeImageCallbacks::SelectDecoder(uint32_t fourcc,\n wuffs_base__slice_u8 prefix) {\n switch (fourcc) {\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BMP)\n case WUFFS_BASE__FOURCC__BMP:\n return wuffs_bmp__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE" +
|
||||
"__GIF)\n case WUFFS_BASE__FOURCC__GIF:\n return wuffs_gif__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__NIE)\n case WUFFS_BASE__FOURCC__NIE:\n return wuffs_nie__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__PNG)\n case WUFFS_BASE__FOURCC__PNG: {\n auto dec = wuffs_png__decoder::alloc_as__wuffs_base__image_decoder();\n // Favor faster decodes over rejecting invalid checksums.\n dec->set_quirk_enabled(WUFFS_BASE__QUIRK_IGNORE_CHECKSUM, true);\n return dec;\n }\n#endif\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP)\n case WUFFS_BASE__FOURCC__WBMP:\n return wuffs_wbmp__decoder::alloc_as__wuffs_base__image_decoder();\n#endif\n }\n\n return wuffs_base__image_decoder::unique_ptr(nullptr, &free);\n}\n\nwuffs_base__pixel_format //\nDecodeImageCallbacks::SelectPixfmt(\n const wuffs_base__image_config&" +
|
||||
" image_config) {\n return wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL);\n}\n\nDecodeImageCallbacks::AllocPixbufResult //\nDecodeImageCallbacks::AllocPixbuf(const wuffs_base__image_config& image_config,\n bool allow_uninitialized_memory) {\n uint32_t w = image_config.pixcfg.width();\n uint32_t h = image_config.pixcfg.height();\n if ((w == 0) || (h == 0)) {\n return AllocPixbufResult(\"\");\n }\n uint64_t len = image_config.pixcfg.pixbuf_len();\n if ((len == 0) || (SIZE_MAX < len)) {\n return AllocPixbufResult(DecodeImage_UnsupportedPixelConfiguration);\n }\n void* ptr =\n allow_uninitialized_memory ? malloc((size_t)len) : calloc((size_t)len, 1);\n if (!ptr) {\n return AllocPixbufResult(DecodeImage_OutOfMemory);\n }\n wuffs_base__pixel_buffer pixbuf;\n wuffs_base__status status = pixbuf.set_from_slice(\n &image_config.pixcfg,\n wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len));\n if (!status.is_ok()) {\n free(ptr);\n return AllocPixbu" +
|
||||
"fResult(status.message());\n }\n return AllocPixbufResult(MemOwner(ptr, &free), pixbuf);\n}\n\nDecodeImageCallbacks::AllocWorkbufResult //\nDecodeImageCallbacks::AllocWorkbuf(wuffs_base__range_ii_u64 len_range,\n bool allow_uninitialized_memory) {\n uint64_t len = len_range.max_incl;\n if (len == 0) {\n return AllocWorkbufResult(\"\");\n } else if (SIZE_MAX < len) {\n return AllocWorkbufResult(DecodeImage_OutOfMemory);\n }\n void* ptr =\n allow_uninitialized_memory ? malloc((size_t)len) : calloc((size_t)len, 1);\n if (!ptr) {\n return AllocWorkbufResult(DecodeImage_OutOfMemory);\n }\n return AllocWorkbufResult(\n MemOwner(ptr, &free),\n wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len));\n}\n\nvoid //\nDecodeImageCallbacks::Done(\n DecodeImageResult& result,\n sync_io::Input& input,\n IOBuffer& buffer,\n wuffs_base__image_decoder::unique_ptr image_decoder) {}\n\nconst char DecodeImage_BufferIsTooShort[] = //\n \"wuffs_aux::DecodeImage: buffer is too short" +
|
||||
"\";\nconst char DecodeImage_MaxInclDimensionExceeded[] = //\n \"wuffs_aux::DecodeImage: max_incl_dimension exceeded\";\nconst char DecodeImage_OutOfMemory[] = //\n \"wuffs_aux::DecodeImage: out of memory\";\nconst char DecodeImage_UnexpectedEndOfFile[] = //\n \"wuffs_aux::DecodeImage: unexpected end of file\";\nconst char DecodeImage_UnsupportedImageFormat[] = //\n \"wuffs_aux::DecodeImage: unsupported image format\";\nconst char DecodeImage_UnsupportedPixelBlend[] = //\n \"wuffs_aux::DecodeImage: unsupported pixel blend\";\nconst char DecodeImage_UnsupportedPixelConfiguration[] = //\n \"wuffs_aux::DecodeImage: unsupported pixel configuration\";\nconst char DecodeImage_UnsupportedPixelFormat[] = //\n \"wuffs_aux::DecodeImage: unsupported pixel format\";\n\n" +
|
||||
"" +
|
||||
"// --------\n\nnamespace {\n\nstd::string //\nDecodeImageAdvanceIOBuf(sync_io::Input& input,\n wuffs_base__io_buffer& io_buf,\n bool compactable,\n uint64_t min_excl_pos,\n uint64_t pos) {\n if ((pos <= min_excl_pos) || (pos < io_buf.reader_position())) {\n // Redirects must go forward.\n return DecodeImage_UnsupportedImageFormat;\n }\n while (true) {\n uint64_t relative_pos = pos - io_buf.reader_position();\n if (relative_pos <= io_buf.reader_length()) {\n io_buf.meta.ri += (size_t)relative_pos;\n break;\n } else if (io_buf.meta.closed) {\n return DecodeImage_UnexpectedEndOfFile;\n }\n io_buf.meta.ri = io_buf.meta.wi;\n if (compactable) {\n io_buf.compact();\n }\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return error_message;\n }\n }\n return \"\";\n}\n\nDecodeImageResult //\nDecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,\n " +
|
||||
" DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__io_buffer& io_buf,\n wuffs_base__pixel_blend pixel_blend,\n wuffs_base__color_u32_argb_premul background_color,\n uint32_t max_incl_dimension) {\n // Check args.\n switch (pixel_blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n break;\n default:\n return DecodeImageResult(DecodeImage_UnsupportedPixelBlend);\n }\n\n wuffs_base__image_config image_config = wuffs_base__null_image_config();\n uint64_t start_pos = io_buf.reader_position();\n bool redirected = false;\n int32_t fourcc = 0;\nredirect:\n do {\n // Determine the image format.\n if (!redirected) {\n while (true) {\n fourcc = wuffs_base__magic_number_guess_fourcc(io_buf.reader_slice());\n if (fourcc > 0) {\n break;\n } else if ((fourcc == 0) && (io_buf.reader_length() >= 64)) {\n break;\n } else if (io_buf.meta.closed ||" +
|
||||
" (io_buf.writer_length() == 0)) {\n fourcc = 0;\n break;\n }\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n } else {\n wuffs_base__io_buffer empty = wuffs_base__empty_io_buffer();\n wuffs_base__more_information minfo = wuffs_base__empty_more_information();\n wuffs_base__status tmm_status =\n image_decoder->tell_me_more(&empty, &minfo, &io_buf);\n if (tmm_status.repr != nullptr) {\n return DecodeImageResult(tmm_status.message());\n }\n if (minfo.flavor != WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n uint64_t pos = minfo.io_redirect__range().min_incl;\n std::string error_message = DecodeImageAdvanceIOBuf(\n input, io_buf, !input.BringsItsOwnIOBuffer(), start_pos, pos);\n if (!error_message.empty()) {\n return" +
|
||||
" DecodeImageResult(std::move(error_message));\n }\n fourcc = (int32_t)(minfo.io_redirect__fourcc());\n if (fourcc == 0) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n image_decoder.reset();\n }\n\n // Select the image decoder.\n image_decoder = callbacks.SelectDecoder(\n (uint32_t)fourcc,\n fourcc ? wuffs_base__empty_slice_u8() : io_buf.reader_slice());\n if (!image_decoder) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n\n // Decode the image config.\n while (true) {\n wuffs_base__status id_dic_status =\n image_decoder->decode_image_config(&image_config, &io_buf);\n if (id_dic_status.repr == nullptr) {\n break;\n } else if (id_dic_status.repr == wuffs_base__note__i_o_redirect) {\n if (redirected) {\n return DecodeImageResult(DecodeImage_UnsupportedImageFormat);\n }\n redirected = true;\n goto redirect;\n } else if (id_dic_status.repr != wuffs_bas" +
|
||||
"e__suspension__short_read) {\n return DecodeImageResult(id_dic_status.message());\n } else if (io_buf.meta.closed) {\n return DecodeImageResult(DecodeImage_UnexpectedEndOfFile);\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n }\n } while (false);\n\n // Select the pixel format.\n uint32_t w = image_config.pixcfg.width();\n uint32_t h = image_config.pixcfg.height();\n if ((w > max_incl_dimension) || (h > max_incl_dimension)) {\n return DecodeImageResult(DecodeImage_MaxInclDimensionExceeded);\n }\n wuffs_base__pixel_format pixel_format = callbacks.SelectPixfmt(image_config);\n if (pixel_format.repr != image_config.pixcfg.pixel_format().repr) {\n switch (pixel_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT" +
|
||||
"__BGRA_NONPREMUL_4X16LE:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n break;\n default:\n return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);\n }\n image_config.pixcfg.set(pixel_format.repr,\n WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h);\n }\n\n // Allocate the pixel buffer.\n bool valid_background_color =\n wuffs_base__color_u32_argb_premul__is_valid(background_color);\n DecodeImageCallbacks::AllocPixbufResult alloc_pixbuf_result =\n callbacks.AllocPixbuf(image_config, valid_background_color);\n if (!alloc_pixbuf_result.error_message.empty()) {\n return DecodeImageResult(std::move(alloc_pixbuf_result.error_message));\n }\n wuffs_base__pixel_buffer pixel_buffer = alloc_pixbuf_result.pixbuf;\n if (valid_background_color) {\n wuffs_base__status pb_scufr_status = pixel_buffer.set_color_u32_fill_rect(\n pixel_buffer.pixcfg.bounds(), b" +
|
||||
"ackground_color);\n if (pb_scufr_status.repr != nullptr) {\n return DecodeImageResult(pb_scufr_status.message());\n }\n }\n\n // Allocate the work buffer. Wuffs' decoders conventionally assume that this\n // can be uninitialized memory.\n wuffs_base__range_ii_u64 workbuf_len = image_decoder->workbuf_len();\n DecodeImageCallbacks::AllocWorkbufResult alloc_workbuf_result =\n callbacks.AllocWorkbuf(workbuf_len, true);\n if (!alloc_workbuf_result.error_message.empty()) {\n return DecodeImageResult(std::move(alloc_workbuf_result.error_message));\n } else if (alloc_workbuf_result.workbuf.len < workbuf_len.min_incl) {\n return DecodeImageResult(DecodeImage_BufferIsTooShort);\n }\n\n // Decode the frame config.\n wuffs_base__frame_config frame_config = wuffs_base__null_frame_config();\n while (true) {\n wuffs_base__status id_dfc_status =\n image_decoder->decode_frame_config(&frame_config, &io_buf);\n if (id_dfc_status.repr == nullptr) {\n break;\n } else if (id_dfc_status.repr != wuffs_b" +
|
||||
"ase__suspension__short_read) {\n return DecodeImageResult(id_dfc_status.message());\n } else if (io_buf.meta.closed) {\n return DecodeImageResult(DecodeImage_UnexpectedEndOfFile);\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n return DecodeImageResult(std::move(error_message));\n }\n }\n }\n\n // Decode the frame (the pixels).\n //\n // From here on, always returns the pixel_buffer. If we get this far, we can\n // still display a partial image, even if we encounter an error.\n std::string message(\"\");\n if ((pixel_blend == WUFFS_BASE__PIXEL_BLEND__SRC_OVER) &&\n frame_config.overwrite_instead_of_blend()) {\n pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC;\n }\n while (true) {\n wuffs_base__status id_df_status =\n image_decoder->decode_frame(&pixel_buffer, &io_buf, pixel_blend,\n alloc_workbuf_result.workbuf, nullptr);\n if (id_df_status.repr == nullptr) {\n break;\n } else if (" +
|
||||
"id_df_status.repr != wuffs_base__suspension__short_read) {\n message = id_df_status.message();\n break;\n } else if (io_buf.meta.closed) {\n message = DecodeImage_UnexpectedEndOfFile;\n break;\n } else {\n std::string error_message = input.CopyIn(&io_buf);\n if (!error_message.empty()) {\n message = std::move(error_message);\n break;\n }\n }\n }\n return DecodeImageResult(std::move(alloc_pixbuf_result.mem_owner),\n pixel_buffer, std::move(message));\n}\n\n} // namespace\n\nDecodeImageResult //\nDecodeImage(DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__pixel_blend pixel_blend,\n wuffs_base__color_u32_argb_premul background_color,\n uint32_t max_incl_dimension) {\n wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();\n wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();\n std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);\n if (!io_buf) {\n fallba" +
|
||||
"ck_io_array = std::unique_ptr<uint8_t[]>(new uint8_t[32768]);\n fallback_io_buf =\n wuffs_base__ptr_u8__writer(fallback_io_array.get(), 32768);\n io_buf = &fallback_io_buf;\n }\n\n wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);\n DecodeImageResult result =\n DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,\n background_color, max_incl_dimension);\n callbacks.Done(result, input, *io_buf, std::move(image_decoder));\n return result;\n}\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__AUX__IMAGE)\n" +
|
||||
""
|
||||
|
||||
const AuxImageHh = "" +
|
||||
"// ---------------- Auxiliary - Image\n\nnamespace wuffs_aux {\n\nstruct DecodeImageResult {\n DecodeImageResult(MemOwner&& pixbuf_mem_owner0,\n wuffs_base__pixel_buffer pixbuf0,\n std::string&& error_message0);\n DecodeImageResult(std::string&& error_message0);\n\n MemOwner pixbuf_mem_owner;\n wuffs_base__pixel_buffer pixbuf;\n std::string error_message;\n};\n\n// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always\n// called in this order:\n// 1. SelectDecoder\n// 2. SelectPixfmt\n// 3. AllocPixbuf\n// 4. AllocWorkbuf\n// 5. Done\n//\n// It may return early - the third callback might not be invoked if the second\n// one fails - but the final callback (Done) is always invoked.\nclass DecodeImageCallbacks {\n public:\n // AllocPixbufResult holds a memory allocation (the result of malloc or new,\n // a statically allocated pointer, etc), or an error message. The memory is\n // de-allocated when mem_owner goes out of scope and is destroyed.\n struct AllocPixbufResu" +
|
||||
"lt {\n AllocPixbufResult(MemOwner&& mem_owner0, wuffs_base__pixel_buffer pixbuf0);\n AllocPixbufResult(std::string&& error_message0);\n\n MemOwner mem_owner;\n wuffs_base__pixel_buffer pixbuf;\n std::string error_message;\n };\n\n // AllocWorkbufResult holds a memory allocation (the result of malloc or new,\n // a statically allocated pointer, etc), or an error message. The memory is\n // de-allocated when mem_owner goes out of scope and is destroyed.\n struct AllocWorkbufResult {\n AllocWorkbufResult(MemOwner&& mem_owner0, wuffs_base__slice_u8 workbuf0);\n AllocWorkbufResult(std::string&& error_message0);\n\n MemOwner mem_owner;\n wuffs_base__slice_u8 workbuf;\n std::string error_message;\n };\n\n virtual ~DecodeImageCallbacks();\n\n // SelectDecoder returns the image decoder for the input data's file format.\n // Returning a nullptr means failure (DecodeImage_UnsupportedImageFormat).\n //\n // Common formats will have a FourCC value in the range [1 ..= 0x7FFF_FFFF],\n // such as WUFFS_BASE__F" +
|
||||
"OURCC__JPEG. A zero FourCC value means that the\n // caller is responsible for examining the opening bytes (a prefix) of the\n // input data. SelectDecoder implementations should not modify those bytes.\n //\n // SelectDecoder might be called more than once, since some image file\n // formats can wrap others. For example, a nominal BMP file can actually\n // contain a JPEG or a PNG.\n //\n // The default SelectDecoder accepts the FOURCC codes listed below. For\n // modular builds (i.e. when #define'ing WUFFS_CONFIG__MODULES), acceptance\n // of the ETC file format is optional (for each value of ETC) and depends on\n // the corresponding module to be enabled at compile time (i.e. #define'ing\n // WUFFS_CONFIG__MODULE__ETC).\n // - WUFFS_BASE__FOURCC__BMP\n // - WUFFS_BASE__FOURCC__GIF\n // - WUFFS_BASE__FOURCC__NIE\n // - WUFFS_BASE__FOURCC__PNG\n // - WUFFS_BASE__FOURCC__WBMP\n virtual wuffs_base__image_decoder::unique_ptr //\n SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);\n\n // SelectPix" +
|
||||
"fmt returns the destination pixel format for AllocPixbuf. It\n // should return wuffs_base__make_pixel_format(etc) called with one of:\n // - WUFFS_BASE__PIXEL_FORMAT__BGR_565\n // - WUFFS_BASE__PIXEL_FORMAT__BGR\n // - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL\n // - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE\n // - WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL\n // - WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL\n // - WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL\n // or return image_config.pixcfg.pixel_format(). The latter means to use the\n // image file's natural pixel format. For example, GIF images' natural pixel\n // format is an indexed one.\n //\n // Returning otherwise means failure (DecodeImage_UnsupportedPixelFormat).\n //\n // The default SelectPixfmt implementation returns\n // wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) which\n // is 4 bytes per pixel (8 bits per channel × 4 channels).\n virtual wuffs_base__pixel_format //\n SelectPixfmt(const wuffs_base__image_config& image_" +
|
||||
"config);\n\n // AllocPixbuf allocates the pixel buffer.\n //\n // allow_uninitialized_memory will be true if a valid background_color was\n // passed to DecodeImage, since the pixel buffer's contents will be\n // overwritten with that color after AllocPixbuf returns.\n //\n // The default AllocPixbuf implementation allocates either uninitialized or\n // zeroed memory. Zeroed memory typically corresponds to filling with opaque\n // black or transparent black, depending on the pixel format.\n virtual AllocPixbufResult //\n AllocPixbuf(const wuffs_base__image_config& image_config,\n bool allow_uninitialized_memory);\n\n // AllocWorkbuf allocates the work buffer. The allocated buffer's length\n // should be at least len_range.min_incl, but larger allocations (up to\n // len_range.max_incl) may have better performance (by using more memory).\n //\n // The default AllocWorkbuf implementation allocates len_range.max_incl bytes\n // of either uninitialized or zeroed memory.\n virtual AllocWorkbufResult //" +
|
||||
"\n AllocWorkbuf(wuffs_base__range_ii_u64 len_range,\n bool allow_uninitialized_memory);\n\n // Done is always the last Callback method called by DecodeImage, whether or\n // not parsing the input encountered an error. Even when successful, trailing\n // data may remain in input and buffer.\n //\n // The image_decoder is the one returned by SelectDecoder (if SelectDecoder\n // was successful), or a no-op unique_ptr otherwise. Like any unique_ptr,\n // ownership moves to the Done implementation.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as DecodeImage may then de-allocate the backing array.\n //\n // The default Done implementation is a no-op, other than running the\n // image_decoder unique_ptr destructor.\n virtual void //\n Done(DecodeImageResult& result,\n sync_io::Input& input,\n IOBuffer& buffer,\n wuffs_base__image_decoder::unique_ptr image_decoder);\n};\n\nextern const char DecodeImage_BufferIsTooShort[];\nextern const char DecodeImag" +
|
||||
"e_MaxInclDimensionExceeded[];\nextern const char DecodeImage_OutOfMemory[];\nextern const char DecodeImage_UnexpectedEndOfFile[];\nextern const char DecodeImage_UnsupportedImageFormat[];\nextern const char DecodeImage_UnsupportedPixelBlend[];\nextern const char DecodeImage_UnsupportedPixelConfiguration[];\nextern const char DecodeImage_UnsupportedPixelFormat[];\n\n// DecodeImage decodes the image data in input. A variety of image file formats\n// can be decoded, depending on what callbacks.SelectDecoder returns.\n//\n// For animated formats, only the first frame is returned, since the API is\n// simpler for synchronous I/O and having DecodeImage only return when\n// completely done, but rendering animation often involves handling other\n// events in between animation frames. To decode multiple frames of animated\n// images, or for asynchronous I/O (e.g. when decoding an image streamed over\n// the network), use Wuffs' lower level C API instead of its higher level,\n// simplified C++ API (the wuffs_aux API).\n//\n// The DecodeIm" +
|
||||
"ageResult's fields depend on whether decoding succeeded:\n// - On total success, the error_message is empty and pixbuf.pixcfg.is_valid()\n// is true.\n// - On partial success (e.g. the input file was truncated but we are still\n// able to decode some of the pixels), error_message is non-empty but\n// pixbuf.pixcfg.is_valid() is still true. It is up to the caller whether to\n// accept or reject partial success.\n// - On failure, the error_message is non_empty and pixbuf.pixcfg.is_valid()\n// is false.\n//\n// The callbacks allocate the pixel buffer memory and work buffer memory. On\n// success, pixel buffer memory ownership is passed to the DecodeImage caller\n// as the returned pixbuf_mem_owner. Regardless of success or failure, the work\n// buffer memory is deleted.\n//\n// The pixel_blend (one of the constants listed below) determines how to\n// composite the decoded image over the pixel buffer's original pixels (as\n// returned by callbacks.AllocPixbuf):\n// - WUFFS_BASE__PIXEL_BLEND__SRC\n// - WUFFS_BASE" +
|
||||
"__PIXEL_BLEND__SRC_OVER\n//\n// The background_color is used to fill the pixel buffer after\n// callbacks.AllocPixbuf returns, if it is valid in the\n// wuffs_base__color_u32_argb_premul__is_valid sense. The default value,\n// 0x0000_0001, is not valid since its Blue channel value (0x01) is greater\n// than its Alpha channel value (0x00). A valid background_color will typically\n// be overwritten when pixel_blend is WUFFS_BASE__PIXEL_BLEND__SRC, but might\n// still be visible on partial (not total) success or when pixel_blend is\n// WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque.\n//\n// Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's\n// width or height is greater than max_incl_dimension.\nDecodeImageResult //\nDecodeImage(DecodeImageCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,\n wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.\n uint32_" +
|
||||
"t max_incl_dimension = 1048575); // 0x000F_FFFF\n\n} // namespace wuffs_aux\n" +
|
||||
""
|
||||
|
||||
const AuxJsonCc = "" +
|
||||
"// ---------------- Auxiliary - JSON\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__AUX__JSON)\n\n#include <utility>\n\nnamespace wuffs_aux {\n\nDecodeJsonResult::DecodeJsonResult(std::string&& error_message0,\n uint64_t cursor_position0)\n : error_message(std::move(error_message0)),\n cursor_position(cursor_position0) {}\n\nDecodeJsonCallbacks::~DecodeJsonCallbacks() {}\n\nvoid //\nDecodeJsonCallbacks::Done(DecodeJsonResult& result,\n sync_io::Input& input,\n IOBuffer& buffer) {}\n\nconst char DecodeJson_BadJsonPointer[] =\n \"wuffs_aux::DecodeJson: bad JSON Pointer\";\nconst char DecodeJson_NoMatch[] = \"wuffs_aux::DecodeJson: no match\";\n\n" +
|
||||
"" +
|
||||
"// --------\n\n#define WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN \\\n while (tok_buf.meta.ri >= tok_buf.meta.wi) { \\\n if (tok_status.repr == nullptr) { \\\n goto done; \\\n } else if (tok_status.repr == wuffs_base__suspension__short_write) { \\\n tok_buf.compact(); \\\n } else if (tok_status.repr == wuffs_base__suspension__short_read) { \\\n if (!io_error_message.empty()) { \\\n ret_error_message = std::move(io_error_message); \\\n goto done; \\\n } else if (cursor_index != io_buf->meta.ri) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: bad cursor_index\"; " +
|
||||
" \\\n goto done; \\\n } else if (io_buf->meta.closed) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: io_buf is closed\"; \\\n goto done; \\\n } \\\n io_buf->compact(); \\\n if (io_buf->meta.wi >= io_buf->data.len) { \\\n ret_error_message = \\\n \"wuffs_aux::DecodeJson: internal error: io_buf is full\"; \\\n goto done; \\\n } \\\n cursor_index = io_buf->meta.ri; \\\n i" +
|
||||
"o_error_message = input.CopyIn(io_buf); \\\n } else { \\\n ret_error_message = tok_status.message(); \\\n goto done; \\\n } \\\n tok_status = \\\n dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \\\n } \\\n wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \\\n uint64_t token_len = token.length(); \\\n if ((io_buf->meta.ri < cursor_index) || \\\n ((io_buf->meta.ri - cursor_index) < token_len)) { \\\n ret_error_message = \\\n \"wuffs_au" +
|
||||
"x::DecodeJson: internal error: bad token indexes\"; \\\n goto done; \\\n } \\\n uint8_t* token_ptr = io_buf->data.ptr + cursor_index; \\\n (void)(token_ptr); \\\n cursor_index += static_cast<size_t>(token_len)\n\n" +
|
||||
"" +
|
||||
"// --------\n\nnamespace {\n\n// DecodeJson_SplitJsonPointer returns (\"bar\", 8) for (\"/foo/bar/b~1z/qux\", 5,\n// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax.\n//\n// The string returned is unescaped. If calling it again, this time with i=8,\n// the \"b~1z\" substring would be returned as \"b/z\".\nstd::pair<std::string, size_t> //\nDecodeJson_SplitJsonPointer(std::string& s,\n size_t i,\n bool allow_tilde_n_tilde_r_tilde_t) {\n std::string fragment;\n while (i < s.size()) {\n char c = s[i];\n if (c == '/') {\n break;\n } else if (c != '~') {\n fragment.push_back(c);\n i++;\n continue;\n }\n i++;\n if (i >= s.size()) {\n return std::make_pair(std::string(), 0);\n }\n c = s[i];\n if (c == '0') {\n fragment.push_back('~');\n i++;\n continue;\n } else if (c == '1') {\n fragment.push_back('/');\n i++;\n continue;\n } else if (allow_tilde_n_tilde_r_tilde_t) {\n if (c == 'n') {\n " +
|
||||
"fragment.push_back('\\n');\n i++;\n continue;\n } else if (c == 'r') {\n fragment.push_back('\\r');\n i++;\n continue;\n } else if (c == 't') {\n fragment.push_back('\\t');\n i++;\n continue;\n }\n }\n return std::make_pair(std::string(), 0);\n }\n return std::make_pair(std::move(fragment), i);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstd::string //\nDecodeJson_WalkJsonPointerFragment(wuffs_base__token_buffer& tok_buf,\n wuffs_base__status& tok_status,\n wuffs_json__decoder::unique_ptr& dec,\n wuffs_base__io_buffer* io_buf,\n std::string& io_error_message,\n size_t& cursor_index,\n sync_io::Input& input,\n std::string& json_pointer_fragment) {\n std::string ret_error_message;\n while (true) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (vbc == WUFFS_BASE__TOKEN__VBC__FILLER) {\n continue;\n } else if ((vbc != WUFFS_BASE__TOKEN__VBC__STRUCTURE) ||\n !(vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH)) {\n return DecodeJson_NoMatch;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__ST" +
|
||||
"RUCTURE__TO_LIST) {\n goto do_list;\n }\n goto do_dict;\n }\n\ndo_dict:\n // Alternate between these two things:\n // 1. Decode the next dict key (a string). If it matches the fragment, we're\n // done (success). If we've reached the dict's end (VBD__STRUCTURE__POP)\n // so that there was no next dict key, we're done (failure).\n // 2. Otherwise, skip the next dict value.\n while (true) {\n for (std::string str; true;) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n switch (vbc) {\n case WUFFS_BASE__TOKEN__VBC__FILLER:\n continue;\n\n case WUFFS_BASE__TOKEN__VBC__STRUCTURE:\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n goto fail;\n }\n return DecodeJson_NoMatch;\n\n case WUFFS_BASE__TOKEN__VBC__STRING: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {\n // No-op.\n } els" +
|
||||
"e if (vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(token_ptr));\n str.append(ptr, static_cast<size_t>(token_len));\n } else {\n goto fail;\n }\n break;\n }\n\n case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {\n uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];\n size_t n = wuffs_base__utf_8__encode(\n wuffs_base__make_slice_u8(\n &u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),\n static_cast<uint32_t>(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(&u[0]));\n str.append(ptr, n);\n break;\n }\n\n default:\n goto fail;\n }\n\n if (token.continued()) {\n continue;\n }\n if (str == json_pointer_fragment) {\n " +
|
||||
" return \"\";\n }\n goto skip_the_next_dict_value;\n }\n\n skip_the_next_dict_value:\n for (uint32_t skip_depth = 0; true;) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (token.continued() || (vbc == WUFFS_BASE__TOKEN__VBC__FILLER)) {\n continue;\n } else if (vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n skip_depth++;\n continue;\n }\n skip_depth--;\n }\n\n if (skip_depth == 0) {\n break;\n }\n } // skip_the_next_dict_value\n } // do_dict\n\ndo_list:\n do {\n wuffs_base__result_u64 result_u64 = wuffs_base__parse_number_u64(\n wuffs_base__make_slice_u8(\n static_cast<uint8_t*>(static_cast<void*>(\n const_cast<char*>(json_pointer_fragment.data()))),\n json_pointer_fragment.size()),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTI" +
|
||||
"ONS);\n if (!result_u64.status.is_ok()) {\n return DecodeJson_NoMatch;\n }\n uint64_t remaining = result_u64.value;\n if (remaining == 0) {\n goto check_that_a_value_follows;\n }\n for (uint32_t skip_depth = 0; true;) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (token.continued() || (vbc == WUFFS_BASE__TOKEN__VBC__FILLER)) {\n continue;\n } else if (vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n skip_depth++;\n continue;\n }\n if (skip_depth == 0) {\n return DecodeJson_NoMatch;\n }\n skip_depth--;\n }\n\n if (skip_depth > 0) {\n continue;\n }\n remaining--;\n if (remaining == 0) {\n goto check_that_a_value_follows;\n }\n }\n } while (false); // do_list\n\ncheck_that_a_value_follows:\n while (true) {\n WUFFS_AUX__DECODE_JSON" +
|
||||
"__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n if (vbc == WUFFS_BASE__TOKEN__VBC__FILLER) {\n continue;\n }\n\n // Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so that\n // we're only peeking at the next token.\n tok_buf.meta.ri--;\n cursor_index -= static_cast<size_t>(token_len);\n\n if ((vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) &&\n (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP)) {\n return DecodeJson_NoMatch;\n }\n return \"\";\n } // check_that_a_value_follows\n\nfail:\n return \"wuffs_aux::DecodeJson: internal error: unexpected token\";\ndone:\n return ret_error_message;\n}\n\n} // namespace\n\n" +
|
||||
"" +
|
||||
"// --------\n\nDecodeJsonResult //\nDecodeJson(DecodeJsonCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks,\n std::string json_pointer) {\n // Prepare the wuffs_base__io_buffer and the resultant error_message.\n wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();\n wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();\n std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);\n if (!io_buf) {\n fallback_io_array = std::unique_ptr<uint8_t[]>(new uint8_t[4096]);\n fallback_io_buf = wuffs_base__ptr_u8__writer(fallback_io_array.get(), 4096);\n io_buf = &fallback_io_buf;\n }\n // cursor_index is discussed at\n // https://nigeltao.github.io/blog/2020/jsonptr.html#the-cursor-index\n size_t cursor_index = 0;\n std::string ret_error_message;\n std::string io_error_message;\n\n do {\n // Prepare the low-level JSON decoder.\n wuffs_json__decoder::unique_ptr dec = wuffs_json__decoder::alloc();\n if (!dec) {\n ret_error_message = " +
|
||||
"\"wuffs_aux::DecodeJson: out of memory\";\n goto done;\n } else if (WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {\n ret_error_message =\n \"wuffs_aux::DecodeJson: internal error: bad WORKBUF_LEN\";\n goto done;\n }\n bool allow_tilde_n_tilde_r_tilde_t = false;\n for (size_t i = 0; i < quirks.len; i++) {\n dec->set_quirk_enabled(quirks.ptr[i], true);\n if (quirks.ptr[i] ==\n WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {\n allow_tilde_n_tilde_r_tilde_t = true;\n }\n }\n\n // Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.\n wuffs_base__token tok_array[256];\n wuffs_base__token_buffer tok_buf =\n wuffs_base__slice_token__writer(wuffs_base__make_slice_token(\n &tok_array[0], (sizeof(tok_array) / sizeof(tok_array[0]))));\n wuffs_base__status tok_status =\n dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8());\n\n // Prepare other state.\n uint32_t depth = 0;\n std::string str;" +
|
||||
"\n\n // Walk the (optional) JSON Pointer.\n for (size_t i = 0; i < json_pointer.size();) {\n if (json_pointer[i] != '/') {\n ret_error_message = DecodeJson_BadJsonPointer;\n goto done;\n }\n std::pair<std::string, size_t> split = DecodeJson_SplitJsonPointer(\n json_pointer, i + 1, allow_tilde_n_tilde_r_tilde_t);\n i = split.second;\n if (i == 0) {\n ret_error_message = DecodeJson_BadJsonPointer;\n goto done;\n }\n ret_error_message = DecodeJson_WalkJsonPointerFragment(\n tok_buf, tok_status, dec, io_buf, io_error_message, cursor_index,\n input, split.first);\n if (!ret_error_message.empty()) {\n goto done;\n }\n }\n\n // Loop, doing these two things:\n // 1. Get the next token.\n // 2. Process that token.\n while (true) {\n WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN;\n\n int64_t vbc = token.value_base_category();\n uint64_t vbd = token.value_base_detail();\n switch (vbc) {\n case WUFFS_" +
|
||||
"BASE__TOKEN__VBC__FILLER:\n continue;\n\n case WUFFS_BASE__TOKEN__VBC__STRUCTURE: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH) {\n ret_error_message = callbacks.Push(static_cast<uint32_t>(vbd));\n if (!ret_error_message.empty()) {\n goto done;\n }\n depth++;\n continue;\n }\n ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));\n depth--;\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__STRING: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) {\n // No-op.\n } else if (vbd &\n WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(token_ptr));\n str.append(ptr, static_cast<size_t>(token_len));\n } else {\n goto fail;\n }\n " +
|
||||
"if (token.continued()) {\n continue;\n }\n ret_error_message = callbacks.AppendTextString(std::move(str));\n str.clear();\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__UNICODE_CODE_POINT: {\n uint8_t u[WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL];\n size_t n = wuffs_base__utf_8__encode(\n wuffs_base__make_slice_u8(\n &u[0], WUFFS_BASE__UTF_8__BYTE_LENGTH__MAX_INCL),\n static_cast<uint32_t>(vbd));\n const char* ptr = // Convert from (uint8_t*).\n static_cast<const char*>(static_cast<void*>(&u[0]));\n str.append(ptr, n);\n if (token.continued()) {\n continue;\n }\n goto fail;\n }\n\n case WUFFS_BASE__TOKEN__VBC__LITERAL: {\n ret_error_message =\n (vbd & WUFFS_BASE__TOKEN__VBD__LITERAL__NULL)\n ? callbacks.AppendNull()\n : callbacks.AppendBool(vbd &\n " +
|
||||
" WUFFS_BASE__TOKEN__VBD__LITERAL__TRUE);\n goto parsed_a_value;\n }\n\n case WUFFS_BASE__TOKEN__VBC__NUMBER: {\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__FORMAT_TEXT) {\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_INTEGER_SIGNED) {\n wuffs_base__result_i64 r = wuffs_base__parse_number_i64(\n wuffs_base__make_slice_u8(token_ptr,\n static_cast<size_t>(token_len)),\n WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (r.status.is_ok()) {\n ret_error_message = callbacks.AppendI64(r.value);\n goto parsed_a_value;\n }\n }\n if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_FLOATING_POINT) {\n wuffs_base__result_f64 r = wuffs_base__parse_number_f64(\n wuffs_base__make_slice_u8(token_ptr,\n static_cast<size_t>(token_len)),\n " +
|
||||
" WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS);\n if (r.status.is_ok()) {\n ret_error_message = callbacks.AppendF64(r.value);\n goto parsed_a_value;\n }\n }\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_INF) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0xFFF0000000000000ul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_INF) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0x7FF0000000000000ul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_NEG_NAN) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0xF" +
|
||||
"FFFFFFFFFFFFFFFul));\n goto parsed_a_value;\n } else if (vbd & WUFFS_BASE__TOKEN__VBD__NUMBER__CONTENT_POS_NAN) {\n ret_error_message = callbacks.AppendF64(\n wuffs_base__ieee_754_bit_representation__from_u64_to_f64(\n 0x7FFFFFFFFFFFFFFFul));\n goto parsed_a_value;\n }\n goto fail;\n }\n }\n\n fail:\n ret_error_message =\n \"wuffs_aux::DecodeJson: internal error: unexpected token\";\n goto done;\n\n parsed_a_value:\n // If an error was encountered, we are done. Otherwise, (depth == 0)\n // after parsing a value is equivalent to having decoded the entire JSON\n // value (for an empty json_pointer query) or having decoded the\n // pointed-to JSON value (for a non-empty json_pointer query). In the\n // latter case, we are also done.\n //\n // However, if quirks like WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER or\n // WUFFS_JSON__QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF are pass" +
|
||||
"ed, decoding\n // the entire JSON value should also consume any trailing filler, in case\n // the DecodeJson caller wants to subsequently check that the input is\n // completely exhausted (and otherwise raise \"valid JSON followed by\n // further (unexpected) data\"). We aren't done yet. Instead, keep the\n // loop running until WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN's\n // decode_tokens returns an ok status.\n if (!ret_error_message.empty() ||\n ((depth == 0) && !json_pointer.empty())) {\n goto done;\n }\n }\n } while (false);\n\ndone:\n DecodeJsonResult result(\n std::move(ret_error_message),\n wuffs_base__u64__sat_add(io_buf->meta.pos, cursor_index));\n callbacks.Done(result, input, *io_buf);\n return result;\n}\n\n#undef WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN\n\n} // namespace wuffs_aux\n\n#endif // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__AUX__JSON)\n" +
|
||||
""
|
||||
|
||||
const AuxJsonHh = "" +
|
||||
"// ---------------- Auxiliary - JSON\n\nnamespace wuffs_aux {\n\nstruct DecodeJsonResult {\n DecodeJsonResult(std::string&& error_message0, uint64_t cursor_position0);\n\n std::string error_message;\n uint64_t cursor_position;\n};\n\nclass DecodeJsonCallbacks {\n public:\n virtual ~DecodeJsonCallbacks();\n\n // AppendXxx are called for leaf nodes: literals, numbers and strings. For\n // strings, the Callbacks implementation is responsible for tracking map keys\n // versus other values.\n\n virtual std::string AppendNull() = 0;\n virtual std::string AppendBool(bool val) = 0;\n virtual std::string AppendF64(double val) = 0;\n virtual std::string AppendI64(int64_t val) = 0;\n virtual std::string AppendTextString(std::string&& val) = 0;\n\n // Push and Pop are called for container nodes: JSON arrays (lists) and JSON\n // objects (dictionaries).\n //\n // The flags bits combine exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST\n // - WUFFS_BASE__TOKEN__V" +
|
||||
"BD__STRUCTURE__FROM_DICT\n // and exactly one of:\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_NONE\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST\n // - WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_DICT\n\n virtual std::string Push(uint32_t flags) = 0;\n virtual std::string Pop(uint32_t flags) = 0;\n\n // Done is always the last Callback method called by DecodeJson, whether or\n // not parsing the input as JSON encountered an error. Even when successful,\n // trailing data may remain in input and buffer. See \"Unintuitive JSON\n // Parsing\" (https://nullprogram.com/blog/2019/12/28/) which discusses JSON\n // parsing and when it stops.\n //\n // Do not keep a reference to buffer or buffer.data.ptr after Done returns,\n // as DecodeJson may then de-allocate the backing array.\n //\n // The default Done implementation is a no-op.\n virtual void //\n Done(DecodeJsonResult& result, sync_io::Input& input, IOBuffer& buffer);\n};\n\nextern const char DecodeJson_BadJsonPointer[];\nextern const char DecodeJson_NoMatch[];\n\n//" +
|
||||
" DecodeJson calls callbacks based on the JSON-formatted data in input.\n//\n// On success, the returned error_message is empty and cursor_position counts\n// the number of bytes consumed. On failure, error_message is non-empty and\n// cursor_position is the location of the error. That error may be a content\n// error (invalid JSON) or an input error (e.g. network failure).\n//\n// json_pointer is a query in the JSON Pointer (RFC 6901) syntax. The callbacks\n// run for the input's sub-node that matches the query. DecodeJson_NoMatch is\n// returned if no matching sub-node was found. The empty query matches the\n// input's root node, consistent with JSON Pointer semantics.\n//\n// The JSON Pointer implementation is greedy: duplicate keys are not rejected\n// but only the first match for each '/'-separated fragment is followed.\nDecodeJsonResult //\nDecodeJson(DecodeJsonCallbacks& callbacks,\n sync_io::Input& input,\n wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32(),\n std::string json_po" +
|
||||
"inter = std::string());\n\n} // namespace wuffs_aux\n" +
|
||||
""
|
||||
|
||||
var AuxNonBaseCcFiles = []string{
|
||||
AuxCborCc,
|
||||
AuxImageCc,
|
||||
AuxJsonCc,
|
||||
}
|
||||
|
||||
var AuxNonBaseHhFiles = []string{
|
||||
AuxCborHh,
|
||||
AuxImageHh,
|
||||
AuxJsonHh,
|
||||
}
|
||||
|
||||
const BaseCopyright = "" +
|
||||
"// Copyright 2017 The Wuffs Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n" +
|
||||
""
|
||||
@@ -1,193 +0,0 @@
|
||||
// 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.
|
||||
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
// gen.go converts "../base/*" to "data.go".
|
||||
//
|
||||
// Invoke it via "go generate".
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"go/format"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const columns = 1024
|
||||
|
||||
func main() {
|
||||
if err := main1(); err != nil {
|
||||
os.Stderr.WriteString(err.Error() + "\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func main1() error {
|
||||
out := &bytes.Buffer{}
|
||||
out.WriteString("// Code generated by running \"go generate\". DO NOT EDIT.\n")
|
||||
out.WriteString("\n")
|
||||
out.WriteString("// Copyright 2017 The Wuffs Authors.\n")
|
||||
out.WriteString("//\n")
|
||||
out.WriteString("// Licensed under the Apache License, Version 2.0 (the \"License\");\n")
|
||||
out.WriteString("// you may not use this file except in compliance with the License.\n")
|
||||
out.WriteString("// You may obtain a copy of the License at\n")
|
||||
out.WriteString("//\n")
|
||||
out.WriteString("// https://www.apache.org/licenses/LICENSE-2.0\n")
|
||||
out.WriteString("//\n")
|
||||
out.WriteString("// Unless required by applicable law or agreed to in writing, software\n")
|
||||
out.WriteString("// distributed under the License is distributed on an \"AS IS\" BASIS,\n")
|
||||
out.WriteString("// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n")
|
||||
out.WriteString("// See the License for the specific language governing permissions and\n")
|
||||
out.WriteString("// limitations under the License.\n")
|
||||
out.WriteString("\n")
|
||||
out.WriteString("package data\n")
|
||||
out.WriteString("\n")
|
||||
|
||||
if err := genData(out); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
formatted, err := format.Source(out.Bytes())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return ioutil.WriteFile("data.go", formatted, 0644)
|
||||
}
|
||||
|
||||
func genData(out *bytes.Buffer) error {
|
||||
files := []struct {
|
||||
filename, varname string
|
||||
}{
|
||||
{"../base/all-impl.c", "BaseAllImplC"},
|
||||
|
||||
{"../base/fundamental-private.h", "BaseFundamentalPrivateH"},
|
||||
{"../base/fundamental-public.h", "BaseFundamentalPublicH"},
|
||||
{"../base/memory-private.h", "BaseMemoryPrivateH"},
|
||||
{"../base/memory-public.h", "BaseMemoryPublicH"},
|
||||
{"../base/image-private.h", "BaseImagePrivateH"},
|
||||
{"../base/image-public.h", "BaseImagePublicH"},
|
||||
{"../base/io-private.h", "BaseIOPrivateH"},
|
||||
{"../base/io-public.h", "BaseIOPublicH"},
|
||||
{"../base/range-private.h", "BaseRangePrivateH"},
|
||||
{"../base/range-public.h", "BaseRangePublicH"},
|
||||
{"../base/strconv-private.h", "BaseStrConvPrivateH"},
|
||||
{"../base/strconv-public.h", "BaseStrConvPublicH"},
|
||||
{"../base/token-private.h", "BaseTokenPrivateH"},
|
||||
{"../base/token-public.h", "BaseTokenPublicH"},
|
||||
|
||||
{"../base/floatconv-submodule-code.c", "BaseFloatConvSubmoduleCodeC"},
|
||||
{"../base/floatconv-submodule-data.c", "BaseFloatConvSubmoduleDataC"},
|
||||
{"../base/intconv-submodule.c", "BaseIntConvSubmoduleC"},
|
||||
{"../base/magic-submodule.c", "BaseMagicSubmoduleC"},
|
||||
{"../base/pixconv-submodule.c", "BasePixConvSubmoduleC"},
|
||||
{"../base/utf8-submodule.c", "BaseUTF8SubmoduleC"},
|
||||
|
||||
{"../auxiliary/base.cc", "AuxBaseCc"},
|
||||
{"../auxiliary/base.hh", "AuxBaseHh"},
|
||||
{"../auxiliary/cbor.cc", "AuxCborCc"},
|
||||
{"../auxiliary/cbor.hh", "AuxCborHh"},
|
||||
{"../auxiliary/image.cc", "AuxImageCc"},
|
||||
{"../auxiliary/image.hh", "AuxImageHh"},
|
||||
{"../auxiliary/json.cc", "AuxJsonCc"},
|
||||
{"../auxiliary/json.hh", "AuxJsonHh"},
|
||||
}
|
||||
|
||||
prefixAfterEditing := []byte("// After editing this file,")
|
||||
prefixCopyright := []byte("// Copyright ")
|
||||
copyright := []byte(nil)
|
||||
|
||||
for _, f := range files {
|
||||
in, err := ioutil.ReadFile(f.filename)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if !bytes.HasPrefix(in, prefixAfterEditing) {
|
||||
return fmt.Errorf("%s's contents do not start with %q", f.filename, prefixAfterEditing)
|
||||
}
|
||||
if i := bytes.Index(in, []byte("\n\n")); i >= 0 {
|
||||
in = in[i+2:]
|
||||
}
|
||||
|
||||
if !bytes.HasPrefix(in, prefixCopyright) {
|
||||
return fmt.Errorf("%s's contents do not start with %q", f.filename, prefixCopyright)
|
||||
}
|
||||
if i := bytes.Index(in, []byte("\n\n")); i >= 0 {
|
||||
if len(copyright) == 0 {
|
||||
// Take only one of the two trailing '\n's.
|
||||
copyright = in[:i+1]
|
||||
}
|
||||
in = in[i+2:]
|
||||
}
|
||||
|
||||
fmt.Fprintf(out, "const %s = \"\" +\n", f.varname)
|
||||
writeStringConst(out, in)
|
||||
out.WriteString("\"\"\n\n")
|
||||
}
|
||||
|
||||
fmt.Fprintf(out, "var AuxNonBaseCcFiles = []string{\n")
|
||||
for _, f := range files {
|
||||
if strings.HasPrefix(f.varname, "Aux") &&
|
||||
strings.HasSuffix(f.varname, "Cc") &&
|
||||
(f.varname != "AuxBaseCc") {
|
||||
fmt.Fprintf(out, "%s,\n", f.varname)
|
||||
}
|
||||
}
|
||||
fmt.Fprintf(out, "}\n\n")
|
||||
|
||||
fmt.Fprintf(out, "var AuxNonBaseHhFiles = []string{\n")
|
||||
for _, f := range files {
|
||||
if strings.HasPrefix(f.varname, "Aux") &&
|
||||
strings.HasSuffix(f.varname, "Hh") &&
|
||||
(f.varname != "AuxBaseHh") {
|
||||
fmt.Fprintf(out, "%s,\n", f.varname)
|
||||
}
|
||||
}
|
||||
fmt.Fprintf(out, "}\n\n")
|
||||
|
||||
fmt.Fprintf(out, "const BaseCopyright = \"\" +\n")
|
||||
writeStringConst(out, copyright)
|
||||
out.WriteString("\"\"\n\n")
|
||||
return nil
|
||||
}
|
||||
|
||||
var dashDashDashDash = []byte("// ----")
|
||||
|
||||
func writeStringConst(out *bytes.Buffer, s []byte) {
|
||||
for len(s) > 0 {
|
||||
remaining := []byte(nil)
|
||||
if i := bytes.Index(s[1:], dashDashDashDash); i >= 0 {
|
||||
s, remaining = s[:i+1], s[i+1:]
|
||||
}
|
||||
|
||||
for len(s) > 0 {
|
||||
t := s
|
||||
if len(t) > columns {
|
||||
t = t[:columns]
|
||||
}
|
||||
s = s[len(t):]
|
||||
fmt.Fprintf(out, "%q +\n", t)
|
||||
}
|
||||
|
||||
s = remaining
|
||||
if len(s) > 0 {
|
||||
out.WriteString("\"\" +\n")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,142 @@
|
||||
// Copyright 2021 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.
|
||||
|
||||
package cgen
|
||||
|
||||
import (
|
||||
_ "embed"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// EmbeddedString holds hand-written C/C++ code, exposed by this Go package by
|
||||
// a "go:embed" directive.
|
||||
type EmbeddedString string
|
||||
|
||||
// Trim removes the leading "Copyright etc" boilerplate.
|
||||
func (e EmbeddedString) Trim() string {
|
||||
s := string(e)
|
||||
if strings.HasPrefix(s, "// Copyright ") {
|
||||
if i := strings.Index(s, "\n\n"); i >= 0 {
|
||||
s = s[i+2:]
|
||||
}
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// ----
|
||||
|
||||
//go:embed base/all-impl.c
|
||||
var embedBaseAllImplC EmbeddedString
|
||||
|
||||
// ----
|
||||
|
||||
//go:embed base/fundamental-private.h
|
||||
var embedBaseFundamentalPrivateH EmbeddedString
|
||||
|
||||
//go:embed base/fundamental-public.h
|
||||
var embedBaseFundamentalPublicH EmbeddedString
|
||||
|
||||
//go:embed base/memory-private.h
|
||||
var embedBaseMemoryPrivateH EmbeddedString
|
||||
|
||||
//go:embed base/memory-public.h
|
||||
var embedBaseMemoryPublicH EmbeddedString
|
||||
|
||||
//go:embed base/image-private.h
|
||||
var embedBaseImagePrivateH EmbeddedString
|
||||
|
||||
//go:embed base/image-public.h
|
||||
var embedBaseImagePublicH EmbeddedString
|
||||
|
||||
//go:embed base/io-private.h
|
||||
var embedBaseIOPrivateH EmbeddedString
|
||||
|
||||
//go:embed base/io-public.h
|
||||
var embedBaseIOPublicH EmbeddedString
|
||||
|
||||
//go:embed base/range-private.h
|
||||
var embedBaseRangePrivateH EmbeddedString
|
||||
|
||||
//go:embed base/range-public.h
|
||||
var embedBaseRangePublicH EmbeddedString
|
||||
|
||||
//go:embed base/strconv-private.h
|
||||
var embedBaseStrConvPrivateH EmbeddedString
|
||||
|
||||
//go:embed base/strconv-public.h
|
||||
var embedBaseStrConvPublicH EmbeddedString
|
||||
|
||||
//go:embed base/token-private.h
|
||||
var embedBaseTokenPrivateH EmbeddedString
|
||||
|
||||
//go:embed base/token-public.h
|
||||
var embedBaseTokenPublicH EmbeddedString
|
||||
|
||||
// ----
|
||||
|
||||
//go:embed base/floatconv-submodule-code.c
|
||||
var embedBaseFloatConvSubmoduleCodeC EmbeddedString
|
||||
|
||||
//go:embed base/floatconv-submodule-data.c
|
||||
var embedBaseFloatConvSubmoduleDataC EmbeddedString
|
||||
|
||||
//go:embed base/intconv-submodule.c
|
||||
var embedBaseIntConvSubmoduleC EmbeddedString
|
||||
|
||||
//go:embed base/magic-submodule.c
|
||||
var embedBaseMagicSubmoduleC EmbeddedString
|
||||
|
||||
//go:embed base/pixconv-submodule.c
|
||||
var embedBasePixConvSubmoduleC EmbeddedString
|
||||
|
||||
//go:embed base/utf8-submodule.c
|
||||
var embedBaseUTF8SubmoduleC EmbeddedString
|
||||
|
||||
// ----
|
||||
|
||||
//go:embed auxiliary/base.cc
|
||||
var EmbeddedString_AuxBaseCc EmbeddedString
|
||||
|
||||
//go:embed auxiliary/base.hh
|
||||
var EmbeddedString_AuxBaseHh EmbeddedString
|
||||
|
||||
//go:embed auxiliary/cbor.cc
|
||||
var embedAuxCborCc EmbeddedString
|
||||
|
||||
//go:embed auxiliary/cbor.hh
|
||||
var embedAuxCborHh EmbeddedString
|
||||
|
||||
//go:embed auxiliary/image.cc
|
||||
var embedAuxImageCc EmbeddedString
|
||||
|
||||
//go:embed auxiliary/image.hh
|
||||
var embedAuxImageHh EmbeddedString
|
||||
|
||||
//go:embed auxiliary/json.cc
|
||||
var embedAuxJsonCc EmbeddedString
|
||||
|
||||
//go:embed auxiliary/json.hh
|
||||
var embedAuxJsonHh EmbeddedString
|
||||
|
||||
var EmbeddedStrings_AuxNonBaseCcFiles = []EmbeddedString{
|
||||
embedAuxCborCc,
|
||||
embedAuxImageCc,
|
||||
embedAuxJsonCc,
|
||||
}
|
||||
|
||||
var EmbeddedStrings_AuxNonBaseHhFiles = []EmbeddedString{
|
||||
embedAuxCborHh,
|
||||
embedAuxImageHh,
|
||||
embedAuxJsonHh,
|
||||
}
|
||||
@@ -123,7 +123,12 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, sideEffectsOnly bool, depth u
|
||||
if err := g.writeExpr(b, recv, false, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.printf(", sizeof (%s%s), WUFFS_VERSION, 0))", g.packagePrefix(qid), qid[1].Str(g.tm))
|
||||
b.printf(",\nsizeof (%s%s), WUFFS_VERSION, ", g.packagePrefix(qid), qid[1].Str(g.tm))
|
||||
if recv.IsThisDotFoo() != 0 {
|
||||
b.writes("WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED))")
|
||||
} else {
|
||||
b.writes("0))")
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -40,7 +40,7 @@ type funk struct {
|
||||
derivedVars map[t.ID]struct{}
|
||||
jumpTargets map[a.Loop]string
|
||||
coroSuspPoint uint32
|
||||
ioBinds uint32
|
||||
ioManips uint32
|
||||
tempW uint32
|
||||
tempR uint32
|
||||
usesEmptyIOBuffer bool
|
||||
|
||||
@@ -185,8 +185,8 @@ loop:
|
||||
return err
|
||||
}
|
||||
|
||||
case a.KIOBind:
|
||||
if err := h.doIOBind(r, o.AsIOBind(), depth); err != nil {
|
||||
case a.KIOManip:
|
||||
if err := h.doIOManip(r, o.AsIOManip(), depth); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -324,13 +324,18 @@ func (h *livenessHelper) doExpr1(r livenesses, n *a.Expr, allToStrong bool, dept
|
||||
return nil
|
||||
}
|
||||
|
||||
func (h *livenessHelper) doIOBind(r livenesses, n *a.IOBind, depth uint32) error {
|
||||
func (h *livenessHelper) doIOManip(r livenesses, n *a.IOManip, depth uint32) error {
|
||||
if err := h.doExpr(r, n.IO()); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := h.doExpr(r, n.Arg1()); err != nil {
|
||||
return err
|
||||
}
|
||||
if histPos := n.HistoryPosition(); histPos != nil {
|
||||
if err := h.doExpr(r, n.HistoryPosition()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return h.doBlock(r, n.Body(), depth)
|
||||
}
|
||||
|
||||
|
||||
@@ -60,8 +60,8 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error {
|
||||
return g.writeStatementAssign(b, n.Operator(), n.LHS(), n.RHS(), depth)
|
||||
case a.KChoose:
|
||||
return g.writeStatementChoose(b, n.AsChoose(), depth)
|
||||
case a.KIOBind:
|
||||
return g.writeStatementIOBind(b, n.AsIOBind(), depth)
|
||||
case a.KIOManip:
|
||||
return g.writeStatementIOManip(b, n.AsIOManip(), depth)
|
||||
case a.KIf:
|
||||
return g.writeStatementIf(b, n.AsIf(), depth)
|
||||
case a.KIterate:
|
||||
@@ -277,15 +277,15 @@ func cpuArchCNames(asserts []*a.Node) (caMacro string, caName string, caAttribut
|
||||
caMacro, caName, caAttribute = "ARM_NEON", "arm_neon", ""
|
||||
case t.IDX86SSE42:
|
||||
caMacro, caName, caAttribute =
|
||||
"X86_64", "x86_sse42",
|
||||
"X86_FAMILY", "x86_sse42",
|
||||
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2\")"
|
||||
case t.IDX86AVX2:
|
||||
caMacro, caName, caAttribute =
|
||||
"X86_64", "x86_avx2",
|
||||
"X86_FAMILY", "x86_avx2",
|
||||
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"pclmul,popcnt,sse4.2,avx2\")"
|
||||
case t.IDX86BMI2:
|
||||
caMacro, caName, caAttribute =
|
||||
"X86_64", "x86_bmi2",
|
||||
"X86_FAMILY", "x86_bmi2",
|
||||
"WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET(\"bmi2\")"
|
||||
}
|
||||
}
|
||||
@@ -293,12 +293,12 @@ func cpuArchCNames(asserts []*a.Node) (caMacro string, caName string, caAttribut
|
||||
return caMacro, caName, caAttribute, nil
|
||||
}
|
||||
|
||||
func (g *gen) writeStatementIOBind(b *buffer, n *a.IOBind, depth uint32) error {
|
||||
if g.currFunk.ioBinds > maxIOBinds {
|
||||
func (g *gen) writeStatementIOManip(b *buffer, n *a.IOManip, depth uint32) error {
|
||||
if g.currFunk.ioManips > maxIOManips {
|
||||
return fmt.Errorf("too many temporary variables required")
|
||||
}
|
||||
ioBindNum := g.currFunk.ioBinds
|
||||
g.currFunk.ioBinds++
|
||||
ioBindNum := g.currFunk.ioManips
|
||||
g.currFunk.ioManips++
|
||||
|
||||
e := n.IO()
|
||||
prefix := vPrefix
|
||||
@@ -343,6 +343,10 @@ func (g *gen) writeStatementIOBind(b *buffer, n *a.IOBind, depth uint32) error {
|
||||
if err := g.writeExpr(b, n.Arg1(), false, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(",\n")
|
||||
if err := g.writeExpr(b, n.HistoryPosition(), false, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(");\n")
|
||||
|
||||
} else {
|
||||
|
||||
@@ -64,8 +64,8 @@ func (g *gen) needDerivedVar(name t.ID) bool {
|
||||
}
|
||||
}
|
||||
|
||||
case a.KIOBind:
|
||||
if p.AsIOBind().IO().IsArgsDotFoo() == name {
|
||||
case a.KIOManip:
|
||||
if p.AsIOManip().IO().IsArgsDotFoo() == name {
|
||||
return errNeedDerivedVar
|
||||
}
|
||||
}
|
||||
|
||||
@@ -18,7 +18,7 @@ package testcut
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"testing"
|
||||
)
|
||||
|
||||
@@ -29,7 +29,7 @@ func calculateDecodedLen(b []byte,
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
n, err := io.Copy(ioutil.Discard, r)
|
||||
n, err := io.Copy(io.Discard, r)
|
||||
if err != nil {
|
||||
r.Close()
|
||||
return 0, err
|
||||
@@ -48,7 +48,7 @@ func Test(tt *testing.T,
|
||||
filenames []string) {
|
||||
|
||||
for _, filename := range filenames {
|
||||
full, err := ioutil.ReadFile("../../test/data/" + filename)
|
||||
full, err := os.ReadFile("../../test/data/" + filename)
|
||||
if err != nil {
|
||||
tt.Errorf("f=%q: ReadFile: %v", filename, err)
|
||||
continue
|
||||
@@ -151,7 +151,7 @@ func Benchmark(b *testing.B,
|
||||
trimSuffix int,
|
||||
decodedLen int64) {
|
||||
|
||||
full, err := ioutil.ReadFile("../../test/data/" + filename)
|
||||
full, err := os.ReadFile("../../test/data/" + filename)
|
||||
if err != nil {
|
||||
b.Fatalf("ReadFile: %v", err)
|
||||
}
|
||||
|
||||
@@ -46,7 +46,7 @@ const (
|
||||
KField
|
||||
KFile
|
||||
KFunc
|
||||
KIOBind
|
||||
KIOManip
|
||||
KIf
|
||||
KIterate
|
||||
KJump
|
||||
@@ -78,7 +78,7 @@ var kindStrings = [...]string{
|
||||
KField: "KField",
|
||||
KFile: "KFile",
|
||||
KFunc: "KFunc",
|
||||
KIOBind: "KIOBind",
|
||||
KIOManip: "KIOManip",
|
||||
KIf: "KIf",
|
||||
KIterate: "KIterate",
|
||||
KJump: "KJump",
|
||||
@@ -169,7 +169,7 @@ type Node struct {
|
||||
// Field . . name Field
|
||||
// File . . . File
|
||||
// Func funcName receiverPkg receiverName Func
|
||||
// IOBind . . . IOBind
|
||||
// IOManip keyword . . IOManip
|
||||
// If . . . If
|
||||
// Iterate advance label length Iterate
|
||||
// Jump keyword label . Jump
|
||||
@@ -208,7 +208,7 @@ func (n *Node) AsExpr() *Expr { return (*Expr)(n) }
|
||||
func (n *Node) AsField() *Field { return (*Field)(n) }
|
||||
func (n *Node) AsFile() *File { return (*File)(n) }
|
||||
func (n *Node) AsFunc() *Func { return (*Func)(n) }
|
||||
func (n *Node) AsIOBind() *IOBind { return (*IOBind)(n) }
|
||||
func (n *Node) AsIOManip() *IOManip { return (*IOManip)(n) }
|
||||
func (n *Node) AsIf() *If { return (*If)(n) }
|
||||
func (n *Node) AsIterate() *Iterate { return (*Iterate)(n) }
|
||||
func (n *Node) AsJump() *Jump { return (*Jump)(n) }
|
||||
@@ -386,10 +386,15 @@ func (n *Expr) SetMBounds(x interval.IntRange) { n.mBounds = x }
|
||||
func (n *Expr) SetMType(x *TypeExpr) { n.mType = x }
|
||||
|
||||
func (n *Expr) IsArgsDotFoo() (foo t.ID) {
|
||||
if n.id0 == t.IDDot {
|
||||
if (n.lhs.id0 == 0) && (n.lhs.id2 == t.IDArgs) {
|
||||
return n.id2
|
||||
}
|
||||
if (n.id0 == t.IDDot) && (n.lhs.id0 == 0) && (n.lhs.id2 == t.IDArgs) {
|
||||
return n.id2
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (n *Expr) IsThisDotFoo() (foo t.ID) {
|
||||
if (n.id0 == t.IDDot) && (n.lhs.id0 == 0) && (n.lhs.id2 == t.IDThis) {
|
||||
return n.id2
|
||||
}
|
||||
return 0
|
||||
}
|
||||
@@ -583,26 +588,29 @@ func NewField(flags Flags, name t.ID, xType *TypeExpr) *Field {
|
||||
}
|
||||
}
|
||||
|
||||
// IOBind is "io_bind (io:LHS, data:MHS) { List2 }" or "io_limit (io:LHS,
|
||||
// limit:MHS) { List2 }":
|
||||
// IOManip is "io_bind (io:LHS, data:MHS, history_position:RHS) { List2 }" or
|
||||
// "io_limit (io:LHS, limit:MHS) { List2 }":
|
||||
// - ID0: <IDIOBind|IDIOLimit>
|
||||
// - LHS: <Expr>
|
||||
// - MHS: <Expr>
|
||||
// - RHS: <Expr>
|
||||
// - List2: <Statement> body
|
||||
type IOBind Node
|
||||
type IOManip Node
|
||||
|
||||
func (n *IOBind) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *IOBind) Keyword() t.ID { return n.id0 }
|
||||
func (n *IOBind) IO() *Expr { return n.lhs.AsExpr() }
|
||||
func (n *IOBind) Arg1() *Expr { return n.mhs.AsExpr() }
|
||||
func (n *IOBind) Body() []*Node { return n.list2 }
|
||||
func (n *IOManip) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *IOManip) Keyword() t.ID { return n.id0 }
|
||||
func (n *IOManip) IO() *Expr { return n.lhs.AsExpr() }
|
||||
func (n *IOManip) Arg1() *Expr { return n.mhs.AsExpr() }
|
||||
func (n *IOManip) HistoryPosition() *Expr { return n.rhs.AsExpr() }
|
||||
func (n *IOManip) Body() []*Node { return n.list2 }
|
||||
|
||||
func NewIOBind(keyword t.ID, io *Expr, arg1 *Expr, body []*Node) *IOBind {
|
||||
return &IOBind{
|
||||
kind: KIOBind,
|
||||
func NewIOManip(keyword t.ID, io *Expr, arg1 *Expr, historyPosition *Expr, body []*Node) *IOManip {
|
||||
return &IOManip{
|
||||
kind: KIOManip,
|
||||
id0: keyword,
|
||||
lhs: io.AsNode(),
|
||||
mhs: arg1.AsNode(),
|
||||
rhs: historyPosition.AsNode(),
|
||||
list2: body,
|
||||
}
|
||||
}
|
||||
@@ -1149,7 +1157,7 @@ func NewFile(filename string, topLevelDecls []*Node) *File {
|
||||
// - Assert
|
||||
// - Assign
|
||||
// - Choose
|
||||
// - IOBind
|
||||
// - IOManip
|
||||
// - If
|
||||
// - Iterate
|
||||
// - Jump
|
||||
|
||||
@@ -28,13 +28,17 @@ import (
|
||||
)
|
||||
|
||||
var FourCCs = [...][2]string{
|
||||
{"BGCL", "Background Color"},
|
||||
{"BMP ", "Bitmap"},
|
||||
{"BRTL", "Brotli"},
|
||||
{"BZ2 ", "Bzip2"},
|
||||
{"CBOR", "Concise Binary Object Representation"},
|
||||
{"CHRM", "Primary Chromaticities and White Point"},
|
||||
{"CSS ", "Cascading Style Sheets"},
|
||||
{"EPS ", "Encapsulated PostScript"},
|
||||
{"EXIF", "Exchangeable Image File Format"},
|
||||
{"FLAC", "Free Lossless Audio Codec"},
|
||||
{"GAMA", "Gamma Correction"},
|
||||
{"GIF ", "Graphics Interchange Format"},
|
||||
{"GZ ", "GNU Zip"},
|
||||
{"HEIF", "High Efficiency Image File"},
|
||||
@@ -47,29 +51,37 @@ var FourCCs = [...][2]string{
|
||||
{"JS ", "JavaScript"},
|
||||
{"JSON", "JavaScript Object Notation"},
|
||||
{"JWCC", "JSON With Commas and Comments"},
|
||||
{"KVP ", "Key-Value Pair"},
|
||||
{"KVPK", "Key-Value Pair (Key)"},
|
||||
{"KVPV", "Key-Value Pair (Value)"},
|
||||
{"LZ4 ", "Lempel–Ziv 4"},
|
||||
{"MD ", "Markdown"},
|
||||
{"MTIM", "Modification Time"},
|
||||
{"MP3 ", "MPEG-1 Audio Layer III"},
|
||||
{"NIE ", "Naive Image"},
|
||||
{"OFS2", "Offset (2-Dimensional)"},
|
||||
{"OTF ", "Open Type Format"},
|
||||
{"PDF ", "Portable Document Format"},
|
||||
{"PHYD", "Physical Dimensions"},
|
||||
{"PNG ", "Portable Network Graphics"},
|
||||
{"PNM ", "Portable Anymap"},
|
||||
{"PS ", "PostScript"},
|
||||
{"QOI ", "Quite OK Image"},
|
||||
{"RAC ", "Random Access Compression"},
|
||||
{"RAW ", "Raw"},
|
||||
{"RIFF", "Resource Interchange File Format"},
|
||||
{"RIGL", "Riegeli Records"},
|
||||
{"SNPY", "Snappy"},
|
||||
{"SRGB", "Standard Red Green Blue (Rendering Intent)"},
|
||||
{"SVG ", "Scalable Vector Graphics"},
|
||||
{"TAR ", "Tape Archive"},
|
||||
{"TEXT", "Text"},
|
||||
{"TIFF", "Tagged Image File Format"},
|
||||
{"TOML", "Tom's Obvious Minimal Language"},
|
||||
{"WAVE", "Waveform"},
|
||||
{"WBMP", "Wireless Bitmap"},
|
||||
{"WEBP", "Web Picture"},
|
||||
{"WOFF", "Web Open Font Format"},
|
||||
{"WP8 ", "Web Picture (VP8)"},
|
||||
{"WP8L", "Web Picture (VP8 Lossless)"},
|
||||
{"XML ", "Extensible Markup Language"},
|
||||
{"XMP ", "Extensible Metadata Platform"},
|
||||
{"XZ ", "Xz"},
|
||||
@@ -85,6 +97,20 @@ var Consts = [...]struct {
|
||||
}{
|
||||
// ----
|
||||
|
||||
{t.IDU8, "0", "ANIMATION_DISPOSAL__NONE"},
|
||||
{t.IDU8, "1", "ANIMATION_DISPOSAL__RESTORE_BACKGROUND"},
|
||||
{t.IDU8, "2", "ANIMATION_DISPOSAL__RESTORE_PREVIOUS"},
|
||||
|
||||
// ----
|
||||
|
||||
{t.IDU32, "1", "MORE_INFORMATION__FLAVOR__IO_REDIRECT"},
|
||||
{t.IDU32, "2", "MORE_INFORMATION__FLAVOR__IO_SEEK"},
|
||||
{t.IDU32, "3", "MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH"},
|
||||
{t.IDU32, "4", "MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM"},
|
||||
{t.IDU32, "5", "MORE_INFORMATION__FLAVOR__METADATA_PARSED"},
|
||||
|
||||
// ----
|
||||
|
||||
{t.IDU32, "0x02000008", "PIXEL_FORMAT__A"},
|
||||
|
||||
{t.IDU32, "0x20000008", "PIXEL_FORMAT__Y"},
|
||||
@@ -528,6 +554,7 @@ var funcsOther = [...]string{
|
||||
|
||||
"io_writer.count_since(mark: u64) u64",
|
||||
"io_writer.history_length() u64",
|
||||
"io_writer.history_position() u64",
|
||||
"io_writer.length() u64",
|
||||
"io_writer.mark() u64",
|
||||
"io_writer.position() u64",
|
||||
@@ -939,7 +966,9 @@ var TableFuncs = []string{
|
||||
"GENERIC T2.stride() u64",
|
||||
"GENERIC T2.width() u64",
|
||||
|
||||
"GENERIC T2.row(y: u32) T1",
|
||||
"GENERIC T2.row_u32(y: u32) T1",
|
||||
"GENERIC T2.subtable(" +
|
||||
"min_incl_x: u64, min_incl_y: u64, max_incl_x: u64, max_incl_y: u64) T2",
|
||||
}
|
||||
|
||||
func ParseFuncs(tm *t.Map, ss []string, callback func(*a.Func) error) error {
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -24,7 +25,6 @@ import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"go/format"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"strings"
|
||||
|
||||
@@ -63,7 +63,7 @@ func main1() error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return ioutil.WriteFile("data.go", formatted, 0644)
|
||||
return os.WriteFile("data.go", formatted, 0644)
|
||||
}
|
||||
|
||||
var (
|
||||
|
||||
@@ -250,14 +250,19 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
case a.KChoose:
|
||||
// No-op.
|
||||
|
||||
case a.KIOBind:
|
||||
n := n.AsIOBind()
|
||||
case a.KIOManip:
|
||||
n := n.AsIOManip()
|
||||
if _, err := q.bcheckExpr(n.IO(), 0); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := q.bcheckExpr(n.Arg1(), 0); err != nil {
|
||||
return err
|
||||
}
|
||||
if histPos := n.HistoryPosition(); histPos != nil {
|
||||
if _, err := q.bcheckExpr(histPos, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err := q.bcheckBlock(n.Body()); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -135,6 +135,10 @@ func Check(tm *t.Map, files []*a.File, resolveUse func(usePath string) ([]byte,
|
||||
}
|
||||
xType := (*a.TypeExpr)(nil)
|
||||
switch z.Type {
|
||||
case t.IDU8:
|
||||
xType = typeExprU8
|
||||
case t.IDU16:
|
||||
xType = typeExprU16
|
||||
case t.IDU32:
|
||||
xType = typeExprU32
|
||||
case t.IDU64:
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -24,7 +25,6 @@ import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"go/format"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"sort"
|
||||
"strings"
|
||||
@@ -56,11 +56,11 @@ func main1() error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return ioutil.WriteFile("data.go", formatted, 0644)
|
||||
return os.WriteFile("data.go", formatted, 0644)
|
||||
}
|
||||
|
||||
func loadReasons() ([]string, error) {
|
||||
s, err := ioutil.ReadFile("axioms.md")
|
||||
s, err := os.ReadFile("axioms.md")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
@@ -149,8 +149,8 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
}
|
||||
return nil
|
||||
|
||||
case a.KIOBind:
|
||||
n := n.AsIOBind()
|
||||
case a.KIOManip:
|
||||
n := n.AsIOManip()
|
||||
if err := q.tcheckExpr(n.IO(), 0); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -171,6 +171,16 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
n.Keyword().Str(q.tm), n.Arg1().Str(q.tm), typ.Str(q.tm), arg1Typ.Str(q.tm))
|
||||
}
|
||||
|
||||
if n.Keyword() == t.IDIOBind {
|
||||
if err := q.tcheckExpr(n.HistoryPosition(), 0); err != nil {
|
||||
return err
|
||||
}
|
||||
if typ := n.HistoryPosition().MType(); !typ.IsIdeal() && !typ.EqIgnoringRefinements(typeExprU64) {
|
||||
return fmt.Errorf("check: %s expression %q, of type %q, does not have type %q",
|
||||
n.Keyword().Str(q.tm), n.HistoryPosition().Str(q.tm), typ.Str(q.tm), typeExprU64.Str(q.tm))
|
||||
}
|
||||
}
|
||||
|
||||
for _, o := range n.Body() {
|
||||
// TODO: prohibit jumps (breaks, continues), rets (returns, yields)
|
||||
// and retry-calling ? methods while inside an io_bind body.
|
||||
|
||||
@@ -17,7 +17,7 @@ package generate
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
@@ -98,7 +98,7 @@ func checkPackageName(s string) string {
|
||||
func parseFiles(tm *t.Map, filenames []string) (files []*a.File, err error) {
|
||||
if len(filenames) == 0 {
|
||||
const filename = "stdin"
|
||||
src, err := ioutil.ReadAll(os.Stdin)
|
||||
src, err := io.ReadAll(os.Stdin)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -117,7 +117,7 @@ func parseFiles(tm *t.Map, filenames []string) (files []*a.File, err error) {
|
||||
|
||||
func ParseFiles(tm *t.Map, filenames []string, opts *parse.Options) (files []*a.File, err error) {
|
||||
for _, filename := range filenames {
|
||||
src, err := ioutil.ReadFile(filename)
|
||||
src, err := os.ReadFile(filename)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -139,5 +139,5 @@ func resolveUse(usePath string) ([]byte, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return ioutil.ReadFile(filepath.Join(wuffsRoot, "gen", "wuffs", filepath.FromSlash(usePath)))
|
||||
return os.ReadFile(filepath.Join(wuffsRoot, "gen", "wuffs", filepath.FromSlash(usePath)))
|
||||
}
|
||||
@@ -861,7 +861,7 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
return a.NewChoose(name, args).AsNode(), nil
|
||||
|
||||
case t.IDIOBind, t.IDIOLimit:
|
||||
return p.parseIOBindNode()
|
||||
return p.parseIOManipNode()
|
||||
|
||||
case t.IDIf:
|
||||
o, err := p.parseIf()
|
||||
@@ -1050,7 +1050,7 @@ func (p *parser) parseAsserts() ([]*a.Node, error) {
|
||||
return asserts, nil
|
||||
}
|
||||
|
||||
func (p *parser) parseIOBindNode() (*a.Node, error) {
|
||||
func (p *parser) parseIOManipNode() (*a.Node, error) {
|
||||
keyword := p.peek1()
|
||||
p.src = p.src[1:]
|
||||
|
||||
@@ -1123,6 +1123,36 @@ func (p *parser) parseIOBindNode() (*a.Node, error) {
|
||||
io.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
|
||||
histPos := (*a.Expr)(nil)
|
||||
if keyword == t.IDIOBind {
|
||||
if x := p.peek1(); x != t.IDComma {
|
||||
got := p.tm.ByID(x)
|
||||
return nil, fmt.Errorf(`parse: expected ",", got %q at %s:%d`, got, p.filename, p.line())
|
||||
}
|
||||
p.src = p.src[1:]
|
||||
|
||||
if x := p.peek1(); x != t.IDHistoryPosition {
|
||||
got := p.tm.ByID(x)
|
||||
return nil, fmt.Errorf(`parse: expected "history_position", got %q at %s:%d`, got, p.filename, p.line())
|
||||
}
|
||||
p.src = p.src[1:]
|
||||
|
||||
if x := p.peek1(); x != t.IDColon {
|
||||
got := p.tm.ByID(x)
|
||||
return nil, fmt.Errorf(`parse: expected ":", got %q at %s:%d`, got, p.filename, p.line())
|
||||
}
|
||||
p.src = p.src[1:]
|
||||
|
||||
histPos, err = p.parseExpr()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if histPos.Effect() != 0 {
|
||||
return nil, fmt.Errorf(`parse: argument %q is not effect-free at %s:%d`,
|
||||
io.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
}
|
||||
|
||||
if x := p.peek1(); x != t.IDCloseParen {
|
||||
got := p.tm.ByID(x)
|
||||
return nil, fmt.Errorf(`parse: expected ")", got %q at %s:%d`, got, p.filename, p.line())
|
||||
@@ -1134,7 +1164,7 @@ func (p *parser) parseIOBindNode() (*a.Node, error) {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return a.NewIOBind(keyword, io, arg1, body).AsNode(), nil
|
||||
return a.NewIOManip(keyword, io, arg1, histPos, body).AsNode(), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseIf() (*a.If, error) {
|
||||
@@ -1354,22 +1384,6 @@ func (p *parser) parseArgNode() (*a.Node, error) {
|
||||
return a.NewArg(name, value).AsNode(), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseIOBindExprNode() (*a.Node, error) {
|
||||
e, err := p.parseExpr()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch e.Operator() {
|
||||
case 0:
|
||||
return e.AsNode(), nil
|
||||
case t.IDDot:
|
||||
if lhs := e.LHS().AsExpr(); lhs.Operator() == 0 && lhs.Ident() == t.IDArgs {
|
||||
return e.AsNode(), nil
|
||||
}
|
||||
}
|
||||
return nil, fmt.Errorf(`parse: expected "args.something", got %q at %s:%d`, e.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
|
||||
func (p *parser) parseVarNode() (*a.Node, error) {
|
||||
id, err := p.parseIdent()
|
||||
if err != nil {
|
||||
|
||||
@@ -490,19 +490,20 @@ const (
|
||||
|
||||
IDDecodeFrameOptions = ID(0x158)
|
||||
|
||||
IDCanUndoByte = ID(0x160)
|
||||
IDCountSince = ID(0x161)
|
||||
IDHistoryLength = ID(0x162)
|
||||
IDIsClosed = ID(0x163)
|
||||
IDMark = ID(0x164)
|
||||
IDMatch15 = ID(0x165)
|
||||
IDMatch31 = ID(0x166)
|
||||
IDMatch7 = ID(0x167)
|
||||
IDPosition = ID(0x168)
|
||||
IDSince = ID(0x169)
|
||||
IDSkip = ID(0x16A)
|
||||
IDSkipU32 = ID(0x16B)
|
||||
IDSkipU32Fast = ID(0x16C)
|
||||
IDCanUndoByte = ID(0x160)
|
||||
IDCountSince = ID(0x161)
|
||||
IDHistoryLength = ID(0x162)
|
||||
IDHistoryPosition = ID(0x163)
|
||||
IDIsClosed = ID(0x164)
|
||||
IDMark = ID(0x165)
|
||||
IDMatch15 = ID(0x166)
|
||||
IDMatch31 = ID(0x167)
|
||||
IDMatch7 = ID(0x168)
|
||||
IDPosition = ID(0x169)
|
||||
IDSince = ID(0x16A)
|
||||
IDSkip = ID(0x16B)
|
||||
IDSkipU32 = ID(0x16C)
|
||||
IDSkipU32Fast = ID(0x16D)
|
||||
|
||||
IDCopyFromSlice = ID(0x170)
|
||||
IDLimitedCopyU32FromHistory = ID(0x171)
|
||||
@@ -667,12 +668,14 @@ const (
|
||||
IDIO = ID(0x242)
|
||||
IDLimit = ID(0x243)
|
||||
IDPrefix = ID(0x244)
|
||||
IDRow = ID(0x245)
|
||||
IDRowU32 = ID(0x245)
|
||||
IDStride = ID(0x246)
|
||||
IDSuffix = ID(0x247)
|
||||
IDUintptrLow12Bits = ID(0x248)
|
||||
IDValidUTF8Length = ID(0x249)
|
||||
IDWidth = ID(0x24A)
|
||||
IDSubslice = ID(0x247)
|
||||
IDSubtable = ID(0x248)
|
||||
IDSuffix = ID(0x249)
|
||||
IDUintptrLow12Bits = ID(0x24A)
|
||||
IDValidUTF8Length = ID(0x24B)
|
||||
IDWidth = ID(0x24C)
|
||||
|
||||
IDLimitedSwizzleU32InterleavedFromReader = ID(0x280)
|
||||
IDSwizzleInterleavedFromReader = ID(0x281)
|
||||
@@ -917,19 +920,20 @@ var builtInsByID = [nBuiltInIDs]string{
|
||||
|
||||
IDDecodeFrameOptions: "decode_frame_options",
|
||||
|
||||
IDCanUndoByte: "can_undo_byte",
|
||||
IDCountSince: "count_since",
|
||||
IDHistoryLength: "history_length",
|
||||
IDIsClosed: "is_closed",
|
||||
IDMark: "mark",
|
||||
IDMatch15: "match15",
|
||||
IDMatch31: "match31",
|
||||
IDMatch7: "match7",
|
||||
IDPosition: "position",
|
||||
IDSince: "since",
|
||||
IDSkip: "skip",
|
||||
IDSkipU32: "skip_u32",
|
||||
IDSkipU32Fast: "skip_u32_fast",
|
||||
IDCanUndoByte: "can_undo_byte",
|
||||
IDCountSince: "count_since",
|
||||
IDHistoryLength: "history_length",
|
||||
IDHistoryPosition: "history_position",
|
||||
IDIsClosed: "is_closed",
|
||||
IDMark: "mark",
|
||||
IDMatch15: "match15",
|
||||
IDMatch31: "match31",
|
||||
IDMatch7: "match7",
|
||||
IDPosition: "position",
|
||||
IDSince: "since",
|
||||
IDSkip: "skip",
|
||||
IDSkipU32: "skip_u32",
|
||||
IDSkipU32Fast: "skip_u32_fast",
|
||||
|
||||
IDCopyFromSlice: "copy_from_slice",
|
||||
IDLimitedCopyU32FromHistory: "limited_copy_u32_from_history",
|
||||
@@ -1090,8 +1094,10 @@ var builtInsByID = [nBuiltInIDs]string{
|
||||
IDIO: "io",
|
||||
IDLimit: "limit",
|
||||
IDPrefix: "prefix",
|
||||
IDRow: "row",
|
||||
IDRowU32: "row_u32",
|
||||
IDStride: "stride",
|
||||
IDSubslice: "subslice",
|
||||
IDSubtable: "subtable",
|
||||
IDSuffix: "suffix",
|
||||
IDUintptrLow12Bits: "uintptr_low_12_bits",
|
||||
IDValidUTF8Length: "valid_utf_8_length",
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
|
||||
// ----------------
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -24,7 +25,6 @@ import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"os"
|
||||
"sort"
|
||||
@@ -151,7 +151,7 @@ func main1() error {
|
||||
fmt.Fprintf(w, "// %4d entries have %2d%s probes\n", x, i, plus)
|
||||
}
|
||||
|
||||
return ioutil.WriteFile("data.go", w.Bytes(), 0644)
|
||||
return os.WriteFile("data.go", w.Bytes(), 0644)
|
||||
}
|
||||
|
||||
func build() error {
|
||||
|
||||
@@ -16,7 +16,7 @@ package cgolz4
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io/ioutil"
|
||||
"io"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
@@ -74,7 +74,7 @@ func TestRoundTrip(tt *testing.T) {
|
||||
// Uncompress.
|
||||
{
|
||||
r.Reset(strings.NewReader(compressed), nil)
|
||||
gotBytes, err := ioutil.ReadAll(r)
|
||||
gotBytes, err := io.ReadAll(r)
|
||||
if err != nil {
|
||||
r.Close()
|
||||
tt.Fatalf("i=%d: ReadAll: %v", i, err)
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
|
||||
// ----------------
|
||||
|
||||
//go:build !cgo
|
||||
// +build !cgo
|
||||
|
||||
package cgolz4
|
||||
|
||||
@@ -18,7 +18,7 @@ import (
|
||||
"bytes"
|
||||
"compress/zlib"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
@@ -57,7 +57,7 @@ func testReadAll(tt *testing.T, r resetReadCloser, src io.Reader, dict []byte, w
|
||||
tt.Fatalf("Reset: %v", err)
|
||||
}
|
||||
|
||||
got, err := ioutil.ReadAll(r)
|
||||
got, err := io.ReadAll(r)
|
||||
if err != nil {
|
||||
tt.Fatalf("ReadAll: %v", err)
|
||||
}
|
||||
@@ -87,7 +87,7 @@ func benchmarkReader(b *testing.B, r resetReadCloser) {
|
||||
}
|
||||
|
||||
src := bytes.NewReader(nil)
|
||||
srcBytes, err := ioutil.ReadFile("../../test/data/pi.txt.zlib")
|
||||
srcBytes, err := os.ReadFile("../../test/data/pi.txt.zlib")
|
||||
if err != nil {
|
||||
b.Fatalf("ReadFile: %v", err)
|
||||
}
|
||||
@@ -100,7 +100,7 @@ func benchmarkReader(b *testing.B, r resetReadCloser) {
|
||||
b.Fatalf("Reset: %v", err)
|
||||
}
|
||||
|
||||
if n, err := io.Copy(ioutil.Discard, r); err != nil {
|
||||
if n, err := io.Copy(io.Discard, r); err != nil {
|
||||
b.Fatalf("Copy: %v", err)
|
||||
} else if n != 100003 {
|
||||
b.Fatalf("Copy: got %d, want %d", n, 100003)
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
|
||||
// ----------------
|
||||
|
||||
//go:build !cgo
|
||||
// +build !cgo
|
||||
|
||||
package cgozlib
|
||||
|
||||
@@ -16,7 +16,7 @@ package cgozstd
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io/ioutil"
|
||||
"io"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
@@ -87,7 +87,7 @@ func TestRoundTrip(tt *testing.T) {
|
||||
r.Close()
|
||||
tt.Fatalf("i=%d: Reset: %v", i, err)
|
||||
}
|
||||
gotBytes, err := ioutil.ReadAll(r)
|
||||
gotBytes, err := io.ReadAll(r)
|
||||
if err != nil {
|
||||
r.Close()
|
||||
tt.Fatalf("i=%d: ReadAll: %v", i, err)
|
||||
@@ -149,7 +149,7 @@ func TestDictionary(tt *testing.T) {
|
||||
r.Close()
|
||||
tt.Fatalf("%s: Reset: %v", name, err)
|
||||
}
|
||||
gotBytes, err := ioutil.ReadAll(r)
|
||||
gotBytes, err := io.ReadAll(r)
|
||||
if err != nil {
|
||||
r.Close()
|
||||
tt.Fatalf("%s: ReadAll: %v", name, err)
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
|
||||
// ----------------
|
||||
|
||||
//go:build !cgo
|
||||
// +build !cgo
|
||||
|
||||
package cgozstd
|
||||
|
||||
@@ -18,7 +18,6 @@ import (
|
||||
"bytes"
|
||||
"compress/flate"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"testing"
|
||||
|
||||
"github.com/google/wuffs/internal/testcut"
|
||||
@@ -26,8 +25,8 @@ import (
|
||||
|
||||
func TestCut(tt *testing.T) {
|
||||
testcut.Test(tt, SmallestValidMaxEncodedLen, Cut, newReader, []string{
|
||||
"artificial/deflate-backref-crosses-blocks.deflate",
|
||||
"artificial/deflate-distance-32768.deflate",
|
||||
"artificial-deflate/backref-crosses-blocks.deflate",
|
||||
"artificial-deflate/distance-32768.deflate",
|
||||
"romeo.txt.deflate",
|
||||
"romeo.txt.fixed-huff.deflate",
|
||||
})
|
||||
@@ -43,7 +42,7 @@ func newReader(r io.Reader) (io.ReadCloser, error) {
|
||||
}
|
||||
|
||||
func decodeFlate(src []byte) string {
|
||||
dst, err := ioutil.ReadAll(flate.NewReader(bytes.NewReader(src)))
|
||||
dst, err := io.ReadAll(flate.NewReader(bytes.NewReader(src)))
|
||||
if err != nil {
|
||||
return err.Error()
|
||||
}
|
||||
|
||||
@@ -20,7 +20,6 @@ import (
|
||||
"fmt"
|
||||
"hash/crc32"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"math/rand"
|
||||
"os"
|
||||
"strings"
|
||||
@@ -165,7 +164,7 @@ func TestWriterILAStartMemTempFile(tt *testing.T) {
|
||||
}
|
||||
|
||||
func TestWriterILAStartRealTempFile(tt *testing.T) {
|
||||
f, err := ioutil.TempFile("", "rac_test")
|
||||
f, err := os.CreateTemp("", "rac_test")
|
||||
if err != nil {
|
||||
tt.Fatalf("TempFile: %v", err)
|
||||
}
|
||||
@@ -560,7 +559,7 @@ func TestReaderEmpty(tt *testing.T) {
|
||||
CompressedSize: int64(len(encoded)),
|
||||
}
|
||||
defer r.Close()
|
||||
got, err := ioutil.ReadAll(r)
|
||||
got, err := io.ReadAll(r)
|
||||
if err != nil {
|
||||
tt.Fatalf("ReadAll: %v", err)
|
||||
}
|
||||
@@ -587,7 +586,7 @@ func TestReaderZeroes(tt *testing.T) {
|
||||
CompressedSize: int64(len(encoded)),
|
||||
}
|
||||
defer r.Close()
|
||||
got, err := ioutil.ReadAll(r)
|
||||
got, err := io.ReadAll(r)
|
||||
if err != nil {
|
||||
tt.Fatalf("ReadAll: %v", err)
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build cgo
|
||||
// +build cgo
|
||||
|
||||
package raczlib
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build !cgo
|
||||
// +build !cgo
|
||||
|
||||
package raczlib
|
||||
|
||||
@@ -18,7 +18,7 @@ import (
|
||||
"bytes"
|
||||
"compress/zlib"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"io"
|
||||
"log"
|
||||
"strings"
|
||||
|
||||
@@ -83,7 +83,7 @@ func ExampleCut() {
|
||||
if err != nil {
|
||||
log.Fatalf("NewReader: %v", err)
|
||||
}
|
||||
uncompressed, err := ioutil.ReadAll(r)
|
||||
uncompressed, err := io.ReadAll(r)
|
||||
if err != nil {
|
||||
log.Fatalf("ReadAll: %v", err)
|
||||
}
|
||||
|
||||
@@ -54,13 +54,14 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
// Note that Clang also defines __GNUC__.
|
||||
#ifdef __cplusplus
|
||||
#if (__cplusplus >= 201103L) || defined(_MSC_VER)
|
||||
#include <memory>
|
||||
#define WUFFS_BASE__HAVE_EQ_DELETE
|
||||
#define WUFFS_BASE__HAVE_UNIQUE_PTR
|
||||
#elif defined(__GNUC__)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#elif defined(__GNUC__) || defined(__clang__)
|
||||
#warning "Wuffs' C++ code expects -std=c++11 or later"
|
||||
#endif
|
||||
|
||||
@@ -88,7 +89,7 @@ extern "C" {
|
||||
#define WUFFS_VERSION_MAJOR 0
|
||||
#define WUFFS_VERSION_MINOR 0
|
||||
#define WUFFS_VERSION_PATCH 0
|
||||
#define WUFFS_VERSION_PRE_RELEASE_LABEL "work.in.progress"
|
||||
#define WUFFS_VERSION_PRE_RELEASE_LABEL "unsupported.snapshot"
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 0
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 0
|
||||
#define WUFFS_VERSION_STRING "0.0.0+0.00000000"
|
||||
@@ -131,15 +132,18 @@ extern "C" {
|
||||
// POPCNT. This is checked at runtime via cpuid, not at compile time.
|
||||
//
|
||||
// Likewise, "cpu_arch >= x86_avx2" also requires PCLMUL, POPCNT and SSE4.2.
|
||||
#if defined(__x86_64__) && !defined(__native_client__)
|
||||
#if defined(__i386__) || defined(__x86_64__)
|
||||
#if !defined(__native_client__)
|
||||
#include <cpuid.h>
|
||||
#include <x86intrin.h>
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_64
|
||||
#endif // defined(__x86_64__) && !defined(__native_client__)
|
||||
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
|
||||
#endif // !defined(__native_client__)
|
||||
#endif // defined(__i386__) || defined(__x86_64__)
|
||||
|
||||
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
|
||||
|
||||
#if defined(_M_X64)
|
||||
#if defined(_M_IX86) || defined(_M_X64)
|
||||
#if defined(__AVX__) || defined(__clang__)
|
||||
|
||||
// We need <intrin.h> for the __cpuid function.
|
||||
@@ -153,7 +157,8 @@ extern "C" {
|
||||
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT
|
||||
#include <nmmintrin.h> // SSE4.2
|
||||
#include <wmmintrin.h> // AES, PCLMUL
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_64
|
||||
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
|
||||
|
||||
#else // defined(__AVX__) || defined(__clang__)
|
||||
|
||||
@@ -163,19 +168,22 @@ extern "C" {
|
||||
// For MSVC's cl.exe (unlike clang or gcc), SIMD capability is a compile-time
|
||||
// property of the source file (e.g. a /arch:AVX or -mavx compiler flag), not
|
||||
// of individual functions (that can be conditionally selected at runtime).
|
||||
#pragma message("Wuffs with MSVC+X64 needs /arch:AVX for best performance")
|
||||
#pragma message("Wuffs with MSVC+IX86/X64 needs /arch:AVX for best performance")
|
||||
|
||||
#endif // defined(__AVX__) || defined(__clang__)
|
||||
#endif // defined(_M_X64)
|
||||
#endif // defined(_M_IX86) || defined(_M_X64)
|
||||
|
||||
#endif // (#if-chain ref AVOID_CPU_ARCH_1)
|
||||
#endif // (#if-chain ref AVOID_CPU_ARCH_0)
|
||||
|
||||
// --------
|
||||
|
||||
// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
|
||||
// static storage. The motivation is discussed in the "ALLOW STATIC
|
||||
// IMPLEMENTATION" section of
|
||||
// Define WUFFS_CONFIG__STATIC_FUNCTIONS (combined with WUFFS_IMPLEMENTATION)
|
||||
// to make all of Wuffs' functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#if defined(WUFFS_CONFIG__STATIC_FUNCTIONS)
|
||||
#define WUFFS_BASE__MAYBE_STATIC static
|
||||
@@ -205,7 +213,7 @@ wuffs_base__cpu_arch__have_arm_neon() {
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__cpu_arch__have_x86_avx2() {
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// GCC defines these macros but MSVC does not.
|
||||
// - bit_AVX2 = (1 << 5)
|
||||
const unsigned int avx2_ebx7 = 0x00000020;
|
||||
@@ -245,13 +253,13 @@ wuffs_base__cpu_arch__have_x86_avx2() {
|
||||
#else
|
||||
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
|
||||
#endif // defined(__GNUC__); defined(_MSC_VER)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__cpu_arch__have_x86_bmi2() {
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// GCC defines these macros but MSVC does not.
|
||||
// - bit_BMI2 = (1 << 8)
|
||||
const unsigned int bmi2_ebx7 = 0x00000100;
|
||||
@@ -275,13 +283,13 @@ wuffs_base__cpu_arch__have_x86_bmi2() {
|
||||
#else
|
||||
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
|
||||
#endif // defined(__GNUC__); defined(_MSC_VER)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// GCC defines these macros but MSVC does not.
|
||||
// - bit_PCLMUL = (1 << 1)
|
||||
// - bit_POPCNT = (1 << 23)
|
||||
@@ -307,7 +315,7 @@ wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
#else
|
||||
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
|
||||
#endif // defined(__GNUC__); defined(_MSC_VER)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -322,8 +330,9 @@ wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Clang also defines "__GNUC__".
|
||||
#if defined(__GNUC__)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused))
|
||||
#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result))
|
||||
#else
|
||||
@@ -551,7 +560,20 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
|
||||
// --------
|
||||
|
||||
// FourCC constants.
|
||||
// FourCC constants. Four Character Codes are literally four ASCII characters
|
||||
// (sometimes padded with ' ' spaces) that pack neatly into a signed or
|
||||
// unsigned 32-bit integer. ASCII letters are conventionally upper case.
|
||||
//
|
||||
// They are often used to identify video codecs (e.g. "H265") and pixel formats
|
||||
// (e.g. "YV12"). Wuffs uses them for that but also generally for naming
|
||||
// various things: compression formats (e.g. "BZ2 "), image metadata (e.g.
|
||||
// "EXIF"), file formats (e.g. "HTML"), etc.
|
||||
//
|
||||
// Wuffs' u32 values are big-endian ("JPEG" is 0x4A504547 not 0x4745504A) to
|
||||
// preserve ordering: "JPEG" < "MP3 " and 0x4A504547 < 0x4D503320.
|
||||
|
||||
// Background Color.
|
||||
#define WUFFS_BASE__FOURCC__BGCL 0x4247434C
|
||||
|
||||
// Bitmap.
|
||||
#define WUFFS_BASE__FOURCC__BMP 0x424D5020
|
||||
@@ -565,15 +587,24 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// Concise Binary Object Representation.
|
||||
#define WUFFS_BASE__FOURCC__CBOR 0x43424F52
|
||||
|
||||
// Primary Chromaticities and White Point.
|
||||
#define WUFFS_BASE__FOURCC__CHRM 0x4348524D
|
||||
|
||||
// Cascading Style Sheets.
|
||||
#define WUFFS_BASE__FOURCC__CSS 0x43535320
|
||||
|
||||
// Encapsulated PostScript.
|
||||
#define WUFFS_BASE__FOURCC__EPS 0x45505320
|
||||
|
||||
// Exchangeable Image File Format.
|
||||
#define WUFFS_BASE__FOURCC__EXIF 0x45584946
|
||||
|
||||
// Free Lossless Audio Codec.
|
||||
#define WUFFS_BASE__FOURCC__FLAC 0x464C4143
|
||||
|
||||
// Gamma Correction.
|
||||
#define WUFFS_BASE__FOURCC__GAMA 0x47414D41
|
||||
|
||||
// Graphics Interchange Format.
|
||||
#define WUFFS_BASE__FOURCC__GIF 0x47494620
|
||||
|
||||
@@ -610,24 +641,42 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// JSON With Commas and Comments.
|
||||
#define WUFFS_BASE__FOURCC__JWCC 0x4A574343
|
||||
|
||||
// Key-Value Pair.
|
||||
#define WUFFS_BASE__FOURCC__KVP 0x4B565020
|
||||
|
||||
// Key-Value Pair (Key).
|
||||
#define WUFFS_BASE__FOURCC__KVPK 0x4B56504B
|
||||
|
||||
// Key-Value Pair (Value).
|
||||
#define WUFFS_BASE__FOURCC__KVPV 0x4B565056
|
||||
|
||||
// Lempel–Ziv 4.
|
||||
#define WUFFS_BASE__FOURCC__LZ4 0x4C5A3420
|
||||
|
||||
// Markdown.
|
||||
#define WUFFS_BASE__FOURCC__MD 0x4D442020
|
||||
|
||||
// Modification Time.
|
||||
#define WUFFS_BASE__FOURCC__MTIM 0x4D54494D
|
||||
|
||||
// MPEG-1 Audio Layer III.
|
||||
#define WUFFS_BASE__FOURCC__MP3 0x4D503320
|
||||
|
||||
// Naive Image.
|
||||
#define WUFFS_BASE__FOURCC__NIE 0x4E494520
|
||||
|
||||
// Offset (2-Dimensional).
|
||||
#define WUFFS_BASE__FOURCC__OFS2 0x4F465332
|
||||
|
||||
// Open Type Format.
|
||||
#define WUFFS_BASE__FOURCC__OTF 0x4F544620
|
||||
|
||||
// Portable Document Format.
|
||||
#define WUFFS_BASE__FOURCC__PDF 0x50444620
|
||||
|
||||
// Physical Dimensions.
|
||||
#define WUFFS_BASE__FOURCC__PHYD 0x50485944
|
||||
|
||||
// Portable Network Graphics.
|
||||
#define WUFFS_BASE__FOURCC__PNG 0x504E4720
|
||||
|
||||
@@ -637,6 +686,9 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// PostScript.
|
||||
#define WUFFS_BASE__FOURCC__PS 0x50532020
|
||||
|
||||
// Quite OK Image.
|
||||
#define WUFFS_BASE__FOURCC__QOI 0x514F4920
|
||||
|
||||
// Random Access Compression.
|
||||
#define WUFFS_BASE__FOURCC__RAC 0x52414320
|
||||
|
||||
@@ -652,12 +704,18 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// Snappy.
|
||||
#define WUFFS_BASE__FOURCC__SNPY 0x534E5059
|
||||
|
||||
// Standard Red Green Blue (Rendering Intent).
|
||||
#define WUFFS_BASE__FOURCC__SRGB 0x53524742
|
||||
|
||||
// Scalable Vector Graphics.
|
||||
#define WUFFS_BASE__FOURCC__SVG 0x53564720
|
||||
|
||||
// Tape Archive.
|
||||
#define WUFFS_BASE__FOURCC__TAR 0x54415220
|
||||
|
||||
// Text.
|
||||
#define WUFFS_BASE__FOURCC__TEXT 0x54455854
|
||||
|
||||
// Tagged Image File Format.
|
||||
#define WUFFS_BASE__FOURCC__TIFF 0x54494646
|
||||
|
||||
@@ -670,15 +728,12 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// Wireless Bitmap.
|
||||
#define WUFFS_BASE__FOURCC__WBMP 0x57424D50
|
||||
|
||||
// Web Picture.
|
||||
#define WUFFS_BASE__FOURCC__WEBP 0x57454250
|
||||
|
||||
// Web Open Font Format.
|
||||
#define WUFFS_BASE__FOURCC__WOFF 0x574F4646
|
||||
|
||||
// Web Picture (VP8).
|
||||
#define WUFFS_BASE__FOURCC__WP8 0x57503820
|
||||
|
||||
// Web Picture (VP8 Lossless).
|
||||
#define WUFFS_BASE__FOURCC__WP8L 0x5750384C
|
||||
|
||||
// Extensible Markup Language.
|
||||
#define WUFFS_BASE__FOURCC__XML 0x584D4C20
|
||||
|
||||
@@ -956,7 +1011,9 @@ wuffs_base__multiply_u64(uint64_t x, uint64_t y) {
|
||||
|
||||
// --------
|
||||
|
||||
#if defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#if (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__count_leading_zeroes_u64(uint64_t u) {
|
||||
@@ -1000,7 +1057,7 @@ wuffs_base__count_leading_zeroes_u64(uint64_t u) {
|
||||
return n;
|
||||
}
|
||||
|
||||
#endif // defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
|
||||
#endif // (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
|
||||
|
||||
// --------
|
||||
|
||||
@@ -1564,6 +1621,25 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
// wuffs_base__table_u8__subtable_ij returns t[ix:jx, iy:jy].
|
||||
//
|
||||
// It returns an empty table if i or j is out of bounds.
|
||||
static inline wuffs_base__table_u8 //
|
||||
wuffs_base__table_u8__subtable_ij(wuffs_base__table_u8 t,
|
||||
uint64_t ix,
|
||||
uint64_t iy,
|
||||
uint64_t jx,
|
||||
uint64_t jy) {
|
||||
if ((ix <= jx) && (jx <= SIZE_MAX) && (jx <= t.width) && //
|
||||
(iy <= jy) && (jy <= SIZE_MAX) && (jy <= t.height)) {
|
||||
return wuffs_base__make_table_u8(t.ptr + ix + (iy * t.stride), //
|
||||
((size_t)(jx - ix)), //
|
||||
((size_t)(jy - iy)), //
|
||||
t.stride); //
|
||||
}
|
||||
return wuffs_base__make_table_u8(NULL, 0, 0, 0);
|
||||
}
|
||||
|
||||
// wuffs_base__table__flattened_length returns the number of elements covered
|
||||
// by the 1-dimensional span that backs a 2-dimensional table. This counts the
|
||||
// elements inside the table and, when width != stride, the elements outside
|
||||
@@ -2446,14 +2522,24 @@ typedef struct wuffs_base__more_information__struct {
|
||||
inline wuffs_base__range_ie_u64 io_redirect__range() const;
|
||||
inline uint64_t io_seek__position() const;
|
||||
inline uint32_t metadata__fourcc() const;
|
||||
// Deprecated: use metadata_raw_passthrough__range.
|
||||
inline wuffs_base__range_ie_u64 metadata__range() const;
|
||||
inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const;
|
||||
inline int32_t metadata_parsed__chrm(uint32_t component) const;
|
||||
inline uint32_t metadata_parsed__gama() const;
|
||||
inline uint32_t metadata_parsed__srgb() const;
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_base__more_information;
|
||||
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT 1
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK 2
|
||||
// Deprecated: use
|
||||
// WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH.
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA 3
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH 3
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM 4
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED 5
|
||||
|
||||
static inline wuffs_base__more_information //
|
||||
wuffs_base__empty_more_information() {
|
||||
@@ -2510,6 +2596,8 @@ wuffs_base__more_information__metadata__fourcc(
|
||||
return m->w;
|
||||
}
|
||||
|
||||
// Deprecated: use
|
||||
// wuffs_base__more_information__metadata_raw_passthrough__range.
|
||||
static inline wuffs_base__range_ie_u64 //
|
||||
wuffs_base__more_information__metadata__range(
|
||||
const wuffs_base__more_information* m) {
|
||||
@@ -2519,6 +2607,103 @@ wuffs_base__more_information__metadata__range(
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__range_ie_u64 //
|
||||
wuffs_base__more_information__metadata_raw_passthrough__range(
|
||||
const wuffs_base__more_information* m) {
|
||||
wuffs_base__range_ie_u64 ret;
|
||||
ret.min_incl = m->y;
|
||||
ret.max_excl = m->z;
|
||||
return ret;
|
||||
}
|
||||
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_X 0
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_Y 1
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_X 2
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_Y 3
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_X 4
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_Y 5
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_X 6
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_Y 7
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__chrm returns chromaticity
|
||||
// values (scaled by 100000) like the PNG "cHRM" chunk. For example, the sRGB
|
||||
// color space corresponds to:
|
||||
// - ETC__CHRM__WHITE_X 31270
|
||||
// - ETC__CHRM__WHITE_Y 32900
|
||||
// - ETC__CHRM__RED_X 64000
|
||||
// - ETC__CHRM__RED_Y 33000
|
||||
// - ETC__CHRM__GREEN_X 30000
|
||||
// - ETC__CHRM__GREEN_Y 60000
|
||||
// - ETC__CHRM__BLUE_X 15000
|
||||
// - ETC__CHRM__BLUE_Y 6000
|
||||
//
|
||||
// See
|
||||
// https://ciechanow.ski/color-spaces/#chromaticity-and-white-point-coordinates
|
||||
static inline int32_t //
|
||||
wuffs_base__more_information__metadata_parsed__chrm(
|
||||
const wuffs_base__more_information* m,
|
||||
uint32_t component) {
|
||||
// After the flavor and the w field (holding a FourCC), a
|
||||
// wuffs_base__more_information holds 24 bytes of data in three uint64_t
|
||||
// typed fields (x, y and z). We pack the eight chromaticity values (wx, wy,
|
||||
// rx, ..., by), basically int24_t values, into 24 bytes like this:
|
||||
// - LSB MSB
|
||||
// - x: wx wx wx wy wy wy rx rx
|
||||
// - y: rx ry ry ry gx gx gx gy
|
||||
// - z: gy gy bx bx bx by by by
|
||||
uint32_t u = 0;
|
||||
switch (component & 7) {
|
||||
case 0:
|
||||
u = ((uint32_t)(m->x >> 0));
|
||||
break;
|
||||
case 1:
|
||||
u = ((uint32_t)(m->x >> 24));
|
||||
break;
|
||||
case 2:
|
||||
u = ((uint32_t)((m->x >> 48) | (m->y << 16)));
|
||||
break;
|
||||
case 3:
|
||||
u = ((uint32_t)(m->y >> 8));
|
||||
break;
|
||||
case 4:
|
||||
u = ((uint32_t)(m->y >> 32));
|
||||
break;
|
||||
case 5:
|
||||
u = ((uint32_t)((m->y >> 56) | (m->z << 8)));
|
||||
break;
|
||||
case 6:
|
||||
u = ((uint32_t)(m->z >> 16));
|
||||
break;
|
||||
case 7:
|
||||
u = ((uint32_t)(m->z >> 40));
|
||||
break;
|
||||
}
|
||||
// The left-right shifts sign-extend from 24-bit to 32-bit integers.
|
||||
return ((int32_t)(u << 8)) >> 8;
|
||||
}
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__gama returns inverse gamma
|
||||
// correction values (scaled by 100000) like the PNG "gAMA" chunk. For example,
|
||||
// for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2).
|
||||
static inline uint32_t //
|
||||
wuffs_base__more_information__metadata_parsed__gama(
|
||||
const wuffs_base__more_information* m) {
|
||||
return ((uint32_t)(m->x));
|
||||
}
|
||||
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__PERCEPTUAL 0
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__RELATIVE_COLORIMETRIC 1
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__SATURATION 2
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__ABSOLUTE_COLORIMETRIC 3
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__srgb returns the sRGB
|
||||
// rendering intent like the PNG "sRGB" chunk.
|
||||
static inline uint32_t //
|
||||
wuffs_base__more_information__metadata_parsed__srgb(
|
||||
const wuffs_base__more_information* m) {
|
||||
return m->x & 3;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
inline void //
|
||||
@@ -2556,6 +2741,26 @@ wuffs_base__more_information::metadata__range() const {
|
||||
return wuffs_base__more_information__metadata__range(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__range_ie_u64 //
|
||||
wuffs_base__more_information::metadata_raw_passthrough__range() const {
|
||||
return wuffs_base__more_information__metadata_raw_passthrough__range(this);
|
||||
}
|
||||
|
||||
inline int32_t //
|
||||
wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const {
|
||||
return wuffs_base__more_information__metadata_parsed__chrm(this, component);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__more_information::metadata_parsed__gama() const {
|
||||
return wuffs_base__more_information__metadata_parsed__gama(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__more_information::metadata_parsed__srgb() const {
|
||||
return wuffs_base__more_information__metadata_parsed__srgb(this);
|
||||
}
|
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
// ---------------- I/O
|
||||
@@ -5062,9 +5267,9 @@ wuffs_base__pixel_swizzler::swizzle_interleaved_from_slice(
|
||||
|
||||
// wuffs_base__ieee_754_bit_representation__etc converts between a double
|
||||
// precision numerical value and its IEEE 754 representations:
|
||||
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
|
||||
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
|
||||
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
|
||||
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
|
||||
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
|
||||
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
|
||||
//
|
||||
// For example, it converts between:
|
||||
// - +1.0 and 0x3C00, 0x3F80_0000 or 0x3FF0_0000_0000_0000.
|
||||
@@ -7103,6 +7308,7 @@ struct wuffs_deflate__decoder__struct {
|
||||
|
||||
uint32_t f_bits;
|
||||
uint32_t f_n_bits;
|
||||
uint64_t f_transformed_history_count;
|
||||
uint32_t f_history_index;
|
||||
uint32_t f_n_huffs_bits[2];
|
||||
bool f_end_of_block;
|
||||
@@ -7155,7 +7361,6 @@ struct wuffs_deflate__decoder__struct {
|
||||
uint32_t v_length;
|
||||
uint32_t v_dist_minus_1;
|
||||
uint32_t v_hlen;
|
||||
uint32_t v_hdist;
|
||||
uint64_t scratch;
|
||||
} s_decode_huffman_slow[1];
|
||||
} private_data;
|
||||
@@ -7675,8 +7880,8 @@ struct wuffs_gif__decoder__struct {
|
||||
bool f_previous_lzw_decode_ended_abruptly;
|
||||
bool f_has_global_palette;
|
||||
uint8_t f_interlace;
|
||||
bool f_seen_num_loops;
|
||||
uint32_t f_num_loops;
|
||||
bool f_seen_num_animation_loops_value;
|
||||
uint32_t f_num_animation_loops_value;
|
||||
uint32_t f_background_color_u32_argb_premul;
|
||||
uint32_t f_black_color_u32_argb_premul;
|
||||
bool f_gc_has_transparent_index;
|
||||
@@ -8725,6 +8930,8 @@ extern const char wuffs_zlib__error__incorrect_dictionary[];
|
||||
|
||||
// ---------------- Public Consts
|
||||
|
||||
#define WUFFS_ZLIB__QUIRK_JUST_RAW_DEFLATE 2113790976
|
||||
|
||||
#define WUFFS_ZLIB__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1
|
||||
|
||||
// ---------------- Struct Declarations
|
||||
@@ -8836,6 +9043,7 @@ struct wuffs_zlib__decoder__struct {
|
||||
bool f_header_complete;
|
||||
bool f_got_dictionary;
|
||||
bool f_want_dictionary;
|
||||
bool f_quirks[1];
|
||||
bool f_ignore_checksum;
|
||||
uint32_t f_dict_id_got;
|
||||
uint32_t f_dict_id_want;
|
||||
@@ -8954,17 +9162,22 @@ struct wuffs_zlib__decoder__struct {
|
||||
|
||||
// ---------------- Status Codes
|
||||
|
||||
extern const char wuffs_png__error__bad_animation_sequence_number[];
|
||||
extern const char wuffs_png__error__bad_checksum[];
|
||||
extern const char wuffs_png__error__bad_chunk[];
|
||||
extern const char wuffs_png__error__bad_filter[];
|
||||
extern const char wuffs_png__error__bad_header[];
|
||||
extern const char wuffs_png__error__bad_text_chunk_not_latin_1[];
|
||||
extern const char wuffs_png__error__missing_palette[];
|
||||
extern const char wuffs_png__error__unsupported_png_compression_method[];
|
||||
extern const char wuffs_png__error__unsupported_png_file[];
|
||||
|
||||
// ---------------- Public Consts
|
||||
|
||||
#define WUFFS_PNG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0
|
||||
|
||||
#define WUFFS_PNG__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 8
|
||||
|
||||
// ---------------- Struct Declarations
|
||||
|
||||
typedef struct wuffs_png__decoder__struct wuffs_png__decoder;
|
||||
@@ -9114,22 +9327,68 @@ struct wuffs_png__decoder__struct {
|
||||
uint32_t f_height;
|
||||
uint64_t f_pass_bytes_per_row;
|
||||
uint64_t f_workbuf_wi;
|
||||
uint64_t f_workbuf_hist_pos_base;
|
||||
uint64_t f_overall_workbuf_length;
|
||||
uint64_t f_pass_workbuf_length;
|
||||
uint8_t f_call_sequence;
|
||||
bool f_report_metadata_chrm;
|
||||
bool f_report_metadata_exif;
|
||||
bool f_report_metadata_gama;
|
||||
bool f_report_metadata_iccp;
|
||||
bool f_report_metadata_kvp;
|
||||
bool f_report_metadata_srgb;
|
||||
bool f_ignore_checksum;
|
||||
uint8_t f_depth;
|
||||
uint8_t f_color_type;
|
||||
uint8_t f_filter_distance;
|
||||
uint8_t f_interlace_pass;
|
||||
bool f_seen_actl;
|
||||
bool f_seen_chrm;
|
||||
bool f_seen_fctl;
|
||||
bool f_seen_exif;
|
||||
bool f_seen_gama;
|
||||
bool f_seen_iccp;
|
||||
bool f_seen_idat;
|
||||
bool f_seen_plte;
|
||||
bool f_seen_srgb;
|
||||
bool f_seen_trns;
|
||||
uint32_t f_dst_pixfmt;
|
||||
uint32_t f_src_pixfmt;
|
||||
bool f_metadata_is_zlib_compressed;
|
||||
bool f_zlib_is_dirty;
|
||||
uint32_t f_chunk_type;
|
||||
uint8_t f_chunk_type_array[4];
|
||||
uint64_t f_chunk_length;
|
||||
uint32_t f_chunk_length;
|
||||
uint64_t f_remap_transparency;
|
||||
uint32_t f_dst_pixfmt;
|
||||
uint32_t f_src_pixfmt;
|
||||
uint32_t f_num_animation_frames_value;
|
||||
uint32_t f_num_animation_loops_value;
|
||||
uint32_t f_num_decoded_frame_configs_value;
|
||||
uint32_t f_num_decoded_frames_value;
|
||||
uint32_t f_frame_rect_x0;
|
||||
uint32_t f_frame_rect_y0;
|
||||
uint32_t f_frame_rect_x1;
|
||||
uint32_t f_frame_rect_y1;
|
||||
uint32_t f_first_rect_x0;
|
||||
uint32_t f_first_rect_y0;
|
||||
uint32_t f_first_rect_x1;
|
||||
uint32_t f_first_rect_y1;
|
||||
uint64_t f_frame_config_io_position;
|
||||
uint64_t f_first_config_io_position;
|
||||
uint64_t f_frame_duration;
|
||||
uint64_t f_first_duration;
|
||||
uint8_t f_frame_disposal;
|
||||
uint8_t f_first_disposal;
|
||||
bool f_frame_overwrite_instead_of_blend;
|
||||
bool f_first_overwrite_instead_of_blend;
|
||||
uint32_t f_next_animation_seq_num;
|
||||
uint32_t f_metadata_flavor;
|
||||
uint32_t f_metadata_fourcc;
|
||||
uint64_t f_metadata_x;
|
||||
uint64_t f_metadata_y;
|
||||
uint64_t f_metadata_z;
|
||||
uint32_t f_ztxt_ri;
|
||||
uint32_t f_ztxt_wi;
|
||||
uint64_t f_ztxt_hist_pos;
|
||||
wuffs_base__pixel_swizzler f_swizzler;
|
||||
|
||||
wuffs_base__empty_struct (*choosy_filter_1)(
|
||||
@@ -9146,11 +9405,19 @@ struct wuffs_png__decoder__struct {
|
||||
uint32_t p_decode_image_config[1];
|
||||
uint32_t p_decode_ihdr[1];
|
||||
uint32_t p_decode_other_chunk[1];
|
||||
uint32_t p_decode_actl[1];
|
||||
uint32_t p_decode_chrm[1];
|
||||
uint32_t p_decode_fctl[1];
|
||||
uint32_t p_decode_gama[1];
|
||||
uint32_t p_decode_iccp[1];
|
||||
uint32_t p_decode_plte[1];
|
||||
uint32_t p_decode_srgb[1];
|
||||
uint32_t p_decode_trns[1];
|
||||
uint32_t p_decode_frame_config[1];
|
||||
uint32_t p_skip_frame[1];
|
||||
uint32_t p_decode_frame[1];
|
||||
uint32_t p_decode_pass[1];
|
||||
uint32_t p_tell_me_more[1];
|
||||
wuffs_base__status (*choosy_filter_and_swizzle)(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
@@ -9173,19 +9440,47 @@ struct wuffs_png__decoder__struct {
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_other_chunk[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_actl[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_chrm[1];
|
||||
struct {
|
||||
uint32_t v_x0;
|
||||
uint32_t v_x1;
|
||||
uint32_t v_y1;
|
||||
uint64_t scratch;
|
||||
} s_decode_fctl[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_gama[1];
|
||||
struct {
|
||||
uint32_t v_num_entries;
|
||||
uint32_t v_i;
|
||||
uint64_t scratch;
|
||||
} s_decode_plte[1];
|
||||
struct {
|
||||
uint32_t v_num_entries;
|
||||
uint32_t v_i;
|
||||
uint32_t v_n;
|
||||
uint64_t scratch;
|
||||
} s_decode_trns[1];
|
||||
struct {
|
||||
uint32_t v_checksum_have;
|
||||
uint64_t scratch;
|
||||
} s_decode_frame_config[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_skip_frame[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_frame[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_pass[1];
|
||||
struct {
|
||||
wuffs_base__status v_zlib_status;
|
||||
uint64_t scratch;
|
||||
} s_tell_me_more[1];
|
||||
} private_data;
|
||||
|
||||
#ifdef __cplusplus
|
||||
@@ -9682,6 +9977,63 @@ namespace sync_io {
|
||||
|
||||
// --------
|
||||
|
||||
// DynIOBuffer is an IOBuffer that is backed by a dynamically sized byte array.
|
||||
// It owns that backing array and will free it in its destructor.
|
||||
//
|
||||
// The array size can be explicitly extended (by calling the grow method) but,
|
||||
// unlike a C++ std::vector, there is no implicit extension (e.g. by calling
|
||||
// std::vector::insert) and its maximum size is capped by the max_incl
|
||||
// constructor argument.
|
||||
//
|
||||
// It contains an IOBuffer-typed field whose reader side provides access to
|
||||
// previously written bytes and whose writer side provides access to the
|
||||
// allocated but not-yet-written-to slack space. For Go programmers, this slack
|
||||
// space is roughly analogous to the s[len(s):cap(s)] space of a slice s.
|
||||
class DynIOBuffer {
|
||||
public:
|
||||
enum GrowResult {
|
||||
OK = 0,
|
||||
FailedMaxInclExceeded = 1,
|
||||
FailedOutOfMemory = 2,
|
||||
};
|
||||
|
||||
// m_buf holds the dynamically sized byte array and its read/write indexes:
|
||||
// - m_buf.meta.wi is roughly analogous to a Go slice's length.
|
||||
// - m_buf.data.len is roughly analogous to a Go slice's capacity. It is
|
||||
// also equal to the m_buf.data.ptr malloc/realloc size.
|
||||
//
|
||||
// Users should not modify the m_buf.data.ptr or m_buf.data.len fields (as
|
||||
// they are conceptually private to this class), but they can modify the
|
||||
// bytes referenced by that pointer-length pair (e.g. compactions).
|
||||
IOBuffer m_buf;
|
||||
|
||||
// m_max_incl is an inclusive upper bound on the backing array size.
|
||||
const uint64_t m_max_incl;
|
||||
|
||||
// Constructor and destructor.
|
||||
explicit DynIOBuffer(uint64_t max_incl);
|
||||
~DynIOBuffer();
|
||||
|
||||
// Drop frees the byte array and resets m_buf. The DynIOBuffer can still be
|
||||
// used after a drop call. It just restarts from zero.
|
||||
void drop();
|
||||
|
||||
// grow ensures that the byte array size is at least min_incl and at most
|
||||
// max_incl. It returns FailedMaxInclExceeded if that would require
|
||||
// allocating more than max_incl bytes, including the case where (min_incl >
|
||||
// max_incl). It returns FailedOutOfMemory if memory allocation failed.
|
||||
GrowResult grow(uint64_t min_incl);
|
||||
|
||||
private:
|
||||
// Delete the copy and assign constructors.
|
||||
DynIOBuffer(const DynIOBuffer&) = delete;
|
||||
DynIOBuffer& operator=(const DynIOBuffer&) = delete;
|
||||
|
||||
static uint64_t round_up(uint64_t min_incl, uint64_t max_incl);
|
||||
};
|
||||
|
||||
// --------
|
||||
|
||||
class Input {
|
||||
public:
|
||||
virtual ~Input();
|
||||
@@ -9792,6 +10144,26 @@ class DecodeCborCallbacks {
|
||||
Done(DecodeCborResult& result, sync_io::Input& input, IOBuffer& buffer);
|
||||
};
|
||||
|
||||
// The FooArgBar types add structure to Foo's optional arguments. They wrap
|
||||
// inner representations for several reasons:
|
||||
// - It provides a home for the DefaultValue static method, for Foo callers
|
||||
// that want to override some but not all optional arguments.
|
||||
// - It provides the "Bar" name at Foo call sites, which can help self-
|
||||
// document Foo calls with many arguemnts.
|
||||
// - It provides some type safety against accidentally transposing or omitting
|
||||
// adjacent fundamentally-numeric-typed optional arguments.
|
||||
|
||||
// DecodeCborArgQuirks wraps an optional argument to DecodeCbor.
|
||||
struct DecodeCborArgQuirks {
|
||||
explicit DecodeCborArgQuirks(wuffs_base__slice_u32 repr0);
|
||||
explicit DecodeCborArgQuirks(uint32_t* ptr, size_t len);
|
||||
|
||||
// DefaultValue returns an empty slice.
|
||||
static DecodeCborArgQuirks DefaultValue();
|
||||
|
||||
wuffs_base__slice_u32 repr;
|
||||
};
|
||||
|
||||
// DecodeCbor calls callbacks based on the CBOR-formatted data in input.
|
||||
//
|
||||
// On success, the returned error_message is empty and cursor_position counts
|
||||
@@ -9801,7 +10173,7 @@ class DecodeCborCallbacks {
|
||||
DecodeCborResult //
|
||||
DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32());
|
||||
DecodeCborArgQuirks quirks = DecodeCborArgQuirks::DefaultValue());
|
||||
|
||||
} // namespace wuffs_aux
|
||||
|
||||
@@ -9823,10 +10195,11 @@ struct DecodeImageResult {
|
||||
// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always
|
||||
// called in this order:
|
||||
// 1. SelectDecoder
|
||||
// 2. SelectPixfmt
|
||||
// 3. AllocPixbuf
|
||||
// 4. AllocWorkbuf
|
||||
// 5. Done
|
||||
// 2. HandleMetadata
|
||||
// 3. SelectPixfmt
|
||||
// 4. AllocPixbuf
|
||||
// 5. AllocWorkbuf
|
||||
// 6. Done
|
||||
//
|
||||
// It may return early - the third callback might not be invoked if the second
|
||||
// one fails - but the final callback (Done) is always invoked.
|
||||
@@ -9883,6 +10256,22 @@ class DecodeImageCallbacks {
|
||||
virtual wuffs_base__image_decoder::unique_ptr //
|
||||
SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);
|
||||
|
||||
// HandleMetadata acknowledges image metadata. minfo.flavor will be one of:
|
||||
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH
|
||||
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED
|
||||
// If it is ETC__METADATA_RAW_ETC then raw contains the metadata bytes. Those
|
||||
// bytes should not be retained beyond the the HandleMetadata call.
|
||||
//
|
||||
// minfo.metadata__fourcc() will typically match one of the
|
||||
// DecodeImageArgFlags bits. For example, if (REPORT_METADATA_CHRM |
|
||||
// REPORT_METADATA_GAMA) was passed to DecodeImage then the metadata FourCC
|
||||
// will be either WUFFS_BASE__FOURCC__CHRM or WUFFS_BASE__FOURCC__GAMA.
|
||||
//
|
||||
// It returns an error message, or an empty string on success.
|
||||
virtual std::string //
|
||||
HandleMetadata(const wuffs_base__more_information& minfo,
|
||||
wuffs_base__slice_u8 raw);
|
||||
|
||||
// SelectPixfmt returns the destination pixel format for AllocPixbuf. It
|
||||
// should return wuffs_base__make_pixel_format(etc) called with one of:
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
|
||||
@@ -9949,13 +10338,116 @@ class DecodeImageCallbacks {
|
||||
|
||||
extern const char DecodeImage_BufferIsTooShort[];
|
||||
extern const char DecodeImage_MaxInclDimensionExceeded[];
|
||||
extern const char DecodeImage_MaxInclMetadataLengthExceeded[];
|
||||
extern const char DecodeImage_OutOfMemory[];
|
||||
extern const char DecodeImage_UnexpectedEndOfFile[];
|
||||
extern const char DecodeImage_UnsupportedImageFormat[];
|
||||
extern const char DecodeImage_UnsupportedMetadata[];
|
||||
extern const char DecodeImage_UnsupportedPixelBlend[];
|
||||
extern const char DecodeImage_UnsupportedPixelConfiguration[];
|
||||
extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
|
||||
// The FooArgBar types add structure to Foo's optional arguments. They wrap
|
||||
// inner representations for several reasons:
|
||||
// - It provides a home for the DefaultValue static method, for Foo callers
|
||||
// that want to override some but not all optional arguments.
|
||||
// - It provides the "Bar" name at Foo call sites, which can help self-
|
||||
// document Foo calls with many arguemnts.
|
||||
// - It provides some type safety against accidentally transposing or omitting
|
||||
// adjacent fundamentally-numeric-typed optional arguments.
|
||||
|
||||
// DecodeImageArgQuirks wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgQuirks {
|
||||
explicit DecodeImageArgQuirks(wuffs_base__slice_u32 repr0);
|
||||
explicit DecodeImageArgQuirks(uint32_t* ptr, size_t len);
|
||||
|
||||
// DefaultValue returns an empty slice.
|
||||
static DecodeImageArgQuirks DefaultValue();
|
||||
|
||||
wuffs_base__slice_u32 repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgFlags wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgFlags {
|
||||
explicit DecodeImageArgFlags(uint64_t repr0);
|
||||
|
||||
// DefaultValue returns 0.
|
||||
static DecodeImageArgFlags DefaultValue();
|
||||
|
||||
// TODO: support all of the REPORT_METADATA_ETC flags, not just CHRM, EXIF,
|
||||
// GAMA, ICCP, KVP, SRGB and XMP.
|
||||
|
||||
// Background Color.
|
||||
static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001;
|
||||
// Primary Chromaticities and White Point.
|
||||
static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002;
|
||||
// Exchangeable Image File Format.
|
||||
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004;
|
||||
// Gamma Correction.
|
||||
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008;
|
||||
// International Color Consortium Profile.
|
||||
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010;
|
||||
// Key-Value Pair.
|
||||
//
|
||||
// For PNG files, this includes iTXt, tEXt and zTXt chunks. In the
|
||||
// HandleMetadata callback, the raw argument contains UTF-8 strings.
|
||||
static constexpr uint64_t REPORT_METADATA_KVP = 0x0020;
|
||||
// Modification Time.
|
||||
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040;
|
||||
// Offset (2-Dimensional).
|
||||
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080;
|
||||
// Physical Dimensions.
|
||||
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100;
|
||||
// Standard Red Green Blue (Rendering Intent).
|
||||
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200;
|
||||
// Extensible Metadata Platform.
|
||||
static constexpr uint64_t REPORT_METADATA_XMP = 0x0400;
|
||||
|
||||
uint64_t repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgPixelBlend wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgPixelBlend {
|
||||
explicit DecodeImageArgPixelBlend(wuffs_base__pixel_blend repr0);
|
||||
|
||||
// DefaultValue returns WUFFS_BASE__PIXEL_BLEND__SRC.
|
||||
static DecodeImageArgPixelBlend DefaultValue();
|
||||
|
||||
wuffs_base__pixel_blend repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgBackgroundColor wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgBackgroundColor {
|
||||
explicit DecodeImageArgBackgroundColor(
|
||||
wuffs_base__color_u32_argb_premul repr0);
|
||||
|
||||
// DefaultValue returns 1, an invalid wuffs_base__color_u32_argb_premul.
|
||||
static DecodeImageArgBackgroundColor DefaultValue();
|
||||
|
||||
wuffs_base__color_u32_argb_premul repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgMaxInclDimension wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgMaxInclDimension {
|
||||
explicit DecodeImageArgMaxInclDimension(uint32_t repr0);
|
||||
|
||||
// DefaultValue returns 1048575 = 0x000F_FFFF, more than 1 million pixels.
|
||||
static DecodeImageArgMaxInclDimension DefaultValue();
|
||||
|
||||
uint32_t repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgMaxInclMetadataLength wraps an optional argument to
|
||||
// DecodeImage.
|
||||
struct DecodeImageArgMaxInclMetadataLength {
|
||||
explicit DecodeImageArgMaxInclMetadataLength(uint64_t repr0);
|
||||
|
||||
// DefaultValue returns 16777215 = 0x00FF_FFFF, one less than 16 MiB.
|
||||
static DecodeImageArgMaxInclMetadataLength DefaultValue();
|
||||
|
||||
uint64_t repr;
|
||||
};
|
||||
|
||||
// DecodeImage decodes the image data in input. A variety of image file formats
|
||||
// can be decoded, depending on what callbacks.SelectDecoder returns.
|
||||
//
|
||||
@@ -9998,13 +10490,21 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
// WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque.
|
||||
//
|
||||
// Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's
|
||||
// width or height is greater than max_incl_dimension.
|
||||
// width or height is greater than max_incl_dimension or if any opted-in (via
|
||||
// flags bits) metadata is longer than max_incl_metadata_length.
|
||||
DecodeImageResult //
|
||||
DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.
|
||||
uint32_t max_incl_dimension = 1048575); // 0x000F_FFFF
|
||||
DecodeImageArgQuirks quirks = DecodeImageArgQuirks::DefaultValue(),
|
||||
DecodeImageArgFlags flags = DecodeImageArgFlags::DefaultValue(),
|
||||
DecodeImageArgPixelBlend pixel_blend =
|
||||
DecodeImageArgPixelBlend::DefaultValue(),
|
||||
DecodeImageArgBackgroundColor background_color =
|
||||
DecodeImageArgBackgroundColor::DefaultValue(),
|
||||
DecodeImageArgMaxInclDimension max_incl_dimension =
|
||||
DecodeImageArgMaxInclDimension::DefaultValue(),
|
||||
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length =
|
||||
DecodeImageArgMaxInclMetadataLength::DefaultValue());
|
||||
|
||||
} // namespace wuffs_aux
|
||||
|
||||
@@ -10065,6 +10565,36 @@ class DecodeJsonCallbacks {
|
||||
extern const char DecodeJson_BadJsonPointer[];
|
||||
extern const char DecodeJson_NoMatch[];
|
||||
|
||||
// The FooArgBar types add structure to Foo's optional arguments. They wrap
|
||||
// inner representations for several reasons:
|
||||
// - It provides a home for the DefaultValue static method, for Foo callers
|
||||
// that want to override some but not all optional arguments.
|
||||
// - It provides the "Bar" name at Foo call sites, which can help self-
|
||||
// document Foo calls with many arguemnts.
|
||||
// - It provides some type safety against accidentally transposing or omitting
|
||||
// adjacent fundamentally-numeric-typed optional arguments.
|
||||
|
||||
// DecodeJsonArgQuirks wraps an optional argument to DecodeJson.
|
||||
struct DecodeJsonArgQuirks {
|
||||
explicit DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0);
|
||||
explicit DecodeJsonArgQuirks(uint32_t* ptr, size_t len);
|
||||
|
||||
// DefaultValue returns an empty slice.
|
||||
static DecodeJsonArgQuirks DefaultValue();
|
||||
|
||||
wuffs_base__slice_u32 repr;
|
||||
};
|
||||
|
||||
// DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson.
|
||||
struct DecodeJsonArgJsonPointer {
|
||||
explicit DecodeJsonArgJsonPointer(std::string repr0);
|
||||
|
||||
// DefaultValue returns an empty string.
|
||||
static DecodeJsonArgJsonPointer DefaultValue();
|
||||
|
||||
std::string repr;
|
||||
};
|
||||
|
||||
// DecodeJson calls callbacks based on the JSON-formatted data in input.
|
||||
//
|
||||
// On success, the returned error_message is empty and cursor_position counts
|
||||
@@ -10082,8 +10612,9 @@ extern const char DecodeJson_NoMatch[];
|
||||
DecodeJsonResult //
|
||||
DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32(),
|
||||
std::string json_pointer = std::string());
|
||||
DecodeJsonArgQuirks quirks = DecodeJsonArgQuirks::DefaultValue(),
|
||||
DecodeJsonArgJsonPointer json_pointer =
|
||||
DecodeJsonArgJsonPointer::DefaultValue());
|
||||
|
||||
} // namespace wuffs_aux
|
||||
|
||||
@@ -10133,8 +10664,9 @@ extern "C" {
|
||||
goto suspend; \
|
||||
case n:;
|
||||
|
||||
// Clang also defines "__GNUC__".
|
||||
#if defined(__GNUC__)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))
|
||||
#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))
|
||||
#else
|
||||
@@ -10292,7 +10824,7 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,
|
||||
// --------
|
||||
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {
|
||||
wuffs_base__table_u8__row_u32(wuffs_base__table_u8 t, uint32_t y) {
|
||||
if (y < t.height) {
|
||||
return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width);
|
||||
}
|
||||
@@ -10463,11 +10995,12 @@ wuffs_base__io_reader__set(wuffs_base__io_buffer* b,
|
||||
const uint8_t** ptr_io0_r,
|
||||
const uint8_t** ptr_io1_r,
|
||||
const uint8_t** ptr_io2_r,
|
||||
wuffs_base__slice_u8 data) {
|
||||
wuffs_base__slice_u8 data,
|
||||
uint64_t history_position) {
|
||||
b->data = data;
|
||||
b->meta.wi = data.len;
|
||||
b->meta.ri = 0;
|
||||
b->meta.pos = 0;
|
||||
b->meta.pos = history_position;
|
||||
b->meta.closed = false;
|
||||
|
||||
*ptr_iop_r = data.ptr;
|
||||
@@ -10507,7 +11040,7 @@ wuffs_base__io_writer__limit(uint8_t** ptr_io2_w,
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -10515,7 +11048,7 @@ wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
|
||||
return 0;
|
||||
}
|
||||
uint8_t* p = *ptr_iop_w;
|
||||
if ((size_t)(p - io1_w) < (size_t)(distance)) {
|
||||
if ((size_t)(p - io0_w) < (size_t)(distance)) {
|
||||
return 0;
|
||||
}
|
||||
uint8_t* q = p - distance;
|
||||
@@ -10552,10 +11085,10 @@ wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
|
||||
// The caller needs to prove that:
|
||||
// - length <= (io2_w - *ptr_iop_w)
|
||||
// - distance >= 1
|
||||
// - distance <= (*ptr_iop_w - io1_w)
|
||||
// - distance <= (*ptr_iop_w - io0_w)
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -10587,11 +11120,11 @@ wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,
|
||||
// The caller needs to prove that:
|
||||
// - (length + 8) <= (io2_w - *ptr_iop_w)
|
||||
// - distance == 1
|
||||
// - distance <= (*ptr_iop_w - io1_w)
|
||||
// - distance <= (*ptr_iop_w - io0_w)
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
|
||||
uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -10627,11 +11160,11 @@ wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fa
|
||||
// The caller needs to prove that:
|
||||
// - (length + 8) <= (io2_w - *ptr_iop_w)
|
||||
// - distance >= 8
|
||||
// - distance <= (*ptr_iop_w - io1_w)
|
||||
// - distance <= (*ptr_iop_w - io0_w)
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(
|
||||
uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -10701,11 +11234,12 @@ wuffs_base__io_writer__set(wuffs_base__io_buffer* b,
|
||||
uint8_t** ptr_io0_w,
|
||||
uint8_t** ptr_io1_w,
|
||||
uint8_t** ptr_io2_w,
|
||||
wuffs_base__slice_u8 data) {
|
||||
wuffs_base__slice_u8 data,
|
||||
uint64_t history_position) {
|
||||
b->data = data;
|
||||
b->meta.wi = 0;
|
||||
b->meta.ri = 0;
|
||||
b->meta.pos = 0;
|
||||
b->meta.pos = history_position;
|
||||
b->meta.closed = false;
|
||||
|
||||
*ptr_iop_w = data.ptr;
|
||||
@@ -12358,14 +12892,14 @@ wuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f) {
|
||||
// padded with implicit zeroes.
|
||||
//
|
||||
// For example, if num_digits is 3 and digits is "\x07\x08\x09":
|
||||
// - A decimal_point of -2 means ".00789"
|
||||
// - A decimal_point of -1 means ".0789"
|
||||
// - A decimal_point of +0 means ".789"
|
||||
// - A decimal_point of +1 means "7.89"
|
||||
// - A decimal_point of +2 means "78.9"
|
||||
// - A decimal_point of +3 means "789."
|
||||
// - A decimal_point of +4 means "7890."
|
||||
// - A decimal_point of +5 means "78900."
|
||||
// - A decimal_point of -2 means ".00789"
|
||||
// - A decimal_point of -1 means ".0789"
|
||||
// - A decimal_point of +0 means ".789"
|
||||
// - A decimal_point of +1 means "7.89"
|
||||
// - A decimal_point of +2 means "78.9"
|
||||
// - A decimal_point of +3 means "789."
|
||||
// - A decimal_point of +4 means "7890."
|
||||
// - A decimal_point of +5 means "78900."
|
||||
//
|
||||
// As above, a decimal_point higher than +2047 means that the overall value is
|
||||
// infinity, lower than -2047 means zero.
|
||||
@@ -12710,10 +13244,10 @@ wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(
|
||||
// wuffs_base__private_implementation__high_prec_dec__rounded_integer returns
|
||||
// the integral (non-fractional) part of h, provided that it is 18 or fewer
|
||||
// decimal digits. For 19 or more digits, it returns UINT64_MAX. Note that:
|
||||
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
|
||||
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
|
||||
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
|
||||
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
|
||||
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
|
||||
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
|
||||
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
|
||||
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
|
||||
// and that IEEE 754 double precision has 52 mantissa bits.
|
||||
//
|
||||
// That integral part is rounded-to-even: rounding 7.5 or 8.5 both give 8.
|
||||
@@ -14270,13 +14804,18 @@ wuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options) {
|
||||
ret.value = 0;
|
||||
return ret;
|
||||
} else if (negative) {
|
||||
if (r.value > 0x8000000000000000) {
|
||||
goto fail_out_of_bounds;
|
||||
if (r.value < 0x8000000000000000) {
|
||||
wuffs_base__result_i64 ret;
|
||||
ret.status.repr = NULL;
|
||||
ret.value = -(int64_t)(r.value);
|
||||
return ret;
|
||||
} else if (r.value == 0x8000000000000000) {
|
||||
wuffs_base__result_i64 ret;
|
||||
ret.status.repr = NULL;
|
||||
ret.value = INT64_MIN;
|
||||
return ret;
|
||||
}
|
||||
wuffs_base__result_i64 ret;
|
||||
ret.status.repr = NULL;
|
||||
ret.value = -(int64_t)(r.value);
|
||||
return ret;
|
||||
goto fail_out_of_bounds;
|
||||
} else if (r.value > 0x7FFFFFFFFFFFFFFF) {
|
||||
goto fail_out_of_bounds;
|
||||
} else {
|
||||
@@ -15041,19 +15580,23 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
|
||||
//
|
||||
// Keep it sorted by magic[1], then magic[0] descending and finally by
|
||||
// magic[2:]. When multiple entries match, the longest one wins.
|
||||
//
|
||||
// The fourcc field might be negated, in which case there's further
|
||||
// specialization (see § below).
|
||||
static struct {
|
||||
int32_t fourcc;
|
||||
const char* magic;
|
||||
} table[] = {
|
||||
{0x57424D50, "\x01\x00\x00"}, // WBMP
|
||||
{0x424D5020, "\x01\x42\x4D"}, // BMP
|
||||
{0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
|
||||
{0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
|
||||
{0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
|
||||
{0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF (see § below)
|
||||
{0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
|
||||
{0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
|
||||
{0x4A504547, "\x01\xFF\xD8"}, // JPEG
|
||||
{-0x30302020, "\x01\x00\x00"}, // '00 'be
|
||||
{+0x424D5020, "\x01\x42\x4D"}, // BMP
|
||||
{+0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
|
||||
{+0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
|
||||
{+0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
|
||||
{-0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF
|
||||
{+0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
|
||||
{+0x514F4920, "\x03\x71\x6F\x69\x66"}, // QOI
|
||||
{+0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
|
||||
{+0x4A504547, "\x01\xFF\xD8"}, // JPEG
|
||||
};
|
||||
static const size_t table_len = sizeof(table) / sizeof(table[0]);
|
||||
|
||||
@@ -15094,19 +15637,33 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
|
||||
return 0;
|
||||
|
||||
match:
|
||||
// Some FourCC values (see § above) are further specialized.
|
||||
if (fourcc == 0x52494646) { // 'RIFF'be
|
||||
if (prefix.len < 16) {
|
||||
return -1;
|
||||
}
|
||||
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
|
||||
if (x == 0x57454250) { // 'WEBP'be
|
||||
uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);
|
||||
if (y == 0x56503820) { // 'VP8 'be
|
||||
return 0x57503820; // 'WP8 'be
|
||||
} else if (y == 0x5650384C) { // 'VP8L'be
|
||||
return 0x5750384C; // 'WP8L'be
|
||||
// Negative FourCC values (see § above) are further specialized.
|
||||
if (fourcc < 0) {
|
||||
fourcc = -fourcc;
|
||||
|
||||
if (fourcc == 0x52494646) { // 'RIFF'be
|
||||
if (prefix.len < 12) {
|
||||
return -1;
|
||||
}
|
||||
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
|
||||
if (x == 0x57454250) { // 'WEBP'be
|
||||
return 0x57454250; // 'WEBP'be
|
||||
}
|
||||
|
||||
} else if (fourcc == 0x30302020) { // '00 'be
|
||||
// Binary data starting with multiple 0x00 NUL bytes is quite common.
|
||||
if (prefix.len < 4) {
|
||||
return -1;
|
||||
} else if ((prefix.ptr[2] != 0x00) &&
|
||||
((prefix.ptr[2] >= 0x80) || (prefix.ptr[3] != 0x00))) {
|
||||
// Roughly speaking, this could be a non-degenerate (non-0-width and
|
||||
// non-0-height) WBMP image.
|
||||
return 0x57424D50; // 'WBMP'be
|
||||
} else if (((prefix.ptr[2] == 0x01) || (prefix.ptr[2] == 0x02)) &&
|
||||
(prefix.ptr[3] == 0x00)) {
|
||||
return 0x49434F20; // 'ICO 'be
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return fourcc;
|
||||
@@ -15608,14 +16165,23 @@ static inline uint32_t //
|
||||
wuffs_base__composite_nonpremul_nonpremul_u32_axxx(uint32_t dst_nonpremul,
|
||||
uint32_t src_nonpremul) {
|
||||
// Extract 16-bit color components.
|
||||
//
|
||||
// If the destination is transparent then SRC_OVER is equivalent to SRC: just
|
||||
// return src_nonpremul. This isn't just an optimization (skipping the rest
|
||||
// of the function's computation). It also preserves the nonpremul
|
||||
// distinction between e.g. transparent red and transparent blue that would
|
||||
// otherwise be lost by converting from nonpremul to premul and back.
|
||||
uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
|
||||
if (da == 0) {
|
||||
return src_nonpremul;
|
||||
}
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -15652,14 +16218,23 @@ static inline uint64_t //
|
||||
wuffs_base__composite_nonpremul_nonpremul_u64_axxx(uint64_t dst_nonpremul,
|
||||
uint64_t src_nonpremul) {
|
||||
// Extract components.
|
||||
//
|
||||
// If the destination is transparent then SRC_OVER is equivalent to SRC: just
|
||||
// return src_nonpremul. This isn't just an optimization (skipping the rest
|
||||
// of the function's computation). It also preserves the nonpremul
|
||||
// distinction between e.g. transparent red and transparent blue that would
|
||||
// otherwise be lost by converting from nonpremul to premul and back.
|
||||
uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
|
||||
if (da == 0) {
|
||||
return src_nonpremul;
|
||||
}
|
||||
uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
|
||||
uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
|
||||
uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
|
||||
uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -15690,14 +16265,14 @@ static inline uint32_t //
|
||||
wuffs_base__composite_nonpremul_premul_u32_axxx(uint32_t dst_nonpremul,
|
||||
uint32_t src_premul) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -15734,14 +16309,14 @@ static inline uint64_t //
|
||||
wuffs_base__composite_nonpremul_premul_u64_axxx(uint64_t dst_nonpremul,
|
||||
uint64_t src_premul) {
|
||||
// Extract components.
|
||||
uint64_t sa = 0xFFFF & (src_premul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_premul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_premul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_premul >> 0);
|
||||
uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
|
||||
uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
|
||||
uint64_t sa = 0xFFFF & (src_premul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_premul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_premul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_premul >> 0);
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -15772,14 +16347,14 @@ static inline uint32_t //
|
||||
wuffs_base__composite_premul_nonpremul_u32_axxx(uint32_t dst_premul,
|
||||
uint32_t src_nonpremul) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -15804,14 +16379,14 @@ static inline uint64_t //
|
||||
wuffs_base__composite_premul_nonpremul_u64_axxx(uint64_t dst_premul,
|
||||
uint64_t src_nonpremul) {
|
||||
// Extract components.
|
||||
uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
|
||||
uint64_t da = 0xFFFF & (dst_premul >> 48);
|
||||
uint64_t dr = 0xFFFF & (dst_premul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_premul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_premul >> 0);
|
||||
uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint64_t ia = 0xFFFF - sa;
|
||||
@@ -15830,14 +16405,14 @@ static inline uint32_t //
|
||||
wuffs_base__composite_premul_premul_u32_axxx(uint32_t dst_premul,
|
||||
uint32_t src_premul) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -15917,7 +16492,7 @@ wuffs_base__pixel_swizzler__swap_rgb_bgr(uint8_t* dst_ptr,
|
||||
}
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
|
||||
@@ -15961,7 +16536,7 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
|
||||
}
|
||||
return len;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
static uint64_t //
|
||||
@@ -16897,13 +17472,13 @@ wuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src_over(
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -16945,13 +17520,13 @@ wuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src_over(
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
|
||||
uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
|
||||
uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
|
||||
uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -17020,13 +17595,13 @@ wuffs_base__pixel_swizzler__bgr__bgra_premul__src_over(uint8_t* dst_ptr,
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -17098,13 +17673,13 @@ wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src_over(
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -17173,13 +17748,13 @@ wuffs_base__pixel_swizzler__bgr__rgba_premul__src_over(uint8_t* dst_ptr,
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -18240,7 +18815,7 @@ wuffs_base__pixel_swizzler__bgrw__bgrx(uint8_t* dst_ptr,
|
||||
}
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
|
||||
@@ -18293,7 +18868,7 @@ wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
|
||||
|
||||
return len;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
static uint64_t //
|
||||
@@ -18952,7 +19527,7 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(
|
||||
}
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
|
||||
@@ -18999,7 +19574,7 @@ wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
|
||||
|
||||
return len;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
static uint64_t //
|
||||
@@ -19287,7 +19862,7 @@ wuffs_base__pixel_swizzler__prepare__y(wuffs_base__pixel_swizzler* p,
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__xxxx__y__sse42;
|
||||
}
|
||||
@@ -19670,7 +20245,7 @@ wuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
|
||||
}
|
||||
@@ -19745,7 +20320,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -19926,7 +20501,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_premul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -19994,7 +20569,7 @@ wuffs_base__pixel_swizzler__prepare__rgb(wuffs_base__pixel_swizzler* p,
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
|
||||
}
|
||||
@@ -20045,7 +20620,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -20156,7 +20731,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_premul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -20639,12 +21214,12 @@ wuffs_adler32__hasher__up_arm_neon(
|
||||
wuffs_base__slice_u8 a_x);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_adler32__hasher__up_x86_sse42(
|
||||
wuffs_adler32__hasher* self,
|
||||
wuffs_base__slice_u8 a_x);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
// ---------------- VTables
|
||||
|
||||
@@ -20760,7 +21335,7 @@ wuffs_adler32__hasher__update_u32(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_adler32__hasher__up_arm_neon :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_adler32__hasher__up_x86_sse42 :
|
||||
#endif
|
||||
self->private_impl.choosy_up);
|
||||
@@ -20952,7 +21527,7 @@ wuffs_adler32__hasher__up_arm_neon(
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func adler32.hasher.up_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_adler32__hasher__up_x86_sse42(
|
||||
@@ -21038,7 +21613,7 @@ wuffs_adler32__hasher__up_x86_sse42(
|
||||
self->private_impl.f_state = (((v_s2 & 65535) << 16) | (v_s1 & 65535));
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ADLER32)
|
||||
@@ -21369,7 +21944,7 @@ wuffs_bmp__decoder__decode_image_config(
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_padding -= 14;
|
||||
self->private_impl.f_io_redirect_pos = wuffs_base__u64__sat_add(((uint64_t)(self->private_impl.f_padding)), wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))));
|
||||
self->private_impl.f_io_redirect_pos = wuffs_base__u64__sat_add(((uint64_t)(self->private_impl.f_padding)), wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))));
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
uint32_t t_2;
|
||||
@@ -22118,7 +22693,7 @@ wuffs_bmp__decoder__decode_image_config(
|
||||
} else if (self->private_impl.f_bits_per_pixel == 32) {
|
||||
self->private_impl.f_pad_per_row = 0;
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
if (a_dst != NULL) {
|
||||
v_dst_pixfmt = 2164295816;
|
||||
if ((self->private_impl.f_channel_num_bits[0] > 8) ||
|
||||
@@ -22216,7 +22791,7 @@ wuffs_bmp__decoder__decode_frame_config(
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 3) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
}
|
||||
@@ -22521,7 +23096,7 @@ wuffs_bmp__decoder__swizzle_none(
|
||||
goto label__outer__continue;
|
||||
}
|
||||
}
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -22606,7 +23181,7 @@ wuffs_bmp__decoder__swizzle_rle(
|
||||
v_rle_state = self->private_impl.f_rle_state;
|
||||
label__outer__continue:;
|
||||
while (true) {
|
||||
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
|
||||
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -22766,7 +23341,7 @@ wuffs_bmp__decoder__swizzle_rle(
|
||||
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
|
||||
goto exit;
|
||||
}
|
||||
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
|
||||
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -22798,7 +23373,7 @@ wuffs_bmp__decoder__swizzle_rle(
|
||||
}
|
||||
label__outer__break:;
|
||||
while (self->private_impl.f_dst_y < self->private_impl.f_height) {
|
||||
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
|
||||
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -22928,7 +23503,7 @@ wuffs_bmp__decoder__swizzle_bitfields(
|
||||
v_p0 += 1;
|
||||
}
|
||||
label__0__break:;
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -23010,7 +23585,7 @@ wuffs_bmp__decoder__swizzle_low_bit_depth(
|
||||
goto label__loop__break;
|
||||
}
|
||||
}
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -24818,19 +25393,19 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
|
||||
wuffs_base__slice_u8 a_x);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_crc32__ieee_hasher__up_x86_avx2(
|
||||
wuffs_crc32__ieee_hasher* self,
|
||||
wuffs_base__slice_u8 a_x);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_crc32__ieee_hasher__up_x86_sse42(
|
||||
wuffs_crc32__ieee_hasher* self,
|
||||
wuffs_base__slice_u8 a_x);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
// ---------------- VTables
|
||||
|
||||
@@ -24944,10 +25519,10 @@ wuffs_crc32__ieee_hasher__update_u32(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
|
||||
wuffs_base__cpu_arch__have_arm_crc32() ? &wuffs_crc32__ieee_hasher__up_arm_crc32 :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_avx2() ? &wuffs_crc32__ieee_hasher__up_x86_avx2 :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_crc32__ieee_hasher__up_x86_sse42 :
|
||||
#endif
|
||||
self->private_impl.choosy_up);
|
||||
@@ -25137,7 +25712,7 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
|
||||
// -------- func crc32.ieee_hasher.up_x86_avx2
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_crc32__ieee_hasher__up_x86_avx2(
|
||||
@@ -25250,13 +25825,13 @@ wuffs_crc32__ieee_hasher__up_x86_avx2(
|
||||
self->private_impl.f_state = (4294967295 ^ v_s);
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func crc32.ieee_hasher.up_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_crc32__ieee_hasher__up_x86_sse42(
|
||||
@@ -25369,7 +25944,7 @@ wuffs_crc32__ieee_hasher__up_x86_sse42(
|
||||
self->private_impl.f_state = (4294967295 ^ v_s);
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__CRC32)
|
||||
@@ -25494,13 +26069,13 @@ wuffs_deflate__decoder__init_huff(
|
||||
uint32_t a_n_codes1,
|
||||
uint32_t a_base_symbol);
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__status
|
||||
wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
wuffs_deflate__decoder* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_deflate__decoder__decode_huffman_fast32(
|
||||
@@ -25730,7 +26305,7 @@ wuffs_deflate__decoder__transform_io(
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
self->private_impl.choosy_decode_huffman_fast64 = (
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_bmi2() ? &wuffs_deflate__decoder__decode_huffman_bmi2 :
|
||||
#endif
|
||||
self->private_impl.choosy_decode_huffman_fast64);
|
||||
@@ -25756,6 +26331,7 @@ wuffs_deflate__decoder__transform_io(
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_transformed_history_count, wuffs_base__io__count_since(v_mark, ((uint64_t)(iop_a_dst - io0_a_dst))));
|
||||
wuffs_deflate__decoder__add_history(self, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_dst - io0_a_dst)), io0_a_dst));
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
@@ -26432,14 +27008,17 @@ wuffs_deflate__decoder__init_huff(
|
||||
v_i += 1;
|
||||
}
|
||||
if (v_remaining != 0) {
|
||||
if ((a_which == 1) &&
|
||||
(v_counts[1] == 1) &&
|
||||
(self->private_data.f_code_lengths[a_n_codes0] == 1) &&
|
||||
((((uint32_t)(v_counts[0])) + a_n_codes0 + 1) == a_n_codes1)) {
|
||||
self->private_impl.f_n_huffs_bits[1] = 1;
|
||||
self->private_data.f_huffs[1][0] = (WUFFS_DEFLATE__DCODE_MAGIC_NUMBERS[0] | 1);
|
||||
self->private_data.f_huffs[1][1] = (WUFFS_DEFLATE__DCODE_MAGIC_NUMBERS[31] | 1);
|
||||
return wuffs_base__make_status(NULL);
|
||||
if ((a_which == 1) && (v_counts[1] == 1) && ((((uint32_t)(v_counts[0])) + a_n_codes0 + 1) == a_n_codes1)) {
|
||||
v_i = 0;
|
||||
while (v_i <= 29) {
|
||||
if (self->private_data.f_code_lengths[(a_n_codes0 + v_i)] == 1) {
|
||||
self->private_impl.f_n_huffs_bits[1] = 1;
|
||||
self->private_data.f_huffs[1][0] = (WUFFS_DEFLATE__DCODE_MAGIC_NUMBERS[v_i] | 1);
|
||||
self->private_data.f_huffs[1][1] = (WUFFS_DEFLATE__DCODE_MAGIC_NUMBERS[31] | 1);
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
v_i += 1;
|
||||
}
|
||||
}
|
||||
return wuffs_base__make_status(wuffs_deflate__error__bad_huffman_code_under_subscribed);
|
||||
}
|
||||
@@ -26622,7 +27201,7 @@ wuffs_deflate__decoder__init_huff(
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_bmi2
|
||||
// -------- func deflate.decoder.decode_huffman_bmi2
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("bmi2")
|
||||
static wuffs_base__status
|
||||
wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
@@ -26643,6 +27222,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
uint32_t v_dist_minus_1 = 0;
|
||||
uint32_t v_hlen = 0;
|
||||
uint32_t v_hdist = 0;
|
||||
uint32_t v_hdist_adjustment = 0;
|
||||
|
||||
uint8_t* iop_a_dst = NULL;
|
||||
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -26676,6 +27256,11 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
v_n_bits = self->private_impl.f_n_bits;
|
||||
v_lmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
|
||||
v_dmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
|
||||
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
|
||||
label__loop__continue:;
|
||||
while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 266) && (((uint64_t)(io2_a_src - iop_a_src)) >= 8)) {
|
||||
v_bits |= ((uint64_t)(wuffs_base__peek_u64le__no_bounds_check(iop_a_src) << (v_n_bits & 63)));
|
||||
@@ -26766,13 +27351,13 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
v_hlen = v_length;
|
||||
v_length = 0;
|
||||
}
|
||||
v_hdist += v_hdist_adjustment;
|
||||
if (self->private_impl.f_history_index < v_hdist) {
|
||||
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist = (self->private_impl.f_history_index - v_hdist);
|
||||
wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), (v_hdist & 32767)));
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
|
||||
if (v_length == 0) {
|
||||
goto label__loop__continue;
|
||||
}
|
||||
@@ -26826,7 +27411,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
|
||||
return status;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_bmi2
|
||||
|
||||
// -------- func deflate.decoder.decode_huffman_fast32
|
||||
@@ -26850,6 +27435,7 @@ wuffs_deflate__decoder__decode_huffman_fast32(
|
||||
uint32_t v_dist_minus_1 = 0;
|
||||
uint32_t v_hlen = 0;
|
||||
uint32_t v_hdist = 0;
|
||||
uint32_t v_hdist_adjustment = 0;
|
||||
|
||||
uint8_t* iop_a_dst = NULL;
|
||||
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -26883,6 +27469,11 @@ wuffs_deflate__decoder__decode_huffman_fast32(
|
||||
v_n_bits = self->private_impl.f_n_bits;
|
||||
v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
|
||||
v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
|
||||
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
|
||||
label__loop__continue:;
|
||||
while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 266) && (((uint64_t)(io2_a_src - iop_a_src)) >= 12)) {
|
||||
if (v_n_bits < 15) {
|
||||
@@ -27025,13 +27616,13 @@ wuffs_deflate__decoder__decode_huffman_fast32(
|
||||
v_hlen = v_length;
|
||||
v_length = 0;
|
||||
}
|
||||
v_hdist += v_hdist_adjustment;
|
||||
if (self->private_impl.f_history_index < v_hdist) {
|
||||
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist = (self->private_impl.f_history_index - v_hdist);
|
||||
wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), (v_hdist & 32767)));
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
|
||||
if (v_length == 0) {
|
||||
goto label__loop__continue;
|
||||
}
|
||||
@@ -27108,6 +27699,7 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
|
||||
uint32_t v_dist_minus_1 = 0;
|
||||
uint32_t v_hlen = 0;
|
||||
uint32_t v_hdist = 0;
|
||||
uint32_t v_hdist_adjustment = 0;
|
||||
|
||||
uint8_t* iop_a_dst = NULL;
|
||||
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -27141,6 +27733,11 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
|
||||
v_n_bits = self->private_impl.f_n_bits;
|
||||
v_lmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
|
||||
v_dmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
|
||||
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
|
||||
label__loop__continue:;
|
||||
while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 266) && (((uint64_t)(io2_a_src - iop_a_src)) >= 8)) {
|
||||
v_bits |= ((uint64_t)(wuffs_base__peek_u64le__no_bounds_check(iop_a_src) << (v_n_bits & 63)));
|
||||
@@ -27231,13 +27828,13 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
|
||||
v_hlen = v_length;
|
||||
v_length = 0;
|
||||
}
|
||||
v_hdist += v_hdist_adjustment;
|
||||
if (self->private_impl.f_history_index < v_hdist) {
|
||||
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist = (self->private_impl.f_history_index - v_hdist);
|
||||
wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), (v_hdist & 32767)));
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
|
||||
if (v_length == 0) {
|
||||
goto label__loop__continue;
|
||||
}
|
||||
@@ -27358,7 +27955,6 @@ wuffs_deflate__decoder__decode_huffman_slow(
|
||||
v_length = self->private_data.s_decode_huffman_slow[0].v_length;
|
||||
v_dist_minus_1 = self->private_data.s_decode_huffman_slow[0].v_dist_minus_1;
|
||||
v_hlen = self->private_data.s_decode_huffman_slow[0].v_hlen;
|
||||
v_hdist = self->private_data.s_decode_huffman_slow[0].v_hdist;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
@@ -27555,54 +28151,29 @@ wuffs_deflate__decoder__decode_huffman_slow(
|
||||
v_bits >>= v_table_entry_n_bits;
|
||||
v_n_bits -= v_table_entry_n_bits;
|
||||
}
|
||||
label__inner__continue:;
|
||||
while (true) {
|
||||
if (((uint64_t)((v_dist_minus_1 + 1))) > ((uint64_t)(iop_a_dst - io0_a_dst))) {
|
||||
v_hdist = ((uint32_t)((((uint64_t)((v_dist_minus_1 + 1))) - ((uint64_t)(iop_a_dst - io0_a_dst)))));
|
||||
if (v_length > v_hdist) {
|
||||
v_length -= v_hdist;
|
||||
if (v_hdist < v_length) {
|
||||
v_hlen = v_hdist;
|
||||
} else {
|
||||
v_hlen = v_length;
|
||||
v_length = 0;
|
||||
}
|
||||
v_hdist += ((uint32_t)((((uint64_t)(self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0))) & 4294967295)));
|
||||
if (self->private_impl.f_history_index < v_hdist) {
|
||||
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist = (self->private_impl.f_history_index - v_hdist);
|
||||
while (true) {
|
||||
v_n_copied = wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 32768), (v_hdist & 32767)));
|
||||
if (v_hlen <= v_n_copied) {
|
||||
v_hlen = 0;
|
||||
goto label__4__break;
|
||||
}
|
||||
if (v_n_copied > 0) {
|
||||
v_hlen -= v_n_copied;
|
||||
v_hdist = (((uint32_t)(v_hdist + v_n_copied)) & 32767);
|
||||
if (v_hdist == 0) {
|
||||
goto label__4__break;
|
||||
}
|
||||
}
|
||||
v_n_copied = wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
|
||||
if (v_n_copied < v_hlen) {
|
||||
v_length -= v_n_copied;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
|
||||
goto label__inner__continue;
|
||||
}
|
||||
label__4__break:;
|
||||
if (v_hlen > 0) {
|
||||
while (true) {
|
||||
v_n_copied = wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 32768), (v_hdist & 32767)));
|
||||
if (v_hlen <= v_n_copied) {
|
||||
v_hlen = 0;
|
||||
goto label__5__break;
|
||||
}
|
||||
v_hlen -= v_n_copied;
|
||||
v_hdist += v_n_copied;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
|
||||
}
|
||||
label__5__break:;
|
||||
}
|
||||
v_length -= v_hlen;
|
||||
if (v_length == 0) {
|
||||
goto label__loop__continue;
|
||||
}
|
||||
@@ -27610,14 +28181,12 @@ wuffs_deflate__decoder__decode_huffman_slow(
|
||||
v_n_copied = wuffs_base__io_writer__limited_copy_u32_from_history(
|
||||
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
|
||||
if (v_length <= v_n_copied) {
|
||||
v_length = 0;
|
||||
goto label__6__break;
|
||||
goto label__loop__continue;
|
||||
}
|
||||
v_length -= v_n_copied;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
|
||||
}
|
||||
label__6__break:;
|
||||
}
|
||||
label__loop__break:;
|
||||
self->private_impl.f_bits = v_bits;
|
||||
@@ -27646,7 +28215,6 @@ wuffs_deflate__decoder__decode_huffman_slow(
|
||||
self->private_data.s_decode_huffman_slow[0].v_length = v_length;
|
||||
self->private_data.s_decode_huffman_slow[0].v_dist_minus_1 = v_dist_minus_1;
|
||||
self->private_data.s_decode_huffman_slow[0].v_hlen = v_hlen;
|
||||
self->private_data.s_decode_huffman_slow[0].v_hdist = v_hdist;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
@@ -28630,7 +29198,7 @@ wuffs_gif__decoder__tell_me_more(
|
||||
while (true) {
|
||||
label__0__continue:;
|
||||
while (true) {
|
||||
if (wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_io_position) {
|
||||
if (wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_io_position) {
|
||||
if (a_minfo != NULL) {
|
||||
wuffs_base__more_information__set(a_minfo,
|
||||
2,
|
||||
@@ -28669,13 +29237,13 @@ wuffs_gif__decoder__tell_me_more(
|
||||
} else {
|
||||
iop_a_src += 1;
|
||||
}
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))), v_chunk_length);
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))), v_chunk_length);
|
||||
if (a_minfo != NULL) {
|
||||
wuffs_base__more_information__set(a_minfo,
|
||||
3,
|
||||
self->private_impl.f_metadata_fourcc,
|
||||
0,
|
||||
wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))),
|
||||
wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))),
|
||||
self->private_impl.f_metadata_io_position);
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__even_more_information);
|
||||
@@ -28731,10 +29299,13 @@ wuffs_gif__decoder__num_animation_loops(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (self->private_impl.f_seen_num_loops) {
|
||||
return self->private_impl.f_num_loops;
|
||||
if (self->private_impl.f_seen_num_animation_loops_value) {
|
||||
return self->private_impl.f_num_animation_loops_value;
|
||||
}
|
||||
return 1;
|
||||
if (self->private_impl.f_num_decoded_frame_configs_value > 1) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// -------- func gif.decoder.num_decoded_frame_configs
|
||||
@@ -29201,9 +29772,9 @@ wuffs_gif__decoder__decode_up_to_id_part1(
|
||||
|
||||
if ( ! self->private_impl.f_restarted) {
|
||||
if (self->private_impl.f_call_sequence != 2) {
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
}
|
||||
} else if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
} else if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
} else {
|
||||
@@ -29879,22 +30450,22 @@ wuffs_gif__decoder__decode_ae(
|
||||
*scratch |= ((uint64_t)(num_bits_4)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_num_loops = t_4;
|
||||
self->private_impl.f_num_animation_loops_value = t_4;
|
||||
}
|
||||
self->private_impl.f_seen_num_loops = true;
|
||||
if ((0 < self->private_impl.f_num_loops) && (self->private_impl.f_num_loops <= 65535)) {
|
||||
self->private_impl.f_num_loops += 1;
|
||||
self->private_impl.f_seen_num_animation_loops_value = true;
|
||||
if ((0 < self->private_impl.f_num_animation_loops_value) && (self->private_impl.f_num_animation_loops_value <= 65535)) {
|
||||
self->private_impl.f_num_animation_loops_value += 1;
|
||||
}
|
||||
} else if (self->private_impl.f_ignore_metadata) {
|
||||
} else if (v_is_iccp && self->private_impl.f_report_metadata_iccp) {
|
||||
self->private_impl.f_metadata_fourcc = 1229144912;
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_call_sequence = 1;
|
||||
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
|
||||
goto ok;
|
||||
} else if (v_is_xmp && self->private_impl.f_report_metadata_xmp) {
|
||||
self->private_impl.f_metadata_fourcc = 1481461792;
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_call_sequence = 1;
|
||||
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
|
||||
goto ok;
|
||||
@@ -30365,7 +30936,8 @@ wuffs_gif__decoder__decode_id_part1(
|
||||
goto ok;
|
||||
}
|
||||
if (self->private_impl.f_previous_lzw_decode_ended_abruptly) {
|
||||
wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(&self->private_data.f_lzw, sizeof (wuffs_lzw__decoder), WUFFS_VERSION, 0));
|
||||
wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(&self->private_data.f_lzw,
|
||||
sizeof (wuffs_lzw__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
@@ -30518,7 +31090,8 @@ wuffs_gif__decoder__decode_id_part2(
|
||||
wuffs_base__slice_u8__subslice_ij(wuffs_base__make_slice_u8(self->private_data.f_compressed,
|
||||
4096),
|
||||
self->private_impl.f_compressed_ri,
|
||||
self->private_impl.f_compressed_wi));
|
||||
self->private_impl.f_compressed_wi),
|
||||
0);
|
||||
v_mark = ((uint64_t)(iop_v_r - io0_v_r));
|
||||
{
|
||||
u_r.meta.ri = ((size_t)(iop_v_r - u_r.data.ptr));
|
||||
@@ -30570,6 +31143,30 @@ wuffs_gif__decoder__decode_id_part2(
|
||||
goto label__outer__continue;
|
||||
} else if (v_lzw_status.repr == wuffs_base__suspension__short_write) {
|
||||
goto label__inner__continue;
|
||||
} else if (self->private_impl.f_quirks[3] && (self->private_impl.f_dst_y >= self->private_impl.f_frame_rect_y1) && (self->private_impl.f_interlace == 0)) {
|
||||
if (v_need_block_size || (v_block_size > 0)) {
|
||||
self->private_data.s_decode_id_part2[0].scratch = ((uint32_t)(v_block_size));
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
if (self->private_data.s_decode_id_part2[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_id_part2[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_decode_id_part2[0].scratch;
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
status = wuffs_gif__decoder__skip_blocks(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
}
|
||||
goto label__outer__break;
|
||||
}
|
||||
status = v_lzw_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
@@ -30650,7 +31247,7 @@ wuffs_gif__decoder__copy_to_image_buffer(
|
||||
}
|
||||
return wuffs_base__make_status(wuffs_base__error__too_much_data);
|
||||
}
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (self->private_impl.f_dst_y >= self->private_impl.f_height) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, 0);
|
||||
} else if (v_width_in_bytes < ((uint64_t)(v_dst.len))) {
|
||||
@@ -30676,12 +31273,12 @@ wuffs_gif__decoder__copy_to_image_buffer(
|
||||
goto label__0__continue;
|
||||
}
|
||||
if ((self->private_impl.f_num_decoded_frames_value == 0) && ! self->private_impl.f_gc_has_transparent_index && (self->private_impl.f_interlace > 1)) {
|
||||
v_replicate_src = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_replicate_src = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
v_replicate_y0 = wuffs_base__u32__sat_add(self->private_impl.f_dst_y, 1);
|
||||
v_replicate_y1 = wuffs_base__u32__sat_add(self->private_impl.f_dst_y, ((uint32_t)(WUFFS_GIF__INTERLACE_COUNT[self->private_impl.f_interlace])));
|
||||
v_replicate_y1 = wuffs_base__u32__min(v_replicate_y1, self->private_impl.f_frame_rect_y1);
|
||||
while (v_replicate_y0 < v_replicate_y1) {
|
||||
v_replicate_dst = wuffs_base__table_u8__row(v_tab, v_replicate_y0);
|
||||
v_replicate_dst = wuffs_base__table_u8__row_u32(v_tab, v_replicate_y0);
|
||||
wuffs_base__slice_u8__copy_from_slice(v_replicate_dst, v_replicate_src);
|
||||
v_replicate_y0 += 1;
|
||||
}
|
||||
@@ -33096,16 +33693,19 @@ wuffs_json__decoder__decode_comment(
|
||||
}
|
||||
while (true) {
|
||||
if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
|
||||
if (v_length > 0) {
|
||||
if (a_src && a_src->meta.closed) {
|
||||
*iop_a_dst++ = wuffs_base__make_token(
|
||||
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
|
||||
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
|
||||
self->private_impl.f_comment_type = 2;
|
||||
status = wuffs_base__make_status(NULL);
|
||||
goto ok;
|
||||
} else if (v_length > 0) {
|
||||
*iop_a_dst++ = wuffs_base__make_token(
|
||||
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
|
||||
(((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) |
|
||||
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
|
||||
}
|
||||
if (a_src && a_src->meta.closed) {
|
||||
status = wuffs_base__make_status(wuffs_json__error__bad_input);
|
||||
goto exit;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
|
||||
v_length = 0;
|
||||
@@ -33113,10 +33713,9 @@ wuffs_json__decoder__decode_comment(
|
||||
}
|
||||
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
|
||||
if (v_c == 10) {
|
||||
iop_a_src += 1;
|
||||
*iop_a_dst++ = wuffs_base__make_token(
|
||||
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
|
||||
(((uint64_t)((v_length + 1))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
|
||||
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
|
||||
self->private_impl.f_comment_type = 2;
|
||||
status = wuffs_base__make_status(NULL);
|
||||
goto ok;
|
||||
@@ -33884,7 +34483,7 @@ wuffs_nie__decoder__decode_frame_config(
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 3) {
|
||||
if (16 != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
if (16 != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
}
|
||||
@@ -34087,7 +34686,7 @@ wuffs_nie__decoder__swizzle(
|
||||
goto label__0__break;
|
||||
}
|
||||
}
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -34305,6 +34904,10 @@ const char wuffs_zlib__error__incorrect_dictionary[] = "#zlib: incorrect diction
|
||||
|
||||
// ---------------- Private Consts
|
||||
|
||||
#define WUFFS_ZLIB__QUIRKS_BASE 2113790976
|
||||
|
||||
#define WUFFS_ZLIB__QUIRKS_COUNT 1
|
||||
|
||||
// ---------------- Private Initializer Prototypes
|
||||
|
||||
// ---------------- Private Function Prototypes
|
||||
@@ -34468,8 +35071,15 @@ wuffs_zlib__decoder__set_quirk_enabled(
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
if (a_quirk == 1) {
|
||||
if (self->private_impl.f_header_complete) {
|
||||
self->private_impl.f_bad_call_sequence = true;
|
||||
} else if (a_quirk == 1) {
|
||||
self->private_impl.f_ignore_checksum = a_enabled;
|
||||
} else if (a_quirk >= 2113790976) {
|
||||
a_quirk -= 2113790976;
|
||||
if (a_quirk < 1) {
|
||||
self->private_impl.f_quirks[a_quirk] = a_enabled;
|
||||
}
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
@@ -34559,6 +35169,7 @@ wuffs_zlib__decoder__transform_io(
|
||||
if (self->private_impl.f_bad_call_sequence) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_quirks[0]) {
|
||||
} else if ( ! self->private_impl.f_want_dictionary) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
@@ -34666,7 +35277,7 @@ wuffs_zlib__decoder__transform_io(
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
if ( ! self->private_impl.f_ignore_checksum && ! self->private_impl.f_quirks[0]) {
|
||||
v_checksum_got = wuffs_adler32__hasher__update_u32(&self->private_data.f_checksum, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_dst - io0_a_dst)), io0_a_dst));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
@@ -34676,38 +35287,40 @@ wuffs_zlib__decoder__transform_io(
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
}
|
||||
label__0__break:;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_transform_io[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
if ( ! self->private_impl.f_quirks[0]) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_transform_io[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_transform_io[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_transform_io[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
v_checksum_want = t_3;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_got != v_checksum_want)) {
|
||||
status = wuffs_base__make_status(wuffs_zlib__error__bad_checksum);
|
||||
goto exit;
|
||||
}
|
||||
v_checksum_want = t_3;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_got != v_checksum_want)) {
|
||||
status = wuffs_base__make_status(wuffs_zlib__error__bad_checksum);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
ok:
|
||||
@@ -34742,17 +35355,25 @@ wuffs_zlib__decoder__transform_io(
|
||||
|
||||
// ---------------- Status Codes Implementations
|
||||
|
||||
const char wuffs_png__error__bad_animation_sequence_number[] = "#png: bad animation sequence number";
|
||||
const char wuffs_png__error__bad_checksum[] = "#png: bad checksum";
|
||||
const char wuffs_png__error__bad_chunk[] = "#png: bad chunk";
|
||||
const char wuffs_png__error__bad_filter[] = "#png: bad filter";
|
||||
const char wuffs_png__error__bad_header[] = "#png: bad header";
|
||||
const char wuffs_png__error__bad_text_chunk_not_latin_1[] = "#png: bad text chunk (not Latin-1)";
|
||||
const char wuffs_png__error__missing_palette[] = "#png: missing palette";
|
||||
const char wuffs_png__error__unsupported_png_compression_method[] = "#png: unsupported PNG compression method";
|
||||
const char wuffs_png__error__unsupported_png_file[] = "#png: unsupported PNG file";
|
||||
const char wuffs_png__error__internal_error_inconsistent_i_o[] = "#png: internal error: inconsistent I/O";
|
||||
const char wuffs_png__error__internal_error_inconsistent_chunk_type[] = "#png: internal error: inconsistent chunk type";
|
||||
const char wuffs_png__error__internal_error_inconsistent_frame_bounds[] = "#png: internal error: inconsistent frame bounds";
|
||||
const char wuffs_png__error__internal_error_inconsistent_workbuf_length[] = "#png: internal error: inconsistent workbuf length";
|
||||
const char wuffs_png__error__internal_error_zlib_decoder_did_not_exhaust_its_input[] = "#png: internal error: zlib decoder did not exhaust its input";
|
||||
|
||||
// ---------------- Private Consts
|
||||
|
||||
#define WUFFS_PNG__ANCILLARY_BIT 32
|
||||
|
||||
static const uint8_t
|
||||
WUFFS_PNG__INTERLACING[8][6] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
{
|
||||
@@ -34789,6 +35410,42 @@ WUFFS_PNG__NUM_CHANNELS[8] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
1, 0, 3, 1, 2, 0, 4, 0,
|
||||
};
|
||||
|
||||
static const uint16_t
|
||||
WUFFS_PNG__LATIN_1[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
32, 33, 34, 35, 36, 37, 38, 39,
|
||||
40, 41, 42, 43, 44, 45, 46, 47,
|
||||
48, 49, 50, 51, 52, 53, 54, 55,
|
||||
56, 57, 58, 59, 60, 61, 62, 63,
|
||||
64, 65, 66, 67, 68, 69, 70, 71,
|
||||
72, 73, 74, 75, 76, 77, 78, 79,
|
||||
80, 81, 82, 83, 84, 85, 86, 87,
|
||||
88, 89, 90, 91, 92, 93, 94, 95,
|
||||
96, 97, 98, 99, 100, 101, 102, 103,
|
||||
104, 105, 106, 107, 108, 109, 110, 111,
|
||||
112, 113, 114, 115, 116, 117, 118, 119,
|
||||
120, 121, 122, 123, 124, 125, 126, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 41410, 41666, 41922, 42178, 42434, 42690, 42946,
|
||||
43202, 43458, 43714, 43970, 44226, 44482, 44738, 44994,
|
||||
45250, 45506, 45762, 46018, 46274, 46530, 46786, 47042,
|
||||
47298, 47554, 47810, 48066, 48322, 48578, 48834, 49090,
|
||||
32963, 33219, 33475, 33731, 33987, 34243, 34499, 34755,
|
||||
35011, 35267, 35523, 35779, 36035, 36291, 36547, 36803,
|
||||
37059, 37315, 37571, 37827, 38083, 38339, 38595, 38851,
|
||||
39107, 39363, 39619, 39875, 40131, 40387, 40643, 40899,
|
||||
41155, 41411, 41667, 41923, 42179, 42435, 42691, 42947,
|
||||
43203, 43459, 43715, 43971, 44227, 44483, 44739, 44995,
|
||||
45251, 45507, 45763, 46019, 46275, 46531, 46787, 47043,
|
||||
47299, 47555, 47811, 48067, 48323, 48579, 48835, 49091,
|
||||
};
|
||||
|
||||
// ---------------- Private Initializer Prototypes
|
||||
|
||||
// ---------------- Private Function Prototypes
|
||||
@@ -34898,36 +35555,36 @@ wuffs_png__decoder__filter_4_distance_4_fallback(
|
||||
wuffs_base__slice_u8 a_curr,
|
||||
wuffs_base__slice_u8 a_prev);
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_1_distance_4_x86_sse42(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__slice_u8 a_curr);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_3_distance_4_x86_sse42(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__slice_u8 a_curr,
|
||||
wuffs_base__slice_u8 a_prev);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_4_distance_3_x86_sse42(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__slice_u8 a_curr,
|
||||
wuffs_base__slice_u8 a_prev);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_4_distance_4_x86_sse42(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__slice_u8 a_curr,
|
||||
wuffs_base__slice_u8 a_prev);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_ihdr(
|
||||
@@ -34952,16 +35609,56 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_actl(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_chrm(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_exif(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_fctl(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_gama(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_iccp(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_plte(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_srgb(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_trns(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__skip_frame(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_pass(
|
||||
wuffs_png__decoder* self,
|
||||
@@ -36135,7 +36832,7 @@ wuffs_png__decoder__filter_4_distance_4_fallback(
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func png.decoder.filter_1_distance_4_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_1_distance_4_x86_sse42(
|
||||
@@ -36175,13 +36872,13 @@ wuffs_png__decoder__filter_1_distance_4_x86_sse42(
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func png.decoder.filter_3_distance_4_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_3_distance_4_x86_sse42(
|
||||
@@ -36280,13 +36977,13 @@ wuffs_png__decoder__filter_3_distance_4_x86_sse42(
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func png.decoder.filter_4_distance_3_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_4_distance_3_x86_sse42(
|
||||
@@ -36406,13 +37103,13 @@ wuffs_png__decoder__filter_4_distance_3_x86_sse42(
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func png.decoder.filter_4_distance_4_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_4_distance_4_x86_sse42(
|
||||
@@ -36510,7 +37207,7 @@ wuffs_png__decoder__filter_4_distance_4_x86_sse42(
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
// -------- func png.decoder.set_quirk_enabled
|
||||
@@ -36586,172 +37283,210 @@ wuffs_png__decoder__decode_image_config(
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence != 0) {
|
||||
if (self->private_impl.f_call_sequence == 2) {
|
||||
if (self->private_impl.f_metadata_fourcc != 0) {
|
||||
self->private_impl.f_call_sequence = 1;
|
||||
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
|
||||
goto ok;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence != 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
|
||||
t_0 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 8;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 56) {
|
||||
t_0 = ((uint64_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
v_magic = t_0;
|
||||
}
|
||||
if (v_magic != 727905341920923785) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint64_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
|
||||
t_1 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 8;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 56) {
|
||||
t_1 = ((uint64_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_magic = t_1;
|
||||
}
|
||||
if (v_magic != 5927942488114331648) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
|
||||
self->private_impl.f_chunk_type_array[0] = 73;
|
||||
self->private_impl.f_chunk_type_array[1] = 72;
|
||||
self->private_impl.f_chunk_type_array[2] = 68;
|
||||
self->private_impl.f_chunk_type_array[3] = 82;
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
while (true) {
|
||||
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
} else {
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_2 = wuffs_png__decoder__decode_ihdr(self, a_src);
|
||||
v_status = t_2;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
goto label__0__break;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
}
|
||||
label__0__break:;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
}
|
||||
v_checksum_want = t_3;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_have != v_checksum_want)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
|
||||
goto exit;
|
||||
}
|
||||
while (true) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
uint64_t t_4;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_4 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
|
||||
t_0 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 8;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
|
||||
if (num_bits_4 == 24) {
|
||||
t_4 = ((uint64_t)(*scratch >> 32));
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 56) {
|
||||
t_0 = ((uint64_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_4 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_4));
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_chunk_length = t_4;
|
||||
v_magic = t_0;
|
||||
}
|
||||
if (v_magic != 727905341920923785) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint64_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
|
||||
t_1 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 8;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 56) {
|
||||
t_1 = ((uint64_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_magic = t_1;
|
||||
}
|
||||
if (v_magic != 5927942488114331648) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_type_array[0] = 73;
|
||||
self->private_impl.f_chunk_type_array[1] = 72;
|
||||
self->private_impl.f_chunk_type_array[2] = 68;
|
||||
self->private_impl.f_chunk_type_array[3] = 82;
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
|
||||
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
while (true) {
|
||||
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_2 = wuffs_png__decoder__decode_ihdr(self, a_src);
|
||||
v_status = t_2;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
goto label__0__break;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
}
|
||||
label__0__break:;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
}
|
||||
v_checksum_want = t_3;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_have != v_checksum_want)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
while (true) {
|
||||
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
|
||||
if (a_src && a_src->meta.closed) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(8);
|
||||
}
|
||||
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
|
||||
if (self->private_impl.f_chunk_type == 1413563465) {
|
||||
if ( ! self->private_impl.f_seen_actl || self->private_impl.f_seen_fctl) {
|
||||
goto label__1__break;
|
||||
}
|
||||
self->private_impl.f_seen_idat = true;
|
||||
} else if (self->private_impl.f_chunk_type == 1413571686) {
|
||||
if (self->private_impl.f_seen_idat && self->private_impl.f_seen_fctl) {
|
||||
goto label__1__break;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
iop_a_src += 8;
|
||||
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0)) {
|
||||
self->private_impl.f_chunk_type_array[0] = ((uint8_t)(((self->private_impl.f_chunk_type >> 0) & 255)));
|
||||
self->private_impl.f_chunk_type_array[1] = ((uint8_t)(((self->private_impl.f_chunk_type >> 8) & 255)));
|
||||
self->private_impl.f_chunk_type_array[2] = ((uint8_t)(((self->private_impl.f_chunk_type >> 16) & 255)));
|
||||
self->private_impl.f_chunk_type_array[3] = ((uint8_t)(((self->private_impl.f_chunk_type >> 24) & 255)));
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
|
||||
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
}
|
||||
while (true) {
|
||||
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_4 = wuffs_png__decoder__decode_other_chunk(self, a_src);
|
||||
v_status = t_4;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0)) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
goto label__2__break;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
|
||||
}
|
||||
label__2__break:;
|
||||
if (self->private_impl.f_metadata_fourcc != 0) {
|
||||
self->private_impl.f_call_sequence = 1;
|
||||
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
|
||||
goto ok;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
uint32_t t_5;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_5 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
t_5 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
@@ -36762,83 +37497,21 @@ wuffs_png__decoder__decode_image_config(
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_5 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_5;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
|
||||
if (num_bits_5 == 24) {
|
||||
t_5 = ((uint32_t)(*scratch));
|
||||
t_5 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_5 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_5)) << 56;
|
||||
*scratch |= ((uint64_t)(num_bits_5));
|
||||
}
|
||||
}
|
||||
self->private_impl.f_chunk_type = t_5;
|
||||
v_checksum_want = t_5;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type == 1413563465) || (self->private_impl.f_chunk_type == 1163152464))) {
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
|
||||
self->private_impl.f_chunk_type_array[0] = ((uint8_t)(((self->private_impl.f_chunk_type >> 0) & 255)));
|
||||
self->private_impl.f_chunk_type_array[1] = ((uint8_t)(((self->private_impl.f_chunk_type >> 8) & 255)));
|
||||
self->private_impl.f_chunk_type_array[2] = ((uint8_t)(((self->private_impl.f_chunk_type >> 16) & 255)));
|
||||
self->private_impl.f_chunk_type_array[3] = ((uint8_t)(((self->private_impl.f_chunk_type >> 24) & 255)));
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
}
|
||||
if (self->private_impl.f_chunk_type == 1413563465) {
|
||||
goto label__1__break;
|
||||
}
|
||||
while (true) {
|
||||
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_6 = wuffs_png__decoder__decode_other_chunk(self, a_src);
|
||||
v_status = t_6;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type == 1163152464)) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
goto label__2__break;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(12);
|
||||
}
|
||||
label__2__break:;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
|
||||
uint32_t t_7;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_7 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_7 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_7);
|
||||
if (num_bits_7 == 24) {
|
||||
t_7 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_7 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_7));
|
||||
}
|
||||
}
|
||||
v_checksum_want = t_7;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type == 1163152464) && (v_checksum_have != v_checksum_want)) {
|
||||
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0) && (v_checksum_have != v_checksum_want)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
|
||||
goto exit;
|
||||
}
|
||||
@@ -36848,7 +37521,8 @@ wuffs_png__decoder__decode_image_config(
|
||||
status = wuffs_base__make_status(wuffs_png__error__missing_palette);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_first_config_io_position = self->private_impl.f_frame_config_io_position;
|
||||
if (a_dst != NULL) {
|
||||
wuffs_base__image_config__set(
|
||||
a_dst,
|
||||
@@ -36856,9 +37530,19 @@ wuffs_png__decoder__decode_image_config(
|
||||
0,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height,
|
||||
self->private_impl.f_frame_config_io_position,
|
||||
self->private_impl.f_first_config_io_position,
|
||||
((self->private_impl.f_color_type <= 3) && ! self->private_impl.f_seen_trns));
|
||||
}
|
||||
if ( ! self->private_impl.f_seen_actl) {
|
||||
self->private_impl.f_num_animation_frames_value = 1;
|
||||
self->private_impl.f_first_rect_x0 = 0;
|
||||
self->private_impl.f_first_rect_y0 = 0;
|
||||
self->private_impl.f_first_rect_x1 = self->private_impl.f_width;
|
||||
self->private_impl.f_first_rect_y1 = self->private_impl.f_height;
|
||||
self->private_impl.f_first_duration = 0;
|
||||
self->private_impl.f_first_disposal = 0;
|
||||
self->private_impl.f_first_overwrite_instead_of_blend = false;
|
||||
}
|
||||
self->private_impl.f_call_sequence = 3;
|
||||
|
||||
ok:
|
||||
@@ -37022,7 +37706,7 @@ wuffs_png__decoder__decode_ihdr(
|
||||
v_a8 = t_4;
|
||||
}
|
||||
if (v_a8 != 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
@@ -37060,7 +37744,7 @@ wuffs_png__decoder__decode_ihdr(
|
||||
self->private_impl.f_filter_distance = 0;
|
||||
wuffs_png__decoder__assign_filter_distance(self);
|
||||
if (self->private_impl.f_filter_distance == 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_overall_workbuf_length = (((uint64_t)(self->private_impl.f_height)) * (1 + wuffs_png__decoder__calculate_bytes_per_row(self, self->private_impl.f_width)));
|
||||
@@ -37091,7 +37775,9 @@ static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__assign_filter_distance(
|
||||
wuffs_png__decoder* self) {
|
||||
if (self->private_impl.f_depth < 8) {
|
||||
if (self->private_impl.f_color_type == 0) {
|
||||
if ((self->private_impl.f_depth != 1) && (self->private_impl.f_depth != 2) && (self->private_impl.f_depth != 4)) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
} else if (self->private_impl.f_color_type == 0) {
|
||||
self->private_impl.f_dst_pixfmt = 536870920;
|
||||
self->private_impl.f_src_pixfmt = 536870920;
|
||||
} else if (self->private_impl.f_color_type == 3) {
|
||||
@@ -37109,8 +37795,13 @@ wuffs_png__decoder__assign_filter_distance(
|
||||
self->private_impl.f_src_pixfmt = 536870920;
|
||||
self->private_impl.f_filter_distance = 1;
|
||||
} else if (self->private_impl.f_depth == 16) {
|
||||
self->private_impl.f_dst_pixfmt = 536870923;
|
||||
self->private_impl.f_src_pixfmt = 537919499;
|
||||
if (self->private_impl.f_interlace_pass == 0) {
|
||||
self->private_impl.f_dst_pixfmt = 536870923;
|
||||
self->private_impl.f_src_pixfmt = 537919499;
|
||||
} else {
|
||||
self->private_impl.f_dst_pixfmt = 2164308923;
|
||||
self->private_impl.f_src_pixfmt = 2164308923;
|
||||
}
|
||||
self->private_impl.f_filter_distance = 2;
|
||||
}
|
||||
} else if (self->private_impl.f_color_type == 2) {
|
||||
@@ -37194,7 +37885,7 @@ wuffs_png__decoder__choose_filter_implementations(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_4_distance_3_arm_neon :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_4_distance_3_x86_sse42 :
|
||||
#endif
|
||||
&wuffs_png__decoder__filter_4_distance_3_fallback);
|
||||
@@ -37203,7 +37894,7 @@ wuffs_png__decoder__choose_filter_implementations(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_1_distance_4_arm_neon :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_1_distance_4_x86_sse42 :
|
||||
#endif
|
||||
&wuffs_png__decoder__filter_1_distance_4_fallback);
|
||||
@@ -37211,7 +37902,7 @@ wuffs_png__decoder__choose_filter_implementations(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_3_distance_4_arm_neon :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_3_distance_4_x86_sse42 :
|
||||
#endif
|
||||
&wuffs_png__decoder__filter_3_distance_4_fallback);
|
||||
@@ -37219,7 +37910,7 @@ wuffs_png__decoder__choose_filter_implementations(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_4_distance_4_arm_neon :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_4_distance_4_x86_sse42 :
|
||||
#endif
|
||||
&wuffs_png__decoder__filter_4_distance_4_fallback);
|
||||
@@ -37251,22 +37942,161 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_type == 1163152464) {
|
||||
if (self->private_impl.f_seen_plte || (self->private_impl.f_color_type != 3)) {
|
||||
if (self->private_impl.f_seen_plte) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_color_type == 3) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_png__decoder__decode_plte(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else if ((self->private_impl.f_color_type == 2) || (self->private_impl.f_color_type == 6)) {
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_seen_plte = true;
|
||||
} else if ((self->private_impl.f_chunk_type & 32) == 0) {
|
||||
if (self->private_impl.f_chunk_type != 1413563465) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1280598881) {
|
||||
if (self->private_impl.f_seen_actl) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_png__decoder__decode_plte(self, a_src);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_png__decoder__decode_actl(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_plte = true;
|
||||
self->private_impl.f_seen_actl = true;
|
||||
} else if (self->private_impl.f_chunk_type == 1297238115) {
|
||||
if (self->private_impl.f_report_metadata_chrm) {
|
||||
if (self->private_impl.f_seen_chrm) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
status = wuffs_png__decoder__decode_chrm(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_chrm = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1716082789) {
|
||||
if (self->private_impl.f_report_metadata_exif) {
|
||||
if (self->private_impl.f_seen_exif) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
status = wuffs_png__decoder__decode_exif(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_exif = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1280598886) {
|
||||
if (self->private_impl.f_seen_fctl) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
status = wuffs_png__decoder__decode_fctl(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_fctl = true;
|
||||
} else if (self->private_impl.f_chunk_type == 1095582055) {
|
||||
if (self->private_impl.f_report_metadata_gama) {
|
||||
if (self->private_impl.f_seen_gama) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
status = wuffs_png__decoder__decode_gama(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_gama = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1346585449) {
|
||||
if (self->private_impl.f_report_metadata_iccp) {
|
||||
if (self->private_impl.f_seen_iccp) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
status = wuffs_png__decoder__decode_iccp(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_iccp = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1111970419) {
|
||||
if (self->private_impl.f_report_metadata_srgb) {
|
||||
if (self->private_impl.f_seen_srgb) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
status = wuffs_png__decoder__decode_srgb(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_srgb = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1397641844) {
|
||||
if (self->private_impl.f_seen_trns || (self->private_impl.f_color_type > 3) || ((self->private_impl.f_color_type == 3) && ! self->private_impl.f_seen_plte)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
@@ -37275,7 +38105,7 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
status = wuffs_png__decoder__decode_trns(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -37284,9 +38114,18 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_trns = true;
|
||||
} else {
|
||||
} else if ((self->private_impl.f_chunk_type == 1951945833) || (self->private_impl.f_chunk_type == 1951942004) || (self->private_impl.f_chunk_type == 1951945850)) {
|
||||
if (self->private_impl.f_report_metadata_kvp) {
|
||||
self->private_impl.f_metadata_flavor = 4;
|
||||
self->private_impl.f_metadata_fourcc = 1263947851;
|
||||
self->private_impl.f_metadata_x = 0;
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
}
|
||||
}
|
||||
if (self->private_impl.f_metadata_fourcc == 0) {
|
||||
self->private_data.s_decode_other_chunk[0].scratch = self->private_impl.f_chunk_length;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
if (self->private_data.s_decode_other_chunk[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_other_chunk[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
@@ -37315,6 +38154,964 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_actl
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_actl(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_actl[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 8) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_interlace_pass > 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_actl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_actl[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
self->private_impl.f_num_animation_frames_value = t_0;
|
||||
}
|
||||
if (self->private_impl.f_num_animation_frames_value == 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_actl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_actl[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
}
|
||||
}
|
||||
self->private_impl.f_num_animation_loops_value = t_1;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_actl[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_actl[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_chrm
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_chrm(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint64_t v_u = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_chrm[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 32) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
self->private_impl.f_metadata_flavor = 5;
|
||||
self->private_impl.f_metadata_fourcc = 1128813133;
|
||||
self->private_impl.f_metadata_x = 0;
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_u = t_0;
|
||||
}
|
||||
self->private_impl.f_metadata_x |= ((16777215 & v_u) << 0);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint64_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
}
|
||||
}
|
||||
v_u = t_1;
|
||||
}
|
||||
self->private_impl.f_metadata_x |= ((16777215 & v_u) << 24);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint64_t t_2;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_2 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_2 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_2);
|
||||
if (num_bits_2 == 24) {
|
||||
t_2 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_2 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_2));
|
||||
}
|
||||
}
|
||||
v_u = t_2;
|
||||
}
|
||||
self->private_impl.f_metadata_x |= ((uint64_t)((16777215 & v_u) << 48));
|
||||
self->private_impl.f_metadata_y |= ((16777215 & v_u) >> 16);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
uint64_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
}
|
||||
v_u = t_3;
|
||||
}
|
||||
self->private_impl.f_metadata_y |= ((16777215 & v_u) << 8);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
uint64_t t_4;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_4 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
|
||||
if (num_bits_4 == 24) {
|
||||
t_4 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_4 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_4));
|
||||
}
|
||||
}
|
||||
v_u = t_4;
|
||||
}
|
||||
self->private_impl.f_metadata_y |= ((16777215 & v_u) << 32);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
|
||||
uint64_t t_5;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_5 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
|
||||
if (num_bits_5 == 24) {
|
||||
t_5 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_5 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_5));
|
||||
}
|
||||
}
|
||||
v_u = t_5;
|
||||
}
|
||||
self->private_impl.f_metadata_y |= ((uint64_t)((16777215 & v_u) << 56));
|
||||
self->private_impl.f_metadata_z |= ((16777215 & v_u) >> 8);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
|
||||
uint64_t t_6;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_6 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_6 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_6);
|
||||
if (num_bits_6 == 24) {
|
||||
t_6 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_6 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_6));
|
||||
}
|
||||
}
|
||||
v_u = t_6;
|
||||
}
|
||||
self->private_impl.f_metadata_z |= ((16777215 & v_u) << 16);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
|
||||
uint64_t t_7;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_7 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_7 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_7);
|
||||
if (num_bits_7 == 24) {
|
||||
t_7 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_7 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_7));
|
||||
}
|
||||
}
|
||||
v_u = t_7;
|
||||
}
|
||||
self->private_impl.f_metadata_z |= ((16777215 & v_u) << 40);
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_chrm[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_chrm[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_exif
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_exif(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
if (self->private_impl.f_chunk_length < 4) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_metadata_flavor = 3;
|
||||
self->private_impl.f_metadata_fourcc = 1163413830;
|
||||
self->private_impl.f_metadata_x = 0;
|
||||
self->private_impl.f_metadata_y = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_metadata_z = wuffs_base__u64__sat_add(self->private_impl.f_metadata_y, ((uint64_t)(self->private_impl.f_chunk_length)));
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_fctl
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_fctl(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_x0 = 0;
|
||||
uint32_t v_y0 = 0;
|
||||
uint32_t v_x1 = 0;
|
||||
uint32_t v_y1 = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_fctl[0];
|
||||
if (coro_susp_point) {
|
||||
v_x0 = self->private_data.s_decode_fctl[0].v_x0;
|
||||
v_x1 = self->private_data.s_decode_fctl[0].v_x1;
|
||||
v_y1 = self->private_data.s_decode_fctl[0].v_y1;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 26) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_x0 = t_0;
|
||||
}
|
||||
if (v_x0 != self->private_impl.f_next_animation_seq_num) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_next_animation_seq_num += 1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
}
|
||||
}
|
||||
v_x1 = t_1;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint32_t t_2;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_2 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_2 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_2);
|
||||
if (num_bits_2 == 24) {
|
||||
t_2 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_2 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_2));
|
||||
}
|
||||
}
|
||||
v_y1 = t_2;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
}
|
||||
v_x0 = t_3;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
uint32_t t_4;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_4 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
|
||||
if (num_bits_4 == 24) {
|
||||
t_4 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_4 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_4));
|
||||
}
|
||||
}
|
||||
v_y0 = t_4;
|
||||
}
|
||||
v_x1 += v_x0;
|
||||
v_y1 += v_y0;
|
||||
if ((v_x0 >= v_x1) ||
|
||||
(v_x0 > self->private_impl.f_width) ||
|
||||
(v_x1 > self->private_impl.f_width) ||
|
||||
(v_y0 >= v_y1) ||
|
||||
(v_y0 > self->private_impl.f_height) ||
|
||||
(v_y1 > self->private_impl.f_height)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_frame_rect_x0 = v_x0;
|
||||
self->private_impl.f_frame_rect_y0 = v_y0;
|
||||
self->private_impl.f_frame_rect_x1 = v_x1;
|
||||
self->private_impl.f_frame_rect_y1 = v_y1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
|
||||
uint32_t t_5;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
|
||||
t_5 = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 2;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
|
||||
if (num_bits_5 == 8) {
|
||||
t_5 = ((uint32_t)(*scratch >> 48));
|
||||
break;
|
||||
}
|
||||
num_bits_5 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_5));
|
||||
}
|
||||
}
|
||||
v_x0 = t_5;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
|
||||
uint32_t t_6;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
|
||||
t_6 = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 2;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_6 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_6);
|
||||
if (num_bits_6 == 8) {
|
||||
t_6 = ((uint32_t)(*scratch >> 48));
|
||||
break;
|
||||
}
|
||||
num_bits_6 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_6));
|
||||
}
|
||||
}
|
||||
v_x1 = t_6;
|
||||
}
|
||||
if (v_x1 <= 0) {
|
||||
self->private_impl.f_frame_duration = (((uint64_t)(v_x0)) * 7056000);
|
||||
} else {
|
||||
self->private_impl.f_frame_duration = ((((uint64_t)(v_x0)) * 705600000) / ((uint64_t)(v_x1)));
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint32_t t_7 = *iop_a_src++;
|
||||
v_x0 = t_7;
|
||||
}
|
||||
if (v_x0 == 0) {
|
||||
self->private_impl.f_frame_disposal = 0;
|
||||
} else if (v_x0 == 1) {
|
||||
self->private_impl.f_frame_disposal = 1;
|
||||
} else if (v_x0 == 2) {
|
||||
self->private_impl.f_frame_disposal = 2;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint32_t t_8 = *iop_a_src++;
|
||||
v_x0 = t_8;
|
||||
}
|
||||
if (v_x0 == 0) {
|
||||
self->private_impl.f_frame_overwrite_instead_of_blend = true;
|
||||
} else if (v_x0 == 1) {
|
||||
self->private_impl.f_frame_overwrite_instead_of_blend = false;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (self->private_impl.f_num_decoded_frame_configs_value == 0) {
|
||||
self->private_impl.f_first_rect_x0 = self->private_impl.f_frame_rect_x0;
|
||||
self->private_impl.f_first_rect_y0 = self->private_impl.f_frame_rect_y0;
|
||||
self->private_impl.f_first_rect_x1 = self->private_impl.f_frame_rect_x1;
|
||||
self->private_impl.f_first_rect_y1 = self->private_impl.f_frame_rect_y1;
|
||||
self->private_impl.f_first_duration = self->private_impl.f_frame_duration;
|
||||
self->private_impl.f_first_disposal = self->private_impl.f_frame_disposal;
|
||||
self->private_impl.f_first_overwrite_instead_of_blend = self->private_impl.f_frame_overwrite_instead_of_blend;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_fctl[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_fctl[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_fctl[0].v_x0 = v_x0;
|
||||
self->private_data.s_decode_fctl[0].v_x1 = v_x1;
|
||||
self->private_data.s_decode_fctl[0].v_y1 = v_y1;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_gama
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_gama(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_gama[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 4) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
self->private_impl.f_metadata_flavor = 5;
|
||||
self->private_impl.f_metadata_fourcc = 1195461953;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_gama[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_gama[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
self->private_impl.f_metadata_x = t_0;
|
||||
}
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_gama[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_gama[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_iccp
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_iccp(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint8_t v_c = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_iccp[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
while (true) {
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_0 = *iop_a_src++;
|
||||
v_c = t_0;
|
||||
}
|
||||
if (v_c == 0) {
|
||||
goto label__0__break;
|
||||
}
|
||||
}
|
||||
label__0__break:;
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_1 = *iop_a_src++;
|
||||
v_c = t_1;
|
||||
}
|
||||
if (v_c != 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_metadata_is_zlib_compressed = true;
|
||||
self->private_impl.f_metadata_flavor = 4;
|
||||
self->private_impl.f_metadata_fourcc = 1229144912;
|
||||
self->private_impl.f_metadata_x = 0;
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_iccp[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_iccp[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_plte
|
||||
|
||||
static wuffs_base__status
|
||||
@@ -37351,6 +39148,7 @@ wuffs_png__decoder__decode_plte(
|
||||
goto exit;
|
||||
}
|
||||
v_num_entries = (((uint32_t)(self->private_impl.f_chunk_length)) / 3);
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
while (v_i < v_num_entries) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
@@ -37417,6 +39215,67 @@ wuffs_png__decoder__decode_plte(
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_srgb
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_srgb(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_srgb[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 1) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
self->private_impl.f_metadata_flavor = 5;
|
||||
self->private_impl.f_metadata_fourcc = 1397901122;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t t_0 = *iop_a_src++;
|
||||
self->private_impl.f_metadata_x = t_0;
|
||||
}
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_srgb[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_srgb[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_trns
|
||||
|
||||
static wuffs_base__status
|
||||
@@ -37425,8 +39284,9 @@ wuffs_png__decoder__decode_trns(
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_num_entries = 0;
|
||||
uint32_t v_i = 0;
|
||||
uint32_t v_n = 0;
|
||||
uint64_t v_u = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -37441,42 +39301,143 @@ wuffs_png__decoder__decode_trns(
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_trns[0];
|
||||
if (coro_susp_point) {
|
||||
v_num_entries = self->private_data.s_decode_trns[0].v_num_entries;
|
||||
v_i = self->private_data.s_decode_trns[0].v_i;
|
||||
v_n = self->private_data.s_decode_trns[0].v_n;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length > 256) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
v_num_entries = ((uint32_t)(self->private_impl.f_chunk_length));
|
||||
while (v_i < v_num_entries) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_0 = *iop_a_src++;
|
||||
self->private_data.f_src_palette[((4 * v_i) + 3)] = t_0;
|
||||
}
|
||||
v_i += 1;
|
||||
}
|
||||
if (self->private_impl.f_color_type == 3) {
|
||||
self->private_impl.f_dst_pixfmt = 2164523016;
|
||||
self->private_impl.f_src_pixfmt = 2164523016;
|
||||
} else {
|
||||
if (self->private_impl.f_color_type == 0) {
|
||||
self->private_impl.choosy_filter_and_swizzle = (
|
||||
&wuffs_png__decoder__filter_and_swizzle_tricky);
|
||||
if (self->private_impl.f_color_type == 0) {
|
||||
self->private_impl.f_dst_pixfmt = 2164295816;
|
||||
self->private_impl.f_src_pixfmt = 2164308923;
|
||||
} else if (self->private_impl.f_color_type == 2) {
|
||||
if (self->private_impl.f_depth <= 8) {
|
||||
self->private_impl.f_dst_pixfmt = 2164295816;
|
||||
self->private_impl.f_src_pixfmt = 2164295816;
|
||||
} else {
|
||||
self->private_impl.f_dst_pixfmt = 2164308923;
|
||||
self->private_impl.f_src_pixfmt = 2164308923;
|
||||
}
|
||||
if (self->private_impl.f_chunk_length != 2) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
|
||||
t_0 = ((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 2;
|
||||
} else {
|
||||
self->private_data.s_decode_trns[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_trns[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 8) {
|
||||
t_0 = ((uint64_t)(*scratch >> 48));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_u = t_0;
|
||||
}
|
||||
if (self->private_impl.f_depth <= 1) {
|
||||
self->private_impl.f_remap_transparency = (((v_u & 1) * 16777215) | 4278190080);
|
||||
} else if (self->private_impl.f_depth <= 2) {
|
||||
self->private_impl.f_remap_transparency = (((v_u & 3) * 5592405) | 4278190080);
|
||||
} else if (self->private_impl.f_depth <= 4) {
|
||||
self->private_impl.f_remap_transparency = (((v_u & 15) * 1118481) | 4278190080);
|
||||
} else if (self->private_impl.f_depth <= 8) {
|
||||
self->private_impl.f_remap_transparency = (((v_u & 255) * 65793) | 4278190080);
|
||||
} else {
|
||||
self->private_impl.f_remap_transparency = ((v_u * 4295032833) | 18446462598732840960u);
|
||||
}
|
||||
} else if (self->private_impl.f_color_type == 2) {
|
||||
self->private_impl.choosy_filter_and_swizzle = (
|
||||
&wuffs_png__decoder__filter_and_swizzle_tricky);
|
||||
if (self->private_impl.f_depth <= 8) {
|
||||
self->private_impl.f_dst_pixfmt = 2164295816;
|
||||
self->private_impl.f_src_pixfmt = 2164295816;
|
||||
} else {
|
||||
self->private_impl.f_dst_pixfmt = 2164308923;
|
||||
self->private_impl.f_src_pixfmt = 2164308923;
|
||||
}
|
||||
if (self->private_impl.f_chunk_length != 6) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint64_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 6)) {
|
||||
t_1 = ((uint64_t)(wuffs_base__peek_u48be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 6;
|
||||
} else {
|
||||
self->private_data.s_decode_trns[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_trns[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 40) {
|
||||
t_1 = ((uint64_t)(*scratch >> 16));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
}
|
||||
}
|
||||
v_u = t_1;
|
||||
}
|
||||
if (self->private_impl.f_depth <= 8) {
|
||||
self->private_impl.f_remap_transparency = ((255 & (v_u >> 0)) |
|
||||
(65280 & (v_u >> 8)) |
|
||||
(16711680 & (v_u >> 16)) |
|
||||
4278190080);
|
||||
} else {
|
||||
self->private_impl.f_remap_transparency = (v_u | 18446462598732840960u);
|
||||
}
|
||||
} else if (self->private_impl.f_color_type == 3) {
|
||||
self->private_impl.f_dst_pixfmt = 2164523016;
|
||||
self->private_impl.f_src_pixfmt = 2164523016;
|
||||
if (self->private_impl.f_chunk_length > 256) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
v_n = ((uint32_t)(self->private_impl.f_chunk_length));
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
while (v_i < v_n) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_2 = *iop_a_src++;
|
||||
self->private_data.f_src_palette[((4 * v_i) + 3)] = t_2;
|
||||
}
|
||||
v_i += 1;
|
||||
}
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
@@ -37488,8 +39449,8 @@ wuffs_png__decoder__decode_trns(
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_trns[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_trns[0].v_num_entries = v_num_entries;
|
||||
self->private_data.s_decode_trns[0].v_i = v_i;
|
||||
self->private_data.s_decode_trns[0].v_n = v_n;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
@@ -37543,7 +39504,10 @@ wuffs_png__decoder__decode_frame_config(
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence < 3) {
|
||||
if (self->private_impl.f_call_sequence == 255) {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
} else if (self->private_impl.f_call_sequence < 3) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
@@ -37556,34 +39520,153 @@ wuffs_png__decoder__decode_frame_config(
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 3) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 4) {
|
||||
self->private_impl.f_call_sequence = 255;
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_png__decoder__skip_frame(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
if (self->private_impl.f_call_sequence == 255) {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
}
|
||||
}
|
||||
if (self->private_impl.f_num_decoded_frame_configs_value == 0) {
|
||||
self->private_impl.f_frame_rect_x0 = self->private_impl.f_first_rect_x0;
|
||||
self->private_impl.f_frame_rect_y0 = self->private_impl.f_first_rect_y0;
|
||||
self->private_impl.f_frame_rect_x1 = self->private_impl.f_first_rect_x1;
|
||||
self->private_impl.f_frame_rect_y1 = self->private_impl.f_first_rect_y1;
|
||||
self->private_impl.f_frame_config_io_position = self->private_impl.f_first_config_io_position;
|
||||
self->private_impl.f_frame_duration = self->private_impl.f_first_duration;
|
||||
self->private_impl.f_frame_disposal = self->private_impl.f_first_disposal;
|
||||
self->private_impl.f_frame_overwrite_instead_of_blend = self->private_impl.f_first_overwrite_instead_of_blend;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
while (true) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_frame_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_frame_config[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
self->private_impl.f_chunk_length = t_0;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_frame_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_frame_config[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_chunk_type = t_1;
|
||||
}
|
||||
if (self->private_impl.f_chunk_type == 1413571686) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_chunk_type == 1280598886) {
|
||||
self->private_impl.f_frame_config_io_position = ((uint64_t)(wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))) - 8));
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
status = wuffs_png__decoder__decode_fctl(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_data.s_decode_frame_config[0].scratch = 4;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
if (self->private_data.s_decode_frame_config[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_frame_config[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_decode_frame_config[0].scratch;
|
||||
goto label__0__break;
|
||||
}
|
||||
self->private_data.s_decode_frame_config[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 4);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
if (self->private_data.s_decode_frame_config[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_frame_config[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_decode_frame_config[0].scratch;
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
}
|
||||
label__0__break:;
|
||||
}
|
||||
if (a_dst != NULL) {
|
||||
wuffs_base__frame_config__set(
|
||||
a_dst,
|
||||
wuffs_base__utility__make_rect_ie_u32(
|
||||
0,
|
||||
0,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height),
|
||||
((wuffs_base__flicks)(0)),
|
||||
0,
|
||||
self->private_impl.f_frame_rect_x0,
|
||||
self->private_impl.f_frame_rect_y0,
|
||||
self->private_impl.f_frame_rect_x1,
|
||||
self->private_impl.f_frame_rect_y1),
|
||||
((wuffs_base__flicks)(self->private_impl.f_frame_duration)),
|
||||
((uint64_t)(self->private_impl.f_num_decoded_frame_configs_value)),
|
||||
self->private_impl.f_frame_config_io_position,
|
||||
0,
|
||||
false,
|
||||
false,
|
||||
self->private_impl.f_frame_disposal,
|
||||
((self->private_impl.f_color_type <= 3) && ! self->private_impl.f_seen_trns),
|
||||
self->private_impl.f_frame_overwrite_instead_of_blend,
|
||||
0);
|
||||
}
|
||||
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frame_configs_value, 1);
|
||||
self->private_impl.f_call_sequence = 4;
|
||||
|
||||
ok:
|
||||
@@ -37608,6 +39691,162 @@ wuffs_png__decoder__decode_frame_config(
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.skip_frame
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__skip_frame(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_seq_num = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_skip_frame[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
self->private_impl.f_chunk_type_array[0] = 0;
|
||||
self->private_impl.f_chunk_type_array[1] = 0;
|
||||
self->private_impl.f_chunk_type_array[2] = 0;
|
||||
self->private_impl.f_chunk_type_array[3] = 0;
|
||||
label__0__continue:;
|
||||
while (true) {
|
||||
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
|
||||
if (a_src && a_src->meta.closed) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
|
||||
if (self->private_impl.f_chunk_type == 1413563465) {
|
||||
if (self->private_impl.f_chunk_type_array[0] == 102) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_type_array[0] = 73;
|
||||
self->private_impl.f_chunk_type_array[1] = 68;
|
||||
self->private_impl.f_chunk_type_array[2] = 65;
|
||||
self->private_impl.f_chunk_type_array[3] = 84;
|
||||
} else if (self->private_impl.f_chunk_type == 1413571686) {
|
||||
if (self->private_impl.f_chunk_type_array[0] == 73) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_type_array[0] = 102;
|
||||
self->private_impl.f_chunk_type_array[1] = 100;
|
||||
self->private_impl.f_chunk_type_array[2] = 65;
|
||||
self->private_impl.f_chunk_type_array[3] = 84;
|
||||
if (self->private_impl.f_chunk_length < 4) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 4;
|
||||
iop_a_src += 8;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_skip_frame[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_skip_frame[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_seq_num = t_0;
|
||||
}
|
||||
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_next_animation_seq_num += 1;
|
||||
self->private_data.s_skip_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 4);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
if (self->private_data.s_skip_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_skip_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_skip_frame[0].scratch;
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
goto label__0__continue;
|
||||
} else if (self->private_impl.f_chunk_type_array[0] != 0) {
|
||||
goto label__0__break;
|
||||
} else if (self->private_impl.f_chunk_type == 1280598886) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_data.s_skip_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 12);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
if (self->private_data.s_skip_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_skip_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_skip_frame[0].scratch;
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
}
|
||||
label__0__break:;
|
||||
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
|
||||
if (self->private_impl.f_num_decoded_frames_value < self->private_impl.f_num_animation_frames_value) {
|
||||
self->private_impl.f_call_sequence = 5;
|
||||
} else {
|
||||
self->private_impl.f_call_sequence = 255;
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_skip_frame[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_skip_frame[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_frame
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
@@ -37639,25 +39878,138 @@ wuffs_png__decoder__decode_frame(
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_seq_num = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
uint32_t v_pass_width = 0;
|
||||
uint32_t v_pass_height = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_frame[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence < 4) {
|
||||
if (self->private_impl.f_call_sequence == 255) {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
} else if (self->private_impl.f_call_sequence != 4) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_png__decoder__decode_frame_config(self, NULL, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 4) {
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
}
|
||||
while (true) {
|
||||
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
|
||||
if (a_src && a_src->meta.closed) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
|
||||
}
|
||||
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
|
||||
if (self->private_impl.f_chunk_type == 1413563465) {
|
||||
self->private_impl.f_chunk_type_array[0] = 73;
|
||||
self->private_impl.f_chunk_type_array[1] = 68;
|
||||
self->private_impl.f_chunk_type_array[2] = 65;
|
||||
self->private_impl.f_chunk_type_array[3] = 84;
|
||||
iop_a_src += 8;
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
|
||||
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
}
|
||||
goto label__0__break;
|
||||
} else if (self->private_impl.f_chunk_type == 1413571686) {
|
||||
self->private_impl.f_chunk_type_array[0] = 102;
|
||||
self->private_impl.f_chunk_type_array[1] = 100;
|
||||
self->private_impl.f_chunk_type_array[2] = 65;
|
||||
self->private_impl.f_chunk_type_array[3] = 84;
|
||||
if (self->private_impl.f_chunk_length < 4) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 4;
|
||||
iop_a_src += 8;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_frame[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_frame[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_seq_num = t_0;
|
||||
}
|
||||
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_next_animation_seq_num += 1;
|
||||
goto label__0__break;
|
||||
} else if (self->private_impl.f_chunk_type == 1280598886) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_data.s_decode_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 12);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
if (self->private_data.s_decode_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_decode_frame[0].scratch;
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
}
|
||||
label__0__break:;
|
||||
if (self->private_impl.f_zlib_is_dirty) {
|
||||
wuffs_base__ignore_status(wuffs_zlib__decoder__initialize(&self->private_data.f_zlib,
|
||||
sizeof (wuffs_zlib__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
if (self->private_impl.f_ignore_checksum) {
|
||||
wuffs_zlib__decoder__set_quirk_enabled(&self->private_data.f_zlib, 1, true);
|
||||
}
|
||||
}
|
||||
self->private_impl.f_zlib_is_dirty = true;
|
||||
v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
|
||||
wuffs_base__pixel_buffer__pixel_format(a_dst),
|
||||
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)),
|
||||
@@ -37674,14 +40026,26 @@ wuffs_png__decoder__decode_frame(
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
self->private_impl.f_workbuf_hist_pos_base = 0;
|
||||
while (true) {
|
||||
v_pass_width = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][1])) + self->private_impl.f_width) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]));
|
||||
v_pass_height = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][4])) + self->private_impl.f_height) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][3]));
|
||||
if (self->private_impl.f_chunk_type_array[0] == 73) {
|
||||
v_pass_width = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][1])) + self->private_impl.f_width) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]));
|
||||
v_pass_height = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][4])) + self->private_impl.f_height) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][3]));
|
||||
} else {
|
||||
v_pass_width = (16777215 & ((uint32_t)(self->private_impl.f_frame_rect_x1 - self->private_impl.f_frame_rect_x0)));
|
||||
v_pass_height = (16777215 & ((uint32_t)(self->private_impl.f_frame_rect_y1 - self->private_impl.f_frame_rect_y0)));
|
||||
}
|
||||
if ((v_pass_width > 0) && (v_pass_height > 0)) {
|
||||
self->private_impl.f_pass_bytes_per_row = wuffs_png__decoder__calculate_bytes_per_row(self, v_pass_width);
|
||||
self->private_impl.f_pass_workbuf_length = (((uint64_t)(v_pass_height)) * (1 + self->private_impl.f_pass_bytes_per_row));
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
status = wuffs_png__decoder__decode_pass(self, a_src, a_workbuf);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
@@ -37696,9 +40060,10 @@ wuffs_png__decoder__decode_frame(
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
self->private_impl.f_workbuf_hist_pos_base += self->private_impl.f_pass_workbuf_length;
|
||||
}
|
||||
if ((self->private_impl.f_interlace_pass == 0) || (self->private_impl.f_interlace_pass >= 7)) {
|
||||
goto label__0__break;
|
||||
goto label__1__break;
|
||||
}
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
@@ -37709,8 +40074,13 @@ wuffs_png__decoder__decode_frame(
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
}
|
||||
label__0__break:;
|
||||
self->private_impl.f_call_sequence = 255;
|
||||
label__1__break:;
|
||||
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
|
||||
if (self->private_impl.f_num_decoded_frames_value < self->private_impl.f_num_animation_frames_value) {
|
||||
self->private_impl.f_call_sequence = 5;
|
||||
} else {
|
||||
self->private_impl.f_call_sequence = 255;
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_frame[0] = 0;
|
||||
@@ -37724,6 +40094,10 @@ wuffs_png__decoder__decode_frame(
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
}
|
||||
@@ -37750,6 +40124,7 @@ wuffs_png__decoder__decode_pass(
|
||||
wuffs_base__status v_zlib_status = wuffs_base__make_status(NULL);
|
||||
uint32_t v_checksum_have = 0;
|
||||
uint32_t v_checksum_want = 0;
|
||||
uint32_t v_seq_num = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -37763,9 +40138,6 @@ wuffs_png__decoder__decode_pass(
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_pass[0];
|
||||
if (coro_susp_point) {
|
||||
v_checksum_have = self->private_data.s_decode_pass[0].v_checksum_have;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
@@ -37790,11 +40162,12 @@ wuffs_png__decoder__decode_pass(
|
||||
&io2_v_w,
|
||||
wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
self->private_impl.f_workbuf_wi,
|
||||
self->private_impl.f_pass_workbuf_length));
|
||||
self->private_impl.f_pass_workbuf_length),
|
||||
((uint64_t)(self->private_impl.f_workbuf_hist_pos_base + self->private_impl.f_workbuf_wi)));
|
||||
{
|
||||
const uint8_t *o_1_io2_a_src = io2_a_src;
|
||||
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
self->private_impl.f_chunk_length);
|
||||
((uint64_t)(self->private_impl.f_chunk_length)));
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
@@ -37815,7 +40188,7 @@ wuffs_png__decoder__decode_pass(
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
|
||||
}
|
||||
wuffs_base__u64__sat_sub_indirect(&self->private_impl.f_chunk_length, wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))));
|
||||
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
|
||||
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_workbuf_wi, wuffs_base__io__count_since(v_w_mark, ((uint64_t)(iop_v_w - io0_v_w))));
|
||||
io2_a_src = o_1_io2_a_src;
|
||||
if (a_src) {
|
||||
@@ -37829,41 +40202,41 @@ wuffs_png__decoder__decode_pass(
|
||||
io2_v_w = o_0_io2_v_w;
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_zlib_status)) {
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
if (self->private_impl.f_chunk_length > 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__too_much_data);
|
||||
goto exit;
|
||||
}
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_pass[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
if (self->private_impl.f_chunk_length > 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__too_much_data);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_pass[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
}
|
||||
v_checksum_want = t_1;
|
||||
}
|
||||
v_checksum_want = t_1;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type_array[0] == 73)) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
|
||||
if (v_checksum_have != v_checksum_want) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
|
||||
goto exit;
|
||||
@@ -37915,7 +40288,7 @@ wuffs_png__decoder__decode_pass(
|
||||
}
|
||||
v_checksum_want = t_2;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type_array[0] == 73)) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
|
||||
if (v_checksum_have != v_checksum_want) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
|
||||
@@ -37924,9 +40297,9 @@ wuffs_png__decoder__decode_pass(
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint64_t t_3;
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_pass[0].scratch = 0;
|
||||
@@ -37942,7 +40315,7 @@ wuffs_png__decoder__decode_pass(
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint64_t)(*scratch >> 32));
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
@@ -37980,17 +40353,59 @@ wuffs_png__decoder__decode_pass(
|
||||
}
|
||||
self->private_impl.f_chunk_type = t_4;
|
||||
}
|
||||
if (self->private_impl.f_chunk_type != 1413563465) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
|
||||
self->private_impl.f_chunk_type_array[0] = 73;
|
||||
self->private_impl.f_chunk_type_array[1] = 68;
|
||||
self->private_impl.f_chunk_type_array[2] = 65;
|
||||
self->private_impl.f_chunk_type_array[3] = 84;
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
if (self->private_impl.f_chunk_type_array[0] == 73) {
|
||||
if (self->private_impl.f_chunk_type != 1413563465) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
|
||||
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
}
|
||||
} else {
|
||||
if ((self->private_impl.f_chunk_type != 1413571686) || (self->private_impl.f_chunk_length < 4)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 4;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
uint32_t t_5;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_5 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_pass[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
|
||||
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
|
||||
if (num_bits_5 == 24) {
|
||||
t_5 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_5 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_5));
|
||||
}
|
||||
}
|
||||
v_seq_num = t_5;
|
||||
}
|
||||
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_next_animation_seq_num += 1;
|
||||
}
|
||||
goto label__0__continue;
|
||||
} else if (((uint64_t)(io2_a_src - iop_a_src)) > 0) {
|
||||
@@ -37998,7 +40413,7 @@ wuffs_png__decoder__decode_pass(
|
||||
goto exit;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
|
||||
}
|
||||
label__0__break:;
|
||||
if (self->private_impl.f_workbuf_wi != self->private_impl.f_pass_workbuf_length) {
|
||||
@@ -38018,7 +40433,6 @@ wuffs_png__decoder__decode_pass(
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_pass[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_pass[0].v_checksum_have = v_checksum_have;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
@@ -38043,10 +40457,10 @@ wuffs_png__decoder__frame_dirty_rect(
|
||||
}
|
||||
|
||||
return wuffs_base__utility__make_rect_ie_u32(
|
||||
0,
|
||||
0,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height);
|
||||
self->private_impl.f_frame_rect_x0,
|
||||
self->private_impl.f_frame_rect_y0,
|
||||
self->private_impl.f_frame_rect_x1,
|
||||
self->private_impl.f_frame_rect_y1);
|
||||
}
|
||||
|
||||
// -------- func png.decoder.num_animation_loops
|
||||
@@ -38062,7 +40476,7 @@ wuffs_png__decoder__num_animation_loops(
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return self->private_impl.f_num_animation_loops_value;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.num_decoded_frame_configs
|
||||
@@ -38078,10 +40492,7 @@ wuffs_png__decoder__num_decoded_frame_configs(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (self->private_impl.f_call_sequence > 3) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
return ((uint64_t)(self->private_impl.f_num_decoded_frame_configs_value));
|
||||
}
|
||||
|
||||
// -------- func png.decoder.num_decoded_frames
|
||||
@@ -38097,10 +40508,7 @@ wuffs_png__decoder__num_decoded_frames(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (self->private_impl.f_call_sequence > 4) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
return ((uint64_t)(self->private_impl.f_num_decoded_frames_value));
|
||||
}
|
||||
|
||||
// -------- func png.decoder.restart_frame
|
||||
@@ -38122,8 +40530,7 @@ wuffs_png__decoder__restart_frame(
|
||||
|
||||
if (self->private_impl.f_call_sequence < 3) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
}
|
||||
if (a_index != 0) {
|
||||
} else if ((a_index >= ((uint64_t)(self->private_impl.f_num_animation_frames_value))) || ((a_index == 0) && (a_io_position != self->private_impl.f_first_config_io_position))) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
self->private_impl.f_call_sequence = 3;
|
||||
@@ -38131,6 +40538,8 @@ wuffs_png__decoder__restart_frame(
|
||||
self->private_impl.f_interlace_pass = 1;
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = a_io_position;
|
||||
self->private_impl.f_num_decoded_frame_configs_value = ((uint32_t)((a_index & 4294967295)));
|
||||
self->private_impl.f_num_decoded_frames_value = self->private_impl.f_num_decoded_frame_configs_value;
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
@@ -38141,6 +40550,26 @@ wuffs_png__decoder__set_report_metadata(
|
||||
wuffs_png__decoder* self,
|
||||
uint32_t a_fourcc,
|
||||
bool a_report) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
if (a_fourcc == 1128813133) {
|
||||
self->private_impl.f_report_metadata_chrm = a_report;
|
||||
} else if (a_fourcc == 1163413830) {
|
||||
self->private_impl.f_report_metadata_exif = a_report;
|
||||
} else if (a_fourcc == 1195461953) {
|
||||
self->private_impl.f_report_metadata_gama = a_report;
|
||||
} else if (a_fourcc == 1229144912) {
|
||||
self->private_impl.f_report_metadata_iccp = a_report;
|
||||
} else if (a_fourcc == 1263947808) {
|
||||
self->private_impl.f_report_metadata_kvp = a_report;
|
||||
} else if (a_fourcc == 1397901122) {
|
||||
self->private_impl.f_report_metadata_srgb = a_report;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
@@ -38173,13 +40602,498 @@ wuffs_png__decoder__tell_me_more(
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
status = wuffs_base__make_status(wuffs_base__error__no_more_information);
|
||||
goto exit;
|
||||
uint8_t v_c = 0;
|
||||
uint16_t v_c2 = 0;
|
||||
wuffs_base__io_buffer u_w = wuffs_base__empty_io_buffer();
|
||||
wuffs_base__io_buffer* v_w = &u_w;
|
||||
uint8_t* iop_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io0_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io1_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io2_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint64_t v_num_written = 0;
|
||||
uint64_t v_w_mark = 0;
|
||||
uint64_t v_r_mark = 0;
|
||||
wuffs_base__status v_zlib_status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint8_t* iop_a_dst = NULL;
|
||||
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io1_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io2_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_dst) {
|
||||
io0_a_dst = a_dst->data.ptr;
|
||||
io1_a_dst = io0_a_dst + a_dst->meta.wi;
|
||||
iop_a_dst = io1_a_dst;
|
||||
io2_a_dst = io0_a_dst + a_dst->data.len;
|
||||
if (a_dst->meta.closed) {
|
||||
io2_a_dst = iop_a_dst;
|
||||
}
|
||||
}
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_tell_me_more[0];
|
||||
if (coro_susp_point) {
|
||||
v_zlib_status = self->private_data.s_tell_me_more[0].v_zlib_status;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence != 1) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
goto exit;
|
||||
}
|
||||
if (self->private_impl.f_metadata_fourcc == 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__no_more_information);
|
||||
goto exit;
|
||||
}
|
||||
while (true) {
|
||||
if (self->private_impl.f_metadata_flavor == 3) {
|
||||
while (true) {
|
||||
if (wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_y) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
|
||||
goto exit;
|
||||
} else if (a_minfo != NULL) {
|
||||
wuffs_base__more_information__set(a_minfo,
|
||||
self->private_impl.f_metadata_flavor,
|
||||
self->private_impl.f_metadata_fourcc,
|
||||
self->private_impl.f_metadata_x,
|
||||
self->private_impl.f_metadata_y,
|
||||
self->private_impl.f_metadata_z);
|
||||
}
|
||||
if (self->private_impl.f_metadata_y >= self->private_impl.f_metadata_z) {
|
||||
goto label__goto_done__break;
|
||||
}
|
||||
self->private_impl.f_metadata_y = self->private_impl.f_metadata_z;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__even_more_information);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
}
|
||||
if (self->private_impl.f_metadata_is_zlib_compressed) {
|
||||
if (self->private_impl.f_zlib_is_dirty) {
|
||||
wuffs_base__ignore_status(wuffs_zlib__decoder__initialize(&self->private_data.f_zlib,
|
||||
sizeof (wuffs_zlib__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
if (self->private_impl.f_ignore_checksum) {
|
||||
wuffs_zlib__decoder__set_quirk_enabled(&self->private_data.f_zlib, 1, true);
|
||||
}
|
||||
}
|
||||
self->private_impl.f_zlib_is_dirty = true;
|
||||
self->private_impl.f_ztxt_hist_pos = 0;
|
||||
}
|
||||
label__loop__continue:;
|
||||
while (true) {
|
||||
if (a_minfo != NULL) {
|
||||
wuffs_base__more_information__set(a_minfo,
|
||||
self->private_impl.f_metadata_flavor,
|
||||
self->private_impl.f_metadata_fourcc,
|
||||
self->private_impl.f_metadata_x,
|
||||
self->private_impl.f_metadata_y,
|
||||
self->private_impl.f_metadata_z);
|
||||
}
|
||||
if (self->private_impl.f_metadata_flavor != 4) {
|
||||
goto label__loop__break;
|
||||
}
|
||||
if (self->private_impl.f_metadata_is_zlib_compressed) {
|
||||
if (self->private_impl.f_chunk_type == 1346585449) {
|
||||
{
|
||||
const uint8_t *o_0_io2_a_src = io2_a_src;
|
||||
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_chunk_length)));
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_dst) {
|
||||
a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_0 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, a_dst, a_src, wuffs_base__utility__empty_slice_u8());
|
||||
v_zlib_status = t_0;
|
||||
if (a_dst) {
|
||||
iop_a_dst = a_dst->data.ptr + a_dst->meta.wi;
|
||||
}
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
|
||||
io2_a_src = o_0_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_zlib_status)) {
|
||||
self->private_impl.f_metadata_is_zlib_compressed = false;
|
||||
goto label__loop__break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
|
||||
status = v_zlib_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
status = v_zlib_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
|
||||
} else if (self->private_impl.f_chunk_type == 1951945833) {
|
||||
{
|
||||
const uint8_t *o_1_io2_a_src = io2_a_src;
|
||||
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_chunk_length)));
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_dst) {
|
||||
a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_1 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, a_dst, a_src, wuffs_base__utility__empty_slice_u8());
|
||||
v_zlib_status = t_1;
|
||||
if (a_dst) {
|
||||
iop_a_dst = a_dst->data.ptr + a_dst->meta.wi;
|
||||
}
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
|
||||
io2_a_src = o_1_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_zlib_status)) {
|
||||
self->private_impl.f_metadata_is_zlib_compressed = false;
|
||||
goto label__loop__break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
|
||||
status = v_zlib_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
status = v_zlib_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
|
||||
} else if (self->private_impl.f_chunk_type == 1951945850) {
|
||||
if (self->private_impl.f_ztxt_ri == self->private_impl.f_ztxt_wi) {
|
||||
{
|
||||
wuffs_base__io_buffer* o_2_v_w = v_w;
|
||||
uint8_t *o_2_iop_v_w = iop_v_w;
|
||||
uint8_t *o_2_io0_v_w = io0_v_w;
|
||||
uint8_t *o_2_io1_v_w = io1_v_w;
|
||||
uint8_t *o_2_io2_v_w = io2_v_w;
|
||||
v_w = wuffs_base__io_writer__set(
|
||||
&u_w,
|
||||
&iop_v_w,
|
||||
&io0_v_w,
|
||||
&io1_v_w,
|
||||
&io2_v_w,
|
||||
wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024),
|
||||
self->private_impl.f_ztxt_hist_pos);
|
||||
{
|
||||
const uint8_t *o_3_io2_a_src = io2_a_src;
|
||||
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_chunk_length)));
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
v_w_mark = ((uint64_t)(iop_v_w - io0_v_w));
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
u_w.meta.wi = ((size_t)(iop_v_w - u_w.data.ptr));
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_2 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, v_w, a_src, wuffs_base__utility__empty_slice_u8());
|
||||
v_zlib_status = t_2;
|
||||
iop_v_w = u_w.data.ptr + u_w.meta.wi;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
|
||||
v_num_written = wuffs_base__io__count_since(v_w_mark, ((uint64_t)(iop_v_w - io0_v_w)));
|
||||
io2_a_src = o_3_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
v_w = o_2_v_w;
|
||||
iop_v_w = o_2_iop_v_w;
|
||||
io0_v_w = o_2_io0_v_w;
|
||||
io1_v_w = o_2_io1_v_w;
|
||||
io2_v_w = o_2_io2_v_w;
|
||||
}
|
||||
if (v_num_written > 1024) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_i_o);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_ztxt_ri = 0;
|
||||
self->private_impl.f_ztxt_wi = ((uint32_t)(v_num_written));
|
||||
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_ztxt_hist_pos, v_num_written);
|
||||
}
|
||||
while (self->private_impl.f_ztxt_ri < self->private_impl.f_ztxt_wi) {
|
||||
v_c2 = WUFFS_PNG__LATIN_1[self->private_data.f_dst_palette[self->private_impl.f_ztxt_ri]];
|
||||
if (v_c2 == 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_text_chunk_not_latin_1);
|
||||
goto exit;
|
||||
} else if (v_c2 <= 127) {
|
||||
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
|
||||
v_c2 = 0;
|
||||
goto label__loop__continue;
|
||||
}
|
||||
self->private_impl.f_ztxt_ri += 1;
|
||||
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(v_c2))), iop_a_dst += 1);
|
||||
} else {
|
||||
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 1) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
v_c2 = 0;
|
||||
goto label__loop__continue;
|
||||
}
|
||||
self->private_impl.f_ztxt_ri += 1;
|
||||
(wuffs_base__poke_u16le__no_bounds_check(iop_a_dst, v_c2), iop_a_dst += 2);
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_zlib_status)) {
|
||||
self->private_impl.f_metadata_is_zlib_compressed = false;
|
||||
goto label__loop__break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
|
||||
status = v_zlib_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
} else if (v_zlib_status.repr != wuffs_base__suspension__short_write) {
|
||||
status = v_zlib_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
|
||||
}
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_chunk_type);
|
||||
goto exit;
|
||||
}
|
||||
} else if ((self->private_impl.f_chunk_type == 1951945833) && (self->private_impl.f_metadata_fourcc == 1263947862)) {
|
||||
while (true) {
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
goto label__loop__break;
|
||||
} else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
|
||||
goto label__loop__continue;
|
||||
} else if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(8);
|
||||
goto label__loop__continue;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 1;
|
||||
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, v_c), iop_a_dst += 1);
|
||||
}
|
||||
} else {
|
||||
while (true) {
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
if (self->private_impl.f_metadata_fourcc == 1263947851) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
goto label__loop__break;
|
||||
} else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
|
||||
goto label__loop__continue;
|
||||
}
|
||||
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
|
||||
if (v_c == 0) {
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
iop_a_src += 1;
|
||||
goto label__loop__break;
|
||||
}
|
||||
v_c2 = WUFFS_PNG__LATIN_1[v_c];
|
||||
if (v_c2 == 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_text_chunk_not_latin_1);
|
||||
goto exit;
|
||||
} else if (v_c2 <= 127) {
|
||||
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
|
||||
v_c2 = 0;
|
||||
goto label__loop__continue;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
iop_a_src += 1;
|
||||
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(v_c2))), iop_a_dst += 1);
|
||||
} else {
|
||||
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 1) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
|
||||
v_c2 = 0;
|
||||
goto label__loop__continue;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
iop_a_src += 1;
|
||||
(wuffs_base__poke_u16le__no_bounds_check(iop_a_dst, v_c2), iop_a_dst += 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
label__loop__break:;
|
||||
if (self->private_impl.f_metadata_fourcc == 1263947851) {
|
||||
self->private_impl.f_metadata_fourcc = 1263947862;
|
||||
if (self->private_impl.f_chunk_type == 1951945833) {
|
||||
if (self->private_impl.f_chunk_length <= 1) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 2;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_3 = *iop_a_src++;
|
||||
v_c = t_3;
|
||||
}
|
||||
if (v_c == 0) {
|
||||
self->private_impl.f_metadata_is_zlib_compressed = false;
|
||||
} else if (v_c == 1) {
|
||||
self->private_impl.f_metadata_is_zlib_compressed = true;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_4 = *iop_a_src++;
|
||||
v_c = t_4;
|
||||
}
|
||||
if ((v_c != 0) && self->private_impl.f_metadata_is_zlib_compressed) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_metadata_fourcc -= 2;
|
||||
while (self->private_impl.f_metadata_fourcc != 1263947862) {
|
||||
self->private_impl.f_metadata_fourcc += 1;
|
||||
while (true) {
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_5 = *iop_a_src++;
|
||||
v_c = t_5;
|
||||
}
|
||||
if (v_c == 0) {
|
||||
goto label__0__break;
|
||||
}
|
||||
}
|
||||
label__0__break:;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1951945850) {
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_6 = *iop_a_src++;
|
||||
v_c = t_6;
|
||||
}
|
||||
if (v_c != 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_metadata_is_zlib_compressed = true;
|
||||
}
|
||||
self->private_impl.f_call_sequence = 2;
|
||||
status = wuffs_base__make_status(NULL);
|
||||
goto ok;
|
||||
}
|
||||
goto label__goto_done__break;
|
||||
}
|
||||
label__goto_done__break:;
|
||||
if (self->private_impl.f_chunk_length != 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_data.s_tell_me_more[0].scratch = 4;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
|
||||
if (self->private_data.s_tell_me_more[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_tell_me_more[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_tell_me_more[0].scratch;
|
||||
self->private_impl.f_metadata_flavor = 0;
|
||||
self->private_impl.f_metadata_fourcc = 0;
|
||||
self->private_impl.f_metadata_x = 0;
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
self->private_impl.f_call_sequence = 2;
|
||||
status = wuffs_base__make_status(NULL);
|
||||
goto ok;
|
||||
|
||||
ok:
|
||||
self->private_impl.p_tell_me_more[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_tell_me_more[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 4 : 0;
|
||||
self->private_data.s_tell_me_more[0].v_zlib_status = v_zlib_status;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_dst) {
|
||||
a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
}
|
||||
@@ -38220,7 +41134,8 @@ wuffs_png__decoder__filter_and_swizzle__choosy_default(
|
||||
wuffs_base__pixel_format v_dst_pixfmt = {0};
|
||||
uint32_t v_dst_bits_per_pixel = 0;
|
||||
uint64_t v_dst_bytes_per_pixel = 0;
|
||||
uint64_t v_dst_bytes_per_row = 0;
|
||||
uint64_t v_dst_bytes_per_row0 = 0;
|
||||
uint64_t v_dst_bytes_per_row1 = 0;
|
||||
wuffs_base__slice_u8 v_dst_palette = {0};
|
||||
wuffs_base__table_u8 v_tab = {0};
|
||||
uint32_t v_y = 0;
|
||||
@@ -38235,14 +41150,33 @@ wuffs_png__decoder__filter_and_swizzle__choosy_default(
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
|
||||
v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
|
||||
v_dst_bytes_per_row0 = (((uint64_t)(self->private_impl.f_frame_rect_x0)) * v_dst_bytes_per_pixel);
|
||||
v_dst_bytes_per_row1 = (((uint64_t)(self->private_impl.f_frame_rect_x1)) * v_dst_bytes_per_pixel);
|
||||
v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024));
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, v_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
}
|
||||
if (v_dst_bytes_per_row1 < ((uint64_t)(v_tab.width))) {
|
||||
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
|
||||
0,
|
||||
0,
|
||||
v_dst_bytes_per_row1,
|
||||
((uint64_t)(v_tab.height)));
|
||||
}
|
||||
if (v_dst_bytes_per_row0 < ((uint64_t)(v_tab.width))) {
|
||||
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
|
||||
v_dst_bytes_per_row0,
|
||||
0,
|
||||
((uint64_t)(v_tab.width)),
|
||||
((uint64_t)(v_tab.height)));
|
||||
} else {
|
||||
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0);
|
||||
}
|
||||
v_y = self->private_impl.f_frame_rect_y0;
|
||||
while (v_y < self->private_impl.f_frame_rect_y1) {
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_y);
|
||||
if (1 > ((uint64_t)(a_workbuf.len))) {
|
||||
return wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_workbuf_length);
|
||||
}
|
||||
@@ -38282,7 +41216,7 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
wuffs_base__pixel_format v_dst_pixfmt = {0};
|
||||
uint32_t v_dst_bits_per_pixel = 0;
|
||||
uint64_t v_dst_bytes_per_pixel = 0;
|
||||
uint64_t v_dst_bytes_per_row = 0;
|
||||
uint64_t v_dst_bytes_per_row1 = 0;
|
||||
wuffs_base__slice_u8 v_dst_palette = {0};
|
||||
wuffs_base__table_u8 v_tab = {0};
|
||||
uint64_t v_src_bytes_per_pixel = 0;
|
||||
@@ -38306,26 +41240,22 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
|
||||
v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
|
||||
v_dst_bytes_per_row1 = (((uint64_t)(self->private_impl.f_frame_rect_x1)) * v_dst_bytes_per_pixel);
|
||||
v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024));
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
|
||||
v_src_bytes_per_pixel = 1;
|
||||
if (self->private_impl.f_depth >= 8) {
|
||||
v_src_bytes_per_pixel = (((uint64_t)(WUFFS_PNG__NUM_CHANNELS[self->private_impl.f_color_type])) * ((uint64_t)((self->private_impl.f_depth >> 3))));
|
||||
}
|
||||
v_bits_unpacked[0] = 255;
|
||||
v_bits_unpacked[1] = 255;
|
||||
v_bits_unpacked[2] = 255;
|
||||
v_bits_unpacked[3] = 255;
|
||||
v_bits_unpacked[4] = 255;
|
||||
v_bits_unpacked[5] = 255;
|
||||
v_bits_unpacked[6] = 255;
|
||||
v_bits_unpacked[7] = 255;
|
||||
v_y = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][5]));
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, v_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
if (self->private_impl.f_chunk_type_array[0] == 73) {
|
||||
v_y = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][5]));
|
||||
} else {
|
||||
v_y = self->private_impl.f_frame_rect_y0;
|
||||
}
|
||||
while (v_y < self->private_impl.f_frame_rect_y1) {
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_y);
|
||||
if (v_dst_bytes_per_row1 < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row1);
|
||||
}
|
||||
if (1 > ((uint64_t)(a_workbuf.len))) {
|
||||
return wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_workbuf_length);
|
||||
@@ -38350,9 +41280,13 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
return wuffs_base__make_status(wuffs_png__error__bad_filter);
|
||||
}
|
||||
v_s = v_curr_row;
|
||||
v_x = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][2]));
|
||||
if (self->private_impl.f_chunk_type_array[0] == 73) {
|
||||
v_x = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][2]));
|
||||
} else {
|
||||
v_x = self->private_impl.f_frame_rect_x0;
|
||||
}
|
||||
if (self->private_impl.f_depth == 8) {
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
while (v_x < self->private_impl.f_frame_rect_x1) {
|
||||
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
|
||||
if (v_i <= ((uint64_t)(v_dst.len))) {
|
||||
if (self->private_impl.f_color_type == 4) {
|
||||
@@ -38364,6 +41298,44 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, 2);
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
|
||||
}
|
||||
} else if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) != 0) {
|
||||
if (self->private_impl.f_color_type == 0) {
|
||||
if (1 <= ((uint64_t)(v_s.len))) {
|
||||
v_bits_unpacked[0] = v_s.ptr[0];
|
||||
v_bits_unpacked[1] = v_s.ptr[0];
|
||||
v_bits_unpacked[2] = v_s.ptr[0];
|
||||
v_bits_unpacked[3] = 255;
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, 1);
|
||||
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
|
||||
(((uint32_t)(v_bits_unpacked[1])) << 8) |
|
||||
(((uint32_t)(v_bits_unpacked[2])) << 16) |
|
||||
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
|
||||
v_bits_unpacked[0] = 0;
|
||||
v_bits_unpacked[1] = 0;
|
||||
v_bits_unpacked[2] = 0;
|
||||
v_bits_unpacked[3] = 0;
|
||||
}
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
|
||||
}
|
||||
} else {
|
||||
if (3 <= ((uint64_t)(v_s.len))) {
|
||||
v_bits_unpacked[0] = v_s.ptr[2];
|
||||
v_bits_unpacked[1] = v_s.ptr[1];
|
||||
v_bits_unpacked[2] = v_s.ptr[0];
|
||||
v_bits_unpacked[3] = 255;
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, 3);
|
||||
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
|
||||
(((uint32_t)(v_bits_unpacked[1])) << 8) |
|
||||
(((uint32_t)(v_bits_unpacked[2])) << 16) |
|
||||
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
|
||||
v_bits_unpacked[0] = 0;
|
||||
v_bits_unpacked[1] = 0;
|
||||
v_bits_unpacked[2] = 0;
|
||||
v_bits_unpacked[3] = 0;
|
||||
}
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
|
||||
}
|
||||
}
|
||||
} else if (v_src_bytes_per_pixel <= ((uint64_t)(v_s.len))) {
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__slice_u8__subslice_j(v_s, v_src_bytes_per_pixel));
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, v_src_bytes_per_pixel);
|
||||
@@ -38378,7 +41350,7 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
}
|
||||
v_shift = ((8 - self->private_impl.f_depth) & 7);
|
||||
v_packs_remaining = 0;
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
while (v_x < self->private_impl.f_frame_rect_x1) {
|
||||
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
|
||||
if (v_i <= ((uint64_t)(v_dst.len))) {
|
||||
if ((v_packs_remaining == 0) && (1 <= ((uint64_t)(v_s.len)))) {
|
||||
@@ -38389,12 +41361,28 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
v_bits_unpacked[0] = ((uint8_t)((v_bits_packed >> v_shift) * v_multiplier));
|
||||
v_bits_packed = ((uint8_t)(v_bits_packed << self->private_impl.f_depth));
|
||||
v_packs_remaining = ((uint8_t)(v_packs_remaining - 1));
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 1));
|
||||
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) != 0) {
|
||||
v_bits_unpacked[1] = v_bits_unpacked[0];
|
||||
v_bits_unpacked[2] = v_bits_unpacked[0];
|
||||
v_bits_unpacked[3] = 255;
|
||||
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
|
||||
(((uint32_t)(v_bits_unpacked[1])) << 8) |
|
||||
(((uint32_t)(v_bits_unpacked[2])) << 16) |
|
||||
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
|
||||
v_bits_unpacked[0] = 0;
|
||||
v_bits_unpacked[1] = 0;
|
||||
v_bits_unpacked[2] = 0;
|
||||
v_bits_unpacked[3] = 0;
|
||||
}
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
|
||||
} else {
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 1));
|
||||
}
|
||||
}
|
||||
v_x += (((uint32_t)(1)) << WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]);
|
||||
}
|
||||
} else {
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
while (v_x < self->private_impl.f_frame_rect_x1) {
|
||||
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
|
||||
if (v_i <= ((uint64_t)(v_dst.len))) {
|
||||
if (self->private_impl.f_color_type == 0) {
|
||||
@@ -38405,7 +41393,26 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
v_bits_unpacked[3] = v_s.ptr[0];
|
||||
v_bits_unpacked[4] = v_s.ptr[1];
|
||||
v_bits_unpacked[5] = v_s.ptr[0];
|
||||
v_bits_unpacked[6] = 255;
|
||||
v_bits_unpacked[7] = 255;
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, 2);
|
||||
if (self->private_impl.f_remap_transparency == ((((uint64_t)(v_bits_unpacked[0])) << 0) |
|
||||
(((uint64_t)(v_bits_unpacked[1])) << 8) |
|
||||
(((uint64_t)(v_bits_unpacked[2])) << 16) |
|
||||
(((uint64_t)(v_bits_unpacked[3])) << 24) |
|
||||
(((uint64_t)(v_bits_unpacked[4])) << 32) |
|
||||
(((uint64_t)(v_bits_unpacked[5])) << 40) |
|
||||
(((uint64_t)(v_bits_unpacked[6])) << 48) |
|
||||
(((uint64_t)(v_bits_unpacked[7])) << 56))) {
|
||||
v_bits_unpacked[0] = 0;
|
||||
v_bits_unpacked[1] = 0;
|
||||
v_bits_unpacked[2] = 0;
|
||||
v_bits_unpacked[3] = 0;
|
||||
v_bits_unpacked[4] = 0;
|
||||
v_bits_unpacked[5] = 0;
|
||||
v_bits_unpacked[6] = 0;
|
||||
v_bits_unpacked[7] = 0;
|
||||
}
|
||||
}
|
||||
} else if (self->private_impl.f_color_type == 2) {
|
||||
if (6 <= ((uint64_t)(v_s.len))) {
|
||||
@@ -38415,7 +41422,26 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
v_bits_unpacked[3] = v_s.ptr[2];
|
||||
v_bits_unpacked[4] = v_s.ptr[1];
|
||||
v_bits_unpacked[5] = v_s.ptr[0];
|
||||
v_bits_unpacked[6] = 255;
|
||||
v_bits_unpacked[7] = 255;
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, 6);
|
||||
if (self->private_impl.f_remap_transparency == ((((uint64_t)(v_bits_unpacked[0])) << 0) |
|
||||
(((uint64_t)(v_bits_unpacked[1])) << 8) |
|
||||
(((uint64_t)(v_bits_unpacked[2])) << 16) |
|
||||
(((uint64_t)(v_bits_unpacked[3])) << 24) |
|
||||
(((uint64_t)(v_bits_unpacked[4])) << 32) |
|
||||
(((uint64_t)(v_bits_unpacked[5])) << 40) |
|
||||
(((uint64_t)(v_bits_unpacked[6])) << 48) |
|
||||
(((uint64_t)(v_bits_unpacked[7])) << 56))) {
|
||||
v_bits_unpacked[0] = 0;
|
||||
v_bits_unpacked[1] = 0;
|
||||
v_bits_unpacked[2] = 0;
|
||||
v_bits_unpacked[3] = 0;
|
||||
v_bits_unpacked[4] = 0;
|
||||
v_bits_unpacked[5] = 0;
|
||||
v_bits_unpacked[6] = 0;
|
||||
v_bits_unpacked[7] = 0;
|
||||
}
|
||||
}
|
||||
} else if (self->private_impl.f_color_type == 4) {
|
||||
if (4 <= ((uint64_t)(v_s.len))) {
|
||||
@@ -38689,7 +41715,7 @@ wuffs_wbmp__decoder__decode_image_config(
|
||||
}
|
||||
v_i += 1;
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
if (a_dst != NULL) {
|
||||
wuffs_base__image_config__set(
|
||||
a_dst,
|
||||
@@ -38783,7 +41809,7 @@ wuffs_wbmp__decoder__decode_frame_config(
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 3) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
}
|
||||
@@ -38943,7 +41969,7 @@ wuffs_wbmp__decoder__decode_frame(
|
||||
if (self->private_impl.f_width > 0) {
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
|
||||
while (v_dst_y < self->private_impl.f_height) {
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, v_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_dst_y);
|
||||
v_dst_x = 0;
|
||||
while (v_dst_x < self->private_impl.f_width) {
|
||||
if ((v_dst_x & 7) == 0) {
|
||||
@@ -38951,7 +41977,7 @@ wuffs_wbmp__decoder__decode_frame(
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, v_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_dst_y);
|
||||
v_dst_x_in_bytes = (((uint64_t)(v_dst_x)) * v_dst_bytes_per_pixel);
|
||||
if (v_dst_x_in_bytes <= ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_dst_x_in_bytes);
|
||||
@@ -39191,6 +42217,71 @@ namespace sync_io {
|
||||
|
||||
// --------
|
||||
|
||||
DynIOBuffer::DynIOBuffer(uint64_t max_incl)
|
||||
: m_buf(wuffs_base__empty_io_buffer()), m_max_incl(max_incl) {}
|
||||
|
||||
DynIOBuffer::~DynIOBuffer() {
|
||||
if (m_buf.data.ptr) {
|
||||
free(m_buf.data.ptr);
|
||||
}
|
||||
}
|
||||
|
||||
void //
|
||||
DynIOBuffer::drop() {
|
||||
if (m_buf.data.ptr) {
|
||||
free(m_buf.data.ptr);
|
||||
}
|
||||
m_buf = wuffs_base__empty_io_buffer();
|
||||
}
|
||||
|
||||
DynIOBuffer::GrowResult //
|
||||
DynIOBuffer::grow(uint64_t min_incl) {
|
||||
uint64_t n = round_up(min_incl, m_max_incl);
|
||||
if (n == 0) {
|
||||
return ((min_incl == 0) && (m_max_incl == 0))
|
||||
? DynIOBuffer::GrowResult::OK
|
||||
: DynIOBuffer::GrowResult::FailedMaxInclExceeded;
|
||||
} else if (n > m_buf.data.len) {
|
||||
uint8_t* ptr = static_cast<uint8_t*>(realloc(m_buf.data.ptr, n));
|
||||
if (!ptr) {
|
||||
return DynIOBuffer::GrowResult::FailedOutOfMemory;
|
||||
}
|
||||
m_buf.data.ptr = ptr;
|
||||
m_buf.data.len = n;
|
||||
}
|
||||
return DynIOBuffer::GrowResult::OK;
|
||||
}
|
||||
|
||||
// round_up rounds min_incl up, returning the smallest value x satisfying
|
||||
// (min_incl <= x) and (x <= max_incl) and some other constraints. It returns 0
|
||||
// if there is no such x.
|
||||
//
|
||||
// When max_incl <= 4096, the other constraints are:
|
||||
// - (x == max_incl)
|
||||
//
|
||||
// When max_incl > 4096, the other constraints are:
|
||||
// - (x == max_incl) or (x is a power of 2)
|
||||
// - (x >= 4096)
|
||||
uint64_t //
|
||||
DynIOBuffer::round_up(uint64_t min_incl, uint64_t max_incl) {
|
||||
if (min_incl > max_incl) {
|
||||
return 0;
|
||||
}
|
||||
uint64_t n = 4096;
|
||||
if (n >= max_incl) {
|
||||
return max_incl;
|
||||
}
|
||||
while (n < min_incl) {
|
||||
if (n >= (max_incl / 2)) {
|
||||
return max_incl;
|
||||
}
|
||||
n *= 2;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
Input::~Input() {}
|
||||
|
||||
IOBuffer* //
|
||||
@@ -39265,6 +42356,164 @@ MemoryInput::CopyIn(IOBuffer* dst) {
|
||||
|
||||
} // namespace sync_io
|
||||
|
||||
namespace private_impl {
|
||||
|
||||
struct ErrorMessages {
|
||||
const char* max_incl_metadata_length_exceeded;
|
||||
const char* out_of_memory;
|
||||
const char* unexpected_end_of_file;
|
||||
const char* unsupported_metadata;
|
||||
const char* unsupported_negative_advance;
|
||||
|
||||
// If adding new "const char*" typed fields to this struct, either add them
|
||||
// after existing fields or, if re-ordering fields, make sure that you update
|
||||
// all of the "const private_impl::ErrorMessages FooBarErrorMessages" values
|
||||
// in all of the sibling *.cc files.
|
||||
|
||||
static inline const char* resolve(const char* s) {
|
||||
return s ? s : "wuffs_aux::private_impl: unknown error";
|
||||
};
|
||||
};
|
||||
|
||||
std::string //
|
||||
AdvanceIOBufferTo(const ErrorMessages& error_messages,
|
||||
sync_io::Input& input,
|
||||
IOBuffer& io_buf,
|
||||
uint64_t absolute_position) {
|
||||
if (absolute_position < io_buf.reader_position()) {
|
||||
return error_messages.resolve(error_messages.unsupported_negative_advance);
|
||||
}
|
||||
while (true) {
|
||||
uint64_t relative_position = absolute_position - io_buf.reader_position();
|
||||
if (relative_position <= io_buf.reader_length()) {
|
||||
io_buf.meta.ri += (size_t)relative_position;
|
||||
break;
|
||||
} else if (io_buf.meta.closed) {
|
||||
return error_messages.resolve(error_messages.unexpected_end_of_file);
|
||||
}
|
||||
io_buf.meta.ri = io_buf.meta.wi;
|
||||
if (!input.BringsItsOwnIOBuffer()) {
|
||||
io_buf.compact();
|
||||
}
|
||||
std::string error_message = input.CopyIn(&io_buf);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
std::string //
|
||||
HandleMetadata(
|
||||
const ErrorMessages& error_messages,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
sync_io::DynIOBuffer& raw,
|
||||
wuffs_base__status (*tell_me_more_func)(void*,
|
||||
wuffs_base__io_buffer*,
|
||||
wuffs_base__more_information*,
|
||||
wuffs_base__io_buffer*),
|
||||
void* tell_me_more_receiver,
|
||||
std::string (*handle_metadata_func)(void*,
|
||||
const wuffs_base__more_information*,
|
||||
wuffs_base__slice_u8),
|
||||
void* handle_metadata_receiver) {
|
||||
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
|
||||
// Reset raw but keep its backing array (the raw.m_buf.data slice).
|
||||
raw.m_buf.meta = wuffs_base__empty_io_buffer_meta();
|
||||
|
||||
while (true) {
|
||||
minfo = wuffs_base__empty_more_information();
|
||||
wuffs_base__status status = (*tell_me_more_func)(
|
||||
tell_me_more_receiver, &raw.m_buf, &minfo, &io_buf);
|
||||
switch (minfo.flavor) {
|
||||
case 0:
|
||||
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM:
|
||||
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED:
|
||||
break;
|
||||
|
||||
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH: {
|
||||
wuffs_base__range_ie_u64 r = minfo.metadata_raw_passthrough__range();
|
||||
if (r.is_empty()) {
|
||||
break;
|
||||
}
|
||||
uint64_t num_to_copy = r.length();
|
||||
if (num_to_copy > (raw.m_max_incl - raw.m_buf.meta.wi)) {
|
||||
return error_messages.resolve(
|
||||
error_messages.max_incl_metadata_length_exceeded);
|
||||
} else if (num_to_copy > (raw.m_buf.data.len - raw.m_buf.meta.wi)) {
|
||||
switch (raw.grow(num_to_copy + raw.m_buf.meta.wi)) {
|
||||
case sync_io::DynIOBuffer::GrowResult::OK:
|
||||
break;
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
|
||||
return error_messages.resolve(
|
||||
error_messages.max_incl_metadata_length_exceeded);
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
|
||||
return error_messages.resolve(error_messages.out_of_memory);
|
||||
}
|
||||
}
|
||||
|
||||
if (io_buf.reader_position() > r.min_incl) {
|
||||
return error_messages.resolve(error_messages.unsupported_metadata);
|
||||
} else {
|
||||
std::string error_message =
|
||||
AdvanceIOBufferTo(error_messages, input, io_buf, r.min_incl);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
|
||||
while (true) {
|
||||
uint64_t n =
|
||||
wuffs_base__u64__min(num_to_copy, io_buf.reader_length());
|
||||
memcpy(raw.m_buf.writer_pointer(), io_buf.reader_pointer(), n);
|
||||
raw.m_buf.meta.wi += n;
|
||||
io_buf.meta.ri += n;
|
||||
num_to_copy -= n;
|
||||
if (num_to_copy == 0) {
|
||||
break;
|
||||
} else if (io_buf.meta.closed) {
|
||||
return error_messages.resolve(
|
||||
error_messages.unexpected_end_of_file);
|
||||
} else if (!input.BringsItsOwnIOBuffer()) {
|
||||
io_buf.compact();
|
||||
}
|
||||
std::string error_message = input.CopyIn(&io_buf);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
return error_messages.resolve(error_messages.unsupported_metadata);
|
||||
}
|
||||
|
||||
if (status.repr == nullptr) {
|
||||
break;
|
||||
} else if (status.repr != wuffs_base__suspension__even_more_information) {
|
||||
if (status.repr != wuffs_base__suspension__short_write) {
|
||||
return status.message();
|
||||
}
|
||||
switch (raw.grow(wuffs_base__u64__sat_add(raw.m_buf.data.len, 1))) {
|
||||
case sync_io::DynIOBuffer::GrowResult::OK:
|
||||
break;
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
|
||||
return error_messages.resolve(
|
||||
error_messages.max_incl_metadata_length_exceeded);
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
|
||||
return error_messages.resolve(error_messages.out_of_memory);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (*handle_metadata_func)(handle_metadata_receiver, &minfo,
|
||||
raw.m_buf.reader_slice());
|
||||
}
|
||||
|
||||
} // namespace private_impl
|
||||
|
||||
} // namespace wuffs_aux
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) ||
|
||||
@@ -39290,10 +42539,21 @@ DecodeCborCallbacks::Done(DecodeCborResult& result,
|
||||
sync_io::Input& input,
|
||||
IOBuffer& buffer) {}
|
||||
|
||||
DecodeCborArgQuirks::DecodeCborArgQuirks(wuffs_base__slice_u32 repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeCborArgQuirks::DecodeCborArgQuirks(uint32_t* ptr0, size_t len0)
|
||||
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
|
||||
|
||||
DecodeCborArgQuirks //
|
||||
DecodeCborArgQuirks::DefaultValue() {
|
||||
return DecodeCborArgQuirks(wuffs_base__empty_slice_u32());
|
||||
}
|
||||
|
||||
DecodeCborResult //
|
||||
DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks) {
|
||||
DecodeCborArgQuirks quirks) {
|
||||
// Prepare the wuffs_base__io_buffer and the resultant error_message.
|
||||
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
|
||||
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
|
||||
@@ -39313,11 +42573,11 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
// Prepare the low-level CBOR decoder.
|
||||
wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();
|
||||
if (!dec) {
|
||||
ret_error_message = "wuffs_aux::CborDecoder: out of memory";
|
||||
ret_error_message = "wuffs_aux::DecodeCbor: out of memory";
|
||||
goto done;
|
||||
}
|
||||
for (size_t i = 0; i < quirks.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.ptr[i], true);
|
||||
for (size_t i = 0; i < quirks.repr.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
|
||||
}
|
||||
|
||||
// Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.
|
||||
@@ -39328,7 +42588,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
|
||||
|
||||
// Prepare other state.
|
||||
uint32_t depth = 0;
|
||||
int32_t depth = 0;
|
||||
std::string str;
|
||||
int64_t extension_category = 0;
|
||||
uint64_t extension_detail = 0;
|
||||
@@ -39355,17 +42615,17 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
goto done;
|
||||
} else if (cursor_index != io_buf->meta.ri) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad cursor_index";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad cursor_index";
|
||||
goto done;
|
||||
} else if (io_buf->meta.closed) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: io_buf is closed";
|
||||
"wuffs_aux::DecodeCbor: internal error: io_buf is closed";
|
||||
goto done;
|
||||
}
|
||||
io_buf->compact();
|
||||
if (io_buf->meta.wi >= io_buf->data.len) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: io_buf is full";
|
||||
"wuffs_aux::DecodeCbor: internal error: io_buf is full";
|
||||
goto done;
|
||||
}
|
||||
cursor_index = io_buf->meta.ri;
|
||||
@@ -39377,11 +42637,19 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
|
||||
if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad WORKBUF_LEN";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad WORKBUF_LEN";
|
||||
goto done;
|
||||
}
|
||||
wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8();
|
||||
tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf);
|
||||
if ((tok_buf.meta.ri > tok_buf.meta.wi) ||
|
||||
(tok_buf.meta.wi > tok_buf.data.len) ||
|
||||
(io_buf->meta.ri > io_buf->meta.wi) ||
|
||||
(io_buf->meta.wi > io_buf->data.len)) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeCbor: internal error: bad buffer indexes";
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];
|
||||
@@ -39389,7 +42657,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
if ((io_buf->meta.ri < cursor_index) ||
|
||||
((io_buf->meta.ri - cursor_index) < token_len)) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad token indexes";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad token indexes";
|
||||
goto done;
|
||||
}
|
||||
uint8_t* token_ptr = io_buf->data.ptr + cursor_index;
|
||||
@@ -39425,7 +42693,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
}
|
||||
}
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad extended token";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad extended token";
|
||||
goto done;
|
||||
}
|
||||
|
||||
@@ -39440,10 +42708,20 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
goto done;
|
||||
}
|
||||
depth++;
|
||||
if (depth > WUFFS_CBOR__DECODER_DEPTH_MAX_INCL) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeCbor: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
|
||||
depth--;
|
||||
if (depth < 0) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeCbor: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
goto parsed_a_value;
|
||||
}
|
||||
|
||||
@@ -39580,7 +42858,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
|
||||
fail:
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: unexpected token";
|
||||
"wuffs_aux::DecodeCbor: internal error: unexpected token";
|
||||
goto done;
|
||||
|
||||
parsed_a_value:
|
||||
@@ -39684,6 +42962,12 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
|
||||
return wuffs_base__image_decoder::unique_ptr(nullptr, &free);
|
||||
}
|
||||
|
||||
std::string //
|
||||
DecodeImageCallbacks::HandleMetadata(const wuffs_base__more_information& minfo,
|
||||
wuffs_base__slice_u8 raw) {
|
||||
return "";
|
||||
}
|
||||
|
||||
wuffs_base__pixel_format //
|
||||
DecodeImageCallbacks::SelectPixfmt(
|
||||
const wuffs_base__image_config& image_config) {
|
||||
@@ -39748,12 +43032,16 @@ const char DecodeImage_BufferIsTooShort[] = //
|
||||
"wuffs_aux::DecodeImage: buffer is too short";
|
||||
const char DecodeImage_MaxInclDimensionExceeded[] = //
|
||||
"wuffs_aux::DecodeImage: max_incl_dimension exceeded";
|
||||
const char DecodeImage_MaxInclMetadataLengthExceeded[] = //
|
||||
"wuffs_aux::DecodeImage: max_incl_metadata_length exceeded";
|
||||
const char DecodeImage_OutOfMemory[] = //
|
||||
"wuffs_aux::DecodeImage: out of memory";
|
||||
const char DecodeImage_UnexpectedEndOfFile[] = //
|
||||
"wuffs_aux::DecodeImage: unexpected end of file";
|
||||
const char DecodeImage_UnsupportedImageFormat[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported image format";
|
||||
const char DecodeImage_UnsupportedMetadata[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported metadata";
|
||||
const char DecodeImage_UnsupportedPixelBlend[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported pixel blend";
|
||||
const char DecodeImage_UnsupportedPixelConfiguration[] = //
|
||||
@@ -39761,38 +43049,105 @@ const char DecodeImage_UnsupportedPixelConfiguration[] = //
|
||||
const char DecodeImage_UnsupportedPixelFormat[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported pixel format";
|
||||
|
||||
DecodeImageArgQuirks::DecodeImageArgQuirks(wuffs_base__slice_u32 repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgQuirks::DecodeImageArgQuirks(uint32_t* ptr0, size_t len0)
|
||||
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
|
||||
|
||||
DecodeImageArgQuirks //
|
||||
DecodeImageArgQuirks::DefaultValue() {
|
||||
return DecodeImageArgQuirks(wuffs_base__empty_slice_u32());
|
||||
}
|
||||
|
||||
DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {}
|
||||
|
||||
DecodeImageArgFlags //
|
||||
DecodeImageArgFlags::DefaultValue() {
|
||||
return DecodeImageArgFlags(0);
|
||||
}
|
||||
|
||||
DecodeImageArgPixelBlend::DecodeImageArgPixelBlend(
|
||||
wuffs_base__pixel_blend repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgPixelBlend //
|
||||
DecodeImageArgPixelBlend::DefaultValue() {
|
||||
return DecodeImageArgPixelBlend(WUFFS_BASE__PIXEL_BLEND__SRC);
|
||||
}
|
||||
|
||||
DecodeImageArgBackgroundColor::DecodeImageArgBackgroundColor(
|
||||
wuffs_base__color_u32_argb_premul repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgBackgroundColor //
|
||||
DecodeImageArgBackgroundColor::DefaultValue() {
|
||||
return DecodeImageArgBackgroundColor(1);
|
||||
}
|
||||
|
||||
DecodeImageArgMaxInclDimension::DecodeImageArgMaxInclDimension(uint32_t repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgMaxInclDimension //
|
||||
DecodeImageArgMaxInclDimension::DefaultValue() {
|
||||
return DecodeImageArgMaxInclDimension(1048575);
|
||||
}
|
||||
|
||||
DecodeImageArgMaxInclMetadataLength::DecodeImageArgMaxInclMetadataLength(
|
||||
uint64_t repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgMaxInclMetadataLength //
|
||||
DecodeImageArgMaxInclMetadataLength::DefaultValue() {
|
||||
return DecodeImageArgMaxInclMetadataLength(16777215);
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
namespace {
|
||||
|
||||
const private_impl::ErrorMessages DecodeImageErrorMessages = {
|
||||
DecodeImage_MaxInclMetadataLengthExceeded, //
|
||||
DecodeImage_OutOfMemory, //
|
||||
DecodeImage_UnexpectedEndOfFile, //
|
||||
DecodeImage_UnsupportedMetadata, //
|
||||
DecodeImage_UnsupportedImageFormat, //
|
||||
};
|
||||
|
||||
std::string //
|
||||
DecodeImageAdvanceIOBuf(sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
bool compactable,
|
||||
uint64_t min_excl_pos,
|
||||
uint64_t pos) {
|
||||
if ((pos <= min_excl_pos) || (pos < io_buf.reader_position())) {
|
||||
// Redirects must go forward.
|
||||
return DecodeImage_UnsupportedImageFormat;
|
||||
}
|
||||
while (true) {
|
||||
uint64_t relative_pos = pos - io_buf.reader_position();
|
||||
if (relative_pos <= io_buf.reader_length()) {
|
||||
io_buf.meta.ri += (size_t)relative_pos;
|
||||
break;
|
||||
} else if (io_buf.meta.closed) {
|
||||
return DecodeImage_UnexpectedEndOfFile;
|
||||
}
|
||||
io_buf.meta.ri = io_buf.meta.wi;
|
||||
if (compactable) {
|
||||
io_buf.compact();
|
||||
}
|
||||
std::string error_message = input.CopyIn(&io_buf);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
return "";
|
||||
DecodeImageAdvanceIOBufferTo(sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
uint64_t absolute_position) {
|
||||
return private_impl::AdvanceIOBufferTo(DecodeImageErrorMessages, input,
|
||||
io_buf, absolute_position);
|
||||
}
|
||||
|
||||
wuffs_base__status //
|
||||
DIHM0(void* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__more_information* a_minfo,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
return wuffs_base__image_decoder__tell_me_more(
|
||||
static_cast<wuffs_base__image_decoder*>(self), a_dst, a_minfo, a_src);
|
||||
}
|
||||
|
||||
std::string //
|
||||
DIHM1(void* self,
|
||||
const wuffs_base__more_information* minfo,
|
||||
wuffs_base__slice_u8 raw) {
|
||||
return static_cast<DecodeImageCallbacks*>(self)->HandleMetadata(*minfo, raw);
|
||||
}
|
||||
|
||||
std::string //
|
||||
DecodeImageHandleMetadata(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
sync_io::DynIOBuffer& raw_metadata_buf) {
|
||||
return private_impl::HandleMetadata(DecodeImageErrorMessages, input, io_buf,
|
||||
raw_metadata_buf, DIHM0,
|
||||
static_cast<void*>(image_decoder.get()),
|
||||
DIHM1, static_cast<void*>(&callbacks));
|
||||
}
|
||||
|
||||
DecodeImageResult //
|
||||
@@ -39800,9 +43155,12 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
wuffs_base__slice_u32 quirks,
|
||||
uint64_t flags,
|
||||
wuffs_base__pixel_blend pixel_blend,
|
||||
wuffs_base__color_u32_argb_premul background_color,
|
||||
uint32_t max_incl_dimension) {
|
||||
uint32_t max_incl_dimension,
|
||||
uint64_t max_incl_metadata_length) {
|
||||
// Check args.
|
||||
switch (pixel_blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
@@ -39813,6 +43171,7 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
}
|
||||
|
||||
wuffs_base__image_config image_config = wuffs_base__null_image_config();
|
||||
sync_io::DynIOBuffer raw_metadata_buf(max_incl_metadata_length);
|
||||
uint64_t start_pos = io_buf.reader_position();
|
||||
bool redirected = false;
|
||||
int32_t fourcc = 0;
|
||||
@@ -39847,8 +43206,12 @@ redirect:
|
||||
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
|
||||
}
|
||||
uint64_t pos = minfo.io_redirect__range().min_incl;
|
||||
std::string error_message = DecodeImageAdvanceIOBuf(
|
||||
input, io_buf, !input.BringsItsOwnIOBuffer(), start_pos, pos);
|
||||
if (pos <= start_pos) {
|
||||
// Redirects must go forward.
|
||||
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
|
||||
}
|
||||
std::string error_message =
|
||||
DecodeImageAdvanceIOBufferTo(input, io_buf, pos);
|
||||
if (!error_message.empty()) {
|
||||
return DecodeImageResult(std::move(error_message));
|
||||
}
|
||||
@@ -39867,6 +43230,36 @@ redirect:
|
||||
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
|
||||
}
|
||||
|
||||
// Apply quirks.
|
||||
for (size_t i = 0; i < quirks.len; i++) {
|
||||
image_decoder->set_quirk_enabled(quirks.ptr[i], true);
|
||||
}
|
||||
|
||||
// Apply flags.
|
||||
if (flags != 0) {
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_CHRM) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_EXIF) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__EXIF, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_GAMA) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__GAMA, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_ICCP) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__ICCP, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_KVP) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__KVP, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_SRGB) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__SRGB, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_XMP) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__XMP, true);
|
||||
}
|
||||
}
|
||||
|
||||
// Decode the image config.
|
||||
while (true) {
|
||||
wuffs_base__status id_dic_status =
|
||||
@@ -39879,6 +43272,12 @@ redirect:
|
||||
}
|
||||
redirected = true;
|
||||
goto redirect;
|
||||
} else if (id_dic_status.repr == wuffs_base__note__metadata_reported) {
|
||||
std::string error_message = DecodeImageHandleMetadata(
|
||||
image_decoder, callbacks, input, io_buf, raw_metadata_buf);
|
||||
if (!error_message.empty()) {
|
||||
return DecodeImageResult(std::move(error_message));
|
||||
}
|
||||
} else if (id_dic_status.repr != wuffs_base__suspension__short_read) {
|
||||
return DecodeImageResult(id_dic_status.message());
|
||||
} else if (io_buf.meta.closed) {
|
||||
@@ -39891,6 +43290,7 @@ redirect:
|
||||
}
|
||||
}
|
||||
} while (false);
|
||||
raw_metadata_buf.drop();
|
||||
|
||||
// Select the pixel format.
|
||||
uint32_t w = image_config.pixcfg.width();
|
||||
@@ -40001,9 +43401,12 @@ redirect:
|
||||
DecodeImageResult //
|
||||
DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__pixel_blend pixel_blend,
|
||||
wuffs_base__color_u32_argb_premul background_color,
|
||||
uint32_t max_incl_dimension) {
|
||||
DecodeImageArgQuirks quirks,
|
||||
DecodeImageArgFlags flags,
|
||||
DecodeImageArgPixelBlend pixel_blend,
|
||||
DecodeImageArgBackgroundColor background_color,
|
||||
DecodeImageArgMaxInclDimension max_incl_dimension,
|
||||
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length) {
|
||||
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
|
||||
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
|
||||
std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);
|
||||
@@ -40016,8 +43419,9 @@ DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
|
||||
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);
|
||||
DecodeImageResult result =
|
||||
DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,
|
||||
background_color, max_incl_dimension);
|
||||
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr,
|
||||
flags.repr, pixel_blend.repr, background_color.repr,
|
||||
max_incl_dimension.repr, max_incl_metadata_length.repr);
|
||||
callbacks.Done(result, input, *io_buf, std::move(image_decoder));
|
||||
return result;
|
||||
}
|
||||
@@ -40047,9 +43451,29 @@ DecodeJsonCallbacks::Done(DecodeJsonResult& result,
|
||||
sync_io::Input& input,
|
||||
IOBuffer& buffer) {}
|
||||
|
||||
const char DecodeJson_BadJsonPointer[] =
|
||||
const char DecodeJson_BadJsonPointer[] = //
|
||||
"wuffs_aux::DecodeJson: bad JSON Pointer";
|
||||
const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
|
||||
const char DecodeJson_NoMatch[] = //
|
||||
"wuffs_aux::DecodeJson: no match";
|
||||
|
||||
DecodeJsonArgQuirks::DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeJsonArgQuirks::DecodeJsonArgQuirks(uint32_t* ptr0, size_t len0)
|
||||
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
|
||||
|
||||
DecodeJsonArgQuirks //
|
||||
DecodeJsonArgQuirks::DefaultValue() {
|
||||
return DecodeJsonArgQuirks(wuffs_base__empty_slice_u32());
|
||||
}
|
||||
|
||||
DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeJsonArgJsonPointer //
|
||||
DecodeJsonArgJsonPointer::DefaultValue() {
|
||||
return DecodeJsonArgJsonPointer(std::string());
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
@@ -40086,6 +43510,14 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
|
||||
} \
|
||||
tok_status = \
|
||||
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \
|
||||
if ((tok_buf.meta.ri > tok_buf.meta.wi) || \
|
||||
(tok_buf.meta.wi > tok_buf.data.len) || \
|
||||
(io_buf->meta.ri > io_buf->meta.wi) || \
|
||||
(io_buf->meta.wi > io_buf->data.len)) { \
|
||||
ret_error_message = \
|
||||
"wuffs_aux::DecodeJson: internal error: bad buffer indexes"; \
|
||||
goto done; \
|
||||
} \
|
||||
} \
|
||||
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \
|
||||
uint64_t token_len = token.length(); \
|
||||
@@ -40104,7 +43536,8 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
|
||||
namespace {
|
||||
|
||||
// DecodeJson_SplitJsonPointer returns ("bar", 8) for ("/foo/bar/b~1z/qux", 5,
|
||||
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax.
|
||||
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax or i is
|
||||
// out of bounds.
|
||||
//
|
||||
// The string returned is unescaped. If calling it again, this time with i=8,
|
||||
// the "b~1z" substring would be returned as "b/z".
|
||||
@@ -40113,6 +43546,9 @@ DecodeJson_SplitJsonPointer(std::string& s,
|
||||
size_t i,
|
||||
bool allow_tilde_n_tilde_r_tilde_t) {
|
||||
std::string fragment;
|
||||
if (i > s.size()) {
|
||||
return std::make_pair(std::string(), 0);
|
||||
}
|
||||
while (i < s.size()) {
|
||||
char c = s[i];
|
||||
if (c == '/') {
|
||||
@@ -40319,8 +43755,8 @@ check_that_a_value_follows:
|
||||
continue;
|
||||
}
|
||||
|
||||
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so that
|
||||
// we're only peeking at the next token.
|
||||
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so
|
||||
// that we're only peeking at the next token.
|
||||
tok_buf.meta.ri--;
|
||||
cursor_index -= static_cast<size_t>(token_len);
|
||||
|
||||
@@ -40344,8 +43780,8 @@ done:
|
||||
DecodeJsonResult //
|
||||
DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks,
|
||||
std::string json_pointer) {
|
||||
DecodeJsonArgQuirks quirks,
|
||||
DecodeJsonArgJsonPointer json_pointer) {
|
||||
// Prepare the wuffs_base__io_buffer and the resultant error_message.
|
||||
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
|
||||
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
|
||||
@@ -40373,9 +43809,9 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
goto done;
|
||||
}
|
||||
bool allow_tilde_n_tilde_r_tilde_t = false;
|
||||
for (size_t i = 0; i < quirks.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.ptr[i], true);
|
||||
if (quirks.ptr[i] ==
|
||||
for (size_t i = 0; i < quirks.repr.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
|
||||
if (quirks.repr.ptr[i] ==
|
||||
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {
|
||||
allow_tilde_n_tilde_r_tilde_t = true;
|
||||
}
|
||||
@@ -40390,17 +43826,17 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8());
|
||||
|
||||
// Prepare other state.
|
||||
uint32_t depth = 0;
|
||||
int32_t depth = 0;
|
||||
std::string str;
|
||||
|
||||
// Walk the (optional) JSON Pointer.
|
||||
for (size_t i = 0; i < json_pointer.size();) {
|
||||
if (json_pointer[i] != '/') {
|
||||
for (size_t i = 0; i < json_pointer.repr.size();) {
|
||||
if (json_pointer.repr[i] != '/') {
|
||||
ret_error_message = DecodeJson_BadJsonPointer;
|
||||
goto done;
|
||||
}
|
||||
std::pair<std::string, size_t> split = DecodeJson_SplitJsonPointer(
|
||||
json_pointer, i + 1, allow_tilde_n_tilde_r_tilde_t);
|
||||
json_pointer.repr, i + 1, allow_tilde_n_tilde_r_tilde_t);
|
||||
i = split.second;
|
||||
if (i == 0) {
|
||||
ret_error_message = DecodeJson_BadJsonPointer;
|
||||
@@ -40433,10 +43869,20 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
goto done;
|
||||
}
|
||||
depth++;
|
||||
if (depth > WUFFS_JSON__DECODER_DEPTH_MAX_INCL) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeJson: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
|
||||
depth--;
|
||||
if (depth < 0) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeJson: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
goto parsed_a_value;
|
||||
}
|
||||
|
||||
@@ -40551,7 +43997,7 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
// loop running until WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN's
|
||||
// decode_tokens returns an ok status.
|
||||
if (!ret_error_message.empty() ||
|
||||
((depth == 0) && !json_pointer.empty())) {
|
||||
((depth == 0) && !json_pointer.repr.empty())) {
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -54,13 +54,14 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
// Note that Clang also defines __GNUC__.
|
||||
#ifdef __cplusplus
|
||||
#if (__cplusplus >= 201103L) || defined(_MSC_VER)
|
||||
#include <memory>
|
||||
#define WUFFS_BASE__HAVE_EQ_DELETE
|
||||
#define WUFFS_BASE__HAVE_UNIQUE_PTR
|
||||
#elif defined(__GNUC__)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#elif defined(__GNUC__) || defined(__clang__)
|
||||
#warning "Wuffs' C++ code expects -std=c++11 or later"
|
||||
#endif
|
||||
|
||||
@@ -84,15 +85,15 @@ extern "C" {
|
||||
// each major.minor branch, the commit count should increase monotonically.
|
||||
//
|
||||
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
|
||||
// 6a30c1ede0dc765fbbc443b2536b7691485be9fb committed on 2021-07-18.
|
||||
// 4aa672af48fd5c11ab4c0b704a4ccf8d90eb5662 committed on 2022-01-08.
|
||||
#define WUFFS_VERSION 0x000030000
|
||||
#define WUFFS_VERSION_MAJOR 0
|
||||
#define WUFFS_VERSION_MINOR 3
|
||||
#define WUFFS_VERSION_PATCH 0
|
||||
#define WUFFS_VERSION_PRE_RELEASE_LABEL "beta.7"
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3069
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20210718
|
||||
#define WUFFS_VERSION_STRING "0.3.0-beta.7+3069.20210718"
|
||||
#define WUFFS_VERSION_PRE_RELEASE_LABEL "beta.13"
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3245
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20220108
|
||||
#define WUFFS_VERSION_STRING "0.3.0-beta.13+3245.20220108"
|
||||
|
||||
// ---------------- Configuration
|
||||
|
||||
@@ -132,15 +133,18 @@ extern "C" {
|
||||
// POPCNT. This is checked at runtime via cpuid, not at compile time.
|
||||
//
|
||||
// Likewise, "cpu_arch >= x86_avx2" also requires PCLMUL, POPCNT and SSE4.2.
|
||||
#if defined(__x86_64__) && !defined(__native_client__)
|
||||
#if defined(__i386__) || defined(__x86_64__)
|
||||
#if !defined(__native_client__)
|
||||
#include <cpuid.h>
|
||||
#include <x86intrin.h>
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_64
|
||||
#endif // defined(__x86_64__) && !defined(__native_client__)
|
||||
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
|
||||
#endif // !defined(__native_client__)
|
||||
#endif // defined(__i386__) || defined(__x86_64__)
|
||||
|
||||
#elif defined(_MSC_VER) // (#if-chain ref AVOID_CPU_ARCH_1)
|
||||
|
||||
#if defined(_M_X64)
|
||||
#if defined(_M_IX86) || defined(_M_X64)
|
||||
#if defined(__AVX__) || defined(__clang__)
|
||||
|
||||
// We need <intrin.h> for the __cpuid function.
|
||||
@@ -154,7 +158,8 @@ extern "C" {
|
||||
#include <immintrin.h> // AVX, AVX2, FMA, POPCNT
|
||||
#include <nmmintrin.h> // SSE4.2
|
||||
#include <wmmintrin.h> // AES, PCLMUL
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_64
|
||||
// X86_FAMILY means X86 (32-bit) or X86_64 (64-bit, obviously).
|
||||
#define WUFFS_BASE__CPU_ARCH__X86_FAMILY
|
||||
|
||||
#else // defined(__AVX__) || defined(__clang__)
|
||||
|
||||
@@ -164,19 +169,22 @@ extern "C" {
|
||||
// For MSVC's cl.exe (unlike clang or gcc), SIMD capability is a compile-time
|
||||
// property of the source file (e.g. a /arch:AVX or -mavx compiler flag), not
|
||||
// of individual functions (that can be conditionally selected at runtime).
|
||||
#pragma message("Wuffs with MSVC+X64 needs /arch:AVX for best performance")
|
||||
#pragma message("Wuffs with MSVC+IX86/X64 needs /arch:AVX for best performance")
|
||||
|
||||
#endif // defined(__AVX__) || defined(__clang__)
|
||||
#endif // defined(_M_X64)
|
||||
#endif // defined(_M_IX86) || defined(_M_X64)
|
||||
|
||||
#endif // (#if-chain ref AVOID_CPU_ARCH_1)
|
||||
#endif // (#if-chain ref AVOID_CPU_ARCH_0)
|
||||
|
||||
// --------
|
||||
|
||||
// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
|
||||
// static storage. The motivation is discussed in the "ALLOW STATIC
|
||||
// IMPLEMENTATION" section of
|
||||
// Define WUFFS_CONFIG__STATIC_FUNCTIONS (combined with WUFFS_IMPLEMENTATION)
|
||||
// to make all of Wuffs' functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#if defined(WUFFS_CONFIG__STATIC_FUNCTIONS)
|
||||
#define WUFFS_BASE__MAYBE_STATIC static
|
||||
@@ -206,7 +214,7 @@ wuffs_base__cpu_arch__have_arm_neon() {
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__cpu_arch__have_x86_avx2() {
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// GCC defines these macros but MSVC does not.
|
||||
// - bit_AVX2 = (1 << 5)
|
||||
const unsigned int avx2_ebx7 = 0x00000020;
|
||||
@@ -246,13 +254,13 @@ wuffs_base__cpu_arch__have_x86_avx2() {
|
||||
#else
|
||||
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
|
||||
#endif // defined(__GNUC__); defined(_MSC_VER)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__cpu_arch__have_x86_bmi2() {
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// GCC defines these macros but MSVC does not.
|
||||
// - bit_BMI2 = (1 << 8)
|
||||
const unsigned int bmi2_ebx7 = 0x00000100;
|
||||
@@ -276,13 +284,13 @@ wuffs_base__cpu_arch__have_x86_bmi2() {
|
||||
#else
|
||||
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
|
||||
#endif // defined(__GNUC__); defined(_MSC_VER)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// GCC defines these macros but MSVC does not.
|
||||
// - bit_PCLMUL = (1 << 1)
|
||||
// - bit_POPCNT = (1 << 23)
|
||||
@@ -308,7 +316,7 @@ wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
#else
|
||||
#error "WUFFS_BASE__CPU_ARCH__ETC combined with an unsupported compiler"
|
||||
#endif // defined(__GNUC__); defined(_MSC_VER)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -323,8 +331,9 @@ wuffs_base__cpu_arch__have_x86_sse42() {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Clang also defines "__GNUC__".
|
||||
#if defined(__GNUC__)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused))
|
||||
#define WUFFS_BASE__WARN_UNUSED_RESULT __attribute__((warn_unused_result))
|
||||
#else
|
||||
@@ -552,7 +561,20 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
|
||||
// --------
|
||||
|
||||
// FourCC constants.
|
||||
// FourCC constants. Four Character Codes are literally four ASCII characters
|
||||
// (sometimes padded with ' ' spaces) that pack neatly into a signed or
|
||||
// unsigned 32-bit integer. ASCII letters are conventionally upper case.
|
||||
//
|
||||
// They are often used to identify video codecs (e.g. "H265") and pixel formats
|
||||
// (e.g. "YV12"). Wuffs uses them for that but also generally for naming
|
||||
// various things: compression formats (e.g. "BZ2 "), image metadata (e.g.
|
||||
// "EXIF"), file formats (e.g. "HTML"), etc.
|
||||
//
|
||||
// Wuffs' u32 values are big-endian ("JPEG" is 0x4A504547 not 0x4745504A) to
|
||||
// preserve ordering: "JPEG" < "MP3 " and 0x4A504547 < 0x4D503320.
|
||||
|
||||
// Background Color.
|
||||
#define WUFFS_BASE__FOURCC__BGCL 0x4247434C
|
||||
|
||||
// Bitmap.
|
||||
#define WUFFS_BASE__FOURCC__BMP 0x424D5020
|
||||
@@ -566,15 +588,24 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// Concise Binary Object Representation.
|
||||
#define WUFFS_BASE__FOURCC__CBOR 0x43424F52
|
||||
|
||||
// Primary Chromaticities and White Point.
|
||||
#define WUFFS_BASE__FOURCC__CHRM 0x4348524D
|
||||
|
||||
// Cascading Style Sheets.
|
||||
#define WUFFS_BASE__FOURCC__CSS 0x43535320
|
||||
|
||||
// Encapsulated PostScript.
|
||||
#define WUFFS_BASE__FOURCC__EPS 0x45505320
|
||||
|
||||
// Exchangeable Image File Format.
|
||||
#define WUFFS_BASE__FOURCC__EXIF 0x45584946
|
||||
|
||||
// Free Lossless Audio Codec.
|
||||
#define WUFFS_BASE__FOURCC__FLAC 0x464C4143
|
||||
|
||||
// Gamma Correction.
|
||||
#define WUFFS_BASE__FOURCC__GAMA 0x47414D41
|
||||
|
||||
// Graphics Interchange Format.
|
||||
#define WUFFS_BASE__FOURCC__GIF 0x47494620
|
||||
|
||||
@@ -611,24 +642,42 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// JSON With Commas and Comments.
|
||||
#define WUFFS_BASE__FOURCC__JWCC 0x4A574343
|
||||
|
||||
// Key-Value Pair.
|
||||
#define WUFFS_BASE__FOURCC__KVP 0x4B565020
|
||||
|
||||
// Key-Value Pair (Key).
|
||||
#define WUFFS_BASE__FOURCC__KVPK 0x4B56504B
|
||||
|
||||
// Key-Value Pair (Value).
|
||||
#define WUFFS_BASE__FOURCC__KVPV 0x4B565056
|
||||
|
||||
// Lempel–Ziv 4.
|
||||
#define WUFFS_BASE__FOURCC__LZ4 0x4C5A3420
|
||||
|
||||
// Markdown.
|
||||
#define WUFFS_BASE__FOURCC__MD 0x4D442020
|
||||
|
||||
// Modification Time.
|
||||
#define WUFFS_BASE__FOURCC__MTIM 0x4D54494D
|
||||
|
||||
// MPEG-1 Audio Layer III.
|
||||
#define WUFFS_BASE__FOURCC__MP3 0x4D503320
|
||||
|
||||
// Naive Image.
|
||||
#define WUFFS_BASE__FOURCC__NIE 0x4E494520
|
||||
|
||||
// Offset (2-Dimensional).
|
||||
#define WUFFS_BASE__FOURCC__OFS2 0x4F465332
|
||||
|
||||
// Open Type Format.
|
||||
#define WUFFS_BASE__FOURCC__OTF 0x4F544620
|
||||
|
||||
// Portable Document Format.
|
||||
#define WUFFS_BASE__FOURCC__PDF 0x50444620
|
||||
|
||||
// Physical Dimensions.
|
||||
#define WUFFS_BASE__FOURCC__PHYD 0x50485944
|
||||
|
||||
// Portable Network Graphics.
|
||||
#define WUFFS_BASE__FOURCC__PNG 0x504E4720
|
||||
|
||||
@@ -638,6 +687,9 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// PostScript.
|
||||
#define WUFFS_BASE__FOURCC__PS 0x50532020
|
||||
|
||||
// Quite OK Image.
|
||||
#define WUFFS_BASE__FOURCC__QOI 0x514F4920
|
||||
|
||||
// Random Access Compression.
|
||||
#define WUFFS_BASE__FOURCC__RAC 0x52414320
|
||||
|
||||
@@ -653,12 +705,18 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// Snappy.
|
||||
#define WUFFS_BASE__FOURCC__SNPY 0x534E5059
|
||||
|
||||
// Standard Red Green Blue (Rendering Intent).
|
||||
#define WUFFS_BASE__FOURCC__SRGB 0x53524742
|
||||
|
||||
// Scalable Vector Graphics.
|
||||
#define WUFFS_BASE__FOURCC__SVG 0x53564720
|
||||
|
||||
// Tape Archive.
|
||||
#define WUFFS_BASE__FOURCC__TAR 0x54415220
|
||||
|
||||
// Text.
|
||||
#define WUFFS_BASE__FOURCC__TEXT 0x54455854
|
||||
|
||||
// Tagged Image File Format.
|
||||
#define WUFFS_BASE__FOURCC__TIFF 0x54494646
|
||||
|
||||
@@ -671,15 +729,12 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// Wireless Bitmap.
|
||||
#define WUFFS_BASE__FOURCC__WBMP 0x57424D50
|
||||
|
||||
// Web Picture.
|
||||
#define WUFFS_BASE__FOURCC__WEBP 0x57454250
|
||||
|
||||
// Web Open Font Format.
|
||||
#define WUFFS_BASE__FOURCC__WOFF 0x574F4646
|
||||
|
||||
// Web Picture (VP8).
|
||||
#define WUFFS_BASE__FOURCC__WP8 0x57503820
|
||||
|
||||
// Web Picture (VP8 Lossless).
|
||||
#define WUFFS_BASE__FOURCC__WP8L 0x5750384C
|
||||
|
||||
// Extensible Markup Language.
|
||||
#define WUFFS_BASE__FOURCC__XML 0x584D4C20
|
||||
|
||||
@@ -957,7 +1012,9 @@ wuffs_base__multiply_u64(uint64_t x, uint64_t y) {
|
||||
|
||||
// --------
|
||||
|
||||
#if defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#if (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__count_leading_zeroes_u64(uint64_t u) {
|
||||
@@ -1001,7 +1058,7 @@ wuffs_base__count_leading_zeroes_u64(uint64_t u) {
|
||||
return n;
|
||||
}
|
||||
|
||||
#endif // defined(__GNUC__) && (__SIZEOF_LONG__ == 8)
|
||||
#endif // (defined(__GNUC__) || defined(__clang__)) && (__SIZEOF_LONG__ == 8)
|
||||
|
||||
// --------
|
||||
|
||||
@@ -1565,6 +1622,25 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
// wuffs_base__table_u8__subtable_ij returns t[ix:jx, iy:jy].
|
||||
//
|
||||
// It returns an empty table if i or j is out of bounds.
|
||||
static inline wuffs_base__table_u8 //
|
||||
wuffs_base__table_u8__subtable_ij(wuffs_base__table_u8 t,
|
||||
uint64_t ix,
|
||||
uint64_t iy,
|
||||
uint64_t jx,
|
||||
uint64_t jy) {
|
||||
if ((ix <= jx) && (jx <= SIZE_MAX) && (jx <= t.width) && //
|
||||
(iy <= jy) && (jy <= SIZE_MAX) && (jy <= t.height)) {
|
||||
return wuffs_base__make_table_u8(t.ptr + ix + (iy * t.stride), //
|
||||
((size_t)(jx - ix)), //
|
||||
((size_t)(jy - iy)), //
|
||||
t.stride); //
|
||||
}
|
||||
return wuffs_base__make_table_u8(NULL, 0, 0, 0);
|
||||
}
|
||||
|
||||
// wuffs_base__table__flattened_length returns the number of elements covered
|
||||
// by the 1-dimensional span that backs a 2-dimensional table. This counts the
|
||||
// elements inside the table and, when width != stride, the elements outside
|
||||
@@ -2447,14 +2523,24 @@ typedef struct wuffs_base__more_information__struct {
|
||||
inline wuffs_base__range_ie_u64 io_redirect__range() const;
|
||||
inline uint64_t io_seek__position() const;
|
||||
inline uint32_t metadata__fourcc() const;
|
||||
// Deprecated: use metadata_raw_passthrough__range.
|
||||
inline wuffs_base__range_ie_u64 metadata__range() const;
|
||||
inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const;
|
||||
inline int32_t metadata_parsed__chrm(uint32_t component) const;
|
||||
inline uint32_t metadata_parsed__gama() const;
|
||||
inline uint32_t metadata_parsed__srgb() const;
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_base__more_information;
|
||||
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT 1
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK 2
|
||||
// Deprecated: use
|
||||
// WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH.
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA 3
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH 3
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM 4
|
||||
#define WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED 5
|
||||
|
||||
static inline wuffs_base__more_information //
|
||||
wuffs_base__empty_more_information() {
|
||||
@@ -2511,6 +2597,8 @@ wuffs_base__more_information__metadata__fourcc(
|
||||
return m->w;
|
||||
}
|
||||
|
||||
// Deprecated: use
|
||||
// wuffs_base__more_information__metadata_raw_passthrough__range.
|
||||
static inline wuffs_base__range_ie_u64 //
|
||||
wuffs_base__more_information__metadata__range(
|
||||
const wuffs_base__more_information* m) {
|
||||
@@ -2520,6 +2608,103 @@ wuffs_base__more_information__metadata__range(
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__range_ie_u64 //
|
||||
wuffs_base__more_information__metadata_raw_passthrough__range(
|
||||
const wuffs_base__more_information* m) {
|
||||
wuffs_base__range_ie_u64 ret;
|
||||
ret.min_incl = m->y;
|
||||
ret.max_excl = m->z;
|
||||
return ret;
|
||||
}
|
||||
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_X 0
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__WHITE_Y 1
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_X 2
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__RED_Y 3
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_X 4
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__GREEN_Y 5
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_X 6
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CHRM__BLUE_Y 7
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__chrm returns chromaticity
|
||||
// values (scaled by 100000) like the PNG "cHRM" chunk. For example, the sRGB
|
||||
// color space corresponds to:
|
||||
// - ETC__CHRM__WHITE_X 31270
|
||||
// - ETC__CHRM__WHITE_Y 32900
|
||||
// - ETC__CHRM__RED_X 64000
|
||||
// - ETC__CHRM__RED_Y 33000
|
||||
// - ETC__CHRM__GREEN_X 30000
|
||||
// - ETC__CHRM__GREEN_Y 60000
|
||||
// - ETC__CHRM__BLUE_X 15000
|
||||
// - ETC__CHRM__BLUE_Y 6000
|
||||
//
|
||||
// See
|
||||
// https://ciechanow.ski/color-spaces/#chromaticity-and-white-point-coordinates
|
||||
static inline int32_t //
|
||||
wuffs_base__more_information__metadata_parsed__chrm(
|
||||
const wuffs_base__more_information* m,
|
||||
uint32_t component) {
|
||||
// After the flavor and the w field (holding a FourCC), a
|
||||
// wuffs_base__more_information holds 24 bytes of data in three uint64_t
|
||||
// typed fields (x, y and z). We pack the eight chromaticity values (wx, wy,
|
||||
// rx, ..., by), basically int24_t values, into 24 bytes like this:
|
||||
// - LSB MSB
|
||||
// - x: wx wx wx wy wy wy rx rx
|
||||
// - y: rx ry ry ry gx gx gx gy
|
||||
// - z: gy gy bx bx bx by by by
|
||||
uint32_t u = 0;
|
||||
switch (component & 7) {
|
||||
case 0:
|
||||
u = ((uint32_t)(m->x >> 0));
|
||||
break;
|
||||
case 1:
|
||||
u = ((uint32_t)(m->x >> 24));
|
||||
break;
|
||||
case 2:
|
||||
u = ((uint32_t)((m->x >> 48) | (m->y << 16)));
|
||||
break;
|
||||
case 3:
|
||||
u = ((uint32_t)(m->y >> 8));
|
||||
break;
|
||||
case 4:
|
||||
u = ((uint32_t)(m->y >> 32));
|
||||
break;
|
||||
case 5:
|
||||
u = ((uint32_t)((m->y >> 56) | (m->z << 8)));
|
||||
break;
|
||||
case 6:
|
||||
u = ((uint32_t)(m->z >> 16));
|
||||
break;
|
||||
case 7:
|
||||
u = ((uint32_t)(m->z >> 40));
|
||||
break;
|
||||
}
|
||||
// The left-right shifts sign-extend from 24-bit to 32-bit integers.
|
||||
return ((int32_t)(u << 8)) >> 8;
|
||||
}
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__gama returns inverse gamma
|
||||
// correction values (scaled by 100000) like the PNG "gAMA" chunk. For example,
|
||||
// for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2).
|
||||
static inline uint32_t //
|
||||
wuffs_base__more_information__metadata_parsed__gama(
|
||||
const wuffs_base__more_information* m) {
|
||||
return ((uint32_t)(m->x));
|
||||
}
|
||||
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__PERCEPTUAL 0
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__RELATIVE_COLORIMETRIC 1
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__SATURATION 2
|
||||
#define WUFFS_BASE__SRGB_RENDERING_INTENT__ABSOLUTE_COLORIMETRIC 3
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__srgb returns the sRGB
|
||||
// rendering intent like the PNG "sRGB" chunk.
|
||||
static inline uint32_t //
|
||||
wuffs_base__more_information__metadata_parsed__srgb(
|
||||
const wuffs_base__more_information* m) {
|
||||
return m->x & 3;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
inline void //
|
||||
@@ -2557,6 +2742,26 @@ wuffs_base__more_information::metadata__range() const {
|
||||
return wuffs_base__more_information__metadata__range(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__range_ie_u64 //
|
||||
wuffs_base__more_information::metadata_raw_passthrough__range() const {
|
||||
return wuffs_base__more_information__metadata_raw_passthrough__range(this);
|
||||
}
|
||||
|
||||
inline int32_t //
|
||||
wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const {
|
||||
return wuffs_base__more_information__metadata_parsed__chrm(this, component);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__more_information::metadata_parsed__gama() const {
|
||||
return wuffs_base__more_information__metadata_parsed__gama(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__more_information::metadata_parsed__srgb() const {
|
||||
return wuffs_base__more_information__metadata_parsed__srgb(this);
|
||||
}
|
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
// ---------------- I/O
|
||||
@@ -5063,9 +5268,9 @@ wuffs_base__pixel_swizzler::swizzle_interleaved_from_slice(
|
||||
|
||||
// wuffs_base__ieee_754_bit_representation__etc converts between a double
|
||||
// precision numerical value and its IEEE 754 representations:
|
||||
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
|
||||
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
|
||||
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
|
||||
// - 16-bit: 1 sign bit, 5 exponent bits, 10 explicit significand bits.
|
||||
// - 32-bit: 1 sign bit, 8 exponent bits, 23 explicit significand bits.
|
||||
// - 64-bit: 1 sign bit, 11 exponent bits, 52 explicit significand bits.
|
||||
//
|
||||
// For example, it converts between:
|
||||
// - +1.0 and 0x3C00, 0x3F80_0000 or 0x3FF0_0000_0000_0000.
|
||||
@@ -7104,6 +7309,7 @@ struct wuffs_deflate__decoder__struct {
|
||||
|
||||
uint32_t f_bits;
|
||||
uint32_t f_n_bits;
|
||||
uint64_t f_transformed_history_count;
|
||||
uint32_t f_history_index;
|
||||
uint32_t f_n_huffs_bits[2];
|
||||
bool f_end_of_block;
|
||||
@@ -7156,7 +7362,6 @@ struct wuffs_deflate__decoder__struct {
|
||||
uint32_t v_length;
|
||||
uint32_t v_dist_minus_1;
|
||||
uint32_t v_hlen;
|
||||
uint32_t v_hdist;
|
||||
uint64_t scratch;
|
||||
} s_decode_huffman_slow[1];
|
||||
} private_data;
|
||||
@@ -7676,8 +7881,8 @@ struct wuffs_gif__decoder__struct {
|
||||
bool f_previous_lzw_decode_ended_abruptly;
|
||||
bool f_has_global_palette;
|
||||
uint8_t f_interlace;
|
||||
bool f_seen_num_loops;
|
||||
uint32_t f_num_loops;
|
||||
bool f_seen_num_animation_loops_value;
|
||||
uint32_t f_num_animation_loops_value;
|
||||
uint32_t f_background_color_u32_argb_premul;
|
||||
uint32_t f_black_color_u32_argb_premul;
|
||||
bool f_gc_has_transparent_index;
|
||||
@@ -8726,6 +8931,8 @@ extern const char wuffs_zlib__error__incorrect_dictionary[];
|
||||
|
||||
// ---------------- Public Consts
|
||||
|
||||
#define WUFFS_ZLIB__QUIRK_JUST_RAW_DEFLATE 2113790976
|
||||
|
||||
#define WUFFS_ZLIB__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1
|
||||
|
||||
// ---------------- Struct Declarations
|
||||
@@ -8837,6 +9044,7 @@ struct wuffs_zlib__decoder__struct {
|
||||
bool f_header_complete;
|
||||
bool f_got_dictionary;
|
||||
bool f_want_dictionary;
|
||||
bool f_quirks[1];
|
||||
bool f_ignore_checksum;
|
||||
uint32_t f_dict_id_got;
|
||||
uint32_t f_dict_id_want;
|
||||
@@ -8955,17 +9163,22 @@ struct wuffs_zlib__decoder__struct {
|
||||
|
||||
// ---------------- Status Codes
|
||||
|
||||
extern const char wuffs_png__error__bad_animation_sequence_number[];
|
||||
extern const char wuffs_png__error__bad_checksum[];
|
||||
extern const char wuffs_png__error__bad_chunk[];
|
||||
extern const char wuffs_png__error__bad_filter[];
|
||||
extern const char wuffs_png__error__bad_header[];
|
||||
extern const char wuffs_png__error__bad_text_chunk_not_latin_1[];
|
||||
extern const char wuffs_png__error__missing_palette[];
|
||||
extern const char wuffs_png__error__unsupported_png_compression_method[];
|
||||
extern const char wuffs_png__error__unsupported_png_file[];
|
||||
|
||||
// ---------------- Public Consts
|
||||
|
||||
#define WUFFS_PNG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0
|
||||
|
||||
#define WUFFS_PNG__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 8
|
||||
|
||||
// ---------------- Struct Declarations
|
||||
|
||||
typedef struct wuffs_png__decoder__struct wuffs_png__decoder;
|
||||
@@ -9115,22 +9328,68 @@ struct wuffs_png__decoder__struct {
|
||||
uint32_t f_height;
|
||||
uint64_t f_pass_bytes_per_row;
|
||||
uint64_t f_workbuf_wi;
|
||||
uint64_t f_workbuf_hist_pos_base;
|
||||
uint64_t f_overall_workbuf_length;
|
||||
uint64_t f_pass_workbuf_length;
|
||||
uint8_t f_call_sequence;
|
||||
bool f_report_metadata_chrm;
|
||||
bool f_report_metadata_exif;
|
||||
bool f_report_metadata_gama;
|
||||
bool f_report_metadata_iccp;
|
||||
bool f_report_metadata_kvp;
|
||||
bool f_report_metadata_srgb;
|
||||
bool f_ignore_checksum;
|
||||
uint8_t f_depth;
|
||||
uint8_t f_color_type;
|
||||
uint8_t f_filter_distance;
|
||||
uint8_t f_interlace_pass;
|
||||
bool f_seen_actl;
|
||||
bool f_seen_chrm;
|
||||
bool f_seen_fctl;
|
||||
bool f_seen_exif;
|
||||
bool f_seen_gama;
|
||||
bool f_seen_iccp;
|
||||
bool f_seen_idat;
|
||||
bool f_seen_plte;
|
||||
bool f_seen_srgb;
|
||||
bool f_seen_trns;
|
||||
uint32_t f_dst_pixfmt;
|
||||
uint32_t f_src_pixfmt;
|
||||
bool f_metadata_is_zlib_compressed;
|
||||
bool f_zlib_is_dirty;
|
||||
uint32_t f_chunk_type;
|
||||
uint8_t f_chunk_type_array[4];
|
||||
uint64_t f_chunk_length;
|
||||
uint32_t f_chunk_length;
|
||||
uint64_t f_remap_transparency;
|
||||
uint32_t f_dst_pixfmt;
|
||||
uint32_t f_src_pixfmt;
|
||||
uint32_t f_num_animation_frames_value;
|
||||
uint32_t f_num_animation_loops_value;
|
||||
uint32_t f_num_decoded_frame_configs_value;
|
||||
uint32_t f_num_decoded_frames_value;
|
||||
uint32_t f_frame_rect_x0;
|
||||
uint32_t f_frame_rect_y0;
|
||||
uint32_t f_frame_rect_x1;
|
||||
uint32_t f_frame_rect_y1;
|
||||
uint32_t f_first_rect_x0;
|
||||
uint32_t f_first_rect_y0;
|
||||
uint32_t f_first_rect_x1;
|
||||
uint32_t f_first_rect_y1;
|
||||
uint64_t f_frame_config_io_position;
|
||||
uint64_t f_first_config_io_position;
|
||||
uint64_t f_frame_duration;
|
||||
uint64_t f_first_duration;
|
||||
uint8_t f_frame_disposal;
|
||||
uint8_t f_first_disposal;
|
||||
bool f_frame_overwrite_instead_of_blend;
|
||||
bool f_first_overwrite_instead_of_blend;
|
||||
uint32_t f_next_animation_seq_num;
|
||||
uint32_t f_metadata_flavor;
|
||||
uint32_t f_metadata_fourcc;
|
||||
uint64_t f_metadata_x;
|
||||
uint64_t f_metadata_y;
|
||||
uint64_t f_metadata_z;
|
||||
uint32_t f_ztxt_ri;
|
||||
uint32_t f_ztxt_wi;
|
||||
uint64_t f_ztxt_hist_pos;
|
||||
wuffs_base__pixel_swizzler f_swizzler;
|
||||
|
||||
wuffs_base__empty_struct (*choosy_filter_1)(
|
||||
@@ -9147,11 +9406,19 @@ struct wuffs_png__decoder__struct {
|
||||
uint32_t p_decode_image_config[1];
|
||||
uint32_t p_decode_ihdr[1];
|
||||
uint32_t p_decode_other_chunk[1];
|
||||
uint32_t p_decode_actl[1];
|
||||
uint32_t p_decode_chrm[1];
|
||||
uint32_t p_decode_fctl[1];
|
||||
uint32_t p_decode_gama[1];
|
||||
uint32_t p_decode_iccp[1];
|
||||
uint32_t p_decode_plte[1];
|
||||
uint32_t p_decode_srgb[1];
|
||||
uint32_t p_decode_trns[1];
|
||||
uint32_t p_decode_frame_config[1];
|
||||
uint32_t p_skip_frame[1];
|
||||
uint32_t p_decode_frame[1];
|
||||
uint32_t p_decode_pass[1];
|
||||
uint32_t p_tell_me_more[1];
|
||||
wuffs_base__status (*choosy_filter_and_swizzle)(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
@@ -9174,19 +9441,47 @@ struct wuffs_png__decoder__struct {
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_other_chunk[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_actl[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_chrm[1];
|
||||
struct {
|
||||
uint32_t v_x0;
|
||||
uint32_t v_x1;
|
||||
uint32_t v_y1;
|
||||
uint64_t scratch;
|
||||
} s_decode_fctl[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_gama[1];
|
||||
struct {
|
||||
uint32_t v_num_entries;
|
||||
uint32_t v_i;
|
||||
uint64_t scratch;
|
||||
} s_decode_plte[1];
|
||||
struct {
|
||||
uint32_t v_num_entries;
|
||||
uint32_t v_i;
|
||||
uint32_t v_n;
|
||||
uint64_t scratch;
|
||||
} s_decode_trns[1];
|
||||
struct {
|
||||
uint32_t v_checksum_have;
|
||||
uint64_t scratch;
|
||||
} s_decode_frame_config[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_skip_frame[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_frame[1];
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_pass[1];
|
||||
struct {
|
||||
wuffs_base__status v_zlib_status;
|
||||
uint64_t scratch;
|
||||
} s_tell_me_more[1];
|
||||
} private_data;
|
||||
|
||||
#ifdef __cplusplus
|
||||
@@ -9683,6 +9978,63 @@ namespace sync_io {
|
||||
|
||||
// --------
|
||||
|
||||
// DynIOBuffer is an IOBuffer that is backed by a dynamically sized byte array.
|
||||
// It owns that backing array and will free it in its destructor.
|
||||
//
|
||||
// The array size can be explicitly extended (by calling the grow method) but,
|
||||
// unlike a C++ std::vector, there is no implicit extension (e.g. by calling
|
||||
// std::vector::insert) and its maximum size is capped by the max_incl
|
||||
// constructor argument.
|
||||
//
|
||||
// It contains an IOBuffer-typed field whose reader side provides access to
|
||||
// previously written bytes and whose writer side provides access to the
|
||||
// allocated but not-yet-written-to slack space. For Go programmers, this slack
|
||||
// space is roughly analogous to the s[len(s):cap(s)] space of a slice s.
|
||||
class DynIOBuffer {
|
||||
public:
|
||||
enum GrowResult {
|
||||
OK = 0,
|
||||
FailedMaxInclExceeded = 1,
|
||||
FailedOutOfMemory = 2,
|
||||
};
|
||||
|
||||
// m_buf holds the dynamically sized byte array and its read/write indexes:
|
||||
// - m_buf.meta.wi is roughly analogous to a Go slice's length.
|
||||
// - m_buf.data.len is roughly analogous to a Go slice's capacity. It is
|
||||
// also equal to the m_buf.data.ptr malloc/realloc size.
|
||||
//
|
||||
// Users should not modify the m_buf.data.ptr or m_buf.data.len fields (as
|
||||
// they are conceptually private to this class), but they can modify the
|
||||
// bytes referenced by that pointer-length pair (e.g. compactions).
|
||||
IOBuffer m_buf;
|
||||
|
||||
// m_max_incl is an inclusive upper bound on the backing array size.
|
||||
const uint64_t m_max_incl;
|
||||
|
||||
// Constructor and destructor.
|
||||
explicit DynIOBuffer(uint64_t max_incl);
|
||||
~DynIOBuffer();
|
||||
|
||||
// Drop frees the byte array and resets m_buf. The DynIOBuffer can still be
|
||||
// used after a drop call. It just restarts from zero.
|
||||
void drop();
|
||||
|
||||
// grow ensures that the byte array size is at least min_incl and at most
|
||||
// max_incl. It returns FailedMaxInclExceeded if that would require
|
||||
// allocating more than max_incl bytes, including the case where (min_incl >
|
||||
// max_incl). It returns FailedOutOfMemory if memory allocation failed.
|
||||
GrowResult grow(uint64_t min_incl);
|
||||
|
||||
private:
|
||||
// Delete the copy and assign constructors.
|
||||
DynIOBuffer(const DynIOBuffer&) = delete;
|
||||
DynIOBuffer& operator=(const DynIOBuffer&) = delete;
|
||||
|
||||
static uint64_t round_up(uint64_t min_incl, uint64_t max_incl);
|
||||
};
|
||||
|
||||
// --------
|
||||
|
||||
class Input {
|
||||
public:
|
||||
virtual ~Input();
|
||||
@@ -9793,6 +10145,26 @@ class DecodeCborCallbacks {
|
||||
Done(DecodeCborResult& result, sync_io::Input& input, IOBuffer& buffer);
|
||||
};
|
||||
|
||||
// The FooArgBar types add structure to Foo's optional arguments. They wrap
|
||||
// inner representations for several reasons:
|
||||
// - It provides a home for the DefaultValue static method, for Foo callers
|
||||
// that want to override some but not all optional arguments.
|
||||
// - It provides the "Bar" name at Foo call sites, which can help self-
|
||||
// document Foo calls with many arguemnts.
|
||||
// - It provides some type safety against accidentally transposing or omitting
|
||||
// adjacent fundamentally-numeric-typed optional arguments.
|
||||
|
||||
// DecodeCborArgQuirks wraps an optional argument to DecodeCbor.
|
||||
struct DecodeCborArgQuirks {
|
||||
explicit DecodeCborArgQuirks(wuffs_base__slice_u32 repr0);
|
||||
explicit DecodeCborArgQuirks(uint32_t* ptr, size_t len);
|
||||
|
||||
// DefaultValue returns an empty slice.
|
||||
static DecodeCborArgQuirks DefaultValue();
|
||||
|
||||
wuffs_base__slice_u32 repr;
|
||||
};
|
||||
|
||||
// DecodeCbor calls callbacks based on the CBOR-formatted data in input.
|
||||
//
|
||||
// On success, the returned error_message is empty and cursor_position counts
|
||||
@@ -9802,7 +10174,7 @@ class DecodeCborCallbacks {
|
||||
DecodeCborResult //
|
||||
DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32());
|
||||
DecodeCborArgQuirks quirks = DecodeCborArgQuirks::DefaultValue());
|
||||
|
||||
} // namespace wuffs_aux
|
||||
|
||||
@@ -9824,10 +10196,11 @@ struct DecodeImageResult {
|
||||
// DecodeImageCallbacks are the callbacks given to DecodeImage. They are always
|
||||
// called in this order:
|
||||
// 1. SelectDecoder
|
||||
// 2. SelectPixfmt
|
||||
// 3. AllocPixbuf
|
||||
// 4. AllocWorkbuf
|
||||
// 5. Done
|
||||
// 2. HandleMetadata
|
||||
// 3. SelectPixfmt
|
||||
// 4. AllocPixbuf
|
||||
// 5. AllocWorkbuf
|
||||
// 6. Done
|
||||
//
|
||||
// It may return early - the third callback might not be invoked if the second
|
||||
// one fails - but the final callback (Done) is always invoked.
|
||||
@@ -9884,6 +10257,22 @@ class DecodeImageCallbacks {
|
||||
virtual wuffs_base__image_decoder::unique_ptr //
|
||||
SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix);
|
||||
|
||||
// HandleMetadata acknowledges image metadata. minfo.flavor will be one of:
|
||||
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH
|
||||
// - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED
|
||||
// If it is ETC__METADATA_RAW_ETC then raw contains the metadata bytes. Those
|
||||
// bytes should not be retained beyond the the HandleMetadata call.
|
||||
//
|
||||
// minfo.metadata__fourcc() will typically match one of the
|
||||
// DecodeImageArgFlags bits. For example, if (REPORT_METADATA_CHRM |
|
||||
// REPORT_METADATA_GAMA) was passed to DecodeImage then the metadata FourCC
|
||||
// will be either WUFFS_BASE__FOURCC__CHRM or WUFFS_BASE__FOURCC__GAMA.
|
||||
//
|
||||
// It returns an error message, or an empty string on success.
|
||||
virtual std::string //
|
||||
HandleMetadata(const wuffs_base__more_information& minfo,
|
||||
wuffs_base__slice_u8 raw);
|
||||
|
||||
// SelectPixfmt returns the destination pixel format for AllocPixbuf. It
|
||||
// should return wuffs_base__make_pixel_format(etc) called with one of:
|
||||
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
|
||||
@@ -9950,13 +10339,116 @@ class DecodeImageCallbacks {
|
||||
|
||||
extern const char DecodeImage_BufferIsTooShort[];
|
||||
extern const char DecodeImage_MaxInclDimensionExceeded[];
|
||||
extern const char DecodeImage_MaxInclMetadataLengthExceeded[];
|
||||
extern const char DecodeImage_OutOfMemory[];
|
||||
extern const char DecodeImage_UnexpectedEndOfFile[];
|
||||
extern const char DecodeImage_UnsupportedImageFormat[];
|
||||
extern const char DecodeImage_UnsupportedMetadata[];
|
||||
extern const char DecodeImage_UnsupportedPixelBlend[];
|
||||
extern const char DecodeImage_UnsupportedPixelConfiguration[];
|
||||
extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
|
||||
// The FooArgBar types add structure to Foo's optional arguments. They wrap
|
||||
// inner representations for several reasons:
|
||||
// - It provides a home for the DefaultValue static method, for Foo callers
|
||||
// that want to override some but not all optional arguments.
|
||||
// - It provides the "Bar" name at Foo call sites, which can help self-
|
||||
// document Foo calls with many arguemnts.
|
||||
// - It provides some type safety against accidentally transposing or omitting
|
||||
// adjacent fundamentally-numeric-typed optional arguments.
|
||||
|
||||
// DecodeImageArgQuirks wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgQuirks {
|
||||
explicit DecodeImageArgQuirks(wuffs_base__slice_u32 repr0);
|
||||
explicit DecodeImageArgQuirks(uint32_t* ptr, size_t len);
|
||||
|
||||
// DefaultValue returns an empty slice.
|
||||
static DecodeImageArgQuirks DefaultValue();
|
||||
|
||||
wuffs_base__slice_u32 repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgFlags wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgFlags {
|
||||
explicit DecodeImageArgFlags(uint64_t repr0);
|
||||
|
||||
// DefaultValue returns 0.
|
||||
static DecodeImageArgFlags DefaultValue();
|
||||
|
||||
// TODO: support all of the REPORT_METADATA_ETC flags, not just CHRM, EXIF,
|
||||
// GAMA, ICCP, KVP, SRGB and XMP.
|
||||
|
||||
// Background Color.
|
||||
static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001;
|
||||
// Primary Chromaticities and White Point.
|
||||
static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002;
|
||||
// Exchangeable Image File Format.
|
||||
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004;
|
||||
// Gamma Correction.
|
||||
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008;
|
||||
// International Color Consortium Profile.
|
||||
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010;
|
||||
// Key-Value Pair.
|
||||
//
|
||||
// For PNG files, this includes iTXt, tEXt and zTXt chunks. In the
|
||||
// HandleMetadata callback, the raw argument contains UTF-8 strings.
|
||||
static constexpr uint64_t REPORT_METADATA_KVP = 0x0020;
|
||||
// Modification Time.
|
||||
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040;
|
||||
// Offset (2-Dimensional).
|
||||
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080;
|
||||
// Physical Dimensions.
|
||||
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100;
|
||||
// Standard Red Green Blue (Rendering Intent).
|
||||
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200;
|
||||
// Extensible Metadata Platform.
|
||||
static constexpr uint64_t REPORT_METADATA_XMP = 0x0400;
|
||||
|
||||
uint64_t repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgPixelBlend wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgPixelBlend {
|
||||
explicit DecodeImageArgPixelBlend(wuffs_base__pixel_blend repr0);
|
||||
|
||||
// DefaultValue returns WUFFS_BASE__PIXEL_BLEND__SRC.
|
||||
static DecodeImageArgPixelBlend DefaultValue();
|
||||
|
||||
wuffs_base__pixel_blend repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgBackgroundColor wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgBackgroundColor {
|
||||
explicit DecodeImageArgBackgroundColor(
|
||||
wuffs_base__color_u32_argb_premul repr0);
|
||||
|
||||
// DefaultValue returns 1, an invalid wuffs_base__color_u32_argb_premul.
|
||||
static DecodeImageArgBackgroundColor DefaultValue();
|
||||
|
||||
wuffs_base__color_u32_argb_premul repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgMaxInclDimension wraps an optional argument to DecodeImage.
|
||||
struct DecodeImageArgMaxInclDimension {
|
||||
explicit DecodeImageArgMaxInclDimension(uint32_t repr0);
|
||||
|
||||
// DefaultValue returns 1048575 = 0x000F_FFFF, more than 1 million pixels.
|
||||
static DecodeImageArgMaxInclDimension DefaultValue();
|
||||
|
||||
uint32_t repr;
|
||||
};
|
||||
|
||||
// DecodeImageArgMaxInclMetadataLength wraps an optional argument to
|
||||
// DecodeImage.
|
||||
struct DecodeImageArgMaxInclMetadataLength {
|
||||
explicit DecodeImageArgMaxInclMetadataLength(uint64_t repr0);
|
||||
|
||||
// DefaultValue returns 16777215 = 0x00FF_FFFF, one less than 16 MiB.
|
||||
static DecodeImageArgMaxInclMetadataLength DefaultValue();
|
||||
|
||||
uint64_t repr;
|
||||
};
|
||||
|
||||
// DecodeImage decodes the image data in input. A variety of image file formats
|
||||
// can be decoded, depending on what callbacks.SelectDecoder returns.
|
||||
//
|
||||
@@ -9999,13 +10491,21 @@ extern const char DecodeImage_UnsupportedPixelFormat[];
|
||||
// WUFFS_BASE__PIXEL_BLEND__SRC_OVER and the decoded image is not fully opaque.
|
||||
//
|
||||
// Decoding fails (with DecodeImage_MaxInclDimensionExceeded) if the image's
|
||||
// width or height is greater than max_incl_dimension.
|
||||
// width or height is greater than max_incl_dimension or if any opted-in (via
|
||||
// flags bits) metadata is longer than max_incl_metadata_length.
|
||||
DecodeImageResult //
|
||||
DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__pixel_blend pixel_blend = WUFFS_BASE__PIXEL_BLEND__SRC,
|
||||
wuffs_base__color_u32_argb_premul background_color = 1, // Invalid.
|
||||
uint32_t max_incl_dimension = 1048575); // 0x000F_FFFF
|
||||
DecodeImageArgQuirks quirks = DecodeImageArgQuirks::DefaultValue(),
|
||||
DecodeImageArgFlags flags = DecodeImageArgFlags::DefaultValue(),
|
||||
DecodeImageArgPixelBlend pixel_blend =
|
||||
DecodeImageArgPixelBlend::DefaultValue(),
|
||||
DecodeImageArgBackgroundColor background_color =
|
||||
DecodeImageArgBackgroundColor::DefaultValue(),
|
||||
DecodeImageArgMaxInclDimension max_incl_dimension =
|
||||
DecodeImageArgMaxInclDimension::DefaultValue(),
|
||||
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length =
|
||||
DecodeImageArgMaxInclMetadataLength::DefaultValue());
|
||||
|
||||
} // namespace wuffs_aux
|
||||
|
||||
@@ -10066,6 +10566,36 @@ class DecodeJsonCallbacks {
|
||||
extern const char DecodeJson_BadJsonPointer[];
|
||||
extern const char DecodeJson_NoMatch[];
|
||||
|
||||
// The FooArgBar types add structure to Foo's optional arguments. They wrap
|
||||
// inner representations for several reasons:
|
||||
// - It provides a home for the DefaultValue static method, for Foo callers
|
||||
// that want to override some but not all optional arguments.
|
||||
// - It provides the "Bar" name at Foo call sites, which can help self-
|
||||
// document Foo calls with many arguemnts.
|
||||
// - It provides some type safety against accidentally transposing or omitting
|
||||
// adjacent fundamentally-numeric-typed optional arguments.
|
||||
|
||||
// DecodeJsonArgQuirks wraps an optional argument to DecodeJson.
|
||||
struct DecodeJsonArgQuirks {
|
||||
explicit DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0);
|
||||
explicit DecodeJsonArgQuirks(uint32_t* ptr, size_t len);
|
||||
|
||||
// DefaultValue returns an empty slice.
|
||||
static DecodeJsonArgQuirks DefaultValue();
|
||||
|
||||
wuffs_base__slice_u32 repr;
|
||||
};
|
||||
|
||||
// DecodeJsonArgJsonPointer wraps an optional argument to DecodeJson.
|
||||
struct DecodeJsonArgJsonPointer {
|
||||
explicit DecodeJsonArgJsonPointer(std::string repr0);
|
||||
|
||||
// DefaultValue returns an empty string.
|
||||
static DecodeJsonArgJsonPointer DefaultValue();
|
||||
|
||||
std::string repr;
|
||||
};
|
||||
|
||||
// DecodeJson calls callbacks based on the JSON-formatted data in input.
|
||||
//
|
||||
// On success, the returned error_message is empty and cursor_position counts
|
||||
@@ -10083,8 +10613,9 @@ extern const char DecodeJson_NoMatch[];
|
||||
DecodeJsonResult //
|
||||
DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks = wuffs_base__empty_slice_u32(),
|
||||
std::string json_pointer = std::string());
|
||||
DecodeJsonArgQuirks quirks = DecodeJsonArgQuirks::DefaultValue(),
|
||||
DecodeJsonArgJsonPointer json_pointer =
|
||||
DecodeJsonArgJsonPointer::DefaultValue());
|
||||
|
||||
} // namespace wuffs_aux
|
||||
|
||||
@@ -10134,8 +10665,9 @@ extern "C" {
|
||||
goto suspend; \
|
||||
case n:;
|
||||
|
||||
// Clang also defines "__GNUC__".
|
||||
#if defined(__GNUC__)
|
||||
// The "defined(__clang__)" isn't redundant. While vanilla clang defines
|
||||
// __GNUC__, clang-cl (which mimics MSVC's cl.exe) does not.
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))
|
||||
#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))
|
||||
#else
|
||||
@@ -10293,7 +10825,7 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,
|
||||
// --------
|
||||
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {
|
||||
wuffs_base__table_u8__row_u32(wuffs_base__table_u8 t, uint32_t y) {
|
||||
if (y < t.height) {
|
||||
return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width);
|
||||
}
|
||||
@@ -10464,11 +10996,12 @@ wuffs_base__io_reader__set(wuffs_base__io_buffer* b,
|
||||
const uint8_t** ptr_io0_r,
|
||||
const uint8_t** ptr_io1_r,
|
||||
const uint8_t** ptr_io2_r,
|
||||
wuffs_base__slice_u8 data) {
|
||||
wuffs_base__slice_u8 data,
|
||||
uint64_t history_position) {
|
||||
b->data = data;
|
||||
b->meta.wi = data.len;
|
||||
b->meta.ri = 0;
|
||||
b->meta.pos = 0;
|
||||
b->meta.pos = history_position;
|
||||
b->meta.closed = false;
|
||||
|
||||
*ptr_iop_r = data.ptr;
|
||||
@@ -10508,7 +11041,7 @@ wuffs_base__io_writer__limit(uint8_t** ptr_io2_w,
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -10516,7 +11049,7 @@ wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
|
||||
return 0;
|
||||
}
|
||||
uint8_t* p = *ptr_iop_w;
|
||||
if ((size_t)(p - io1_w) < (size_t)(distance)) {
|
||||
if ((size_t)(p - io0_w) < (size_t)(distance)) {
|
||||
return 0;
|
||||
}
|
||||
uint8_t* q = p - distance;
|
||||
@@ -10553,10 +11086,10 @@ wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
|
||||
// The caller needs to prove that:
|
||||
// - length <= (io2_w - *ptr_iop_w)
|
||||
// - distance >= 1
|
||||
// - distance <= (*ptr_iop_w - io1_w)
|
||||
// - distance <= (*ptr_iop_w - io0_w)
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -10588,11 +11121,11 @@ wuffs_base__io_writer__limited_copy_u32_from_history_fast(uint8_t** ptr_iop_w,
|
||||
// The caller needs to prove that:
|
||||
// - (length + 8) <= (io2_w - *ptr_iop_w)
|
||||
// - distance == 1
|
||||
// - distance <= (*ptr_iop_w - io1_w)
|
||||
// - distance <= (*ptr_iop_w - io0_w)
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fast(
|
||||
uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -10628,11 +11161,11 @@ wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_distance_1_fa
|
||||
// The caller needs to prove that:
|
||||
// - (length + 8) <= (io2_w - *ptr_iop_w)
|
||||
// - distance >= 8
|
||||
// - distance <= (*ptr_iop_w - io1_w)
|
||||
// - distance <= (*ptr_iop_w - io0_w)
|
||||
static inline uint32_t //
|
||||
wuffs_base__io_writer__limited_copy_u32_from_history_8_byte_chunks_fast(
|
||||
uint8_t** ptr_iop_w,
|
||||
uint8_t* io1_w,
|
||||
uint8_t* io0_w,
|
||||
uint8_t* io2_w,
|
||||
uint32_t length,
|
||||
uint32_t distance) {
|
||||
@@ -10702,11 +11235,12 @@ wuffs_base__io_writer__set(wuffs_base__io_buffer* b,
|
||||
uint8_t** ptr_io0_w,
|
||||
uint8_t** ptr_io1_w,
|
||||
uint8_t** ptr_io2_w,
|
||||
wuffs_base__slice_u8 data) {
|
||||
wuffs_base__slice_u8 data,
|
||||
uint64_t history_position) {
|
||||
b->data = data;
|
||||
b->meta.wi = 0;
|
||||
b->meta.ri = 0;
|
||||
b->meta.pos = 0;
|
||||
b->meta.pos = history_position;
|
||||
b->meta.closed = false;
|
||||
|
||||
*ptr_iop_w = data.ptr;
|
||||
@@ -12359,14 +12893,14 @@ wuffs_base__ieee_754_bit_representation__from_f64_to_u32_truncate(double f) {
|
||||
// padded with implicit zeroes.
|
||||
//
|
||||
// For example, if num_digits is 3 and digits is "\x07\x08\x09":
|
||||
// - A decimal_point of -2 means ".00789"
|
||||
// - A decimal_point of -1 means ".0789"
|
||||
// - A decimal_point of +0 means ".789"
|
||||
// - A decimal_point of +1 means "7.89"
|
||||
// - A decimal_point of +2 means "78.9"
|
||||
// - A decimal_point of +3 means "789."
|
||||
// - A decimal_point of +4 means "7890."
|
||||
// - A decimal_point of +5 means "78900."
|
||||
// - A decimal_point of -2 means ".00789"
|
||||
// - A decimal_point of -1 means ".0789"
|
||||
// - A decimal_point of +0 means ".789"
|
||||
// - A decimal_point of +1 means "7.89"
|
||||
// - A decimal_point of +2 means "78.9"
|
||||
// - A decimal_point of +3 means "789."
|
||||
// - A decimal_point of +4 means "7890."
|
||||
// - A decimal_point of +5 means "78900."
|
||||
//
|
||||
// As above, a decimal_point higher than +2047 means that the overall value is
|
||||
// infinity, lower than -2047 means zero.
|
||||
@@ -12711,10 +13245,10 @@ wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(
|
||||
// wuffs_base__private_implementation__high_prec_dec__rounded_integer returns
|
||||
// the integral (non-fractional) part of h, provided that it is 18 or fewer
|
||||
// decimal digits. For 19 or more digits, it returns UINT64_MAX. Note that:
|
||||
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
|
||||
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
|
||||
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
|
||||
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
|
||||
// - (1 << 53) is 9007199254740992, which has 16 decimal digits.
|
||||
// - (1 << 56) is 72057594037927936, which has 17 decimal digits.
|
||||
// - (1 << 59) is 576460752303423488, which has 18 decimal digits.
|
||||
// - (1 << 63) is 9223372036854775808, which has 19 decimal digits.
|
||||
// and that IEEE 754 double precision has 52 mantissa bits.
|
||||
//
|
||||
// That integral part is rounded-to-even: rounding 7.5 or 8.5 both give 8.
|
||||
@@ -14271,13 +14805,18 @@ wuffs_base__parse_number_i64(wuffs_base__slice_u8 s, uint32_t options) {
|
||||
ret.value = 0;
|
||||
return ret;
|
||||
} else if (negative) {
|
||||
if (r.value > 0x8000000000000000) {
|
||||
goto fail_out_of_bounds;
|
||||
if (r.value < 0x8000000000000000) {
|
||||
wuffs_base__result_i64 ret;
|
||||
ret.status.repr = NULL;
|
||||
ret.value = -(int64_t)(r.value);
|
||||
return ret;
|
||||
} else if (r.value == 0x8000000000000000) {
|
||||
wuffs_base__result_i64 ret;
|
||||
ret.status.repr = NULL;
|
||||
ret.value = INT64_MIN;
|
||||
return ret;
|
||||
}
|
||||
wuffs_base__result_i64 ret;
|
||||
ret.status.repr = NULL;
|
||||
ret.value = -(int64_t)(r.value);
|
||||
return ret;
|
||||
goto fail_out_of_bounds;
|
||||
} else if (r.value > 0x7FFFFFFFFFFFFFFF) {
|
||||
goto fail_out_of_bounds;
|
||||
} else {
|
||||
@@ -15042,19 +15581,23 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
|
||||
//
|
||||
// Keep it sorted by magic[1], then magic[0] descending and finally by
|
||||
// magic[2:]. When multiple entries match, the longest one wins.
|
||||
//
|
||||
// The fourcc field might be negated, in which case there's further
|
||||
// specialization (see § below).
|
||||
static struct {
|
||||
int32_t fourcc;
|
||||
const char* magic;
|
||||
} table[] = {
|
||||
{0x57424D50, "\x01\x00\x00"}, // WBMP
|
||||
{0x424D5020, "\x01\x42\x4D"}, // BMP
|
||||
{0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
|
||||
{0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
|
||||
{0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
|
||||
{0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF (see § below)
|
||||
{0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
|
||||
{0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
|
||||
{0x4A504547, "\x01\xFF\xD8"}, // JPEG
|
||||
{-0x30302020, "\x01\x00\x00"}, // '00 'be
|
||||
{+0x424D5020, "\x01\x42\x4D"}, // BMP
|
||||
{+0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
|
||||
{+0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
|
||||
{+0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
|
||||
{-0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF
|
||||
{+0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
|
||||
{+0x514F4920, "\x03\x71\x6F\x69\x66"}, // QOI
|
||||
{+0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
|
||||
{+0x4A504547, "\x01\xFF\xD8"}, // JPEG
|
||||
};
|
||||
static const size_t table_len = sizeof(table) / sizeof(table[0]);
|
||||
|
||||
@@ -15095,19 +15638,33 @@ wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix) {
|
||||
return 0;
|
||||
|
||||
match:
|
||||
// Some FourCC values (see § above) are further specialized.
|
||||
if (fourcc == 0x52494646) { // 'RIFF'be
|
||||
if (prefix.len < 16) {
|
||||
return -1;
|
||||
}
|
||||
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
|
||||
if (x == 0x57454250) { // 'WEBP'be
|
||||
uint32_t y = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 12);
|
||||
if (y == 0x56503820) { // 'VP8 'be
|
||||
return 0x57503820; // 'WP8 'be
|
||||
} else if (y == 0x5650384C) { // 'VP8L'be
|
||||
return 0x5750384C; // 'WP8L'be
|
||||
// Negative FourCC values (see § above) are further specialized.
|
||||
if (fourcc < 0) {
|
||||
fourcc = -fourcc;
|
||||
|
||||
if (fourcc == 0x52494646) { // 'RIFF'be
|
||||
if (prefix.len < 12) {
|
||||
return -1;
|
||||
}
|
||||
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix.ptr + 8);
|
||||
if (x == 0x57454250) { // 'WEBP'be
|
||||
return 0x57454250; // 'WEBP'be
|
||||
}
|
||||
|
||||
} else if (fourcc == 0x30302020) { // '00 'be
|
||||
// Binary data starting with multiple 0x00 NUL bytes is quite common.
|
||||
if (prefix.len < 4) {
|
||||
return -1;
|
||||
} else if ((prefix.ptr[2] != 0x00) &&
|
||||
((prefix.ptr[2] >= 0x80) || (prefix.ptr[3] != 0x00))) {
|
||||
// Roughly speaking, this could be a non-degenerate (non-0-width and
|
||||
// non-0-height) WBMP image.
|
||||
return 0x57424D50; // 'WBMP'be
|
||||
} else if (((prefix.ptr[2] == 0x01) || (prefix.ptr[2] == 0x02)) &&
|
||||
(prefix.ptr[3] == 0x00)) {
|
||||
return 0x49434F20; // 'ICO 'be
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return fourcc;
|
||||
@@ -15609,14 +16166,23 @@ static inline uint32_t //
|
||||
wuffs_base__composite_nonpremul_nonpremul_u32_axxx(uint32_t dst_nonpremul,
|
||||
uint32_t src_nonpremul) {
|
||||
// Extract 16-bit color components.
|
||||
//
|
||||
// If the destination is transparent then SRC_OVER is equivalent to SRC: just
|
||||
// return src_nonpremul. This isn't just an optimization (skipping the rest
|
||||
// of the function's computation). It also preserves the nonpremul
|
||||
// distinction between e.g. transparent red and transparent blue that would
|
||||
// otherwise be lost by converting from nonpremul to premul and back.
|
||||
uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
|
||||
if (da == 0) {
|
||||
return src_nonpremul;
|
||||
}
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -15653,14 +16219,23 @@ static inline uint64_t //
|
||||
wuffs_base__composite_nonpremul_nonpremul_u64_axxx(uint64_t dst_nonpremul,
|
||||
uint64_t src_nonpremul) {
|
||||
// Extract components.
|
||||
//
|
||||
// If the destination is transparent then SRC_OVER is equivalent to SRC: just
|
||||
// return src_nonpremul. This isn't just an optimization (skipping the rest
|
||||
// of the function's computation). It also preserves the nonpremul
|
||||
// distinction between e.g. transparent red and transparent blue that would
|
||||
// otherwise be lost by converting from nonpremul to premul and back.
|
||||
uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
|
||||
if (da == 0) {
|
||||
return src_nonpremul;
|
||||
}
|
||||
uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
|
||||
uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
|
||||
uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
|
||||
uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -15691,14 +16266,14 @@ static inline uint32_t //
|
||||
wuffs_base__composite_nonpremul_premul_u32_axxx(uint32_t dst_nonpremul,
|
||||
uint32_t src_premul) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -15735,14 +16310,14 @@ static inline uint64_t //
|
||||
wuffs_base__composite_nonpremul_premul_u64_axxx(uint64_t dst_nonpremul,
|
||||
uint64_t src_premul) {
|
||||
// Extract components.
|
||||
uint64_t sa = 0xFFFF & (src_premul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_premul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_premul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_premul >> 0);
|
||||
uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
|
||||
uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
|
||||
uint64_t sa = 0xFFFF & (src_premul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_premul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_premul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_premul >> 0);
|
||||
|
||||
// Convert dst from nonpremul to premul.
|
||||
dr = (dr * da) / 0xFFFF;
|
||||
@@ -15773,14 +16348,14 @@ static inline uint32_t //
|
||||
wuffs_base__composite_premul_nonpremul_u32_axxx(uint32_t dst_premul,
|
||||
uint32_t src_nonpremul) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -15805,14 +16380,14 @@ static inline uint64_t //
|
||||
wuffs_base__composite_premul_nonpremul_u64_axxx(uint64_t dst_premul,
|
||||
uint64_t src_nonpremul) {
|
||||
// Extract components.
|
||||
uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
|
||||
uint64_t da = 0xFFFF & (dst_premul >> 48);
|
||||
uint64_t dr = 0xFFFF & (dst_premul >> 32);
|
||||
uint64_t dg = 0xFFFF & (dst_premul >> 16);
|
||||
uint64_t db = 0xFFFF & (dst_premul >> 0);
|
||||
uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
|
||||
uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
|
||||
uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
|
||||
uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint64_t ia = 0xFFFF - sa;
|
||||
@@ -15831,14 +16406,14 @@ static inline uint32_t //
|
||||
wuffs_base__composite_premul_premul_u32_axxx(uint32_t dst_premul,
|
||||
uint32_t src_premul) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));
|
||||
uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));
|
||||
uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));
|
||||
uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));
|
||||
uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
|
||||
uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
|
||||
uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
|
||||
uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -15918,7 +16493,7 @@ wuffs_base__pixel_swizzler__swap_rgb_bgr(uint8_t* dst_ptr,
|
||||
}
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
|
||||
@@ -15962,7 +16537,7 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
|
||||
}
|
||||
return len;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
static uint64_t //
|
||||
@@ -16898,13 +17473,13 @@ wuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src_over(
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -16946,13 +17521,13 @@ wuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src_over(
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
|
||||
uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
|
||||
uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
|
||||
uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -17021,13 +17596,13 @@ wuffs_base__pixel_swizzler__bgr__bgra_premul__src_over(uint8_t* dst_ptr,
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -17099,13 +17674,13 @@ wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src_over(
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -17174,13 +17749,13 @@ wuffs_base__pixel_swizzler__bgr__rgba_premul__src_over(uint8_t* dst_ptr,
|
||||
|
||||
while (n >= 1) {
|
||||
// Extract 16-bit color components.
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
uint32_t sa = 0x101 * ((uint32_t)s[3]);
|
||||
uint32_t sb = 0x101 * ((uint32_t)s[2]);
|
||||
uint32_t sg = 0x101 * ((uint32_t)s[1]);
|
||||
uint32_t sr = 0x101 * ((uint32_t)s[0]);
|
||||
uint32_t dr = 0x101 * ((uint32_t)d[2]);
|
||||
uint32_t dg = 0x101 * ((uint32_t)d[1]);
|
||||
uint32_t db = 0x101 * ((uint32_t)d[0]);
|
||||
|
||||
// Calculate the inverse of the src-alpha: how much of the dst to keep.
|
||||
uint32_t ia = 0xFFFF - sa;
|
||||
@@ -18241,7 +18816,7 @@ wuffs_base__pixel_swizzler__bgrw__bgrx(uint8_t* dst_ptr,
|
||||
}
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
|
||||
@@ -18294,7 +18869,7 @@ wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
|
||||
|
||||
return len;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
static uint64_t //
|
||||
@@ -18953,7 +19528,7 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(
|
||||
}
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
|
||||
@@ -19000,7 +19575,7 @@ wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
|
||||
|
||||
return len;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
static uint64_t //
|
||||
@@ -19288,7 +19863,7 @@ wuffs_base__pixel_swizzler__prepare__y(wuffs_base__pixel_swizzler* p,
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__xxxx__y__sse42;
|
||||
}
|
||||
@@ -19671,7 +20246,7 @@ wuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
|
||||
}
|
||||
@@ -19746,7 +20321,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -19927,7 +20502,7 @@ wuffs_base__pixel_swizzler__prepare__bgra_premul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -19995,7 +20570,7 @@ wuffs_base__pixel_swizzler__prepare__rgb(wuffs_base__pixel_swizzler* p,
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
|
||||
}
|
||||
@@ -20046,7 +20621,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -20157,7 +20732,7 @@ wuffs_base__pixel_swizzler__prepare__rgba_premul(
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
switch (blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
if (wuffs_base__cpu_arch__have_x86_sse42()) {
|
||||
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
|
||||
}
|
||||
@@ -20640,12 +21215,12 @@ wuffs_adler32__hasher__up_arm_neon(
|
||||
wuffs_base__slice_u8 a_x);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_adler32__hasher__up_x86_sse42(
|
||||
wuffs_adler32__hasher* self,
|
||||
wuffs_base__slice_u8 a_x);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
// ---------------- VTables
|
||||
|
||||
@@ -20761,7 +21336,7 @@ wuffs_adler32__hasher__update_u32(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_adler32__hasher__up_arm_neon :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_adler32__hasher__up_x86_sse42 :
|
||||
#endif
|
||||
self->private_impl.choosy_up);
|
||||
@@ -20953,7 +21528,7 @@ wuffs_adler32__hasher__up_arm_neon(
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func adler32.hasher.up_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_adler32__hasher__up_x86_sse42(
|
||||
@@ -21039,7 +21614,7 @@ wuffs_adler32__hasher__up_x86_sse42(
|
||||
self->private_impl.f_state = (((v_s2 & 65535) << 16) | (v_s1 & 65535));
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ADLER32)
|
||||
@@ -21370,7 +21945,7 @@ wuffs_bmp__decoder__decode_image_config(
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_padding -= 14;
|
||||
self->private_impl.f_io_redirect_pos = wuffs_base__u64__sat_add(((uint64_t)(self->private_impl.f_padding)), wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))));
|
||||
self->private_impl.f_io_redirect_pos = wuffs_base__u64__sat_add(((uint64_t)(self->private_impl.f_padding)), wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))));
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
uint32_t t_2;
|
||||
@@ -22119,7 +22694,7 @@ wuffs_bmp__decoder__decode_image_config(
|
||||
} else if (self->private_impl.f_bits_per_pixel == 32) {
|
||||
self->private_impl.f_pad_per_row = 0;
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
if (a_dst != NULL) {
|
||||
v_dst_pixfmt = 2164295816;
|
||||
if ((self->private_impl.f_channel_num_bits[0] > 8) ||
|
||||
@@ -22217,7 +22792,7 @@ wuffs_bmp__decoder__decode_frame_config(
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 3) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
}
|
||||
@@ -22522,7 +23097,7 @@ wuffs_bmp__decoder__swizzle_none(
|
||||
goto label__outer__continue;
|
||||
}
|
||||
}
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -22607,7 +23182,7 @@ wuffs_bmp__decoder__swizzle_rle(
|
||||
v_rle_state = self->private_impl.f_rle_state;
|
||||
label__outer__continue:;
|
||||
while (true) {
|
||||
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
|
||||
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -22767,7 +23342,7 @@ wuffs_bmp__decoder__swizzle_rle(
|
||||
status = wuffs_base__make_status(wuffs_bmp__error__bad_rle_compression);
|
||||
goto exit;
|
||||
}
|
||||
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
|
||||
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -22799,7 +23374,7 @@ wuffs_bmp__decoder__swizzle_rle(
|
||||
}
|
||||
label__outer__break:;
|
||||
while (self->private_impl.f_dst_y < self->private_impl.f_height) {
|
||||
v_row = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_row = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_row.len))) {
|
||||
v_row = wuffs_base__slice_u8__subslice_j(v_row, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -22929,7 +23504,7 @@ wuffs_bmp__decoder__swizzle_bitfields(
|
||||
v_p0 += 1;
|
||||
}
|
||||
label__0__break:;
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -23011,7 +23586,7 @@ wuffs_bmp__decoder__swizzle_low_bit_depth(
|
||||
goto label__loop__break;
|
||||
}
|
||||
}
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -24819,19 +25394,19 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
|
||||
wuffs_base__slice_u8 a_x);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_crc32__ieee_hasher__up_x86_avx2(
|
||||
wuffs_crc32__ieee_hasher* self,
|
||||
wuffs_base__slice_u8 a_x);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_crc32__ieee_hasher__up_x86_sse42(
|
||||
wuffs_crc32__ieee_hasher* self,
|
||||
wuffs_base__slice_u8 a_x);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
// ---------------- VTables
|
||||
|
||||
@@ -24945,10 +25520,10 @@ wuffs_crc32__ieee_hasher__update_u32(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
|
||||
wuffs_base__cpu_arch__have_arm_crc32() ? &wuffs_crc32__ieee_hasher__up_arm_crc32 :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_avx2() ? &wuffs_crc32__ieee_hasher__up_x86_avx2 :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_crc32__ieee_hasher__up_x86_sse42 :
|
||||
#endif
|
||||
self->private_impl.choosy_up);
|
||||
@@ -25138,7 +25713,7 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_avx2
|
||||
// -------- func crc32.ieee_hasher.up_x86_avx2
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_crc32__ieee_hasher__up_x86_avx2(
|
||||
@@ -25251,13 +25826,13 @@ wuffs_crc32__ieee_hasher__up_x86_avx2(
|
||||
self->private_impl.f_state = (4294967295 ^ v_s);
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_avx2
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func crc32.ieee_hasher.up_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_crc32__ieee_hasher__up_x86_sse42(
|
||||
@@ -25370,7 +25945,7 @@ wuffs_crc32__ieee_hasher__up_x86_sse42(
|
||||
self->private_impl.f_state = (4294967295 ^ v_s);
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__CRC32)
|
||||
@@ -25495,13 +26070,13 @@ wuffs_deflate__decoder__init_huff(
|
||||
uint32_t a_n_codes1,
|
||||
uint32_t a_base_symbol);
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__status
|
||||
wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
wuffs_deflate__decoder* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_deflate__decoder__decode_huffman_fast32(
|
||||
@@ -25731,7 +26306,7 @@ wuffs_deflate__decoder__transform_io(
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
self->private_impl.choosy_decode_huffman_fast64 = (
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_bmi2() ? &wuffs_deflate__decoder__decode_huffman_bmi2 :
|
||||
#endif
|
||||
self->private_impl.choosy_decode_huffman_fast64);
|
||||
@@ -25757,6 +26332,7 @@ wuffs_deflate__decoder__transform_io(
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_transformed_history_count, wuffs_base__io__count_since(v_mark, ((uint64_t)(iop_a_dst - io0_a_dst))));
|
||||
wuffs_deflate__decoder__add_history(self, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_dst - io0_a_dst)), io0_a_dst));
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
@@ -26433,14 +27009,17 @@ wuffs_deflate__decoder__init_huff(
|
||||
v_i += 1;
|
||||
}
|
||||
if (v_remaining != 0) {
|
||||
if ((a_which == 1) &&
|
||||
(v_counts[1] == 1) &&
|
||||
(self->private_data.f_code_lengths[a_n_codes0] == 1) &&
|
||||
((((uint32_t)(v_counts[0])) + a_n_codes0 + 1) == a_n_codes1)) {
|
||||
self->private_impl.f_n_huffs_bits[1] = 1;
|
||||
self->private_data.f_huffs[1][0] = (WUFFS_DEFLATE__DCODE_MAGIC_NUMBERS[0] | 1);
|
||||
self->private_data.f_huffs[1][1] = (WUFFS_DEFLATE__DCODE_MAGIC_NUMBERS[31] | 1);
|
||||
return wuffs_base__make_status(NULL);
|
||||
if ((a_which == 1) && (v_counts[1] == 1) && ((((uint32_t)(v_counts[0])) + a_n_codes0 + 1) == a_n_codes1)) {
|
||||
v_i = 0;
|
||||
while (v_i <= 29) {
|
||||
if (self->private_data.f_code_lengths[(a_n_codes0 + v_i)] == 1) {
|
||||
self->private_impl.f_n_huffs_bits[1] = 1;
|
||||
self->private_data.f_huffs[1][0] = (WUFFS_DEFLATE__DCODE_MAGIC_NUMBERS[v_i] | 1);
|
||||
self->private_data.f_huffs[1][1] = (WUFFS_DEFLATE__DCODE_MAGIC_NUMBERS[31] | 1);
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
v_i += 1;
|
||||
}
|
||||
}
|
||||
return wuffs_base__make_status(wuffs_deflate__error__bad_huffman_code_under_subscribed);
|
||||
}
|
||||
@@ -26623,7 +27202,7 @@ wuffs_deflate__decoder__init_huff(
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_bmi2
|
||||
// -------- func deflate.decoder.decode_huffman_bmi2
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("bmi2")
|
||||
static wuffs_base__status
|
||||
wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
@@ -26644,6 +27223,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
uint32_t v_dist_minus_1 = 0;
|
||||
uint32_t v_hlen = 0;
|
||||
uint32_t v_hdist = 0;
|
||||
uint32_t v_hdist_adjustment = 0;
|
||||
|
||||
uint8_t* iop_a_dst = NULL;
|
||||
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -26677,6 +27257,11 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
v_n_bits = self->private_impl.f_n_bits;
|
||||
v_lmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
|
||||
v_dmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
|
||||
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
|
||||
label__loop__continue:;
|
||||
while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 266) && (((uint64_t)(io2_a_src - iop_a_src)) >= 8)) {
|
||||
v_bits |= ((uint64_t)(wuffs_base__peek_u64le__no_bounds_check(iop_a_src) << (v_n_bits & 63)));
|
||||
@@ -26767,13 +27352,13 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
v_hlen = v_length;
|
||||
v_length = 0;
|
||||
}
|
||||
v_hdist += v_hdist_adjustment;
|
||||
if (self->private_impl.f_history_index < v_hdist) {
|
||||
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist = (self->private_impl.f_history_index - v_hdist);
|
||||
wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), (v_hdist & 32767)));
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
|
||||
if (v_length == 0) {
|
||||
goto label__loop__continue;
|
||||
}
|
||||
@@ -26827,7 +27412,7 @@ wuffs_deflate__decoder__decode_huffman_bmi2(
|
||||
|
||||
return status;
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_bmi2
|
||||
|
||||
// -------- func deflate.decoder.decode_huffman_fast32
|
||||
@@ -26851,6 +27436,7 @@ wuffs_deflate__decoder__decode_huffman_fast32(
|
||||
uint32_t v_dist_minus_1 = 0;
|
||||
uint32_t v_hlen = 0;
|
||||
uint32_t v_hdist = 0;
|
||||
uint32_t v_hdist_adjustment = 0;
|
||||
|
||||
uint8_t* iop_a_dst = NULL;
|
||||
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -26884,6 +27470,11 @@ wuffs_deflate__decoder__decode_huffman_fast32(
|
||||
v_n_bits = self->private_impl.f_n_bits;
|
||||
v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
|
||||
v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
|
||||
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
|
||||
label__loop__continue:;
|
||||
while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 266) && (((uint64_t)(io2_a_src - iop_a_src)) >= 12)) {
|
||||
if (v_n_bits < 15) {
|
||||
@@ -27026,13 +27617,13 @@ wuffs_deflate__decoder__decode_huffman_fast32(
|
||||
v_hlen = v_length;
|
||||
v_length = 0;
|
||||
}
|
||||
v_hdist += v_hdist_adjustment;
|
||||
if (self->private_impl.f_history_index < v_hdist) {
|
||||
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist = (self->private_impl.f_history_index - v_hdist);
|
||||
wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), (v_hdist & 32767)));
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
|
||||
if (v_length == 0) {
|
||||
goto label__loop__continue;
|
||||
}
|
||||
@@ -27109,6 +27700,7 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
|
||||
uint32_t v_dist_minus_1 = 0;
|
||||
uint32_t v_hlen = 0;
|
||||
uint32_t v_hdist = 0;
|
||||
uint32_t v_hdist_adjustment = 0;
|
||||
|
||||
uint8_t* iop_a_dst = NULL;
|
||||
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -27142,6 +27734,11 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
|
||||
v_n_bits = self->private_impl.f_n_bits;
|
||||
v_lmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
|
||||
v_dmask = ((((uint64_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
|
||||
if (self->private_impl.f_transformed_history_count < (a_dst ? a_dst->meta.pos : 0)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist_adjustment = ((uint32_t)(((self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0)) & 4294967295)));
|
||||
label__loop__continue:;
|
||||
while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 266) && (((uint64_t)(io2_a_src - iop_a_src)) >= 8)) {
|
||||
v_bits |= ((uint64_t)(wuffs_base__peek_u64le__no_bounds_check(iop_a_src) << (v_n_bits & 63)));
|
||||
@@ -27232,13 +27829,13 @@ wuffs_deflate__decoder__decode_huffman_fast64__choosy_default(
|
||||
v_hlen = v_length;
|
||||
v_length = 0;
|
||||
}
|
||||
v_hdist += v_hdist_adjustment;
|
||||
if (self->private_impl.f_history_index < v_hdist) {
|
||||
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist = (self->private_impl.f_history_index - v_hdist);
|
||||
wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), (v_hdist & 32767)));
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
|
||||
if (v_length == 0) {
|
||||
goto label__loop__continue;
|
||||
}
|
||||
@@ -27359,7 +27956,6 @@ wuffs_deflate__decoder__decode_huffman_slow(
|
||||
v_length = self->private_data.s_decode_huffman_slow[0].v_length;
|
||||
v_dist_minus_1 = self->private_data.s_decode_huffman_slow[0].v_dist_minus_1;
|
||||
v_hlen = self->private_data.s_decode_huffman_slow[0].v_hlen;
|
||||
v_hdist = self->private_data.s_decode_huffman_slow[0].v_hdist;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
@@ -27556,54 +28152,29 @@ wuffs_deflate__decoder__decode_huffman_slow(
|
||||
v_bits >>= v_table_entry_n_bits;
|
||||
v_n_bits -= v_table_entry_n_bits;
|
||||
}
|
||||
label__inner__continue:;
|
||||
while (true) {
|
||||
if (((uint64_t)((v_dist_minus_1 + 1))) > ((uint64_t)(iop_a_dst - io0_a_dst))) {
|
||||
v_hdist = ((uint32_t)((((uint64_t)((v_dist_minus_1 + 1))) - ((uint64_t)(iop_a_dst - io0_a_dst)))));
|
||||
if (v_length > v_hdist) {
|
||||
v_length -= v_hdist;
|
||||
if (v_hdist < v_length) {
|
||||
v_hlen = v_hdist;
|
||||
} else {
|
||||
v_hlen = v_length;
|
||||
v_length = 0;
|
||||
}
|
||||
v_hdist += ((uint32_t)((((uint64_t)(self->private_impl.f_transformed_history_count - (a_dst ? a_dst->meta.pos : 0))) & 4294967295)));
|
||||
if (self->private_impl.f_history_index < v_hdist) {
|
||||
status = wuffs_base__make_status(wuffs_deflate__error__bad_distance);
|
||||
goto exit;
|
||||
}
|
||||
v_hdist = (self->private_impl.f_history_index - v_hdist);
|
||||
while (true) {
|
||||
v_n_copied = wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 32768), (v_hdist & 32767)));
|
||||
if (v_hlen <= v_n_copied) {
|
||||
v_hlen = 0;
|
||||
goto label__4__break;
|
||||
}
|
||||
if (v_n_copied > 0) {
|
||||
v_hlen -= v_n_copied;
|
||||
v_hdist = (((uint32_t)(v_hdist + v_n_copied)) & 32767);
|
||||
if (v_hdist == 0) {
|
||||
goto label__4__break;
|
||||
}
|
||||
}
|
||||
v_n_copied = wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
|
||||
if (v_n_copied < v_hlen) {
|
||||
v_length -= v_n_copied;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
|
||||
goto label__inner__continue;
|
||||
}
|
||||
label__4__break:;
|
||||
if (v_hlen > 0) {
|
||||
while (true) {
|
||||
v_n_copied = wuffs_base__io_writer__limited_copy_u32_from_slice(
|
||||
&iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 32768), (v_hdist & 32767)));
|
||||
if (v_hlen <= v_n_copied) {
|
||||
v_hlen = 0;
|
||||
goto label__5__break;
|
||||
}
|
||||
v_hlen -= v_n_copied;
|
||||
v_hdist += v_n_copied;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
|
||||
}
|
||||
label__5__break:;
|
||||
}
|
||||
v_length -= v_hlen;
|
||||
if (v_length == 0) {
|
||||
goto label__loop__continue;
|
||||
}
|
||||
@@ -27611,14 +28182,12 @@ wuffs_deflate__decoder__decode_huffman_slow(
|
||||
v_n_copied = wuffs_base__io_writer__limited_copy_u32_from_history(
|
||||
&iop_a_dst, io0_a_dst, io2_a_dst, v_length, (v_dist_minus_1 + 1));
|
||||
if (v_length <= v_n_copied) {
|
||||
v_length = 0;
|
||||
goto label__6__break;
|
||||
goto label__loop__continue;
|
||||
}
|
||||
v_length -= v_n_copied;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
|
||||
}
|
||||
label__6__break:;
|
||||
}
|
||||
label__loop__break:;
|
||||
self->private_impl.f_bits = v_bits;
|
||||
@@ -27647,7 +28216,6 @@ wuffs_deflate__decoder__decode_huffman_slow(
|
||||
self->private_data.s_decode_huffman_slow[0].v_length = v_length;
|
||||
self->private_data.s_decode_huffman_slow[0].v_dist_minus_1 = v_dist_minus_1;
|
||||
self->private_data.s_decode_huffman_slow[0].v_hlen = v_hlen;
|
||||
self->private_data.s_decode_huffman_slow[0].v_hdist = v_hdist;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
@@ -28631,7 +29199,7 @@ wuffs_gif__decoder__tell_me_more(
|
||||
while (true) {
|
||||
label__0__continue:;
|
||||
while (true) {
|
||||
if (wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_io_position) {
|
||||
if (wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_io_position) {
|
||||
if (a_minfo != NULL) {
|
||||
wuffs_base__more_information__set(a_minfo,
|
||||
2,
|
||||
@@ -28670,13 +29238,13 @@ wuffs_gif__decoder__tell_me_more(
|
||||
} else {
|
||||
iop_a_src += 1;
|
||||
}
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))), v_chunk_length);
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))), v_chunk_length);
|
||||
if (a_minfo != NULL) {
|
||||
wuffs_base__more_information__set(a_minfo,
|
||||
3,
|
||||
self->private_impl.f_metadata_fourcc,
|
||||
0,
|
||||
wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))),
|
||||
wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))),
|
||||
self->private_impl.f_metadata_io_position);
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__even_more_information);
|
||||
@@ -28732,10 +29300,13 @@ wuffs_gif__decoder__num_animation_loops(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (self->private_impl.f_seen_num_loops) {
|
||||
return self->private_impl.f_num_loops;
|
||||
if (self->private_impl.f_seen_num_animation_loops_value) {
|
||||
return self->private_impl.f_num_animation_loops_value;
|
||||
}
|
||||
return 1;
|
||||
if (self->private_impl.f_num_decoded_frame_configs_value > 1) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// -------- func gif.decoder.num_decoded_frame_configs
|
||||
@@ -29202,9 +29773,9 @@ wuffs_gif__decoder__decode_up_to_id_part1(
|
||||
|
||||
if ( ! self->private_impl.f_restarted) {
|
||||
if (self->private_impl.f_call_sequence != 2) {
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
}
|
||||
} else if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
} else if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
} else {
|
||||
@@ -29880,22 +30451,22 @@ wuffs_gif__decoder__decode_ae(
|
||||
*scratch |= ((uint64_t)(num_bits_4)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_num_loops = t_4;
|
||||
self->private_impl.f_num_animation_loops_value = t_4;
|
||||
}
|
||||
self->private_impl.f_seen_num_loops = true;
|
||||
if ((0 < self->private_impl.f_num_loops) && (self->private_impl.f_num_loops <= 65535)) {
|
||||
self->private_impl.f_num_loops += 1;
|
||||
self->private_impl.f_seen_num_animation_loops_value = true;
|
||||
if ((0 < self->private_impl.f_num_animation_loops_value) && (self->private_impl.f_num_animation_loops_value <= 65535)) {
|
||||
self->private_impl.f_num_animation_loops_value += 1;
|
||||
}
|
||||
} else if (self->private_impl.f_ignore_metadata) {
|
||||
} else if (v_is_iccp && self->private_impl.f_report_metadata_iccp) {
|
||||
self->private_impl.f_metadata_fourcc = 1229144912;
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_call_sequence = 1;
|
||||
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
|
||||
goto ok;
|
||||
} else if (v_is_xmp && self->private_impl.f_report_metadata_xmp) {
|
||||
self->private_impl.f_metadata_fourcc = 1481461792;
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_call_sequence = 1;
|
||||
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
|
||||
goto ok;
|
||||
@@ -30366,7 +30937,8 @@ wuffs_gif__decoder__decode_id_part1(
|
||||
goto ok;
|
||||
}
|
||||
if (self->private_impl.f_previous_lzw_decode_ended_abruptly) {
|
||||
wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(&self->private_data.f_lzw, sizeof (wuffs_lzw__decoder), WUFFS_VERSION, 0));
|
||||
wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(&self->private_data.f_lzw,
|
||||
sizeof (wuffs_lzw__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
@@ -30519,7 +31091,8 @@ wuffs_gif__decoder__decode_id_part2(
|
||||
wuffs_base__slice_u8__subslice_ij(wuffs_base__make_slice_u8(self->private_data.f_compressed,
|
||||
4096),
|
||||
self->private_impl.f_compressed_ri,
|
||||
self->private_impl.f_compressed_wi));
|
||||
self->private_impl.f_compressed_wi),
|
||||
0);
|
||||
v_mark = ((uint64_t)(iop_v_r - io0_v_r));
|
||||
{
|
||||
u_r.meta.ri = ((size_t)(iop_v_r - u_r.data.ptr));
|
||||
@@ -30571,6 +31144,30 @@ wuffs_gif__decoder__decode_id_part2(
|
||||
goto label__outer__continue;
|
||||
} else if (v_lzw_status.repr == wuffs_base__suspension__short_write) {
|
||||
goto label__inner__continue;
|
||||
} else if (self->private_impl.f_quirks[3] && (self->private_impl.f_dst_y >= self->private_impl.f_frame_rect_y1) && (self->private_impl.f_interlace == 0)) {
|
||||
if (v_need_block_size || (v_block_size > 0)) {
|
||||
self->private_data.s_decode_id_part2[0].scratch = ((uint32_t)(v_block_size));
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
if (self->private_data.s_decode_id_part2[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_id_part2[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_decode_id_part2[0].scratch;
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
status = wuffs_gif__decoder__skip_blocks(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
}
|
||||
goto label__outer__break;
|
||||
}
|
||||
status = v_lzw_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
@@ -30651,7 +31248,7 @@ wuffs_gif__decoder__copy_to_image_buffer(
|
||||
}
|
||||
return wuffs_base__make_status(wuffs_base__error__too_much_data);
|
||||
}
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (self->private_impl.f_dst_y >= self->private_impl.f_height) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, 0);
|
||||
} else if (v_width_in_bytes < ((uint64_t)(v_dst.len))) {
|
||||
@@ -30677,12 +31274,12 @@ wuffs_gif__decoder__copy_to_image_buffer(
|
||||
goto label__0__continue;
|
||||
}
|
||||
if ((self->private_impl.f_num_decoded_frames_value == 0) && ! self->private_impl.f_gc_has_transparent_index && (self->private_impl.f_interlace > 1)) {
|
||||
v_replicate_src = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_replicate_src = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
v_replicate_y0 = wuffs_base__u32__sat_add(self->private_impl.f_dst_y, 1);
|
||||
v_replicate_y1 = wuffs_base__u32__sat_add(self->private_impl.f_dst_y, ((uint32_t)(WUFFS_GIF__INTERLACE_COUNT[self->private_impl.f_interlace])));
|
||||
v_replicate_y1 = wuffs_base__u32__min(v_replicate_y1, self->private_impl.f_frame_rect_y1);
|
||||
while (v_replicate_y0 < v_replicate_y1) {
|
||||
v_replicate_dst = wuffs_base__table_u8__row(v_tab, v_replicate_y0);
|
||||
v_replicate_dst = wuffs_base__table_u8__row_u32(v_tab, v_replicate_y0);
|
||||
wuffs_base__slice_u8__copy_from_slice(v_replicate_dst, v_replicate_src);
|
||||
v_replicate_y0 += 1;
|
||||
}
|
||||
@@ -33097,16 +33694,19 @@ wuffs_json__decoder__decode_comment(
|
||||
}
|
||||
while (true) {
|
||||
if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
|
||||
if (v_length > 0) {
|
||||
if (a_src && a_src->meta.closed) {
|
||||
*iop_a_dst++ = wuffs_base__make_token(
|
||||
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
|
||||
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
|
||||
self->private_impl.f_comment_type = 2;
|
||||
status = wuffs_base__make_status(NULL);
|
||||
goto ok;
|
||||
} else if (v_length > 0) {
|
||||
*iop_a_dst++ = wuffs_base__make_token(
|
||||
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
|
||||
(((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) |
|
||||
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
|
||||
}
|
||||
if (a_src && a_src->meta.closed) {
|
||||
status = wuffs_base__make_status(wuffs_json__error__bad_input);
|
||||
goto exit;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
|
||||
v_length = 0;
|
||||
@@ -33114,10 +33714,9 @@ wuffs_json__decoder__decode_comment(
|
||||
}
|
||||
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
|
||||
if (v_c == 10) {
|
||||
iop_a_src += 1;
|
||||
*iop_a_dst++ = wuffs_base__make_token(
|
||||
(((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
|
||||
(((uint64_t)((v_length + 1))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
|
||||
(((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
|
||||
self->private_impl.f_comment_type = 2;
|
||||
status = wuffs_base__make_status(NULL);
|
||||
goto ok;
|
||||
@@ -33885,7 +34484,7 @@ wuffs_nie__decoder__decode_frame_config(
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 3) {
|
||||
if (16 != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
if (16 != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
}
|
||||
@@ -34088,7 +34687,7 @@ wuffs_nie__decoder__swizzle(
|
||||
goto label__0__break;
|
||||
}
|
||||
}
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, self->private_impl.f_dst_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
}
|
||||
@@ -34306,6 +34905,10 @@ const char wuffs_zlib__error__incorrect_dictionary[] = "#zlib: incorrect diction
|
||||
|
||||
// ---------------- Private Consts
|
||||
|
||||
#define WUFFS_ZLIB__QUIRKS_BASE 2113790976
|
||||
|
||||
#define WUFFS_ZLIB__QUIRKS_COUNT 1
|
||||
|
||||
// ---------------- Private Initializer Prototypes
|
||||
|
||||
// ---------------- Private Function Prototypes
|
||||
@@ -34469,8 +35072,15 @@ wuffs_zlib__decoder__set_quirk_enabled(
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
if (a_quirk == 1) {
|
||||
if (self->private_impl.f_header_complete) {
|
||||
self->private_impl.f_bad_call_sequence = true;
|
||||
} else if (a_quirk == 1) {
|
||||
self->private_impl.f_ignore_checksum = a_enabled;
|
||||
} else if (a_quirk >= 2113790976) {
|
||||
a_quirk -= 2113790976;
|
||||
if (a_quirk < 1) {
|
||||
self->private_impl.f_quirks[a_quirk] = a_enabled;
|
||||
}
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
@@ -34560,6 +35170,7 @@ wuffs_zlib__decoder__transform_io(
|
||||
if (self->private_impl.f_bad_call_sequence) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_quirks[0]) {
|
||||
} else if ( ! self->private_impl.f_want_dictionary) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
@@ -34667,7 +35278,7 @@ wuffs_zlib__decoder__transform_io(
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
if ( ! self->private_impl.f_ignore_checksum && ! self->private_impl.f_quirks[0]) {
|
||||
v_checksum_got = wuffs_adler32__hasher__update_u32(&self->private_data.f_checksum, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_dst - io0_a_dst)), io0_a_dst));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
@@ -34677,38 +35288,40 @@ wuffs_zlib__decoder__transform_io(
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
}
|
||||
label__0__break:;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_transform_io[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
if ( ! self->private_impl.f_quirks[0]) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_transform_io[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_transform_io[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_transform_io[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
v_checksum_want = t_3;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_got != v_checksum_want)) {
|
||||
status = wuffs_base__make_status(wuffs_zlib__error__bad_checksum);
|
||||
goto exit;
|
||||
}
|
||||
v_checksum_want = t_3;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_got != v_checksum_want)) {
|
||||
status = wuffs_base__make_status(wuffs_zlib__error__bad_checksum);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
ok:
|
||||
@@ -34743,17 +35356,25 @@ wuffs_zlib__decoder__transform_io(
|
||||
|
||||
// ---------------- Status Codes Implementations
|
||||
|
||||
const char wuffs_png__error__bad_animation_sequence_number[] = "#png: bad animation sequence number";
|
||||
const char wuffs_png__error__bad_checksum[] = "#png: bad checksum";
|
||||
const char wuffs_png__error__bad_chunk[] = "#png: bad chunk";
|
||||
const char wuffs_png__error__bad_filter[] = "#png: bad filter";
|
||||
const char wuffs_png__error__bad_header[] = "#png: bad header";
|
||||
const char wuffs_png__error__bad_text_chunk_not_latin_1[] = "#png: bad text chunk (not Latin-1)";
|
||||
const char wuffs_png__error__missing_palette[] = "#png: missing palette";
|
||||
const char wuffs_png__error__unsupported_png_compression_method[] = "#png: unsupported PNG compression method";
|
||||
const char wuffs_png__error__unsupported_png_file[] = "#png: unsupported PNG file";
|
||||
const char wuffs_png__error__internal_error_inconsistent_i_o[] = "#png: internal error: inconsistent I/O";
|
||||
const char wuffs_png__error__internal_error_inconsistent_chunk_type[] = "#png: internal error: inconsistent chunk type";
|
||||
const char wuffs_png__error__internal_error_inconsistent_frame_bounds[] = "#png: internal error: inconsistent frame bounds";
|
||||
const char wuffs_png__error__internal_error_inconsistent_workbuf_length[] = "#png: internal error: inconsistent workbuf length";
|
||||
const char wuffs_png__error__internal_error_zlib_decoder_did_not_exhaust_its_input[] = "#png: internal error: zlib decoder did not exhaust its input";
|
||||
|
||||
// ---------------- Private Consts
|
||||
|
||||
#define WUFFS_PNG__ANCILLARY_BIT 32
|
||||
|
||||
static const uint8_t
|
||||
WUFFS_PNG__INTERLACING[8][6] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
{
|
||||
@@ -34790,6 +35411,42 @@ WUFFS_PNG__NUM_CHANNELS[8] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
1, 0, 3, 1, 2, 0, 4, 0,
|
||||
};
|
||||
|
||||
static const uint16_t
|
||||
WUFFS_PNG__LATIN_1[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
32, 33, 34, 35, 36, 37, 38, 39,
|
||||
40, 41, 42, 43, 44, 45, 46, 47,
|
||||
48, 49, 50, 51, 52, 53, 54, 55,
|
||||
56, 57, 58, 59, 60, 61, 62, 63,
|
||||
64, 65, 66, 67, 68, 69, 70, 71,
|
||||
72, 73, 74, 75, 76, 77, 78, 79,
|
||||
80, 81, 82, 83, 84, 85, 86, 87,
|
||||
88, 89, 90, 91, 92, 93, 94, 95,
|
||||
96, 97, 98, 99, 100, 101, 102, 103,
|
||||
104, 105, 106, 107, 108, 109, 110, 111,
|
||||
112, 113, 114, 115, 116, 117, 118, 119,
|
||||
120, 121, 122, 123, 124, 125, 126, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 41410, 41666, 41922, 42178, 42434, 42690, 42946,
|
||||
43202, 43458, 43714, 43970, 44226, 44482, 44738, 44994,
|
||||
45250, 45506, 45762, 46018, 46274, 46530, 46786, 47042,
|
||||
47298, 47554, 47810, 48066, 48322, 48578, 48834, 49090,
|
||||
32963, 33219, 33475, 33731, 33987, 34243, 34499, 34755,
|
||||
35011, 35267, 35523, 35779, 36035, 36291, 36547, 36803,
|
||||
37059, 37315, 37571, 37827, 38083, 38339, 38595, 38851,
|
||||
39107, 39363, 39619, 39875, 40131, 40387, 40643, 40899,
|
||||
41155, 41411, 41667, 41923, 42179, 42435, 42691, 42947,
|
||||
43203, 43459, 43715, 43971, 44227, 44483, 44739, 44995,
|
||||
45251, 45507, 45763, 46019, 46275, 46531, 46787, 47043,
|
||||
47299, 47555, 47811, 48067, 48323, 48579, 48835, 49091,
|
||||
};
|
||||
|
||||
// ---------------- Private Initializer Prototypes
|
||||
|
||||
// ---------------- Private Function Prototypes
|
||||
@@ -34899,36 +35556,36 @@ wuffs_png__decoder__filter_4_distance_4_fallback(
|
||||
wuffs_base__slice_u8 a_curr,
|
||||
wuffs_base__slice_u8 a_prev);
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_1_distance_4_x86_sse42(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__slice_u8 a_curr);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_3_distance_4_x86_sse42(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__slice_u8 a_curr,
|
||||
wuffs_base__slice_u8 a_prev);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_4_distance_3_x86_sse42(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__slice_u8 a_curr,
|
||||
wuffs_base__slice_u8 a_prev);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_4_distance_4_x86_sse42(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__slice_u8 a_curr,
|
||||
wuffs_base__slice_u8 a_prev);
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_ihdr(
|
||||
@@ -34953,16 +35610,56 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_actl(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_chrm(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_exif(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_fctl(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_gama(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_iccp(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_plte(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_srgb(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_trns(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__skip_frame(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_pass(
|
||||
wuffs_png__decoder* self,
|
||||
@@ -36136,7 +36833,7 @@ wuffs_png__decoder__filter_4_distance_4_fallback(
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func png.decoder.filter_1_distance_4_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_1_distance_4_x86_sse42(
|
||||
@@ -36176,13 +36873,13 @@ wuffs_png__decoder__filter_1_distance_4_x86_sse42(
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func png.decoder.filter_3_distance_4_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_3_distance_4_x86_sse42(
|
||||
@@ -36281,13 +36978,13 @@ wuffs_png__decoder__filter_3_distance_4_x86_sse42(
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func png.decoder.filter_4_distance_3_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_4_distance_3_x86_sse42(
|
||||
@@ -36407,13 +37104,13 @@ wuffs_png__decoder__filter_4_distance_3_x86_sse42(
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
|
||||
// -------- func png.decoder.filter_4_distance_4_x86_sse42
|
||||
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__filter_4_distance_4_x86_sse42(
|
||||
@@ -36511,7 +37208,7 @@ wuffs_png__decoder__filter_4_distance_4_x86_sse42(
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
|
||||
|
||||
// -------- func png.decoder.set_quirk_enabled
|
||||
@@ -36587,172 +37284,210 @@ wuffs_png__decoder__decode_image_config(
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence != 0) {
|
||||
if (self->private_impl.f_call_sequence == 2) {
|
||||
if (self->private_impl.f_metadata_fourcc != 0) {
|
||||
self->private_impl.f_call_sequence = 1;
|
||||
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
|
||||
goto ok;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence != 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
|
||||
t_0 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 8;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 56) {
|
||||
t_0 = ((uint64_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
v_magic = t_0;
|
||||
}
|
||||
if (v_magic != 727905341920923785) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint64_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
|
||||
t_1 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 8;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 56) {
|
||||
t_1 = ((uint64_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_magic = t_1;
|
||||
}
|
||||
if (v_magic != 5927942488114331648) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
|
||||
self->private_impl.f_chunk_type_array[0] = 73;
|
||||
self->private_impl.f_chunk_type_array[1] = 72;
|
||||
self->private_impl.f_chunk_type_array[2] = 68;
|
||||
self->private_impl.f_chunk_type_array[3] = 82;
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
while (true) {
|
||||
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
} else {
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_2 = wuffs_png__decoder__decode_ihdr(self, a_src);
|
||||
v_status = t_2;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
goto label__0__break;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
}
|
||||
label__0__break:;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
}
|
||||
v_checksum_want = t_3;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_have != v_checksum_want)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
|
||||
goto exit;
|
||||
}
|
||||
while (true) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
uint64_t t_4;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_4 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
|
||||
t_0 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 8;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
|
||||
if (num_bits_4 == 24) {
|
||||
t_4 = ((uint64_t)(*scratch >> 32));
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 56) {
|
||||
t_0 = ((uint64_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_4 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_4));
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_chunk_length = t_4;
|
||||
v_magic = t_0;
|
||||
}
|
||||
if (v_magic != 727905341920923785) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint64_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) {
|
||||
t_1 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 8;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 56) {
|
||||
t_1 = ((uint64_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_magic = t_1;
|
||||
}
|
||||
if (v_magic != 5927942488114331648) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_type_array[0] = 73;
|
||||
self->private_impl.f_chunk_type_array[1] = 72;
|
||||
self->private_impl.f_chunk_type_array[2] = 68;
|
||||
self->private_impl.f_chunk_type_array[3] = 82;
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
|
||||
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
while (true) {
|
||||
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_2 = wuffs_png__decoder__decode_ihdr(self, a_src);
|
||||
v_status = t_2;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
goto label__0__break;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
}
|
||||
label__0__break:;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
}
|
||||
v_checksum_want = t_3;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (v_checksum_have != v_checksum_want)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
while (true) {
|
||||
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
|
||||
if (a_src && a_src->meta.closed) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(8);
|
||||
}
|
||||
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
|
||||
if (self->private_impl.f_chunk_type == 1413563465) {
|
||||
if ( ! self->private_impl.f_seen_actl || self->private_impl.f_seen_fctl) {
|
||||
goto label__1__break;
|
||||
}
|
||||
self->private_impl.f_seen_idat = true;
|
||||
} else if (self->private_impl.f_chunk_type == 1413571686) {
|
||||
if (self->private_impl.f_seen_idat && self->private_impl.f_seen_fctl) {
|
||||
goto label__1__break;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
iop_a_src += 8;
|
||||
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0)) {
|
||||
self->private_impl.f_chunk_type_array[0] = ((uint8_t)(((self->private_impl.f_chunk_type >> 0) & 255)));
|
||||
self->private_impl.f_chunk_type_array[1] = ((uint8_t)(((self->private_impl.f_chunk_type >> 8) & 255)));
|
||||
self->private_impl.f_chunk_type_array[2] = ((uint8_t)(((self->private_impl.f_chunk_type >> 16) & 255)));
|
||||
self->private_impl.f_chunk_type_array[3] = ((uint8_t)(((self->private_impl.f_chunk_type >> 24) & 255)));
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
|
||||
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
}
|
||||
while (true) {
|
||||
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_4 = wuffs_png__decoder__decode_other_chunk(self, a_src);
|
||||
v_status = t_4;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0)) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
goto label__2__break;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
|
||||
}
|
||||
label__2__break:;
|
||||
if (self->private_impl.f_metadata_fourcc != 0) {
|
||||
self->private_impl.f_call_sequence = 1;
|
||||
status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
|
||||
goto ok;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
uint32_t t_5;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_5 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
t_5 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
@@ -36763,83 +37498,21 @@ wuffs_png__decoder__decode_image_config(
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_5 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_5;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
|
||||
if (num_bits_5 == 24) {
|
||||
t_5 = ((uint32_t)(*scratch));
|
||||
t_5 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_5 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_5)) << 56;
|
||||
*scratch |= ((uint64_t)(num_bits_5));
|
||||
}
|
||||
}
|
||||
self->private_impl.f_chunk_type = t_5;
|
||||
v_checksum_want = t_5;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type == 1413563465) || (self->private_impl.f_chunk_type == 1163152464))) {
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
|
||||
self->private_impl.f_chunk_type_array[0] = ((uint8_t)(((self->private_impl.f_chunk_type >> 0) & 255)));
|
||||
self->private_impl.f_chunk_type_array[1] = ((uint8_t)(((self->private_impl.f_chunk_type >> 8) & 255)));
|
||||
self->private_impl.f_chunk_type_array[2] = ((uint8_t)(((self->private_impl.f_chunk_type >> 16) & 255)));
|
||||
self->private_impl.f_chunk_type_array[3] = ((uint8_t)(((self->private_impl.f_chunk_type >> 24) & 255)));
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
}
|
||||
if (self->private_impl.f_chunk_type == 1413563465) {
|
||||
goto label__1__break;
|
||||
}
|
||||
while (true) {
|
||||
v_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_6 = wuffs_png__decoder__decode_other_chunk(self, a_src);
|
||||
v_status = t_6;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type == 1163152464)) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
goto label__2__break;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(12);
|
||||
}
|
||||
label__2__break:;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
|
||||
uint32_t t_7;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_7 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_image_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_image_config[0].scratch;
|
||||
uint32_t num_bits_7 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_7);
|
||||
if (num_bits_7 == 24) {
|
||||
t_7 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_7 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_7));
|
||||
}
|
||||
}
|
||||
v_checksum_want = t_7;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type == 1163152464) && (v_checksum_have != v_checksum_want)) {
|
||||
if ( ! self->private_impl.f_ignore_checksum && ((self->private_impl.f_chunk_type & 32) == 0) && (v_checksum_have != v_checksum_want)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
|
||||
goto exit;
|
||||
}
|
||||
@@ -36849,7 +37522,8 @@ wuffs_png__decoder__decode_image_config(
|
||||
status = wuffs_base__make_status(wuffs_png__error__missing_palette);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_first_config_io_position = self->private_impl.f_frame_config_io_position;
|
||||
if (a_dst != NULL) {
|
||||
wuffs_base__image_config__set(
|
||||
a_dst,
|
||||
@@ -36857,9 +37531,19 @@ wuffs_png__decoder__decode_image_config(
|
||||
0,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height,
|
||||
self->private_impl.f_frame_config_io_position,
|
||||
self->private_impl.f_first_config_io_position,
|
||||
((self->private_impl.f_color_type <= 3) && ! self->private_impl.f_seen_trns));
|
||||
}
|
||||
if ( ! self->private_impl.f_seen_actl) {
|
||||
self->private_impl.f_num_animation_frames_value = 1;
|
||||
self->private_impl.f_first_rect_x0 = 0;
|
||||
self->private_impl.f_first_rect_y0 = 0;
|
||||
self->private_impl.f_first_rect_x1 = self->private_impl.f_width;
|
||||
self->private_impl.f_first_rect_y1 = self->private_impl.f_height;
|
||||
self->private_impl.f_first_duration = 0;
|
||||
self->private_impl.f_first_disposal = 0;
|
||||
self->private_impl.f_first_overwrite_instead_of_blend = false;
|
||||
}
|
||||
self->private_impl.f_call_sequence = 3;
|
||||
|
||||
ok:
|
||||
@@ -37023,7 +37707,7 @@ wuffs_png__decoder__decode_ihdr(
|
||||
v_a8 = t_4;
|
||||
}
|
||||
if (v_a8 != 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
@@ -37061,7 +37745,7 @@ wuffs_png__decoder__decode_ihdr(
|
||||
self->private_impl.f_filter_distance = 0;
|
||||
wuffs_png__decoder__assign_filter_distance(self);
|
||||
if (self->private_impl.f_filter_distance == 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_overall_workbuf_length = (((uint64_t)(self->private_impl.f_height)) * (1 + wuffs_png__decoder__calculate_bytes_per_row(self, self->private_impl.f_width)));
|
||||
@@ -37092,7 +37776,9 @@ static wuffs_base__empty_struct
|
||||
wuffs_png__decoder__assign_filter_distance(
|
||||
wuffs_png__decoder* self) {
|
||||
if (self->private_impl.f_depth < 8) {
|
||||
if (self->private_impl.f_color_type == 0) {
|
||||
if ((self->private_impl.f_depth != 1) && (self->private_impl.f_depth != 2) && (self->private_impl.f_depth != 4)) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
} else if (self->private_impl.f_color_type == 0) {
|
||||
self->private_impl.f_dst_pixfmt = 536870920;
|
||||
self->private_impl.f_src_pixfmt = 536870920;
|
||||
} else if (self->private_impl.f_color_type == 3) {
|
||||
@@ -37110,8 +37796,13 @@ wuffs_png__decoder__assign_filter_distance(
|
||||
self->private_impl.f_src_pixfmt = 536870920;
|
||||
self->private_impl.f_filter_distance = 1;
|
||||
} else if (self->private_impl.f_depth == 16) {
|
||||
self->private_impl.f_dst_pixfmt = 536870923;
|
||||
self->private_impl.f_src_pixfmt = 537919499;
|
||||
if (self->private_impl.f_interlace_pass == 0) {
|
||||
self->private_impl.f_dst_pixfmt = 536870923;
|
||||
self->private_impl.f_src_pixfmt = 537919499;
|
||||
} else {
|
||||
self->private_impl.f_dst_pixfmt = 2164308923;
|
||||
self->private_impl.f_src_pixfmt = 2164308923;
|
||||
}
|
||||
self->private_impl.f_filter_distance = 2;
|
||||
}
|
||||
} else if (self->private_impl.f_color_type == 2) {
|
||||
@@ -37195,7 +37886,7 @@ wuffs_png__decoder__choose_filter_implementations(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_4_distance_3_arm_neon :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_4_distance_3_x86_sse42 :
|
||||
#endif
|
||||
&wuffs_png__decoder__filter_4_distance_3_fallback);
|
||||
@@ -37204,7 +37895,7 @@ wuffs_png__decoder__choose_filter_implementations(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_1_distance_4_arm_neon :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_1_distance_4_x86_sse42 :
|
||||
#endif
|
||||
&wuffs_png__decoder__filter_1_distance_4_fallback);
|
||||
@@ -37212,7 +37903,7 @@ wuffs_png__decoder__choose_filter_implementations(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_3_distance_4_arm_neon :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_3_distance_4_x86_sse42 :
|
||||
#endif
|
||||
&wuffs_png__decoder__filter_3_distance_4_fallback);
|
||||
@@ -37220,7 +37911,7 @@ wuffs_png__decoder__choose_filter_implementations(
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
|
||||
wuffs_base__cpu_arch__have_arm_neon() ? &wuffs_png__decoder__filter_4_distance_4_arm_neon :
|
||||
#endif
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
||||
#if defined(WUFFS_BASE__CPU_ARCH__X86_FAMILY)
|
||||
wuffs_base__cpu_arch__have_x86_sse42() ? &wuffs_png__decoder__filter_4_distance_4_x86_sse42 :
|
||||
#endif
|
||||
&wuffs_png__decoder__filter_4_distance_4_fallback);
|
||||
@@ -37252,22 +37943,161 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_type == 1163152464) {
|
||||
if (self->private_impl.f_seen_plte || (self->private_impl.f_color_type != 3)) {
|
||||
if (self->private_impl.f_seen_plte) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_color_type == 3) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_png__decoder__decode_plte(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else if ((self->private_impl.f_color_type == 2) || (self->private_impl.f_color_type == 6)) {
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_seen_plte = true;
|
||||
} else if ((self->private_impl.f_chunk_type & 32) == 0) {
|
||||
if (self->private_impl.f_chunk_type != 1413563465) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1280598881) {
|
||||
if (self->private_impl.f_seen_actl) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_png__decoder__decode_plte(self, a_src);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_png__decoder__decode_actl(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_plte = true;
|
||||
self->private_impl.f_seen_actl = true;
|
||||
} else if (self->private_impl.f_chunk_type == 1297238115) {
|
||||
if (self->private_impl.f_report_metadata_chrm) {
|
||||
if (self->private_impl.f_seen_chrm) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
status = wuffs_png__decoder__decode_chrm(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_chrm = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1716082789) {
|
||||
if (self->private_impl.f_report_metadata_exif) {
|
||||
if (self->private_impl.f_seen_exif) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
status = wuffs_png__decoder__decode_exif(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_exif = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1280598886) {
|
||||
if (self->private_impl.f_seen_fctl) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
status = wuffs_png__decoder__decode_fctl(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_fctl = true;
|
||||
} else if (self->private_impl.f_chunk_type == 1095582055) {
|
||||
if (self->private_impl.f_report_metadata_gama) {
|
||||
if (self->private_impl.f_seen_gama) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
status = wuffs_png__decoder__decode_gama(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_gama = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1346585449) {
|
||||
if (self->private_impl.f_report_metadata_iccp) {
|
||||
if (self->private_impl.f_seen_iccp) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
status = wuffs_png__decoder__decode_iccp(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_iccp = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1111970419) {
|
||||
if (self->private_impl.f_report_metadata_srgb) {
|
||||
if (self->private_impl.f_seen_srgb) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
status = wuffs_png__decoder__decode_srgb(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_srgb = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1397641844) {
|
||||
if (self->private_impl.f_seen_trns || (self->private_impl.f_color_type > 3) || ((self->private_impl.f_color_type == 3) && ! self->private_impl.f_seen_plte)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
@@ -37276,7 +38106,7 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
status = wuffs_png__decoder__decode_trns(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -37285,9 +38115,18 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_trns = true;
|
||||
} else {
|
||||
} else if ((self->private_impl.f_chunk_type == 1951945833) || (self->private_impl.f_chunk_type == 1951942004) || (self->private_impl.f_chunk_type == 1951945850)) {
|
||||
if (self->private_impl.f_report_metadata_kvp) {
|
||||
self->private_impl.f_metadata_flavor = 4;
|
||||
self->private_impl.f_metadata_fourcc = 1263947851;
|
||||
self->private_impl.f_metadata_x = 0;
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
}
|
||||
}
|
||||
if (self->private_impl.f_metadata_fourcc == 0) {
|
||||
self->private_data.s_decode_other_chunk[0].scratch = self->private_impl.f_chunk_length;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
if (self->private_data.s_decode_other_chunk[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_other_chunk[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
@@ -37316,6 +38155,964 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_actl
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_actl(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_actl[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 8) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_interlace_pass > 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_actl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_actl[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
self->private_impl.f_num_animation_frames_value = t_0;
|
||||
}
|
||||
if (self->private_impl.f_num_animation_frames_value == 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_actl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_actl[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
}
|
||||
}
|
||||
self->private_impl.f_num_animation_loops_value = t_1;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_actl[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_actl[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_chrm
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_chrm(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint64_t v_u = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_chrm[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 32) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
self->private_impl.f_metadata_flavor = 5;
|
||||
self->private_impl.f_metadata_fourcc = 1128813133;
|
||||
self->private_impl.f_metadata_x = 0;
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_u = t_0;
|
||||
}
|
||||
self->private_impl.f_metadata_x |= ((16777215 & v_u) << 0);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint64_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
}
|
||||
}
|
||||
v_u = t_1;
|
||||
}
|
||||
self->private_impl.f_metadata_x |= ((16777215 & v_u) << 24);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint64_t t_2;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_2 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_2 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_2);
|
||||
if (num_bits_2 == 24) {
|
||||
t_2 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_2 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_2));
|
||||
}
|
||||
}
|
||||
v_u = t_2;
|
||||
}
|
||||
self->private_impl.f_metadata_x |= ((uint64_t)((16777215 & v_u) << 48));
|
||||
self->private_impl.f_metadata_y |= ((16777215 & v_u) >> 16);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
uint64_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
}
|
||||
v_u = t_3;
|
||||
}
|
||||
self->private_impl.f_metadata_y |= ((16777215 & v_u) << 8);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
uint64_t t_4;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_4 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
|
||||
if (num_bits_4 == 24) {
|
||||
t_4 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_4 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_4));
|
||||
}
|
||||
}
|
||||
v_u = t_4;
|
||||
}
|
||||
self->private_impl.f_metadata_y |= ((16777215 & v_u) << 32);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
|
||||
uint64_t t_5;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_5 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
|
||||
if (num_bits_5 == 24) {
|
||||
t_5 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_5 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_5));
|
||||
}
|
||||
}
|
||||
v_u = t_5;
|
||||
}
|
||||
self->private_impl.f_metadata_y |= ((uint64_t)((16777215 & v_u) << 56));
|
||||
self->private_impl.f_metadata_z |= ((16777215 & v_u) >> 8);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
|
||||
uint64_t t_6;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_6 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_6 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_6);
|
||||
if (num_bits_6 == 24) {
|
||||
t_6 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_6 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_6));
|
||||
}
|
||||
}
|
||||
v_u = t_6;
|
||||
}
|
||||
self->private_impl.f_metadata_z |= ((16777215 & v_u) << 16);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
|
||||
uint64_t t_7;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_7 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_chrm[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_chrm[0].scratch;
|
||||
uint32_t num_bits_7 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_7);
|
||||
if (num_bits_7 == 24) {
|
||||
t_7 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_7 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_7));
|
||||
}
|
||||
}
|
||||
v_u = t_7;
|
||||
}
|
||||
self->private_impl.f_metadata_z |= ((16777215 & v_u) << 40);
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_chrm[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_chrm[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_exif
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_exif(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
if (self->private_impl.f_chunk_length < 4) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_metadata_flavor = 3;
|
||||
self->private_impl.f_metadata_fourcc = 1163413830;
|
||||
self->private_impl.f_metadata_x = 0;
|
||||
self->private_impl.f_metadata_y = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_metadata_z = wuffs_base__u64__sat_add(self->private_impl.f_metadata_y, ((uint64_t)(self->private_impl.f_chunk_length)));
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_fctl
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_fctl(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_x0 = 0;
|
||||
uint32_t v_y0 = 0;
|
||||
uint32_t v_x1 = 0;
|
||||
uint32_t v_y1 = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_fctl[0];
|
||||
if (coro_susp_point) {
|
||||
v_x0 = self->private_data.s_decode_fctl[0].v_x0;
|
||||
v_x1 = self->private_data.s_decode_fctl[0].v_x1;
|
||||
v_y1 = self->private_data.s_decode_fctl[0].v_y1;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 26) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_x0 = t_0;
|
||||
}
|
||||
if (v_x0 != self->private_impl.f_next_animation_seq_num) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_next_animation_seq_num += 1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
}
|
||||
}
|
||||
v_x1 = t_1;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint32_t t_2;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_2 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_2 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_2);
|
||||
if (num_bits_2 == 24) {
|
||||
t_2 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_2 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_2));
|
||||
}
|
||||
}
|
||||
v_y1 = t_2;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_3 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_3));
|
||||
}
|
||||
}
|
||||
v_x0 = t_3;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
uint32_t t_4;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_4 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
|
||||
if (num_bits_4 == 24) {
|
||||
t_4 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_4 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_4));
|
||||
}
|
||||
}
|
||||
v_y0 = t_4;
|
||||
}
|
||||
v_x1 += v_x0;
|
||||
v_y1 += v_y0;
|
||||
if ((v_x0 >= v_x1) ||
|
||||
(v_x0 > self->private_impl.f_width) ||
|
||||
(v_x1 > self->private_impl.f_width) ||
|
||||
(v_y0 >= v_y1) ||
|
||||
(v_y0 > self->private_impl.f_height) ||
|
||||
(v_y1 > self->private_impl.f_height)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_frame_rect_x0 = v_x0;
|
||||
self->private_impl.f_frame_rect_y0 = v_y0;
|
||||
self->private_impl.f_frame_rect_x1 = v_x1;
|
||||
self->private_impl.f_frame_rect_y1 = v_y1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
|
||||
uint32_t t_5;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
|
||||
t_5 = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 2;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
|
||||
if (num_bits_5 == 8) {
|
||||
t_5 = ((uint32_t)(*scratch >> 48));
|
||||
break;
|
||||
}
|
||||
num_bits_5 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_5));
|
||||
}
|
||||
}
|
||||
v_x0 = t_5;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
|
||||
uint32_t t_6;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
|
||||
t_6 = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 2;
|
||||
} else {
|
||||
self->private_data.s_decode_fctl[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_fctl[0].scratch;
|
||||
uint32_t num_bits_6 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_6);
|
||||
if (num_bits_6 == 8) {
|
||||
t_6 = ((uint32_t)(*scratch >> 48));
|
||||
break;
|
||||
}
|
||||
num_bits_6 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_6));
|
||||
}
|
||||
}
|
||||
v_x1 = t_6;
|
||||
}
|
||||
if (v_x1 <= 0) {
|
||||
self->private_impl.f_frame_duration = (((uint64_t)(v_x0)) * 7056000);
|
||||
} else {
|
||||
self->private_impl.f_frame_duration = ((((uint64_t)(v_x0)) * 705600000) / ((uint64_t)(v_x1)));
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint32_t t_7 = *iop_a_src++;
|
||||
v_x0 = t_7;
|
||||
}
|
||||
if (v_x0 == 0) {
|
||||
self->private_impl.f_frame_disposal = 0;
|
||||
} else if (v_x0 == 1) {
|
||||
self->private_impl.f_frame_disposal = 1;
|
||||
} else if (v_x0 == 2) {
|
||||
self->private_impl.f_frame_disposal = 2;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint32_t t_8 = *iop_a_src++;
|
||||
v_x0 = t_8;
|
||||
}
|
||||
if (v_x0 == 0) {
|
||||
self->private_impl.f_frame_overwrite_instead_of_blend = true;
|
||||
} else if (v_x0 == 1) {
|
||||
self->private_impl.f_frame_overwrite_instead_of_blend = false;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (self->private_impl.f_num_decoded_frame_configs_value == 0) {
|
||||
self->private_impl.f_first_rect_x0 = self->private_impl.f_frame_rect_x0;
|
||||
self->private_impl.f_first_rect_y0 = self->private_impl.f_frame_rect_y0;
|
||||
self->private_impl.f_first_rect_x1 = self->private_impl.f_frame_rect_x1;
|
||||
self->private_impl.f_first_rect_y1 = self->private_impl.f_frame_rect_y1;
|
||||
self->private_impl.f_first_duration = self->private_impl.f_frame_duration;
|
||||
self->private_impl.f_first_disposal = self->private_impl.f_frame_disposal;
|
||||
self->private_impl.f_first_overwrite_instead_of_blend = self->private_impl.f_frame_overwrite_instead_of_blend;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_fctl[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_fctl[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_fctl[0].v_x0 = v_x0;
|
||||
self->private_data.s_decode_fctl[0].v_x1 = v_x1;
|
||||
self->private_data.s_decode_fctl[0].v_y1 = v_y1;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_gama
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_gama(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_gama[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 4) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
self->private_impl.f_metadata_flavor = 5;
|
||||
self->private_impl.f_metadata_fourcc = 1195461953;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_gama[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_gama[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint64_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
self->private_impl.f_metadata_x = t_0;
|
||||
}
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_gama[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_gama[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_iccp
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_iccp(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint8_t v_c = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_iccp[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
while (true) {
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_0 = *iop_a_src++;
|
||||
v_c = t_0;
|
||||
}
|
||||
if (v_c == 0) {
|
||||
goto label__0__break;
|
||||
}
|
||||
}
|
||||
label__0__break:;
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_1 = *iop_a_src++;
|
||||
v_c = t_1;
|
||||
}
|
||||
if (v_c != 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_metadata_is_zlib_compressed = true;
|
||||
self->private_impl.f_metadata_flavor = 4;
|
||||
self->private_impl.f_metadata_fourcc = 1229144912;
|
||||
self->private_impl.f_metadata_x = 0;
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_iccp[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_iccp[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_plte
|
||||
|
||||
static wuffs_base__status
|
||||
@@ -37352,6 +39149,7 @@ wuffs_png__decoder__decode_plte(
|
||||
goto exit;
|
||||
}
|
||||
v_num_entries = (((uint32_t)(self->private_impl.f_chunk_length)) / 3);
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
while (v_i < v_num_entries) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
@@ -37418,6 +39216,67 @@ wuffs_png__decoder__decode_plte(
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_srgb
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_srgb(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_srgb[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 1) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
self->private_impl.f_metadata_flavor = 5;
|
||||
self->private_impl.f_metadata_fourcc = 1397901122;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t t_0 = *iop_a_src++;
|
||||
self->private_impl.f_metadata_x = t_0;
|
||||
}
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_srgb[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_srgb[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_trns
|
||||
|
||||
static wuffs_base__status
|
||||
@@ -37426,8 +39285,9 @@ wuffs_png__decoder__decode_trns(
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_num_entries = 0;
|
||||
uint32_t v_i = 0;
|
||||
uint32_t v_n = 0;
|
||||
uint64_t v_u = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -37442,42 +39302,143 @@ wuffs_png__decoder__decode_trns(
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_trns[0];
|
||||
if (coro_susp_point) {
|
||||
v_num_entries = self->private_data.s_decode_trns[0].v_num_entries;
|
||||
v_i = self->private_data.s_decode_trns[0].v_i;
|
||||
v_n = self->private_data.s_decode_trns[0].v_n;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length > 256) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
v_num_entries = ((uint32_t)(self->private_impl.f_chunk_length));
|
||||
while (v_i < v_num_entries) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_0 = *iop_a_src++;
|
||||
self->private_data.f_src_palette[((4 * v_i) + 3)] = t_0;
|
||||
}
|
||||
v_i += 1;
|
||||
}
|
||||
if (self->private_impl.f_color_type == 3) {
|
||||
self->private_impl.f_dst_pixfmt = 2164523016;
|
||||
self->private_impl.f_src_pixfmt = 2164523016;
|
||||
} else {
|
||||
if (self->private_impl.f_color_type == 0) {
|
||||
self->private_impl.choosy_filter_and_swizzle = (
|
||||
&wuffs_png__decoder__filter_and_swizzle_tricky);
|
||||
if (self->private_impl.f_color_type == 0) {
|
||||
self->private_impl.f_dst_pixfmt = 2164295816;
|
||||
self->private_impl.f_src_pixfmt = 2164308923;
|
||||
} else if (self->private_impl.f_color_type == 2) {
|
||||
if (self->private_impl.f_depth <= 8) {
|
||||
self->private_impl.f_dst_pixfmt = 2164295816;
|
||||
self->private_impl.f_src_pixfmt = 2164295816;
|
||||
} else {
|
||||
self->private_impl.f_dst_pixfmt = 2164308923;
|
||||
self->private_impl.f_src_pixfmt = 2164308923;
|
||||
}
|
||||
if (self->private_impl.f_chunk_length != 2) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
|
||||
t_0 = ((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 2;
|
||||
} else {
|
||||
self->private_data.s_decode_trns[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_trns[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 8) {
|
||||
t_0 = ((uint64_t)(*scratch >> 48));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_u = t_0;
|
||||
}
|
||||
if (self->private_impl.f_depth <= 1) {
|
||||
self->private_impl.f_remap_transparency = (((v_u & 1) * 16777215) | 4278190080);
|
||||
} else if (self->private_impl.f_depth <= 2) {
|
||||
self->private_impl.f_remap_transparency = (((v_u & 3) * 5592405) | 4278190080);
|
||||
} else if (self->private_impl.f_depth <= 4) {
|
||||
self->private_impl.f_remap_transparency = (((v_u & 15) * 1118481) | 4278190080);
|
||||
} else if (self->private_impl.f_depth <= 8) {
|
||||
self->private_impl.f_remap_transparency = (((v_u & 255) * 65793) | 4278190080);
|
||||
} else {
|
||||
self->private_impl.f_remap_transparency = ((v_u * 4295032833) | 18446462598732840960u);
|
||||
}
|
||||
} else if (self->private_impl.f_color_type == 2) {
|
||||
self->private_impl.choosy_filter_and_swizzle = (
|
||||
&wuffs_png__decoder__filter_and_swizzle_tricky);
|
||||
if (self->private_impl.f_depth <= 8) {
|
||||
self->private_impl.f_dst_pixfmt = 2164295816;
|
||||
self->private_impl.f_src_pixfmt = 2164295816;
|
||||
} else {
|
||||
self->private_impl.f_dst_pixfmt = 2164308923;
|
||||
self->private_impl.f_src_pixfmt = 2164308923;
|
||||
}
|
||||
if (self->private_impl.f_chunk_length != 6) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint64_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 6)) {
|
||||
t_1 = ((uint64_t)(wuffs_base__peek_u48be__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 6;
|
||||
} else {
|
||||
self->private_data.s_decode_trns[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_trns[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 40) {
|
||||
t_1 = ((uint64_t)(*scratch >> 16));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
}
|
||||
}
|
||||
v_u = t_1;
|
||||
}
|
||||
if (self->private_impl.f_depth <= 8) {
|
||||
self->private_impl.f_remap_transparency = ((255 & (v_u >> 0)) |
|
||||
(65280 & (v_u >> 8)) |
|
||||
(16711680 & (v_u >> 16)) |
|
||||
4278190080);
|
||||
} else {
|
||||
self->private_impl.f_remap_transparency = (v_u | 18446462598732840960u);
|
||||
}
|
||||
} else if (self->private_impl.f_color_type == 3) {
|
||||
self->private_impl.f_dst_pixfmt = 2164523016;
|
||||
self->private_impl.f_src_pixfmt = 2164523016;
|
||||
if (self->private_impl.f_chunk_length > 256) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
v_n = ((uint32_t)(self->private_impl.f_chunk_length));
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
while (v_i < v_n) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_2 = *iop_a_src++;
|
||||
self->private_data.f_src_palette[((4 * v_i) + 3)] = t_2;
|
||||
}
|
||||
v_i += 1;
|
||||
}
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
@@ -37489,8 +39450,8 @@ wuffs_png__decoder__decode_trns(
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_trns[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_trns[0].v_num_entries = v_num_entries;
|
||||
self->private_data.s_decode_trns[0].v_i = v_i;
|
||||
self->private_data.s_decode_trns[0].v_n = v_n;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
@@ -37544,7 +39505,10 @@ wuffs_png__decoder__decode_frame_config(
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence < 3) {
|
||||
if (self->private_impl.f_call_sequence == 255) {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
} else if (self->private_impl.f_call_sequence < 3) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
@@ -37557,34 +39521,153 @@ wuffs_png__decoder__decode_frame_config(
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 3) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 4) {
|
||||
self->private_impl.f_call_sequence = 255;
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_png__decoder__skip_frame(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
if (self->private_impl.f_call_sequence == 255) {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
}
|
||||
}
|
||||
if (self->private_impl.f_num_decoded_frame_configs_value == 0) {
|
||||
self->private_impl.f_frame_rect_x0 = self->private_impl.f_first_rect_x0;
|
||||
self->private_impl.f_frame_rect_y0 = self->private_impl.f_first_rect_y0;
|
||||
self->private_impl.f_frame_rect_x1 = self->private_impl.f_first_rect_x1;
|
||||
self->private_impl.f_frame_rect_y1 = self->private_impl.f_first_rect_y1;
|
||||
self->private_impl.f_frame_config_io_position = self->private_impl.f_first_config_io_position;
|
||||
self->private_impl.f_frame_duration = self->private_impl.f_first_duration;
|
||||
self->private_impl.f_frame_disposal = self->private_impl.f_first_disposal;
|
||||
self->private_impl.f_frame_overwrite_instead_of_blend = self->private_impl.f_first_overwrite_instead_of_blend;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
while (true) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_frame_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_frame_config[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
self->private_impl.f_chunk_length = t_0;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_frame_config[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_frame_config[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_chunk_type = t_1;
|
||||
}
|
||||
if (self->private_impl.f_chunk_type == 1413571686) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_chunk_type == 1280598886) {
|
||||
self->private_impl.f_frame_config_io_position = ((uint64_t)(wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))) - 8));
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
status = wuffs_png__decoder__decode_fctl(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_data.s_decode_frame_config[0].scratch = 4;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
if (self->private_data.s_decode_frame_config[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_frame_config[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_decode_frame_config[0].scratch;
|
||||
goto label__0__break;
|
||||
}
|
||||
self->private_data.s_decode_frame_config[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 4);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
if (self->private_data.s_decode_frame_config[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_frame_config[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_decode_frame_config[0].scratch;
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
}
|
||||
label__0__break:;
|
||||
}
|
||||
if (a_dst != NULL) {
|
||||
wuffs_base__frame_config__set(
|
||||
a_dst,
|
||||
wuffs_base__utility__make_rect_ie_u32(
|
||||
0,
|
||||
0,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height),
|
||||
((wuffs_base__flicks)(0)),
|
||||
0,
|
||||
self->private_impl.f_frame_rect_x0,
|
||||
self->private_impl.f_frame_rect_y0,
|
||||
self->private_impl.f_frame_rect_x1,
|
||||
self->private_impl.f_frame_rect_y1),
|
||||
((wuffs_base__flicks)(self->private_impl.f_frame_duration)),
|
||||
((uint64_t)(self->private_impl.f_num_decoded_frame_configs_value)),
|
||||
self->private_impl.f_frame_config_io_position,
|
||||
0,
|
||||
false,
|
||||
false,
|
||||
self->private_impl.f_frame_disposal,
|
||||
((self->private_impl.f_color_type <= 3) && ! self->private_impl.f_seen_trns),
|
||||
self->private_impl.f_frame_overwrite_instead_of_blend,
|
||||
0);
|
||||
}
|
||||
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frame_configs_value, 1);
|
||||
self->private_impl.f_call_sequence = 4;
|
||||
|
||||
ok:
|
||||
@@ -37609,6 +39692,162 @@ wuffs_png__decoder__decode_frame_config(
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.skip_frame
|
||||
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__skip_frame(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_seq_num = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_skip_frame[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
self->private_impl.f_chunk_type_array[0] = 0;
|
||||
self->private_impl.f_chunk_type_array[1] = 0;
|
||||
self->private_impl.f_chunk_type_array[2] = 0;
|
||||
self->private_impl.f_chunk_type_array[3] = 0;
|
||||
label__0__continue:;
|
||||
while (true) {
|
||||
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
|
||||
if (a_src && a_src->meta.closed) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
|
||||
if (self->private_impl.f_chunk_type == 1413563465) {
|
||||
if (self->private_impl.f_chunk_type_array[0] == 102) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_type_array[0] = 73;
|
||||
self->private_impl.f_chunk_type_array[1] = 68;
|
||||
self->private_impl.f_chunk_type_array[2] = 65;
|
||||
self->private_impl.f_chunk_type_array[3] = 84;
|
||||
} else if (self->private_impl.f_chunk_type == 1413571686) {
|
||||
if (self->private_impl.f_chunk_type_array[0] == 73) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_type_array[0] = 102;
|
||||
self->private_impl.f_chunk_type_array[1] = 100;
|
||||
self->private_impl.f_chunk_type_array[2] = 65;
|
||||
self->private_impl.f_chunk_type_array[3] = 84;
|
||||
if (self->private_impl.f_chunk_length < 4) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 4;
|
||||
iop_a_src += 8;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_skip_frame[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_skip_frame[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_seq_num = t_0;
|
||||
}
|
||||
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_next_animation_seq_num += 1;
|
||||
self->private_data.s_skip_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 4);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
if (self->private_data.s_skip_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_skip_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_skip_frame[0].scratch;
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
goto label__0__continue;
|
||||
} else if (self->private_impl.f_chunk_type_array[0] != 0) {
|
||||
goto label__0__break;
|
||||
} else if (self->private_impl.f_chunk_type == 1280598886) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_data.s_skip_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 12);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
if (self->private_data.s_skip_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_skip_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_skip_frame[0].scratch;
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
}
|
||||
label__0__break:;
|
||||
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
|
||||
if (self->private_impl.f_num_decoded_frames_value < self->private_impl.f_num_animation_frames_value) {
|
||||
self->private_impl.f_call_sequence = 5;
|
||||
} else {
|
||||
self->private_impl.f_call_sequence = 255;
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_skip_frame[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_skip_frame[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_frame
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
@@ -37640,25 +39879,138 @@ wuffs_png__decoder__decode_frame(
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_seq_num = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
uint32_t v_pass_width = 0;
|
||||
uint32_t v_pass_height = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_frame[0];
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence < 4) {
|
||||
if (self->private_impl.f_call_sequence == 255) {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
} else if (self->private_impl.f_call_sequence != 4) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_png__decoder__decode_frame_config(self, NULL, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 4) {
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
}
|
||||
while (true) {
|
||||
while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
|
||||
if (a_src && a_src->meta.closed) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
|
||||
}
|
||||
self->private_impl.f_chunk_length = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
self->private_impl.f_chunk_type = ((uint32_t)((wuffs_base__peek_u64le__no_bounds_check(iop_a_src) >> 32)));
|
||||
if (self->private_impl.f_chunk_type == 1413563465) {
|
||||
self->private_impl.f_chunk_type_array[0] = 73;
|
||||
self->private_impl.f_chunk_type_array[1] = 68;
|
||||
self->private_impl.f_chunk_type_array[2] = 65;
|
||||
self->private_impl.f_chunk_type_array[3] = 84;
|
||||
iop_a_src += 8;
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
|
||||
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
}
|
||||
goto label__0__break;
|
||||
} else if (self->private_impl.f_chunk_type == 1413571686) {
|
||||
self->private_impl.f_chunk_type_array[0] = 102;
|
||||
self->private_impl.f_chunk_type_array[1] = 100;
|
||||
self->private_impl.f_chunk_type_array[2] = 65;
|
||||
self->private_impl.f_chunk_type_array[3] = 84;
|
||||
if (self->private_impl.f_chunk_length < 4) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 4;
|
||||
iop_a_src += 8;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_frame[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_frame[0].scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0);
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_seq_num = t_0;
|
||||
}
|
||||
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_next_animation_seq_num += 1;
|
||||
goto label__0__break;
|
||||
} else if (self->private_impl.f_chunk_type == 1280598886) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_data.s_decode_frame[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 12);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
if (self->private_data.s_decode_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_decode_frame[0].scratch;
|
||||
self->private_impl.f_chunk_length = 0;
|
||||
}
|
||||
label__0__break:;
|
||||
if (self->private_impl.f_zlib_is_dirty) {
|
||||
wuffs_base__ignore_status(wuffs_zlib__decoder__initialize(&self->private_data.f_zlib,
|
||||
sizeof (wuffs_zlib__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
if (self->private_impl.f_ignore_checksum) {
|
||||
wuffs_zlib__decoder__set_quirk_enabled(&self->private_data.f_zlib, 1, true);
|
||||
}
|
||||
}
|
||||
self->private_impl.f_zlib_is_dirty = true;
|
||||
v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
|
||||
wuffs_base__pixel_buffer__pixel_format(a_dst),
|
||||
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)),
|
||||
@@ -37675,14 +40027,26 @@ wuffs_png__decoder__decode_frame(
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
self->private_impl.f_workbuf_hist_pos_base = 0;
|
||||
while (true) {
|
||||
v_pass_width = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][1])) + self->private_impl.f_width) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]));
|
||||
v_pass_height = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][4])) + self->private_impl.f_height) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][3]));
|
||||
if (self->private_impl.f_chunk_type_array[0] == 73) {
|
||||
v_pass_width = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][1])) + self->private_impl.f_width) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]));
|
||||
v_pass_height = (16777215 & ((((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][4])) + self->private_impl.f_height) >> WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][3]));
|
||||
} else {
|
||||
v_pass_width = (16777215 & ((uint32_t)(self->private_impl.f_frame_rect_x1 - self->private_impl.f_frame_rect_x0)));
|
||||
v_pass_height = (16777215 & ((uint32_t)(self->private_impl.f_frame_rect_y1 - self->private_impl.f_frame_rect_y0)));
|
||||
}
|
||||
if ((v_pass_width > 0) && (v_pass_height > 0)) {
|
||||
self->private_impl.f_pass_bytes_per_row = wuffs_png__decoder__calculate_bytes_per_row(self, v_pass_width);
|
||||
self->private_impl.f_pass_workbuf_length = (((uint64_t)(v_pass_height)) * (1 + self->private_impl.f_pass_bytes_per_row));
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
status = wuffs_png__decoder__decode_pass(self, a_src, a_workbuf);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
@@ -37697,9 +40061,10 @@ wuffs_png__decoder__decode_frame(
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
self->private_impl.f_workbuf_hist_pos_base += self->private_impl.f_pass_workbuf_length;
|
||||
}
|
||||
if ((self->private_impl.f_interlace_pass == 0) || (self->private_impl.f_interlace_pass >= 7)) {
|
||||
goto label__0__break;
|
||||
goto label__1__break;
|
||||
}
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
@@ -37710,8 +40075,13 @@ wuffs_png__decoder__decode_frame(
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
}
|
||||
label__0__break:;
|
||||
self->private_impl.f_call_sequence = 255;
|
||||
label__1__break:;
|
||||
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
|
||||
if (self->private_impl.f_num_decoded_frames_value < self->private_impl.f_num_animation_frames_value) {
|
||||
self->private_impl.f_call_sequence = 5;
|
||||
} else {
|
||||
self->private_impl.f_call_sequence = 255;
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_frame[0] = 0;
|
||||
@@ -37725,6 +40095,10 @@ wuffs_png__decoder__decode_frame(
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
}
|
||||
@@ -37751,6 +40125,7 @@ wuffs_png__decoder__decode_pass(
|
||||
wuffs_base__status v_zlib_status = wuffs_base__make_status(NULL);
|
||||
uint32_t v_checksum_have = 0;
|
||||
uint32_t v_checksum_want = 0;
|
||||
uint32_t v_seq_num = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -37764,9 +40139,6 @@ wuffs_png__decoder__decode_pass(
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_pass[0];
|
||||
if (coro_susp_point) {
|
||||
v_checksum_have = self->private_data.s_decode_pass[0].v_checksum_have;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
@@ -37791,11 +40163,12 @@ wuffs_png__decoder__decode_pass(
|
||||
&io2_v_w,
|
||||
wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
self->private_impl.f_workbuf_wi,
|
||||
self->private_impl.f_pass_workbuf_length));
|
||||
self->private_impl.f_pass_workbuf_length),
|
||||
((uint64_t)(self->private_impl.f_workbuf_hist_pos_base + self->private_impl.f_workbuf_wi)));
|
||||
{
|
||||
const uint8_t *o_1_io2_a_src = io2_a_src;
|
||||
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
self->private_impl.f_chunk_length);
|
||||
((uint64_t)(self->private_impl.f_chunk_length)));
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
@@ -37816,7 +40189,7 @@ wuffs_png__decoder__decode_pass(
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__io__since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src)), io0_a_src));
|
||||
}
|
||||
wuffs_base__u64__sat_sub_indirect(&self->private_impl.f_chunk_length, wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))));
|
||||
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
|
||||
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_workbuf_wi, wuffs_base__io__count_since(v_w_mark, ((uint64_t)(iop_v_w - io0_v_w))));
|
||||
io2_a_src = o_1_io2_a_src;
|
||||
if (a_src) {
|
||||
@@ -37830,41 +40203,41 @@ wuffs_png__decoder__decode_pass(
|
||||
io2_v_w = o_0_io2_v_w;
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_zlib_status)) {
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
if (self->private_impl.f_chunk_length > 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__too_much_data);
|
||||
goto exit;
|
||||
}
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_pass[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
if (self->private_impl.f_chunk_length > 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__too_much_data);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_pass[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1);
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_1));
|
||||
}
|
||||
v_checksum_want = t_1;
|
||||
}
|
||||
v_checksum_want = t_1;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type_array[0] == 73)) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
|
||||
if (v_checksum_have != v_checksum_want) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
|
||||
goto exit;
|
||||
@@ -37916,7 +40289,7 @@ wuffs_png__decoder__decode_pass(
|
||||
}
|
||||
v_checksum_want = t_2;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_chunk_type_array[0] == 73)) {
|
||||
v_checksum_have = wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__utility__empty_slice_u8());
|
||||
if (v_checksum_have != v_checksum_want) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
|
||||
@@ -37925,9 +40298,9 @@ wuffs_png__decoder__decode_pass(
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint64_t t_3;
|
||||
uint32_t t_3;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_3 = ((uint64_t)(wuffs_base__peek_u32be__no_bounds_check(iop_a_src)));
|
||||
t_3 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_pass[0].scratch = 0;
|
||||
@@ -37943,7 +40316,7 @@ wuffs_png__decoder__decode_pass(
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3);
|
||||
if (num_bits_3 == 24) {
|
||||
t_3 = ((uint64_t)(*scratch >> 32));
|
||||
t_3 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_3 += 8;
|
||||
@@ -37981,17 +40354,59 @@ wuffs_png__decoder__decode_pass(
|
||||
}
|
||||
self->private_impl.f_chunk_type = t_4;
|
||||
}
|
||||
if (self->private_impl.f_chunk_type != 1413563465) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32, sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, 0));
|
||||
self->private_impl.f_chunk_type_array[0] = 73;
|
||||
self->private_impl.f_chunk_type_array[1] = 68;
|
||||
self->private_impl.f_chunk_type_array[2] = 65;
|
||||
self->private_impl.f_chunk_type_array[3] = 84;
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
if (self->private_impl.f_chunk_type_array[0] == 73) {
|
||||
if (self->private_impl.f_chunk_type != 1413563465) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if ( ! self->private_impl.f_ignore_checksum) {
|
||||
wuffs_base__ignore_status(wuffs_crc32__ieee_hasher__initialize(&self->private_data.f_crc32,
|
||||
sizeof (wuffs_crc32__ieee_hasher), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_crc32__ieee_hasher__update_u32(&self->private_data.f_crc32, wuffs_base__make_slice_u8(self->private_impl.f_chunk_type_array, 4));
|
||||
}
|
||||
} else {
|
||||
if ((self->private_impl.f_chunk_type != 1413571686) || (self->private_impl.f_chunk_length < 4)) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 4;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
uint32_t t_5;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_5 = wuffs_base__peek_u32be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_pass[0].scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_pass[0].scratch;
|
||||
uint32_t num_bits_5 = ((uint32_t)(*scratch & 0xFF));
|
||||
*scratch >>= 8;
|
||||
*scratch <<= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5);
|
||||
if (num_bits_5 == 24) {
|
||||
t_5 = ((uint32_t)(*scratch >> 32));
|
||||
break;
|
||||
}
|
||||
num_bits_5 += 8;
|
||||
*scratch |= ((uint64_t)(num_bits_5));
|
||||
}
|
||||
}
|
||||
v_seq_num = t_5;
|
||||
}
|
||||
if (v_seq_num != self->private_impl.f_next_animation_seq_num) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_animation_sequence_number);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_next_animation_seq_num >= 4294967295) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_next_animation_seq_num += 1;
|
||||
}
|
||||
goto label__0__continue;
|
||||
} else if (((uint64_t)(io2_a_src - iop_a_src)) > 0) {
|
||||
@@ -37999,7 +40414,7 @@ wuffs_png__decoder__decode_pass(
|
||||
goto exit;
|
||||
}
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
|
||||
}
|
||||
label__0__break:;
|
||||
if (self->private_impl.f_workbuf_wi != self->private_impl.f_pass_workbuf_length) {
|
||||
@@ -38019,7 +40434,6 @@ wuffs_png__decoder__decode_pass(
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_pass[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_pass[0].v_checksum_have = v_checksum_have;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
@@ -38044,10 +40458,10 @@ wuffs_png__decoder__frame_dirty_rect(
|
||||
}
|
||||
|
||||
return wuffs_base__utility__make_rect_ie_u32(
|
||||
0,
|
||||
0,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height);
|
||||
self->private_impl.f_frame_rect_x0,
|
||||
self->private_impl.f_frame_rect_y0,
|
||||
self->private_impl.f_frame_rect_x1,
|
||||
self->private_impl.f_frame_rect_y1);
|
||||
}
|
||||
|
||||
// -------- func png.decoder.num_animation_loops
|
||||
@@ -38063,7 +40477,7 @@ wuffs_png__decoder__num_animation_loops(
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return self->private_impl.f_num_animation_loops_value;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.num_decoded_frame_configs
|
||||
@@ -38079,10 +40493,7 @@ wuffs_png__decoder__num_decoded_frame_configs(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (self->private_impl.f_call_sequence > 3) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
return ((uint64_t)(self->private_impl.f_num_decoded_frame_configs_value));
|
||||
}
|
||||
|
||||
// -------- func png.decoder.num_decoded_frames
|
||||
@@ -38098,10 +40509,7 @@ wuffs_png__decoder__num_decoded_frames(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (self->private_impl.f_call_sequence > 4) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
return ((uint64_t)(self->private_impl.f_num_decoded_frames_value));
|
||||
}
|
||||
|
||||
// -------- func png.decoder.restart_frame
|
||||
@@ -38123,8 +40531,7 @@ wuffs_png__decoder__restart_frame(
|
||||
|
||||
if (self->private_impl.f_call_sequence < 3) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
}
|
||||
if (a_index != 0) {
|
||||
} else if ((a_index >= ((uint64_t)(self->private_impl.f_num_animation_frames_value))) || ((a_index == 0) && (a_io_position != self->private_impl.f_first_config_io_position))) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
self->private_impl.f_call_sequence = 3;
|
||||
@@ -38132,6 +40539,8 @@ wuffs_png__decoder__restart_frame(
|
||||
self->private_impl.f_interlace_pass = 1;
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = a_io_position;
|
||||
self->private_impl.f_num_decoded_frame_configs_value = ((uint32_t)((a_index & 4294967295)));
|
||||
self->private_impl.f_num_decoded_frames_value = self->private_impl.f_num_decoded_frame_configs_value;
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
@@ -38142,6 +40551,26 @@ wuffs_png__decoder__set_report_metadata(
|
||||
wuffs_png__decoder* self,
|
||||
uint32_t a_fourcc,
|
||||
bool a_report) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
if (a_fourcc == 1128813133) {
|
||||
self->private_impl.f_report_metadata_chrm = a_report;
|
||||
} else if (a_fourcc == 1163413830) {
|
||||
self->private_impl.f_report_metadata_exif = a_report;
|
||||
} else if (a_fourcc == 1195461953) {
|
||||
self->private_impl.f_report_metadata_gama = a_report;
|
||||
} else if (a_fourcc == 1229144912) {
|
||||
self->private_impl.f_report_metadata_iccp = a_report;
|
||||
} else if (a_fourcc == 1263947808) {
|
||||
self->private_impl.f_report_metadata_kvp = a_report;
|
||||
} else if (a_fourcc == 1397901122) {
|
||||
self->private_impl.f_report_metadata_srgb = a_report;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
@@ -38174,13 +40603,498 @@ wuffs_png__decoder__tell_me_more(
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
status = wuffs_base__make_status(wuffs_base__error__no_more_information);
|
||||
goto exit;
|
||||
uint8_t v_c = 0;
|
||||
uint16_t v_c2 = 0;
|
||||
wuffs_base__io_buffer u_w = wuffs_base__empty_io_buffer();
|
||||
wuffs_base__io_buffer* v_w = &u_w;
|
||||
uint8_t* iop_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io0_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io1_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io2_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint64_t v_num_written = 0;
|
||||
uint64_t v_w_mark = 0;
|
||||
uint64_t v_r_mark = 0;
|
||||
wuffs_base__status v_zlib_status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint8_t* iop_a_dst = NULL;
|
||||
uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io1_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io2_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_dst) {
|
||||
io0_a_dst = a_dst->data.ptr;
|
||||
io1_a_dst = io0_a_dst + a_dst->meta.wi;
|
||||
iop_a_dst = io1_a_dst;
|
||||
io2_a_dst = io0_a_dst + a_dst->data.len;
|
||||
if (a_dst->meta.closed) {
|
||||
io2_a_dst = iop_a_dst;
|
||||
}
|
||||
}
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_tell_me_more[0];
|
||||
if (coro_susp_point) {
|
||||
v_zlib_status = self->private_data.s_tell_me_more[0].v_zlib_status;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence != 1) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
goto exit;
|
||||
}
|
||||
if (self->private_impl.f_metadata_fourcc == 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__no_more_information);
|
||||
goto exit;
|
||||
}
|
||||
while (true) {
|
||||
if (self->private_impl.f_metadata_flavor == 3) {
|
||||
while (true) {
|
||||
if (wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_y) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_i_o_position);
|
||||
goto exit;
|
||||
} else if (a_minfo != NULL) {
|
||||
wuffs_base__more_information__set(a_minfo,
|
||||
self->private_impl.f_metadata_flavor,
|
||||
self->private_impl.f_metadata_fourcc,
|
||||
self->private_impl.f_metadata_x,
|
||||
self->private_impl.f_metadata_y,
|
||||
self->private_impl.f_metadata_z);
|
||||
}
|
||||
if (self->private_impl.f_metadata_y >= self->private_impl.f_metadata_z) {
|
||||
goto label__goto_done__break;
|
||||
}
|
||||
self->private_impl.f_metadata_y = self->private_impl.f_metadata_z;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__even_more_information);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
}
|
||||
if (self->private_impl.f_metadata_is_zlib_compressed) {
|
||||
if (self->private_impl.f_zlib_is_dirty) {
|
||||
wuffs_base__ignore_status(wuffs_zlib__decoder__initialize(&self->private_data.f_zlib,
|
||||
sizeof (wuffs_zlib__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
if (self->private_impl.f_ignore_checksum) {
|
||||
wuffs_zlib__decoder__set_quirk_enabled(&self->private_data.f_zlib, 1, true);
|
||||
}
|
||||
}
|
||||
self->private_impl.f_zlib_is_dirty = true;
|
||||
self->private_impl.f_ztxt_hist_pos = 0;
|
||||
}
|
||||
label__loop__continue:;
|
||||
while (true) {
|
||||
if (a_minfo != NULL) {
|
||||
wuffs_base__more_information__set(a_minfo,
|
||||
self->private_impl.f_metadata_flavor,
|
||||
self->private_impl.f_metadata_fourcc,
|
||||
self->private_impl.f_metadata_x,
|
||||
self->private_impl.f_metadata_y,
|
||||
self->private_impl.f_metadata_z);
|
||||
}
|
||||
if (self->private_impl.f_metadata_flavor != 4) {
|
||||
goto label__loop__break;
|
||||
}
|
||||
if (self->private_impl.f_metadata_is_zlib_compressed) {
|
||||
if (self->private_impl.f_chunk_type == 1346585449) {
|
||||
{
|
||||
const uint8_t *o_0_io2_a_src = io2_a_src;
|
||||
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_chunk_length)));
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_dst) {
|
||||
a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_0 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, a_dst, a_src, wuffs_base__utility__empty_slice_u8());
|
||||
v_zlib_status = t_0;
|
||||
if (a_dst) {
|
||||
iop_a_dst = a_dst->data.ptr + a_dst->meta.wi;
|
||||
}
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
|
||||
io2_a_src = o_0_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_zlib_status)) {
|
||||
self->private_impl.f_metadata_is_zlib_compressed = false;
|
||||
goto label__loop__break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
|
||||
status = v_zlib_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
status = v_zlib_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
|
||||
} else if (self->private_impl.f_chunk_type == 1951945833) {
|
||||
{
|
||||
const uint8_t *o_1_io2_a_src = io2_a_src;
|
||||
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_chunk_length)));
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_dst) {
|
||||
a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_1 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, a_dst, a_src, wuffs_base__utility__empty_slice_u8());
|
||||
v_zlib_status = t_1;
|
||||
if (a_dst) {
|
||||
iop_a_dst = a_dst->data.ptr + a_dst->meta.wi;
|
||||
}
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
|
||||
io2_a_src = o_1_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_zlib_status)) {
|
||||
self->private_impl.f_metadata_is_zlib_compressed = false;
|
||||
goto label__loop__break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
|
||||
status = v_zlib_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
status = v_zlib_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
|
||||
} else if (self->private_impl.f_chunk_type == 1951945850) {
|
||||
if (self->private_impl.f_ztxt_ri == self->private_impl.f_ztxt_wi) {
|
||||
{
|
||||
wuffs_base__io_buffer* o_2_v_w = v_w;
|
||||
uint8_t *o_2_iop_v_w = iop_v_w;
|
||||
uint8_t *o_2_io0_v_w = io0_v_w;
|
||||
uint8_t *o_2_io1_v_w = io1_v_w;
|
||||
uint8_t *o_2_io2_v_w = io2_v_w;
|
||||
v_w = wuffs_base__io_writer__set(
|
||||
&u_w,
|
||||
&iop_v_w,
|
||||
&io0_v_w,
|
||||
&io1_v_w,
|
||||
&io2_v_w,
|
||||
wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024),
|
||||
self->private_impl.f_ztxt_hist_pos);
|
||||
{
|
||||
const uint8_t *o_3_io2_a_src = io2_a_src;
|
||||
wuffs_base__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_chunk_length)));
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
v_w_mark = ((uint64_t)(iop_v_w - io0_v_w));
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
u_w.meta.wi = ((size_t)(iop_v_w - u_w.data.ptr));
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_2 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, v_w, a_src, wuffs_base__utility__empty_slice_u8());
|
||||
v_zlib_status = t_2;
|
||||
iop_v_w = u_w.data.ptr + u_w.meta.wi;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_chunk_length, ((uint32_t)((wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))) & 4294967295))));
|
||||
v_num_written = wuffs_base__io__count_since(v_w_mark, ((uint64_t)(iop_v_w - io0_v_w)));
|
||||
io2_a_src = o_3_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
v_w = o_2_v_w;
|
||||
iop_v_w = o_2_iop_v_w;
|
||||
io0_v_w = o_2_io0_v_w;
|
||||
io1_v_w = o_2_io1_v_w;
|
||||
io2_v_w = o_2_io2_v_w;
|
||||
}
|
||||
if (v_num_written > 1024) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_i_o);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_ztxt_ri = 0;
|
||||
self->private_impl.f_ztxt_wi = ((uint32_t)(v_num_written));
|
||||
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_ztxt_hist_pos, v_num_written);
|
||||
}
|
||||
while (self->private_impl.f_ztxt_ri < self->private_impl.f_ztxt_wi) {
|
||||
v_c2 = WUFFS_PNG__LATIN_1[self->private_data.f_dst_palette[self->private_impl.f_ztxt_ri]];
|
||||
if (v_c2 == 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_text_chunk_not_latin_1);
|
||||
goto exit;
|
||||
} else if (v_c2 <= 127) {
|
||||
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
|
||||
v_c2 = 0;
|
||||
goto label__loop__continue;
|
||||
}
|
||||
self->private_impl.f_ztxt_ri += 1;
|
||||
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(v_c2))), iop_a_dst += 1);
|
||||
} else {
|
||||
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 1) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
v_c2 = 0;
|
||||
goto label__loop__continue;
|
||||
}
|
||||
self->private_impl.f_ztxt_ri += 1;
|
||||
(wuffs_base__poke_u16le__no_bounds_check(iop_a_dst, v_c2), iop_a_dst += 2);
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_zlib_status)) {
|
||||
self->private_impl.f_metadata_is_zlib_compressed = false;
|
||||
goto label__loop__break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_zlib_status)) {
|
||||
status = v_zlib_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
} else if (v_zlib_status.repr != wuffs_base__suspension__short_write) {
|
||||
status = v_zlib_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
|
||||
}
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_chunk_type);
|
||||
goto exit;
|
||||
}
|
||||
} else if ((self->private_impl.f_chunk_type == 1951945833) && (self->private_impl.f_metadata_fourcc == 1263947862)) {
|
||||
while (true) {
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
goto label__loop__break;
|
||||
} else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
|
||||
goto label__loop__continue;
|
||||
} else if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(8);
|
||||
goto label__loop__continue;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 1;
|
||||
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, v_c), iop_a_dst += 1);
|
||||
}
|
||||
} else {
|
||||
while (true) {
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
if (self->private_impl.f_metadata_fourcc == 1263947851) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
goto label__loop__break;
|
||||
} else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
|
||||
goto label__loop__continue;
|
||||
}
|
||||
v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
|
||||
if (v_c == 0) {
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
iop_a_src += 1;
|
||||
goto label__loop__break;
|
||||
}
|
||||
v_c2 = WUFFS_PNG__LATIN_1[v_c];
|
||||
if (v_c2 == 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_text_chunk_not_latin_1);
|
||||
goto exit;
|
||||
} else if (v_c2 <= 127) {
|
||||
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
|
||||
v_c2 = 0;
|
||||
goto label__loop__continue;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
iop_a_src += 1;
|
||||
(wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, ((uint8_t)(v_c2))), iop_a_dst += 1);
|
||||
} else {
|
||||
if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 1) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_write);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
|
||||
v_c2 = 0;
|
||||
goto label__loop__continue;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
iop_a_src += 1;
|
||||
(wuffs_base__poke_u16le__no_bounds_check(iop_a_dst, v_c2), iop_a_dst += 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
label__loop__break:;
|
||||
if (self->private_impl.f_metadata_fourcc == 1263947851) {
|
||||
self->private_impl.f_metadata_fourcc = 1263947862;
|
||||
if (self->private_impl.f_chunk_type == 1951945833) {
|
||||
if (self->private_impl.f_chunk_length <= 1) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 2;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_3 = *iop_a_src++;
|
||||
v_c = t_3;
|
||||
}
|
||||
if (v_c == 0) {
|
||||
self->private_impl.f_metadata_is_zlib_compressed = false;
|
||||
} else if (v_c == 1) {
|
||||
self->private_impl.f_metadata_is_zlib_compressed = true;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_4 = *iop_a_src++;
|
||||
v_c = t_4;
|
||||
}
|
||||
if ((v_c != 0) && self->private_impl.f_metadata_is_zlib_compressed) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_metadata_fourcc -= 2;
|
||||
while (self->private_impl.f_metadata_fourcc != 1263947862) {
|
||||
self->private_impl.f_metadata_fourcc += 1;
|
||||
while (true) {
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_5 = *iop_a_src++;
|
||||
v_c = t_5;
|
||||
}
|
||||
if (v_c == 0) {
|
||||
goto label__0__break;
|
||||
}
|
||||
}
|
||||
label__0__break:;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1951945850) {
|
||||
if (self->private_impl.f_chunk_length <= 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length -= 1;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_6 = *iop_a_src++;
|
||||
v_c = t_6;
|
||||
}
|
||||
if (v_c != 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__unsupported_png_compression_method);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_metadata_is_zlib_compressed = true;
|
||||
}
|
||||
self->private_impl.f_call_sequence = 2;
|
||||
status = wuffs_base__make_status(NULL);
|
||||
goto ok;
|
||||
}
|
||||
goto label__goto_done__break;
|
||||
}
|
||||
label__goto_done__break:;
|
||||
if (self->private_impl.f_chunk_length != 0) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_data.s_tell_me_more[0].scratch = 4;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
|
||||
if (self->private_data.s_tell_me_more[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_tell_me_more[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_tell_me_more[0].scratch;
|
||||
self->private_impl.f_metadata_flavor = 0;
|
||||
self->private_impl.f_metadata_fourcc = 0;
|
||||
self->private_impl.f_metadata_x = 0;
|
||||
self->private_impl.f_metadata_y = 0;
|
||||
self->private_impl.f_metadata_z = 0;
|
||||
self->private_impl.f_call_sequence = 2;
|
||||
status = wuffs_base__make_status(NULL);
|
||||
goto ok;
|
||||
|
||||
ok:
|
||||
self->private_impl.p_tell_me_more[0] = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_tell_me_more[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 4 : 0;
|
||||
self->private_data.s_tell_me_more[0].v_zlib_status = v_zlib_status;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_dst) {
|
||||
a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
}
|
||||
@@ -38221,7 +41135,8 @@ wuffs_png__decoder__filter_and_swizzle__choosy_default(
|
||||
wuffs_base__pixel_format v_dst_pixfmt = {0};
|
||||
uint32_t v_dst_bits_per_pixel = 0;
|
||||
uint64_t v_dst_bytes_per_pixel = 0;
|
||||
uint64_t v_dst_bytes_per_row = 0;
|
||||
uint64_t v_dst_bytes_per_row0 = 0;
|
||||
uint64_t v_dst_bytes_per_row1 = 0;
|
||||
wuffs_base__slice_u8 v_dst_palette = {0};
|
||||
wuffs_base__table_u8 v_tab = {0};
|
||||
uint32_t v_y = 0;
|
||||
@@ -38236,14 +41151,33 @@ wuffs_png__decoder__filter_and_swizzle__choosy_default(
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
|
||||
v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
|
||||
v_dst_bytes_per_row0 = (((uint64_t)(self->private_impl.f_frame_rect_x0)) * v_dst_bytes_per_pixel);
|
||||
v_dst_bytes_per_row1 = (((uint64_t)(self->private_impl.f_frame_rect_x1)) * v_dst_bytes_per_pixel);
|
||||
v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024));
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, v_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
}
|
||||
if (v_dst_bytes_per_row1 < ((uint64_t)(v_tab.width))) {
|
||||
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
|
||||
0,
|
||||
0,
|
||||
v_dst_bytes_per_row1,
|
||||
((uint64_t)(v_tab.height)));
|
||||
}
|
||||
if (v_dst_bytes_per_row0 < ((uint64_t)(v_tab.width))) {
|
||||
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
|
||||
v_dst_bytes_per_row0,
|
||||
0,
|
||||
((uint64_t)(v_tab.width)),
|
||||
((uint64_t)(v_tab.height)));
|
||||
} else {
|
||||
v_tab = wuffs_base__table_u8__subtable_ij(v_tab,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0);
|
||||
}
|
||||
v_y = self->private_impl.f_frame_rect_y0;
|
||||
while (v_y < self->private_impl.f_frame_rect_y1) {
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_y);
|
||||
if (1 > ((uint64_t)(a_workbuf.len))) {
|
||||
return wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_workbuf_length);
|
||||
}
|
||||
@@ -38283,7 +41217,7 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
wuffs_base__pixel_format v_dst_pixfmt = {0};
|
||||
uint32_t v_dst_bits_per_pixel = 0;
|
||||
uint64_t v_dst_bytes_per_pixel = 0;
|
||||
uint64_t v_dst_bytes_per_row = 0;
|
||||
uint64_t v_dst_bytes_per_row1 = 0;
|
||||
wuffs_base__slice_u8 v_dst_palette = {0};
|
||||
wuffs_base__table_u8 v_tab = {0};
|
||||
uint64_t v_src_bytes_per_pixel = 0;
|
||||
@@ -38307,26 +41241,22 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
|
||||
v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
|
||||
v_dst_bytes_per_row1 = (((uint64_t)(self->private_impl.f_frame_rect_x1)) * v_dst_bytes_per_pixel);
|
||||
v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024));
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
|
||||
v_src_bytes_per_pixel = 1;
|
||||
if (self->private_impl.f_depth >= 8) {
|
||||
v_src_bytes_per_pixel = (((uint64_t)(WUFFS_PNG__NUM_CHANNELS[self->private_impl.f_color_type])) * ((uint64_t)((self->private_impl.f_depth >> 3))));
|
||||
}
|
||||
v_bits_unpacked[0] = 255;
|
||||
v_bits_unpacked[1] = 255;
|
||||
v_bits_unpacked[2] = 255;
|
||||
v_bits_unpacked[3] = 255;
|
||||
v_bits_unpacked[4] = 255;
|
||||
v_bits_unpacked[5] = 255;
|
||||
v_bits_unpacked[6] = 255;
|
||||
v_bits_unpacked[7] = 255;
|
||||
v_y = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][5]));
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, v_y);
|
||||
if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row);
|
||||
if (self->private_impl.f_chunk_type_array[0] == 73) {
|
||||
v_y = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][5]));
|
||||
} else {
|
||||
v_y = self->private_impl.f_frame_rect_y0;
|
||||
}
|
||||
while (v_y < self->private_impl.f_frame_rect_y1) {
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_y);
|
||||
if (v_dst_bytes_per_row1 < ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row1);
|
||||
}
|
||||
if (1 > ((uint64_t)(a_workbuf.len))) {
|
||||
return wuffs_base__make_status(wuffs_png__error__internal_error_inconsistent_workbuf_length);
|
||||
@@ -38351,9 +41281,13 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
return wuffs_base__make_status(wuffs_png__error__bad_filter);
|
||||
}
|
||||
v_s = v_curr_row;
|
||||
v_x = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][2]));
|
||||
if (self->private_impl.f_chunk_type_array[0] == 73) {
|
||||
v_x = ((uint32_t)(WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][2]));
|
||||
} else {
|
||||
v_x = self->private_impl.f_frame_rect_x0;
|
||||
}
|
||||
if (self->private_impl.f_depth == 8) {
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
while (v_x < self->private_impl.f_frame_rect_x1) {
|
||||
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
|
||||
if (v_i <= ((uint64_t)(v_dst.len))) {
|
||||
if (self->private_impl.f_color_type == 4) {
|
||||
@@ -38365,6 +41299,44 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, 2);
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
|
||||
}
|
||||
} else if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) != 0) {
|
||||
if (self->private_impl.f_color_type == 0) {
|
||||
if (1 <= ((uint64_t)(v_s.len))) {
|
||||
v_bits_unpacked[0] = v_s.ptr[0];
|
||||
v_bits_unpacked[1] = v_s.ptr[0];
|
||||
v_bits_unpacked[2] = v_s.ptr[0];
|
||||
v_bits_unpacked[3] = 255;
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, 1);
|
||||
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
|
||||
(((uint32_t)(v_bits_unpacked[1])) << 8) |
|
||||
(((uint32_t)(v_bits_unpacked[2])) << 16) |
|
||||
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
|
||||
v_bits_unpacked[0] = 0;
|
||||
v_bits_unpacked[1] = 0;
|
||||
v_bits_unpacked[2] = 0;
|
||||
v_bits_unpacked[3] = 0;
|
||||
}
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
|
||||
}
|
||||
} else {
|
||||
if (3 <= ((uint64_t)(v_s.len))) {
|
||||
v_bits_unpacked[0] = v_s.ptr[2];
|
||||
v_bits_unpacked[1] = v_s.ptr[1];
|
||||
v_bits_unpacked[2] = v_s.ptr[0];
|
||||
v_bits_unpacked[3] = 255;
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, 3);
|
||||
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
|
||||
(((uint32_t)(v_bits_unpacked[1])) << 8) |
|
||||
(((uint32_t)(v_bits_unpacked[2])) << 16) |
|
||||
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
|
||||
v_bits_unpacked[0] = 0;
|
||||
v_bits_unpacked[1] = 0;
|
||||
v_bits_unpacked[2] = 0;
|
||||
v_bits_unpacked[3] = 0;
|
||||
}
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
|
||||
}
|
||||
}
|
||||
} else if (v_src_bytes_per_pixel <= ((uint64_t)(v_s.len))) {
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__slice_u8__subslice_j(v_s, v_src_bytes_per_pixel));
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, v_src_bytes_per_pixel);
|
||||
@@ -38379,7 +41351,7 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
}
|
||||
v_shift = ((8 - self->private_impl.f_depth) & 7);
|
||||
v_packs_remaining = 0;
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
while (v_x < self->private_impl.f_frame_rect_x1) {
|
||||
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
|
||||
if (v_i <= ((uint64_t)(v_dst.len))) {
|
||||
if ((v_packs_remaining == 0) && (1 <= ((uint64_t)(v_s.len)))) {
|
||||
@@ -38390,12 +41362,28 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
v_bits_unpacked[0] = ((uint8_t)((v_bits_packed >> v_shift) * v_multiplier));
|
||||
v_bits_packed = ((uint8_t)(v_bits_packed << self->private_impl.f_depth));
|
||||
v_packs_remaining = ((uint8_t)(v_packs_remaining - 1));
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 1));
|
||||
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) != 0) {
|
||||
v_bits_unpacked[1] = v_bits_unpacked[0];
|
||||
v_bits_unpacked[2] = v_bits_unpacked[0];
|
||||
v_bits_unpacked[3] = 255;
|
||||
if (((uint32_t)((self->private_impl.f_remap_transparency & 4294967295))) == ((((uint32_t)(v_bits_unpacked[0])) << 0) |
|
||||
(((uint32_t)(v_bits_unpacked[1])) << 8) |
|
||||
(((uint32_t)(v_bits_unpacked[2])) << 16) |
|
||||
(((uint32_t)(v_bits_unpacked[3])) << 24))) {
|
||||
v_bits_unpacked[0] = 0;
|
||||
v_bits_unpacked[1] = 0;
|
||||
v_bits_unpacked[2] = 0;
|
||||
v_bits_unpacked[3] = 0;
|
||||
}
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 4));
|
||||
} else {
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(v_bits_unpacked, 1));
|
||||
}
|
||||
}
|
||||
v_x += (((uint32_t)(1)) << WUFFS_PNG__INTERLACING[self->private_impl.f_interlace_pass][0]);
|
||||
}
|
||||
} else {
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
while (v_x < self->private_impl.f_frame_rect_x1) {
|
||||
v_i = (((uint64_t)(v_x)) * v_dst_bytes_per_pixel);
|
||||
if (v_i <= ((uint64_t)(v_dst.len))) {
|
||||
if (self->private_impl.f_color_type == 0) {
|
||||
@@ -38406,7 +41394,26 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
v_bits_unpacked[3] = v_s.ptr[0];
|
||||
v_bits_unpacked[4] = v_s.ptr[1];
|
||||
v_bits_unpacked[5] = v_s.ptr[0];
|
||||
v_bits_unpacked[6] = 255;
|
||||
v_bits_unpacked[7] = 255;
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, 2);
|
||||
if (self->private_impl.f_remap_transparency == ((((uint64_t)(v_bits_unpacked[0])) << 0) |
|
||||
(((uint64_t)(v_bits_unpacked[1])) << 8) |
|
||||
(((uint64_t)(v_bits_unpacked[2])) << 16) |
|
||||
(((uint64_t)(v_bits_unpacked[3])) << 24) |
|
||||
(((uint64_t)(v_bits_unpacked[4])) << 32) |
|
||||
(((uint64_t)(v_bits_unpacked[5])) << 40) |
|
||||
(((uint64_t)(v_bits_unpacked[6])) << 48) |
|
||||
(((uint64_t)(v_bits_unpacked[7])) << 56))) {
|
||||
v_bits_unpacked[0] = 0;
|
||||
v_bits_unpacked[1] = 0;
|
||||
v_bits_unpacked[2] = 0;
|
||||
v_bits_unpacked[3] = 0;
|
||||
v_bits_unpacked[4] = 0;
|
||||
v_bits_unpacked[5] = 0;
|
||||
v_bits_unpacked[6] = 0;
|
||||
v_bits_unpacked[7] = 0;
|
||||
}
|
||||
}
|
||||
} else if (self->private_impl.f_color_type == 2) {
|
||||
if (6 <= ((uint64_t)(v_s.len))) {
|
||||
@@ -38416,7 +41423,26 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
v_bits_unpacked[3] = v_s.ptr[2];
|
||||
v_bits_unpacked[4] = v_s.ptr[1];
|
||||
v_bits_unpacked[5] = v_s.ptr[0];
|
||||
v_bits_unpacked[6] = 255;
|
||||
v_bits_unpacked[7] = 255;
|
||||
v_s = wuffs_base__slice_u8__subslice_i(v_s, 6);
|
||||
if (self->private_impl.f_remap_transparency == ((((uint64_t)(v_bits_unpacked[0])) << 0) |
|
||||
(((uint64_t)(v_bits_unpacked[1])) << 8) |
|
||||
(((uint64_t)(v_bits_unpacked[2])) << 16) |
|
||||
(((uint64_t)(v_bits_unpacked[3])) << 24) |
|
||||
(((uint64_t)(v_bits_unpacked[4])) << 32) |
|
||||
(((uint64_t)(v_bits_unpacked[5])) << 40) |
|
||||
(((uint64_t)(v_bits_unpacked[6])) << 48) |
|
||||
(((uint64_t)(v_bits_unpacked[7])) << 56))) {
|
||||
v_bits_unpacked[0] = 0;
|
||||
v_bits_unpacked[1] = 0;
|
||||
v_bits_unpacked[2] = 0;
|
||||
v_bits_unpacked[3] = 0;
|
||||
v_bits_unpacked[4] = 0;
|
||||
v_bits_unpacked[5] = 0;
|
||||
v_bits_unpacked[6] = 0;
|
||||
v_bits_unpacked[7] = 0;
|
||||
}
|
||||
}
|
||||
} else if (self->private_impl.f_color_type == 4) {
|
||||
if (4 <= ((uint64_t)(v_s.len))) {
|
||||
@@ -38690,7 +41716,7 @@ wuffs_wbmp__decoder__decode_image_config(
|
||||
}
|
||||
v_i += 1;
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
if (a_dst != NULL) {
|
||||
wuffs_base__image_config__set(
|
||||
a_dst,
|
||||
@@ -38784,7 +41810,7 @@ wuffs_wbmp__decoder__decode_frame_config(
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 3) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
}
|
||||
@@ -38944,7 +41970,7 @@ wuffs_wbmp__decoder__decode_frame(
|
||||
if (self->private_impl.f_width > 0) {
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
|
||||
while (v_dst_y < self->private_impl.f_height) {
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, v_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_dst_y);
|
||||
v_dst_x = 0;
|
||||
while (v_dst_x < self->private_impl.f_width) {
|
||||
if ((v_dst_x & 7) == 0) {
|
||||
@@ -38952,7 +41978,7 @@ wuffs_wbmp__decoder__decode_frame(
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
|
||||
v_dst = wuffs_base__table_u8__row(v_tab, v_dst_y);
|
||||
v_dst = wuffs_base__table_u8__row_u32(v_tab, v_dst_y);
|
||||
v_dst_x_in_bytes = (((uint64_t)(v_dst_x)) * v_dst_bytes_per_pixel);
|
||||
if (v_dst_x_in_bytes <= ((uint64_t)(v_dst.len))) {
|
||||
v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_dst_x_in_bytes);
|
||||
@@ -39192,6 +42218,71 @@ namespace sync_io {
|
||||
|
||||
// --------
|
||||
|
||||
DynIOBuffer::DynIOBuffer(uint64_t max_incl)
|
||||
: m_buf(wuffs_base__empty_io_buffer()), m_max_incl(max_incl) {}
|
||||
|
||||
DynIOBuffer::~DynIOBuffer() {
|
||||
if (m_buf.data.ptr) {
|
||||
free(m_buf.data.ptr);
|
||||
}
|
||||
}
|
||||
|
||||
void //
|
||||
DynIOBuffer::drop() {
|
||||
if (m_buf.data.ptr) {
|
||||
free(m_buf.data.ptr);
|
||||
}
|
||||
m_buf = wuffs_base__empty_io_buffer();
|
||||
}
|
||||
|
||||
DynIOBuffer::GrowResult //
|
||||
DynIOBuffer::grow(uint64_t min_incl) {
|
||||
uint64_t n = round_up(min_incl, m_max_incl);
|
||||
if (n == 0) {
|
||||
return ((min_incl == 0) && (m_max_incl == 0))
|
||||
? DynIOBuffer::GrowResult::OK
|
||||
: DynIOBuffer::GrowResult::FailedMaxInclExceeded;
|
||||
} else if (n > m_buf.data.len) {
|
||||
uint8_t* ptr = static_cast<uint8_t*>(realloc(m_buf.data.ptr, n));
|
||||
if (!ptr) {
|
||||
return DynIOBuffer::GrowResult::FailedOutOfMemory;
|
||||
}
|
||||
m_buf.data.ptr = ptr;
|
||||
m_buf.data.len = n;
|
||||
}
|
||||
return DynIOBuffer::GrowResult::OK;
|
||||
}
|
||||
|
||||
// round_up rounds min_incl up, returning the smallest value x satisfying
|
||||
// (min_incl <= x) and (x <= max_incl) and some other constraints. It returns 0
|
||||
// if there is no such x.
|
||||
//
|
||||
// When max_incl <= 4096, the other constraints are:
|
||||
// - (x == max_incl)
|
||||
//
|
||||
// When max_incl > 4096, the other constraints are:
|
||||
// - (x == max_incl) or (x is a power of 2)
|
||||
// - (x >= 4096)
|
||||
uint64_t //
|
||||
DynIOBuffer::round_up(uint64_t min_incl, uint64_t max_incl) {
|
||||
if (min_incl > max_incl) {
|
||||
return 0;
|
||||
}
|
||||
uint64_t n = 4096;
|
||||
if (n >= max_incl) {
|
||||
return max_incl;
|
||||
}
|
||||
while (n < min_incl) {
|
||||
if (n >= (max_incl / 2)) {
|
||||
return max_incl;
|
||||
}
|
||||
n *= 2;
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
Input::~Input() {}
|
||||
|
||||
IOBuffer* //
|
||||
@@ -39266,6 +42357,164 @@ MemoryInput::CopyIn(IOBuffer* dst) {
|
||||
|
||||
} // namespace sync_io
|
||||
|
||||
namespace private_impl {
|
||||
|
||||
struct ErrorMessages {
|
||||
const char* max_incl_metadata_length_exceeded;
|
||||
const char* out_of_memory;
|
||||
const char* unexpected_end_of_file;
|
||||
const char* unsupported_metadata;
|
||||
const char* unsupported_negative_advance;
|
||||
|
||||
// If adding new "const char*" typed fields to this struct, either add them
|
||||
// after existing fields or, if re-ordering fields, make sure that you update
|
||||
// all of the "const private_impl::ErrorMessages FooBarErrorMessages" values
|
||||
// in all of the sibling *.cc files.
|
||||
|
||||
static inline const char* resolve(const char* s) {
|
||||
return s ? s : "wuffs_aux::private_impl: unknown error";
|
||||
};
|
||||
};
|
||||
|
||||
std::string //
|
||||
AdvanceIOBufferTo(const ErrorMessages& error_messages,
|
||||
sync_io::Input& input,
|
||||
IOBuffer& io_buf,
|
||||
uint64_t absolute_position) {
|
||||
if (absolute_position < io_buf.reader_position()) {
|
||||
return error_messages.resolve(error_messages.unsupported_negative_advance);
|
||||
}
|
||||
while (true) {
|
||||
uint64_t relative_position = absolute_position - io_buf.reader_position();
|
||||
if (relative_position <= io_buf.reader_length()) {
|
||||
io_buf.meta.ri += (size_t)relative_position;
|
||||
break;
|
||||
} else if (io_buf.meta.closed) {
|
||||
return error_messages.resolve(error_messages.unexpected_end_of_file);
|
||||
}
|
||||
io_buf.meta.ri = io_buf.meta.wi;
|
||||
if (!input.BringsItsOwnIOBuffer()) {
|
||||
io_buf.compact();
|
||||
}
|
||||
std::string error_message = input.CopyIn(&io_buf);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
std::string //
|
||||
HandleMetadata(
|
||||
const ErrorMessages& error_messages,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
sync_io::DynIOBuffer& raw,
|
||||
wuffs_base__status (*tell_me_more_func)(void*,
|
||||
wuffs_base__io_buffer*,
|
||||
wuffs_base__more_information*,
|
||||
wuffs_base__io_buffer*),
|
||||
void* tell_me_more_receiver,
|
||||
std::string (*handle_metadata_func)(void*,
|
||||
const wuffs_base__more_information*,
|
||||
wuffs_base__slice_u8),
|
||||
void* handle_metadata_receiver) {
|
||||
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
|
||||
// Reset raw but keep its backing array (the raw.m_buf.data slice).
|
||||
raw.m_buf.meta = wuffs_base__empty_io_buffer_meta();
|
||||
|
||||
while (true) {
|
||||
minfo = wuffs_base__empty_more_information();
|
||||
wuffs_base__status status = (*tell_me_more_func)(
|
||||
tell_me_more_receiver, &raw.m_buf, &minfo, &io_buf);
|
||||
switch (minfo.flavor) {
|
||||
case 0:
|
||||
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM:
|
||||
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED:
|
||||
break;
|
||||
|
||||
case WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH: {
|
||||
wuffs_base__range_ie_u64 r = minfo.metadata_raw_passthrough__range();
|
||||
if (r.is_empty()) {
|
||||
break;
|
||||
}
|
||||
uint64_t num_to_copy = r.length();
|
||||
if (num_to_copy > (raw.m_max_incl - raw.m_buf.meta.wi)) {
|
||||
return error_messages.resolve(
|
||||
error_messages.max_incl_metadata_length_exceeded);
|
||||
} else if (num_to_copy > (raw.m_buf.data.len - raw.m_buf.meta.wi)) {
|
||||
switch (raw.grow(num_to_copy + raw.m_buf.meta.wi)) {
|
||||
case sync_io::DynIOBuffer::GrowResult::OK:
|
||||
break;
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
|
||||
return error_messages.resolve(
|
||||
error_messages.max_incl_metadata_length_exceeded);
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
|
||||
return error_messages.resolve(error_messages.out_of_memory);
|
||||
}
|
||||
}
|
||||
|
||||
if (io_buf.reader_position() > r.min_incl) {
|
||||
return error_messages.resolve(error_messages.unsupported_metadata);
|
||||
} else {
|
||||
std::string error_message =
|
||||
AdvanceIOBufferTo(error_messages, input, io_buf, r.min_incl);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
|
||||
while (true) {
|
||||
uint64_t n =
|
||||
wuffs_base__u64__min(num_to_copy, io_buf.reader_length());
|
||||
memcpy(raw.m_buf.writer_pointer(), io_buf.reader_pointer(), n);
|
||||
raw.m_buf.meta.wi += n;
|
||||
io_buf.meta.ri += n;
|
||||
num_to_copy -= n;
|
||||
if (num_to_copy == 0) {
|
||||
break;
|
||||
} else if (io_buf.meta.closed) {
|
||||
return error_messages.resolve(
|
||||
error_messages.unexpected_end_of_file);
|
||||
} else if (!input.BringsItsOwnIOBuffer()) {
|
||||
io_buf.compact();
|
||||
}
|
||||
std::string error_message = input.CopyIn(&io_buf);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
return error_messages.resolve(error_messages.unsupported_metadata);
|
||||
}
|
||||
|
||||
if (status.repr == nullptr) {
|
||||
break;
|
||||
} else if (status.repr != wuffs_base__suspension__even_more_information) {
|
||||
if (status.repr != wuffs_base__suspension__short_write) {
|
||||
return status.message();
|
||||
}
|
||||
switch (raw.grow(wuffs_base__u64__sat_add(raw.m_buf.data.len, 1))) {
|
||||
case sync_io::DynIOBuffer::GrowResult::OK:
|
||||
break;
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedMaxInclExceeded:
|
||||
return error_messages.resolve(
|
||||
error_messages.max_incl_metadata_length_exceeded);
|
||||
case sync_io::DynIOBuffer::GrowResult::FailedOutOfMemory:
|
||||
return error_messages.resolve(error_messages.out_of_memory);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (*handle_metadata_func)(handle_metadata_receiver, &minfo,
|
||||
raw.m_buf.reader_slice());
|
||||
}
|
||||
|
||||
} // namespace private_impl
|
||||
|
||||
} // namespace wuffs_aux
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) ||
|
||||
@@ -39291,10 +42540,21 @@ DecodeCborCallbacks::Done(DecodeCborResult& result,
|
||||
sync_io::Input& input,
|
||||
IOBuffer& buffer) {}
|
||||
|
||||
DecodeCborArgQuirks::DecodeCborArgQuirks(wuffs_base__slice_u32 repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeCborArgQuirks::DecodeCborArgQuirks(uint32_t* ptr0, size_t len0)
|
||||
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
|
||||
|
||||
DecodeCborArgQuirks //
|
||||
DecodeCborArgQuirks::DefaultValue() {
|
||||
return DecodeCborArgQuirks(wuffs_base__empty_slice_u32());
|
||||
}
|
||||
|
||||
DecodeCborResult //
|
||||
DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks) {
|
||||
DecodeCborArgQuirks quirks) {
|
||||
// Prepare the wuffs_base__io_buffer and the resultant error_message.
|
||||
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
|
||||
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
|
||||
@@ -39314,11 +42574,11 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
// Prepare the low-level CBOR decoder.
|
||||
wuffs_cbor__decoder::unique_ptr dec = wuffs_cbor__decoder::alloc();
|
||||
if (!dec) {
|
||||
ret_error_message = "wuffs_aux::CborDecoder: out of memory";
|
||||
ret_error_message = "wuffs_aux::DecodeCbor: out of memory";
|
||||
goto done;
|
||||
}
|
||||
for (size_t i = 0; i < quirks.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.ptr[i], true);
|
||||
for (size_t i = 0; i < quirks.repr.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
|
||||
}
|
||||
|
||||
// Prepare the wuffs_base__tok_buffer. 256 tokens is 2KiB.
|
||||
@@ -39329,7 +42589,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
wuffs_base__status tok_status = wuffs_base__make_status(nullptr);
|
||||
|
||||
// Prepare other state.
|
||||
uint32_t depth = 0;
|
||||
int32_t depth = 0;
|
||||
std::string str;
|
||||
int64_t extension_category = 0;
|
||||
uint64_t extension_detail = 0;
|
||||
@@ -39356,17 +42616,17 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
goto done;
|
||||
} else if (cursor_index != io_buf->meta.ri) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad cursor_index";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad cursor_index";
|
||||
goto done;
|
||||
} else if (io_buf->meta.closed) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: io_buf is closed";
|
||||
"wuffs_aux::DecodeCbor: internal error: io_buf is closed";
|
||||
goto done;
|
||||
}
|
||||
io_buf->compact();
|
||||
if (io_buf->meta.wi >= io_buf->data.len) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: io_buf is full";
|
||||
"wuffs_aux::DecodeCbor: internal error: io_buf is full";
|
||||
goto done;
|
||||
}
|
||||
cursor_index = io_buf->meta.ri;
|
||||
@@ -39378,11 +42638,19 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
|
||||
if (WUFFS_CBOR__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE != 0) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad WORKBUF_LEN";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad WORKBUF_LEN";
|
||||
goto done;
|
||||
}
|
||||
wuffs_base__slice_u8 work_buf = wuffs_base__empty_slice_u8();
|
||||
tok_status = dec->decode_tokens(&tok_buf, io_buf, work_buf);
|
||||
if ((tok_buf.meta.ri > tok_buf.meta.wi) ||
|
||||
(tok_buf.meta.wi > tok_buf.data.len) ||
|
||||
(io_buf->meta.ri > io_buf->meta.wi) ||
|
||||
(io_buf->meta.wi > io_buf->data.len)) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeCbor: internal error: bad buffer indexes";
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++];
|
||||
@@ -39390,7 +42658,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
if ((io_buf->meta.ri < cursor_index) ||
|
||||
((io_buf->meta.ri - cursor_index) < token_len)) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad token indexes";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad token indexes";
|
||||
goto done;
|
||||
}
|
||||
uint8_t* token_ptr = io_buf->data.ptr + cursor_index;
|
||||
@@ -39426,7 +42694,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
}
|
||||
}
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: bad extended token";
|
||||
"wuffs_aux::DecodeCbor: internal error: bad extended token";
|
||||
goto done;
|
||||
}
|
||||
|
||||
@@ -39441,10 +42709,20 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
goto done;
|
||||
}
|
||||
depth++;
|
||||
if (depth > WUFFS_CBOR__DECODER_DEPTH_MAX_INCL) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeCbor: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
|
||||
depth--;
|
||||
if (depth < 0) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeCbor: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
goto parsed_a_value;
|
||||
}
|
||||
|
||||
@@ -39581,7 +42859,7 @@ DecodeCbor(DecodeCborCallbacks& callbacks,
|
||||
|
||||
fail:
|
||||
ret_error_message =
|
||||
"wuffs_aux::CborDecoder: internal error: unexpected token";
|
||||
"wuffs_aux::DecodeCbor: internal error: unexpected token";
|
||||
goto done;
|
||||
|
||||
parsed_a_value:
|
||||
@@ -39685,6 +42963,12 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
|
||||
return wuffs_base__image_decoder::unique_ptr(nullptr, &free);
|
||||
}
|
||||
|
||||
std::string //
|
||||
DecodeImageCallbacks::HandleMetadata(const wuffs_base__more_information& minfo,
|
||||
wuffs_base__slice_u8 raw) {
|
||||
return "";
|
||||
}
|
||||
|
||||
wuffs_base__pixel_format //
|
||||
DecodeImageCallbacks::SelectPixfmt(
|
||||
const wuffs_base__image_config& image_config) {
|
||||
@@ -39749,12 +43033,16 @@ const char DecodeImage_BufferIsTooShort[] = //
|
||||
"wuffs_aux::DecodeImage: buffer is too short";
|
||||
const char DecodeImage_MaxInclDimensionExceeded[] = //
|
||||
"wuffs_aux::DecodeImage: max_incl_dimension exceeded";
|
||||
const char DecodeImage_MaxInclMetadataLengthExceeded[] = //
|
||||
"wuffs_aux::DecodeImage: max_incl_metadata_length exceeded";
|
||||
const char DecodeImage_OutOfMemory[] = //
|
||||
"wuffs_aux::DecodeImage: out of memory";
|
||||
const char DecodeImage_UnexpectedEndOfFile[] = //
|
||||
"wuffs_aux::DecodeImage: unexpected end of file";
|
||||
const char DecodeImage_UnsupportedImageFormat[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported image format";
|
||||
const char DecodeImage_UnsupportedMetadata[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported metadata";
|
||||
const char DecodeImage_UnsupportedPixelBlend[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported pixel blend";
|
||||
const char DecodeImage_UnsupportedPixelConfiguration[] = //
|
||||
@@ -39762,38 +43050,105 @@ const char DecodeImage_UnsupportedPixelConfiguration[] = //
|
||||
const char DecodeImage_UnsupportedPixelFormat[] = //
|
||||
"wuffs_aux::DecodeImage: unsupported pixel format";
|
||||
|
||||
DecodeImageArgQuirks::DecodeImageArgQuirks(wuffs_base__slice_u32 repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgQuirks::DecodeImageArgQuirks(uint32_t* ptr0, size_t len0)
|
||||
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
|
||||
|
||||
DecodeImageArgQuirks //
|
||||
DecodeImageArgQuirks::DefaultValue() {
|
||||
return DecodeImageArgQuirks(wuffs_base__empty_slice_u32());
|
||||
}
|
||||
|
||||
DecodeImageArgFlags::DecodeImageArgFlags(uint64_t repr0) : repr(repr0) {}
|
||||
|
||||
DecodeImageArgFlags //
|
||||
DecodeImageArgFlags::DefaultValue() {
|
||||
return DecodeImageArgFlags(0);
|
||||
}
|
||||
|
||||
DecodeImageArgPixelBlend::DecodeImageArgPixelBlend(
|
||||
wuffs_base__pixel_blend repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgPixelBlend //
|
||||
DecodeImageArgPixelBlend::DefaultValue() {
|
||||
return DecodeImageArgPixelBlend(WUFFS_BASE__PIXEL_BLEND__SRC);
|
||||
}
|
||||
|
||||
DecodeImageArgBackgroundColor::DecodeImageArgBackgroundColor(
|
||||
wuffs_base__color_u32_argb_premul repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgBackgroundColor //
|
||||
DecodeImageArgBackgroundColor::DefaultValue() {
|
||||
return DecodeImageArgBackgroundColor(1);
|
||||
}
|
||||
|
||||
DecodeImageArgMaxInclDimension::DecodeImageArgMaxInclDimension(uint32_t repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgMaxInclDimension //
|
||||
DecodeImageArgMaxInclDimension::DefaultValue() {
|
||||
return DecodeImageArgMaxInclDimension(1048575);
|
||||
}
|
||||
|
||||
DecodeImageArgMaxInclMetadataLength::DecodeImageArgMaxInclMetadataLength(
|
||||
uint64_t repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeImageArgMaxInclMetadataLength //
|
||||
DecodeImageArgMaxInclMetadataLength::DefaultValue() {
|
||||
return DecodeImageArgMaxInclMetadataLength(16777215);
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
namespace {
|
||||
|
||||
const private_impl::ErrorMessages DecodeImageErrorMessages = {
|
||||
DecodeImage_MaxInclMetadataLengthExceeded, //
|
||||
DecodeImage_OutOfMemory, //
|
||||
DecodeImage_UnexpectedEndOfFile, //
|
||||
DecodeImage_UnsupportedMetadata, //
|
||||
DecodeImage_UnsupportedImageFormat, //
|
||||
};
|
||||
|
||||
std::string //
|
||||
DecodeImageAdvanceIOBuf(sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
bool compactable,
|
||||
uint64_t min_excl_pos,
|
||||
uint64_t pos) {
|
||||
if ((pos <= min_excl_pos) || (pos < io_buf.reader_position())) {
|
||||
// Redirects must go forward.
|
||||
return DecodeImage_UnsupportedImageFormat;
|
||||
}
|
||||
while (true) {
|
||||
uint64_t relative_pos = pos - io_buf.reader_position();
|
||||
if (relative_pos <= io_buf.reader_length()) {
|
||||
io_buf.meta.ri += (size_t)relative_pos;
|
||||
break;
|
||||
} else if (io_buf.meta.closed) {
|
||||
return DecodeImage_UnexpectedEndOfFile;
|
||||
}
|
||||
io_buf.meta.ri = io_buf.meta.wi;
|
||||
if (compactable) {
|
||||
io_buf.compact();
|
||||
}
|
||||
std::string error_message = input.CopyIn(&io_buf);
|
||||
if (!error_message.empty()) {
|
||||
return error_message;
|
||||
}
|
||||
}
|
||||
return "";
|
||||
DecodeImageAdvanceIOBufferTo(sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
uint64_t absolute_position) {
|
||||
return private_impl::AdvanceIOBufferTo(DecodeImageErrorMessages, input,
|
||||
io_buf, absolute_position);
|
||||
}
|
||||
|
||||
wuffs_base__status //
|
||||
DIHM0(void* self,
|
||||
wuffs_base__io_buffer* a_dst,
|
||||
wuffs_base__more_information* a_minfo,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
return wuffs_base__image_decoder__tell_me_more(
|
||||
static_cast<wuffs_base__image_decoder*>(self), a_dst, a_minfo, a_src);
|
||||
}
|
||||
|
||||
std::string //
|
||||
DIHM1(void* self,
|
||||
const wuffs_base__more_information* minfo,
|
||||
wuffs_base__slice_u8 raw) {
|
||||
return static_cast<DecodeImageCallbacks*>(self)->HandleMetadata(*minfo, raw);
|
||||
}
|
||||
|
||||
std::string //
|
||||
DecodeImageHandleMetadata(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
sync_io::DynIOBuffer& raw_metadata_buf) {
|
||||
return private_impl::HandleMetadata(DecodeImageErrorMessages, input, io_buf,
|
||||
raw_metadata_buf, DIHM0,
|
||||
static_cast<void*>(image_decoder.get()),
|
||||
DIHM1, static_cast<void*>(&callbacks));
|
||||
}
|
||||
|
||||
DecodeImageResult //
|
||||
@@ -39801,9 +43156,12 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__io_buffer& io_buf,
|
||||
wuffs_base__slice_u32 quirks,
|
||||
uint64_t flags,
|
||||
wuffs_base__pixel_blend pixel_blend,
|
||||
wuffs_base__color_u32_argb_premul background_color,
|
||||
uint32_t max_incl_dimension) {
|
||||
uint32_t max_incl_dimension,
|
||||
uint64_t max_incl_metadata_length) {
|
||||
// Check args.
|
||||
switch (pixel_blend) {
|
||||
case WUFFS_BASE__PIXEL_BLEND__SRC:
|
||||
@@ -39814,6 +43172,7 @@ DecodeImage0(wuffs_base__image_decoder::unique_ptr& image_decoder,
|
||||
}
|
||||
|
||||
wuffs_base__image_config image_config = wuffs_base__null_image_config();
|
||||
sync_io::DynIOBuffer raw_metadata_buf(max_incl_metadata_length);
|
||||
uint64_t start_pos = io_buf.reader_position();
|
||||
bool redirected = false;
|
||||
int32_t fourcc = 0;
|
||||
@@ -39848,8 +43207,12 @@ redirect:
|
||||
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
|
||||
}
|
||||
uint64_t pos = minfo.io_redirect__range().min_incl;
|
||||
std::string error_message = DecodeImageAdvanceIOBuf(
|
||||
input, io_buf, !input.BringsItsOwnIOBuffer(), start_pos, pos);
|
||||
if (pos <= start_pos) {
|
||||
// Redirects must go forward.
|
||||
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
|
||||
}
|
||||
std::string error_message =
|
||||
DecodeImageAdvanceIOBufferTo(input, io_buf, pos);
|
||||
if (!error_message.empty()) {
|
||||
return DecodeImageResult(std::move(error_message));
|
||||
}
|
||||
@@ -39868,6 +43231,36 @@ redirect:
|
||||
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
|
||||
}
|
||||
|
||||
// Apply quirks.
|
||||
for (size_t i = 0; i < quirks.len; i++) {
|
||||
image_decoder->set_quirk_enabled(quirks.ptr[i], true);
|
||||
}
|
||||
|
||||
// Apply flags.
|
||||
if (flags != 0) {
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_CHRM) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_EXIF) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__EXIF, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_GAMA) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__GAMA, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_ICCP) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__ICCP, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_KVP) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__KVP, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_SRGB) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__SRGB, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_XMP) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__XMP, true);
|
||||
}
|
||||
}
|
||||
|
||||
// Decode the image config.
|
||||
while (true) {
|
||||
wuffs_base__status id_dic_status =
|
||||
@@ -39880,6 +43273,12 @@ redirect:
|
||||
}
|
||||
redirected = true;
|
||||
goto redirect;
|
||||
} else if (id_dic_status.repr == wuffs_base__note__metadata_reported) {
|
||||
std::string error_message = DecodeImageHandleMetadata(
|
||||
image_decoder, callbacks, input, io_buf, raw_metadata_buf);
|
||||
if (!error_message.empty()) {
|
||||
return DecodeImageResult(std::move(error_message));
|
||||
}
|
||||
} else if (id_dic_status.repr != wuffs_base__suspension__short_read) {
|
||||
return DecodeImageResult(id_dic_status.message());
|
||||
} else if (io_buf.meta.closed) {
|
||||
@@ -39892,6 +43291,7 @@ redirect:
|
||||
}
|
||||
}
|
||||
} while (false);
|
||||
raw_metadata_buf.drop();
|
||||
|
||||
// Select the pixel format.
|
||||
uint32_t w = image_config.pixcfg.width();
|
||||
@@ -40002,9 +43402,12 @@ redirect:
|
||||
DecodeImageResult //
|
||||
DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__pixel_blend pixel_blend,
|
||||
wuffs_base__color_u32_argb_premul background_color,
|
||||
uint32_t max_incl_dimension) {
|
||||
DecodeImageArgQuirks quirks,
|
||||
DecodeImageArgFlags flags,
|
||||
DecodeImageArgPixelBlend pixel_blend,
|
||||
DecodeImageArgBackgroundColor background_color,
|
||||
DecodeImageArgMaxInclDimension max_incl_dimension,
|
||||
DecodeImageArgMaxInclMetadataLength max_incl_metadata_length) {
|
||||
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
|
||||
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
|
||||
std::unique_ptr<uint8_t[]> fallback_io_array(nullptr);
|
||||
@@ -40017,8 +43420,9 @@ DecodeImage(DecodeImageCallbacks& callbacks,
|
||||
|
||||
wuffs_base__image_decoder::unique_ptr image_decoder(nullptr, &free);
|
||||
DecodeImageResult result =
|
||||
DecodeImage0(image_decoder, callbacks, input, *io_buf, pixel_blend,
|
||||
background_color, max_incl_dimension);
|
||||
DecodeImage0(image_decoder, callbacks, input, *io_buf, quirks.repr,
|
||||
flags.repr, pixel_blend.repr, background_color.repr,
|
||||
max_incl_dimension.repr, max_incl_metadata_length.repr);
|
||||
callbacks.Done(result, input, *io_buf, std::move(image_decoder));
|
||||
return result;
|
||||
}
|
||||
@@ -40048,9 +43452,29 @@ DecodeJsonCallbacks::Done(DecodeJsonResult& result,
|
||||
sync_io::Input& input,
|
||||
IOBuffer& buffer) {}
|
||||
|
||||
const char DecodeJson_BadJsonPointer[] =
|
||||
const char DecodeJson_BadJsonPointer[] = //
|
||||
"wuffs_aux::DecodeJson: bad JSON Pointer";
|
||||
const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
|
||||
const char DecodeJson_NoMatch[] = //
|
||||
"wuffs_aux::DecodeJson: no match";
|
||||
|
||||
DecodeJsonArgQuirks::DecodeJsonArgQuirks(wuffs_base__slice_u32 repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeJsonArgQuirks::DecodeJsonArgQuirks(uint32_t* ptr0, size_t len0)
|
||||
: repr(wuffs_base__make_slice_u32(ptr0, len0)) {}
|
||||
|
||||
DecodeJsonArgQuirks //
|
||||
DecodeJsonArgQuirks::DefaultValue() {
|
||||
return DecodeJsonArgQuirks(wuffs_base__empty_slice_u32());
|
||||
}
|
||||
|
||||
DecodeJsonArgJsonPointer::DecodeJsonArgJsonPointer(std::string repr0)
|
||||
: repr(repr0) {}
|
||||
|
||||
DecodeJsonArgJsonPointer //
|
||||
DecodeJsonArgJsonPointer::DefaultValue() {
|
||||
return DecodeJsonArgJsonPointer(std::string());
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
@@ -40087,6 +43511,14 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
|
||||
} \
|
||||
tok_status = \
|
||||
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8()); \
|
||||
if ((tok_buf.meta.ri > tok_buf.meta.wi) || \
|
||||
(tok_buf.meta.wi > tok_buf.data.len) || \
|
||||
(io_buf->meta.ri > io_buf->meta.wi) || \
|
||||
(io_buf->meta.wi > io_buf->data.len)) { \
|
||||
ret_error_message = \
|
||||
"wuffs_aux::DecodeJson: internal error: bad buffer indexes"; \
|
||||
goto done; \
|
||||
} \
|
||||
} \
|
||||
wuffs_base__token token = tok_buf.data.ptr[tok_buf.meta.ri++]; \
|
||||
uint64_t token_len = token.length(); \
|
||||
@@ -40105,7 +43537,8 @@ const char DecodeJson_NoMatch[] = "wuffs_aux::DecodeJson: no match";
|
||||
namespace {
|
||||
|
||||
// DecodeJson_SplitJsonPointer returns ("bar", 8) for ("/foo/bar/b~1z/qux", 5,
|
||||
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax.
|
||||
// etc). It returns a 0 size_t when s has invalid JSON Pointer syntax or i is
|
||||
// out of bounds.
|
||||
//
|
||||
// The string returned is unescaped. If calling it again, this time with i=8,
|
||||
// the "b~1z" substring would be returned as "b/z".
|
||||
@@ -40114,6 +43547,9 @@ DecodeJson_SplitJsonPointer(std::string& s,
|
||||
size_t i,
|
||||
bool allow_tilde_n_tilde_r_tilde_t) {
|
||||
std::string fragment;
|
||||
if (i > s.size()) {
|
||||
return std::make_pair(std::string(), 0);
|
||||
}
|
||||
while (i < s.size()) {
|
||||
char c = s[i];
|
||||
if (c == '/') {
|
||||
@@ -40320,8 +43756,8 @@ check_that_a_value_follows:
|
||||
continue;
|
||||
}
|
||||
|
||||
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so that
|
||||
// we're only peeking at the next token.
|
||||
// Undo the last part of WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN, so
|
||||
// that we're only peeking at the next token.
|
||||
tok_buf.meta.ri--;
|
||||
cursor_index -= static_cast<size_t>(token_len);
|
||||
|
||||
@@ -40345,8 +43781,8 @@ done:
|
||||
DecodeJsonResult //
|
||||
DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
sync_io::Input& input,
|
||||
wuffs_base__slice_u32 quirks,
|
||||
std::string json_pointer) {
|
||||
DecodeJsonArgQuirks quirks,
|
||||
DecodeJsonArgJsonPointer json_pointer) {
|
||||
// Prepare the wuffs_base__io_buffer and the resultant error_message.
|
||||
wuffs_base__io_buffer* io_buf = input.BringsItsOwnIOBuffer();
|
||||
wuffs_base__io_buffer fallback_io_buf = wuffs_base__empty_io_buffer();
|
||||
@@ -40374,9 +43810,9 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
goto done;
|
||||
}
|
||||
bool allow_tilde_n_tilde_r_tilde_t = false;
|
||||
for (size_t i = 0; i < quirks.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.ptr[i], true);
|
||||
if (quirks.ptr[i] ==
|
||||
for (size_t i = 0; i < quirks.repr.len; i++) {
|
||||
dec->set_quirk_enabled(quirks.repr.ptr[i], true);
|
||||
if (quirks.repr.ptr[i] ==
|
||||
WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T) {
|
||||
allow_tilde_n_tilde_r_tilde_t = true;
|
||||
}
|
||||
@@ -40391,17 +43827,17 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
dec->decode_tokens(&tok_buf, io_buf, wuffs_base__empty_slice_u8());
|
||||
|
||||
// Prepare other state.
|
||||
uint32_t depth = 0;
|
||||
int32_t depth = 0;
|
||||
std::string str;
|
||||
|
||||
// Walk the (optional) JSON Pointer.
|
||||
for (size_t i = 0; i < json_pointer.size();) {
|
||||
if (json_pointer[i] != '/') {
|
||||
for (size_t i = 0; i < json_pointer.repr.size();) {
|
||||
if (json_pointer.repr[i] != '/') {
|
||||
ret_error_message = DecodeJson_BadJsonPointer;
|
||||
goto done;
|
||||
}
|
||||
std::pair<std::string, size_t> split = DecodeJson_SplitJsonPointer(
|
||||
json_pointer, i + 1, allow_tilde_n_tilde_r_tilde_t);
|
||||
json_pointer.repr, i + 1, allow_tilde_n_tilde_r_tilde_t);
|
||||
i = split.second;
|
||||
if (i == 0) {
|
||||
ret_error_message = DecodeJson_BadJsonPointer;
|
||||
@@ -40434,10 +43870,20 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
goto done;
|
||||
}
|
||||
depth++;
|
||||
if (depth > WUFFS_JSON__DECODER_DEPTH_MAX_INCL) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeJson: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
ret_error_message = callbacks.Pop(static_cast<uint32_t>(vbd));
|
||||
depth--;
|
||||
if (depth < 0) {
|
||||
ret_error_message =
|
||||
"wuffs_aux::DecodeJson: internal error: bad depth";
|
||||
goto done;
|
||||
}
|
||||
goto parsed_a_value;
|
||||
}
|
||||
|
||||
@@ -40552,7 +43998,7 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
|
||||
// loop running until WUFFS_AUX__DECODE_JSON__GET_THE_NEXT_TOKEN's
|
||||
// decode_tokens returns an ok status.
|
||||
if (!ret_error_message.empty() ||
|
||||
((depth == 0) && !json_pointer.empty())) {
|
||||
((depth == 0) && !json_pointer.repr.empty())) {
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -175,9 +175,8 @@ main(int argc, char** argv) {
|
||||
// https://play.golang.org/p/IU2T58P00C
|
||||
const uint32_t expected_hash_of_1mib_of_zeroes = 0x00f00001UL;
|
||||
|
||||
int i;
|
||||
int num_bad = 0;
|
||||
for (i = 0; i < num_reps; i++) {
|
||||
for (int i = 0; i < num_reps; i++) {
|
||||
uint32_t actual_hash = calculate_hash(g_buffer, BUFFER_SIZE);
|
||||
if (!g_flags.no_check && (actual_hash != expected_hash_of_1mib_of_zeroes)) {
|
||||
num_bad++;
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -68,6 +68,16 @@
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// If building this program in an environment that doesn't easily accommodate
|
||||
// relative includes, you can use the script/inline-c-relative-includes.go
|
||||
// program to generate a stand-alone C file.
|
||||
@@ -320,8 +330,7 @@ decode(bool frag_dst, bool frag_idat) {
|
||||
struct timeval bench_start_tv;
|
||||
gettimeofday(&bench_start_tv, NULL);
|
||||
|
||||
int i;
|
||||
for (i = 0; i < reps; i++) {
|
||||
for (int i = 0; i < reps; i++) {
|
||||
const char* msg = decode_once(frag_dst, frag_idat);
|
||||
if (msg) {
|
||||
return msg;
|
||||
@@ -387,10 +396,9 @@ main(int argc, char** argv) {
|
||||
"compatible with the\n"
|
||||
"# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install "
|
||||
"it, first\n"
|
||||
"# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n");
|
||||
"# install Go, then run \"go install golang.org/x/perf/cmd/benchstat\".\n");
|
||||
|
||||
int i;
|
||||
for (i = 0; i < 5; i++) {
|
||||
for (int i = 0; i < 5; i++) {
|
||||
msg = decode(true, true);
|
||||
if (msg) {
|
||||
return fail(msg);
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -29,7 +30,6 @@ import (
|
||||
"compress/flate"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"runtime"
|
||||
"time"
|
||||
@@ -62,7 +62,7 @@ var testCases = []testCase{{
|
||||
}}
|
||||
|
||||
func mustLoad(filename string) []byte {
|
||||
src, err := ioutil.ReadFile("../../" + filename)
|
||||
src, err := os.ReadFile("../../" + filename)
|
||||
if err != nil {
|
||||
panic(err.Error())
|
||||
}
|
||||
@@ -81,7 +81,7 @@ func main1() error {
|
||||
fmt.Printf("#\n")
|
||||
fmt.Printf("# The output format, including the \"Benchmark\" prefixes, is compatible with the\n")
|
||||
fmt.Printf("# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install it, first\n")
|
||||
fmt.Printf("# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n")
|
||||
fmt.Printf("# install Go, then run \"go install golang.org/x/perf/cmd/benchstat\".\n")
|
||||
|
||||
for i := -1; i < reps; i++ {
|
||||
for _, tc := range testCases {
|
||||
@@ -117,6 +117,6 @@ func main1() error {
|
||||
func decode(src []byte) (numBytes uint64, retErr error) {
|
||||
r := flate.NewReader(bytes.NewReader(src))
|
||||
defer r.Close()
|
||||
n, err := io.Copy(ioutil.Discard, r)
|
||||
n, err := io.Copy(io.Discard, r)
|
||||
return uint64(n), err
|
||||
}
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -30,7 +31,6 @@ import (
|
||||
"image"
|
||||
"image/draw"
|
||||
"image/gif"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"runtime"
|
||||
"strings"
|
||||
@@ -87,7 +87,7 @@ var testCases = []testCase{{
|
||||
}}
|
||||
|
||||
func mustLoad(filename string) []byte {
|
||||
src, err := ioutil.ReadFile("../../" + filename)
|
||||
src, err := os.ReadFile("../../" + filename)
|
||||
if err != nil {
|
||||
panic(err.Error())
|
||||
}
|
||||
@@ -106,7 +106,7 @@ func main1() error {
|
||||
fmt.Printf("#\n")
|
||||
fmt.Printf("# The output format, including the \"Benchmark\" prefixes, is compatible with the\n")
|
||||
fmt.Printf("# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install it, first\n")
|
||||
fmt.Printf("# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n")
|
||||
fmt.Printf("# install Go, then run \"go install golang.org/x/perf/cmd/benchstat\".\n")
|
||||
|
||||
for i := -1; i < reps; i++ {
|
||||
for _, tc := range testCases {
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -30,7 +31,6 @@ import (
|
||||
"image"
|
||||
"image/draw"
|
||||
"image/png"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"runtime"
|
||||
"strings"
|
||||
@@ -71,7 +71,7 @@ var testCases = []testCase{{
|
||||
}}
|
||||
|
||||
func mustLoad(filename string) []byte {
|
||||
src, err := ioutil.ReadFile("../../" + filename)
|
||||
src, err := os.ReadFile("../../" + filename)
|
||||
if err != nil {
|
||||
panic(err.Error())
|
||||
}
|
||||
@@ -90,7 +90,7 @@ func main1() error {
|
||||
fmt.Printf("#\n")
|
||||
fmt.Printf("# The output format, including the \"Benchmark\" prefixes, is compatible with the\n")
|
||||
fmt.Printf("# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install it, first\n")
|
||||
fmt.Printf("# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n")
|
||||
fmt.Printf("# install Go, then run \"go install golang.org/x/perf/cmd/benchstat\".\n")
|
||||
|
||||
for i := -1; i < reps; i++ {
|
||||
for _, tc := range testCases {
|
||||
|
||||
@@ -32,9 +32,19 @@ save=`git log -1 --pretty=format:"%H"`
|
||||
|
||||
i=0
|
||||
while [ $i -lt $num_commits ]; do
|
||||
this_hash=`git log -1 --pretty=format:"%h"`
|
||||
set +e
|
||||
$cc -O3 -o bench-history.out test/c/std/$package.c
|
||||
this_metric=`./bench-history.out -bench -focus=$focus -iterscale=$iterscale -reps=$reps | benchstat /dev/stdin | sed -ne '/^name.*speed$/,$ p' | grep $focus`
|
||||
if [ $? -ne 0 ]; then
|
||||
this_metric='compile_failed'
|
||||
else
|
||||
this_metric=`./bench-history.out -bench -focus=$focus -iterscale=$iterscale -reps=$reps | benchstat /dev/stdin | sed -ne '/^name.*speed$/,$ p' | grep $focus`
|
||||
if [ $? -ne 0 ]; then
|
||||
this_metric='bench_failed'
|
||||
fi
|
||||
fi
|
||||
set -e
|
||||
|
||||
this_hash=`git log -1 --pretty=format:"%h"`
|
||||
echo $this_hash $this_metric
|
||||
git checkout --quiet HEAD^
|
||||
i=$((i + 1))
|
||||
|
||||
@@ -47,7 +47,7 @@ fn main() {
|
||||
print!("#\n");
|
||||
print!("# The output format, including the \"Benchmark\" prefixes, is compatible with the\n");
|
||||
print!("# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install it, first\n");
|
||||
print!("# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n");
|
||||
print!("# install Go, then run \"go install golang.org/x/perf/cmd/benchstat\".\n");
|
||||
|
||||
let mut dst = vec![0u8; 64 * 1024 * 1024];
|
||||
|
||||
|
||||
@@ -52,7 +52,7 @@ fn main() {
|
||||
print!("#\n");
|
||||
print!("# The output format, including the \"Benchmark\" prefixes, is compatible with the\n");
|
||||
print!("# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install it, first\n");
|
||||
print!("# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n");
|
||||
print!("# install Go, then run \"go install golang.org/x/perf/cmd/benchstat\".\n");
|
||||
|
||||
let mut dst = vec![0u8; 64 * 1024 * 1024];
|
||||
|
||||
|
||||
@@ -45,7 +45,7 @@ fn main() {
|
||||
print!("#\n");
|
||||
print!("# The output format, including the \"Benchmark\" prefixes, is compatible with the\n");
|
||||
print!("# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install it, first\n");
|
||||
print!("# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n");
|
||||
print!("# install Go, then run \"go install golang.org/x/perf/cmd/benchstat\".\n");
|
||||
|
||||
let mut dst0 = vec![0u8; 64 * 1024 * 1024];
|
||||
let mut dst1 = vec![0u8; 64 * 1024 * 1024];
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -33,7 +34,7 @@ import (
|
||||
"crypto/sha256"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"io"
|
||||
"log"
|
||||
"math/rand"
|
||||
"net/http"
|
||||
@@ -484,7 +485,7 @@ func (w worker) work1(u *url.URL, followHTML bool) (e entry, links []*url.URL, f
|
||||
if _, err := os.Stat(filename); os.IsNotExist(err) {
|
||||
log.Printf("worker #%03d: writing %q", w, urlString)
|
||||
os.MkdirAll(filepath.Dir(filename), 0755)
|
||||
if err := ioutil.WriteFile(filename, data, 0644); err != nil {
|
||||
if err := os.WriteFile(filename, data, 0644); err != nil {
|
||||
log.Println(err)
|
||||
return entry{}, nil, true
|
||||
}
|
||||
@@ -508,7 +509,7 @@ func fetch(urlString string) (statusCode uint32, body []byte, retErr error) {
|
||||
}
|
||||
defer res.Body.Close()
|
||||
|
||||
body, err = ioutil.ReadAll(res.Body)
|
||||
body, err = io.ReadAll(res.Body)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -35,7 +36,7 @@ import (
|
||||
"bytes"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"io"
|
||||
"os"
|
||||
)
|
||||
|
||||
@@ -112,7 +113,7 @@ func emit() error {
|
||||
}
|
||||
filename := fmt.Sprintf("cbor-rfc-7049-examples/%02d.cbor", fileNumber)
|
||||
fileNumber++
|
||||
err := ioutil.WriteFile(filename, contents, 0644)
|
||||
err := os.WriteFile(filename, contents, 0644)
|
||||
contents = nil
|
||||
return err
|
||||
}
|
||||
@@ -128,7 +129,7 @@ func readExampleTable() ([]byte, error) {
|
||||
appendixA := []byte("Appendix A. Examples\n\n")
|
||||
ruler := []byte("+------------------------------+------------------------------------+\n")
|
||||
|
||||
src, err := ioutil.ReadAll(os.Stdin)
|
||||
src, err := io.ReadAll(os.Stdin)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -33,7 +34,7 @@ import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"hash/adler32"
|
||||
"io/ioutil"
|
||||
"io"
|
||||
"os"
|
||||
"strings"
|
||||
)
|
||||
@@ -71,7 +72,7 @@ func main1() error {
|
||||
}
|
||||
|
||||
func decode(filename string) error {
|
||||
src, err := ioutil.ReadFile(filename)
|
||||
src, err := os.ReadFile(filename)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -130,7 +131,7 @@ func doWriteDeflate(deflateCompressed []byte, uncompressed []byte, filename stri
|
||||
filename = filename[:len(filename)-3]
|
||||
}
|
||||
filename += ".deflate"
|
||||
if err := ioutil.WriteFile(filename, deflateCompressed, 0666); err != nil {
|
||||
if err := os.WriteFile(filename, deflateCompressed, 0666); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("wrote %s\n", filename)
|
||||
@@ -170,7 +171,7 @@ func doWriteZlib(deflateCompressed []byte, uncompressed []byte, filename string)
|
||||
filename = filename[:len(filename)-3]
|
||||
}
|
||||
filename += ".zlib"
|
||||
if err := ioutil.WriteFile(filename, asZlib, 0666); err != nil {
|
||||
if err := os.WriteFile(filename, asZlib, 0666); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("wrote %s\n", filename)
|
||||
@@ -192,7 +193,7 @@ func readString(src []byte, i int) (int, error) {
|
||||
func checkDeflate(x []byte) ([]byte, error) {
|
||||
rc := flate.NewReader(bytes.NewReader(x))
|
||||
defer rc.Close()
|
||||
x, err := ioutil.ReadAll(rc)
|
||||
x, err := io.ReadAll(rc)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("data is not valid deflate: %v", err)
|
||||
}
|
||||
@@ -205,7 +206,7 @@ func checkZlib(x []byte) ([]byte, error) {
|
||||
return nil, fmt.Errorf("data is not valid zlib: %v", err)
|
||||
}
|
||||
defer rc.Close()
|
||||
x, err = ioutil.ReadAll(rc)
|
||||
x, err = io.ReadAll(rc)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("data is not valid zlib: %v", err)
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -36,7 +37,7 @@ import (
|
||||
"compress/lzw"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
)
|
||||
@@ -90,7 +91,7 @@ func main1() error {
|
||||
filename = fmt.Sprintf("%s-frame-%03d", filename, argIndex)
|
||||
}
|
||||
filename += ".indexes.giflzw"
|
||||
if err := ioutil.WriteFile(filename, frame, 0644); err != nil {
|
||||
if err := os.WriteFile(filename, frame, 0644); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -116,7 +117,7 @@ func main1() error {
|
||||
}
|
||||
|
||||
func extractLZWFrames(filename string) (ret [][]byte, err error) {
|
||||
src, err := ioutil.ReadFile(filename)
|
||||
src, err := os.ReadFile(filename)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -237,7 +238,7 @@ func checkLZW(data []byte) error {
|
||||
}
|
||||
rc := lzw.NewReader(bytes.NewReader(data[1:]), lzw.LSB, int(data[0]))
|
||||
defer rc.Close()
|
||||
_, err := ioutil.ReadAll(rc)
|
||||
_, err := io.ReadAll(rc)
|
||||
if err != nil {
|
||||
return fmt.Errorf("block data is not valid LZW: %v", err)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
// Copyright 2021 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.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
// extract-nia-frames.go extracts the individual frames from a NIA animation,
|
||||
// writing them out as NIE images.
|
||||
//
|
||||
// Usage: go run extract-nia-frames.go foo.nia bar/baz.nia
|
||||
//
|
||||
// This will write new files:
|
||||
// - foo.000000.nie
|
||||
// - foo.000001.nie
|
||||
// - foo.000002.nie
|
||||
// - foo.000003.nie
|
||||
// - etc
|
||||
// - bar/baz.000000.nie
|
||||
// - bar/baz.000001.nie
|
||||
// - etc
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
)
|
||||
|
||||
var (
|
||||
dryRun = flag.Bool("dry-run", false, "just print metadata; don't write NIE files")
|
||||
)
|
||||
|
||||
func main() {
|
||||
if err := main1(); err != nil {
|
||||
os.Stderr.WriteString(err.Error() + "\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func main1() error {
|
||||
flag.Parse()
|
||||
for _, a := range flag.Args() {
|
||||
if err := extract(a); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func extract(srcFilename string) error {
|
||||
fmt.Printf("Extract %s\n", srcFilename)
|
||||
f, err := os.Open(srcFilename)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer f.Close()
|
||||
r := bufio.NewReader(f)
|
||||
|
||||
dstFilenamePrefix := srcFilename[:len(srcFilename)-len(filepath.Ext(srcFilename))]
|
||||
|
||||
buf := [16]byte{}
|
||||
if _, err := io.ReadFull(r, buf[:16]); err != nil {
|
||||
return err
|
||||
}
|
||||
depth8 := buf[7] == '8'
|
||||
width := u32le(buf[8:])
|
||||
height := u32le(buf[12:])
|
||||
padded := !depth8 && ((width & 1) != 0) && ((height & 1) != 0)
|
||||
if (u32le(buf[:]) != 0x41AF_C36E) || // 0x41AF_C36E is 'nïA'le.
|
||||
(buf[4] != 0xFF) ||
|
||||
(buf[5] != 'b') ||
|
||||
((buf[6] != 'n') && (buf[6] != 'p')) ||
|
||||
((buf[7] != '4') && (buf[7] != '8')) ||
|
||||
(width >= 0x8000_0000) ||
|
||||
(height >= 0x8000_0000) {
|
||||
return errors.New("bad NIA header")
|
||||
}
|
||||
fmt.Printf(" Config v1-b%c%c\n", buf[6], buf[7])
|
||||
fmt.Printf(" Width %d\n", width)
|
||||
fmt.Printf(" Height %d\n", height)
|
||||
|
||||
nieSize := calculateNIESize(depth8, width, height)
|
||||
if nieSize < 0 {
|
||||
return errors.New("unsupported NIA (image dimensions are too large)")
|
||||
}
|
||||
|
||||
prevCDD := uint64(0)
|
||||
for frameIndex := uint64(0); ; frameIndex++ {
|
||||
if _, err := io.ReadFull(r, buf[:8]); err != nil {
|
||||
return err
|
||||
}
|
||||
cdd := u64le(buf[:])
|
||||
if (cdd >> 32) == 0x8000_0000 {
|
||||
fmt.Printf(" LoopCount %d\n", uint32(cdd))
|
||||
break
|
||||
} else if ((cdd >> 32) > 0x8000_0000) || (cdd < prevCDD) {
|
||||
return errors.New("bad CDD (Cumulative Display Duration)")
|
||||
}
|
||||
fmt.Printf(" CDD %16d flicks = %8g seconds; delta = %8g seconds\n",
|
||||
cdd,
|
||||
float64(cdd)/705_600000,
|
||||
float64(cdd-prevCDD)/705_600000,
|
||||
)
|
||||
prevCDD = cdd
|
||||
|
||||
dstFilename := fmt.Sprintf("%s.%06d.nie", dstFilenamePrefix, frameIndex)
|
||||
if err := extract1(dstFilename, r, int64(nieSize)); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if padded {
|
||||
if _, err := io.ReadFull(r, buf[:4]); err != nil {
|
||||
return err
|
||||
} else if u32le(buf[:]) != 0 {
|
||||
return errors.New("bad padding")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func calculateNIESize(depth8 bool, width uint32, height uint32) int64 {
|
||||
const maxInt64 = (1 << 63) - 1
|
||||
const maxUint64 = (1 << 64) - 1
|
||||
|
||||
n := uint64(width) * uint64(height) * 4
|
||||
if depth8 {
|
||||
if n > (maxUint64 / 2) {
|
||||
return -1
|
||||
}
|
||||
n *= 2
|
||||
}
|
||||
if n > (maxInt64 - 16) {
|
||||
return -1
|
||||
}
|
||||
return int64(n + 16)
|
||||
}
|
||||
|
||||
func extract1(dstFilename string, r *bufio.Reader, nieSize int64) error {
|
||||
if *dryRun {
|
||||
fmt.Printf(" DryRun %s\n", dstFilename)
|
||||
_, err := io.CopyN(io.Discard, r, nieSize)
|
||||
return err
|
||||
}
|
||||
|
||||
fmt.Printf(" Write %s\n", dstFilename)
|
||||
f, err := os.Create(dstFilename)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err1 := io.CopyN(f, r, nieSize)
|
||||
err2 := f.Close()
|
||||
if err1 != nil {
|
||||
return err1
|
||||
}
|
||||
return err2
|
||||
}
|
||||
|
||||
func u32le(b []byte) uint32 {
|
||||
return (uint32(b[0]) << 0) |
|
||||
(uint32(b[1]) << 8) |
|
||||
(uint32(b[2]) << 16) |
|
||||
(uint32(b[3]) << 24)
|
||||
}
|
||||
|
||||
func u64le(b []byte) uint64 {
|
||||
return (uint64(b[0]) << 0) |
|
||||
(uint64(b[1]) << 8) |
|
||||
(uint64(b[2]) << 16) |
|
||||
(uint64(b[3]) << 24) |
|
||||
(uint64(b[4]) << 32) |
|
||||
(uint64(b[5]) << 40) |
|
||||
(uint64(b[6]) << 48) |
|
||||
(uint64(b[7]) << 56)
|
||||
}
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -29,7 +30,6 @@ import (
|
||||
"image"
|
||||
"image/gif"
|
||||
"image/png"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"path/filepath"
|
||||
)
|
||||
@@ -60,12 +60,12 @@ func main1() error {
|
||||
}
|
||||
}
|
||||
if bPalette != nil {
|
||||
if err := ioutil.WriteFile(baseFilename+".palette", bPalette, 0644); err != nil {
|
||||
if err := os.WriteFile(baseFilename+".palette", bPalette, 0644); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if bIndexes != nil {
|
||||
if err := ioutil.WriteFile(baseFilename+".indexes", bIndexes, 0644); err != nil {
|
||||
if err := os.WriteFile(baseFilename+".indexes", bIndexes, 0644); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -25,8 +26,10 @@ package main
|
||||
import (
|
||||
"bytes"
|
||||
"compress/lzw"
|
||||
"compress/zlib"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"hash/crc32"
|
||||
"io"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
@@ -54,7 +57,7 @@ func main() {
|
||||
}
|
||||
|
||||
func main1() error {
|
||||
stdin, err := ioutil.ReadAll(os.Stdin)
|
||||
stdin, err := io.ReadAll(os.Stdin)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -137,6 +140,10 @@ func appendU16LE(b []byte, u uint16) []byte {
|
||||
return append(b, uint8(u), uint8(u>>8))
|
||||
}
|
||||
|
||||
func appendU32BE(b []byte, u uint32) []byte {
|
||||
return append(b, uint8(u>>24), uint8(u>>16), uint8(u>>8), uint8(u))
|
||||
}
|
||||
|
||||
func log2(u uint32) (i int32) {
|
||||
for i, pow := uint32(0), uint32(1); i < 32; i, pow = i+1, pow<<1 {
|
||||
if u == pow {
|
||||
@@ -580,20 +587,20 @@ func stateDeflateDynamicHuffman(line string) (stateFunc, error) {
|
||||
return stateDeflateDynamicHuffman, nil
|
||||
|
||||
} else if l, d, ok := deflateParseLenDist(line); ok {
|
||||
if (l != 3) || (d != 2) {
|
||||
return nil, fmt.Errorf("TODO: support len/dist pairs for dynamic Huffman blocks")
|
||||
if (l > 10) || (d > 4) {
|
||||
return nil, fmt.Errorf("TODO: support len/dist ExtraBits > 0 for dynamic Huffman blocks")
|
||||
}
|
||||
// len 3 is code 257, with no extra bits.
|
||||
if s := g.huffmans[2][257]; s != "" {
|
||||
// len 3 is code 257, len 4 is code 258, etc. All with no ExtraBits.
|
||||
if s := g.huffmans[2][l+254]; s != "" {
|
||||
deflateGlobalsWriteDynamicHuffmanBits(s)
|
||||
} else {
|
||||
return nil, fmt.Errorf("no code for literal/length symbol 257")
|
||||
return nil, fmt.Errorf("no code for literal/length symbol %d", l+254)
|
||||
}
|
||||
// dist 2 is code 1, with no extra bits.
|
||||
if s := g.huffmans[3][1]; s != "" {
|
||||
// dist 1 is code 0, dist 2 is code 1, etc. All with no ExtraBits.
|
||||
if s := g.huffmans[3][d-1]; s != "" {
|
||||
deflateGlobalsWriteDynamicHuffmanBits(s)
|
||||
} else {
|
||||
return nil, fmt.Errorf("no code for distance symbol 2")
|
||||
return nil, fmt.Errorf("no code for distance symbol %d", d-1)
|
||||
}
|
||||
return stateDeflateDynamicHuffman, nil
|
||||
|
||||
@@ -1219,3 +1226,106 @@ func stateGifFramePalette(line string) (stateFunc, error) {
|
||||
|
||||
return nil, fmt.Errorf("bad stateGifFramePalette command: %q", line)
|
||||
}
|
||||
|
||||
// ----
|
||||
|
||||
func init() {
|
||||
formats["png"] = statePng
|
||||
}
|
||||
|
||||
var pngGlobals struct {
|
||||
scratch [4]byte
|
||||
|
||||
animSeqNum uint32
|
||||
chunkData bytes.Buffer
|
||||
chunkType string
|
||||
zlibWriter *zlib.Writer
|
||||
}
|
||||
|
||||
func statePng(line string) (stateFunc, error) {
|
||||
g := &pngGlobals
|
||||
switch {
|
||||
case line == "":
|
||||
return statePng, nil
|
||||
|
||||
case line == "magic":
|
||||
out = append(out, "\x89PNG\x0D\x0A\x1A\x0A"...)
|
||||
return statePng, nil
|
||||
|
||||
case (len(line) == 6) && (line[4] == ' ') && (line[5] == '{'):
|
||||
g.chunkData.Reset()
|
||||
g.chunkType = line[:4]
|
||||
return statePngChunk, nil
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("bad statePng command: %q", line)
|
||||
}
|
||||
|
||||
func statePngChunk(line string) (stateFunc, error) {
|
||||
g := &pngGlobals
|
||||
if line == "}" {
|
||||
if n := g.chunkData.Len(); n > 0xFFFF_FFFF {
|
||||
return nil, fmt.Errorf("chunkData is too long")
|
||||
}
|
||||
out = appendU32BE(out, uint32(g.chunkData.Len()))
|
||||
n := len(out)
|
||||
out = append(out, g.chunkType...)
|
||||
out = append(out, g.chunkData.Bytes()...)
|
||||
out = appendU32BE(out, crc32.ChecksumIEEE(out[n:]))
|
||||
return statePng, nil
|
||||
}
|
||||
|
||||
switch {
|
||||
case line == "animSeqNum++":
|
||||
g.chunkData.Write(appendU32BE(g.scratch[:0], g.animSeqNum))
|
||||
g.animSeqNum++
|
||||
return statePngChunk, nil
|
||||
|
||||
case line == "raw {":
|
||||
return statePngRaw, nil
|
||||
|
||||
case line == "zlib {":
|
||||
g.zlibWriter = zlib.NewWriter(&g.chunkData)
|
||||
return statePngZlib, nil
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("bad statePngChunk command: %q", line)
|
||||
}
|
||||
|
||||
func statePngRaw(line string) (stateFunc, error) {
|
||||
g := &pngGlobals
|
||||
if line == "}" {
|
||||
return statePngChunk, nil
|
||||
}
|
||||
|
||||
for s := line; s != ""; {
|
||||
if x, remaining, ok := parseHex(s); ok {
|
||||
g.chunkData.WriteByte(byte(x))
|
||||
s = remaining
|
||||
} else {
|
||||
return nil, fmt.Errorf("bad statePngRaw command: %q", line)
|
||||
}
|
||||
}
|
||||
return statePngRaw, nil
|
||||
}
|
||||
|
||||
func statePngZlib(line string) (stateFunc, error) {
|
||||
g := &pngGlobals
|
||||
if line == "}" {
|
||||
if err := g.zlibWriter.Close(); err != nil {
|
||||
return nil, fmt.Errorf("statePngZlib: %w", err)
|
||||
}
|
||||
return statePngChunk, nil
|
||||
}
|
||||
|
||||
for s := line; s != ""; {
|
||||
if x, remaining, ok := parseHex(s); ok {
|
||||
g.scratch[0] = byte(x)
|
||||
g.zlibWriter.Write(g.scratch[:1])
|
||||
s = remaining
|
||||
} else {
|
||||
return nil, fmt.Errorf("bad statePngZlib command: %q", line)
|
||||
}
|
||||
}
|
||||
return statePngZlib, nil
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
// Copyright 2021 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.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
// make-red-blue-gradient.go makes a simple PNG image with optional color
|
||||
// correction chunks.
|
||||
//
|
||||
// Usage: go run make-red-blue-gradient.go > foo.png
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"compress/zlib"
|
||||
"errors"
|
||||
"flag"
|
||||
"hash/crc32"
|
||||
"image"
|
||||
"image/color"
|
||||
"image/png"
|
||||
"math"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var (
|
||||
checkerboard = flag.Bool("checkerboard", false, "Create a checkerboard pattern instead")
|
||||
gama = flag.Float64("gama", 0, "Gamma correction value (e.g. 2.2)")
|
||||
iccp = flag.String("iccp", "", "ICC filename (e.g. foo/bar.icc)")
|
||||
)
|
||||
|
||||
func main() {
|
||||
if err := main1(); err != nil {
|
||||
os.Stderr.WriteString(err.Error() + "\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func main1() error {
|
||||
flag.Parse()
|
||||
|
||||
// Make a checkerboard or red-blue gradient.
|
||||
src := image.Image(nil)
|
||||
if *checkerboard {
|
||||
// With -gama=1.0 (or -gama=2.2), the two halves of this image should
|
||||
// have roughly equal (or un-equal) brightness.
|
||||
m := image.NewGray(image.Rect(0, 0, 256, 256))
|
||||
for y := 0; y < 256; y++ {
|
||||
for x := 0; x < 256; x++ {
|
||||
if x < 128 {
|
||||
m.SetGray(x, y, color.Gray{0x80})
|
||||
} else if ((x ^ y) & 1) == 1 {
|
||||
m.SetGray(x, y, color.Gray{0xFF})
|
||||
} else {
|
||||
m.SetGray(x, y, color.Gray{0x00})
|
||||
}
|
||||
}
|
||||
}
|
||||
src = m
|
||||
} else {
|
||||
m := image.NewRGBA(image.Rect(0, 0, 256, 256))
|
||||
for y := 0; y < 256; y++ {
|
||||
for x := 0; x < 256; x++ {
|
||||
m.SetRGBA(x, y, color.RGBA{
|
||||
R: uint8(x),
|
||||
G: 0x00,
|
||||
B: uint8(y),
|
||||
A: 0xFF,
|
||||
})
|
||||
}
|
||||
}
|
||||
src = m
|
||||
}
|
||||
|
||||
// Encode to PNG.
|
||||
buf := &bytes.Buffer{}
|
||||
png.Encode(buf, src)
|
||||
original := buf.Bytes()
|
||||
|
||||
// Split the encoding into a magic+IHDR prefix and an IDAT+IEND suffix. The
|
||||
// starting magic number is 8 bytes long. The IHDR chunk is 25 bytes long.
|
||||
prefix, suffix := original[:33], original[33:]
|
||||
out := []byte(nil)
|
||||
out = append(out, prefix...)
|
||||
|
||||
// Insert the optional chunks between the prefix and suffix.
|
||||
|
||||
if *gama > 0 {
|
||||
g := uint32(math.Round(100000 / *gama))
|
||||
out = appendPNGChunk(out, "gAMA",
|
||||
byte(g>>24),
|
||||
byte(g>>16),
|
||||
byte(g>>8),
|
||||
byte(g>>0),
|
||||
)
|
||||
}
|
||||
|
||||
if *iccp != "" {
|
||||
raw, err := os.ReadFile(*iccp)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
name, err := iccpName(*iccp)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
data := &bytes.Buffer{}
|
||||
data.WriteString(name)
|
||||
data.WriteByte(0x00) // The name is NUL terminated.
|
||||
data.WriteByte(0x00) // 0x00 means zlib compression.
|
||||
w := zlib.NewWriter(data)
|
||||
w.Write(raw)
|
||||
w.Close()
|
||||
out = appendPNGChunk(out, "iCCP", data.Bytes()...)
|
||||
}
|
||||
|
||||
// Append the suffix and write to stdout.
|
||||
out = append(out, suffix...)
|
||||
_, err := os.Stdout.Write(out)
|
||||
return err
|
||||
}
|
||||
|
||||
func appendPNGChunk(b []byte, name string, chunk ...byte) []byte {
|
||||
n := uint32(len(chunk))
|
||||
b = append(b,
|
||||
byte(n>>24),
|
||||
byte(n>>16),
|
||||
byte(n>>8),
|
||||
byte(n>>0),
|
||||
)
|
||||
b = append(b, name...)
|
||||
b = append(b, chunk...)
|
||||
hasher := crc32.NewIEEE()
|
||||
hasher.Write([]byte(name))
|
||||
hasher.Write(chunk)
|
||||
c := hasher.Sum32()
|
||||
return append(b,
|
||||
byte(c>>24),
|
||||
byte(c>>16),
|
||||
byte(c>>8),
|
||||
byte(c>>0),
|
||||
)
|
||||
}
|
||||
|
||||
// iccpName determines a "bar" iCCP profile name (that satisifes the PNG
|
||||
// specification re the iCCP chunk) based on the "foo/bar.icc" filename.
|
||||
func iccpName(filename string) (string, error) {
|
||||
s := filepath.Base(filename)
|
||||
if i := strings.IndexByte(s, '.'); i >= 0 {
|
||||
s = s[:i]
|
||||
}
|
||||
s = strings.TrimSpace(s)
|
||||
if strings.Index(s, " ") >= 0 {
|
||||
return "", errors.New("ICCP name cannot contain consecutive spaces")
|
||||
} else if (len(s) < 1) || (79 < len(s)) {
|
||||
return "", errors.New("ICCP name has invalid length.")
|
||||
}
|
||||
for i := 0; i < len(s); i++ {
|
||||
if (s[i] < ' ') || ('~' < s[i]) {
|
||||
// Strictly speaking, the PNG specification allows the iCCP name to
|
||||
// be printable Latin-1, not just printable ASCII, but printable
|
||||
// ASCII is easier and avoids any later Latin-1 vs UTF-8 ambiguity.
|
||||
return "", errors.New("ICCP name is not printable ASCII")
|
||||
}
|
||||
}
|
||||
return s, nil
|
||||
}
|
||||
@@ -37,6 +37,16 @@
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
// Deprecated: unused as of commit 695a6815 "Remove gif.config_decoder".
|
||||
@@ -110,7 +111,6 @@ import (
|
||||
"bytes"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
@@ -166,7 +166,7 @@ func main1() error {
|
||||
sort.Strings(sortedFilenames)
|
||||
for _, filename := range sortedFilenames {
|
||||
contents := globalTargets[filename]
|
||||
if x, err := ioutil.ReadFile(filename); (err == nil) && bytes.Equal(x, contents) {
|
||||
if x, err := os.ReadFile(filename); (err == nil) && bytes.Equal(x, contents) {
|
||||
fmt.Printf("gen unchanged: %s\n", filename)
|
||||
|
||||
continue
|
||||
@@ -240,7 +240,7 @@ type filter struct {
|
||||
}
|
||||
|
||||
func do(filename string) error {
|
||||
src, err := ioutil.ReadFile(filename)
|
||||
src, err := os.ReadFile(filename)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -395,7 +395,7 @@ func wuffsfmt(src []byte) []byte {
|
||||
const chmodSupported = runtime.GOOS != "windows"
|
||||
|
||||
func writeFile(filename string, b []byte) error {
|
||||
f, err := ioutil.TempFile(filepath.Dir(filename), filepath.Base(filename))
|
||||
f, err := os.CreateTemp(filepath.Dir(filename), filepath.Base(filename))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -73,6 +73,16 @@
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
@@ -302,8 +312,7 @@ main1(int argc, char** argv) {
|
||||
WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE,
|
||||
0,
|
||||
};
|
||||
uint32_t i;
|
||||
for (i = 0; quirks[i]; i++) {
|
||||
for (uint32_t i = 0; quirks[i]; i++) {
|
||||
wuffs_base__token_decoder__set_quirk_enabled(g_dec, quirks[i], true);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -37,13 +38,12 @@ import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"gopkg.in/russross/blackfriday.v2"
|
||||
"github.com/russross/blackfriday/v2"
|
||||
)
|
||||
|
||||
var skiphttp = flag.Bool("skiphttp", false, `skip "http:" or "https:" links`)
|
||||
@@ -105,7 +105,7 @@ func main1() error {
|
||||
}
|
||||
|
||||
func visit(r *renderer, filename string) error {
|
||||
src, err := ioutil.ReadFile(filename)
|
||||
src, err := os.ReadFile(filename)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
#!/bin/bash -eu
|
||||
# Copyright 2021 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.
|
||||
|
||||
# ----------------
|
||||
|
||||
# This script prints the CRC-32 checksum of the decoded pixels (in the NIA
|
||||
# format, see doc/spec/nie-spec.md) of every image given as a command line
|
||||
# argument: if a file then itself, if a directory then the files under it. It
|
||||
# skips any non-image file found (non-image meaning not decodable by Wuffs'
|
||||
# standard library).
|
||||
#
|
||||
# It is not perfect. It can have false positives and false negatives.
|
||||
# Nonetheless, running it regularly (compiled against the in-development
|
||||
# release/c/wuffs-unsupported-snapshot.c) can help detect regressions.
|
||||
#
|
||||
# "False positive" means that a non-image file can produce a non-zero checksum.
|
||||
# Any file (containing binary data) starting with two '\x00' NUL bytes can
|
||||
# sometimes be mistaken for a WBMP-formatted image file.
|
||||
#
|
||||
# "False negative" means that an image file that produces an all-zero checksum
|
||||
# will be skipped.
|
||||
|
||||
if [ ! -e wuffs-root-directory.txt ]; then
|
||||
echo "$0 should be run from the Wuffs root directory."
|
||||
exit 1
|
||||
elif [ ! -e gen/bin/example-convert-to-nia ]; then
|
||||
echo "Run \"./build-example.sh example/convert-to-nia\" first."
|
||||
exit 1
|
||||
elif [ ! -e gen/bin/example-crc32 ]; then
|
||||
echo "Run \"./build-example.sh example/crc32\" first."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
sources=$@
|
||||
if [ $# -eq 0 ]; then
|
||||
sources=test/data
|
||||
fi
|
||||
|
||||
# ----
|
||||
|
||||
handle() {
|
||||
local c=$(gen/bin/example-convert-to-nia <$1 2>/dev/null | gen/bin/example-crc32)
|
||||
if [ "$c" != "00000000" ]; then
|
||||
echo $c $1
|
||||
fi
|
||||
}
|
||||
|
||||
# ----
|
||||
|
||||
echo "# Generated by script/print-nia-checksums.sh"
|
||||
for f in $sources; do
|
||||
if [ -f $f ]; then
|
||||
handle $f
|
||||
elif [ -d $f ]; then
|
||||
for g in `find $f -type f | LANG=C sort`; do
|
||||
handle $g
|
||||
done
|
||||
else
|
||||
echo "Could not open $f"
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
@@ -0,0 +1,57 @@
|
||||
// Copyright 2021 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.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
// print-png-latin-1.go prints the UTF-8 encoding of the std/png Latin-1 table.
|
||||
//
|
||||
// Usage: go run print-png-latin-1.go
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
)
|
||||
|
||||
func main() {
|
||||
if err := main1(); err != nil {
|
||||
os.Stderr.WriteString(err.Error() + "\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
func main1() error {
|
||||
// The PNG spec (https://www.w3.org/TR/PNG/) says "*printable* [emphasis
|
||||
// added] Latin-1 characters and spaces (only character codes 32-126 and
|
||||
// 161-255 decimal are allowed)".
|
||||
//
|
||||
// See also https://www.w3.org/TR/2003/REC-PNG-20031110/iso_8859-1.txt
|
||||
for r := rune(0); r <= 0xFF; r++ {
|
||||
if (r < 32) || ((126 < r) && (r < 161)) {
|
||||
fmt.Printf(" 0x0000,")
|
||||
} else if r < 128 {
|
||||
fmt.Printf(" 0x%04X,", r)
|
||||
} else {
|
||||
s := fmt.Sprintf("%c", r)
|
||||
fmt.Printf(" 0x%02X%02X,", s[1], s[0]) // UTF-8 as little-endian uint16.
|
||||
}
|
||||
|
||||
if r%8 == 7 {
|
||||
fmt.Println()
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -125,6 +126,10 @@ var f64TestCases = []float64{
|
||||
6.022141e23,
|
||||
6.0221408e23,
|
||||
6.02214076e23,
|
||||
|
||||
// Some "parse to float64" implementations find this one tricky.
|
||||
// https://github.com/serde-rs/json/issues/707
|
||||
122.416294033786585,
|
||||
}
|
||||
|
||||
var u64TestCases = []uint64{
|
||||
|
||||
@@ -52,6 +52,16 @@
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when
|
||||
// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs'
|
||||
// functions have static storage.
|
||||
//
|
||||
// This can help the compiler ignore or discard unused code, which can produce
|
||||
// faster compiles and smaller binaries. Other motivations are discussed in the
|
||||
// "ALLOW STATIC IMPLEMENTATION" section of
|
||||
// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt
|
||||
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
@@ -25,7 +26,6 @@ import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"math/rand"
|
||||
"os"
|
||||
|
||||
@@ -41,7 +41,7 @@ func main() {
|
||||
}
|
||||
|
||||
func main1() error {
|
||||
input, err := ioutil.ReadAll(os.Stdin)
|
||||
input, err := io.ReadAll(os.Stdin)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//go:build ignore
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
@@ -530,7 +530,7 @@ pri func decoder.swizzle_none!(dst: ptr base.pixel_buffer, src: base.io_reader)
|
||||
}
|
||||
}
|
||||
|
||||
dst = tab.row(y: this.dst_y)
|
||||
dst = tab.row_u32(y: this.dst_y)
|
||||
if dst_bytes_per_row < dst.length() {
|
||||
dst = dst[.. dst_bytes_per_row]
|
||||
}
|
||||
@@ -597,7 +597,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
|
||||
rle_state = this.rle_state
|
||||
|
||||
while.outer true {
|
||||
row = tab.row(y: this.dst_y)
|
||||
row = tab.row_u32(y: this.dst_y)
|
||||
if dst_bytes_per_row < row.length() {
|
||||
row = row[.. dst_bytes_per_row]
|
||||
}
|
||||
@@ -771,7 +771,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
|
||||
if this.dst_y >= this.height {
|
||||
return "#bad RLE compression"
|
||||
}
|
||||
row = tab.row(y: this.dst_y)
|
||||
row = tab.row_u32(y: this.dst_y)
|
||||
if dst_bytes_per_row < row.length() {
|
||||
row = row[.. dst_bytes_per_row]
|
||||
}
|
||||
@@ -801,7 +801,7 @@ pri func decoder.swizzle_rle!(dst: ptr base.pixel_buffer, src: base.io_reader) b
|
||||
} endwhile.outer
|
||||
|
||||
while this.dst_y < this.height {
|
||||
row = tab.row(y: this.dst_y)
|
||||
row = tab.row_u32(y: this.dst_y)
|
||||
if dst_bytes_per_row < row.length() {
|
||||
row = row[.. dst_bytes_per_row]
|
||||
}
|
||||
@@ -921,7 +921,7 @@ pri func decoder.swizzle_bitfields!(dst: ptr base.pixel_buffer, src: base.io_rea
|
||||
} endwhile
|
||||
// -------- END convert to PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE.
|
||||
|
||||
dst = tab.row(y: this.dst_y)
|
||||
dst = tab.row_u32(y: this.dst_y)
|
||||
if dst_bytes_per_row < dst.length() {
|
||||
dst = dst[.. dst_bytes_per_row]
|
||||
}
|
||||
@@ -983,7 +983,7 @@ pri func decoder.swizzle_low_bit_depth!(dst: ptr base.pixel_buffer, src: base.io
|
||||
}
|
||||
}
|
||||
|
||||
dst = tab.row(y: this.dst_y)
|
||||
dst = tab.row_u32(y: this.dst_y)
|
||||
if dst_bytes_per_row < dst.length() {
|
||||
dst = dst[.. dst_bytes_per_row]
|
||||
}
|
||||
@@ -1151,7 +1151,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
|
||||
}
|
||||
if args.minfo <> nullptr {
|
||||
args.minfo.set!(
|
||||
flavor: 1, // WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_REDIRECT
|
||||
flavor: base.MORE_INFORMATION__FLAVOR__IO_REDIRECT,
|
||||
w: this.io_redirect_fourcc,
|
||||
x: 0,
|
||||
y: this.io_redirect_pos,
|
||||
|
||||
@@ -70,6 +70,14 @@ pub struct decoder? implements base.io_transformer(
|
||||
bits : base.u32,
|
||||
n_bits : base.u32,
|
||||
|
||||
// transformed_history_count is the number of bytes written to the history
|
||||
// ringbuffer due to calling transform_io. It excludes any pre-history
|
||||
// written by explicit calls to add_history. It also excludes any bytes
|
||||
// decoded from the final transform_io call (the one that doesn't suspend)
|
||||
// as there is no further need for tracking history (for resolving back-
|
||||
// references) once the decoding completes.
|
||||
transformed_history_count : base.u64,
|
||||
|
||||
// history_index indexes the history array, defined below.
|
||||
history_index : base.u32,
|
||||
|
||||
@@ -211,6 +219,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
|
||||
if not status.is_suspension() {
|
||||
return status
|
||||
}
|
||||
this.transformed_history_count ~sat+= args.dst.count_since(mark: mark)
|
||||
// TODO: should "since" be "since!", as the return value lets you
|
||||
// modify the state of args.dst, so future mutations (via the slice)
|
||||
// can change the veracity of any args.dst assertions?
|
||||
@@ -619,17 +628,21 @@ pri func decoder.init_huff!(which: base.u32[..= 1], n_codes0: base.u32[..= 288],
|
||||
} endwhile
|
||||
if remaining <> 0 {
|
||||
// As a special case, allow a degenerate H-D Huffman table, with only
|
||||
// one 1-bit code, for the smallest possible distance.
|
||||
// one 1-bit code.
|
||||
if (args.which == 1) and (counts[1] == 1) and
|
||||
(this.code_lengths[args.n_codes0] == 1) and
|
||||
(((counts[0] as base.u32) + args.n_codes0 + 1) == args.n_codes1) {
|
||||
|
||||
this.n_huffs_bits[1] = 1
|
||||
this.huffs[1][0] = DCODE_MAGIC_NUMBERS[0] | 1
|
||||
this.huffs[1][1] = DCODE_MAGIC_NUMBERS[31] | 1
|
||||
return ok
|
||||
i = 0
|
||||
while i <= 29 {
|
||||
if this.code_lengths[args.n_codes0 + i] == 1 {
|
||||
this.n_huffs_bits[1] = 1
|
||||
this.huffs[1][0] = DCODE_MAGIC_NUMBERS[i] | 1
|
||||
this.huffs[1][1] = DCODE_MAGIC_NUMBERS[31] | 1
|
||||
return ok
|
||||
}
|
||||
i += 1
|
||||
} endwhile
|
||||
}
|
||||
|
||||
return "#bad Huffman code (under-subscribed)"
|
||||
}
|
||||
|
||||
|
||||
@@ -35,6 +35,7 @@ pri func decoder.decode_huffman_bmi2!(dst: base.io_writer, src: base.io_reader)
|
||||
var dist_minus_1 : base.u32[..= 0x7FFF]
|
||||
var hlen : base.u32[..= 0x7FFF]
|
||||
var hdist : base.u32
|
||||
var hdist_adjustment : base.u32
|
||||
|
||||
if (this.n_bits >= 8) or ((this.bits >> (this.n_bits & 7)) <> 0) {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
@@ -46,6 +47,11 @@ pri func decoder.decode_huffman_bmi2!(dst: base.io_writer, src: base.io_reader)
|
||||
lmask = ((1 as base.u64) << this.n_huffs_bits[0]) - 1
|
||||
dmask = ((1 as base.u64) << this.n_huffs_bits[1]) - 1
|
||||
|
||||
if this.transformed_history_count < args.dst.history_position() {
|
||||
return base."#bad I/O position"
|
||||
}
|
||||
hdist_adjustment = ((this.transformed_history_count - args.dst.history_position()) & 0xFFFF_FFFF) as base.u32
|
||||
|
||||
// Check up front, on each iteration, that we have enough buffer space to
|
||||
// both read (8 bytes) and write (266 bytes) as much as we need to. Doing
|
||||
// this check once (per iteration), up front, removes the need to check
|
||||
@@ -209,21 +215,18 @@ pri func decoder.decode_huffman_bmi2!(dst: base.io_writer, src: base.io_reader)
|
||||
hlen = length
|
||||
length = 0
|
||||
}
|
||||
hdist ~mod+= hdist_adjustment
|
||||
if this.history_index < hdist {
|
||||
return "#bad distance"
|
||||
}
|
||||
// Re-purpose the hdist variable as the this.history index to
|
||||
// start copying from.
|
||||
hdist = this.history_index - hdist
|
||||
|
||||
// Copy from hdist to the end of this.history.
|
||||
// Copy from this.history[(this.history_index - hdist) ..].
|
||||
//
|
||||
// This copying is simpler than the decode_huffman_slow version
|
||||
// because it cannot yield. We have already checked that
|
||||
// args.dst.length() is large enough.
|
||||
args.dst.limited_copy_u32_from_slice!(
|
||||
up_to: hlen, s: this.history[hdist & 0x7FFF ..])
|
||||
|
||||
up_to: hlen, s: this.history[(this.history_index - hdist) & 0x7FFF ..])
|
||||
if length == 0 {
|
||||
// No need to copy from args.dst.
|
||||
continue.loop
|
||||
|
||||
@@ -32,6 +32,7 @@ pri func decoder.decode_huffman_fast32!(dst: base.io_writer, src: base.io_reader
|
||||
var dist_minus_1 : base.u32[..= 0x7FFF]
|
||||
var hlen : base.u32[..= 0x7FFF]
|
||||
var hdist : base.u32
|
||||
var hdist_adjustment : base.u32
|
||||
|
||||
if (this.n_bits >= 8) or ((this.bits >> (this.n_bits & 7)) <> 0) {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
@@ -43,6 +44,11 @@ pri func decoder.decode_huffman_fast32!(dst: base.io_writer, src: base.io_reader
|
||||
lmask = ((1 as base.u32) << this.n_huffs_bits[0]) - 1
|
||||
dmask = ((1 as base.u32) << this.n_huffs_bits[1]) - 1
|
||||
|
||||
if this.transformed_history_count < args.dst.history_position() {
|
||||
return base."#bad I/O position"
|
||||
}
|
||||
hdist_adjustment = ((this.transformed_history_count - args.dst.history_position()) & 0xFFFF_FFFF) as base.u32
|
||||
|
||||
// Check up front, on each iteration, that we have enough buffer space to
|
||||
// both read (12 bytes) and write (266 bytes) as much as we need to. Doing
|
||||
// this check once (per iteration), up front, removes the need to check
|
||||
@@ -314,21 +320,18 @@ pri func decoder.decode_huffman_fast32!(dst: base.io_writer, src: base.io_reader
|
||||
hlen = length
|
||||
length = 0
|
||||
}
|
||||
hdist ~mod+= hdist_adjustment
|
||||
if this.history_index < hdist {
|
||||
return "#bad distance"
|
||||
}
|
||||
// Re-purpose the hdist variable as the this.history index to
|
||||
// start copying from.
|
||||
hdist = this.history_index - hdist
|
||||
|
||||
// Copy from hdist to the end of this.history.
|
||||
// Copy from this.history[(this.history_index - hdist) ..].
|
||||
//
|
||||
// This copying is simpler than the decode_huffman_slow version
|
||||
// because it cannot yield. We have already checked that
|
||||
// args.dst.length() is large enough.
|
||||
args.dst.limited_copy_u32_from_slice!(
|
||||
up_to: hlen, s: this.history[hdist & 0x7FFF ..])
|
||||
|
||||
up_to: hlen, s: this.history[(this.history_index - hdist) & 0x7FFF ..])
|
||||
if length == 0 {
|
||||
// No need to copy from args.dst.
|
||||
continue.loop
|
||||
|
||||
@@ -34,6 +34,7 @@ pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader
|
||||
var dist_minus_1 : base.u32[..= 0x7FFF]
|
||||
var hlen : base.u32[..= 0x7FFF]
|
||||
var hdist : base.u32
|
||||
var hdist_adjustment : base.u32
|
||||
|
||||
if (this.n_bits >= 8) or ((this.bits >> (this.n_bits & 7)) <> 0) {
|
||||
return "#internal error: inconsistent n_bits"
|
||||
@@ -45,6 +46,11 @@ pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader
|
||||
lmask = ((1 as base.u64) << this.n_huffs_bits[0]) - 1
|
||||
dmask = ((1 as base.u64) << this.n_huffs_bits[1]) - 1
|
||||
|
||||
if this.transformed_history_count < args.dst.history_position() {
|
||||
return base."#bad I/O position"
|
||||
}
|
||||
hdist_adjustment = ((this.transformed_history_count - args.dst.history_position()) & 0xFFFF_FFFF) as base.u32
|
||||
|
||||
// Check up front, on each iteration, that we have enough buffer space to
|
||||
// both read (8 bytes) and write (266 bytes) as much as we need to. Doing
|
||||
// this check once (per iteration), up front, removes the need to check
|
||||
@@ -208,21 +214,18 @@ pri func decoder.decode_huffman_fast64!(dst: base.io_writer, src: base.io_reader
|
||||
hlen = length
|
||||
length = 0
|
||||
}
|
||||
hdist ~mod+= hdist_adjustment
|
||||
if this.history_index < hdist {
|
||||
return "#bad distance"
|
||||
}
|
||||
// Re-purpose the hdist variable as the this.history index to
|
||||
// start copying from.
|
||||
hdist = this.history_index - hdist
|
||||
|
||||
// Copy from hdist to the end of this.history.
|
||||
// Copy from this.history[(this.history_index - hdist) ..].
|
||||
//
|
||||
// This copying is simpler than the decode_huffman_slow version
|
||||
// because it cannot yield. We have already checked that
|
||||
// args.dst.length() is large enough.
|
||||
args.dst.limited_copy_u32_from_slice!(
|
||||
up_to: hlen, s: this.history[hdist & 0x7FFF ..])
|
||||
|
||||
up_to: hlen, s: this.history[(this.history_index - hdist) & 0x7FFF ..])
|
||||
if length == 0 {
|
||||
// No need to copy from args.dst.
|
||||
continue.loop
|
||||
|
||||
@@ -201,62 +201,38 @@ pri func decoder.decode_huffman_slow?(dst: base.io_writer, src: base.io_reader)
|
||||
n_bits -= table_entry_n_bits
|
||||
}
|
||||
|
||||
while true {
|
||||
while.inner true {
|
||||
// Copy from this.history.
|
||||
if ((dist_minus_1 + 1) as base.u64) > args.dst.history_length() {
|
||||
// Set (hlen, hdist) to be the length-distance pair to copy
|
||||
// from this.history, and (length, distance) to be the
|
||||
// remaining length-distance pair to copy from args.dst.
|
||||
// from this.history.
|
||||
hdist = (((dist_minus_1 + 1) as base.u64) - args.dst.history_length()) as base.u32
|
||||
if length > hdist {
|
||||
assert hdist < length via "a < b: b > a"()
|
||||
if hdist < length {
|
||||
assert hdist < 0x8000 via "a < b: a < c; c <= b"(c: length)
|
||||
length -= hdist
|
||||
hlen = hdist
|
||||
assert hlen <= length via "a <= b: a == c; c <= b"(c: hdist)
|
||||
} else {
|
||||
hlen = length
|
||||
length = 0
|
||||
assert hlen <= length via "a <= b: a == b"()
|
||||
}
|
||||
|
||||
hdist ~mod+= ((this.transformed_history_count ~mod- args.dst.history_position()) & 0xFFFF_FFFF) as base.u32
|
||||
if this.history_index < hdist {
|
||||
return "#bad distance"
|
||||
}
|
||||
// Re-purpose the hdist variable as the this.history index to
|
||||
// start copying from.
|
||||
hdist = this.history_index - hdist
|
||||
|
||||
// Copy from hdist to the end of this.history.
|
||||
while true {
|
||||
n_copied = args.dst.limited_copy_u32_from_slice!(
|
||||
up_to: hlen, s: this.history[hdist & 0x7FFF .. 0x8000])
|
||||
if hlen <= n_copied {
|
||||
hlen = 0
|
||||
break
|
||||
}
|
||||
if n_copied > 0 {
|
||||
hlen -= n_copied
|
||||
hdist = (hdist ~mod+ n_copied) & 0x7FFF
|
||||
if hdist == 0 {
|
||||
// Wrap around the this.history ringbuffer.
|
||||
break
|
||||
}
|
||||
}
|
||||
// Copy from this.history[(this.history_index - hdist) ..].
|
||||
n_copied = args.dst.limited_copy_u32_from_slice!(
|
||||
up_to: hlen, s: this.history[(this.history_index - hdist) & 0x7FFF ..])
|
||||
if n_copied < hlen {
|
||||
assert n_copied < length via "a < b: a < c; c <= b"(c: hlen)
|
||||
assert length > n_copied via "a > b: b < a"()
|
||||
length -= n_copied
|
||||
yield? base."$short write"
|
||||
} endwhile
|
||||
// Copy from the start of this.history, if we wrapped around.
|
||||
if hlen > 0 {
|
||||
while true {
|
||||
n_copied = args.dst.limited_copy_u32_from_slice!(
|
||||
up_to: hlen, s: this.history[hdist & 0x7FFF .. 0x8000])
|
||||
if hlen <= n_copied {
|
||||
hlen = 0
|
||||
break
|
||||
}
|
||||
hlen -= n_copied
|
||||
hdist ~mod+= n_copied
|
||||
yield? base."$short write"
|
||||
} endwhile
|
||||
continue.inner
|
||||
}
|
||||
|
||||
assert length >= hlen via "a >= b: b <= a"()
|
||||
length -= hlen
|
||||
if length == 0 {
|
||||
// No need to copy from args.dst.
|
||||
continue.loop
|
||||
@@ -267,12 +243,11 @@ pri func decoder.decode_huffman_slow?(dst: base.io_writer, src: base.io_reader)
|
||||
n_copied = args.dst.limited_copy_u32_from_history!(
|
||||
up_to: length, distance: (dist_minus_1 + 1))
|
||||
if length <= n_copied {
|
||||
length = 0
|
||||
break
|
||||
continue.loop
|
||||
}
|
||||
length -= n_copied
|
||||
yield? base."$short write"
|
||||
} endwhile
|
||||
} endwhile.inner
|
||||
} endwhile.loop
|
||||
|
||||
// TODO: "assert n_bits < 8"? What about (bits >> n_bits)?
|
||||
|
||||
@@ -12,8 +12,6 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// --------
|
||||
|
||||
pub struct decoder? implements base.image_decoder(
|
||||
width : base.u32,
|
||||
height : base.u32,
|
||||
@@ -40,7 +38,7 @@ pub struct decoder? implements base.image_decoder(
|
||||
// - 0x00 -> 0x04: via DFC with implicit DIC
|
||||
// - 0x00 -> 0x05: via DF with implicit DIC and DFC
|
||||
//
|
||||
// - 0x01 -> 0x02: via AMC
|
||||
// - 0x01 -> 0x02: via TMM
|
||||
//
|
||||
// - 0x02 -> 0x01: via DIC (metadata reported)
|
||||
// - 0x02 -> 0x03: via DIC (metadata not reported)
|
||||
@@ -57,11 +55,11 @@ pub struct decoder? implements base.image_decoder(
|
||||
// - ???? -> 0x05: via RF for ???? > 0x00
|
||||
//
|
||||
// Where:
|
||||
// - AMC is ack_metadata_chunk
|
||||
// - DF is decode_frame, implicit means skip_frame
|
||||
// - DFC is decode_frame_config, implicit means nullptr args.dst
|
||||
// - DIC is decode_image_config, implicit means nullptr args.dst
|
||||
// - RF is restart_frame
|
||||
// - TMM is tell_me_more
|
||||
call_sequence : base.u8,
|
||||
|
||||
ignore_metadata : base.bool,
|
||||
@@ -84,8 +82,8 @@ pub struct decoder? implements base.image_decoder(
|
||||
|
||||
// Absent an ANIMEXTS1.0 or NETSCAPE2.0 extension, the implicit number of
|
||||
// animation loops is 1.
|
||||
seen_num_loops : base.bool,
|
||||
num_loops : base.u32,
|
||||
seen_num_animation_loops_value : base.bool,
|
||||
num_animation_loops_value : base.u32,
|
||||
|
||||
background_color_u32_argb_premul : base.u32,
|
||||
black_color_u32_argb_premul : base.u32,
|
||||
@@ -96,7 +94,8 @@ pub struct decoder? implements base.image_decoder(
|
||||
// There are 7_056000 flicks per centisecond.
|
||||
gc_duration : base.u64[..= 0xFFFF * 7_056000],
|
||||
|
||||
frame_config_io_position : base.u64,
|
||||
frame_config_io_position : base.u64,
|
||||
|
||||
num_decoded_frame_configs_value : base.u64,
|
||||
num_decoded_frames_value : base.u64,
|
||||
|
||||
@@ -205,7 +204,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
|
||||
if args.src.position() <> this.metadata_io_position {
|
||||
if args.minfo <> nullptr {
|
||||
args.minfo.set!(
|
||||
flavor: 2, // WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK
|
||||
flavor: base.MORE_INFORMATION__FLAVOR__IO_SEEK,
|
||||
w: 0,
|
||||
x: this.metadata_io_position,
|
||||
y: 0,
|
||||
@@ -250,7 +249,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
|
||||
|
||||
if args.minfo <> nullptr {
|
||||
args.minfo.set!(
|
||||
flavor: 3, // WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA
|
||||
flavor: base.MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH,
|
||||
w: this.metadata_fourcc,
|
||||
x: 0,
|
||||
y: args.src.position(),
|
||||
@@ -262,7 +261,7 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
|
||||
|
||||
if args.minfo <> nullptr {
|
||||
args.minfo.set!(
|
||||
flavor: 3, // WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA
|
||||
flavor: base.MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH,
|
||||
w: this.metadata_fourcc,
|
||||
x: 0,
|
||||
y: this.metadata_io_position,
|
||||
@@ -275,10 +274,24 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
|
||||
}
|
||||
|
||||
pub func decoder.num_animation_loops() base.u32 {
|
||||
if this.seen_num_loops {
|
||||
return this.num_loops
|
||||
if this.seen_num_animation_loops_value {
|
||||
return this.num_animation_loops_value
|
||||
}
|
||||
return 1
|
||||
// Absent an explicit animation loop count, default to 1 meaning "play each
|
||||
// frame exactly once" for animated GIFs and 0 meaning "loop forever" for
|
||||
// still (non-animated) GIFs.
|
||||
//
|
||||
// In practice, returning 1 or 0 has no difference for still GIFs, in that
|
||||
// either way, the pixels on screen do not change over time. However,
|
||||
// returning 0 here matches other Wuffs image decoders (e.g. BMP, PNG)
|
||||
// returning 0 for their still images.
|
||||
//
|
||||
// As a consequence, if a still GIF is losslessly converted to a still BMP
|
||||
// and both of those are then converted to NIA, the two NIA outputs match.
|
||||
if this.num_decoded_frame_configs_value > 1 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
pub func decoder.num_decoded_frame_configs() base.u64 {
|
||||
@@ -662,8 +675,8 @@ pri func decoder.decode_ae?(src: base.io_reader) {
|
||||
args.src.skip_u32?(n: 2)
|
||||
break.goto_done
|
||||
}
|
||||
this.num_loops = args.src.read_u16le_as_u32?()
|
||||
this.seen_num_loops = true
|
||||
this.num_animation_loops_value = args.src.read_u16le_as_u32?()
|
||||
this.seen_num_animation_loops_value = true
|
||||
|
||||
// A loop count of N, in the wire format, actually means "repeat N
|
||||
// times after the first play", if N is positive. A zero N means to
|
||||
@@ -675,8 +688,8 @@ pri func decoder.decode_ae?(src: base.io_reader) {
|
||||
//
|
||||
// Thus, we increment N if it is positive. The comparison against
|
||||
// 0xFFFF will never fail, but is necessary for the overflow checker.
|
||||
if (0 < this.num_loops) and (this.num_loops <= 0xFFFF) {
|
||||
this.num_loops += 1
|
||||
if (0 < this.num_animation_loops_value) and (this.num_animation_loops_value <= 0xFFFF) {
|
||||
this.num_animation_loops_value += 1
|
||||
}
|
||||
|
||||
} else if this.ignore_metadata {
|
||||
@@ -721,16 +734,13 @@ pri func decoder.decode_gc?(src: base.io_reader) {
|
||||
// in the range [4 ..= 7] are "to be defined". In practice, some encoders also
|
||||
// use 4 for "restore previous". See
|
||||
// https://cs.chromium.org/chromium/src/third_party/blink/renderer/platform/image-decoders/gif/gif_image_reader.cc?rcl=5161173c43324da2b13e1aa45bbe69901daa1279&l=625
|
||||
//
|
||||
// TODO: named constants instead of assigning 1 for
|
||||
// WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND, etc.
|
||||
flags = (flags >> 2) & 0x07
|
||||
if flags == 2 {
|
||||
this.gc_disposal = 1 // 1 is WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND
|
||||
this.gc_disposal = base.ANIMATION_DISPOSAL__RESTORE_BACKGROUND
|
||||
} else if (flags == 3) or (flags == 4) {
|
||||
this.gc_disposal = 2 // 2 is WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS
|
||||
this.gc_disposal = base.ANIMATION_DISPOSAL__RESTORE_PREVIOUS
|
||||
} else {
|
||||
this.gc_disposal = 0
|
||||
this.gc_disposal = base.ANIMATION_DISPOSAL__NONE
|
||||
}
|
||||
|
||||
// There are 7_056000 flicks per centisecond.
|
||||
@@ -929,7 +939,7 @@ pri func decoder.decode_id_part2?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
if (this.compressed_ri > this.compressed_wi) or (this.compressed_wi > 4096) {
|
||||
return "#internal error: inconsistent ri/wi"
|
||||
}
|
||||
io_bind (io: r, data: this.compressed[this.compressed_ri .. this.compressed_wi]) {
|
||||
io_bind (io: r, data: this.compressed[this.compressed_ri .. this.compressed_wi], history_position: 0) {
|
||||
mark = r.mark()
|
||||
lzw_status =? this.lzw.transform_io?(
|
||||
dst: this.util.empty_io_writer(), src: r, workbuf: this.util.empty_slice_u8())
|
||||
@@ -958,6 +968,17 @@ pri func decoder.decode_id_part2?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
continue.outer
|
||||
} else if lzw_status == base."$short write" {
|
||||
continue.inner
|
||||
} else if this.quirks[QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA - QUIRKS_BASE] and
|
||||
(this.dst_y >= this.frame_rect_y1) and (this.interlace == 0) {
|
||||
// It's invalid LZW-compressed data, but we still have a full
|
||||
// frame and have opted in to QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA,
|
||||
// so treat it like the lzw_status.is_ok() case, other than not
|
||||
// clearing this.previous_lzw_decode_ended_abruptly.
|
||||
if need_block_size or (block_size > 0) {
|
||||
args.src.skip_u32?(n: block_size as base.u32)
|
||||
this.skip_blocks?(src: args.src)
|
||||
}
|
||||
break.outer
|
||||
}
|
||||
return lzw_status
|
||||
} endwhile.inner
|
||||
@@ -1015,7 +1036,7 @@ pri func decoder.copy_to_image_buffer!(pb: ptr base.pixel_buffer, src: slice bas
|
||||
// First, copy from src to that part of the frame rect that is inside
|
||||
// args.pb's bounds (clipped to the image bounds).
|
||||
|
||||
dst = tab.row(y: this.dst_y)
|
||||
dst = tab.row_u32(y: this.dst_y)
|
||||
if this.dst_y >= this.height {
|
||||
dst = dst[.. 0]
|
||||
} else if width_in_bytes < dst.length() {
|
||||
@@ -1057,13 +1078,13 @@ pri func decoder.copy_to_image_buffer!(pb: ptr base.pixel_buffer, src: slice bas
|
||||
(not this.gc_has_transparent_index) and
|
||||
(this.interlace > 1) {
|
||||
|
||||
replicate_src = tab.row(y: this.dst_y)
|
||||
replicate_src = tab.row_u32(y: this.dst_y)
|
||||
replicate_y0 = this.dst_y ~sat+ 1
|
||||
replicate_y1 = this.dst_y ~sat+ (INTERLACE_COUNT[this.interlace] as base.u32)
|
||||
replicate_y1 = replicate_y1.min(a: this.frame_rect_y1)
|
||||
while replicate_y0 < replicate_y1 {
|
||||
assert replicate_y0 < 0xFFFF_FFFF via "a < b: a < c; c <= b"(c: replicate_y1)
|
||||
replicate_dst = tab.row(y: replicate_y0)
|
||||
replicate_dst = tab.row_u32(y: replicate_y0)
|
||||
replicate_dst.copy_from_slice!(s: replicate_src)
|
||||
replicate_y0 += 1
|
||||
} endwhile
|
||||
|
||||
@@ -1530,7 +1530,16 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
|
||||
pre args.dst.length() > 0,
|
||||
{
|
||||
if args.src.length() <= 0 {
|
||||
if length > 0 {
|
||||
if args.src.is_closed() {
|
||||
args.dst.write_simple_token_fast!(
|
||||
value_major: 0,
|
||||
value_minor: (base.TOKEN__VBC__FILLER << 21) |
|
||||
base.TOKEN__VBD__FILLER__COMMENT_LINE,
|
||||
continued: 0,
|
||||
length: length)
|
||||
this.comment_type = 2
|
||||
return ok
|
||||
} else if length > 0 {
|
||||
args.dst.write_simple_token_fast!(
|
||||
value_major: 0,
|
||||
value_minor: (base.TOKEN__VBC__FILLER << 21) |
|
||||
@@ -1538,9 +1547,6 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
|
||||
continued: 1,
|
||||
length: length)
|
||||
}
|
||||
if args.src.is_closed() {
|
||||
return "#bad input"
|
||||
}
|
||||
yield? base."$short read"
|
||||
length = 0
|
||||
continue.comment_line
|
||||
@@ -1548,13 +1554,12 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
|
||||
|
||||
c = args.src.peek_u8()
|
||||
if c == '\n' {
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
args.dst.write_simple_token_fast!(
|
||||
value_major: 0,
|
||||
value_minor: (base.TOKEN__VBC__FILLER << 21) |
|
||||
base.TOKEN__VBD__FILLER__COMMENT_LINE,
|
||||
continued: 0,
|
||||
length: length + 1)
|
||||
length: length)
|
||||
this.comment_type = 2
|
||||
return ok
|
||||
}
|
||||
|
||||
@@ -109,15 +109,17 @@ pub const QUIRK_ALLOW_COMMENT_BLOCK : base.u32 = 0x4909_9400 | 0x0B
|
||||
// When this quirk is enabled, "// C/C++ style line comments\n" are accepted
|
||||
// anywhere whitespace would be. See also QUIRK_ALLOW_TRAILING_FILLER.
|
||||
//
|
||||
// A line comment may not omit the ending "\n", even if there is no input
|
||||
// afterwards (i.e. the prospective line comment ends with the end-of-file).
|
||||
// Line comments are terminated by a '\n' byte. '\r' bytes are irrelevant. When
|
||||
// combined with QUIRK_ALLOW_TRAILING_FILLER, a line comment at the end of the
|
||||
// file may omit the final '\n' byte.
|
||||
//
|
||||
// They produce WUFFS_BASE__TOKEN__VBD__FILLER__COMMENT_LINE tokens. The token
|
||||
// chain's source bytes includes the starting "//" and the ending "\n".
|
||||
// chain's source bytes includes the starting "//" but always excludes the
|
||||
// ending "\n", regardless of whether it met the end of the file instead.
|
||||
//
|
||||
// Even if the line comments are on consecutive lines, each line comment is a
|
||||
// separate token chain. There may be whitespace tokens between one line
|
||||
// comment's ending "\n" and the next one's starting "//".
|
||||
// separate token chain. Between them is at least one "\n" and maybe other
|
||||
// whitespace, which are not part of a line comment token chain.
|
||||
//
|
||||
// To avoid ambiguity (as comments can contain new lines), this quirk cannot be
|
||||
// combined with QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF.
|
||||
|
||||
@@ -56,7 +56,6 @@ pub struct decoder? implements base.image_decoder(
|
||||
|
||||
swizzler : base.pixel_swizzler,
|
||||
util : base.utility,
|
||||
)(
|
||||
)
|
||||
|
||||
pub func decoder.set_quirk_enabled!(quirk: base.u32, enabled: base.bool) {
|
||||
@@ -211,7 +210,7 @@ pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: base.io_reader) base.
|
||||
}
|
||||
}
|
||||
|
||||
dst = tab.row(y: this.dst_y)
|
||||
dst = tab.row_u32(y: this.dst_y)
|
||||
if dst_bytes_per_row < dst.length() {
|
||||
dst = dst[.. dst_bytes_per_row]
|
||||
}
|
||||
|
||||
@@ -0,0 +1,142 @@
|
||||
// Copyright 2020 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.
|
||||
|
||||
pub status "#bad animation sequence number"
|
||||
pub status "#bad checksum"
|
||||
pub status "#bad chunk"
|
||||
pub status "#bad filter"
|
||||
pub status "#bad header"
|
||||
pub status "#bad text chunk (not Latin-1)"
|
||||
pub status "#missing palette"
|
||||
pub status "#unsupported PNG compression method"
|
||||
pub status "#unsupported PNG file"
|
||||
|
||||
pri status "#internal error: inconsistent I/O"
|
||||
pri status "#internal error: inconsistent chunk type"
|
||||
pri status "#internal error: inconsistent frame bounds"
|
||||
pri status "#internal error: inconsistent workbuf length"
|
||||
pri status "#internal error: zlib decoder did not exhaust its input"
|
||||
|
||||
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0
|
||||
|
||||
// DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL is the minimum length of the src
|
||||
// wuffs_base__io_buffer passed to the decoder.
|
||||
pub const DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL : base.u64 = 8
|
||||
|
||||
// ANCILLARY_BIT is the upper/lower case bit on the chunk type's first byte (in
|
||||
// little-endian order).
|
||||
pri const ANCILLARY_BIT : base.u32 = 0x0000_0020
|
||||
|
||||
// INTERLACING holds the Adam7 interlacing pattern, involving 7 passes:
|
||||
// 1 6 4 6 2 6 4 6
|
||||
// 7 7 7 7 7 7 7 7
|
||||
// 5 6 5 6 5 6 5 6
|
||||
// 7 7 7 7 7 7 7 7
|
||||
// 3 6 4 6 3 6 4 6
|
||||
// 7 7 7 7 7 7 7 7
|
||||
// 5 6 5 6 5 6 5 6
|
||||
// 7 7 7 7 7 7 7 7
|
||||
//
|
||||
// The six elements of each inner array are:
|
||||
// 0: log2(x_stride)
|
||||
// 1: x_stride - x_offset - 1
|
||||
// 2: x_offset
|
||||
// 3: log2(y_stride)
|
||||
// 4: y_stride - y_offset - 1
|
||||
// 5: y_offset
|
||||
pri const INTERLACING : array[8] array[6] base.u8[..= 7] = [
|
||||
[0, 0, 0, 0, 0, 0], // non-interlaced; xy_stride=1, xy_offset=0
|
||||
[3, 7, 0, 3, 7, 0], // interlace_pass == 1
|
||||
[3, 3, 4, 3, 7, 0], // interlace_pass == 2
|
||||
[2, 3, 0, 3, 3, 4], // interlace_pass == 3
|
||||
[2, 1, 2, 2, 3, 0], // interlace_pass == 4
|
||||
[1, 1, 0, 2, 1, 2], // interlace_pass == 5
|
||||
[1, 0, 1, 1, 1, 0], // interlace_pass == 6
|
||||
[0, 0, 0, 1, 0, 1], // interlace_pass == 7
|
||||
]
|
||||
|
||||
// LOW_BIT_DEPTH_MULTIPLIERS holds multipliers that convert D-bit values into
|
||||
// 8-bit values, for depth D.
|
||||
pri const LOW_BIT_DEPTH_MULTIPLIERS : array[8] base.u8 = [
|
||||
0,
|
||||
0b1111_1111, // depth == 1
|
||||
0b0101_0101, // depth == 2
|
||||
0,
|
||||
0b0001_0001, // depth == 4
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
]
|
||||
|
||||
// LOW_BIT_DEPTH_NUM_PACKS holds the number of smaller-than-1-byte units that
|
||||
// are packed into each byte.
|
||||
pri const LOW_BIT_DEPTH_NUM_PACKS : array[8] base.u8 = [
|
||||
0,
|
||||
8, // depth == 1
|
||||
4, // depth == 2
|
||||
0,
|
||||
2, // depth == 4
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
]
|
||||
|
||||
// NUM_CHANNELS holds the number of channels for each valid color type.
|
||||
pri const NUM_CHANNELS : array[8] base.u8[..= 4] = [
|
||||
1, // color_type == 0: Y
|
||||
0,
|
||||
3, // color_type == 2: RGB
|
||||
1, // color_type == 3: indexed
|
||||
2, // color_type == 4: YA
|
||||
0,
|
||||
4, // color_type == 6: RGBA
|
||||
0,
|
||||
]
|
||||
|
||||
// LATIN_1 converts from printable Latin-1 (ISO/IEC 8859-1) to UTF-8 (encoded
|
||||
// as little-endian u16). It was created by script/print-png-latin-1.go.
|
||||
pri const LATIN_1 : array[256] base.u16 = [
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
|
||||
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
|
||||
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
|
||||
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
|
||||
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
|
||||
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
|
||||
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
|
||||
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
|
||||
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
|
||||
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
|
||||
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
|
||||
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0xA1C2, 0xA2C2, 0xA3C2, 0xA4C2, 0xA5C2, 0xA6C2, 0xA7C2,
|
||||
0xA8C2, 0xA9C2, 0xAAC2, 0xABC2, 0xACC2, 0xADC2, 0xAEC2, 0xAFC2,
|
||||
0xB0C2, 0xB1C2, 0xB2C2, 0xB3C2, 0xB4C2, 0xB5C2, 0xB6C2, 0xB7C2,
|
||||
0xB8C2, 0xB9C2, 0xBAC2, 0xBBC2, 0xBCC2, 0xBDC2, 0xBEC2, 0xBFC2,
|
||||
0x80C3, 0x81C3, 0x82C3, 0x83C3, 0x84C3, 0x85C3, 0x86C3, 0x87C3,
|
||||
0x88C3, 0x89C3, 0x8AC3, 0x8BC3, 0x8CC3, 0x8DC3, 0x8EC3, 0x8FC3,
|
||||
0x90C3, 0x91C3, 0x92C3, 0x93C3, 0x94C3, 0x95C3, 0x96C3, 0x97C3,
|
||||
0x98C3, 0x99C3, 0x9AC3, 0x9BC3, 0x9CC3, 0x9DC3, 0x9EC3, 0x9FC3,
|
||||
0xA0C3, 0xA1C3, 0xA2C3, 0xA3C3, 0xA4C3, 0xA5C3, 0xA6C3, 0xA7C3,
|
||||
0xA8C3, 0xA9C3, 0xAAC3, 0xABC3, 0xACC3, 0xADC3, 0xAEC3, 0xAFC3,
|
||||
0xB0C3, 0xB1C3, 0xB2C3, 0xB3C3, 0xB4C3, 0xB5C3, 0xB6C3, 0xB7C3,
|
||||
0xB8C3, 0xB9C3, 0xBAC3, 0xBBC3, 0xBCC3, 0xBDC3, 0xBEC3, 0xBFC3,
|
||||
]
|
||||
@@ -15,18 +15,6 @@
|
||||
use "std/crc32"
|
||||
use "std/zlib"
|
||||
|
||||
pub status "#bad checksum"
|
||||
pub status "#bad chunk"
|
||||
pub status "#bad filter"
|
||||
pub status "#bad header"
|
||||
pub status "#missing palette"
|
||||
pub status "#unsupported PNG file"
|
||||
|
||||
pri status "#internal error: inconsistent workbuf length"
|
||||
pri status "#internal error: zlib decoder did not exhaust its input"
|
||||
|
||||
pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0
|
||||
|
||||
pub struct decoder? implements base.image_decoder(
|
||||
// The 0x00FF_FFFF limit is arbitrary (the PNG spec says 0x7FFF_FFFF) but
|
||||
// it means that (width * height * bytes_per_pixel) doesn't overflow.
|
||||
@@ -37,36 +25,62 @@ pub struct decoder? implements base.image_decoder(
|
||||
pass_bytes_per_row : base.u64[..= 0x07FF_FFF8],
|
||||
|
||||
workbuf_wi : base.u64,
|
||||
workbuf_hist_pos_base : base.u64,
|
||||
overall_workbuf_length : base.u64[..= 0x0007_FFFF_F100_0007],
|
||||
pass_workbuf_length : base.u64[..= 0x0007_FFFF_F100_0007],
|
||||
|
||||
// Call sequence states:
|
||||
// - 0x00: initial state.
|
||||
// - 0x01: metadata reported; image config decode is in progress.
|
||||
// - 0x02: metadata finished; image config decode is in progress.
|
||||
// - 0x03: image config decoded.
|
||||
// - 0x04: frame config decoded.
|
||||
// - 0xFF: end-of-data, usually after (the non-animated) frame decoded.
|
||||
// - 0x05: frame decoded.
|
||||
// - 0xFF: end-of-data, after the final frame decoded.
|
||||
//
|
||||
// State transitions:
|
||||
//
|
||||
// - 0x00 -> 0x03: via DIC
|
||||
// - 0x00 -> 0x01: via DIC (metadata reported)
|
||||
// - 0x00 -> 0x03: via DIC (metadata not reported)
|
||||
// - 0x00 -> 0x04: via DFC with implicit DIC
|
||||
// - 0x00 -> 0x05: via DF with implicit DIC and DFC
|
||||
// - 0x00 -> 0xFF: via DF with implicit DIC and DFC
|
||||
//
|
||||
// - 0x01 -> 0x02: via TMM
|
||||
//
|
||||
// - 0x02 -> 0x01: via DIC (metadata reported)
|
||||
// - 0x02 -> 0x03: via DIC (metadata not reported)
|
||||
//
|
||||
// - 0x03 -> 0x04: via DFC
|
||||
// - 0x03 -> 0x05: via DF with implicit DFC
|
||||
// - 0x03 -> 0xFF: via DF with implicit DFC
|
||||
//
|
||||
// - 0x04 -> 0xFF: via DFC
|
||||
// - 0x04 -> 0x04: via DFC with implicit DF
|
||||
// - 0x04 -> 0x05: via DF
|
||||
// - 0x04 -> 0xFF: via DFC with implicit DF
|
||||
// - 0x04 -> 0xFF: via DF
|
||||
//
|
||||
// - 0x05 -> 0x04: via DFC
|
||||
// - 0x05 -> 0x05: via DF with implicit DFC
|
||||
// - 0x05 -> 0xFF: via DF with implicit DFC
|
||||
//
|
||||
// - ???? -> 0x03: via RF for ???? > 0x00
|
||||
//
|
||||
// Where:
|
||||
// - DF is decode_frame
|
||||
// - DF is decode_frame, implicit means skip_frame
|
||||
// - DFC is decode_frame_config, implicit means nullptr args.dst
|
||||
// - DIC is decode_image_config, implicit means nullptr args.dst
|
||||
// - RF is restart_frame
|
||||
// - TMM is tell_me_more
|
||||
call_sequence : base.u8,
|
||||
|
||||
report_metadata_chrm : base.bool,
|
||||
report_metadata_exif : base.bool,
|
||||
report_metadata_gama : base.bool,
|
||||
report_metadata_iccp : base.bool,
|
||||
report_metadata_kvp : base.bool,
|
||||
report_metadata_srgb : base.bool,
|
||||
|
||||
ignore_checksum : base.bool,
|
||||
|
||||
depth : base.u8[..= 16],
|
||||
@@ -74,17 +88,94 @@ pub struct decoder? implements base.image_decoder(
|
||||
filter_distance : base.u8[..= 8],
|
||||
interlace_pass : base.u8[..= 7],
|
||||
|
||||
seen_actl : base.bool,
|
||||
seen_chrm : base.bool,
|
||||
seen_fctl : base.bool,
|
||||
seen_exif : base.bool,
|
||||
seen_gama : base.bool,
|
||||
seen_iccp : base.bool,
|
||||
seen_idat : base.bool,
|
||||
seen_plte : base.bool,
|
||||
seen_srgb : base.bool,
|
||||
seen_trns : base.bool,
|
||||
|
||||
metadata_is_zlib_compressed : base.bool,
|
||||
|
||||
zlib_is_dirty : base.bool,
|
||||
|
||||
chunk_type : base.u32,
|
||||
chunk_type_array : array[4] base.u8,
|
||||
chunk_length : base.u32,
|
||||
|
||||
// remap_transparency, if non-zero, is the 32-bit or 64-bit (depending on
|
||||
// this.depth) argb_nonpremul color that is nominally opaque but remapped
|
||||
// to transparent black.
|
||||
//
|
||||
// "Remapped" is an unofficial term. This is where the IHDR color type is 0
|
||||
// (Y) or 2 (RGB) but there's also a tRNS chunk.
|
||||
//
|
||||
// PNG transparency that isn't "remapped" is color type 3 (indexed) with
|
||||
// tRNS, color type 4 (YA) or color type 6 (RGBA).
|
||||
remap_transparency : base.u64,
|
||||
|
||||
dst_pixfmt : base.u32,
|
||||
src_pixfmt : base.u32,
|
||||
|
||||
chunk_type : base.u32,
|
||||
chunk_type_array : array[4] base.u8,
|
||||
chunk_length : base.u64,
|
||||
num_animation_frames_value : base.u32,
|
||||
num_animation_loops_value : base.u32,
|
||||
num_decoded_frame_configs_value : base.u32,
|
||||
num_decoded_frames_value : base.u32,
|
||||
|
||||
frame_config_io_position : base.u64,
|
||||
// The frame_etc fields correspond to the base.frame_config argument passed
|
||||
// to decode_frame_config. For animated APNG, these are explicitly given in
|
||||
// the file's fcTL chunks. For still PNG, these are implicitly given in the
|
||||
// file's IHDR chunk.
|
||||
//
|
||||
// Either way, decode_image_config has to read all the way to the start of
|
||||
// the first IDAT / fdAT chunk (e.g. to see if there's a PLTE chunk). While
|
||||
// later frame's restart io_positions are located just before fcTL chunks,
|
||||
// the first frame's restart io_position is located just before the IDAT /
|
||||
// fdAT chunk, so we also have to cache the first frame's configuration as
|
||||
// we cannot re-read the first fcTL. Hence, there are first_etc fields for
|
||||
// every frame_etc field.
|
||||
//
|
||||
// For the etc_duration fields, there are 705_600000 flicks per second and
|
||||
// the maximum frame duration is 65535 seconds.
|
||||
//
|
||||
// The fields are ordered to minimize alignment wastage.
|
||||
frame_rect_x0 : base.u32[..= 0x00FF_FFFF],
|
||||
frame_rect_y0 : base.u32[..= 0x00FF_FFFF],
|
||||
frame_rect_x1 : base.u32[..= 0x00FF_FFFF],
|
||||
frame_rect_y1 : base.u32[..= 0x00FF_FFFF],
|
||||
first_rect_x0 : base.u32[..= 0x00FF_FFFF],
|
||||
first_rect_y0 : base.u32[..= 0x00FF_FFFF],
|
||||
first_rect_x1 : base.u32[..= 0x00FF_FFFF],
|
||||
first_rect_y1 : base.u32[..= 0x00FF_FFFF],
|
||||
frame_config_io_position : base.u64,
|
||||
first_config_io_position : base.u64,
|
||||
frame_duration : base.u64[..= 0x2A0E_6FF1_6600],
|
||||
first_duration : base.u64[..= 0x2A0E_6FF1_6600],
|
||||
frame_disposal : base.u8,
|
||||
first_disposal : base.u8,
|
||||
frame_overwrite_instead_of_blend : base.bool,
|
||||
first_overwrite_instead_of_blend : base.bool,
|
||||
|
||||
next_animation_seq_num : base.u32,
|
||||
|
||||
metadata_flavor : base.u32,
|
||||
metadata_fourcc : base.u32,
|
||||
metadata_x : base.u64,
|
||||
metadata_y : base.u64,
|
||||
metadata_z : base.u64,
|
||||
|
||||
// ztxt_ri and ztxt_wi are read and write indexes into the dst_palette
|
||||
// buffer, re-purposed as a zlib uncompression buffer for zTXt chunks. The
|
||||
// upper bound, 1024, is the same as the dst_palette length.
|
||||
ztxt_ri : base.u32[..= 1024],
|
||||
ztxt_wi : base.u32[..= 1024],
|
||||
// ztxt_hist_pos is the history position: how many uncompressed bytes have
|
||||
// been generated.
|
||||
ztxt_hist_pos : base.u64,
|
||||
|
||||
swizzler : base.pixel_swizzler,
|
||||
util : base.utility,
|
||||
@@ -92,6 +183,10 @@ pub struct decoder? implements base.image_decoder(
|
||||
crc32 : crc32.ieee_hasher,
|
||||
zlib : zlib.decoder,
|
||||
|
||||
// dst_palette and src_palette are used by the swizzler, during
|
||||
// decode_frame. src_palette is initialized by processing the PLTE chunk.
|
||||
// dst_palette is also re-purposed as a zlib uncompression buffer for zTXt
|
||||
// chunks, during decode_image_config.
|
||||
dst_palette : array[4 * 256] base.u8,
|
||||
src_palette : array[4 * 256] base.u8,
|
||||
)
|
||||
@@ -110,44 +205,49 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
|
||||
var checksum_want : base.u32
|
||||
var status : base.status
|
||||
|
||||
if this.call_sequence <> 0 {
|
||||
if this.call_sequence == 2 {
|
||||
if this.metadata_fourcc <> 0 {
|
||||
this.call_sequence = 1
|
||||
return base."@metadata reported"
|
||||
}
|
||||
} else if this.call_sequence <> 0 {
|
||||
return base."#bad call sequence"
|
||||
}
|
||||
|
||||
magic = args.src.read_u64le?()
|
||||
if magic <> '\x89PNG\x0D\x0A\x1A\x0A'le {
|
||||
return "#bad header"
|
||||
}
|
||||
magic = args.src.read_u64le?()
|
||||
if magic <> '\x00\x00\x00\x0DIHDR'le {
|
||||
return "#bad header"
|
||||
}
|
||||
this.crc32.reset!()
|
||||
this.chunk_type_array[0] = 'I'
|
||||
this.chunk_type_array[1] = 'H'
|
||||
this.chunk_type_array[2] = 'D'
|
||||
this.chunk_type_array[3] = 'R'
|
||||
this.crc32.update_u32!(x: this.chunk_type_array[..])
|
||||
|
||||
while true {
|
||||
mark = args.src.mark()
|
||||
status =? this.decode_ihdr?(src: args.src)
|
||||
if not this.ignore_checksum {
|
||||
checksum_have = this.crc32.update_u32!(x: args.src.since(mark: mark))
|
||||
} else {
|
||||
magic = args.src.read_u64le?()
|
||||
if magic <> '\x89PNG\x0D\x0A\x1A\x0A'le {
|
||||
return "#bad header"
|
||||
}
|
||||
if status.is_ok() {
|
||||
break
|
||||
magic = args.src.read_u64le?()
|
||||
if magic <> '\x00\x00\x00\x0DIHDR'le {
|
||||
return "#bad header"
|
||||
}
|
||||
yield? status
|
||||
} endwhile
|
||||
this.chunk_type_array[0] = 'I'
|
||||
this.chunk_type_array[1] = 'H'
|
||||
this.chunk_type_array[2] = 'D'
|
||||
this.chunk_type_array[3] = 'R'
|
||||
this.crc32.reset!()
|
||||
this.crc32.update_u32!(x: this.chunk_type_array[..])
|
||||
|
||||
// Verify CRC-32 checksum.
|
||||
checksum_want = args.src.read_u32be?()
|
||||
if (not this.ignore_checksum) and (checksum_have <> checksum_want) {
|
||||
return "#bad checksum"
|
||||
while true {
|
||||
mark = args.src.mark()
|
||||
status =? this.decode_ihdr?(src: args.src)
|
||||
if not this.ignore_checksum {
|
||||
checksum_have = this.crc32.update_u32!(x: args.src.since(mark: mark))
|
||||
}
|
||||
if status.is_ok() {
|
||||
break
|
||||
}
|
||||
yield? status
|
||||
} endwhile
|
||||
|
||||
// Verify CRC-32 checksum.
|
||||
checksum_want = args.src.read_u32be?()
|
||||
if (not this.ignore_checksum) and (checksum_have <> checksum_want) {
|
||||
return "#bad checksum"
|
||||
}
|
||||
}
|
||||
|
||||
// Read up until an IDAT chunk.
|
||||
// Read up until an IDAT or fdAT chunk.
|
||||
//
|
||||
// By default, libpng "warns and discards" when seeing ancillary chunk
|
||||
// checksum failures (as opposed to critical chunk checksum failures) but
|
||||
@@ -160,26 +260,43 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
|
||||
// IDAT chunk breaks the loop. The only other possible critical chunk is a
|
||||
// PLTE chunk. We verify PLTE checksums here but ignore other checksums.
|
||||
while true {
|
||||
this.chunk_length = args.src.read_u32be_as_u64?()
|
||||
this.chunk_type = args.src.read_u32le?()
|
||||
if (not this.ignore_checksum) and
|
||||
((this.chunk_type == 'IDAT'le) or (this.chunk_type == 'PLTE'le)) {
|
||||
this.crc32.reset!()
|
||||
while args.src.length() < 8,
|
||||
post args.src.length() >= 8,
|
||||
{
|
||||
if args.src.is_closed() {
|
||||
return "#bad chunk"
|
||||
}
|
||||
yield? base."$short read"
|
||||
} endwhile
|
||||
|
||||
this.chunk_length = args.src.peek_u32be()
|
||||
this.chunk_type = (args.src.peek_u64le() >> 32) as base.u32
|
||||
if this.chunk_type == 'IDAT'le {
|
||||
if (not this.seen_actl) or this.seen_fctl {
|
||||
break
|
||||
}
|
||||
this.seen_idat = true
|
||||
} else if this.chunk_type == 'fdAT'le {
|
||||
if this.seen_idat and this.seen_fctl {
|
||||
break
|
||||
}
|
||||
return "#bad chunk"
|
||||
}
|
||||
args.src.skip_u32_fast!(actual: 8, worst_case: 8)
|
||||
|
||||
if (not this.ignore_checksum) and ((this.chunk_type & ANCILLARY_BIT) == 0) {
|
||||
this.chunk_type_array[0] = ((this.chunk_type >> 0) & 0xFF) as base.u8
|
||||
this.chunk_type_array[1] = ((this.chunk_type >> 8) & 0xFF) as base.u8
|
||||
this.chunk_type_array[2] = ((this.chunk_type >> 16) & 0xFF) as base.u8
|
||||
this.chunk_type_array[3] = ((this.chunk_type >> 24) & 0xFF) as base.u8
|
||||
this.crc32.reset!()
|
||||
this.crc32.update_u32!(x: this.chunk_type_array[..])
|
||||
}
|
||||
|
||||
if this.chunk_type == 'IDAT'le {
|
||||
break
|
||||
}
|
||||
|
||||
while true {
|
||||
mark = args.src.mark()
|
||||
status =? this.decode_other_chunk?(src: args.src)
|
||||
if (not this.ignore_checksum) and (this.chunk_type == 'PLTE'le) {
|
||||
if (not this.ignore_checksum) and ((this.chunk_type & ANCILLARY_BIT) == 0) {
|
||||
checksum_have = this.crc32.update_u32!(x: args.src.since(mark: mark))
|
||||
}
|
||||
if status.is_ok() {
|
||||
@@ -187,12 +304,19 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
|
||||
}
|
||||
yield? status
|
||||
} endwhile
|
||||
|
||||
// If we have metadata, delay reading (skipping) the ancillary chunk's
|
||||
// CRC-32 checksum until the end of tell_me_more.
|
||||
if this.metadata_fourcc <> 0 {
|
||||
this.call_sequence = 1
|
||||
return base."@metadata reported"
|
||||
}
|
||||
|
||||
checksum_want = args.src.read_u32be?()
|
||||
if (not this.ignore_checksum) and (this.chunk_type == 'PLTE'le) and
|
||||
if (not this.ignore_checksum) and ((this.chunk_type & ANCILLARY_BIT) == 0) and
|
||||
(checksum_have <> checksum_want) {
|
||||
return "#bad checksum"
|
||||
}
|
||||
|
||||
} endwhile
|
||||
|
||||
if (this.color_type == 3) and (not this.seen_plte) {
|
||||
@@ -200,6 +324,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
|
||||
}
|
||||
|
||||
this.frame_config_io_position = args.src.position()
|
||||
this.first_config_io_position = this.frame_config_io_position
|
||||
|
||||
if args.dst <> nullptr {
|
||||
args.dst.set!(
|
||||
@@ -207,10 +332,23 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
|
||||
pixsub: 0,
|
||||
width: this.width,
|
||||
height: this.height,
|
||||
first_frame_io_position: this.frame_config_io_position,
|
||||
first_frame_io_position: this.first_config_io_position,
|
||||
first_frame_is_opaque: (this.color_type <= 3) and (not this.seen_trns))
|
||||
}
|
||||
|
||||
// For still (non-animated) PNGs, the first and only frame's configuration
|
||||
// is implied by the IHDR chunk instead of an explicit fcTL chunk.
|
||||
if not this.seen_actl {
|
||||
this.num_animation_frames_value = 1
|
||||
this.first_rect_x0 = 0
|
||||
this.first_rect_y0 = 0
|
||||
this.first_rect_x1 = this.width
|
||||
this.first_rect_y1 = this.height
|
||||
this.first_duration = 0
|
||||
this.first_disposal = base.ANIMATION_DISPOSAL__NONE
|
||||
this.first_overwrite_instead_of_blend = false
|
||||
}
|
||||
|
||||
this.call_sequence = 3
|
||||
}
|
||||
|
||||
@@ -251,7 +389,7 @@ pri func decoder.decode_ihdr?(src: base.io_reader) {
|
||||
// Compression.
|
||||
a8 = args.src.read_u8?()
|
||||
if a8 <> 0 {
|
||||
return "#bad header"
|
||||
return "#unsupported PNG compression method"
|
||||
}
|
||||
|
||||
// Filter.
|
||||
@@ -275,7 +413,7 @@ pri func decoder.decode_ihdr?(src: base.io_reader) {
|
||||
this.filter_distance = 0
|
||||
this.assign_filter_distance!()
|
||||
if this.filter_distance == 0 {
|
||||
return "#unsupported PNG file"
|
||||
return "#bad header"
|
||||
}
|
||||
this.overall_workbuf_length = (this.height as base.u64) *
|
||||
(1 + this.calculate_bytes_per_row(width: this.width))
|
||||
@@ -284,7 +422,9 @@ pri func decoder.decode_ihdr?(src: base.io_reader) {
|
||||
|
||||
pri func decoder.assign_filter_distance!() {
|
||||
if this.depth < 8 {
|
||||
if this.color_type == 0 {
|
||||
if (this.depth <> 1) and (this.depth <> 2) and (this.depth <> 4) {
|
||||
return nothing
|
||||
} else if this.color_type == 0 {
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__Y
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__Y
|
||||
} else if this.color_type == 3 {
|
||||
@@ -303,8 +443,14 @@ pri func decoder.assign_filter_distance!() {
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__Y
|
||||
this.filter_distance = 1
|
||||
} else if this.depth == 16 {
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__Y_16LE
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__Y_16BE
|
||||
if this.interlace_pass == 0 {
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__Y_16LE
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__Y_16BE
|
||||
} else {
|
||||
// Interlaced means choosing filter_and_swizzle_tricky.
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
|
||||
}
|
||||
this.filter_distance = 2
|
||||
}
|
||||
|
||||
@@ -397,11 +543,84 @@ pri func decoder.choose_filter_implementations!() {
|
||||
|
||||
pri func decoder.decode_other_chunk?(src: base.io_reader) {
|
||||
if this.chunk_type == 'PLTE'le {
|
||||
if this.seen_plte or (this.color_type <> 3) {
|
||||
if this.seen_plte {
|
||||
return "#bad chunk"
|
||||
} else if this.color_type == 3 {
|
||||
// Color type 3 means paletted.
|
||||
this.decode_plte?(src: args.src)
|
||||
} else if (this.color_type == 2) or (this.color_type == 6) {
|
||||
// Color types 2 and 6 means RGB and RGBA. In these cases, the PLTE
|
||||
// chunk is merely a hint, like a sPLT "suggested palette" chunk.
|
||||
// We ignore it.
|
||||
} else {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.decode_plte?(src: args.src)
|
||||
this.seen_plte = true
|
||||
|
||||
} else if (this.chunk_type & ANCILLARY_BIT) == 0 {
|
||||
if this.chunk_type <> 'IDAT'le {
|
||||
return "#bad chunk"
|
||||
}
|
||||
|
||||
} else if this.chunk_type == 'acTL'le {
|
||||
if this.seen_actl {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.decode_actl?(src: args.src)
|
||||
this.seen_actl = true
|
||||
|
||||
} else if this.chunk_type == 'cHRM'le {
|
||||
if this.report_metadata_chrm {
|
||||
if this.seen_chrm {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.decode_chrm?(src: args.src)
|
||||
this.seen_chrm = true
|
||||
}
|
||||
|
||||
} else if this.chunk_type == 'eXIf'le {
|
||||
if this.report_metadata_exif {
|
||||
if this.seen_exif {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.decode_exif?(src: args.src)
|
||||
this.seen_exif = true
|
||||
}
|
||||
|
||||
} else if this.chunk_type == 'fcTL'le {
|
||||
if this.seen_fctl {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.decode_fctl?(src: args.src)
|
||||
this.seen_fctl = true
|
||||
|
||||
} else if this.chunk_type == 'gAMA'le {
|
||||
if this.report_metadata_gama {
|
||||
if this.seen_gama {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.decode_gama?(src: args.src)
|
||||
this.seen_gama = true
|
||||
}
|
||||
|
||||
} else if this.chunk_type == 'iCCP'le {
|
||||
if this.report_metadata_iccp {
|
||||
if this.seen_iccp {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.decode_iccp?(src: args.src)
|
||||
this.seen_iccp = true
|
||||
}
|
||||
|
||||
} else if this.chunk_type == 'sRGB'le {
|
||||
if this.report_metadata_srgb {
|
||||
if this.seen_srgb {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.decode_srgb?(src: args.src)
|
||||
this.seen_srgb = true
|
||||
}
|
||||
|
||||
} else if this.chunk_type == 'tRNS'le {
|
||||
if this.seen_trns or (this.color_type > 3) or
|
||||
((this.color_type == 3) and (not this.seen_plte)) {
|
||||
@@ -409,9 +628,212 @@ pri func decoder.decode_other_chunk?(src: base.io_reader) {
|
||||
}
|
||||
this.decode_trns?(src: args.src)
|
||||
this.seen_trns = true
|
||||
} else {
|
||||
args.src.skip?(n: this.chunk_length)
|
||||
|
||||
} else if (this.chunk_type == 'iTXt'le) or
|
||||
(this.chunk_type == 'tEXt'le) or
|
||||
(this.chunk_type == 'zTXt'le) {
|
||||
if this.report_metadata_kvp {
|
||||
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM
|
||||
this.metadata_fourcc = 'KVPK'be
|
||||
this.metadata_x = 0
|
||||
this.metadata_y = 0
|
||||
this.metadata_z = 0
|
||||
}
|
||||
}
|
||||
|
||||
if this.metadata_fourcc == 0 {
|
||||
args.src.skip_u32?(n: this.chunk_length)
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.decode_actl?(src: base.io_reader) {
|
||||
if this.chunk_length <> 8 {
|
||||
return "#bad chunk"
|
||||
} else if this.interlace_pass > 0 {
|
||||
// https://wiki.mozilla.org/APNG_Specification doesn't say whether the
|
||||
// interlace pattern starts at the image or frame top-left corner. We
|
||||
// avoid the question by returning "unsupported" for now.
|
||||
return "#unsupported PNG file"
|
||||
}
|
||||
this.chunk_length = 0
|
||||
this.num_animation_frames_value = args.src.read_u32be?()
|
||||
if this.num_animation_frames_value == 0 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.num_animation_loops_value = args.src.read_u32be?()
|
||||
}
|
||||
|
||||
pri func decoder.decode_chrm?(src: base.io_reader) {
|
||||
var u : base.u64
|
||||
|
||||
if this.chunk_length <> 32 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length = 0
|
||||
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_PARSED
|
||||
this.metadata_fourcc = 'CHRM'be
|
||||
this.metadata_x = 0
|
||||
this.metadata_y = 0
|
||||
this.metadata_z = 0
|
||||
|
||||
// See the wuffs_base__more_information__metadata_parsed__chrm comments for
|
||||
// how we pack the eight chromaticity values into three u64 fields. This
|
||||
// admittedly truncates chromaticity values from 32 to 24 bits, but in
|
||||
// practice they only range between 0 and 100000 (which is 0x01_86A0).
|
||||
u = args.src.read_u32be_as_u64?()
|
||||
this.metadata_x |= (0xFF_FFFF & u) << 0
|
||||
u = args.src.read_u32be_as_u64?()
|
||||
this.metadata_x |= (0xFF_FFFF & u) << 24
|
||||
u = args.src.read_u32be_as_u64?()
|
||||
this.metadata_x |= (0xFF_FFFF & u) ~mod<< 48
|
||||
this.metadata_y |= (0xFF_FFFF & u) >> 16
|
||||
u = args.src.read_u32be_as_u64?()
|
||||
this.metadata_y |= (0xFF_FFFF & u) << 8
|
||||
u = args.src.read_u32be_as_u64?()
|
||||
this.metadata_y |= (0xFF_FFFF & u) << 32
|
||||
u = args.src.read_u32be_as_u64?()
|
||||
this.metadata_y |= (0xFF_FFFF & u) ~mod<< 56
|
||||
this.metadata_z |= (0xFF_FFFF & u) >> 8
|
||||
u = args.src.read_u32be_as_u64?()
|
||||
this.metadata_z |= (0xFF_FFFF & u) << 16
|
||||
u = args.src.read_u32be_as_u64?()
|
||||
this.metadata_z |= (0xFF_FFFF & u) << 40
|
||||
}
|
||||
|
||||
pri func decoder.decode_exif?(src: base.io_reader) {
|
||||
if this.chunk_length < 4 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH
|
||||
this.metadata_fourcc = 'EXIF'be
|
||||
this.metadata_x = 0
|
||||
this.metadata_y = args.src.position()
|
||||
this.metadata_z = this.metadata_y ~sat+ (this.chunk_length as base.u64)
|
||||
this.chunk_length = 0
|
||||
}
|
||||
|
||||
pri func decoder.decode_fctl?(src: base.io_reader) {
|
||||
var x0 : base.u32
|
||||
var y0 : base.u32
|
||||
var x1 : base.u32
|
||||
var y1 : base.u32
|
||||
|
||||
if this.chunk_length <> 26 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length = 0
|
||||
|
||||
x0 = args.src.read_u32be?()
|
||||
if x0 <> this.next_animation_seq_num {
|
||||
return "#bad animation sequence number"
|
||||
} else if this.next_animation_seq_num >= 0xFFFF_FFFF {
|
||||
return "#unsupported PNG file"
|
||||
}
|
||||
this.next_animation_seq_num += 1
|
||||
|
||||
x1 = args.src.read_u32be?()
|
||||
y1 = args.src.read_u32be?()
|
||||
x0 = args.src.read_u32be?()
|
||||
y0 = args.src.read_u32be?()
|
||||
x1 ~mod+= x0
|
||||
y1 ~mod+= y0
|
||||
if (x0 >= x1) or (x0 > this.width) or (x1 > this.width) or
|
||||
(y0 >= y1) or (y0 > this.height) or (y1 > this.height) {
|
||||
return "#bad chunk"
|
||||
}
|
||||
assert x1 <= 0x00FF_FFFF via "a <= b: a <= c; c <= b"(c: this.width)
|
||||
assert y1 <= 0x00FF_FFFF via "a <= b: a <= c; c <= b"(c: this.height)
|
||||
assert x0 <= 0x00FF_FFFF via "a <= b: a <= c; c <= b"(c: x1)
|
||||
assert y0 <= 0x00FF_FFFF via "a <= b: a <= c; c <= b"(c: y1)
|
||||
this.frame_rect_x0 = x0
|
||||
this.frame_rect_y0 = y0
|
||||
this.frame_rect_x1 = x1
|
||||
this.frame_rect_y1 = y1
|
||||
|
||||
// There are 705_600000 flicks per second. A nominally zero denominator
|
||||
// means to use 100 instead (the units are centiseconds, the same as GIF).
|
||||
x0 = args.src.read_u16be_as_u32?()
|
||||
x1 = args.src.read_u16be_as_u32?()
|
||||
if x1 <= 0 {
|
||||
this.frame_duration = (x0 as base.u64) * 7_056000
|
||||
} else {
|
||||
this.frame_duration = ((x0 as base.u64) * 705_600000) / (x1 as base.u64)
|
||||
}
|
||||
|
||||
x0 = args.src.read_u8_as_u32?()
|
||||
if x0 == 0 {
|
||||
this.frame_disposal = base.ANIMATION_DISPOSAL__NONE
|
||||
} else if x0 == 1 {
|
||||
this.frame_disposal = base.ANIMATION_DISPOSAL__RESTORE_BACKGROUND
|
||||
} else if x0 == 2 {
|
||||
this.frame_disposal = base.ANIMATION_DISPOSAL__RESTORE_PREVIOUS
|
||||
} else {
|
||||
return "#bad chunk"
|
||||
}
|
||||
|
||||
x0 = args.src.read_u8_as_u32?()
|
||||
if x0 == 0 {
|
||||
this.frame_overwrite_instead_of_blend = true
|
||||
} else if x0 == 1 {
|
||||
this.frame_overwrite_instead_of_blend = false
|
||||
} else {
|
||||
return "#bad chunk"
|
||||
}
|
||||
|
||||
if this.num_decoded_frame_configs_value == 0 {
|
||||
this.first_rect_x0 = this.frame_rect_x0
|
||||
this.first_rect_y0 = this.frame_rect_y0
|
||||
this.first_rect_x1 = this.frame_rect_x1
|
||||
this.first_rect_y1 = this.frame_rect_y1
|
||||
this.first_duration = this.frame_duration
|
||||
this.first_disposal = this.frame_disposal
|
||||
this.first_overwrite_instead_of_blend = this.frame_overwrite_instead_of_blend
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.decode_gama?(src: base.io_reader) {
|
||||
if this.chunk_length <> 4 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length = 0
|
||||
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_PARSED
|
||||
this.metadata_fourcc = 'GAMA'be
|
||||
this.metadata_x = args.src.read_u32be_as_u64?()
|
||||
this.metadata_y = 0
|
||||
this.metadata_z = 0
|
||||
}
|
||||
|
||||
pri func decoder.decode_iccp?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
|
||||
// Skip the NUL-terminated color profile name.
|
||||
while true {
|
||||
if this.chunk_length <= 0 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
c = args.src.read_u8?()
|
||||
if c == 0 {
|
||||
break
|
||||
}
|
||||
} endwhile
|
||||
|
||||
// Compression method.
|
||||
if this.chunk_length <= 0 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0 {
|
||||
return "#unsupported PNG compression method"
|
||||
}
|
||||
|
||||
this.metadata_is_zlib_compressed = true
|
||||
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM
|
||||
this.metadata_fourcc = 'ICCP'be
|
||||
this.metadata_x = 0
|
||||
this.metadata_y = 0
|
||||
this.metadata_z = 0
|
||||
}
|
||||
|
||||
pri func decoder.decode_plte?(src: base.io_reader) {
|
||||
@@ -423,6 +845,7 @@ pri func decoder.decode_plte?(src: base.io_reader) {
|
||||
return "#bad chunk"
|
||||
}
|
||||
num_entries = (this.chunk_length as base.u32) / 3
|
||||
this.chunk_length = 0
|
||||
|
||||
while i < num_entries {
|
||||
assert i < 256 via "a < b: a < c; c <= b"(c: num_entries)
|
||||
@@ -447,82 +870,304 @@ pri func decoder.decode_plte?(src: base.io_reader) {
|
||||
} endwhile
|
||||
}
|
||||
|
||||
pri func decoder.decode_trns?(src: base.io_reader) {
|
||||
var num_entries : base.u32[..= 256]
|
||||
var i : base.u32
|
||||
|
||||
if this.chunk_length > 256 {
|
||||
pri func decoder.decode_srgb?(src: base.io_reader) {
|
||||
if this.chunk_length <> 1 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
num_entries = this.chunk_length as base.u32
|
||||
this.chunk_length = 0
|
||||
this.metadata_flavor = base.MORE_INFORMATION__FLAVOR__METADATA_PARSED
|
||||
this.metadata_fourcc = 'SRGB'be
|
||||
this.metadata_x = args.src.read_u8_as_u64?()
|
||||
this.metadata_y = 0
|
||||
this.metadata_z = 0
|
||||
}
|
||||
|
||||
while i < num_entries {
|
||||
assert i < 256 via "a < b: a < c; c <= b"(c: num_entries)
|
||||
this.src_palette[(4 * i) + 3] = args.src.read_u8?()
|
||||
i += 1
|
||||
} endwhile
|
||||
pri func decoder.decode_trns?(src: base.io_reader) {
|
||||
var i : base.u32
|
||||
var n : base.u32[..= 256]
|
||||
var u : base.u64
|
||||
|
||||
if this.color_type == 3 {
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL
|
||||
} else {
|
||||
if this.color_type == 0 {
|
||||
choose filter_and_swizzle = [filter_and_swizzle_tricky]
|
||||
if this.color_type == 0 {
|
||||
// TODO: PIXEL_FORMAT__YA_NONPREMUL
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
|
||||
} else if this.color_type == 2 {
|
||||
if this.depth <= 8 {
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
} else {
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
|
||||
}
|
||||
if this.chunk_length <> 2 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length = 0
|
||||
|
||||
u = args.src.read_u16be_as_u64?()
|
||||
if this.depth <= 1 {
|
||||
this.remap_transparency = ((u & 0x01) * 0xFF_FFFF) | 0xFF00_0000
|
||||
} else if this.depth <= 2 {
|
||||
this.remap_transparency = ((u & 0x03) * 0x55_5555) | 0xFF00_0000
|
||||
} else if this.depth <= 4 {
|
||||
this.remap_transparency = ((u & 0x0F) * 0x11_1111) | 0xFF00_0000
|
||||
} else if this.depth <= 8 {
|
||||
this.remap_transparency = ((u & 0xFF) * 0x01_0101) | 0xFF00_0000
|
||||
} else {
|
||||
this.remap_transparency = (u * 0x0001_0001_0001) | 0xFFFF_0000_0000_0000
|
||||
}
|
||||
|
||||
} else if this.color_type == 2 {
|
||||
choose filter_and_swizzle = [filter_and_swizzle_tricky]
|
||||
if this.depth <= 8 {
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL
|
||||
} else {
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
|
||||
}
|
||||
if this.chunk_length <> 6 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length = 0
|
||||
|
||||
u = args.src.read_u48be_as_u64?()
|
||||
if this.depth <= 8 {
|
||||
this.remap_transparency =
|
||||
(0x0000_00FF & (u >> 0)) |
|
||||
(0x0000_FF00 & (u >> 8)) |
|
||||
(0x00FF_0000 & (u >> 16)) |
|
||||
0xFF00_0000
|
||||
} else {
|
||||
this.remap_transparency = u | 0xFFFF_0000_0000_0000
|
||||
}
|
||||
|
||||
} else if this.color_type == 3 {
|
||||
this.dst_pixfmt = base.PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL
|
||||
this.src_pixfmt = base.PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL
|
||||
if this.chunk_length > 256 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
n = this.chunk_length as base.u32
|
||||
this.chunk_length = 0
|
||||
while i < n {
|
||||
assert i < 256 via "a < b: a < c; c <= b"(c: n)
|
||||
this.src_palette[(4 * i) + 3] = args.src.read_u8?()
|
||||
i += 1
|
||||
} endwhile
|
||||
|
||||
} else {
|
||||
return "#bad chunk"
|
||||
}
|
||||
}
|
||||
|
||||
pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
|
||||
if this.call_sequence < 3 {
|
||||
if this.call_sequence == 0xFF {
|
||||
return base."@end of data"
|
||||
} else if this.call_sequence < 3 {
|
||||
this.decode_image_config?(dst: nullptr, src: args.src)
|
||||
} else if this.call_sequence == 3 {
|
||||
if this.frame_config_io_position <> args.src.position() {
|
||||
return base."#bad restart"
|
||||
}
|
||||
} else if this.call_sequence == 4 {
|
||||
this.call_sequence = 0xFF
|
||||
return base."@end of data"
|
||||
this.skip_frame?(src: args.src)
|
||||
if this.call_sequence == 0xFF {
|
||||
return base."@end of data"
|
||||
}
|
||||
}
|
||||
|
||||
if this.num_decoded_frame_configs_value == 0 {
|
||||
this.frame_rect_x0 = this.first_rect_x0
|
||||
this.frame_rect_y0 = this.first_rect_y0
|
||||
this.frame_rect_x1 = this.first_rect_x1
|
||||
this.frame_rect_y1 = this.first_rect_y1
|
||||
this.frame_config_io_position = this.first_config_io_position
|
||||
this.frame_duration = this.first_duration
|
||||
this.frame_disposal = this.first_disposal
|
||||
this.frame_overwrite_instead_of_blend = this.first_overwrite_instead_of_blend
|
||||
|
||||
} else {
|
||||
return base."@end of data"
|
||||
// Decode the next fcTL chunk.
|
||||
while true {
|
||||
this.chunk_length = args.src.read_u32be?()
|
||||
this.chunk_type = args.src.read_u32le?()
|
||||
if this.chunk_type == 'fdAT'le {
|
||||
return "#bad chunk"
|
||||
} else if this.chunk_type == 'fcTL'le {
|
||||
this.frame_config_io_position = args.src.position() ~mod- 8
|
||||
this.decode_fctl?(src: args.src)
|
||||
args.src.skip?(n: 4) // Skip the checksum.
|
||||
break
|
||||
}
|
||||
args.src.skip?(n: (this.chunk_length as base.u64) + 4) // +4 for the checksum.
|
||||
this.chunk_length = 0
|
||||
} endwhile
|
||||
}
|
||||
|
||||
if args.dst <> nullptr {
|
||||
args.dst.set!(bounds: this.util.make_rect_ie_u32(
|
||||
min_incl_x: 0,
|
||||
min_incl_y: 0,
|
||||
max_excl_x: this.width,
|
||||
max_excl_y: this.height),
|
||||
duration: 0,
|
||||
index: 0,
|
||||
min_incl_x: this.frame_rect_x0,
|
||||
min_incl_y: this.frame_rect_y0,
|
||||
max_excl_x: this.frame_rect_x1,
|
||||
max_excl_y: this.frame_rect_y1),
|
||||
duration: this.frame_duration,
|
||||
index: this.num_decoded_frame_configs_value as base.u64,
|
||||
io_position: this.frame_config_io_position,
|
||||
disposal: 0,
|
||||
opaque_within_bounds: false,
|
||||
overwrite_instead_of_blend: false,
|
||||
disposal: this.frame_disposal,
|
||||
opaque_within_bounds: (this.color_type <= 3) and (not this.seen_trns),
|
||||
overwrite_instead_of_blend: this.frame_overwrite_instead_of_blend,
|
||||
background_color: 0x0000_0000)
|
||||
}
|
||||
|
||||
this.num_decoded_frame_configs_value ~sat+= 1
|
||||
this.call_sequence = 4
|
||||
}
|
||||
|
||||
pri func decoder.skip_frame?(src: base.io_reader) {
|
||||
var seq_num : base.u32
|
||||
|
||||
this.chunk_type_array[0] = 0
|
||||
this.chunk_type_array[1] = 0
|
||||
this.chunk_type_array[2] = 0
|
||||
this.chunk_type_array[3] = 0
|
||||
|
||||
while true {
|
||||
while args.src.length() < 8,
|
||||
post args.src.length() >= 8,
|
||||
{
|
||||
if args.src.is_closed() {
|
||||
return "#bad chunk"
|
||||
}
|
||||
yield? base."$short read"
|
||||
} endwhile
|
||||
|
||||
this.chunk_length = args.src.peek_u32be()
|
||||
this.chunk_type = (args.src.peek_u64le() >> 32) as base.u32
|
||||
|
||||
if this.chunk_type == 'IDAT'le {
|
||||
if this.chunk_type_array[0] == 'f' {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_type_array[0] = 'I'
|
||||
this.chunk_type_array[1] = 'D'
|
||||
this.chunk_type_array[2] = 'A'
|
||||
this.chunk_type_array[3] = 'T'
|
||||
|
||||
} else if this.chunk_type == 'fdAT'le {
|
||||
if this.chunk_type_array[0] == 'I' {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_type_array[0] = 'f'
|
||||
this.chunk_type_array[1] = 'd'
|
||||
this.chunk_type_array[2] = 'A'
|
||||
this.chunk_type_array[3] = 'T'
|
||||
if this.chunk_length < 4 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 4
|
||||
args.src.skip_u32_fast!(actual: 8, worst_case: 8)
|
||||
seq_num = args.src.read_u32be?()
|
||||
if seq_num <> this.next_animation_seq_num {
|
||||
return "#bad animation sequence number"
|
||||
} else if this.next_animation_seq_num >= 0xFFFF_FFFF {
|
||||
return "#unsupported PNG file"
|
||||
}
|
||||
this.next_animation_seq_num += 1
|
||||
args.src.skip?(n: (this.chunk_length as base.u64) + 4) // +4 for the checksum.
|
||||
this.chunk_length = 0
|
||||
continue
|
||||
|
||||
} else if this.chunk_type_array[0] <> 0 {
|
||||
break
|
||||
|
||||
} else if this.chunk_type == 'fcTL'le {
|
||||
return "#bad chunk"
|
||||
}
|
||||
|
||||
// +12 for chunk length, chunk type and checksum.
|
||||
args.src.skip?(n: (this.chunk_length as base.u64) + 12)
|
||||
this.chunk_length = 0
|
||||
} endwhile
|
||||
|
||||
this.num_decoded_frames_value ~sat+= 1
|
||||
if this.num_decoded_frames_value < this.num_animation_frames_value {
|
||||
this.call_sequence = 5
|
||||
} else {
|
||||
this.call_sequence = 0xFF
|
||||
}
|
||||
}
|
||||
|
||||
pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
|
||||
var seq_num : base.u32
|
||||
var status : base.status
|
||||
var pass_width : base.u32[..= 0x00FF_FFFF]
|
||||
var pass_height : base.u32[..= 0x00FF_FFFF]
|
||||
|
||||
if this.call_sequence < 4 {
|
||||
this.decode_frame_config?(dst: nullptr, src: args.src)
|
||||
} else if this.call_sequence == 4 {
|
||||
// No-op.
|
||||
} else {
|
||||
if this.call_sequence == 0xFF {
|
||||
return base."@end of data"
|
||||
} else if this.call_sequence <> 4 {
|
||||
this.decode_frame_config?(dst: nullptr, src: args.src)
|
||||
}
|
||||
|
||||
while true {
|
||||
while args.src.length() < 8,
|
||||
post args.src.length() >= 8,
|
||||
{
|
||||
if args.src.is_closed() {
|
||||
return "#bad chunk"
|
||||
}
|
||||
yield? base."$short read"
|
||||
} endwhile
|
||||
|
||||
this.chunk_length = args.src.peek_u32be()
|
||||
this.chunk_type = (args.src.peek_u64le() >> 32) as base.u32
|
||||
|
||||
if this.chunk_type == 'IDAT'le {
|
||||
this.chunk_type_array[0] = 'I'
|
||||
this.chunk_type_array[1] = 'D'
|
||||
this.chunk_type_array[2] = 'A'
|
||||
this.chunk_type_array[3] = 'T'
|
||||
args.src.skip_u32_fast!(actual: 8, worst_case: 8)
|
||||
if not this.ignore_checksum {
|
||||
this.crc32.reset!()
|
||||
this.crc32.update_u32!(x: this.chunk_type_array[..])
|
||||
}
|
||||
break
|
||||
|
||||
} else if this.chunk_type == 'fdAT'le {
|
||||
this.chunk_type_array[0] = 'f'
|
||||
this.chunk_type_array[1] = 'd'
|
||||
this.chunk_type_array[2] = 'A'
|
||||
this.chunk_type_array[3] = 'T'
|
||||
if this.chunk_length < 4 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 4
|
||||
args.src.skip_u32_fast!(actual: 8, worst_case: 8)
|
||||
seq_num = args.src.read_u32be?()
|
||||
if seq_num <> this.next_animation_seq_num {
|
||||
return "#bad animation sequence number"
|
||||
} else if this.next_animation_seq_num >= 0xFFFF_FFFF {
|
||||
return "#unsupported PNG file"
|
||||
}
|
||||
this.next_animation_seq_num += 1
|
||||
break
|
||||
|
||||
} else if this.chunk_type == 'fcTL'le {
|
||||
return "#bad chunk"
|
||||
}
|
||||
|
||||
// +12 for chunk length, chunk type and checksum.
|
||||
args.src.skip?(n: (this.chunk_length as base.u64) + 12)
|
||||
this.chunk_length = 0
|
||||
} endwhile
|
||||
|
||||
if this.zlib_is_dirty {
|
||||
this.zlib.reset!()
|
||||
if this.ignore_checksum {
|
||||
this.zlib.set_quirk_enabled!(quirk: base.QUIRK_IGNORE_CHECKSUM, enabled: true)
|
||||
}
|
||||
}
|
||||
this.zlib_is_dirty = true
|
||||
|
||||
status = this.swizzler.prepare!(
|
||||
dst_pixfmt: args.dst.pixel_format(),
|
||||
dst_palette: args.dst.palette_or_else(fallback: this.dst_palette[..]),
|
||||
@@ -533,13 +1178,19 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
|
||||
return status
|
||||
}
|
||||
|
||||
this.workbuf_hist_pos_base = 0
|
||||
while true {
|
||||
pass_width = 0x00FF_FFFF &
|
||||
(((INTERLACING[this.interlace_pass][1] as base.u32) + this.width) >>
|
||||
INTERLACING[this.interlace_pass][0])
|
||||
pass_height = 0x00FF_FFFF &
|
||||
(((INTERLACING[this.interlace_pass][4] as base.u32) + this.height) >>
|
||||
INTERLACING[this.interlace_pass][3])
|
||||
if (this.chunk_type_array[0] == 'I') {
|
||||
pass_width = 0x00FF_FFFF &
|
||||
(((INTERLACING[this.interlace_pass][1] as base.u32) + this.width) >>
|
||||
INTERLACING[this.interlace_pass][0])
|
||||
pass_height = 0x00FF_FFFF &
|
||||
(((INTERLACING[this.interlace_pass][4] as base.u32) + this.height) >>
|
||||
INTERLACING[this.interlace_pass][3])
|
||||
} else {
|
||||
pass_width = 0x00FF_FFFF & (this.frame_rect_x1 ~mod- this.frame_rect_x0)
|
||||
pass_height = 0x00FF_FFFF & (this.frame_rect_y1 ~mod- this.frame_rect_y0)
|
||||
}
|
||||
|
||||
if (pass_width > 0) and (pass_height > 0) {
|
||||
this.pass_bytes_per_row = this.calculate_bytes_per_row(width: pass_width)
|
||||
@@ -549,6 +1200,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
|
||||
if not status.is_ok() {
|
||||
return status
|
||||
}
|
||||
this.workbuf_hist_pos_base ~mod+= this.pass_workbuf_length
|
||||
}
|
||||
|
||||
if (this.interlace_pass == 0) or (this.interlace_pass >= 7) {
|
||||
@@ -557,7 +1209,12 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
|
||||
this.interlace_pass += 1
|
||||
} endwhile
|
||||
|
||||
this.call_sequence = 0xFF
|
||||
this.num_decoded_frames_value ~sat+= 1
|
||||
if this.num_decoded_frames_value < this.num_animation_frames_value {
|
||||
this.call_sequence = 5
|
||||
} else {
|
||||
this.call_sequence = 0xFF
|
||||
}
|
||||
}
|
||||
|
||||
pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
@@ -567,6 +1224,7 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
var zlib_status : base.status
|
||||
var checksum_have : base.u32
|
||||
var checksum_want : base.u32
|
||||
var seq_num : base.u32
|
||||
|
||||
this.workbuf_wi = 0
|
||||
while true {
|
||||
@@ -574,8 +1232,8 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
this.pass_workbuf_length > args.workbuf.length()) {
|
||||
return base."#bad workbuf length"
|
||||
}
|
||||
io_bind (io: w, data: args.workbuf[this.workbuf_wi .. this.pass_workbuf_length]) {
|
||||
io_limit (io: args.src, limit: this.chunk_length) {
|
||||
io_bind (io: w, data: args.workbuf[this.workbuf_wi .. this.pass_workbuf_length], history_position: this.workbuf_hist_pos_base ~mod+ this.workbuf_wi) {
|
||||
io_limit (io: args.src, limit: (this.chunk_length as base.u64)) {
|
||||
w_mark = w.mark()
|
||||
r_mark = args.src.mark()
|
||||
zlib_status =? this.zlib.transform_io?(
|
||||
@@ -583,20 +1241,20 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
if not this.ignore_checksum {
|
||||
this.crc32.update_u32!(x: args.src.since(mark: r_mark))
|
||||
}
|
||||
this.chunk_length ~sat-= args.src.count_since(mark: r_mark)
|
||||
this.chunk_length ~sat-= (args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
|
||||
this.workbuf_wi ~sat+= w.count_since(mark: w_mark)
|
||||
}
|
||||
}
|
||||
|
||||
if zlib_status.is_ok() {
|
||||
if this.chunk_length > 0 {
|
||||
// TODO: should this really be a fatal error?
|
||||
return base."#too much data"
|
||||
}
|
||||
checksum_want = args.src.read_u32be?()
|
||||
// Verify the final IDAT chunk's CRC-32 checksum.
|
||||
if not this.ignore_checksum {
|
||||
if this.chunk_length > 0 {
|
||||
// TODO: should this really be a fatal error?
|
||||
return base."#too much data"
|
||||
}
|
||||
if (not this.ignore_checksum) and (this.chunk_type_array[0] == 'I') {
|
||||
checksum_have = this.crc32.update_u32!(x: this.util.empty_slice_u8())
|
||||
checksum_want = args.src.read_u32be?()
|
||||
if checksum_have <> checksum_want {
|
||||
return "#bad checksum"
|
||||
}
|
||||
@@ -612,28 +1270,37 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
} else if this.chunk_length == 0 {
|
||||
// Verify the non-final IDAT chunk's CRC-32 checksum.
|
||||
checksum_want = args.src.read_u32be?()
|
||||
if not this.ignore_checksum {
|
||||
if (not this.ignore_checksum) and (this.chunk_type_array[0] == 'I') {
|
||||
checksum_have = this.crc32.update_u32!(x: this.util.empty_slice_u8())
|
||||
if checksum_have <> checksum_want {
|
||||
return "#bad checksum"
|
||||
}
|
||||
}
|
||||
|
||||
// The next chunk should be another IDAT.
|
||||
this.chunk_length = args.src.read_u32be_as_u64?()
|
||||
// The next chunk should be another IDAT or fdAT.
|
||||
this.chunk_length = args.src.read_u32be?()
|
||||
this.chunk_type = args.src.read_u32le?()
|
||||
if this.chunk_type <> 'IDAT'le {
|
||||
return "#bad chunk"
|
||||
}
|
||||
|
||||
// The 'IDAT'be is part of the next CRC-32 checksum's input.
|
||||
if not this.ignore_checksum {
|
||||
this.crc32.reset!()
|
||||
this.chunk_type_array[0] = 'I'
|
||||
this.chunk_type_array[1] = 'D'
|
||||
this.chunk_type_array[2] = 'A'
|
||||
this.chunk_type_array[3] = 'T'
|
||||
this.crc32.update_u32!(x: this.chunk_type_array[..])
|
||||
if (this.chunk_type_array[0] == 'I') {
|
||||
if this.chunk_type <> 'IDAT'le {
|
||||
return "#bad chunk"
|
||||
}
|
||||
// The IDAT is part of the next CRC-32 checksum's input.
|
||||
if not this.ignore_checksum {
|
||||
this.crc32.reset!()
|
||||
this.crc32.update_u32!(x: this.chunk_type_array[..])
|
||||
}
|
||||
} else {
|
||||
if (this.chunk_type <> 'fdAT'le) or (this.chunk_length < 4) {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 4
|
||||
seq_num = args.src.read_u32be?()
|
||||
if seq_num <> this.next_animation_seq_num {
|
||||
return "#bad animation sequence number"
|
||||
} else if this.next_animation_seq_num >= 0xFFFF_FFFF {
|
||||
return "#unsupported PNG file"
|
||||
}
|
||||
this.next_animation_seq_num += 1
|
||||
}
|
||||
continue
|
||||
} else if args.src.length() > 0 {
|
||||
@@ -656,35 +1323,29 @@ pri func decoder.decode_pass?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
|
||||
pub func decoder.frame_dirty_rect() base.rect_ie_u32 {
|
||||
return this.util.make_rect_ie_u32(
|
||||
min_incl_x: 0,
|
||||
min_incl_y: 0,
|
||||
max_excl_x: this.width,
|
||||
max_excl_y: this.height)
|
||||
min_incl_x: this.frame_rect_x0,
|
||||
min_incl_y: this.frame_rect_y0,
|
||||
max_excl_x: this.frame_rect_x1,
|
||||
max_excl_y: this.frame_rect_y1)
|
||||
}
|
||||
|
||||
pub func decoder.num_animation_loops() base.u32 {
|
||||
return 0
|
||||
return this.num_animation_loops_value
|
||||
}
|
||||
|
||||
pub func decoder.num_decoded_frame_configs() base.u64 {
|
||||
if this.call_sequence > 3 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
return this.num_decoded_frame_configs_value as base.u64
|
||||
}
|
||||
|
||||
pub func decoder.num_decoded_frames() base.u64 {
|
||||
if this.call_sequence > 4 {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
return this.num_decoded_frames_value as base.u64
|
||||
}
|
||||
|
||||
pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.status {
|
||||
if this.call_sequence < 3 {
|
||||
return base."#bad call sequence"
|
||||
}
|
||||
if args.index <> 0 {
|
||||
} else if (args.index >= (this.num_animation_frames_value as base.u64)) or
|
||||
((args.index == 0) and (args.io_position <> this.first_config_io_position)) {
|
||||
return base."#bad argument"
|
||||
}
|
||||
this.call_sequence = 3
|
||||
@@ -692,15 +1353,323 @@ pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.sta
|
||||
this.interlace_pass = 1
|
||||
}
|
||||
this.frame_config_io_position = args.io_position
|
||||
this.num_decoded_frame_configs_value = (args.index & 0xFFFF_FFFF) as base.u32
|
||||
this.num_decoded_frames_value = this.num_decoded_frame_configs_value
|
||||
return ok
|
||||
}
|
||||
|
||||
pub func decoder.set_report_metadata!(fourcc: base.u32, report: base.bool) {
|
||||
// TODO.
|
||||
if args.fourcc == 'CHRM'be {
|
||||
this.report_metadata_chrm = args.report
|
||||
} else if args.fourcc == 'EXIF'be {
|
||||
this.report_metadata_exif = args.report
|
||||
} else if args.fourcc == 'GAMA'be {
|
||||
this.report_metadata_gama = args.report
|
||||
} else if args.fourcc == 'ICCP'be {
|
||||
this.report_metadata_iccp = args.report
|
||||
} else if args.fourcc == 'KVP 'be {
|
||||
this.report_metadata_kvp = args.report
|
||||
} else if args.fourcc == 'SRGB'be {
|
||||
this.report_metadata_srgb = args.report
|
||||
}
|
||||
}
|
||||
|
||||
pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
|
||||
return base."#no more information"
|
||||
var c : base.u8
|
||||
var c2 : base.u16
|
||||
var w : base.io_writer
|
||||
var num_written : base.u64
|
||||
var w_mark : base.u64
|
||||
var r_mark : base.u64
|
||||
var zlib_status : base.status
|
||||
|
||||
if this.call_sequence <> 1 {
|
||||
return base."#bad call sequence"
|
||||
}
|
||||
if this.metadata_fourcc == 0 {
|
||||
return base."#no more information"
|
||||
}
|
||||
|
||||
while.goto_done true {{
|
||||
if this.metadata_flavor == base.MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH {
|
||||
while true {
|
||||
if args.src.position() <> this.metadata_y {
|
||||
return base."#bad I/O position"
|
||||
} else if args.minfo <> nullptr {
|
||||
args.minfo.set!(
|
||||
flavor: this.metadata_flavor,
|
||||
w: this.metadata_fourcc,
|
||||
x: this.metadata_x,
|
||||
y: this.metadata_y,
|
||||
z: this.metadata_z)
|
||||
}
|
||||
if this.metadata_y >= this.metadata_z {
|
||||
break.goto_done
|
||||
}
|
||||
this.metadata_y = this.metadata_z
|
||||
yield? base."$even more information"
|
||||
} endwhile
|
||||
}
|
||||
|
||||
if this.metadata_is_zlib_compressed {
|
||||
if this.zlib_is_dirty {
|
||||
this.zlib.reset!()
|
||||
if this.ignore_checksum {
|
||||
this.zlib.set_quirk_enabled!(quirk: base.QUIRK_IGNORE_CHECKSUM, enabled: true)
|
||||
}
|
||||
}
|
||||
this.zlib_is_dirty = true
|
||||
this.ztxt_hist_pos = 0
|
||||
}
|
||||
|
||||
while.loop true {
|
||||
if args.minfo <> nullptr {
|
||||
args.minfo.set!(
|
||||
flavor: this.metadata_flavor,
|
||||
w: this.metadata_fourcc,
|
||||
x: this.metadata_x,
|
||||
y: this.metadata_y,
|
||||
z: this.metadata_z)
|
||||
}
|
||||
|
||||
if this.metadata_flavor <> base.MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM {
|
||||
break.loop
|
||||
}
|
||||
|
||||
if this.metadata_is_zlib_compressed {
|
||||
if this.chunk_type == 'iCCP'le {
|
||||
io_limit (io: args.src, limit: this.chunk_length as base.u64) {
|
||||
r_mark = args.src.mark()
|
||||
zlib_status =? this.zlib.transform_io?(
|
||||
dst: args.dst, src: args.src, workbuf: this.util.empty_slice_u8())
|
||||
this.chunk_length ~sat-=
|
||||
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
|
||||
}
|
||||
|
||||
if zlib_status.is_ok() {
|
||||
this.metadata_is_zlib_compressed = false
|
||||
break.loop
|
||||
} else if not zlib_status.is_suspension() {
|
||||
return zlib_status
|
||||
}
|
||||
yield? zlib_status
|
||||
|
||||
} else if this.chunk_type == 'iTXt'le {
|
||||
// TODO: verify uncompressed data is UTF-8.
|
||||
io_limit (io: args.src, limit: this.chunk_length as base.u64) {
|
||||
r_mark = args.src.mark()
|
||||
zlib_status =? this.zlib.transform_io?(
|
||||
dst: args.dst, src: args.src, workbuf: this.util.empty_slice_u8())
|
||||
this.chunk_length ~sat-=
|
||||
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
|
||||
}
|
||||
|
||||
if zlib_status.is_ok() {
|
||||
this.metadata_is_zlib_compressed = false
|
||||
break.loop
|
||||
} else if not zlib_status.is_suspension() {
|
||||
return zlib_status
|
||||
}
|
||||
yield? zlib_status
|
||||
|
||||
} else if this.chunk_type == 'zTXt'le {
|
||||
// Fill this.dst_palette, zlib-uncompressing producing Latin-1.
|
||||
if this.ztxt_ri == this.ztxt_wi {
|
||||
io_bind (io: w, data: this.dst_palette[..], history_position: this.ztxt_hist_pos) {
|
||||
io_limit (io: args.src, limit: this.chunk_length as base.u64) {
|
||||
w_mark = w.mark()
|
||||
r_mark = args.src.mark()
|
||||
zlib_status =? this.zlib.transform_io?(
|
||||
dst: w, src: args.src, workbuf: this.util.empty_slice_u8())
|
||||
this.chunk_length ~sat-=
|
||||
(args.src.count_since(mark: r_mark) & 0xFFFF_FFFF) as base.u32
|
||||
num_written = w.count_since(mark: w_mark)
|
||||
}
|
||||
}
|
||||
if num_written > 1024 {
|
||||
return "#internal error: inconsistent I/O"
|
||||
}
|
||||
this.ztxt_ri = 0
|
||||
this.ztxt_wi = num_written as base.u32
|
||||
this.ztxt_hist_pos ~sat+= num_written
|
||||
}
|
||||
|
||||
// Drain this.dst_palette, converting from Latin-1 to UTF-8.
|
||||
while this.ztxt_ri < this.ztxt_wi {
|
||||
assert this.ztxt_ri < 1024 via "a < b: a < c; c <= b"(c: this.ztxt_wi)
|
||||
c2 = LATIN_1[this.dst_palette[this.ztxt_ri]]
|
||||
if c2 == 0 {
|
||||
return "#bad text chunk (not Latin-1)"
|
||||
} else if c2 <= 0x7F {
|
||||
if args.dst.length() <= 0 {
|
||||
yield? base."$short write"
|
||||
c2 = 0
|
||||
continue.loop
|
||||
}
|
||||
this.ztxt_ri += 1
|
||||
args.dst.write_u8_fast!(a: c2 as base.u8)
|
||||
} else {
|
||||
if args.dst.length() <= 1 {
|
||||
yield? base."$short write"
|
||||
c2 = 0
|
||||
continue.loop
|
||||
}
|
||||
this.ztxt_ri += 1
|
||||
args.dst.write_u16le_fast!(a: c2)
|
||||
}
|
||||
} endwhile
|
||||
|
||||
if zlib_status.is_ok() {
|
||||
this.metadata_is_zlib_compressed = false
|
||||
break.loop
|
||||
} else if not zlib_status.is_suspension() {
|
||||
return zlib_status
|
||||
} else if zlib_status <> base."$short write" {
|
||||
yield? zlib_status
|
||||
}
|
||||
|
||||
} else {
|
||||
return "#internal error: inconsistent chunk type"
|
||||
}
|
||||
|
||||
} else if (this.chunk_type == 'iTXt'le) and (this.metadata_fourcc == 'KVPV'be) {
|
||||
// iTXt value is UTF-8.
|
||||
//
|
||||
// TODO: verify data is UTF-8.
|
||||
while true {
|
||||
if this.chunk_length <= 0 {
|
||||
break.loop
|
||||
} else if args.src.length() <= 0 {
|
||||
yield? base."$short read"
|
||||
continue.loop
|
||||
} else if args.dst.length() <= 0 {
|
||||
yield? base."$short write"
|
||||
continue.loop
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
c = args.src.peek_u8()
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
args.dst.write_u8_fast!(a: c)
|
||||
} endwhile
|
||||
|
||||
} else {
|
||||
// Other uncompressed keys and values are Latin-1.
|
||||
while true {
|
||||
if this.chunk_length <= 0 {
|
||||
// Keys are NUL-terminated but values are not.
|
||||
if this.metadata_fourcc == 'KVPK'be {
|
||||
return "#bad chunk"
|
||||
}
|
||||
break.loop
|
||||
} else if args.src.length() <= 0 {
|
||||
yield? base."$short read"
|
||||
continue.loop
|
||||
}
|
||||
c = args.src.peek_u8()
|
||||
if c == 0 {
|
||||
this.chunk_length -= 1
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
break.loop
|
||||
}
|
||||
c2 = LATIN_1[c]
|
||||
if c2 == 0 {
|
||||
return "#bad text chunk (not Latin-1)"
|
||||
} else if c2 <= 0x7F {
|
||||
if args.dst.length() <= 0 {
|
||||
yield? base."$short write"
|
||||
c2 = 0
|
||||
continue.loop
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
args.dst.write_u8_fast!(a: c2 as base.u8)
|
||||
} else {
|
||||
if args.dst.length() <= 1 {
|
||||
yield? base."$short write"
|
||||
c2 = 0
|
||||
continue.loop
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
args.dst.write_u16le_fast!(a: c2)
|
||||
}
|
||||
} endwhile
|
||||
}
|
||||
} endwhile.loop
|
||||
|
||||
// Key-value pairs come in... pairs.
|
||||
if this.metadata_fourcc == 'KVPK'be {
|
||||
this.metadata_fourcc = 'KVPV'be
|
||||
if this.chunk_type == 'iTXt'le {
|
||||
// Compression flag, compression method.
|
||||
if this.chunk_length <= 1 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 2
|
||||
c = args.src.read_u8?()
|
||||
if c == 0 {
|
||||
this.metadata_is_zlib_compressed = false
|
||||
} else if c == 1 {
|
||||
this.metadata_is_zlib_compressed = true
|
||||
} else {
|
||||
return "#bad chunk"
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if (c <> 0) and this.metadata_is_zlib_compressed {
|
||||
return "#unsupported PNG compression method"
|
||||
}
|
||||
|
||||
// Skip the language tag and translated keyword: two iterations
|
||||
// looking for a NUL terminator.
|
||||
this.metadata_fourcc ~mod-= 2
|
||||
while this.metadata_fourcc <> 'KVPV'be {
|
||||
this.metadata_fourcc ~mod+= 1
|
||||
while true {
|
||||
if this.chunk_length <= 0 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
c = args.src.read_u8?()
|
||||
if c == 0 {
|
||||
break
|
||||
}
|
||||
} endwhile
|
||||
} endwhile
|
||||
|
||||
} else if this.chunk_type == 'zTXt'le {
|
||||
// Compression method.
|
||||
if this.chunk_length <= 0 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0 {
|
||||
return "#unsupported PNG compression method"
|
||||
}
|
||||
this.metadata_is_zlib_compressed = true
|
||||
}
|
||||
|
||||
this.call_sequence = 2
|
||||
return ok
|
||||
}
|
||||
break.goto_done
|
||||
}} endwhile.goto_done
|
||||
|
||||
if this.chunk_length <> 0 {
|
||||
return "#bad chunk"
|
||||
}
|
||||
|
||||
// Skip the ancillary chunk's CRC-32 checksum.
|
||||
args.src.skip?(n: 4)
|
||||
|
||||
this.metadata_flavor = 0
|
||||
this.metadata_fourcc = 0
|
||||
this.metadata_x = 0
|
||||
this.metadata_y = 0
|
||||
this.metadata_z = 0
|
||||
|
||||
this.call_sequence = 2
|
||||
return ok
|
||||
}
|
||||
|
||||
pub func decoder.workbuf_len() base.range_ii_u64 {
|
||||
@@ -708,69 +1677,3 @@ pub func decoder.workbuf_len() base.range_ii_u64 {
|
||||
min_incl: this.overall_workbuf_length,
|
||||
max_incl: this.overall_workbuf_length)
|
||||
}
|
||||
|
||||
// INTERLACING holds the Adam7 interlacing pattern, involving 7 passes:
|
||||
// 1 6 4 6 2 6 4 6
|
||||
// 7 7 7 7 7 7 7 7
|
||||
// 5 6 5 6 5 6 5 6
|
||||
// 7 7 7 7 7 7 7 7
|
||||
// 3 6 4 6 3 6 4 6
|
||||
// 7 7 7 7 7 7 7 7
|
||||
// 5 6 5 6 5 6 5 6
|
||||
// 7 7 7 7 7 7 7 7
|
||||
//
|
||||
// The six elements of each inner array are:
|
||||
// 0: log2(x_stride)
|
||||
// 1: x_stride - x_offset - 1
|
||||
// 2: x_offset
|
||||
// 3: log2(y_stride)
|
||||
// 4: y_stride - y_offset - 1
|
||||
// 5: y_offset
|
||||
pri const INTERLACING : array[8] array[6] base.u8[..= 8] = [
|
||||
[0, 0, 0, 0, 0, 0], // non-interlaced; xy_stride=1, xy_offset=0
|
||||
[3, 7, 0, 3, 7, 0], // interlace_pass == 1
|
||||
[3, 3, 4, 3, 7, 0], // interlace_pass == 2
|
||||
[2, 3, 0, 3, 3, 4], // interlace_pass == 3
|
||||
[2, 1, 2, 2, 3, 0], // interlace_pass == 4
|
||||
[1, 1, 0, 2, 1, 2], // interlace_pass == 5
|
||||
[1, 0, 1, 1, 1, 0], // interlace_pass == 6
|
||||
[0, 0, 0, 1, 0, 1], // interlace_pass == 7
|
||||
]
|
||||
|
||||
// LOW_BIT_DEPTH_MULTIPLIERS holds multipliers that convert D-bit values into
|
||||
// 8-bit values, for depth D.
|
||||
pri const LOW_BIT_DEPTH_MULTIPLIERS : array[8] base.u8 = [
|
||||
0,
|
||||
0b1111_1111, // depth == 1
|
||||
0b0101_0101, // depth == 2
|
||||
0,
|
||||
0b0001_0001, // depth == 4
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
]
|
||||
|
||||
// LOW_BIT_DEPTH_NUM_PACKS holds the number of smaller-than-1-byte units that
|
||||
// are packed into each byte.
|
||||
pri const LOW_BIT_DEPTH_NUM_PACKS : array[8] base.u8 = [
|
||||
0,
|
||||
8, // depth == 1
|
||||
4, // depth == 2
|
||||
0,
|
||||
2, // depth == 4
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
]
|
||||
|
||||
// NUM_CHANNELS holds the number of channels for each valid color type.
|
||||
pri const NUM_CHANNELS : array[8] base.u8[..= 4] = [
|
||||
1, // color_type == 0: Y
|
||||
0,
|
||||
3, // color_type == 2: RGB
|
||||
1, // color_type == 3: indexed
|
||||
2, // color_type == 4: YA
|
||||
0,
|
||||
4, // color_type == 6: RGBA
|
||||
0,
|
||||
]
|
||||
@@ -18,7 +18,8 @@ pri func decoder.filter_and_swizzle!(dst: ptr base.pixel_buffer, workbuf: slice
|
||||
var dst_pixfmt : base.pixel_format
|
||||
var dst_bits_per_pixel : base.u32[..= 256]
|
||||
var dst_bytes_per_pixel : base.u64[..= 32]
|
||||
var dst_bytes_per_row : base.u64
|
||||
var dst_bytes_per_row0 : base.u64
|
||||
var dst_bytes_per_row1 : base.u64
|
||||
var dst_palette : slice base.u8
|
||||
var tab : table base.u8
|
||||
|
||||
@@ -36,16 +37,37 @@ pri func decoder.filter_and_swizzle!(dst: ptr base.pixel_buffer, workbuf: slice
|
||||
return base."#unsupported option"
|
||||
}
|
||||
dst_bytes_per_pixel = (dst_bits_per_pixel / 8) as base.u64
|
||||
dst_bytes_per_row = (this.width as base.u64) * dst_bytes_per_pixel
|
||||
dst_bytes_per_row0 = (this.frame_rect_x0 as base.u64) * dst_bytes_per_pixel
|
||||
dst_bytes_per_row1 = (this.frame_rect_x1 as base.u64) * dst_bytes_per_pixel
|
||||
dst_palette = args.dst.palette_or_else(fallback: this.dst_palette[..])
|
||||
tab = args.dst.plane(p: 0)
|
||||
|
||||
while y < this.height {
|
||||
assert y < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.height)
|
||||
dst = tab.row(y: y)
|
||||
if dst_bytes_per_row < dst.length() {
|
||||
dst = dst[.. dst_bytes_per_row]
|
||||
}
|
||||
if dst_bytes_per_row1 < tab.width() {
|
||||
tab = tab.subtable(
|
||||
min_incl_x: 0,
|
||||
min_incl_y: 0,
|
||||
max_incl_x: dst_bytes_per_row1,
|
||||
max_incl_y: tab.height())
|
||||
}
|
||||
|
||||
if dst_bytes_per_row0 < tab.width() {
|
||||
tab = tab.subtable(
|
||||
min_incl_x: dst_bytes_per_row0,
|
||||
min_incl_y: 0,
|
||||
max_incl_x: tab.width(),
|
||||
max_incl_y: tab.height())
|
||||
} else {
|
||||
tab = tab.subtable(
|
||||
min_incl_x: 0,
|
||||
min_incl_y: 0,
|
||||
max_incl_x: 0,
|
||||
max_incl_y: 0)
|
||||
}
|
||||
|
||||
y = this.frame_rect_y0
|
||||
while y < this.frame_rect_y1 {
|
||||
assert y < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_y1)
|
||||
dst = tab.row_u32(y: y)
|
||||
|
||||
if 1 > args.workbuf.length() {
|
||||
return "#internal error: inconsistent workbuf length"
|
||||
@@ -16,7 +16,7 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
|
||||
var dst_pixfmt : base.pixel_format
|
||||
var dst_bits_per_pixel : base.u32[..= 256]
|
||||
var dst_bytes_per_pixel : base.u64[..= 32]
|
||||
var dst_bytes_per_row : base.u64
|
||||
var dst_bytes_per_row1 : base.u64
|
||||
var dst_palette : slice base.u8
|
||||
var tab : table base.u8
|
||||
|
||||
@@ -45,7 +45,7 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
|
||||
return base."#unsupported option"
|
||||
}
|
||||
dst_bytes_per_pixel = (dst_bits_per_pixel / 8) as base.u64
|
||||
dst_bytes_per_row = (this.width as base.u64) * dst_bytes_per_pixel
|
||||
dst_bytes_per_row1 = (this.frame_rect_x1 as base.u64) * dst_bytes_per_pixel
|
||||
dst_palette = args.dst.palette_or_else(fallback: this.dst_palette[..])
|
||||
tab = args.dst.plane(p: 0)
|
||||
|
||||
@@ -55,21 +55,16 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
|
||||
((this.depth >> 3) as base.u64)
|
||||
}
|
||||
|
||||
bits_unpacked[0] = 0xFF
|
||||
bits_unpacked[1] = 0xFF
|
||||
bits_unpacked[2] = 0xFF
|
||||
bits_unpacked[3] = 0xFF
|
||||
bits_unpacked[4] = 0xFF
|
||||
bits_unpacked[5] = 0xFF
|
||||
bits_unpacked[6] = 0xFF
|
||||
bits_unpacked[7] = 0xFF
|
||||
|
||||
y = INTERLACING[this.interlace_pass][5] as base.u32
|
||||
while y < this.height {
|
||||
assert y < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.height)
|
||||
dst = tab.row(y: y)
|
||||
if dst_bytes_per_row < dst.length() {
|
||||
dst = dst[.. dst_bytes_per_row]
|
||||
if (this.chunk_type_array[0] == 'I') {
|
||||
y = INTERLACING[this.interlace_pass][5] as base.u32
|
||||
} else {
|
||||
y = this.frame_rect_y0
|
||||
}
|
||||
while y < this.frame_rect_y1 {
|
||||
assert y < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_y1)
|
||||
dst = tab.row_u32(y: y)
|
||||
if dst_bytes_per_row1 < dst.length() {
|
||||
dst = dst[.. dst_bytes_per_row1]
|
||||
}
|
||||
|
||||
if 1 > args.workbuf.length() {
|
||||
@@ -98,12 +93,16 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
|
||||
}
|
||||
|
||||
s = curr_row
|
||||
x = INTERLACING[this.interlace_pass][2] as base.u32
|
||||
if (this.chunk_type_array[0] == 'I') {
|
||||
x = INTERLACING[this.interlace_pass][2] as base.u32
|
||||
} else {
|
||||
x = this.frame_rect_x0
|
||||
}
|
||||
if this.depth == 8 {
|
||||
while x < this.width,
|
||||
while x < this.frame_rect_x1,
|
||||
inv y < 0x00FF_FFFF,
|
||||
{
|
||||
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.width)
|
||||
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_x1)
|
||||
i = (x as base.u64) * dst_bytes_per_pixel
|
||||
if i <= dst.length() {
|
||||
if this.color_type == 4 {
|
||||
@@ -118,6 +117,54 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
|
||||
dst_palette: dst_palette,
|
||||
src: bits_unpacked[.. 4])
|
||||
}
|
||||
|
||||
} else if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) <> 0 {
|
||||
if this.color_type == 0 {
|
||||
if 1 <= s.length() {
|
||||
bits_unpacked[0] = s[0]
|
||||
bits_unpacked[1] = s[0]
|
||||
bits_unpacked[2] = s[0]
|
||||
bits_unpacked[3] = 0xFF
|
||||
s = s[1 ..]
|
||||
if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) == (
|
||||
((bits_unpacked[0] as base.u32) << 0) |
|
||||
((bits_unpacked[1] as base.u32) << 8) |
|
||||
((bits_unpacked[2] as base.u32) << 16) |
|
||||
((bits_unpacked[3] as base.u32) << 24)) {
|
||||
bits_unpacked[0] = 0
|
||||
bits_unpacked[1] = 0
|
||||
bits_unpacked[2] = 0
|
||||
bits_unpacked[3] = 0
|
||||
}
|
||||
this.swizzler.swizzle_interleaved_from_slice!(
|
||||
dst: dst[i ..],
|
||||
dst_palette: dst_palette,
|
||||
src: bits_unpacked[.. 4])
|
||||
}
|
||||
} else {
|
||||
if 3 <= s.length() {
|
||||
bits_unpacked[0] = s[2]
|
||||
bits_unpacked[1] = s[1]
|
||||
bits_unpacked[2] = s[0]
|
||||
bits_unpacked[3] = 0xFF
|
||||
s = s[3 ..]
|
||||
if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) == (
|
||||
((bits_unpacked[0] as base.u32) << 0) |
|
||||
((bits_unpacked[1] as base.u32) << 8) |
|
||||
((bits_unpacked[2] as base.u32) << 16) |
|
||||
((bits_unpacked[3] as base.u32) << 24)) {
|
||||
bits_unpacked[0] = 0
|
||||
bits_unpacked[1] = 0
|
||||
bits_unpacked[2] = 0
|
||||
bits_unpacked[3] = 0
|
||||
}
|
||||
this.swizzler.swizzle_interleaved_from_slice!(
|
||||
dst: dst[i ..],
|
||||
dst_palette: dst_palette,
|
||||
src: bits_unpacked[.. 4])
|
||||
}
|
||||
}
|
||||
|
||||
} else if src_bytes_per_pixel <= s.length() {
|
||||
this.swizzler.swizzle_interleaved_from_slice!(
|
||||
dst: dst[i ..],
|
||||
@@ -137,11 +184,11 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
|
||||
shift = (8 - this.depth) & 7
|
||||
packs_remaining = 0
|
||||
|
||||
while x < this.width,
|
||||
while x < this.frame_rect_x1,
|
||||
inv y < 0x00FF_FFFF,
|
||||
inv this.depth < 8,
|
||||
{
|
||||
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.width)
|
||||
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_x1)
|
||||
i = (x as base.u64) * dst_bytes_per_pixel
|
||||
if i <= dst.length() {
|
||||
if (packs_remaining == 0) and (1 <= s.length()) {
|
||||
@@ -153,19 +200,40 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
|
||||
bits_packed = bits_packed ~mod<< this.depth
|
||||
packs_remaining = packs_remaining ~mod- 1
|
||||
|
||||
this.swizzler.swizzle_interleaved_from_slice!(
|
||||
dst: dst[i ..],
|
||||
dst_palette: dst_palette,
|
||||
src: bits_unpacked[.. 1])
|
||||
if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) <> 0 {
|
||||
bits_unpacked[1] = bits_unpacked[0]
|
||||
bits_unpacked[2] = bits_unpacked[0]
|
||||
bits_unpacked[3] = 0xFF
|
||||
if ((this.remap_transparency & 0xFFFF_FFFF) as base.u32) == (
|
||||
((bits_unpacked[0] as base.u32) << 0) |
|
||||
((bits_unpacked[1] as base.u32) << 8) |
|
||||
((bits_unpacked[2] as base.u32) << 16) |
|
||||
((bits_unpacked[3] as base.u32) << 24)) {
|
||||
bits_unpacked[0] = 0
|
||||
bits_unpacked[1] = 0
|
||||
bits_unpacked[2] = 0
|
||||
bits_unpacked[3] = 0
|
||||
}
|
||||
this.swizzler.swizzle_interleaved_from_slice!(
|
||||
dst: dst[i ..],
|
||||
dst_palette: dst_palette,
|
||||
src: bits_unpacked[.. 4])
|
||||
|
||||
} else {
|
||||
this.swizzler.swizzle_interleaved_from_slice!(
|
||||
dst: dst[i ..],
|
||||
dst_palette: dst_palette,
|
||||
src: bits_unpacked[.. 1])
|
||||
}
|
||||
}
|
||||
x += (1 as base.u32) << INTERLACING[this.interlace_pass][0]
|
||||
} endwhile
|
||||
|
||||
} else {
|
||||
while x < this.width,
|
||||
while x < this.frame_rect_x1,
|
||||
inv y < 0x00FF_FFFF,
|
||||
{
|
||||
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.width)
|
||||
assert x < 0x00FF_FFFF via "a < b: a < c; c <= b"(c: this.frame_rect_x1)
|
||||
i = (x as base.u64) * dst_bytes_per_pixel
|
||||
if i <= dst.length() {
|
||||
if this.color_type == 0 {
|
||||
@@ -176,8 +244,29 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
|
||||
bits_unpacked[3] = s[0]
|
||||
bits_unpacked[4] = s[1]
|
||||
bits_unpacked[5] = s[0]
|
||||
bits_unpacked[6] = 0xFF
|
||||
bits_unpacked[7] = 0xFF
|
||||
s = s[2 ..]
|
||||
if this.remap_transparency == (
|
||||
((bits_unpacked[0] as base.u64) << 0) |
|
||||
((bits_unpacked[1] as base.u64) << 8) |
|
||||
((bits_unpacked[2] as base.u64) << 16) |
|
||||
((bits_unpacked[3] as base.u64) << 24) |
|
||||
((bits_unpacked[4] as base.u64) << 32) |
|
||||
((bits_unpacked[5] as base.u64) << 40) |
|
||||
((bits_unpacked[6] as base.u64) << 48) |
|
||||
((bits_unpacked[7] as base.u64) << 56)) {
|
||||
bits_unpacked[0] = 0
|
||||
bits_unpacked[1] = 0
|
||||
bits_unpacked[2] = 0
|
||||
bits_unpacked[3] = 0
|
||||
bits_unpacked[4] = 0
|
||||
bits_unpacked[5] = 0
|
||||
bits_unpacked[6] = 0
|
||||
bits_unpacked[7] = 0
|
||||
}
|
||||
}
|
||||
|
||||
} else if this.color_type == 2 {
|
||||
if 6 <= s.length() {
|
||||
bits_unpacked[0] = s[5]
|
||||
@@ -186,8 +275,29 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
|
||||
bits_unpacked[3] = s[2]
|
||||
bits_unpacked[4] = s[1]
|
||||
bits_unpacked[5] = s[0]
|
||||
bits_unpacked[6] = 0xFF
|
||||
bits_unpacked[7] = 0xFF
|
||||
s = s[6 ..]
|
||||
if this.remap_transparency == (
|
||||
((bits_unpacked[0] as base.u64) << 0) |
|
||||
((bits_unpacked[1] as base.u64) << 8) |
|
||||
((bits_unpacked[2] as base.u64) << 16) |
|
||||
((bits_unpacked[3] as base.u64) << 24) |
|
||||
((bits_unpacked[4] as base.u64) << 32) |
|
||||
((bits_unpacked[5] as base.u64) << 40) |
|
||||
((bits_unpacked[6] as base.u64) << 48) |
|
||||
((bits_unpacked[7] as base.u64) << 56)) {
|
||||
bits_unpacked[0] = 0
|
||||
bits_unpacked[1] = 0
|
||||
bits_unpacked[2] = 0
|
||||
bits_unpacked[3] = 0
|
||||
bits_unpacked[4] = 0
|
||||
bits_unpacked[5] = 0
|
||||
bits_unpacked[6] = 0
|
||||
bits_unpacked[7] = 0
|
||||
}
|
||||
}
|
||||
|
||||
} else if this.color_type == 4 {
|
||||
if 4 <= s.length() {
|
||||
bits_unpacked[0] = s[1]
|
||||
@@ -200,6 +310,7 @@ pri func decoder.filter_and_swizzle_tricky!(dst: ptr base.pixel_buffer, workbuf:
|
||||
bits_unpacked[7] = s[2]
|
||||
s = s[4 ..]
|
||||
}
|
||||
|
||||
} else {
|
||||
if 8 <= s.length() {
|
||||
bits_unpacked[0] = s[5]
|
||||
|
||||
@@ -196,7 +196,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
|
||||
tab = args.dst.plane(p: 0)
|
||||
while dst_y < this.height {
|
||||
assert dst_y < 0xFFFF_FFFF via "a < b: a < c; c <= b"(c: this.height)
|
||||
dst = tab.row(y: dst_y)
|
||||
dst = tab.row_u32(y: dst_y)
|
||||
dst_x = 0
|
||||
|
||||
while dst_x < this.width,
|
||||
@@ -212,7 +212,7 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
|
||||
{
|
||||
yield? base."$short read"
|
||||
tab = args.dst.plane(p: 0)
|
||||
dst = tab.row(y: dst_y)
|
||||
dst = tab.row_u32(y: dst_y)
|
||||
dst_x_in_bytes = (dst_x as base.u64) * dst_bytes_per_pixel
|
||||
if dst_x_in_bytes <= dst.length() {
|
||||
dst = dst[dst_x_in_bytes ..]
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
// Copyright 2021 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.
|
||||
|
||||
// --------
|
||||
|
||||
// Quirks are discussed in (/doc/note/quirks.md).
|
||||
//
|
||||
// The base38 encoding of "zlib" is 0x1F_7F79. Left shifting by 10 gives
|
||||
// 0x7DFD_E400.
|
||||
pri const QUIRKS_BASE : base.u32 = 0x7DFD_E400
|
||||
|
||||
// --------
|
||||
|
||||
// When this quirk is enabled, the decoder speaks just raw deflate, without
|
||||
// zlib's configuration prefix and checksum suffix wrapped around that.
|
||||
//
|
||||
// A zlib.decoder basically becomes a deflate.decoder. This is useful when the
|
||||
// caller might want to choose between the two related-but-slightly-different
|
||||
// formats at run time but would rather not allocate two separate decoders.
|
||||
pub const QUIRK_JUST_RAW_DEFLATE : base.u32 = 0x7DFD_E400 | 0x00
|
||||
|
||||
pri const QUIRKS_COUNT : base.u32 = 0x01
|
||||
@@ -33,6 +33,8 @@ pub struct decoder? implements base.io_transformer(
|
||||
got_dictionary : base.bool,
|
||||
want_dictionary : base.bool,
|
||||
|
||||
quirks : array[QUIRKS_COUNT] base.bool,
|
||||
|
||||
ignore_checksum : base.bool,
|
||||
checksum : adler32.hasher,
|
||||
|
||||
@@ -60,8 +62,15 @@ pub func decoder.add_dictionary!(dict: slice base.u8) {
|
||||
}
|
||||
|
||||
pub func decoder.set_quirk_enabled!(quirk: base.u32, enabled: base.bool) {
|
||||
if args.quirk == base.QUIRK_IGNORE_CHECKSUM {
|
||||
if this.header_complete {
|
||||
this.bad_call_sequence = true
|
||||
} else if args.quirk == base.QUIRK_IGNORE_CHECKSUM {
|
||||
this.ignore_checksum = args.enabled
|
||||
} else if args.quirk >= QUIRKS_BASE {
|
||||
args.quirk -= QUIRKS_BASE
|
||||
if args.quirk < QUIRKS_COUNT {
|
||||
this.quirks[args.quirk] = args.enabled
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -80,6 +89,8 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
|
||||
|
||||
if this.bad_call_sequence {
|
||||
return base."#bad call sequence"
|
||||
} else if this.quirks[QUIRK_JUST_RAW_DEFLATE - QUIRKS_BASE] {
|
||||
// No-op.
|
||||
} else if not this.want_dictionary {
|
||||
x = args.src.read_u16be?()
|
||||
if ((x >> 8) & 0x0F) <> 0x08 {
|
||||
@@ -112,7 +123,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
|
||||
while true {
|
||||
mark = args.dst.mark()
|
||||
status =? this.flate.transform_io?(dst: args.dst, src: args.src, workbuf: args.workbuf)
|
||||
if not this.ignore_checksum {
|
||||
if (not this.ignore_checksum) and (not this.quirks[QUIRK_JUST_RAW_DEFLATE - QUIRKS_BASE]) {
|
||||
checksum_got = this.checksum.update_u32!(x: args.dst.since(mark: mark))
|
||||
}
|
||||
if status.is_ok() {
|
||||
@@ -120,9 +131,12 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
|
||||
}
|
||||
yield? status
|
||||
} endwhile
|
||||
checksum_want = args.src.read_u32be?()
|
||||
if (not this.ignore_checksum) and (checksum_got <> checksum_want) {
|
||||
return "#bad checksum"
|
||||
|
||||
if not this.quirks[QUIRK_JUST_RAW_DEFLATE - QUIRKS_BASE] {
|
||||
checksum_want = args.src.read_u32be?()
|
||||
if (not this.ignore_checksum) and (checksum_got <> checksum_want) {
|
||||
return "#bad checksum"
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: reset state (e.g. want_dictionary), so that we can read concat'ed
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
# Ignore everything without a dot.
|
||||
#
|
||||
# This ignores "pngsuite" but not "fetch-pngsuite.sh".
|
||||
*
|
||||
!*.*
|
||||
@@ -0,0 +1,5 @@
|
||||
This directory contains third party test data, not checked into the repository
|
||||
directly for download size and copyright reasons.
|
||||
|
||||
It also contains derived summary data files (such as `nia-checksums-of-*.txt`)
|
||||
which *are* checked into the repository, for regression testing.
|
||||
@@ -0,0 +1,26 @@
|
||||
#!/bin/bash -eu
|
||||
# Copyright 2021 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.
|
||||
|
||||
# ----------------
|
||||
|
||||
# This script fetches the PngSuite collection of PNG images.
|
||||
|
||||
if [ ! -e ../../wuffs-root-directory.txt ]; then
|
||||
echo "$0 should be run from the Wuffs test/3pdata directory."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
mkdir -p pngsuite
|
||||
curl --silent http://www.schaik.com/pngsuite/PngSuite-2017jul19.tgz | tar -xzf /dev/stdin -C pngsuite
|
||||
@@ -0,0 +1,29 @@
|
||||
As per [the PngSuite page](http://www.schaik.com/pngsuite/#corrupted), every
|
||||
`x*.png` file in the test suite is invalid PNG.
|
||||
|
||||
Nonetheless, `nia-checksums-of-pngsuite.txt` contains an entry for
|
||||
`xcsn0g01.png`, meaning that `convert-to-nia` decoded *some* pixels for it.
|
||||
This is working as intended, because the `xcsn0g01.png` invalidity is in its
|
||||
`IDAT` chunk's checksum (compared to `xhdn0g08.png`'s corruption in its `IHDR`
|
||||
chunk's checksum).
|
||||
|
||||
The `convert-to-nia` semantics are that, provided that it can decode a complete
|
||||
image configuration (width, height, pixel format, etc which, for PNG, comes
|
||||
from the `IHDR` chunk), it outputs *as many pixels as possible* (even if that's
|
||||
zero pixels) so that it gives a 'best effort' decoding for truncated images.
|
||||
Indeed, the NIA conversion for `xcsn0g01.png` holds all-zero pixels (and a
|
||||
"png: bad checksum" error message on stderr) but also a zero exit code.
|
||||
|
||||
```
|
||||
$ gen/bin/example-convert-to-nia < test/3pdata/pngsuite/xcsn0g01.png | hd
|
||||
00000000 6e c3 af 41 ff 62 6e 34 20 00 00 00 20 00 00 00 |n..A.bn4 ... ...|
|
||||
00000010 00 00 00 00 00 00 00 00 6e c3 af 45 ff 62 6e 34 |........n..E.bn4|
|
||||
00000020 20 00 00 00 20 00 00 00 00 00 00 00 00 00 00 00 | ... ...........|
|
||||
00000030 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
|
||||
*
|
||||
00001020 00 00 00 00 00 00 00 00 |........|
|
||||
00001028
|
||||
png: bad checksum
|
||||
$ echo $?
|
||||
0
|
||||
```
|
||||
@@ -0,0 +1,164 @@
|
||||
# Generated by script/print-nia-checksums.sh
|
||||
aac44167 test/3pdata/pngsuite/PngSuite.png
|
||||
926d3aa2 test/3pdata/pngsuite/basi0g01.png
|
||||
8f50bdc6 test/3pdata/pngsuite/basi0g02.png
|
||||
6d612626 test/3pdata/pngsuite/basi0g04.png
|
||||
024cf410 test/3pdata/pngsuite/basi0g08.png
|
||||
bb956205 test/3pdata/pngsuite/basi0g16.png
|
||||
d1ae61d3 test/3pdata/pngsuite/basi2c08.png
|
||||
84bc9be8 test/3pdata/pngsuite/basi2c16.png
|
||||
49bc6b98 test/3pdata/pngsuite/basi3p01.png
|
||||
ad12897b test/3pdata/pngsuite/basi3p02.png
|
||||
81c22b59 test/3pdata/pngsuite/basi3p04.png
|
||||
e59ecea5 test/3pdata/pngsuite/basi3p08.png
|
||||
1b468494 test/3pdata/pngsuite/basi4a08.png
|
||||
8a6dd244 test/3pdata/pngsuite/basi4a16.png
|
||||
2b1044ce test/3pdata/pngsuite/basi6a08.png
|
||||
b039babf test/3pdata/pngsuite/basi6a16.png
|
||||
926d3aa2 test/3pdata/pngsuite/basn0g01.png
|
||||
8f50bdc6 test/3pdata/pngsuite/basn0g02.png
|
||||
6d612626 test/3pdata/pngsuite/basn0g04.png
|
||||
024cf410 test/3pdata/pngsuite/basn0g08.png
|
||||
bb956205 test/3pdata/pngsuite/basn0g16.png
|
||||
d1ae61d3 test/3pdata/pngsuite/basn2c08.png
|
||||
84bc9be8 test/3pdata/pngsuite/basn2c16.png
|
||||
49bc6b98 test/3pdata/pngsuite/basn3p01.png
|
||||
ad12897b test/3pdata/pngsuite/basn3p02.png
|
||||
81c22b59 test/3pdata/pngsuite/basn3p04.png
|
||||
e59ecea5 test/3pdata/pngsuite/basn3p08.png
|
||||
1b468494 test/3pdata/pngsuite/basn4a08.png
|
||||
8a6dd244 test/3pdata/pngsuite/basn4a16.png
|
||||
2b1044ce test/3pdata/pngsuite/basn6a08.png
|
||||
b039babf test/3pdata/pngsuite/basn6a16.png
|
||||
1b468494 test/3pdata/pngsuite/bgai4a08.png
|
||||
8a6dd244 test/3pdata/pngsuite/bgai4a16.png
|
||||
2b1044ce test/3pdata/pngsuite/bgan6a08.png
|
||||
b039babf test/3pdata/pngsuite/bgan6a16.png
|
||||
1b468494 test/3pdata/pngsuite/bgbn4a08.png
|
||||
8a6dd244 test/3pdata/pngsuite/bggn4a16.png
|
||||
2b1044ce test/3pdata/pngsuite/bgwn6a08.png
|
||||
b039babf test/3pdata/pngsuite/bgyn6a16.png
|
||||
b58985e2 test/3pdata/pngsuite/ccwn2c08.png
|
||||
b7f7127d test/3pdata/pngsuite/ccwn3p08.png
|
||||
c7b4c0fa test/3pdata/pngsuite/cdfn2c08.png
|
||||
dabf7a40 test/3pdata/pngsuite/cdhn2c08.png
|
||||
8491ddf5 test/3pdata/pngsuite/cdsn2c08.png
|
||||
d9282a90 test/3pdata/pngsuite/cdun2c08.png
|
||||
81c22b59 test/3pdata/pngsuite/ch1n3p04.png
|
||||
e59ecea5 test/3pdata/pngsuite/ch2n3p08.png
|
||||
b3334ede test/3pdata/pngsuite/cm0n0g04.png
|
||||
b3334ede test/3pdata/pngsuite/cm7n0g04.png
|
||||
b3334ede test/3pdata/pngsuite/cm9n0g04.png
|
||||
8ce6e28c test/3pdata/pngsuite/cs3n2c16.png
|
||||
d565507c test/3pdata/pngsuite/cs3n3p08.png
|
||||
2f5a21b9 test/3pdata/pngsuite/cs5n2c08.png
|
||||
2f5a21b9 test/3pdata/pngsuite/cs5n3p08.png
|
||||
8ce6e28c test/3pdata/pngsuite/cs8n2c08.png
|
||||
8ce6e28c test/3pdata/pngsuite/cs8n3p08.png
|
||||
b3334ede test/3pdata/pngsuite/ct0n0g04.png
|
||||
b3334ede test/3pdata/pngsuite/ct1n0g04.png
|
||||
1bfcb6e6 test/3pdata/pngsuite/cten0g04.png
|
||||
8e493daf test/3pdata/pngsuite/ctfn0g04.png
|
||||
417a539e test/3pdata/pngsuite/ctgn0g04.png
|
||||
28033324 test/3pdata/pngsuite/cthn0g04.png
|
||||
71a82501 test/3pdata/pngsuite/ctjn0g04.png
|
||||
b3334ede test/3pdata/pngsuite/ctzn0g04.png
|
||||
aa5328d3 test/3pdata/pngsuite/exif2c08.png
|
||||
b81f03cc test/3pdata/pngsuite/f00n0g08.png
|
||||
4a12368c test/3pdata/pngsuite/f00n2c08.png
|
||||
7fe4a9d8 test/3pdata/pngsuite/f01n0g08.png
|
||||
36758edc test/3pdata/pngsuite/f01n2c08.png
|
||||
e0ab5774 test/3pdata/pngsuite/f02n0g08.png
|
||||
5e613513 test/3pdata/pngsuite/f02n2c08.png
|
||||
0719e3fa test/3pdata/pngsuite/f03n0g08.png
|
||||
c4709cc1 test/3pdata/pngsuite/f03n2c08.png
|
||||
457f1dab test/3pdata/pngsuite/f04n0g08.png
|
||||
7ec3c986 test/3pdata/pngsuite/f04n2c08.png
|
||||
1f319e46 test/3pdata/pngsuite/f99n0g04.png
|
||||
6000bb5b test/3pdata/pngsuite/g03n0g16.png
|
||||
aa019a24 test/3pdata/pngsuite/g03n2c08.png
|
||||
8f0a3383 test/3pdata/pngsuite/g03n3p04.png
|
||||
f3a44153 test/3pdata/pngsuite/g04n0g16.png
|
||||
3e852c56 test/3pdata/pngsuite/g04n2c08.png
|
||||
edb3555b test/3pdata/pngsuite/g04n3p04.png
|
||||
6b105de1 test/3pdata/pngsuite/g05n0g16.png
|
||||
938803a0 test/3pdata/pngsuite/g05n2c08.png
|
||||
9f7ad612 test/3pdata/pngsuite/g05n3p04.png
|
||||
28816978 test/3pdata/pngsuite/g07n0g16.png
|
||||
fedb8920 test/3pdata/pngsuite/g07n2c08.png
|
||||
9373010e test/3pdata/pngsuite/g07n3p04.png
|
||||
58eb5aca test/3pdata/pngsuite/g10n0g16.png
|
||||
8c5550d0 test/3pdata/pngsuite/g10n2c08.png
|
||||
a6120550 test/3pdata/pngsuite/g10n3p04.png
|
||||
14cc7e1c test/3pdata/pngsuite/g25n0g16.png
|
||||
fd0f349f test/3pdata/pngsuite/g25n2c08.png
|
||||
eb13812a test/3pdata/pngsuite/g25n3p04.png
|
||||
bb956205 test/3pdata/pngsuite/oi1n0g16.png
|
||||
84bc9be8 test/3pdata/pngsuite/oi1n2c16.png
|
||||
bb956205 test/3pdata/pngsuite/oi2n0g16.png
|
||||
84bc9be8 test/3pdata/pngsuite/oi2n2c16.png
|
||||
bb956205 test/3pdata/pngsuite/oi4n0g16.png
|
||||
84bc9be8 test/3pdata/pngsuite/oi4n2c16.png
|
||||
bb956205 test/3pdata/pngsuite/oi9n0g16.png
|
||||
84bc9be8 test/3pdata/pngsuite/oi9n2c16.png
|
||||
84bc9be8 test/3pdata/pngsuite/pp0n2c16.png
|
||||
8ed1f246 test/3pdata/pngsuite/pp0n6a08.png
|
||||
024cf410 test/3pdata/pngsuite/ps1n0g08.png
|
||||
84bc9be8 test/3pdata/pngsuite/ps1n2c16.png
|
||||
024cf410 test/3pdata/pngsuite/ps2n0g08.png
|
||||
84bc9be8 test/3pdata/pngsuite/ps2n2c16.png
|
||||
7cf2b7b2 test/3pdata/pngsuite/s01i3p01.png
|
||||
7cf2b7b2 test/3pdata/pngsuite/s01n3p01.png
|
||||
ffa30c78 test/3pdata/pngsuite/s02i3p01.png
|
||||
ffa30c78 test/3pdata/pngsuite/s02n3p01.png
|
||||
ad298c62 test/3pdata/pngsuite/s03i3p01.png
|
||||
ad298c62 test/3pdata/pngsuite/s03n3p01.png
|
||||
2c30132c test/3pdata/pngsuite/s04i3p01.png
|
||||
2c30132c test/3pdata/pngsuite/s04n3p01.png
|
||||
5fb20358 test/3pdata/pngsuite/s05i3p02.png
|
||||
5fb20358 test/3pdata/pngsuite/s05n3p02.png
|
||||
764e90bd test/3pdata/pngsuite/s06i3p02.png
|
||||
764e90bd test/3pdata/pngsuite/s06n3p02.png
|
||||
9eebca92 test/3pdata/pngsuite/s07i3p02.png
|
||||
9eebca92 test/3pdata/pngsuite/s07n3p02.png
|
||||
d57f2e84 test/3pdata/pngsuite/s08i3p02.png
|
||||
d57f2e84 test/3pdata/pngsuite/s08n3p02.png
|
||||
7585127f test/3pdata/pngsuite/s09i3p02.png
|
||||
7585127f test/3pdata/pngsuite/s09n3p02.png
|
||||
034051a8 test/3pdata/pngsuite/s32i3p04.png
|
||||
034051a8 test/3pdata/pngsuite/s32n3p04.png
|
||||
a377dcdd test/3pdata/pngsuite/s33i3p04.png
|
||||
a377dcdd test/3pdata/pngsuite/s33n3p04.png
|
||||
5bcd998d test/3pdata/pngsuite/s34i3p04.png
|
||||
5bcd998d test/3pdata/pngsuite/s34n3p04.png
|
||||
1cefbbe2 test/3pdata/pngsuite/s35i3p04.png
|
||||
1cefbbe2 test/3pdata/pngsuite/s35n3p04.png
|
||||
97c763a3 test/3pdata/pngsuite/s36i3p04.png
|
||||
97c763a3 test/3pdata/pngsuite/s36n3p04.png
|
||||
2d6bd687 test/3pdata/pngsuite/s37i3p04.png
|
||||
2d6bd687 test/3pdata/pngsuite/s37n3p04.png
|
||||
169951e5 test/3pdata/pngsuite/s38i3p04.png
|
||||
169951e5 test/3pdata/pngsuite/s38n3p04.png
|
||||
17a92eb2 test/3pdata/pngsuite/s39i3p04.png
|
||||
17a92eb2 test/3pdata/pngsuite/s39n3p04.png
|
||||
8cc6b93d test/3pdata/pngsuite/s40i3p04.png
|
||||
8cc6b93d test/3pdata/pngsuite/s40n3p04.png
|
||||
4e406947 test/3pdata/pngsuite/tbbn0g04.png
|
||||
c6e83019 test/3pdata/pngsuite/tbbn2c16.png
|
||||
46deef3b test/3pdata/pngsuite/tbbn3p08.png
|
||||
c6e83019 test/3pdata/pngsuite/tbgn2c16.png
|
||||
46deef3b test/3pdata/pngsuite/tbgn3p08.png
|
||||
c6e83019 test/3pdata/pngsuite/tbrn2c08.png
|
||||
2289ed1e test/3pdata/pngsuite/tbwn0g16.png
|
||||
46deef3b test/3pdata/pngsuite/tbwn3p08.png
|
||||
46deef3b test/3pdata/pngsuite/tbyn3p08.png
|
||||
59b23555 test/3pdata/pngsuite/tm3n3p02.png
|
||||
f2457b64 test/3pdata/pngsuite/tp0n0g08.png
|
||||
05846c5f test/3pdata/pngsuite/tp0n2c08.png
|
||||
3d7708a8 test/3pdata/pngsuite/tp0n3p08.png
|
||||
46deef3b test/3pdata/pngsuite/tp1n3p08.png
|
||||
f286cbfc test/3pdata/pngsuite/xcsn0g01.png
|
||||
9098c4d8 test/3pdata/pngsuite/z00n2c08.png
|
||||
9098c4d8 test/3pdata/pngsuite/z03n2c08.png
|
||||
9098c4d8 test/3pdata/pngsuite/z06n2c08.png
|
||||
9098c4d8 test/3pdata/pngsuite/z09n2c08.png
|
||||
@@ -62,8 +62,7 @@ mimic_gif_decode(uint64_t* n_bytes_out,
|
||||
goto cleanup1;
|
||||
}
|
||||
|
||||
int i;
|
||||
for (i = 0; i < f->ImageCount; i++) {
|
||||
for (int i = 0; i < f->ImageCount; i++) {
|
||||
// Copy the pixel data from the GifFileType* f to the dst buffer, since the
|
||||
// former is free'd at the end of this function.
|
||||
//
|
||||
|
||||
@@ -64,8 +64,7 @@ mimic_png_decode(uint64_t* n_bytes_out,
|
||||
|
||||
spng_ctx* ctx = spng_ctx_new(0);
|
||||
|
||||
size_t i;
|
||||
for (i = 0; i < quirks_len; i++) {
|
||||
for (size_t i = 0; i < quirks_len; i++) {
|
||||
uint32_t q = quirks_ptr[i];
|
||||
if (q == WUFFS_BASE__QUIRK_IGNORE_CHECKSUM) {
|
||||
spng_set_crc_action(ctx, SPNG_CRC_USE, SPNG_CRC_USE);
|
||||
@@ -358,8 +357,7 @@ mimic_png_decode(uint64_t* n_bytes_out,
|
||||
goto cleanup0;
|
||||
}
|
||||
|
||||
size_t i;
|
||||
for (i = 0; i < quirks_len; i++) {
|
||||
for (size_t i = 0; i < quirks_len; i++) {
|
||||
uint32_t q = quirks_ptr[i];
|
||||
if (q == WUFFS_BASE__QUIRK_IGNORE_CHECKSUM) {
|
||||
// TODO: configure libpng to ignore Adler-32 and CRC-32 checksums.
|
||||
|
||||
@@ -131,15 +131,13 @@ test_wuffs_adler32_golden() {
|
||||
},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, test_cases[tc].filename));
|
||||
|
||||
int j;
|
||||
for (j = 0; j < 2; j++) {
|
||||
for (int j = 0; j < 2; j++) {
|
||||
wuffs_adler32__hasher checksum;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_adler32__hasher__initialize(
|
||||
@@ -164,7 +162,7 @@ test_wuffs_adler32_golden() {
|
||||
} while (num_bytes < src.meta.wi);
|
||||
|
||||
if (have != test_cases[tc].want) {
|
||||
RETURN_FAIL("tc=%d, j=%d, filename=\"%s\": have 0x%08" PRIX32
|
||||
RETURN_FAIL("tc=%zu, j=%d, filename=\"%s\": have 0x%08" PRIX32
|
||||
", want 0x%08" PRIX32 "\n",
|
||||
tc, j, test_cases[tc].filename, have, test_cases[tc].want);
|
||||
}
|
||||
@@ -208,8 +206,7 @@ test_wuffs_adler32_pi() {
|
||||
0xBEAA13C1, 0xD29C13F2, 0xE6C51429, 0xFB1E1459,
|
||||
};
|
||||
|
||||
int i;
|
||||
for (i = 0; i < 100; i++) {
|
||||
for (int i = 0; i < 100; i++) {
|
||||
wuffs_adler32__hasher checksum;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_adler32__hasher__initialize(
|
||||
|
||||
@@ -117,8 +117,7 @@ test_wuffs_cbor_decode_invalid() {
|
||||
"\xFE",
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__token tok_array[256];
|
||||
wuffs_base__token_buffer tok_buf =
|
||||
wuffs_base__slice_token__writer(wuffs_base__make_slice_token(
|
||||
@@ -138,7 +137,7 @@ test_wuffs_cbor_decode_invalid() {
|
||||
wuffs_base__status status = wuffs_cbor__decoder__decode_tokens(
|
||||
&dec, &tok_buf, &io_buf, g_work_slice_u8);
|
||||
if (!wuffs_base__status__is_error(&status)) {
|
||||
RETURN_FAIL("tc=%d: have \"%s\", want an error", tc, status.repr);
|
||||
RETURN_FAIL("tc=%zu: have \"%s\", want an error", tc, status.repr);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
@@ -159,8 +158,7 @@ test_wuffs_cbor_decode_valid() {
|
||||
"\xD0\xBF\xFF",
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__token tok_array[256];
|
||||
wuffs_base__token_buffer tok_buf =
|
||||
wuffs_base__slice_token__writer(wuffs_base__make_slice_token(
|
||||
@@ -180,7 +178,7 @@ test_wuffs_cbor_decode_valid() {
|
||||
wuffs_base__status status = wuffs_cbor__decoder__decode_tokens(
|
||||
&dec, &tok_buf, &io_buf, g_work_slice_u8);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("tc=%d: have \"%s\", want no error", tc, status.repr);
|
||||
RETURN_FAIL("tc=%zu: have \"%s\", want no error", tc, status.repr);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
|
||||
@@ -131,15 +131,13 @@ test_wuffs_crc32_ieee_golden() {
|
||||
},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, test_cases[tc].filename));
|
||||
|
||||
int j;
|
||||
for (j = 0; j < 2; j++) {
|
||||
for (int j = 0; j < 2; j++) {
|
||||
wuffs_crc32__ieee_hasher checksum;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_crc32__ieee_hasher__initialize(
|
||||
@@ -164,7 +162,7 @@ test_wuffs_crc32_ieee_golden() {
|
||||
} while (num_bytes < src.meta.wi);
|
||||
|
||||
if (have != test_cases[tc].want) {
|
||||
RETURN_FAIL("tc=%d, j=%d, filename=\"%s\": have 0x%08" PRIX32
|
||||
RETURN_FAIL("tc=%zu, j=%d, filename=\"%s\": have 0x%08" PRIX32
|
||||
", want 0x%08" PRIX32,
|
||||
tc, j, test_cases[tc].filename, have, test_cases[tc].want);
|
||||
}
|
||||
@@ -206,8 +204,7 @@ do_test_xxxxx_crc32_ieee_pi(bool mimic) {
|
||||
0x4D9D54B7, 0xD69454CC, 0xF8BB504D, 0xFC4E595C,
|
||||
};
|
||||
|
||||
int i;
|
||||
for (i = 0; i < 100; i++) {
|
||||
for (int i = 0; i < 100; i++) {
|
||||
uint32_t have;
|
||||
wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){
|
||||
.ptr = (uint8_t*)(digits),
|
||||
|
||||
@@ -74,55 +74,55 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
// go run script/extract-flate-offsets.go test/data/*.gz
|
||||
|
||||
golden_test g_deflate_256_bytes_gt = {
|
||||
.want_filename = "test/data/artificial/256.bytes",
|
||||
.src_filename = "test/data/artificial/256.bytes.gz",
|
||||
.want_filename = "test/data/256.bytes",
|
||||
.src_filename = "test/data/256.bytes.gz",
|
||||
.src_offset0 = 20,
|
||||
.src_offset1 = 281,
|
||||
};
|
||||
|
||||
golden_test g_deflate_deflate_backref_crosses_blocks_gt = {
|
||||
.want_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-backref-crosses-blocks.deflate.decompressed",
|
||||
"test/data/artificial-deflate/"
|
||||
"backref-crosses-blocks.deflate.decompressed",
|
||||
.src_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-backref-crosses-blocks.deflate",
|
||||
"test/data/artificial-deflate/"
|
||||
"backref-crosses-blocks.deflate",
|
||||
};
|
||||
|
||||
golden_test g_deflate_deflate_degenerate_huffman_unused_gt = {
|
||||
golden_test g_deflate_deflate_degenerate_huffman_gt = {
|
||||
.want_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-degenerate-huffman-unused.deflate.decompressed",
|
||||
"test/data/artificial-deflate/"
|
||||
"degenerate-huffman.deflate.decompressed",
|
||||
.src_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-degenerate-huffman-unused.deflate",
|
||||
"test/data/artificial-deflate/"
|
||||
"degenerate-huffman.deflate",
|
||||
};
|
||||
|
||||
golden_test g_deflate_deflate_distance_32768_gt = {
|
||||
.want_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-distance-32768.deflate.decompressed",
|
||||
"test/data/artificial-deflate/"
|
||||
"distance-32768.deflate.decompressed",
|
||||
.src_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-distance-32768.deflate",
|
||||
"test/data/artificial-deflate/"
|
||||
"distance-32768.deflate",
|
||||
};
|
||||
|
||||
golden_test g_deflate_deflate_distance_code_31_gt = {
|
||||
.want_filename =
|
||||
"test/data/artificial/"
|
||||
"qdeflate-distance-code-31.deflate.decompressed",
|
||||
"test/data/artificial-deflate/"
|
||||
"qdistance-code-31.deflate.decompressed",
|
||||
.src_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-distance-code-31.deflate",
|
||||
"test/data/artificial-deflate/"
|
||||
"distance-code-31.deflate",
|
||||
};
|
||||
|
||||
golden_test g_deflate_deflate_huffman_primlen_9_gt = {
|
||||
.want_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-huffman-primlen-9.deflate.decompressed",
|
||||
"test/data/artificial-deflate/"
|
||||
"huffman-primlen-9.deflate.decompressed",
|
||||
.src_filename =
|
||||
"test/data/artificial/"
|
||||
"deflate-huffman-primlen-9.deflate",
|
||||
"test/data/artificial-deflate/"
|
||||
"huffman-primlen-9.deflate",
|
||||
};
|
||||
|
||||
golden_test g_deflate_midsummer_gt = {
|
||||
@@ -213,10 +213,10 @@ test_wuffs_deflate_decode_deflate_backref_crosses_blocks() {
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_deflate_decode_deflate_degenerate_huffman_unused() {
|
||||
test_wuffs_deflate_decode_deflate_degenerate_huffman() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_deflate_decode,
|
||||
&g_deflate_deflate_degenerate_huffman_unused_gt,
|
||||
&g_deflate_deflate_degenerate_huffman_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -269,8 +269,7 @@ test_wuffs_deflate_decode_deflate_huffman_primlen_9() {
|
||||
CHECK_STATUS("transform_io", wuffs_deflate__decoder__transform_io(
|
||||
&dec, &have, &src, g_work_slice_u8));
|
||||
|
||||
int i;
|
||||
for (i = 0; i < 2; i++) {
|
||||
for (int i = 0; i < 2; i++) {
|
||||
// Find the first unused (i.e. zero) entry in the i'th huffs table.
|
||||
int have = WUFFS_DEFLATE__HUFFS_TABLE_SIZE;
|
||||
while ((have > 0) && (dec.private_data.f_huffs[i][have - 1] == 0)) {
|
||||
@@ -354,8 +353,7 @@ test_wuffs_deflate_decode_split_src() {
|
||||
CHECK_STRING(read_file(&src, gt->src_filename));
|
||||
CHECK_STRING(read_file(&want, gt->want_filename));
|
||||
|
||||
int i;
|
||||
for (i = 1; i < 32; i++) {
|
||||
for (int i = 1; i < 32; i++) {
|
||||
size_t split = gt->src_offset0 + i;
|
||||
if (split >= gt->src_offset1) {
|
||||
RETURN_FAIL("i=%d: split was not an interior split", i);
|
||||
@@ -468,8 +466,7 @@ test_wuffs_deflate_history_full() {
|
||||
CHECK_STRING(read_file(&want, gt->want_filename));
|
||||
|
||||
const int full_history_size = 0x8000;
|
||||
int i;
|
||||
for (i = -2; i <= +2; i++) {
|
||||
for (int i = -2; i <= +2; i++) {
|
||||
wuffs_deflate__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_deflate__decoder__initialize(
|
||||
@@ -531,8 +528,7 @@ test_wuffs_deflate_history_partial() {
|
||||
0x8000, 0x8001, 0x9234, 0xFFFB, 0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF,
|
||||
};
|
||||
|
||||
int i;
|
||||
for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(starting_history_indexes); i++) {
|
||||
for (int i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(starting_history_indexes); i++) {
|
||||
uint32_t starting_history_index = starting_history_indexes[i];
|
||||
|
||||
// The flate_pi_gt golden test file decodes to the digits of pi.
|
||||
@@ -564,8 +560,7 @@ test_wuffs_deflate_history_partial() {
|
||||
have_history_index, (int)(want_full), want_history_index);
|
||||
}
|
||||
|
||||
int j;
|
||||
for (j = -2; j < (int)(fragment_length) + 2; j++) {
|
||||
for (int j = -2; j < (int)(fragment_length) + 2; j++) {
|
||||
uint32_t index = (starting_history_index + j) & 0x7FFF;
|
||||
uint8_t have = dec.private_data.f_history[index];
|
||||
uint8_t want = (0 <= j && j < fragment_length) ? fragment[j] : 0;
|
||||
@@ -633,7 +628,6 @@ test_wuffs_deflate_table_redirect() {
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
memset(&(dec.private_data.f_huffs), 0, sizeof(dec.private_data.f_huffs));
|
||||
|
||||
int i;
|
||||
int n = 0;
|
||||
dec.private_data.f_code_lengths[n++] = 1;
|
||||
dec.private_data.f_code_lengths[n++] = 2;
|
||||
@@ -644,7 +638,7 @@ test_wuffs_deflate_table_redirect() {
|
||||
dec.private_data.f_code_lengths[n++] = 7;
|
||||
dec.private_data.f_code_lengths[n++] = 9;
|
||||
dec.private_data.f_code_lengths[n++] = 10;
|
||||
for (i = 0; i < 19; i++) {
|
||||
for (int i = 0; i < 19; i++) {
|
||||
dec.private_data.f_code_lengths[n++] = 12;
|
||||
}
|
||||
dec.private_data.f_code_lengths[n++] = 13;
|
||||
@@ -658,7 +652,7 @@ test_wuffs_deflate_table_redirect() {
|
||||
// should be zero outside of those tables.
|
||||
const int n_f_huffs = sizeof(dec.private_data.f_huffs[0]) /
|
||||
sizeof(dec.private_data.f_huffs[0][0]);
|
||||
for (i = 0; i < n_f_huffs; i++) {
|
||||
for (int i = 0; i < n_f_huffs; i++) {
|
||||
bool have = dec.private_data.f_huffs[0][i] == 0;
|
||||
bool want = i >= (1 << 9) + (1 << 3) + (1 << 3) + (1 << 4);
|
||||
if (have != want) {
|
||||
@@ -696,7 +690,7 @@ test_wuffs_deflate_table_redirect() {
|
||||
0x80000801, 0x80000903, 0x80000801, 0x80000B03,
|
||||
0x80000801, 0x80000A03, 0x80000801, 0x80000C03,
|
||||
};
|
||||
for (i = 0; i < 8; i++) {
|
||||
for (int i = 0; i < 8; i++) {
|
||||
have = dec.private_data.f_huffs[0][0x0200 + i];
|
||||
want = wants[i];
|
||||
if (have != want) {
|
||||
@@ -728,10 +722,10 @@ test_mimic_deflate_decode_deflate_backref_crosses_blocks() {
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_mimic_deflate_decode_deflate_degenerate_huffman_unused() {
|
||||
test_mimic_deflate_decode_deflate_degenerate_huffman() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(mimic_deflate_decode,
|
||||
&g_deflate_deflate_degenerate_huffman_unused_gt,
|
||||
&g_deflate_deflate_degenerate_huffman_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
@@ -896,7 +890,7 @@ proc g_tests[] = {
|
||||
|
||||
test_wuffs_deflate_decode_256_bytes,
|
||||
test_wuffs_deflate_decode_deflate_backref_crosses_blocks,
|
||||
test_wuffs_deflate_decode_deflate_degenerate_huffman_unused,
|
||||
test_wuffs_deflate_decode_deflate_degenerate_huffman,
|
||||
test_wuffs_deflate_decode_deflate_distance_32768,
|
||||
test_wuffs_deflate_decode_deflate_distance_code_31,
|
||||
test_wuffs_deflate_decode_deflate_huffman_primlen_9,
|
||||
@@ -917,7 +911,7 @@ proc g_tests[] = {
|
||||
|
||||
test_mimic_deflate_decode_256_bytes,
|
||||
test_mimic_deflate_decode_deflate_backref_crosses_blocks,
|
||||
test_mimic_deflate_decode_deflate_degenerate_huffman_unused,
|
||||
test_mimic_deflate_decode_deflate_degenerate_huffman,
|
||||
test_mimic_deflate_decode_deflate_distance_32768,
|
||||
test_mimic_deflate_decode_deflate_distance_code_31,
|
||||
test_mimic_deflate_decode_deflate_huffman_primlen_9,
|
||||
|
||||
@@ -252,11 +252,6 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
|
||||
uint32_t have = wuffs_gif__decoder__num_animation_loops(&dec);
|
||||
if (have != 1) {
|
||||
RETURN_FAIL("num_animation_loops: have %" PRIu32 ", want 1", have);
|
||||
}
|
||||
}
|
||||
|
||||
int num_iters = 0;
|
||||
@@ -355,8 +350,7 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
}
|
||||
|
||||
if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__BGR) {
|
||||
size_t i;
|
||||
for (i = 0; i < ind_want.meta.wi; i++) {
|
||||
for (size_t i = 0; i < ind_want.meta.wi; i++) {
|
||||
uint8_t index = ind_want.data.ptr[i];
|
||||
expanded_want.data.ptr[3 * i + 0] = pal_want_array[4 * index + 0];
|
||||
expanded_want.data.ptr[3 * i + 1] = pal_want_array[4 * index + 1];
|
||||
@@ -364,8 +358,7 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
}
|
||||
expanded_want.meta.wi = 3 * ind_want.meta.wi;
|
||||
} else if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__BGR_565) {
|
||||
size_t i;
|
||||
for (i = 0; i < ind_want.meta.wi; i++) {
|
||||
for (size_t i = 0; i < ind_want.meta.wi; i++) {
|
||||
uint8_t index = ind_want.data.ptr[i];
|
||||
uint32_t b5 = pal_want_array[4 * index + 0] >> 3;
|
||||
uint32_t g6 = pal_want_array[4 * index + 1] >> 2;
|
||||
@@ -376,8 +369,7 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
}
|
||||
expanded_want.meta.wi = 2 * ind_want.meta.wi;
|
||||
} else if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL) {
|
||||
size_t i;
|
||||
for (i = 0; i < ind_want.meta.wi; i++) {
|
||||
for (size_t i = 0; i < ind_want.meta.wi; i++) {
|
||||
uint8_t index = ind_want.data.ptr[i];
|
||||
expanded_want.data.ptr[4 * i + 0] = pal_want_array[4 * index + 0];
|
||||
expanded_want.data.ptr[4 * i + 1] = pal_want_array[4 * index + 1];
|
||||
@@ -386,8 +378,7 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
}
|
||||
expanded_want.meta.wi = 4 * ind_want.meta.wi;
|
||||
} else if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__RGB) {
|
||||
size_t i;
|
||||
for (i = 0; i < ind_want.meta.wi; i++) {
|
||||
for (size_t i = 0; i < ind_want.meta.wi; i++) {
|
||||
uint8_t index = ind_want.data.ptr[i];
|
||||
expanded_want.data.ptr[3 * i + 0] = pal_want_array[4 * index + 2];
|
||||
expanded_want.data.ptr[3 * i + 1] = pal_want_array[4 * index + 1];
|
||||
@@ -395,8 +386,7 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
}
|
||||
expanded_want.meta.wi = 3 * ind_want.meta.wi;
|
||||
} else if (dst_pixfmt.repr == WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL) {
|
||||
size_t i;
|
||||
for (i = 0; i < ind_want.meta.wi; i++) {
|
||||
for (size_t i = 0; i < ind_want.meta.wi; i++) {
|
||||
uint8_t index = ind_want.data.ptr[i];
|
||||
expanded_want.data.ptr[4 * i + 0] = pal_want_array[4 * index + 2];
|
||||
expanded_want.data.ptr[4 * i + 1] = pal_want_array[4 * index + 1];
|
||||
@@ -427,6 +417,16 @@ do_test_wuffs_gif_decode(const char* filename,
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
uint32_t have = wuffs_gif__decoder__num_animation_loops(&dec);
|
||||
uint32_t want =
|
||||
(wuffs_gif__decoder__num_decoded_frame_configs(&dec) > 1) ? 1 : 0;
|
||||
if (have != want) {
|
||||
RETURN_FAIL("num_animation_loops: have %" PRIu32 ", want %" PRIu32, have,
|
||||
want);
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -580,8 +580,7 @@ do_test_wuffs_gif_decode_animated(
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
|
||||
uint32_t i;
|
||||
for (i = 0; i < want_num_frames; i++) {
|
||||
for (uint32_t i = 0; i < want_num_frames; i++) {
|
||||
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
|
||||
wuffs_base__status status =
|
||||
wuffs_gif__decoder__decode_frame_config(&dec, &fc, &src);
|
||||
@@ -618,7 +617,7 @@ do_test_wuffs_gif_decode_animated(
|
||||
|
||||
// There should be no more frames, no matter how many times we call
|
||||
// decode_frame.
|
||||
for (i = 0; i < 3; i++) {
|
||||
for (uint32_t i = 0; i < 3; i++) {
|
||||
wuffs_base__status status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
if (status.repr != wuffs_base__note__end_of_data) {
|
||||
@@ -685,8 +684,7 @@ test_wuffs_gif_decode_delay_num_frames_decoded() {
|
||||
}
|
||||
src.meta.wi--;
|
||||
|
||||
int q;
|
||||
for (q = 0; q < 2; q++) {
|
||||
for (int q = 0; q < 2; q++) {
|
||||
src.meta.ri = 0;
|
||||
|
||||
wuffs_gif__decoder dec;
|
||||
@@ -721,9 +719,8 @@ test_wuffs_gif_decode_empty_palette() {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/artificial/gif-empty-palette.gif"));
|
||||
int q;
|
||||
for (q = 0; q < 2; q++) {
|
||||
CHECK_STRING(read_file(&src, "test/data/artificial-gif/empty-palette.gif"));
|
||||
for (int q = 0; q < 2; q++) {
|
||||
src.meta.ri = 0;
|
||||
|
||||
wuffs_gif__decoder dec;
|
||||
@@ -748,8 +745,7 @@ test_wuffs_gif_decode_empty_palette() {
|
||||
RETURN_FAIL("q=%d: set_from_slice: \"%s\"", q, status.repr);
|
||||
}
|
||||
|
||||
int i;
|
||||
for (i = 0; i < 2; i++) {
|
||||
for (int i = 0; i < 2; i++) {
|
||||
status = wuffs_gif__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
if ((q == 1) && (i == 1)) {
|
||||
@@ -789,9 +785,8 @@ test_wuffs_gif_decode_background_color() {
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-background-color.gif"));
|
||||
int q;
|
||||
for (q = 0; q < 2; q++) {
|
||||
read_file(&src, "test/data/artificial-gif/background-color.gif"));
|
||||
for (int q = 0; q < 2; q++) {
|
||||
src.meta.ri = 0;
|
||||
|
||||
wuffs_gif__decoder dec;
|
||||
@@ -828,9 +823,8 @@ test_wuffs_gif_decode_first_frame_is_opaque() {
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-frame-out-of-bounds.gif"));
|
||||
int q;
|
||||
for (q = 0; q < 2; q++) {
|
||||
read_file(&src, "test/data/artificial-gif/frame-out-of-bounds.gif"));
|
||||
for (int q = 0; q < 2; q++) {
|
||||
src.meta.ri = 0;
|
||||
|
||||
wuffs_gif__decoder dec;
|
||||
@@ -866,9 +860,8 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-frame-out-of-bounds.gif"));
|
||||
int q;
|
||||
for (q = 0; q < 2; q++) {
|
||||
read_file(&src, "test/data/artificial-gif/frame-out-of-bounds.gif"));
|
||||
for (int q = 0; q < 2; q++) {
|
||||
src.meta.ri = 0;
|
||||
|
||||
wuffs_gif__decoder dec;
|
||||
@@ -888,7 +881,7 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
|
||||
// The nominal width and height for the overall image is 2×2, but its first
|
||||
// frame extends those bounds to 4×2. See
|
||||
// test/data/artificial/gif-frame-out-of-bounds.gif.make-artificial.txt for
|
||||
// test/data/artificial-gif/frame-out-of-bounds.gif.make-artificial.txt for
|
||||
// more discussion.
|
||||
|
||||
const uint32_t width = q ? 2 : 4;
|
||||
@@ -914,7 +907,7 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
RETURN_FAIL("q=%d: set_from_slice: \"%s\"", q, status.repr);
|
||||
}
|
||||
|
||||
// See test/data/artificial/gif-frame-out-of-bounds.gif.make-artificial.txt
|
||||
// See test/data/artificial-gif/frame-out-of-bounds.gif.make-artificial.txt
|
||||
// for the want_frame_config_bounds and want_pixel_indexes source.
|
||||
|
||||
wuffs_base__rect_ie_u32 want_frame_config_bounds[4] = {
|
||||
@@ -931,8 +924,7 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
q ? "...." : "..45..89",
|
||||
};
|
||||
|
||||
uint32_t i;
|
||||
for (i = 0; true; i++) {
|
||||
for (uint32_t i = 0; true; i++) {
|
||||
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
|
||||
{
|
||||
status = wuffs_gif__decoder__decode_frame_config(&dec, &fc, &src);
|
||||
@@ -964,14 +956,13 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
|
||||
{
|
||||
wuffs_base__table_u8 p = wuffs_base__pixel_buffer__plane(&pb, 0);
|
||||
uint32_t y, x;
|
||||
for (y = 0; y < 5; y++) {
|
||||
for (x = 0; x < 5; x++) {
|
||||
for (uint32_t y = 0; y < 5; y++) {
|
||||
for (uint32_t x = 0; x < 5; x++) {
|
||||
p.ptr[(y * p.stride) + x] = 0xEE;
|
||||
}
|
||||
}
|
||||
for (y = 0; y < height; y++) {
|
||||
for (x = 0; x < width; x++) {
|
||||
for (uint32_t y = 0; y < height; y++) {
|
||||
for (uint32_t x = 0; x < width; x++) {
|
||||
p.ptr[(y * p.stride) + x] = 0;
|
||||
}
|
||||
}
|
||||
@@ -984,8 +975,8 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
status.repr);
|
||||
}
|
||||
|
||||
for (y = 0; y < 5; y++) {
|
||||
for (x = 0; x < 5; x++) {
|
||||
for (uint32_t y = 0; y < 5; y++) {
|
||||
for (uint32_t x = 0; x < 5; x++) {
|
||||
if ((x < width) && (y < height)) {
|
||||
continue;
|
||||
}
|
||||
@@ -1009,8 +1000,8 @@ test_wuffs_gif_decode_frame_out_of_bounds() {
|
||||
}
|
||||
|
||||
char have[(width * height) + 1];
|
||||
for (y = 0; y < height; y++) {
|
||||
for (x = 0; x < width; x++) {
|
||||
for (uint32_t y = 0; y < height; y++) {
|
||||
for (uint32_t x = 0; x < width; x++) {
|
||||
uint8_t index = 0x0F & p.ptr[(y * p.stride) + x];
|
||||
have[(y * width) + x] = index ? ('0' + index) : '.';
|
||||
}
|
||||
@@ -1036,9 +1027,8 @@ test_wuffs_gif_decode_zero_width_frame() {
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-zero-width-frame.gif"));
|
||||
int q;
|
||||
for (q = 0; q < 3; q++) {
|
||||
read_file(&src, "test/data/artificial-gif/zero-width-frame.gif"));
|
||||
for (int q = 0; q < 3; q++) {
|
||||
src.meta.ri = 0;
|
||||
|
||||
wuffs_gif__decoder dec;
|
||||
@@ -1274,8 +1264,8 @@ do_test_wuffs_gif_decode_metadata(bool full) {
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, full ? "test/data/artificial/gif-metadata-full.gif"
|
||||
: "test/data/artificial/gif-metadata-empty.gif"));
|
||||
read_file(&src, full ? "test/data/artificial-gif/metadata-full.gif"
|
||||
: "test/data/artificial-gif/metadata-empty.gif"));
|
||||
|
||||
int iccp;
|
||||
for (iccp = 0; iccp < 2; iccp++) {
|
||||
@@ -1327,12 +1317,14 @@ do_test_wuffs_gif_decode_metadata(bool full) {
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
RETURN_FAIL("tell_me_more (iccp=%d, xmp=%d): \"%s\"", iccp, xmp,
|
||||
status.repr);
|
||||
} else if (minfo.flavor !=
|
||||
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA) {
|
||||
RETURN_FAIL("tell_me_more (iccp=%d, xmp=%d): flavor: have %" PRIu32
|
||||
", want %" PRIu32,
|
||||
iccp, xmp, minfo.flavor,
|
||||
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA);
|
||||
} else if (
|
||||
minfo.flavor !=
|
||||
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH) {
|
||||
RETURN_FAIL(
|
||||
"tell_me_more (iccp=%d, xmp=%d): flavor: have %" PRIu32
|
||||
", want %" PRIu32,
|
||||
iccp, xmp, minfo.flavor,
|
||||
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH);
|
||||
}
|
||||
|
||||
have_fourcc = wuffs_base__more_information__metadata__fourcc(&minfo);
|
||||
@@ -1480,7 +1472,7 @@ test_wuffs_gif_decode_multiple_graphic_controls() {
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(
|
||||
&src, "test/data/artificial/gif-multiple-graphic-controls.gif"));
|
||||
&src, "test/data/artificial-gif/multiple-graphic-controls.gif"));
|
||||
|
||||
wuffs_gif__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -1507,7 +1499,7 @@ test_wuffs_gif_decode_multiple_loop_counts() {
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-multiple-loop-counts.gif"));
|
||||
read_file(&src, "test/data/artificial-gif/multiple-loop-counts.gif"));
|
||||
|
||||
wuffs_gif__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
@@ -1518,29 +1510,27 @@ test_wuffs_gif_decode_multiple_loop_counts() {
|
||||
CHECK_STATUS("decode_image_config",
|
||||
wuffs_gif__decoder__decode_image_config(&dec, &ic, &src));
|
||||
|
||||
// See test/data/artificial/gif-multiple-loop-counts.gif.make-artificial.txt
|
||||
// See test/data/artificial-gif/multiple-loop-counts.gif.make-artificial.txt
|
||||
// for the want_num_animation_loops source. Note that the GIF wire format's
|
||||
// loop counts are the number of animation loops *after* the first play
|
||||
// through, and Wuffs' are the number *including* the first play through.
|
||||
|
||||
uint32_t want_num_animation_loops[4] = {1, 1, 51, 31};
|
||||
uint32_t want_num_animation_loops[4] = {0, 1, 51, 31};
|
||||
|
||||
uint32_t i;
|
||||
for (i = 0; true; i++) {
|
||||
{
|
||||
wuffs_base__status status =
|
||||
wuffs_gif__decoder__decode_frame_config(&dec, NULL, &src);
|
||||
if (i == WUFFS_TESTLIB_ARRAY_SIZE(want_num_animation_loops)) {
|
||||
if (status.repr != wuffs_base__note__end_of_data) {
|
||||
RETURN_FAIL("decode_frame_config #%" PRIu32
|
||||
": have \"%s\", want \"%s\"",
|
||||
i, status.repr, wuffs_base__note__end_of_data);
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("decode_frame_config #%" PRIu32 ": \"%s\"", i, status.repr);
|
||||
uint32_t i = 0;
|
||||
while (true) {
|
||||
wuffs_base__status status =
|
||||
wuffs_gif__decoder__decode_frame_config(&dec, NULL, &src);
|
||||
if (i == WUFFS_TESTLIB_ARRAY_SIZE(want_num_animation_loops)) {
|
||||
if (status.repr != wuffs_base__note__end_of_data) {
|
||||
RETURN_FAIL("decode_frame_config #%" PRIu32
|
||||
": have \"%s\", want \"%s\"",
|
||||
i, status.repr, wuffs_base__note__end_of_data);
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("decode_frame_config #%" PRIu32 ": \"%s\"", i, status.repr);
|
||||
}
|
||||
|
||||
uint32_t have = wuffs_gif__decoder__num_animation_loops(&dec);
|
||||
@@ -1550,6 +1540,7 @@ test_wuffs_gif_decode_multiple_loop_counts() {
|
||||
", want %" PRIu32,
|
||||
i, have, want);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
|
||||
uint32_t have = wuffs_gif__decoder__num_animation_loops(&dec);
|
||||
@@ -1587,7 +1578,7 @@ test_wuffs_gif_decode_pixel_data_none() {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/artificial/gif-pixel-data-none.gif"));
|
||||
CHECK_STRING(read_file(&src, "test/data/artificial-gif/pixel-data-none.gif"));
|
||||
|
||||
return do_test_wuffs_gif_decode_expecting(
|
||||
src, 0, wuffs_base__error__not_enough_data, true);
|
||||
@@ -1600,7 +1591,7 @@ test_wuffs_gif_decode_pixel_data_not_enough() {
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-pixel-data-not-enough.gif"));
|
||||
read_file(&src, "test/data/artificial-gif/pixel-data-not-enough.gif"));
|
||||
|
||||
return do_test_wuffs_gif_decode_expecting(
|
||||
src, 0, wuffs_base__error__not_enough_data, false);
|
||||
@@ -1612,11 +1603,20 @@ test_wuffs_gif_decode_pixel_data_too_much_sans_quirk() {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-pixel-data-too-much.gif"));
|
||||
|
||||
return do_test_wuffs_gif_decode_expecting(
|
||||
src, 0, wuffs_base__error__too_much_data, false);
|
||||
src.meta = wuffs_base__empty_io_buffer_meta();
|
||||
CHECK_STRING(read_file(
|
||||
&src, "test/data/artificial-gif/pixel-data-too-much-bad-lzw.gif"));
|
||||
CHECK_STRING(do_test_wuffs_gif_decode_expecting(
|
||||
src, 0, wuffs_lzw__error__bad_code, false));
|
||||
|
||||
src.meta = wuffs_base__empty_io_buffer_meta();
|
||||
CHECK_STRING(read_file(
|
||||
&src, "test/data/artificial-gif/pixel-data-too-much-good-lzw.gif"));
|
||||
CHECK_STRING(do_test_wuffs_gif_decode_expecting(
|
||||
src, 0, wuffs_base__error__too_much_data, false));
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -1625,11 +1625,20 @@ test_wuffs_gif_decode_pixel_data_too_much_with_quirk() {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-pixel-data-too-much.gif"));
|
||||
|
||||
return do_test_wuffs_gif_decode_expecting(
|
||||
src, WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA, NULL, false);
|
||||
src.meta = wuffs_base__empty_io_buffer_meta();
|
||||
CHECK_STRING(read_file(
|
||||
&src, "test/data/artificial-gif/pixel-data-too-much-bad-lzw.gif"));
|
||||
CHECK_STRING(do_test_wuffs_gif_decode_expecting(
|
||||
src, WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA, NULL, false));
|
||||
|
||||
src.meta = wuffs_base__empty_io_buffer_meta();
|
||||
CHECK_STRING(read_file(
|
||||
&src, "test/data/artificial-gif/pixel-data-too-much-good-lzw.gif"));
|
||||
CHECK_STRING(do_test_wuffs_gif_decode_expecting(
|
||||
src, WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA, NULL, false));
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
@@ -1815,8 +1824,7 @@ do_test_wuffs_gif_io_position(bool chunked) {
|
||||
wuffs_base__frame_config fcs[4];
|
||||
uint32_t width_wants[4] = {64, 37, 49, 49};
|
||||
uint64_t pos_wants[4] = {781, 2126, 2187, 2542};
|
||||
int i;
|
||||
for (i = 0; i < 4; i++) {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
fcs[i] = ((wuffs_base__frame_config){});
|
||||
wuffs_base__status status =
|
||||
wuffs_gif__decoder__decode_frame_config(&dec, &fcs[i], &src);
|
||||
@@ -1878,7 +1886,7 @@ do_test_wuffs_gif_io_position(bool chunked) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
src.meta.ri = pos_wants[i];
|
||||
|
||||
status = wuffs_gif__decoder__restart_frame(
|
||||
@@ -1887,8 +1895,7 @@ do_test_wuffs_gif_io_position(bool chunked) {
|
||||
RETURN_FAIL("restart_frame #%d: \"%s\"", i, status.repr);
|
||||
}
|
||||
|
||||
int j;
|
||||
for (j = i; j < 4; j++) {
|
||||
for (int j = i; j < 4; j++) {
|
||||
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
|
||||
status = wuffs_gif__decoder__decode_frame_config(&dec, &fc, &src);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
@@ -1939,7 +1946,7 @@ test_wuffs_gif_small_frame_interlaced() {
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(
|
||||
read_file(&src, "test/data/artificial/gif-small-frame-interlaced.gif"));
|
||||
read_file(&src, "test/data/artificial-gif/small-frame-interlaced.gif"));
|
||||
|
||||
wuffs_gif__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
|
||||
@@ -160,8 +160,7 @@ do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
|
||||
|
||||
// Decode the src data in 1 or 2 chunks, depending on whether end_limit is
|
||||
// or isn't zero.
|
||||
int i;
|
||||
for (i = 0; i < 2; i++) {
|
||||
for (int i = 0; i < 2; i++) {
|
||||
uint64_t rlimit = UINT64_MAX;
|
||||
const char* want_z = NULL;
|
||||
if (i == 0) {
|
||||
@@ -216,6 +215,65 @@ test_wuffs_gzip_checksum_verify_good() {
|
||||
return do_test_wuffs_gzip_checksum(false, 0);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_gzip_decode_infrequent_compaction() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
wuffs_gzip__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_gzip__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
|
||||
wuffs_base__io_buffer dst = ((wuffs_base__io_buffer){
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
|
||||
// src_bytes holds the first 50 Fibonacci numbers, gzipped using Python's
|
||||
// gzip module.
|
||||
uint8_t src_bytes[183] = {
|
||||
0x1F, 0x8B, 0x08, 0x00, 0x07, 0x22, 0x16, 0x61, 0x02, 0xFF, 0x15, 0x8F,
|
||||
0xC1, 0x11, 0x00, 0x31, 0x08, 0x02, 0xFF, 0x54, 0x23, 0x6A, 0x44, 0xFB,
|
||||
0x6F, 0xEC, 0xB8, 0xC9, 0xCB, 0x59, 0x09, 0x6B, 0x80, 0x7E, 0x89, 0xC2,
|
||||
0xC3, 0x82, 0x85, 0x24, 0xAA, 0xF1, 0x3C, 0x1D, 0xD8, 0x8D, 0xAC, 0x42,
|
||||
0x49, 0x18, 0x06, 0x6E, 0x05, 0xBE, 0x13, 0xF2, 0x6D, 0xA3, 0xB9, 0xC4,
|
||||
0x68, 0x1E, 0x18, 0xD7, 0x03, 0x4A, 0xF4, 0x57, 0x3B, 0x4F, 0xE8, 0xA9,
|
||||
0x59, 0xE8, 0x45, 0x9A, 0x26, 0xEB, 0x0A, 0xBC, 0x71, 0x02, 0x45, 0xAD,
|
||||
0xD7, 0x1E, 0x3B, 0xF3, 0xB0, 0x95, 0xD1, 0xE1, 0xDE, 0x9E, 0x9C, 0x73,
|
||||
0xB9, 0xB6, 0xE2, 0x50, 0x2F, 0xFB, 0x69, 0xF1, 0x14, 0xB9, 0x2E, 0xBD,
|
||||
0x4C, 0xF5, 0x5F, 0xD4, 0x57, 0x61, 0x88, 0x6C, 0x9A, 0x53, 0xA8, 0x8B,
|
||||
0x5D, 0x3A, 0x3A, 0xE5, 0xC8, 0xAD, 0x35, 0xC2, 0xCA, 0xC6, 0xDE, 0x9E,
|
||||
0xF7, 0x36, 0xD8, 0x96, 0x1A, 0x9D, 0x0B, 0x6F, 0xD0, 0x66, 0xD7, 0x5D,
|
||||
0x82, 0x4C, 0x62, 0xE5, 0xF3, 0xE8, 0xFA, 0x0B, 0x8B, 0x59, 0x64, 0x6B,
|
||||
0x8A, 0xF4, 0x84, 0x3C, 0xD9, 0xFC, 0x85, 0x0A, 0xBD, 0xA1, 0x67, 0x3F,
|
||||
0x0D, 0x24, 0xAD, 0xDA, 0xD2, 0x87, 0x0F, 0x12, 0x69, 0x4A, 0xA8, 0x3B,
|
||||
0x01, 0x00, 0x00,
|
||||
};
|
||||
wuffs_base__io_buffer src =
|
||||
wuffs_base__ptr_u8__reader(src_bytes, sizeof src_bytes, true);
|
||||
|
||||
// Decode 5 source bytes at a time. Compact every 15 source bytes.
|
||||
for (size_t i = 0; i < src.data.len; i += 5) {
|
||||
src.meta.wi = i;
|
||||
wuffs_base__status status =
|
||||
wuffs_gzip__decoder__transform_io(&dec, &dst, &src, g_work_slice_u8);
|
||||
if (status.repr != wuffs_base__suspension__short_read) {
|
||||
RETURN_FAIL("i=%zu: have \"%s\", want \"%s\"", i, status.repr,
|
||||
wuffs_base__suspension__short_read);
|
||||
}
|
||||
if (i % 15 == 0) {
|
||||
dst.meta.ri = dst.meta.wi;
|
||||
wuffs_base__io_buffer__compact(&dst);
|
||||
}
|
||||
}
|
||||
|
||||
src.meta.wi = src.data.len;
|
||||
src.meta.closed = true;
|
||||
CHECK_STATUS("final transform_io", wuffs_gzip__decoder__transform_io(
|
||||
&dec, &dst, &src, g_work_slice_u8));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_gzip_decode_midsummer() {
|
||||
CHECK_FOCUS(__func__);
|
||||
@@ -299,6 +357,7 @@ proc g_tests[] = {
|
||||
test_wuffs_gzip_checksum_verify_bad0,
|
||||
test_wuffs_gzip_checksum_verify_bad7,
|
||||
test_wuffs_gzip_checksum_verify_good,
|
||||
test_wuffs_gzip_decode_infrequent_compaction,
|
||||
test_wuffs_gzip_decode_interface,
|
||||
test_wuffs_gzip_decode_midsummer,
|
||||
test_wuffs_gzip_decode_pi,
|
||||
|
||||
@@ -86,8 +86,7 @@ test_wuffs_core_count_leading_zeroes_u64() {
|
||||
{.num = 0xFFFFFFFFFFFFFFFF, .want = 0},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
uint32_t have = wuffs_base__count_leading_zeroes_u64(test_cases[tc].num);
|
||||
if (have != test_cases[tc].want) {
|
||||
RETURN_FAIL("0x%" PRIX64 ": have %" PRIu32 ", want %" PRIu32,
|
||||
@@ -122,8 +121,7 @@ test_wuffs_core_multiply_u64() {
|
||||
.want_lo = 0x89B3DE09506618CF},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__multiply_u64__output have =
|
||||
wuffs_base__multiply_u64(test_cases[tc].x, test_cases[tc].y);
|
||||
if ((have.hi != test_cases[tc].want_hi) ||
|
||||
@@ -343,8 +341,7 @@ test_wuffs_strconv_hpd_rounded_integer() {
|
||||
{.want = UINT64_MAX, .str = "1234567890123456789"},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__private_implementation__high_prec_dec hpd;
|
||||
CHECK_STATUS("hpd__parse",
|
||||
wuffs_base__private_implementation__high_prec_dec__parse(
|
||||
@@ -389,8 +386,7 @@ test_wuffs_strconv_hpd_shift() {
|
||||
.want = "+314159000000000000000000000."},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__private_implementation__high_prec_dec hpd;
|
||||
CHECK_STATUS("hpd__parse",
|
||||
wuffs_base__private_implementation__high_prec_dec__parse(
|
||||
@@ -499,8 +495,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u16() {
|
||||
},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
double have_f64 = wuffs_base__ieee_754_bit_representation__from_u16_to_f64(
|
||||
test_cases[tc].u16_bits);
|
||||
double want_f64 = test_cases[tc].want_f64;
|
||||
@@ -508,7 +503,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u16() {
|
||||
bool equal = ((have_f64 == want_f64) ||
|
||||
((have_f64 != have_f64) && (want_f64 != want_f64)));
|
||||
if (!equal) {
|
||||
RETURN_FAIL("tc=%d: to_f64: have %g, want %g", tc, have_f64, want_f64);
|
||||
RETURN_FAIL("tc=%zu: to_f64: have %g, want %g", tc, have_f64, want_f64);
|
||||
}
|
||||
|
||||
uint64_t have_u64 =
|
||||
@@ -516,7 +511,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u16() {
|
||||
uint64_t want_u64 = test_cases[tc].want_u64;
|
||||
// There's more than one representation of NaN.
|
||||
if ((have_u64 != want_u64) && (want_u64 != nan_u64)) {
|
||||
RETURN_FAIL("tc=%d: to_u64: have 0x%016" PRIX64 ", want 0x%016" PRIX64,
|
||||
RETURN_FAIL("tc=%zu: to_u64: have 0x%016" PRIX64 ", want 0x%016" PRIX64,
|
||||
tc, have_u64, want_u64);
|
||||
}
|
||||
|
||||
@@ -530,13 +525,13 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u16() {
|
||||
wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
||||
want_u64 ^ ((uint64_t)noise)));
|
||||
if (lv.value != test_cases[tc].u16_bits) {
|
||||
RETURN_FAIL("tc=%d: noise=%d: to_u16 value: have 0x%04" PRIX16
|
||||
RETURN_FAIL("tc=%zu: noise=%d: to_u16 value: have 0x%04" PRIX16
|
||||
", want 0x%04" PRIX16,
|
||||
tc, noise, lv.value, test_cases[tc].u16_bits);
|
||||
}
|
||||
int want_lossy = (want_f64 == want_f64) ? noise : 0;
|
||||
if (((int)lv.lossy) != want_lossy) {
|
||||
RETURN_FAIL("tc=%d: noise=%d: to_u16 lossy: have %d, want %d", tc,
|
||||
RETURN_FAIL("tc=%zu: noise=%d: to_u16 lossy: have %d, want %d", tc,
|
||||
noise, ((int)(lv.lossy)), want_lossy);
|
||||
}
|
||||
}
|
||||
@@ -621,8 +616,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u32() {
|
||||
},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
double have_f64 = wuffs_base__ieee_754_bit_representation__from_u32_to_f64(
|
||||
test_cases[tc].u32_bits);
|
||||
double want_f64 = test_cases[tc].want_f64;
|
||||
@@ -630,7 +624,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u32() {
|
||||
bool equal = ((have_f64 == want_f64) ||
|
||||
((have_f64 != have_f64) && (want_f64 != want_f64)));
|
||||
if (!equal) {
|
||||
RETURN_FAIL("tc=%d: to_f64: have %g, want %g", tc, have_f64, want_f64);
|
||||
RETURN_FAIL("tc=%zu: to_f64: have %g, want %g", tc, have_f64, want_f64);
|
||||
}
|
||||
|
||||
uint64_t have_u64 =
|
||||
@@ -638,7 +632,7 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u32() {
|
||||
uint64_t want_u64 = test_cases[tc].want_u64;
|
||||
// There's more than one representation of NaN.
|
||||
if ((have_u64 != want_u64) && (want_u64 != nan_u64)) {
|
||||
RETURN_FAIL("tc=%d: to_u64: have 0x%016" PRIX64 ", want 0x%016" PRIX64,
|
||||
RETURN_FAIL("tc=%zu: to_u64: have 0x%016" PRIX64 ", want 0x%016" PRIX64,
|
||||
tc, have_u64, want_u64);
|
||||
}
|
||||
|
||||
@@ -652,13 +646,13 @@ test_wuffs_strconv_ieee_754_bit_representation_from_u32() {
|
||||
wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
||||
want_u64 ^ ((uint64_t)noise)));
|
||||
if (lv.value != test_cases[tc].u32_bits) {
|
||||
RETURN_FAIL("tc=%d: noise=%d: to_u32 value: have 0x%08" PRIX32
|
||||
RETURN_FAIL("tc=%zu: noise=%d: to_u32 value: have 0x%08" PRIX32
|
||||
", want 0x%08" PRIX32,
|
||||
tc, noise, lv.value, test_cases[tc].u32_bits);
|
||||
}
|
||||
int want_lossy = (want_f64 == want_f64) ? noise : 0;
|
||||
if (((int)lv.lossy) != want_lossy) {
|
||||
RETURN_FAIL("tc=%d: noise=%d: to_u32 lossy: have %d, want %d", tc,
|
||||
RETURN_FAIL("tc=%zu: noise=%d: to_u32 lossy: have %d, want %d", tc,
|
||||
noise, ((int)(lv.lossy)), want_lossy);
|
||||
}
|
||||
}
|
||||
@@ -749,8 +743,7 @@ test_wuffs_strconv_base_64() {
|
||||
"Zm9vYmFy", //
|
||||
};
|
||||
|
||||
size_t tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(wants); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(wants); tc++) {
|
||||
const bool src_closed = true;
|
||||
|
||||
wuffs_base__transform__output e = wuffs_base__base_64__encode(
|
||||
@@ -828,8 +821,7 @@ test_wuffs_strconv_parse_number_f64_options() {
|
||||
|
||||
// Test WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES.
|
||||
{
|
||||
int o;
|
||||
for (o = 0; o < 2; o++) {
|
||||
for (int o = 0; o < 2; o++) {
|
||||
const char* str = "001.25";
|
||||
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
|
||||
wuffs_base__make_slice_u8((void*)str, strlen(str)),
|
||||
@@ -859,8 +851,7 @@ test_wuffs_strconv_parse_number_f64_options() {
|
||||
|
||||
// Test WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES.
|
||||
{
|
||||
int o;
|
||||
for (o = 0; o < 2; o++) {
|
||||
for (int o = 0; o < 2; o++) {
|
||||
const char* str = "_1.2__5";
|
||||
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
|
||||
wuffs_base__make_slice_u8((void*)str, strlen(str)),
|
||||
@@ -889,8 +880,7 @@ test_wuffs_strconv_parse_number_f64_options() {
|
||||
|
||||
// Test WUFFS_BASE__PARSE_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA.
|
||||
{
|
||||
int o;
|
||||
for (o = 0; o < 2; o++) {
|
||||
for (int o = 0; o < 2; o++) {
|
||||
const char* str = "1,75";
|
||||
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
|
||||
wuffs_base__make_slice_u8((void*)str, strlen(str)),
|
||||
@@ -920,8 +910,7 @@ test_wuffs_strconv_parse_number_f64_options() {
|
||||
|
||||
// Test WUFFS_BASE__PARSE_NUMBER_FXX__REJECT_INF_AND_NAN.
|
||||
{
|
||||
int o;
|
||||
for (o = 0; o < 4; o++) {
|
||||
for (int o = 0; o < 4; o++) {
|
||||
const char* str = (o & 2) ? "1e999" : "nan";
|
||||
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
|
||||
wuffs_base__make_slice_u8((void*)str, strlen(str)),
|
||||
@@ -1008,6 +997,9 @@ test_wuffs_strconv_parse_number_f64_regular() {
|
||||
{.want = 0x4038000000000000, .str = "2.4E1"},
|
||||
{.want = 0x4038000000000000, .str = "24"},
|
||||
{.want = 0x4038000000000000, .str = "2400_00000_00000.00000_e-_1_2"},
|
||||
{.want = 0x405E9AA48FBB2888, .str = "122.416294033786585"},
|
||||
{.want = 0x405E9AA48FBB2888, .str = "122.41629403378658"},
|
||||
{.want = 0x405E9AA48FBB2889, .str = "122.4162940337866"},
|
||||
{.want = 0x40FE240C9FCB0C02, .str = "123456.789012"},
|
||||
{.want = 0x41E0246690000001,
|
||||
.str = "2.16656806400000023841857910156251e9"},
|
||||
@@ -1082,8 +1074,7 @@ test_wuffs_strconv_parse_number_f64_regular() {
|
||||
{.want = fail, .str = "nun"},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__result_f64 r = wuffs_base__parse_number_f64(
|
||||
wuffs_base__make_slice_u8((void*)test_cases[tc].str,
|
||||
strlen(test_cases[tc].str)),
|
||||
@@ -1135,8 +1126,7 @@ test_wuffs_strconv_parse_number_i64() {
|
||||
{.want = fail, .str = "9223372036854775808"}, // 1 << 63.
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__result_i64 r = wuffs_base__parse_number_i64(
|
||||
wuffs_base__make_slice_u8((void*)test_cases[tc].str,
|
||||
strlen(test_cases[tc].str)),
|
||||
@@ -1222,8 +1212,7 @@ test_wuffs_strconv_parse_number_u64() {
|
||||
{.want = fail, .str = "x"},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
|
||||
wuffs_base__make_slice_u8((void*)test_cases[tc].str,
|
||||
strlen(test_cases[tc].str)),
|
||||
@@ -1237,8 +1226,7 @@ test_wuffs_strconv_parse_number_u64() {
|
||||
|
||||
// Test WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_MULTIPLE_LEADING_ZEROES.
|
||||
{
|
||||
int o;
|
||||
for (o = 0; o < 2; o++) {
|
||||
for (int o = 0; o < 2; o++) {
|
||||
const char* str = "007";
|
||||
wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
|
||||
wuffs_base__make_slice_u8((void*)str, strlen(str)),
|
||||
@@ -1266,8 +1254,7 @@ test_wuffs_strconv_parse_number_u64() {
|
||||
|
||||
// Test WUFFS_BASE__PARSE_NUMBER_XXX__ALLOW_UNDERSCORES.
|
||||
{
|
||||
int o;
|
||||
for (o = 0; o < 2; o++) {
|
||||
for (int o = 0; o < 2; o++) {
|
||||
const char* str = "56_7__8";
|
||||
wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
|
||||
wuffs_base__make_slice_u8((void*)str, strlen(str)),
|
||||
@@ -1709,6 +1696,15 @@ test_wuffs_strconv_render_number_f64() {
|
||||
.want_3f = "24.000",
|
||||
.want_4g = "24",
|
||||
},
|
||||
{
|
||||
.x = 0x405E9AA48FBB2888,
|
||||
.want__e = "1.2241629403378658e+02",
|
||||
.want__f = "122.41629403378658",
|
||||
.want_0g = "1e+02",
|
||||
.want_2e = "1.22e+02",
|
||||
.want_3f = "122.416",
|
||||
.want_4g = "122.4",
|
||||
},
|
||||
{
|
||||
.x = 0x40FE240C9FCB0C02,
|
||||
.want__e = "1.23456789012e+05",
|
||||
@@ -2123,12 +2119,10 @@ test_wuffs_strconv_render_number_f64() {
|
||||
},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
double f64 = wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
||||
test_cases[tc].x);
|
||||
int o;
|
||||
for (o = 0; o < 6; o++) {
|
||||
for (int o = 0; o < 6; o++) {
|
||||
uint32_t precision = 0;
|
||||
uint32_t options = 0;
|
||||
const char* want = NULL;
|
||||
@@ -2177,8 +2171,7 @@ test_wuffs_strconv_render_number_f64() {
|
||||
|
||||
// Test WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA.
|
||||
{
|
||||
int o;
|
||||
for (o = 0; o < 2; o++) {
|
||||
for (int o = 0; o < 2; o++) {
|
||||
uint8_t dst[8] = {0};
|
||||
const double f64 = 1.75;
|
||||
const uint32_t precision = 2;
|
||||
@@ -2251,8 +2244,7 @@ test_wuffs_strconv_render_number_i64() {
|
||||
return "g_have_slice_u8.len is too short";
|
||||
}
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
size_t n = wuffs_base__render_number_i64(
|
||||
g_have_slice_u8, test_cases[tc].x,
|
||||
WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
|
||||
@@ -2306,8 +2298,7 @@ test_wuffs_strconv_render_number_u64() {
|
||||
return "g_have_slice_u8.len is too short";
|
||||
}
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
size_t n = wuffs_base__render_number_u64(
|
||||
g_have_slice_u8, test_cases[tc].x,
|
||||
WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
|
||||
@@ -2454,8 +2445,7 @@ test_wuffs_strconv_utf_8_next() {
|
||||
{.want0 = 0x0100FFFD, .want1 = 0x0100FFFD, .str = "\xED\xBF\xBF"},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__slice_u8 s = wuffs_base__make_slice_u8(
|
||||
(void*)test_cases[tc].str, strlen(test_cases[tc].str));
|
||||
// Override "The <NUL> byte" with "\x00".
|
||||
@@ -2578,8 +2568,7 @@ test_wuffs_json_decode_interface() {
|
||||
wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
uint32_t i;
|
||||
for (i = 0; quirks[i]; i++) {
|
||||
for (size_t i = 0; quirks[i]; i++) {
|
||||
wuffs_json__decoder__set_quirk_enabled(&dec, quirks[i], true);
|
||||
}
|
||||
CHECK_STRING(do_test__wuffs_base__token_decoder(
|
||||
@@ -2626,8 +2615,7 @@ const char* //
|
||||
test_wuffs_json_decode_end_of_data() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
int i;
|
||||
for (i = 0; i < 2; i++) {
|
||||
for (int i = 0; i < 2; i++) {
|
||||
uint8_t* src_ptr = (uint8_t*)("123null89");
|
||||
size_t src_len = i ? 3 : 9;
|
||||
|
||||
@@ -2719,11 +2707,10 @@ test_wuffs_json_decode_long_numbers() {
|
||||
|
||||
wuffs_json__decoder dec;
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
size_t suffix_length = strlen(test_cases[tc].suffix);
|
||||
if ((suffix_length + 1) > (119 - 102)) { // +1 for the terminal NUL.
|
||||
RETURN_FAIL("tc=%d: src_array is too short", tc);
|
||||
RETURN_FAIL("tc=%zu: src_array is too short", tc);
|
||||
}
|
||||
bool ends_with_space = (suffix_length > 0) &&
|
||||
(test_cases[tc].suffix[suffix_length - 1] == ' ');
|
||||
@@ -2764,7 +2751,7 @@ test_wuffs_json_decode_long_numbers() {
|
||||
}
|
||||
if (total_length != src.meta.ri) {
|
||||
RETURN_FAIL(
|
||||
"tc=%d, nines_length=%zu, closed=%d: total_length: have %zu, "
|
||||
"tc=%zu, nines_length=%zu, closed=%d: total_length: have %zu, "
|
||||
"want %zu",
|
||||
tc, nines_length, closed, total_length, src.meta.ri);
|
||||
}
|
||||
@@ -2780,7 +2767,7 @@ test_wuffs_json_decode_long_numbers() {
|
||||
|
||||
if (have != want) {
|
||||
RETURN_FAIL(
|
||||
"tc=%d, nines_length=%zu, closed=%d: have \"%s\", want \"%s\"",
|
||||
"tc=%zu, nines_length=%zu, closed=%d: have \"%s\", want \"%s\"",
|
||||
tc, nines_length, closed, have, want);
|
||||
}
|
||||
}
|
||||
@@ -2849,8 +2836,7 @@ test_wuffs_json_decode_prior_valid_utf_8() {
|
||||
|
||||
wuffs_json__decoder dec;
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
size_t n = strlen(test_cases[tc]);
|
||||
size_t num_preceding = 0;
|
||||
while (num_preceding < n) {
|
||||
@@ -2862,7 +2848,7 @@ test_wuffs_json_decode_prior_valid_utf_8() {
|
||||
}
|
||||
num_preceding += x.byte_length;
|
||||
if (num_preceding > n) {
|
||||
RETURN_FAIL("tc=%d: utf_8__next overflow", tc);
|
||||
RETURN_FAIL("tc=%zu: utf_8__next overflow", tc);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2910,7 +2896,7 @@ test_wuffs_json_decode_prior_valid_utf_8() {
|
||||
have += wuffs_base__token__length(t);
|
||||
} else {
|
||||
RETURN_FAIL(
|
||||
"tc=%d, prefix=%zu, suffix=%zu, closed=%d: unexpected token",
|
||||
"tc=%zu, prefix=%zu, suffix=%zu, closed=%d: unexpected token",
|
||||
tc, prefix, suffix, closed);
|
||||
}
|
||||
}
|
||||
@@ -2920,7 +2906,7 @@ test_wuffs_json_decode_prior_valid_utf_8() {
|
||||
}
|
||||
if (have != want) {
|
||||
RETURN_FAIL(
|
||||
"tc=%d, prefix=%zu, suffix=%zu, closed=%d: have %zu, want %zu",
|
||||
"tc=%zu, prefix=%zu, suffix=%zu, closed=%d: have %zu, want %zu",
|
||||
tc, prefix, suffix, closed, have, want);
|
||||
}
|
||||
}
|
||||
@@ -2987,10 +2973,8 @@ test_wuffs_json_decode_quirk_allow_backslash_etc() {
|
||||
},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
int q;
|
||||
for (q = 0; q < 2; q++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (int q = 0; q < 2; q++) {
|
||||
wuffs_json__decoder dec;
|
||||
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -3013,7 +2997,7 @@ test_wuffs_json_decode_quirk_allow_backslash_etc() {
|
||||
want_status_repr = wuffs_json__error__bad_c0_control_code;
|
||||
}
|
||||
if (have_status_repr != want_status_repr) {
|
||||
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
q, have_status_repr, want_status_repr);
|
||||
}
|
||||
if (want_status_repr != NULL) {
|
||||
@@ -3031,7 +3015,7 @@ test_wuffs_json_decode_quirk_allow_backslash_etc() {
|
||||
}
|
||||
}
|
||||
if (have != test_cases[tc].want) {
|
||||
RETURN_FAIL("tc=%d, q=%d: Unicode code point: have U+%04" PRIX32
|
||||
RETURN_FAIL("tc=%zu, q=%d: Unicode code point: have U+%04" PRIX32
|
||||
", want U+%04" PRIX32,
|
||||
tc, q, have, test_cases[tc].want);
|
||||
}
|
||||
@@ -3072,8 +3056,7 @@ test_wuffs_json_decode_quirk_allow_backslash_x() {
|
||||
.str = "\"a\\x\""},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_json__decoder dec;
|
||||
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -3090,7 +3073,7 @@ test_wuffs_json_decode_quirk_allow_backslash_x() {
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
|
||||
.repr;
|
||||
if (have_status_repr != test_cases[tc].want_status_repr) {
|
||||
RETURN_FAIL("tc=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
RETURN_FAIL("tc=%zu: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
have_status_repr, test_cases[tc].want_status_repr);
|
||||
}
|
||||
|
||||
@@ -3118,7 +3101,7 @@ test_wuffs_json_decode_quirk_allow_backslash_x() {
|
||||
}
|
||||
uint64_t want = test_cases[tc].want_code_points;
|
||||
if (have != want) {
|
||||
RETURN_FAIL("tc=%d: have U+%08" PRIX64 ", want U+%08" PRIX64, tc, have,
|
||||
RETURN_FAIL("tc=%zu: have U+%08" PRIX64 ", want U+%08" PRIX64, tc, have,
|
||||
want);
|
||||
}
|
||||
}
|
||||
@@ -3144,10 +3127,8 @@ test_wuffs_json_decode_quirk_allow_extra_comma() {
|
||||
{.want = "--", .str = "{,}"},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
int q;
|
||||
for (q = 0; q < 2; q++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (int q = 0; q < 2; q++) {
|
||||
wuffs_json__decoder dec;
|
||||
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -3165,7 +3146,7 @@ test_wuffs_json_decode_quirk_allow_extra_comma() {
|
||||
const char* want =
|
||||
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
|
||||
if (have != want) {
|
||||
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
q, have, want);
|
||||
}
|
||||
|
||||
@@ -3174,17 +3155,17 @@ test_wuffs_json_decode_quirk_allow_extra_comma() {
|
||||
total_length += wuffs_base__token__length(&tok.data.ptr[tok.meta.ri++]);
|
||||
}
|
||||
if (total_length != src.meta.ri) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
total_length, src.meta.ri);
|
||||
}
|
||||
if (test_cases[tc].want[q] == 'X') {
|
||||
if (total_length != src.data.len) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
total_length, src.data.len);
|
||||
}
|
||||
} else if (test_cases[tc].want[q] == '+') {
|
||||
if (total_length >= src.data.len) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want < %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want < %zu", tc, q,
|
||||
total_length, src.data.len);
|
||||
}
|
||||
}
|
||||
@@ -3219,10 +3200,8 @@ test_wuffs_json_decode_quirk_allow_inf_nan_numbers() {
|
||||
{.want = "--", .str = "∞"},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
int q;
|
||||
for (q = 0; q < 2; q++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (int q = 0; q < 2; q++) {
|
||||
wuffs_json__decoder dec;
|
||||
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -3240,7 +3219,7 @@ test_wuffs_json_decode_quirk_allow_inf_nan_numbers() {
|
||||
const char* want =
|
||||
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
|
||||
if (have != want) {
|
||||
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
q, have, want);
|
||||
}
|
||||
|
||||
@@ -3249,17 +3228,17 @@ test_wuffs_json_decode_quirk_allow_inf_nan_numbers() {
|
||||
total_length += wuffs_base__token__length(&tok.data.ptr[tok.meta.ri++]);
|
||||
}
|
||||
if (total_length != src.meta.ri) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
total_length, src.meta.ri);
|
||||
}
|
||||
if (test_cases[tc].want[q] == 'X') {
|
||||
if (total_length != src.data.len) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
total_length, src.data.len);
|
||||
}
|
||||
} else if (test_cases[tc].want[q] == '+') {
|
||||
if (total_length >= src.data.len) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want < %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want < %zu", tc, q,
|
||||
total_length, src.data.len);
|
||||
}
|
||||
}
|
||||
@@ -3288,10 +3267,8 @@ test_wuffs_json_decode_quirk_allow_comment_etc() {
|
||||
{.want = "----", .str = "[4/5]"}, // Lone slash.
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
int q;
|
||||
for (q = 0; q < 4; q++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (int q = 0; q < 4; q++) {
|
||||
wuffs_json__decoder dec;
|
||||
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -3311,7 +3288,7 @@ test_wuffs_json_decode_quirk_allow_comment_etc() {
|
||||
const char* want =
|
||||
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
|
||||
if (have != want) {
|
||||
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
q, have, want);
|
||||
}
|
||||
|
||||
@@ -3320,17 +3297,17 @@ test_wuffs_json_decode_quirk_allow_comment_etc() {
|
||||
total_length += wuffs_base__token__length(&tok.data.ptr[tok.meta.ri++]);
|
||||
}
|
||||
if (total_length != src.meta.ri) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
total_length, src.meta.ri);
|
||||
}
|
||||
if (test_cases[tc].want[q] == 'X') {
|
||||
if (total_length != src.data.len) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
total_length, src.data.len);
|
||||
}
|
||||
} else if (test_cases[tc].want[q] == '+') {
|
||||
if (total_length >= src.data.len) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want < %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want < %zu", tc, q,
|
||||
total_length, src.data.len);
|
||||
}
|
||||
}
|
||||
@@ -3365,10 +3342,8 @@ test_wuffs_json_decode_quirk_allow_leading_etc() {
|
||||
{.want = "----", .str = "\xEFtrue"},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
int q;
|
||||
for (q = 0; q < 4; q++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (int q = 0; q < 4; q++) {
|
||||
wuffs_json__decoder dec;
|
||||
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -3388,7 +3363,7 @@ test_wuffs_json_decode_quirk_allow_leading_etc() {
|
||||
const char* want =
|
||||
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
|
||||
if (have != want) {
|
||||
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
q, have, want);
|
||||
}
|
||||
|
||||
@@ -3397,17 +3372,17 @@ test_wuffs_json_decode_quirk_allow_leading_etc() {
|
||||
total_length += wuffs_base__token__length(&tok.data.ptr[tok.meta.ri++]);
|
||||
}
|
||||
if (total_length != src.meta.ri) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
total_length, src.meta.ri);
|
||||
}
|
||||
if (test_cases[tc].want[q] == 'X') {
|
||||
if (total_length != src.data.len) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
total_length, src.data.len);
|
||||
}
|
||||
} else if (test_cases[tc].want[q] == '+') {
|
||||
if (total_length >= src.data.len) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want < %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want < %zu", tc, q,
|
||||
total_length, src.data.len);
|
||||
}
|
||||
}
|
||||
@@ -3427,6 +3402,14 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
|
||||
// - '4' means that there is non-filler after eof-or-'\n'
|
||||
// - '5' means that there is non-filler before eof-or-'\n'
|
||||
//
|
||||
// The second and third bytes are digits such that the overall string starts
|
||||
// with a three digit number, which is parsed as the top-level JSON value and
|
||||
// everything afterwards is trailer.
|
||||
//
|
||||
// That three digit number modulo 100 also acts as a 'line number' (matching
|
||||
// the tc loop variable), starting counting from zero, so that the 6th test
|
||||
// case, tc == 5, is the line starting with "something hundred and five".
|
||||
//
|
||||
// WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER (together with
|
||||
// WUFFS_JSON__QUIRK_ALLOW_COMMENT_ETC) should decode the '1's, '2's and '3's
|
||||
// completely and the '4's and '5's up to but excluding the non-filler.
|
||||
@@ -3443,17 +3426,17 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
|
||||
"306 /*foo*/ \n", //
|
||||
"307 /*foo*/ \n\n", //
|
||||
"308/*bar\nbaz*/\n\n", //
|
||||
"309 // qux\n\n", //
|
||||
"310 /*c0*/ /*c1*/\n\n", //
|
||||
"311 /*c0*/ \n\n // c2 \n\n", //
|
||||
"412 \n9", //
|
||||
"513 9", //
|
||||
"309 // qux", //
|
||||
"310 // qux\n", //
|
||||
"311 // qux\n\n", //
|
||||
"312 /*c0*/ /*c1*/\n\n", //
|
||||
"313 /*c0*/ \n\n // c2 \n\n", //
|
||||
"414 \n9", //
|
||||
"515 9", //
|
||||
};
|
||||
|
||||
int tc;
|
||||
|
||||
// Test ALLOW_ETC.
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
void* tc_ptr = (void*)(test_cases[tc]);
|
||||
size_t tc_len = strlen(test_cases[tc]);
|
||||
char code = test_cases[tc][0];
|
||||
@@ -3477,8 +3460,8 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8)
|
||||
.repr;
|
||||
if (have_repr != NULL) {
|
||||
RETURN_FAIL("tc=%d, ALLOW_ETC: decode_tokens: have \"%s\", want NULL", tc,
|
||||
have_repr);
|
||||
RETURN_FAIL("tc=%zu, ALLOW_ETC: decode_tokens: have \"%s\", want NULL",
|
||||
tc, have_repr);
|
||||
}
|
||||
|
||||
size_t have_total_length = 0;
|
||||
@@ -3488,16 +3471,16 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
|
||||
}
|
||||
size_t want_total_length = tc_len - ((code >= '4') ? 1 : 0);
|
||||
if (have_total_length != src.meta.ri) {
|
||||
RETURN_FAIL("tc=%d, ALLOW_ETC: total_length: have %zu, want %zu", tc,
|
||||
RETURN_FAIL("tc=%zu, ALLOW_ETC: total_length: have %zu, want %zu", tc,
|
||||
have_total_length, src.meta.ri);
|
||||
} else if (have_total_length != want_total_length) {
|
||||
RETURN_FAIL("tc=%d, ALLOW_ETC: total_length: have %zu, want %zu", tc,
|
||||
RETURN_FAIL("tc=%zu, ALLOW_ETC: total_length: have %zu, want %zu", tc,
|
||||
have_total_length, want_total_length);
|
||||
}
|
||||
}
|
||||
|
||||
// Test EXPECT_ETC.
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
void* tc_ptr = (void*)(test_cases[tc]);
|
||||
size_t tc_len = strlen(test_cases[tc]);
|
||||
char code = test_cases[tc][0];
|
||||
@@ -3519,7 +3502,7 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
|
||||
const char* want_repr =
|
||||
((code == '3') || (code == '5')) ? wuffs_json__error__bad_input : NULL;
|
||||
if (have_repr != want_repr) {
|
||||
RETURN_FAIL("tc=%d, EXPECT_ETC: decode_tokens: have \"%s\", want \"%s\"",
|
||||
RETURN_FAIL("tc=%zu, EXPECT_ETC: decode_tokens: have \"%s\", want \"%s\"",
|
||||
tc, have_repr, want_repr);
|
||||
} else if (have_repr != NULL) {
|
||||
continue;
|
||||
@@ -3532,10 +3515,10 @@ test_wuffs_json_decode_quirk_allow_trailing_comments() {
|
||||
}
|
||||
size_t want_total_length = tc_len - ((code == '1') ? 0 : 1);
|
||||
if (have_total_length != src.meta.ri) {
|
||||
RETURN_FAIL("tc=%d, EXPECT_ETC: total_length: have %zu, want %zu", tc,
|
||||
RETURN_FAIL("tc=%zu, EXPECT_ETC: total_length: have %zu, want %zu", tc,
|
||||
have_total_length, src.meta.ri);
|
||||
} else if (have_total_length != want_total_length) {
|
||||
RETURN_FAIL("tc=%d, EXPECT_ETC: total_length: have %zu, want %zu", tc,
|
||||
RETURN_FAIL("tc=%zu, EXPECT_ETC: total_length: have %zu, want %zu", tc,
|
||||
have_total_length, want_total_length);
|
||||
}
|
||||
}
|
||||
@@ -3572,10 +3555,8 @@ test_wuffs_json_decode_quirk_allow_trailing_filler() {
|
||||
{.want = "XXX", .str = "0"}, //
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
int q;
|
||||
for (q = 0; q < 3; q++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (int q = 0; q < 3; q++) {
|
||||
wuffs_json__decoder dec;
|
||||
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -3595,7 +3576,7 @@ test_wuffs_json_decode_quirk_allow_trailing_filler() {
|
||||
const char* want =
|
||||
(test_cases[tc].want[q] != '-') ? NULL : wuffs_json__error__bad_input;
|
||||
if (have != want) {
|
||||
RETURN_FAIL("tc=%d, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
RETURN_FAIL("tc=%zu, q=%d: decode_tokens: have \"%s\", want \"%s\"", tc,
|
||||
q, have, want);
|
||||
}
|
||||
|
||||
@@ -3604,17 +3585,17 @@ test_wuffs_json_decode_quirk_allow_trailing_filler() {
|
||||
total_length += wuffs_base__token__length(&tok.data.ptr[tok.meta.ri++]);
|
||||
}
|
||||
if (total_length != src.meta.ri) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
total_length, src.meta.ri);
|
||||
}
|
||||
if (test_cases[tc].want[q] == 'X') {
|
||||
if (total_length != src.data.len) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want %zu", tc, q,
|
||||
total_length, src.data.len);
|
||||
}
|
||||
} else if (test_cases[tc].want[q] == '+') {
|
||||
if (total_length >= src.data.len) {
|
||||
RETURN_FAIL("tc=%d, q=%d: total_length: have %zu, want < %zu", tc, q,
|
||||
RETURN_FAIL("tc=%zu, q=%d: total_length: have %zu, want < %zu", tc, q,
|
||||
total_length, src.data.len);
|
||||
}
|
||||
}
|
||||
@@ -3672,8 +3653,7 @@ test_wuffs_json_decode_quirk_replace_invalid_unicode() {
|
||||
{.want = "a\xF0\x90\x80\x80?z", .str = "\"a\\uD800\\uDC00\\uDFFFz\""},
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_json__decoder dec;
|
||||
CHECK_STATUS("initialize", wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -3707,7 +3687,7 @@ test_wuffs_json_decode_quirk_replace_invalid_unicode() {
|
||||
n = 1;
|
||||
}
|
||||
if ((have.data.len - have.meta.wi) < n) {
|
||||
RETURN_FAIL("tc=%d: token too long", tc);
|
||||
RETURN_FAIL("tc=%zu: token too long", tc);
|
||||
}
|
||||
memcpy(&have.data.ptr[have.meta.wi], &u[0], n);
|
||||
have.meta.wi += n;
|
||||
@@ -3718,35 +3698,35 @@ test_wuffs_json_decode_quirk_replace_invalid_unicode() {
|
||||
} else if (vbd &
|
||||
WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) {
|
||||
if ((have.data.len - have.meta.wi) < token_length) {
|
||||
RETURN_FAIL("tc=%d: token too long", tc);
|
||||
RETURN_FAIL("tc=%zu: token too long", tc);
|
||||
}
|
||||
memcpy(&have.data.ptr[have.meta.wi], &test_cases[tc].str[src_index],
|
||||
token_length);
|
||||
have.meta.wi += token_length;
|
||||
} else {
|
||||
RETURN_FAIL("tc=%d: unexpected string-token conversion", tc);
|
||||
RETURN_FAIL("tc=%zu: unexpected string-token conversion", tc);
|
||||
}
|
||||
|
||||
} else {
|
||||
RETURN_FAIL("tc=%d: unexpected token", tc);
|
||||
RETURN_FAIL("tc=%zu: unexpected token", tc);
|
||||
}
|
||||
|
||||
src_index += token_length;
|
||||
}
|
||||
|
||||
if (src_index != src.meta.ri) {
|
||||
RETURN_FAIL("tc=%d: src_index: have %" PRIu64 ", want %zu", tc, src_index,
|
||||
src.meta.ri);
|
||||
RETURN_FAIL("tc=%zu: src_index: have %" PRIu64 ", want %zu", tc,
|
||||
src_index, src.meta.ri);
|
||||
}
|
||||
|
||||
if (have.meta.wi >= have.data.len) {
|
||||
RETURN_FAIL("tc=%d: too many have bytes", tc);
|
||||
RETURN_FAIL("tc=%zu: too many have bytes", tc);
|
||||
}
|
||||
have.data.ptr[have.meta.wi] = '\x00';
|
||||
size_t len = strlen(test_cases[tc].want);
|
||||
if ((len != have.meta.wi) ||
|
||||
(memcmp(have.data.ptr, test_cases[tc].want, len) != 0)) {
|
||||
RETURN_FAIL("tc=%d: have \"%s\", want \"%s\"", tc, have.data.ptr,
|
||||
RETURN_FAIL("tc=%zu: have \"%s\", want \"%s\"", tc, have.data.ptr,
|
||||
test_cases[tc].want);
|
||||
}
|
||||
}
|
||||
@@ -3807,8 +3787,7 @@ test_wuffs_json_decode_unicode4_escapes() {
|
||||
};
|
||||
|
||||
wuffs_json__decoder dec;
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -3822,8 +3801,7 @@ test_wuffs_json_decode_unicode4_escapes() {
|
||||
|
||||
uint32_t have = fail;
|
||||
uint64_t total_length = 0;
|
||||
size_t i;
|
||||
for (i = tok.meta.ri; i < tok.meta.wi; i++) {
|
||||
for (size_t i = tok.meta.ri; i < tok.meta.wi; i++) {
|
||||
wuffs_base__token* t = &tok.data.ptr[i];
|
||||
total_length =
|
||||
wuffs_base__u64__sat_add(total_length, wuffs_base__token__length(t));
|
||||
@@ -3885,8 +3863,7 @@ test_wuffs_json_decode_src_io_buffer_length() {
|
||||
|
||||
wuffs_json__decoder dec;
|
||||
|
||||
int i;
|
||||
for (i = WUFFS_JSON__DECODER_NUMBER_LENGTH_MAX_INCL - 2;
|
||||
for (int i = WUFFS_JSON__DECODER_NUMBER_LENGTH_MAX_INCL - 2;
|
||||
i <= WUFFS_JSON__DECODER_NUMBER_LENGTH_MAX_INCL + 2; i++) {
|
||||
if (i < 0) {
|
||||
RETURN_FAIL("invalid test case: i=%d", i);
|
||||
@@ -3997,8 +3974,7 @@ test_wuffs_json_decode_string() {
|
||||
};
|
||||
|
||||
wuffs_json__decoder dec;
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_json__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
@@ -4012,8 +3988,7 @@ test_wuffs_json_decode_string() {
|
||||
wuffs_json__decoder__decode_tokens(&dec, &tok, &src, g_work_slice_u8);
|
||||
|
||||
uint64_t total_length = 0;
|
||||
size_t i;
|
||||
for (i = tok.meta.ri; i < tok.meta.wi; i++) {
|
||||
for (size_t i = tok.meta.ri; i < tok.meta.wi; i++) {
|
||||
wuffs_base__token* t = &tok.data.ptr[i];
|
||||
total_length =
|
||||
wuffs_base__u64__sat_add(total_length, wuffs_base__token__length(t));
|
||||
@@ -4049,9 +4024,8 @@ do_bench_wuffs_strconv_parse_number_f64(const char* str,
|
||||
wuffs_base__slice_u8 s = wuffs_base__make_slice_u8((void*)str, strlen(str));
|
||||
|
||||
bench_start();
|
||||
uint64_t i;
|
||||
uint64_t iters = iters_unscaled * g_flags.iterscale;
|
||||
for (i = 0; i < iters; i++) {
|
||||
for (uint64_t i = 0; i < iters; i++) {
|
||||
CHECK_STATUS("", wuffs_base__parse_number_f64(
|
||||
s, WUFFS_BASE__PARSE_NUMBER_XXX__DEFAULT_OPTIONS)
|
||||
.status);
|
||||
@@ -4092,11 +4066,9 @@ const char* //
|
||||
do_bench_wuffs_strconv_render_number_f64(wuffs_base__slice_u64 test_cases,
|
||||
uint64_t iters_unscaled) {
|
||||
bench_start();
|
||||
uint64_t i;
|
||||
uint64_t iters = iters_unscaled * g_flags.iterscale;
|
||||
for (i = 0; i < iters; i++) {
|
||||
size_t tc;
|
||||
for (tc = 0; tc < test_cases.len; tc++) {
|
||||
for (uint64_t i = 0; i < iters; i++) {
|
||||
for (size_t tc = 0; tc < test_cases.len; tc++) {
|
||||
size_t n = wuffs_base__render_number_f64(
|
||||
g_have_slice_u8,
|
||||
wuffs_base__ieee_754_bit_representation__from_u64_to_f64(
|
||||
|
||||
@@ -225,8 +225,7 @@ test_wuffs_lzw_decode_output_bad() {
|
||||
// (0x41, 0x42, 0x43) then a bad 8-bit code 0xFF. Decoding should produce 3
|
||||
// bytes and consume 4 bytes.
|
||||
src.meta.wi = 20;
|
||||
int i;
|
||||
for (i = 0; i < src.meta.wi; i++) {
|
||||
for (int i = 0; i < src.meta.wi; i++) {
|
||||
src.data.ptr[i] = 0;
|
||||
}
|
||||
src.data.ptr[0] = 0x41;
|
||||
@@ -271,8 +270,7 @@ test_wuffs_lzw_decode_output_empty() {
|
||||
// Set up src to be 20 bytes long, starting with the 9-bit end code 0x101.
|
||||
// Decoding should produce 0 bytes and consume 2 bytes.
|
||||
src.meta.wi = 20;
|
||||
int i;
|
||||
for (i = 0; i < src.meta.wi; i++) {
|
||||
for (int i = 0; i < src.meta.wi; i++) {
|
||||
src.data.ptr[i] = 0;
|
||||
}
|
||||
src.data.ptr[0] = 0x01;
|
||||
@@ -405,9 +403,8 @@ do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
|
||||
|
||||
bench_start();
|
||||
uint64_t n_bytes = 0;
|
||||
uint64_t i;
|
||||
uint64_t iters = iters_unscaled * g_flags.iterscale;
|
||||
for (i = 0; i < iters; i++) {
|
||||
for (uint64_t i = 0; i < iters; i++) {
|
||||
have.meta.wi = 0;
|
||||
src.meta.ri = 1; // Skip the literal width.
|
||||
wuffs_lzw__decoder dec;
|
||||
|
||||
@@ -118,8 +118,7 @@ do_test_xxxxx_png_decode_bad_crc32_checksum_critical(
|
||||
#endif
|
||||
};
|
||||
|
||||
int tc;
|
||||
for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
@@ -132,7 +131,7 @@ do_test_xxxxx_png_decode_bad_crc32_checksum_critical(
|
||||
wuffs_base__make_pixel_format(
|
||||
WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL),
|
||||
NULL, 0, &src)) {
|
||||
RETURN_FAIL("tc=%d (filename=\"%s\"): bad checksum not rejected", tc,
|
||||
RETURN_FAIL("tc=%zu (filename=\"%s\"): bad checksum not rejected", tc,
|
||||
test_cases[tc]);
|
||||
}
|
||||
}
|
||||
@@ -149,6 +148,10 @@ do_wuffs_png_swizzle(uint32_t width,
|
||||
CHECK_STATUS("initialize", wuffs_png__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__DEFAULT_OPTIONS));
|
||||
dec.private_impl.f_frame_rect_x0 = 0;
|
||||
dec.private_impl.f_frame_rect_y0 = 0;
|
||||
dec.private_impl.f_frame_rect_x1 = width;
|
||||
dec.private_impl.f_frame_rect_y1 = height;
|
||||
dec.private_impl.f_width = width;
|
||||
dec.private_impl.f_height = height;
|
||||
dec.private_impl.f_pass_bytes_per_row = width;
|
||||
@@ -315,16 +318,14 @@ apply_png_encode_filters(wuffs_base__slice_u8 dst_rows,
|
||||
(((width + 1) * height) != src_rows.len)) {
|
||||
return "apply_png_encode_filters: unexpected rows.len";
|
||||
}
|
||||
size_t y;
|
||||
uint8_t* src_prev = NULL;
|
||||
for (y = 0; y < height; y++) {
|
||||
for (size_t y = 0; y < height; y++) {
|
||||
uint8_t filter = src_rows.ptr[(width + 1) * y];
|
||||
dst_rows.ptr[(width + 1) * y] = filter;
|
||||
uint8_t* dst_curr = &dst_rows.ptr[((width + 1) * y) + 1];
|
||||
uint8_t* src_curr = &src_rows.ptr[((width + 1) * y) + 1];
|
||||
|
||||
size_t x;
|
||||
for (x = 0; x < width; x++) {
|
||||
for (size_t x = 0; x < width; x++) {
|
||||
int32_t fa = 0;
|
||||
int32_t fb = 0;
|
||||
int32_t fc = 0;
|
||||
@@ -449,26 +450,485 @@ test_wuffs_png_decode_filters_round_trip() {
|
||||
const char* //
|
||||
test_wuffs_png_decode_frame_config() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
static const uint64_t hibiscus_regular_want_areas[] = {
|
||||
312 * 442,
|
||||
};
|
||||
static const uint64_t hibiscus_regular_want_io_ps[] = {
|
||||
0x0021,
|
||||
};
|
||||
static const uint64_t animated_red_blue_want_areas[] = {
|
||||
64 * 48,
|
||||
37 * 9,
|
||||
49 * 40,
|
||||
37 * 9,
|
||||
};
|
||||
static const uint64_t animated_red_blue_want_io_ps[] = {
|
||||
0x006D,
|
||||
0x044A,
|
||||
0x04D1,
|
||||
0x0720,
|
||||
};
|
||||
|
||||
struct {
|
||||
const char* filename;
|
||||
uint64_t want_count;
|
||||
const uint64_t* want_areas;
|
||||
const uint64_t* want_io_ps;
|
||||
} test_cases[] = {
|
||||
{
|
||||
.filename = "test/data/hibiscus.regular.png",
|
||||
.want_count = WUFFS_TESTLIB_ARRAY_SIZE(hibiscus_regular_want_areas),
|
||||
.want_areas = hibiscus_regular_want_areas,
|
||||
.want_io_ps = hibiscus_regular_want_io_ps,
|
||||
},
|
||||
{
|
||||
.filename = "test/data/animated-red-blue.apng",
|
||||
.want_count = WUFFS_TESTLIB_ARRAY_SIZE(animated_red_blue_want_areas),
|
||||
.want_areas = animated_red_blue_want_areas,
|
||||
.want_io_ps = animated_red_blue_want_io_ps,
|
||||
},
|
||||
};
|
||||
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_png__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_png__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, test_cases[tc].filename));
|
||||
|
||||
uint64_t have_count = 0;
|
||||
while (true) {
|
||||
wuffs_base__status status =
|
||||
wuffs_png__decoder__decode_frame_config(&dec, &fc, &src);
|
||||
if (status.repr == wuffs_base__note__end_of_data) {
|
||||
break;
|
||||
} else if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("decode_frame_config tc=%zu #%" PRIu64 ": %s", tc,
|
||||
have_count, status.repr);
|
||||
}
|
||||
|
||||
if (have_count < test_cases[tc].want_count) {
|
||||
uint64_t have_area = ((uint64_t)wuffs_base__frame_config__width(&fc)) *
|
||||
((uint64_t)wuffs_base__frame_config__height(&fc));
|
||||
if (have_area != test_cases[tc].want_areas[have_count]) {
|
||||
RETURN_FAIL(
|
||||
"area tc=%zu #%" PRIu64 ": have %" PRIu64 ", want %" PRIu64, tc,
|
||||
have_count, have_area, test_cases[tc].want_areas[have_count]);
|
||||
}
|
||||
|
||||
uint64_t have_io_p = wuffs_base__frame_config__io_position(&fc);
|
||||
if (have_io_p != test_cases[tc].want_io_ps[have_count]) {
|
||||
RETURN_FAIL("io_position tc=%zu #%" PRIu64 ": have %" PRIu64
|
||||
", want %" PRIu64,
|
||||
tc, have_count, have_io_p,
|
||||
test_cases[tc].want_io_ps[have_count]);
|
||||
}
|
||||
}
|
||||
|
||||
have_count++;
|
||||
}
|
||||
|
||||
if (have_count != test_cases[tc].want_count) {
|
||||
RETURN_FAIL("count tc=%zu: have %" PRIu64 ", want %" PRIu64, tc,
|
||||
have_count, test_cases[tc].want_count);
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_png_decode_metadata_chrm_gama_srgb() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_png__decoder dec;
|
||||
|
||||
for (int q = 0; q < 4; q++) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/bricks-dither.png"));
|
||||
wuffs_base__image_config ic = ((wuffs_base__image_config){});
|
||||
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_png__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
|
||||
uint32_t want_fourcc = 0;
|
||||
uint32_t want[8] = {0};
|
||||
uint32_t have[8] = {0};
|
||||
if (q == 1) {
|
||||
want_fourcc = WUFFS_BASE__FOURCC__CHRM;
|
||||
want[0] = 31270;
|
||||
want[1] = 32900;
|
||||
want[2] = 64000;
|
||||
want[3] = 33000;
|
||||
want[4] = 30000;
|
||||
want[5] = 60000;
|
||||
want[6] = 15000;
|
||||
want[7] = 6000;
|
||||
} else if (q == 2) {
|
||||
want_fourcc = WUFFS_BASE__FOURCC__GAMA;
|
||||
want[0] = 45455;
|
||||
} else if (q == 3) {
|
||||
want_fourcc = WUFFS_BASE__FOURCC__SRGB;
|
||||
want[0] = WUFFS_BASE__SRGB_RENDERING_INTENT__PERCEPTUAL;
|
||||
have[0] = 123;
|
||||
}
|
||||
wuffs_png__decoder__set_report_metadata(&dec, want_fourcc, true);
|
||||
|
||||
while (true) {
|
||||
wuffs_base__status status =
|
||||
wuffs_png__decoder__decode_image_config(&dec, &ic, &src);
|
||||
if (wuffs_base__status__is_ok(&status)) {
|
||||
break;
|
||||
} else if (status.repr != wuffs_base__note__metadata_reported) {
|
||||
RETURN_FAIL("decode_image_config (q=%d): have \"%s\", want \"%s\"", q,
|
||||
status.repr, wuffs_base__note__metadata_reported);
|
||||
}
|
||||
|
||||
wuffs_base__io_buffer empty = wuffs_base__empty_io_buffer();
|
||||
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
|
||||
status = wuffs_png__decoder__tell_me_more(&dec, &empty, &minfo, &src);
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
RETURN_FAIL("tell_me_more (q=%d): \"%s\"", q, status.repr);
|
||||
} else if (minfo.flavor !=
|
||||
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED) {
|
||||
RETURN_FAIL("tell_me_more (q=%d): flavor: have %" PRIu32
|
||||
", want %" PRIu32,
|
||||
q, minfo.flavor,
|
||||
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED);
|
||||
}
|
||||
uint32_t have_fourcc =
|
||||
wuffs_base__more_information__metadata__fourcc(&minfo);
|
||||
if (have_fourcc != want_fourcc) {
|
||||
RETURN_FAIL("tell_me_more (q=%d): fourcc: have 0x%08" PRIX32
|
||||
", want 0x%08" PRIX32,
|
||||
q, have_fourcc, want_fourcc);
|
||||
} else if (have_fourcc == WUFFS_BASE__FOURCC__CHRM) {
|
||||
for (int i = 0; i < 8; i++) {
|
||||
have[i] = ((uint32_t)(
|
||||
wuffs_base__more_information__metadata_parsed__chrm(&minfo, i)));
|
||||
}
|
||||
} else if (have_fourcc == WUFFS_BASE__FOURCC__GAMA) {
|
||||
have[0] = wuffs_base__more_information__metadata_parsed__gama(&minfo);
|
||||
} else if (have_fourcc == WUFFS_BASE__FOURCC__SRGB) {
|
||||
have[0] = wuffs_base__more_information__metadata_parsed__srgb(&minfo);
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < 8; i++) {
|
||||
if (have[i] != want[i]) {
|
||||
RETURN_FAIL("(q=%d, i=%d): have %" PRIu32 ", want %" PRIu32, q, i,
|
||||
have[i], want[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_png_decode_metadata_exif() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/artificial-png/exif.png"));
|
||||
|
||||
wuffs_png__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_png__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_png__decoder__set_report_metadata(&dec, WUFFS_BASE__FOURCC__EXIF, true);
|
||||
|
||||
wuffs_base__image_config ic = ((wuffs_base__image_config){});
|
||||
wuffs_base__io_buffer empty = wuffs_base__empty_io_buffer();
|
||||
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
|
||||
|
||||
wuffs_base__status status =
|
||||
wuffs_png__decoder__decode_image_config(&dec, &ic, &src);
|
||||
if (status.repr != wuffs_base__note__metadata_reported) {
|
||||
RETURN_FAIL("decode_image_config #0: have \"%s\", want \"%s\"", status.repr,
|
||||
wuffs_base__note__metadata_reported);
|
||||
}
|
||||
|
||||
status = wuffs_png__decoder__tell_me_more(&dec, &empty, &minfo, &src);
|
||||
if (status.repr != wuffs_base__suspension__even_more_information) {
|
||||
RETURN_FAIL("tell_me_more #0: have \"%s\", want \"%s\"", status.repr,
|
||||
wuffs_base__suspension__even_more_information);
|
||||
}
|
||||
|
||||
// "hd test/data/artificial-png/exif.png" says 0x29..0x33 holds "LoremIpsum".
|
||||
wuffs_base__range_ie_u64 have =
|
||||
wuffs_base__more_information__metadata_raw_passthrough__range(&minfo);
|
||||
wuffs_base__range_ie_u64 want = wuffs_base__make_range_ie_u64(0x29, 0x33);
|
||||
if (!wuffs_base__range_ie_u64__equals(&have, want)) {
|
||||
RETURN_FAIL("range #0: have 0x%" PRIx64 "..0x%" PRIX64 ", want 0x%" PRIx64
|
||||
"..0x%" PRIX64,
|
||||
have.min_incl, have.max_excl, want.min_incl, want.max_excl);
|
||||
} else if ((src.meta.ri == 0x29) && (src.meta.wi >= 0x33)) {
|
||||
src.meta.ri = 0x33;
|
||||
}
|
||||
|
||||
status = wuffs_png__decoder__tell_me_more(&dec, &empty, &minfo, &src);
|
||||
if (status.repr != NULL) {
|
||||
RETURN_FAIL("tell_me_more #1: have \"%s\", want \"(null)\"", status.repr);
|
||||
}
|
||||
have = wuffs_base__more_information__metadata_raw_passthrough__range(&minfo);
|
||||
if (!wuffs_base__range_ie_u64__is_empty(&have)) {
|
||||
RETURN_FAIL("tell_me_more #1: non-empty range");
|
||||
}
|
||||
|
||||
status = wuffs_png__decoder__decode_image_config(&dec, &ic, &src);
|
||||
if (status.repr != NULL) {
|
||||
RETURN_FAIL("decode_image_config #1: have \"%s\", want \"(null)\"",
|
||||
status.repr);
|
||||
} else if (wuffs_base__pixel_config__width(&ic.pixcfg) != 1) {
|
||||
RETURN_FAIL("decode_image_config #1: have %" PRIu32 ", want 1",
|
||||
wuffs_base__pixel_config__width(&ic.pixcfg));
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_png_decode_metadata_iccp() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&want, "test/data/DCI-P3-D65.icc"));
|
||||
CHECK_STRING(read_file(
|
||||
&src, "test/data/red-blue-gradient.dcip3d65-no-chrm-no-gama.png"));
|
||||
|
||||
bool seen_iccp = false;
|
||||
|
||||
wuffs_png__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_png__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_png__decoder__set_report_metadata(&dec, WUFFS_BASE__FOURCC__ICCP, true);
|
||||
|
||||
wuffs_base__image_config ic = ((wuffs_base__image_config){});
|
||||
|
||||
while (true) {
|
||||
wuffs_base__status status =
|
||||
wuffs_png__decoder__decode_image_config(&dec, &ic, &src);
|
||||
if (wuffs_base__status__is_ok(&status)) {
|
||||
break;
|
||||
} else if (status.repr != wuffs_base__note__metadata_reported) {
|
||||
RETURN_FAIL("decode_image_config: have \"%s\", want \"%s\"", status.repr,
|
||||
wuffs_base__note__metadata_reported);
|
||||
}
|
||||
|
||||
{
|
||||
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
|
||||
wuffs_base__status status =
|
||||
wuffs_png__decoder__tell_me_more(&dec, &have, &minfo, &src);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("tell_me_more: \"%s\"", status.repr);
|
||||
} else if (minfo.flavor !=
|
||||
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM) {
|
||||
RETURN_FAIL(
|
||||
"tell_me_more: flavor: have %" PRIu32 ", want %" PRIu32,
|
||||
minfo.flavor,
|
||||
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM);
|
||||
} else if (wuffs_base__more_information__metadata__fourcc(&minfo) !=
|
||||
WUFFS_BASE__FOURCC__ICCP) {
|
||||
RETURN_FAIL("tell_me_more: fourcc: have %" PRIX32 ", want %" PRIX32,
|
||||
wuffs_base__more_information__metadata__fourcc(&minfo),
|
||||
WUFFS_BASE__FOURCC__ICCP);
|
||||
}
|
||||
CHECK_STRING(check_io_buffers_equal("", &have, &want));
|
||||
seen_iccp = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!seen_iccp) {
|
||||
RETURN_FAIL("seen_iccp: have %d, want %d", seen_iccp, true);
|
||||
}
|
||||
|
||||
{
|
||||
// 423 = 0x1A7 is just before the "????IDAT" bytes.
|
||||
uint64_t have = wuffs_base__image_config__first_frame_io_position(&ic);
|
||||
uint64_t want = 423;
|
||||
if (have != want) {
|
||||
RETURN_FAIL("first_frame_io_position: have %" PRIu64 ", want %" PRIu64,
|
||||
have, want);
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
|
||||
wuffs_base__status status =
|
||||
wuffs_png__decoder__decode_frame_config(&dec, &fc, &src);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("decode_frame_config: %s", status.repr);
|
||||
}
|
||||
uint32_t have = wuffs_base__frame_config__width(&fc);
|
||||
uint32_t want = 256;
|
||||
if (have != want) {
|
||||
RETURN_FAIL("decode_frame_config: width: have %" PRIu32 ", want %" PRIu32,
|
||||
have, want);
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_png_decode_metadata_kvp() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/artificial-png/key-value-pairs.png"));
|
||||
|
||||
const char* wants[] = {
|
||||
"Key", //
|
||||
"English", //
|
||||
"Clé", //
|
||||
"Français", //
|
||||
"zlïbK", //
|
||||
"zlïbV", //
|
||||
"U-Key", //
|
||||
"U-значение", //
|
||||
"Z-Këy", //
|
||||
"Z-значение", //
|
||||
};
|
||||
|
||||
wuffs_png__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_png__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
wuffs_png__decoder__set_report_metadata(&dec, WUFFS_BASE__FOURCC__KVP, true);
|
||||
|
||||
wuffs_base__image_config ic = ((wuffs_base__image_config){});
|
||||
wuffs_base__more_information minfo = wuffs_base__empty_more_information();
|
||||
|
||||
size_t i = 0;
|
||||
for (;; i++) {
|
||||
wuffs_base__status status =
|
||||
wuffs_png__decoder__decode_image_config(&dec, &ic, &src);
|
||||
if (wuffs_base__status__is_ok(&status)) {
|
||||
break;
|
||||
} else if (status.repr != wuffs_base__note__metadata_reported) {
|
||||
RETURN_FAIL("decode_image_config i=%zu: %s", i, status.repr);
|
||||
}
|
||||
|
||||
wuffs_base__io_buffer have = ((wuffs_base__io_buffer){
|
||||
.data = g_have_slice_u8,
|
||||
});
|
||||
status = wuffs_png__decoder__tell_me_more(&dec, &have, &minfo, &src);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("tell_me_more i=%zu: \"%s\"", i, status.repr);
|
||||
} else if (minfo.flavor !=
|
||||
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM) {
|
||||
RETURN_FAIL("tell_me_more i=%zu: flavor: have %" PRIu32 ", want %" PRIu32,
|
||||
i, minfo.flavor,
|
||||
WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_TRANSFORM);
|
||||
}
|
||||
|
||||
uint32_t have_fourcc =
|
||||
wuffs_base__more_information__metadata__fourcc(&minfo);
|
||||
uint32_t want_fourcc =
|
||||
(i & 1) ? WUFFS_BASE__FOURCC__KVPV : WUFFS_BASE__FOURCC__KVPK;
|
||||
if (have_fourcc != want_fourcc) {
|
||||
RETURN_FAIL("tell_me_more i=%zu: fourcc: have %" PRIX32 ", want %" PRIX32,
|
||||
i, have_fourcc, want_fourcc);
|
||||
}
|
||||
|
||||
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
|
||||
.data = g_want_slice_u8,
|
||||
});
|
||||
if (i < WUFFS_TESTLIB_ARRAY_SIZE(wants)) {
|
||||
size_t n = strlen(wants[i]);
|
||||
if (n <= want.data.len) {
|
||||
memcpy(want.data.ptr, wants[i], n);
|
||||
want.meta.wi = n;
|
||||
}
|
||||
}
|
||||
CHECK_STRING(check_io_buffers_equal("", &have, &want));
|
||||
}
|
||||
|
||||
if (i != WUFFS_TESTLIB_ARRAY_SIZE(wants)) {
|
||||
RETURN_FAIL("i: have %zu, want %zu", i, WUFFS_TESTLIB_ARRAY_SIZE(wants));
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_png_decode_restart_frame() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/pjw-thumbnail.png"));
|
||||
|
||||
wuffs_png__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_png__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
|
||||
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, "test/data/hibiscus.regular.png"));
|
||||
CHECK_STATUS("decode_frame_config #0",
|
||||
wuffs_png__decoder__decode_frame_config(&dec, &fc, &src));
|
||||
|
||||
wuffs_base__status status =
|
||||
wuffs_png__decoder__decode_frame_config(&dec, &fc, &src);
|
||||
if (status.repr != wuffs_base__note__end_of_data) {
|
||||
RETURN_FAIL("decode_frame_config #1: have \"%s\", want \"%s\"", status.repr,
|
||||
wuffs_base__note__end_of_data);
|
||||
wuffs_base__image_config ic = ((wuffs_base__image_config){});
|
||||
CHECK_STATUS("decode_image_config",
|
||||
wuffs_png__decoder__decode_image_config(&dec, &ic, &src));
|
||||
// 51 = 0x33 is just before the "????IDAT" bytes.
|
||||
uint64_t ffio = wuffs_base__image_config__first_frame_io_position(&ic);
|
||||
if (ffio != 51) {
|
||||
RETURN_FAIL("first_frame_io_position: have %" PRIu64 ", want 51", ffio);
|
||||
}
|
||||
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
CHECK_STATUS("set_from_slice", wuffs_base__pixel_buffer__set_from_slice(
|
||||
&pb, &ic.pixcfg, g_pixel_slice_u8));
|
||||
|
||||
for (int i = 0; i < 2; i++) {
|
||||
if (i > 0) {
|
||||
CHECK_STATUS("restart_frame",
|
||||
wuffs_png__decoder__restart_frame(&dec, 0, 51));
|
||||
if (51 <= src.meta.wi) {
|
||||
src.meta.ri = 51;
|
||||
}
|
||||
}
|
||||
|
||||
uint64_t rpos = wuffs_base__io_buffer__reader_position(&src);
|
||||
if (rpos != 51) {
|
||||
RETURN_FAIL("reader_position (before) #%d: have %" PRIu64 ", want 51", i,
|
||||
rpos);
|
||||
}
|
||||
|
||||
wuffs_base__status status = wuffs_png__decoder__decode_frame(
|
||||
&dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC, g_work_slice_u8, NULL);
|
||||
if (!wuffs_base__status__is_ok(&status)) {
|
||||
RETURN_FAIL("decode_frame #%d: %s", i, status.repr);
|
||||
}
|
||||
|
||||
// 196 = 0xC4 is just before the "????IEND" bytes.
|
||||
rpos = wuffs_base__io_buffer__reader_position(&src);
|
||||
if (rpos != 196) {
|
||||
RETURN_FAIL("reader_position (after) #%d: have %" PRIu64 ", want 196", i,
|
||||
rpos);
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -564,10 +1024,6 @@ test_mimic_png_decode_bad_crc32_checksum_critical() {
|
||||
const char* //
|
||||
bench_wuffs_png_decode_image_19k_8bpp() {
|
||||
CHECK_FOCUS(__func__);
|
||||
// libpng automatically applies the "gAMA" chunk (with no matching "sRGB"
|
||||
// chunk) but Wuffs does not. To make the comparison more like-for-like,
|
||||
// especially in emitting identical BGRA pixels, patch the source file by
|
||||
// replacing the "gAMA" with the nonsense "hAMA". ASCII 'g' is 0x67.
|
||||
return do_bench_image_decode(
|
||||
&wuffs_png_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__Y), NULL, 0,
|
||||
@@ -635,8 +1091,7 @@ do_bench_wuffs_png_decode_filter(uint8_t filter,
|
||||
return "source data is too short";
|
||||
}
|
||||
|
||||
uint32_t y;
|
||||
for (y = 0; y < height; y++) {
|
||||
for (uint32_t y = 0; y < height; y++) {
|
||||
workbuf.data.ptr[(1 + bytes_per_row) * y] = filter;
|
||||
}
|
||||
|
||||
@@ -651,6 +1106,10 @@ do_bench_wuffs_png_decode_filter(uint8_t filter,
|
||||
CHECK_STATUS("initialize", wuffs_png__decoder__initialize(
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__DEFAULT_OPTIONS));
|
||||
dec.private_impl.f_frame_rect_x0 = 0;
|
||||
dec.private_impl.f_frame_rect_y0 = 0;
|
||||
dec.private_impl.f_frame_rect_x1 = width;
|
||||
dec.private_impl.f_frame_rect_y1 = height;
|
||||
dec.private_impl.f_width = width;
|
||||
dec.private_impl.f_height = height;
|
||||
dec.private_impl.f_pass_bytes_per_row = bytes_per_row;
|
||||
@@ -676,9 +1135,8 @@ do_bench_wuffs_png_decode_filter(uint8_t filter,
|
||||
|
||||
bench_start();
|
||||
uint64_t n_bytes = 0;
|
||||
uint64_t i;
|
||||
uint64_t iters = iters_unscaled * g_flags.iterscale;
|
||||
for (i = 0; i < iters; i++) {
|
||||
for (uint64_t i = 0; i < iters; i++) {
|
||||
CHECK_STATUS(
|
||||
"filter_and_swizzle",
|
||||
wuffs_png__decoder__filter_and_swizzle(
|
||||
@@ -744,10 +1202,6 @@ bench_wuffs_png_decode_filt_4_dist_4() {
|
||||
const char* //
|
||||
bench_mimic_png_decode_image_19k_8bpp() {
|
||||
CHECK_FOCUS(__func__);
|
||||
// libpng automatically applies the "gAMA" chunk (with no matching "sRGB"
|
||||
// chunk) but Wuffs does not. To make the comparison more like-for-like,
|
||||
// especially in emitting identical BGRA pixels, patch the source file by
|
||||
// replacing the "gAMA" with the nonsense "hAMA". ASCII 'g' is 0x67.
|
||||
return do_bench_image_decode(
|
||||
&mimic_png_decode, WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED,
|
||||
wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__Y), NULL, 0,
|
||||
@@ -811,6 +1265,11 @@ proc g_tests[] = {
|
||||
test_wuffs_png_decode_filters_round_trip,
|
||||
test_wuffs_png_decode_frame_config,
|
||||
test_wuffs_png_decode_interface,
|
||||
test_wuffs_png_decode_metadata_chrm_gama_srgb,
|
||||
test_wuffs_png_decode_metadata_exif,
|
||||
test_wuffs_png_decode_metadata_iccp,
|
||||
test_wuffs_png_decode_metadata_kvp,
|
||||
test_wuffs_png_decode_restart_frame,
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
|
||||
@@ -75,8 +75,7 @@ fill_palette_with_grays(wuffs_base__pixel_buffer* pb) {
|
||||
if (palette.len != 1024) {
|
||||
return;
|
||||
}
|
||||
int i;
|
||||
for (i = 0; i < 256; i++) {
|
||||
for (int i = 0; i < 256; i++) {
|
||||
palette.ptr[(4 * i) + 0] = i;
|
||||
palette.ptr[(4 * i) + 1] = i;
|
||||
palette.ptr[(4 * i) + 2] = i;
|
||||
@@ -90,8 +89,7 @@ fill_palette_with_nrgba_transparent_yellows(wuffs_base__pixel_buffer* pb) {
|
||||
if (palette.len != 1024) {
|
||||
return;
|
||||
}
|
||||
int i;
|
||||
for (i = 0; i < 256; i++) {
|
||||
for (int i = 0; i < 256; i++) {
|
||||
palette.ptr[(4 * i) + 0] = 0x00;
|
||||
palette.ptr[(4 * i) + 1] = 0x99;
|
||||
palette.ptr[(4 * i) + 2] = 0xCC;
|
||||
@@ -161,8 +159,7 @@ test_wuffs_pixel_buffer_fill_rect() {
|
||||
},
|
||||
};
|
||||
|
||||
int d;
|
||||
for (d = 0; d < WUFFS_TESTLIB_ARRAY_SIZE(dsts); d++) {
|
||||
for (size_t d = 0; d < WUFFS_TESTLIB_ARRAY_SIZE(dsts); d++) {
|
||||
// Allocate the dst_pixbuf.
|
||||
wuffs_base__pixel_config dst_pixcfg = ((wuffs_base__pixel_config){});
|
||||
wuffs_base__pixel_config__set(&dst_pixcfg, dsts[d].pixfmt_repr,
|
||||
@@ -173,13 +170,10 @@ test_wuffs_pixel_buffer_fill_rect() {
|
||||
wuffs_base__pixel_buffer__set_from_slice(
|
||||
&dst_pixbuf, &dst_pixcfg, g_have_slice_u8));
|
||||
|
||||
int orientation;
|
||||
for (orientation = 0; orientation < 2; orientation++) {
|
||||
for (int orientation = 0; orientation < 2; orientation++) {
|
||||
// Reset to transparent black (or its closest approximation).
|
||||
uint32_t y;
|
||||
for (y = 0; y < height; y++) {
|
||||
uint32_t x;
|
||||
for (x = 0; x < width; x++) {
|
||||
for (uint32_t y = 0; y < height; y++) {
|
||||
for (uint32_t x = 0; x < width; x++) {
|
||||
CHECK_STATUS(
|
||||
"set_color_u32_at",
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(&dst_pixbuf, x, y, 0));
|
||||
@@ -204,7 +198,7 @@ test_wuffs_pixel_buffer_fill_rect() {
|
||||
wuffs_base__pixel_buffer__color_u32_at(&dst_pixbuf, width / 2,
|
||||
height / 2);
|
||||
if (colors_differ(have_dst_pixel, want_dst_pixel, 0)) {
|
||||
RETURN_FAIL("d=%d, orientation=%d: dst_pixel: have 0x%08" PRIX32
|
||||
RETURN_FAIL("d=%zu, orientation=%d: dst_pixel: have 0x%08" PRIX32
|
||||
", want 0x%08" PRIX32,
|
||||
d, orientation, have_dst_pixel, want_dst_pixel);
|
||||
}
|
||||
@@ -324,8 +318,7 @@ test_wuffs_pixel_swizzler_swizzle() {
|
||||
WUFFS_BASE__PIXEL_BLEND__SRC_OVER,
|
||||
};
|
||||
|
||||
int s;
|
||||
for (s = 0; s < WUFFS_TESTLIB_ARRAY_SIZE(srcs); s++) {
|
||||
for (size_t s = 0; s < WUFFS_TESTLIB_ARRAY_SIZE(srcs); s++) {
|
||||
// Allocate the src_pixbuf.
|
||||
wuffs_base__pixel_config src_pixcfg = ((wuffs_base__pixel_config){});
|
||||
wuffs_base__pixel_config__set(&src_pixcfg, srcs[s].pixfmt_repr,
|
||||
@@ -350,12 +343,11 @@ test_wuffs_pixel_swizzler_swizzle() {
|
||||
wuffs_base__pixel_buffer__color_u32_at(&src_pixbuf, width / 2,
|
||||
height / 2);
|
||||
if (have_src_pixel != srcs[s].color) {
|
||||
RETURN_FAIL("s=%d: src_pixel: have 0x%08" PRIX32 ", want 0x%08" PRIX32, s,
|
||||
have_src_pixel, srcs[s].color);
|
||||
RETURN_FAIL("s=%zu: src_pixel: have 0x%08" PRIX32 ", want 0x%08" PRIX32,
|
||||
s, have_src_pixel, srcs[s].color);
|
||||
}
|
||||
|
||||
int d;
|
||||
for (d = 0; d < WUFFS_TESTLIB_ARRAY_SIZE(dsts); d++) {
|
||||
for (size_t d = 0; d < WUFFS_TESTLIB_ARRAY_SIZE(dsts); d++) {
|
||||
// Allocate the dst_pixbuf.
|
||||
wuffs_base__pixel_config dst_pixcfg = ((wuffs_base__pixel_config){});
|
||||
wuffs_base__pixel_config__set(&dst_pixcfg, dsts[d].pixfmt_repr,
|
||||
@@ -378,8 +370,7 @@ test_wuffs_pixel_swizzler_swizzle() {
|
||||
WUFFS_TESTLIB_ARRAY_SIZE(fallback_palette_array));
|
||||
}
|
||||
|
||||
int b;
|
||||
for (b = 0; b < WUFFS_TESTLIB_ARRAY_SIZE(blends); b++) {
|
||||
for (size_t b = 0; b < WUFFS_TESTLIB_ARRAY_SIZE(blends); b++) {
|
||||
// Set the middle dst pixel.
|
||||
CHECK_STATUS("set_color_u32_at",
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
@@ -394,10 +385,10 @@ test_wuffs_pixel_swizzler_swizzle() {
|
||||
wuffs_base__pixel_buffer__palette(&src_pixbuf), blends[b]));
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(
|
||||
&swizzler,
|
||||
wuffs_base__table_u8__row(
|
||||
wuffs_base__table_u8__row_u32(
|
||||
wuffs_base__pixel_buffer__plane(&dst_pixbuf, 0), height / 2),
|
||||
dst_palette,
|
||||
wuffs_base__table_u8__row(
|
||||
wuffs_base__table_u8__row_u32(
|
||||
wuffs_base__pixel_buffer__plane(&src_pixbuf, 0), height / 2));
|
||||
|
||||
// Check the middle dst pixel.
|
||||
@@ -420,7 +411,7 @@ test_wuffs_pixel_swizzler_swizzle() {
|
||||
wuffs_base__pixel_buffer__color_u32_at(&dst_pixbuf, width / 2,
|
||||
height / 2);
|
||||
if (colors_differ(have_dst_pixel, want_dst_pixel, tolerance)) {
|
||||
RETURN_FAIL("s=%d, d=%d, b=%d: dst_pixel: have 0x%08" PRIX32
|
||||
RETURN_FAIL("s=%zu, d=%zu, b=%zu: dst_pixel: have 0x%08" PRIX32
|
||||
", want 0x%08" PRIX32 ", per-channel tolerance=%" PRId32,
|
||||
s, d, b, have_dst_pixel, want_dst_pixel, tolerance);
|
||||
}
|
||||
@@ -559,11 +550,9 @@ do_bench_wuffs_pixel_swizzler(uint32_t dst_pixfmt_repr,
|
||||
|
||||
bench_start();
|
||||
uint64_t n_bytes = 0;
|
||||
uint64_t i;
|
||||
uint64_t iters = iters_unscaled * g_flags.iterscale;
|
||||
for (i = 0; i < iters; i++) {
|
||||
uint32_t y;
|
||||
for (y = 0; y < height; y++) {
|
||||
for (uint64_t i = 0; i < iters; i++) {
|
||||
for (uint32_t y = 0; y < height; y++) {
|
||||
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(
|
||||
&swizzler,
|
||||
wuffs_base__make_slice_u8(
|
||||
|
||||
@@ -71,6 +71,11 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
|
||||
// ---------------- Golden Tests
|
||||
|
||||
golden_test g_deflate_romeo_gt = {
|
||||
.want_filename = "test/data/romeo.txt",
|
||||
.src_filename = "test/data/romeo.txt.deflate",
|
||||
};
|
||||
|
||||
golden_test g_zlib_midsummer_gt = {
|
||||
.want_filename = "test/data/midsummer.txt",
|
||||
.src_filename = "test/data/midsummer.txt.zlib",
|
||||
@@ -107,6 +112,42 @@ test_wuffs_zlib_decode_interface() {
|
||||
"test/data/romeo.txt.zlib", 0, SIZE_MAX, 942, 0x0A);
|
||||
}
|
||||
|
||||
const char* //
|
||||
wuffs_raw_deflate_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
wuffs_zlib__decoder dec;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_zlib__decoder__initialize(&dec, sizeof dec, WUFFS_VERSION,
|
||||
wuffs_initialize_flags));
|
||||
|
||||
// This wuffs_zlib__decoder__set_quirk_enabled call is the only difference
|
||||
// between wuffs_raw_deflate_decode and wuffs_zlib_decode immediately below.
|
||||
wuffs_zlib__decoder__set_quirk_enabled(
|
||||
&dec, WUFFS_ZLIB__QUIRK_JUST_RAW_DEFLATE, true);
|
||||
|
||||
while (true) {
|
||||
wuffs_base__io_buffer limited_dst = make_limited_writer(*dst, wlimit);
|
||||
wuffs_base__io_buffer limited_src = make_limited_reader(*src, rlimit);
|
||||
|
||||
wuffs_base__status status = wuffs_zlib__decoder__transform_io(
|
||||
&dec, &limited_dst, &limited_src, g_work_slice_u8);
|
||||
|
||||
dst->meta.wi += limited_dst.meta.wi;
|
||||
src->meta.ri += limited_src.meta.ri;
|
||||
|
||||
if (((wlimit < UINT64_MAX) &&
|
||||
(status.repr == wuffs_base__suspension__short_write)) ||
|
||||
((rlimit < UINT64_MAX) &&
|
||||
(status.repr == wuffs_base__suspension__short_read))) {
|
||||
continue;
|
||||
}
|
||||
return status.repr;
|
||||
}
|
||||
}
|
||||
|
||||
const char* //
|
||||
wuffs_zlib_decode(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
@@ -170,8 +211,7 @@ do_test_wuffs_zlib_checksum(bool ignore_checksum, uint32_t bad_checksum) {
|
||||
|
||||
// Decode the src data in 1 or 2 chunks, depending on whether end_limit is
|
||||
// or isn't zero.
|
||||
int i;
|
||||
for (i = 0; i < 2; i++) {
|
||||
for (int i = 0; i < 2; i++) {
|
||||
uint64_t rlimit = UINT64_MAX;
|
||||
const char* want_z = NULL;
|
||||
if (i == 0) {
|
||||
@@ -241,6 +281,13 @@ test_wuffs_zlib_decode_pi() {
|
||||
UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_zlib_decode_raw_deflate_romeo() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_io_buffers(wuffs_raw_deflate_decode, &g_deflate_romeo_gt,
|
||||
UINT64_MAX, UINT64_MAX);
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_zlib_decode_sheep() {
|
||||
CHECK_FOCUS(__func__);
|
||||
@@ -255,8 +302,7 @@ test_wuffs_zlib_decode_sheep() {
|
||||
&dec, sizeof dec, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__DEFAULT_OPTIONS));
|
||||
|
||||
int i;
|
||||
for (i = 0; i < 3; i++) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
wuffs_base__status status =
|
||||
wuffs_zlib__decoder__transform_io(&dec, &have, &src, g_work_slice_u8);
|
||||
|
||||
@@ -378,6 +424,7 @@ proc g_tests[] = {
|
||||
test_wuffs_zlib_decode_interface,
|
||||
test_wuffs_zlib_decode_midsummer,
|
||||
test_wuffs_zlib_decode_pi,
|
||||
test_wuffs_zlib_decode_raw_deflate_romeo,
|
||||
test_wuffs_zlib_decode_sheep,
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
@@ -369,8 +369,7 @@ chdir_to_the_wuffs_root_directory() {
|
||||
// Chdir to the Wuffs root directory, assuming that we're starting from
|
||||
// somewhere in the Wuffs repository, so we can find the root directory by
|
||||
// running chdir("..") a number of times.
|
||||
int n;
|
||||
for (n = 0; n < 64; n++) {
|
||||
for (int n = 0; n < 64; n++) {
|
||||
if (access("wuffs-root-directory.txt", F_OK) == 0) {
|
||||
return NULL;
|
||||
}
|
||||
@@ -423,14 +422,12 @@ test_main(int argc, char** argv, proc* tests, proc* benches) {
|
||||
"compatible with the\n"
|
||||
"# https://godoc.org/golang.org/x/perf/cmd/benchstat tool. To install "
|
||||
"it, first\n"
|
||||
"# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n");
|
||||
"# install Go, then run \"go install golang.org/x/perf/cmd/benchstat\".\n");
|
||||
}
|
||||
|
||||
int i;
|
||||
for (i = 0; i < reps; i++) {
|
||||
for (int i = 0; i < reps; i++) {
|
||||
g_bench_warm_up = i == 0;
|
||||
proc* p;
|
||||
for (p = procs; *p; p++) {
|
||||
for (proc* p = procs; *p; p++) {
|
||||
g_proc_func_name = "unknown_func_name";
|
||||
g_fail_msg[0] = 0;
|
||||
g_in_focus = false;
|
||||
@@ -562,12 +559,10 @@ copy_to_io_buffer_from_pixel_buffer(wuffs_base__io_buffer* dst,
|
||||
}
|
||||
size_t bytes_per_pixel = bits_per_pixel / 8;
|
||||
|
||||
uint32_t p;
|
||||
for (p = 0; p < 1; p++) {
|
||||
for (uint32_t p = 0; p < 1; p++) {
|
||||
wuffs_base__table_u8 tab = wuffs_base__pixel_buffer__plane(src, p);
|
||||
uint32_t y;
|
||||
for (y = r.min_incl_y; y < r.max_excl_y; y++) {
|
||||
wuffs_base__slice_u8 row = wuffs_base__table_u8__row(tab, y);
|
||||
for (uint32_t y = r.min_incl_y; y < r.max_excl_y; y++) {
|
||||
wuffs_base__slice_u8 row = wuffs_base__table_u8__row_u32(tab, y);
|
||||
if ((r.min_incl_x >= r.max_excl_x) ||
|
||||
(r.max_excl_x > (row.len / bytes_per_pixel))) {
|
||||
break;
|
||||
@@ -748,8 +743,7 @@ hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
|
||||
return msg;
|
||||
}
|
||||
size_t base = i - (i & 15);
|
||||
int j;
|
||||
for (j = -3 * 16; j <= +3 * 16; j += 16) {
|
||||
for (int j = -3 * 16; j <= +3 * 16; j += 16) {
|
||||
if ((j < 0) && (base < (size_t)(-j))) {
|
||||
continue;
|
||||
}
|
||||
@@ -759,8 +753,7 @@ hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
|
||||
}
|
||||
size_t n = buf->meta.wi - b;
|
||||
INCR_FAIL(msg, " %06zx:", b);
|
||||
size_t k;
|
||||
for (k = 0; k < 16; k++) {
|
||||
for (size_t k = 0; k < 16; k++) {
|
||||
if (k % 2 == 0) {
|
||||
INCR_FAIL(msg, " ");
|
||||
}
|
||||
@@ -771,7 +764,7 @@ hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
|
||||
}
|
||||
}
|
||||
INCR_FAIL(msg, " ");
|
||||
for (k = 0; k < 16; k++) {
|
||||
for (size_t k = 0; k < 16; k++) {
|
||||
char c = ' ';
|
||||
if (k < n) {
|
||||
c = buf->data.ptr[b + k];
|
||||
@@ -797,12 +790,10 @@ check_io_buffers_equal(const char* prefix,
|
||||
RETURN_FAIL("%sio_buffers_equal: NULL argument", prefix);
|
||||
}
|
||||
char* msg = g_fail_msg;
|
||||
size_t i;
|
||||
size_t i = 0;
|
||||
size_t n = have->meta.wi < want->meta.wi ? have->meta.wi : want->meta.wi;
|
||||
for (i = 0; i < n; i++) {
|
||||
if (have->data.ptr[i] != want->data.ptr[i]) {
|
||||
break;
|
||||
}
|
||||
while ((i < n) && (have->data.ptr[i] == want->data.ptr[i])) {
|
||||
i++;
|
||||
}
|
||||
if (have->meta.wi != want->meta.wi) {
|
||||
INCR_FAIL(msg, "%sio_buffers_equal: wi: have %zu, want %zu.\n", prefix,
|
||||
@@ -893,8 +884,7 @@ proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
|
||||
bench_start();
|
||||
}
|
||||
uint64_t n_bytes = 0;
|
||||
uint64_t i;
|
||||
for (i = 0; i < iters; i++) {
|
||||
for (uint64_t i = 0; i < iters; i++) {
|
||||
have.meta.wi = 0;
|
||||
src.meta.ri = gt->src_offset0;
|
||||
const char* status =
|
||||
@@ -979,8 +969,7 @@ proc_token_decoder(const char* (*codec_func)(wuffs_base__token_buffer*,
|
||||
bench_start();
|
||||
}
|
||||
uint64_t n_bytes = 0;
|
||||
uint64_t i;
|
||||
for (i = 0; i < iters; i++) {
|
||||
for (uint64_t i = 0; i < iters; i++) {
|
||||
have.meta.wi = 0;
|
||||
src.meta.ri = gt->src_offset0;
|
||||
const char* status =
|
||||
@@ -1067,8 +1056,7 @@ do_run__wuffs_base__image_decoder(wuffs_base__image_decoder* b,
|
||||
wuffs_base__frame_config fc = ((wuffs_base__frame_config){});
|
||||
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
|
||||
|
||||
size_t i;
|
||||
for (i = 0; i < quirks_len; i++) {
|
||||
for (size_t i = 0; i < quirks_len; i++) {
|
||||
wuffs_base__image_decoder__set_quirk_enabled(b, quirks_ptr[i], true);
|
||||
}
|
||||
|
||||
@@ -1145,9 +1133,8 @@ do_bench_image_decode(
|
||||
|
||||
bench_start();
|
||||
uint64_t n_bytes = 0;
|
||||
uint64_t i;
|
||||
uint64_t iters = iters_unscaled * g_flags.iterscale;
|
||||
for (i = 0; i < iters; i++) {
|
||||
for (uint64_t i = 0; i < iters; i++) {
|
||||
src.meta.ri = src_ri;
|
||||
CHECK_STRING((*decode_func)(&n_bytes, NULL, wuffs_initialize_flags, pixfmt,
|
||||
quirks_ptr, quirks_len, &src));
|
||||
|
||||
@@ -6,21 +6,28 @@ files were generated by `script/extract-palette-indexes.go`. The `*.tokens`
|
||||
files were generated by `script/print-json-token-debug-format.c`.
|
||||
|
||||
The `*.jpeg` files are usually the canonical versions of the test/data images,
|
||||
and other versions (`*.bmp`, `*.gif`, `*.png`, `*.tiff`) were generated by
|
||||
and other versions (`*.bmp`, `*.gif`, `*.png` etc) were usually generated by
|
||||
ImageMagick's `convert` command line tool. The `*.wbmp` versions were generated
|
||||
by the `script/convert-png-to-wbmp.go` command line tool. The `*.webp` versions
|
||||
were generated by the cwebp command line tool.
|
||||
were generated by the cwebp command line tool. The `*.no-ancillary.png` files
|
||||
were generated by the `script/strip-png-ancillary-chunks.go` command line tool.
|
||||
The `*.qoi` files were generated by the qoiconv command line tool.
|
||||
|
||||
The `*.apng` files were generated by `gif2apng`. Those with finite animation
|
||||
loop counts were manually patched to correct for a `gif2apng` bug.
|
||||
https://bugs.chromium.org/p/chromium/issues/detail?id=592735 argues that GIF
|
||||
and APNG/WEBP have different semantics but `gif2apng` does not cater for that.
|
||||
|
||||
---
|
||||
|
||||
The artificial directory holds artificially generated test data, often to
|
||||
The `artificial-*` directories hold artificially generated test data, often to
|
||||
explicitly test corner cases of various file formats. The files there usually
|
||||
come in families whose names have a common prefix, such as three files
|
||||
`foo.bar`, `foo.bar.qux`, `foo.bar.commentary.txt` all prefixed by `foo.bar`.
|
||||
The file whose name is that prefix is usually the canonical (typically
|
||||
hand-crafted) file, and the other files are then derived from that. Outside of
|
||||
the artificial directory, the other files in this directory are typically real
|
||||
world examples of various file formats, or deriviations of them.
|
||||
the `artificial-*` directories, the other files in this directory are typically
|
||||
real world examples of various file formats, or deriviations of them.
|
||||
|
||||
---
|
||||
|
||||
@@ -28,10 +35,17 @@ The non-ascii directory holds trivial UTF-8 (but not ASCII) text files.
|
||||
|
||||
---
|
||||
|
||||
`DCI-P3-D65.icc` comes from
|
||||
[color.org](https://www.color.org/chardata/rgb/DCIP3.xalter).
|
||||
`DCI-P3-D65.icc.zlib` is a zlib-compresion of that, created by Go's standard
|
||||
library.
|
||||
|
||||
`archive.*` archives a subset of other files in this directory.
|
||||
|
||||
`animated-red-blue.gif` is an original animation by Nigel Tao
|
||||
<nigeltao@golang.org>.
|
||||
<nigeltao@golang.org>. `animated-red-blue.nia` and `animated-red-blue.*.nie`
|
||||
were then generated by `example/convert-to-nia` and
|
||||
`script/extract-nia-frames.go`.
|
||||
|
||||
`australian-abc-local-stations.json` was crawled from
|
||||
[data.gov.au](http://data.gov.au/geoserver/abc-local-stations/wfs?request=GetFeature&typeName=ckan_d534c0e9_a9bf_487b_ac8f_b7877a09d162&outputFormat=json).
|
||||
@@ -43,6 +57,8 @@ The non-ascii directory holds trivial UTF-8 (but not ASCII) text files.
|
||||
`cbor-rfc-7049-examples.*.json` files were then generated by
|
||||
`example/cbor-to-json`.
|
||||
|
||||
`checkerboard.*.png` was generated by `script/make-red-blue-gradient.go`.
|
||||
|
||||
`crude-flag.*` is an original animation by Nigel Tao
|
||||
<nigeltao@golang.org>. See the `lib/nie` documentation.
|
||||
|
||||
@@ -109,6 +125,8 @@ which is in the public domain.
|
||||
`pjw-thumbnail.*` are various encodings of an image derived from an iconic,
|
||||
original photo of Peter J. Weinberger by Rob Pike <r@golang.org>.
|
||||
|
||||
`red-blue-gradient.*.png` was generated by `script/make-red-blue-gradient.go`.
|
||||
|
||||
`rfc-6901-json-pointer.json` is the example JSON document given in the [RFC
|
||||
6901 "JavaScript Object Notation (JSON)
|
||||
Pointer"](https://tools.ietf.org/rfc/rfc6901.txt) specification.
|
||||
|
||||
|
After Width: | Height: | Size: 2.0 KiB |
@@ -1,5 +1,5 @@
|
||||
Running deflate-backref-crosses-blocks.deflate through script/print-bits.go and
|
||||
adding commentary:
|
||||
Running backref-crosses-blocks.deflate through script/print-bits.go and adding
|
||||
commentary:
|
||||
|
||||
offset xoffset ASCII hex binary
|
||||
000000 0x0000 . 0x00 0b_...._.000 Uncompressed block, non-final
|
||||
@@ -1,9 +1,9 @@
|
||||
Running deflate-degenerate-huffman-unused.deflate through script/print-bits.go
|
||||
and adding commentary:
|
||||
Running degenerate-huffman.deflate through script/print-bits.go and adding
|
||||
commentary:
|
||||
|
||||
offset xoffset ASCII hex binary
|
||||
000000 0x0000 . 0x05 0b_...._.101 Dynamic Huffman block, final
|
||||
000000 0x0000 . 0x05 0b_0000_0... NumLCodes: 257
|
||||
000000 0x0000 . 0x04 0b_...._.100 Dynamic Huffman block, non-final
|
||||
000000 0x0000 . 0x04 0b_0000_0... NumLCodes: 257
|
||||
000001 0x0001 . 0xC0 0b_...0_0000 NumDCodes: 1
|
||||
000001 0x0001 . 0xC0 0b_110._.... NumCLCodeLengths: 18
|
||||
000002 0x0002 ! 0x21 0b_...._...1
|
||||
@@ -63,4 +63,7 @@ Apply H-L and H-D.
|
||||
000013 0x000D . 0x89 0b_..0._.... lcode: 111 literal 'o'
|
||||
000013 0x000D . 0x89 0b_.0.._.... lcode: 111 literal 'o'
|
||||
000013 0x000D . 0x89 0b_1..._.... lcode: 256 end of block
|
||||
000014 0x000E . 0x01 0b_...._...1
|
||||
000014 0x000E . 0x1B 0b_...._...1
|
||||
|
||||
The second Dynamic Huffman block (the final one) continues after that, but this
|
||||
commentary stops here.
|
||||
@@ -0,0 +1 @@
|
||||
fooABCDABC
|
||||
@@ -0,0 +1,64 @@
|
||||
# Feed this file to script/make-artificial.go
|
||||
|
||||
make deflate
|
||||
|
||||
blockDynamicHuffman (nonFinal) {
|
||||
huffman CodeLength {
|
||||
1 00
|
||||
2 01
|
||||
17 10
|
||||
18 11
|
||||
}
|
||||
|
||||
huffman Literal/Length {
|
||||
# 102='f', 111='o', 256=EOB
|
||||
111 0
|
||||
102 10
|
||||
256 11
|
||||
}
|
||||
|
||||
huffman Distance {
|
||||
# Incomplete. There is no key/value pair whose value starts with "1".
|
||||
#
|
||||
# The sole key/value pair is also unused. (The one below is used.)
|
||||
0 0
|
||||
}
|
||||
|
||||
literal "foo"
|
||||
endOfBlock
|
||||
}
|
||||
|
||||
blockDynamicHuffman (final) {
|
||||
huffman CodeLength {
|
||||
0 00
|
||||
1 01
|
||||
2 100
|
||||
3 101
|
||||
17 110
|
||||
18 111
|
||||
}
|
||||
|
||||
huffman Literal/Length {
|
||||
# 65='A', 66='B', 67='C', 68='D', 256=EOB, 257=Length3
|
||||
65 100
|
||||
66 101
|
||||
67 110
|
||||
68 111
|
||||
256 00
|
||||
257 01
|
||||
}
|
||||
|
||||
huffman Distance {
|
||||
# Incomplete. There is no key/value pair whose value starts with "1".
|
||||
#
|
||||
# The sole key/value pair is also used. (The one above is unused.)
|
||||
#
|
||||
# Per the second table in RFC 1951 section 3.2.5. "Compressed blocks
|
||||
# (length and distance codes)", code 3 means a distance of 4.
|
||||
3 0
|
||||
}
|
||||
|
||||
literal "ABCD"
|
||||
len 3 dist 4
|
||||
endOfBlock
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
Running deflate-distance-32768.deflate through script/print-bits.go and adding
|
||||
Running distance-32768.deflate through script/print-bits.go and adding
|
||||
commentary:
|
||||
|
||||
offset xoffset ASCII hex binary
|
||||
@@ -1,5 +1,5 @@
|
||||
Running deflate-distance-code-31.deflate through script/print-bits.go and
|
||||
adding commentary:
|
||||
Running distance-code-31.deflate through script/print-bits.go and adding
|
||||
commentary:
|
||||
|
||||
offset xoffset ASCII hex binary
|
||||
000000 0x0000 . 0x03 0b_...._.011 Fixed Huffman block, final
|
||||
@@ -1,5 +1,5 @@
|
||||
Running deflate-huffman-primlen-9.deflate through script/print-bits.go and
|
||||
adding commentary:
|
||||
Running huffman-primlen-9.deflate through script/print-bits.go and adding
|
||||
commentary:
|
||||
|
||||
offset xoffset ASCII hex binary
|
||||
000000 0x0000 . 0xED 0b_...._.101 Dynamic Huffman block, final
|
||||
|
Before Width: | Height: | Size: 90 B After Width: | Height: | Size: 90 B |
|
Before Width: | Height: | Size: 54 B After Width: | Height: | Size: 54 B |
|
Before Width: | Height: | Size: 132 B After Width: | Height: | Size: 132 B |
|
Before Width: | Height: | Size: 90 B After Width: | Height: | Size: 90 B |
|
Before Width: | Height: | Size: 110 B After Width: | Height: | Size: 110 B |
|
Before Width: | Height: | Size: 56 B After Width: | Height: | Size: 56 B |
|
Before Width: | Height: | Size: 139 B After Width: | Height: | Size: 139 B |
|
Before Width: | Height: | Size: 26 B After Width: | Height: | Size: 26 B |
|
Before Width: | Height: | Size: 40 B After Width: | Height: | Size: 40 B |
|
Before Width: | Height: | Size: 40 B After Width: | Height: | Size: 40 B |
|
After Width: | Height: | Size: 41 B |
@@ -0,0 +1,37 @@
|
||||
# Feed this file to script/make-artificial.go
|
||||
|
||||
make gif
|
||||
|
||||
header
|
||||
|
||||
image {
|
||||
imageWidthHeight 2 2
|
||||
palette {
|
||||
0x00 0x00 0xFF
|
||||
0x11 0x00 0xFF
|
||||
0x22 0x00 0xFF
|
||||
0x33 0x00 0xFF
|
||||
}
|
||||
}
|
||||
|
||||
frame {
|
||||
frameLeftTopWidthHeight 0 0 2 2
|
||||
}
|
||||
|
||||
# The frame area is 4 pixels and we supply 4 but then an invalid LZW code.
|
||||
# Compare with pixel-data-too-much-good-lzw.gif.make-artificial.txt
|
||||
#
|
||||
# The disassembly (see also std/lzw/README.md) is:
|
||||
#
|
||||
# 0x02 LZW literal width.
|
||||
# 0x02 GIF block length.
|
||||
# 0x84 0xF1 = 0b1111_0001_1000_0100 (little endian).
|
||||
# 0b...._...._...._.100 3-bit Clear code.
|
||||
# 0b...._...._..00_0... 3-bit Literal 0x00.
|
||||
# 0b...._...1_10.._.... 3-bit Copy code (2 bytes).
|
||||
# 0b...._000._...._.... 3-bit Literal 0x00.
|
||||
# 0b1111_...._...._.... 4-bit Invalid code.
|
||||
# 0x00 GIF block terminator.
|
||||
bytes 0x02 0x02 0x84 0xF1 0x00
|
||||
|
||||
trailer
|
||||
|
After Width: | Height: | Size: 41 B |
@@ -0,0 +1,37 @@
|
||||
# Feed this file to script/make-artificial.go
|
||||
|
||||
make gif
|
||||
|
||||
header
|
||||
|
||||
image {
|
||||
imageWidthHeight 2 2
|
||||
palette {
|
||||
0x00 0x00 0xFF
|
||||
0x11 0x00 0xFF
|
||||
0x22 0x00 0xFF
|
||||
0x33 0x00 0xFF
|
||||
}
|
||||
}
|
||||
|
||||
frame {
|
||||
frameLeftTopWidthHeight 0 0 2 2
|
||||
}
|
||||
|
||||
# The frame area is 4 pixels but we supply 5 (that's still valid LZW data).
|
||||
# Compare with pixel-data-too-much-bad-lzw.gif.make-artificial.txt
|
||||
#
|
||||
# The equivalent bytes' disassembly (see also std/lzw/README.md) is:
|
||||
#
|
||||
# 0x02 LZW literal width.
|
||||
# 0x02 GIF block length.
|
||||
# 0x84 0x5D = 0b0101_1101_1000_0100 (little endian).
|
||||
# 0b...._...._...._.100 3-bit Clear code.
|
||||
# 0b...._...._..00_0... 3-bit Literal 0x00.
|
||||
# 0b...._...1_10.._.... 3-bit Copy code (2 bytes).
|
||||
# 0b...._110._...._.... 3-bit Copy code (2 bytes).
|
||||
# 0b0101_...._...._.... 4-bit End code.
|
||||
# 0x00 GIF block terminator.
|
||||
lzw 2 0x00 0x00 0x00 0x00 0x00
|
||||
|
||||
trailer
|
||||
|
Before Width: | Height: | Size: 40 B After Width: | Height: | Size: 40 B |
|
Before Width: | Height: | Size: 165 B After Width: | Height: | Size: 165 B |
|
Before Width: | Height: | Size: 40 B After Width: | Height: | Size: 40 B |
|
After Width: | Height: | Size: 270 B |
@@ -0,0 +1,87 @@
|
||||
# Feed this file to script/make-artificial.go
|
||||
|
||||
# This APNG image has its first fcTL chunk after the IDAT chunks, so that the
|
||||
# IDAT data (the "default image") is not displayed. See
|
||||
# https://wiki.mozilla.org/APNG_Specification
|
||||
|
||||
make png
|
||||
|
||||
magic
|
||||
|
||||
IHDR {
|
||||
raw {
|
||||
# Width, height.
|
||||
0x00 0x00 0x00 0x03
|
||||
0x00 0x00 0x00 0x02
|
||||
# Depth, color, compression, filter, interlace.
|
||||
0x08 0x02 0x00 0x00 0x00
|
||||
}
|
||||
}
|
||||
|
||||
acTL {
|
||||
raw {
|
||||
# Frame count.
|
||||
0x00 0x00 0x00 0x02
|
||||
# Loop count.
|
||||
0x00 0x00 0x00 0x00
|
||||
}
|
||||
}
|
||||
|
||||
IDAT {
|
||||
zlib {
|
||||
# 3x2 RGB pixels (with filter bytes), shades of red.
|
||||
0x00 0x20 0x00 0x00 0x50 0x00 0x00 0x80 0x00 0x00
|
||||
0x00 0x40 0x00 0x00 0xA0 0x00 0x00 0xFF 0x00 0x00
|
||||
}
|
||||
}
|
||||
|
||||
fcTL {
|
||||
animSeqNum++
|
||||
raw {
|
||||
# Width, height, left, top.
|
||||
0x00 0x00 0x00 0x03
|
||||
0x00 0x00 0x00 0x02
|
||||
0x00 0x00 0x00 0x00
|
||||
0x00 0x00 0x00 0x00
|
||||
# Duration (1/1 second).
|
||||
0x00 0x01 0x00 0x01
|
||||
# Disposal, blend.
|
||||
0x00 0x00
|
||||
}
|
||||
}
|
||||
|
||||
fdAT {
|
||||
animSeqNum++
|
||||
zlib {
|
||||
# 3x2 RGB pixels (with filter bytes), shades of cyan.
|
||||
0x00 0x00 0x20 0x20 0x00 0x50 0x50 0x00 0x80 0x80
|
||||
0x00 0x00 0x40 0x40 0x00 0xA0 0xA0 0x00 0xFF 0xFF
|
||||
}
|
||||
}
|
||||
|
||||
fcTL {
|
||||
animSeqNum++
|
||||
raw {
|
||||
# Width, height, left, top.
|
||||
0x00 0x00 0x00 0x01
|
||||
0x00 0x00 0x00 0x02
|
||||
0x00 0x00 0x00 0x02
|
||||
0x00 0x00 0x00 0x00
|
||||
# Duration (1/1 second).
|
||||
0x00 0x01 0x00 0x01
|
||||
# Disposal, blend.
|
||||
0x00 0x00
|
||||
}
|
||||
}
|
||||
|
||||
fdAT {
|
||||
animSeqNum++
|
||||
zlib {
|
||||
# 1x2 RGB pixels (with filter bytes), shades of gray.
|
||||
0x00 0x80 0x80 0x80
|
||||
0x00 0xFF 0xFF 0xFF
|
||||
}
|
||||
}
|
||||
|
||||
IEND {
|
||||
}
|
||||
|
After Width: | Height: | Size: 93 B |
@@ -0,0 +1,32 @@
|
||||
# Feed this file to script/make-artificial.go
|
||||
|
||||
make png
|
||||
|
||||
magic
|
||||
|
||||
IHDR {
|
||||
raw {
|
||||
# Width, height.
|
||||
0x00 0x00 0x00 0x01
|
||||
0x00 0x00 0x00 0x01
|
||||
# Depth, color, compression, filter, interlace.
|
||||
0x08 0x00 0x00 0x00 0x00
|
||||
}
|
||||
}
|
||||
|
||||
eXIf {
|
||||
raw {
|
||||
# "LoremIpsum" isn't valid EXIF data. It's just a placeholder.
|
||||
0x4C 0x6F 0x72 0x65 0x6D 0x49 0x70 0x73 0x75 0x6D
|
||||
}
|
||||
}
|
||||
|
||||
IDAT {
|
||||
zlib {
|
||||
# 1x1 gray pixels (with filter bytes).
|
||||
0x00 0x80
|
||||
}
|
||||
}
|
||||
|
||||
IEND {
|
||||
}
|
||||
|
After Width: | Height: | Size: 272 B |
@@ -0,0 +1,99 @@
|
||||
# Feed this file to script/make-artificial.go
|
||||
|
||||
make png
|
||||
|
||||
magic
|
||||
|
||||
IHDR {
|
||||
raw {
|
||||
# Width, height.
|
||||
0x00 0x00 0x00 0x01
|
||||
0x00 0x00 0x00 0x01
|
||||
# Depth, color, compression, filter, interlace.
|
||||
0x08 0x00 0x00 0x00 0x00
|
||||
}
|
||||
}
|
||||
|
||||
# Basic key-value pair.
|
||||
tEXt {
|
||||
raw {
|
||||
# "Key\x00".
|
||||
0x4B 0x65 0x79 0x00
|
||||
# "English".
|
||||
0x45 0x6E 0x67 0x6C 0x69 0x73 0x68
|
||||
}
|
||||
}
|
||||
|
||||
# Latin-1 (not UTF-8) uncompressed key-value pair.
|
||||
tEXt {
|
||||
raw {
|
||||
# asLatin1("Clé\x00").
|
||||
0x43 0x6C 0xE9 0x00
|
||||
# asLatin1("Français").
|
||||
0x46 0x72 0x61 0x6E 0xE7 0x61 0x69 0x73
|
||||
}
|
||||
}
|
||||
|
||||
# Latin-1 (not UTF-8) zlib-compressed key-value pair.
|
||||
zTXt {
|
||||
raw {
|
||||
# asLatin1("zlïbK\x00").
|
||||
0x7A 0x6C 0xEF 0x62 0x4B 0x00
|
||||
# Compression method.
|
||||
0x00
|
||||
}
|
||||
zlib {
|
||||
# asLatin1("zlïbV").
|
||||
0x7A 0x6C 0xEF 0x62 0x56
|
||||
}
|
||||
}
|
||||
|
||||
# UTF-8 uncompressed key-value pair.
|
||||
iTXt {
|
||||
raw {
|
||||
# "U-Key\x00".
|
||||
0x55 0x2D 0x4B 0x65 0x79 0x00
|
||||
# Compression flag, compression method.
|
||||
0x00 0x00
|
||||
# Language tag: "ru\x00".
|
||||
0x72 0x75 0x00
|
||||
# Translated key: "U-ключ\x00".
|
||||
0x55 0x2D 0xD0 0xBA 0xD0 0xBB 0xD1 0x8E
|
||||
0xD1 0x87 0x00
|
||||
# "U-значение".
|
||||
0x55 0x2D 0xD0 0xB7 0xD0 0xBD 0xD0 0xB0
|
||||
0xD1 0x87 0xD0 0xB5 0xD0 0xBD 0xD0 0xB8
|
||||
0xD0 0xB5
|
||||
}
|
||||
}
|
||||
|
||||
# Latin-1 / UTF-8 zlib-compressed key-value pair.
|
||||
iTXt {
|
||||
raw {
|
||||
# asLatin1("Z-Këy\x00").
|
||||
0x5A 0x2D 0x4B 0xEB 0x79 0x00
|
||||
# Compression flag, compression method.
|
||||
0x01 0x00
|
||||
# Language tag: "ru\x00".
|
||||
0x72 0x75 0x00
|
||||
# Translated key: "Z-ключ\x00".
|
||||
0x5A 0x2D 0xD0 0xBA 0xD0 0xBB 0xD1 0x8E
|
||||
0xD1 0x87 0x00
|
||||
}
|
||||
zlib {
|
||||
# "Z-значение".
|
||||
0x5A 0x2D 0xD0 0xB7 0xD0 0xBD 0xD0 0xB0
|
||||
0xD1 0x87 0xD0 0xB5 0xD0 0xBD 0xD0 0xB8
|
||||
0xD0 0xB5
|
||||
}
|
||||
}
|
||||
|
||||
IDAT {
|
||||
zlib {
|
||||
# 1x1 gray pixels (with filter bytes).
|
||||
0x00 0x80
|
||||
}
|
||||
}
|
||||
|
||||
IEND {
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
foo
|
||||
@@ -1,27 +0,0 @@
|
||||
# Feed this file to script/make-artificial.go
|
||||
|
||||
make deflate
|
||||
|
||||
blockDynamicHuffman (final) {
|
||||
huffman CodeLength {
|
||||
1 00
|
||||
2 01
|
||||
17 10
|
||||
18 11
|
||||
}
|
||||
|
||||
huffman Literal/Length {
|
||||
# 102='f', 111='o', 256=EOB
|
||||
111 0
|
||||
102 10
|
||||
256 11
|
||||
}
|
||||
|
||||
huffman Distance {
|
||||
# Incomplete. There is no key/value pair whose value starts with "1".
|
||||
0 0
|
||||
}
|
||||
|
||||
literal "foo"
|
||||
endOfBlock
|
||||
}
|
||||
|
Before Width: | Height: | Size: 41 B |
@@ -1,23 +0,0 @@
|
||||
# Feed this file to script/make-artificial.go
|
||||
|
||||
make gif
|
||||
|
||||
header
|
||||
|
||||
image {
|
||||
imageWidthHeight 2 2
|
||||
palette {
|
||||
0x00 0x00 0xFF
|
||||
0x11 0x00 0xFF
|
||||
0x22 0x00 0xFF
|
||||
0x33 0x00 0xFF
|
||||
}
|
||||
}
|
||||
|
||||
frame {
|
||||
frameLeftTopWidthHeight 0 0 2 2
|
||||
}
|
||||
# The frame is 4 pixels, but we supply 5.
|
||||
lzw 2 0x00 0x00 0x00 0x00 0x00
|
||||
|
||||
trailer
|
||||
|
After Width: | Height: | Size: 14 KiB |
|
After Width: | Height: | Size: 441 B |
|
After Width: | Height: | Size: 441 B |
|
After Width: | Height: | Size: 4.2 KiB |
|
After Width: | Height: | Size: 9.2 KiB |
|
After Width: | Height: | Size: 1.1 KiB |
|
After Width: | Height: | Size: 779 B |
|
After Width: | Height: | Size: 779 B |
|
After Width: | Height: | Size: 779 B |
|
After Width: | Height: | Size: 763 B |
@@ -0,0 +1,78 @@
|
||||
# Generated by script/print-nia-checksums.sh
|
||||
d3bb0beb test/data/DCI-P3-D65.icc
|
||||
646e081a test/data/animated-red-blue.000000.nie
|
||||
181c6916 test/data/animated-red-blue.000001.nie
|
||||
e651a889 test/data/animated-red-blue.000002.nie
|
||||
14a5b4b0 test/data/animated-red-blue.000003.nie
|
||||
76e40058 test/data/animated-red-blue.apng
|
||||
76e40058 test/data/animated-red-blue.gif
|
||||
f9a10dac test/data/artificial-gif/background-color.gif
|
||||
36e7d9c7 test/data/artificial-gif/empty-palette.gif
|
||||
db4c30eb test/data/artificial-gif/frame-out-of-bounds.gif
|
||||
f2dc2c43 test/data/artificial-gif/metadata-empty.gif
|
||||
f2dc2c43 test/data/artificial-gif/metadata-full.gif
|
||||
a1a9b56d test/data/artificial-gif/multiple-graphic-controls.gif
|
||||
046a2d07 test/data/artificial-gif/multiple-loop-counts.gif
|
||||
ba6e48f8 test/data/artificial-gif/no-frames.gif
|
||||
f33b9bc1 test/data/artificial-gif/pixel-data-none.gif
|
||||
ac9d76d8 test/data/artificial-gif/pixel-data-not-enough.gif
|
||||
2342e3fc test/data/artificial-gif/pixel-data-too-much-bad-lzw.gif
|
||||
2342e3fc test/data/artificial-gif/pixel-data-too-much-good-lzw.gif
|
||||
39a71dce test/data/artificial-gif/small-frame-interlaced.gif
|
||||
beaec397 test/data/artificial-gif/transparent-index.gif
|
||||
f33b9bc1 test/data/artificial-gif/zero-width-frame.gif
|
||||
0564b364 test/data/artificial-png/apng-skip-idat.png
|
||||
e08a7cc8 test/data/artificial-png/exif.png
|
||||
e08a7cc8 test/data/artificial-png/key-value-pairs.png
|
||||
076cb375 test/data/bricks-color.bmp
|
||||
076cb375 test/data/bricks-color.png
|
||||
f36c2e80 test/data/bricks-dither.bmp
|
||||
f36c2e80 test/data/bricks-dither.gif
|
||||
f36c2e80 test/data/bricks-dither.no-ancillary.png
|
||||
f36c2e80 test/data/bricks-dither.png
|
||||
c2bce675 test/data/bricks-gray.bmp
|
||||
c2bce675 test/data/bricks-gray.gif
|
||||
c2bce675 test/data/bricks-gray.no-ancillary.png
|
||||
c2bce675 test/data/bricks-gray.png
|
||||
7aebfe6c test/data/bricks-nodither.bmp
|
||||
7aebfe6c test/data/bricks-nodither.gif
|
||||
7aebfe6c test/data/bricks-nodither.png
|
||||
ae2e547d test/data/bricks-nodither.wbmp
|
||||
b47730a2 test/data/checkerboard.gamma1dot0.png
|
||||
b47730a2 test/data/checkerboard.gamma2dot2.png
|
||||
aa3e6c7c test/data/crude-flag.nie
|
||||
3014b4c0 test/data/gifplayer-muybridge.gif
|
||||
030f5a48 test/data/harvesters.bmp
|
||||
c18b3d5a test/data/harvesters.gif
|
||||
030f5a48 test/data/harvesters.png
|
||||
e776c90f test/data/hat.bmp
|
||||
6dcba6a4 test/data/hat.gif
|
||||
e776c90f test/data/hat.png
|
||||
d30bfe5d test/data/hat.wbmp
|
||||
33a44f22 test/data/hibiscus.primitive.bmp
|
||||
25e212b3 test/data/hibiscus.primitive.gif
|
||||
33a44f22 test/data/hibiscus.primitive.png
|
||||
60040742 test/data/hibiscus.regular.bmp
|
||||
b727da8b test/data/hibiscus.regular.gif
|
||||
60040742 test/data/hibiscus.regular.png
|
||||
dcbb225a test/data/hippopotamus.bmp
|
||||
ed4b78fc test/data/hippopotamus.interlaced.gif
|
||||
dcbb225a test/data/hippopotamus.interlaced.png
|
||||
c3c4bd65 test/data/hippopotamus.interlaced.truncated.gif
|
||||
d3bbed27 test/data/hippopotamus.masked-with-muybridge.gif
|
||||
7e6acf01 test/data/hippopotamus.masked-with-muybridge.png
|
||||
dcbb225a test/data/hippopotamus.nie
|
||||
ed4b78fc test/data/hippopotamus.regular.gif
|
||||
dcbb225a test/data/hippopotamus.regular.png
|
||||
2dccfe56 test/data/muybridge-frame-000.wbmp
|
||||
db2733f5 test/data/muybridge.apng
|
||||
db2733f5 test/data/muybridge.gif
|
||||
bf7e8c96 test/data/pjw-thumbnail.bmp
|
||||
bf7e8c96 test/data/pjw-thumbnail.gif
|
||||
bf7e8c96 test/data/pjw-thumbnail.png
|
||||
38cb4cbf test/data/red-blue-gradient.dcip3d65-no-chrm-no-gama.png
|
||||
38cb4cbf test/data/red-blue-gradient.gamma1dot0.png
|
||||
38cb4cbf test/data/red-blue-gradient.gamma1dot8.png
|
||||
38cb4cbf test/data/red-blue-gradient.gamma2dot2.png
|
||||
38cb4cbf test/data/red-blue-gradient.vanilla.png
|
||||
75060601 test/data/rgb24png.bmp
|
||||