mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
Also remove explicit PATENTS file. The new LICENSE file already discusses patents. Note that the Puffs project has not yet been publicly released.
210 lines
4.9 KiB
Go
210 lines
4.9 KiB
Go
// Copyright 2017 The Puffs 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
|
|
|
|
// extract-giflzw.go extracts the LZW-compressed block data in a GIF image. The
|
|
// initial byte in each written file is the LZW literal width.
|
|
//
|
|
// Usage: go run extract-giflzw.go foo.gif bar.gif
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/lzw"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
)
|
|
|
|
func main() {
|
|
if err := main1(); err != nil {
|
|
os.Stderr.WriteString(err.Error() + "\n")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func main1() error {
|
|
for _, a := range os.Args[1:] {
|
|
data, err := decode(a)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// As a sanity check, the result should be valid LZW.
|
|
if err := checkLZW(data); err != nil {
|
|
return err
|
|
}
|
|
b := a[:len(a)-len(filepath.Ext(a))]
|
|
if err := ioutil.WriteFile(b+".indexes.giflzw", data, 0644); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func decode(filename string) (ret []byte, err error) {
|
|
src, err := ioutil.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
|
|
}
|
|
|
|
seenID := false
|
|
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
|
|
}
|
|
// For an animated GIF, take only the first frame.
|
|
if !seenID {
|
|
seenID = true
|
|
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(x []byte) error {
|
|
if len(x) == 0 {
|
|
return fmt.Errorf("missing GIF literal width")
|
|
}
|
|
rc := lzw.NewReader(bytes.NewReader(x[1:]), lzw.LSB, int(x[0]))
|
|
defer rc.Close()
|
|
_, err := ioutil.ReadAll(rc)
|
|
if err != nil {
|
|
return fmt.Errorf("block data is not valid LZW: %v", err)
|
|
}
|
|
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
|
|
)
|