mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
386 lines
8.7 KiB
Go
386 lines
8.7 KiB
Go
// 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.
|
|
|
|
//go:build ignore
|
|
// +build ignore
|
|
|
|
package main
|
|
|
|
// extract-giflzw.go extracts or analyzes the LZW-compressed block data in a
|
|
// GIF image.
|
|
//
|
|
// - Add the "-extract" flag to write the LZW data to a file. The initial
|
|
// byte in each written file is the LZW literal width.
|
|
//
|
|
// - Add the "-histogram" flag to print emission length histograms instead of
|
|
// writing out *.indexes.giflzw files.
|
|
//
|
|
// Add the optional "-allframes" flag to process all frames of an animated GIF,
|
|
// not just the first frame. It applies to both -extract and -histogram.
|
|
//
|
|
// Usage: go run extract-giflzw.go -extract foo.gif bar.gif
|
|
// go run extract-giflzw.go -histogram -allframes foo.gif bar.gif
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/lzw"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
)
|
|
|
|
var (
|
|
allframesFlag = flag.Bool("allframes", false, "process all frames, not just the first")
|
|
extractFlag = flag.Bool("extract", false, "write LZW data to a file")
|
|
histogramFlag = flag.Bool("histogram", false, "print emission length histograms")
|
|
)
|
|
|
|
func main() {
|
|
if err := main1(); err != nil {
|
|
os.Stderr.WriteString(err.Error() + "\n")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func main1() error {
|
|
flag.Parse()
|
|
if !*extractFlag && !*histogramFlag {
|
|
return fmt.Errorf("none of -extract or -histogram given")
|
|
}
|
|
|
|
for argIndex, arg := range flag.Args() {
|
|
frames, err := extractLZWFrames(arg)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if *histogramFlag {
|
|
which := "first frame"
|
|
if *allframesFlag {
|
|
which = "all frames"
|
|
}
|
|
fmt.Printf("\n%s (%s)\n", arg, which)
|
|
|
|
histogramTotal = 0
|
|
for i := range histogram {
|
|
histogram[i] = 0
|
|
}
|
|
}
|
|
|
|
for frameIndex, frame := range frames {
|
|
if err := checkLZW(frame); err != nil {
|
|
fmt.Printf("Warning: frame #%d: %v\n", frameIndex, err)
|
|
}
|
|
|
|
if *extractFlag {
|
|
filename := arg[:len(arg)-len(filepath.Ext(arg))]
|
|
if *allframesFlag {
|
|
filename = fmt.Sprintf("%s-frame-%03d", filename, argIndex)
|
|
}
|
|
filename += ".indexes.giflzw"
|
|
if err := os.WriteFile(filename, frame, 0644); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if *histogramFlag {
|
|
// Ignore any LZW format errors. Decode as much as we can.
|
|
_ = buildHistogram(frame)
|
|
}
|
|
|
|
if !*allframesFlag {
|
|
break
|
|
}
|
|
}
|
|
|
|
if *histogramFlag {
|
|
fmt.Printf(" Percent Count Emission_Length_Bucket\n")
|
|
for i, h := range histogram {
|
|
percent := float64(100*h) / float64(histogramTotal)
|
|
fmt.Printf(" %6.2f %6d %s\n", percent, h, bucketNames[i])
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func extractLZWFrames(filename string) (ret [][]byte, err error) {
|
|
src, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Read the header (6 bytes) and screen descriptor (7 bytes).
|
|
if len(src) < 6+7 {
|
|
return nil, fmt.Errorf("not a GIF")
|
|
}
|
|
switch string(src[:6]) {
|
|
case "GIF87a", "GIF89a":
|
|
// No-op.
|
|
default:
|
|
return nil, fmt.Errorf("not a GIF")
|
|
}
|
|
ctSize := 0
|
|
if src[10]&fColorTable != 0 {
|
|
ctSize = 1 << (1 + src[10]&fColorTableBitsMask)
|
|
}
|
|
if src, err = skipColorTable(src[13:], ctSize); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for len(src) > 0 {
|
|
switch src[0] {
|
|
case sExtension:
|
|
if src, err = skipExtension(src[1:]); err != nil {
|
|
return nil, err
|
|
}
|
|
case sImageDescriptor:
|
|
compressed := []byte(nil)
|
|
if src, compressed, err = readImageDescriptor(src[1:]); err != nil {
|
|
return nil, err
|
|
}
|
|
ret = append(ret, compressed)
|
|
case sTrailer:
|
|
if len(src) != 1 {
|
|
return nil, fmt.Errorf("extraneous data after GIF trailer section")
|
|
}
|
|
return ret, nil
|
|
default:
|
|
return nil, fmt.Errorf("unsupported GIF section")
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("missing GIF trailer section")
|
|
}
|
|
|
|
func skipColorTable(src []byte, ctSize int) (src1 []byte, err error) {
|
|
if ctSize == 0 {
|
|
return src, nil
|
|
}
|
|
n := 3 * ctSize
|
|
if len(src) < n {
|
|
return nil, fmt.Errorf("short color table")
|
|
}
|
|
return src[n:], nil
|
|
}
|
|
|
|
func skipExtension(src []byte) (src1 []byte, err error) {
|
|
if len(src) < 2 {
|
|
return nil, fmt.Errorf("bad GIF extension")
|
|
}
|
|
ext := src[0]
|
|
blockSize := int(src[1])
|
|
if len(src) < 2+blockSize {
|
|
return nil, fmt.Errorf("bad GIF extension")
|
|
}
|
|
src = src[2+blockSize:]
|
|
switch ext {
|
|
case ePlainText, eGraphicControl, eComment, eApplication:
|
|
src1, _, err = readBlockData(src, nil)
|
|
return src1, err
|
|
}
|
|
return nil, fmt.Errorf("unsupported GIF extension")
|
|
}
|
|
|
|
func readImageDescriptor(src []byte) (src1 []byte, ret1 []byte, err error) {
|
|
if len(src) < 9 {
|
|
return nil, nil, fmt.Errorf("bad GIF image descriptor")
|
|
}
|
|
ctSize := 0
|
|
if src[8]&fColorTable != 0 {
|
|
ctSize = 1 << (1 + src[8]&fColorTableBitsMask)
|
|
}
|
|
if src, err = skipColorTable(src[9:], ctSize); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
if len(src) < 1 {
|
|
return nil, nil, fmt.Errorf("bad GIF image descriptor")
|
|
}
|
|
literalWidth := src[0]
|
|
if literalWidth < 2 || 8 < literalWidth {
|
|
return nil, nil, fmt.Errorf("bad GIF literal width")
|
|
}
|
|
return readBlockData(src[1:], []byte{literalWidth})
|
|
}
|
|
|
|
func readBlockData(src []byte, ret []byte) (src1 []byte, ret1 []byte, err error) {
|
|
for {
|
|
if len(src) < 1 {
|
|
return nil, nil, fmt.Errorf("bad GIF block")
|
|
}
|
|
n := int(src[0]) + 1
|
|
if len(src) < n {
|
|
return nil, nil, fmt.Errorf("bad GIF block")
|
|
}
|
|
ret = append(ret, src[1:n]...)
|
|
src = src[n:]
|
|
if n == 1 {
|
|
return src, ret, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func checkLZW(data []byte) error {
|
|
if len(data) == 0 {
|
|
return fmt.Errorf("missing GIF literal width")
|
|
}
|
|
rc := lzw.NewReader(bytes.NewReader(data[1:]), lzw.LSB, int(data[0]))
|
|
defer rc.Close()
|
|
_, err := io.ReadAll(rc)
|
|
if err != nil {
|
|
return fmt.Errorf("block data is not valid LZW: %v", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
const numBuckets = 14
|
|
|
|
var (
|
|
histogramTotal = uint32(0)
|
|
histogram = [numBuckets]uint32{}
|
|
bucketNames = [numBuckets]string{
|
|
" 1 (Literal Code)",
|
|
" 2",
|
|
" 3",
|
|
" 4",
|
|
" 5",
|
|
" 6",
|
|
" 7",
|
|
" 8",
|
|
" 9 .. 16",
|
|
" 17 .. 32",
|
|
" 33 .. 64",
|
|
" 65 .. 128",
|
|
"127 .. 256",
|
|
"256+ ",
|
|
}
|
|
)
|
|
|
|
func bucket(emissionLength uint32) uint32 {
|
|
switch {
|
|
case emissionLength <= 0:
|
|
panic("bad emissionLength")
|
|
case emissionLength <= 8:
|
|
return emissionLength - 1
|
|
case emissionLength <= 16:
|
|
return 8
|
|
case emissionLength <= 32:
|
|
return 9
|
|
case emissionLength <= 64:
|
|
return 10
|
|
case emissionLength <= 128:
|
|
return 11
|
|
case emissionLength <= 256:
|
|
return 12
|
|
default:
|
|
return 13
|
|
}
|
|
}
|
|
|
|
func buildHistogram(data []byte) error {
|
|
if len(data) == 0 {
|
|
return fmt.Errorf("missing GIF literal width")
|
|
}
|
|
|
|
literalWidth, data := uint32(data[0]), data[1:]
|
|
clearCode := uint32(1) << literalWidth
|
|
endCode := clearCode + 1
|
|
|
|
saveCode := endCode
|
|
prevCode := uint32(0)
|
|
width := literalWidth + 1
|
|
|
|
prefixes := [4096]uint32{}
|
|
emissionLengths := [4096]uint32{}
|
|
for i := uint32(0); i < clearCode; i++ {
|
|
emissionLengths[i] = 1
|
|
}
|
|
|
|
bits := uint32(0)
|
|
nBits := uint32(0)
|
|
|
|
for {
|
|
for nBits < width {
|
|
if len(data) == 0 {
|
|
return fmt.Errorf("bad LZW data: short read")
|
|
}
|
|
bits |= uint32(data[0]) << nBits
|
|
data = data[1:]
|
|
nBits += 8
|
|
}
|
|
|
|
code := bits & ((uint32(1) << width) - 1)
|
|
bits >>= width
|
|
nBits -= width
|
|
|
|
if code < clearCode {
|
|
// Literal, emitting exactly 1 byte.
|
|
|
|
} else if code == clearCode {
|
|
saveCode = endCode
|
|
prevCode = 0
|
|
width = literalWidth + 1
|
|
continue
|
|
|
|
} else if code == endCode {
|
|
break
|
|
|
|
} else if code <= saveCode {
|
|
// Copy, emitting 2 or more bytes.
|
|
|
|
} else {
|
|
return fmt.Errorf("bad LZW data: code out of range")
|
|
}
|
|
|
|
n := emissionLengths[code]
|
|
if code == saveCode {
|
|
n = emissionLengths[prevCode] + 1
|
|
}
|
|
histogram[bucket(n)]++
|
|
histogramTotal++
|
|
|
|
if saveCode <= 4095 {
|
|
prefixes[saveCode] = prevCode
|
|
emissionLengths[saveCode] = emissionLengths[prevCode] + 1
|
|
saveCode++
|
|
if (saveCode == (1 << width)) && (width < 12) {
|
|
width++
|
|
}
|
|
prevCode = code
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// The constants below are intrinsic to the GIF file format. The spec is
|
|
// http://www.w3.org/Graphics/GIF/spec-gif89a.txt
|
|
const (
|
|
// Flags.
|
|
fColorTableBitsMask = 0x07
|
|
fColorTable = 0x80
|
|
|
|
// Sections.
|
|
sExtension = 0x21
|
|
sImageDescriptor = 0x2C
|
|
sTrailer = 0x3B
|
|
|
|
// Extensions.
|
|
ePlainText = 0x01
|
|
eGraphicControl = 0xF9
|
|
eComment = 0xFE
|
|
eApplication = 0xFF
|
|
)
|