better sniff and dng

internal/codec/detect.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"path/filepath"
+	"sort"
 	"strings"
 )
 
@@ -30,17 +31,15 @@ func (s *Sniffed) String() string {
 }
 
 func Sniff(reader io.Reader, input string, ignoreExtension bool) (*Sniffed, io.Reader, error) {
+	var (
+		hintedExt   string
+		hintedCodec Codec
+	)
+
 	if !ignoreExtension {
-		ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(input), "."))
-		if ext != "" {
-			codec, _ := FindCodec(ext, false)
-			if codec != nil {
-				return &Sniffed{
-					Header:     []byte("." + ext),
-					Confidence: 100,
-					Codec:      codec,
-				}, reader, nil
-			}
+		hintedExt = strings.ToLower(strings.TrimPrefix(filepath.Ext(input), "."))
+		if hintedExt != "" {
+			hintedCodec, _ = FindCodec(hintedExt, false)
 		}
 	}
 
@@ -51,10 +50,15 @@ func Sniff(reader io.Reader, input string, ignoreExtension bool) (*Sniffed, io.R
 
 	ra := bytes.NewReader(buf)
 
+	type candidate struct {
+		codec      Codec
+		confidence int
+		header     []byte
+	}
+
 	var (
-		best  int
-		magic []byte
-		guess Codec
+		best int
+		list []candidate
 	)
 
 	for _, codec := range codecs {
@@ -69,21 +73,59 @@ func Sniff(reader io.Reader, input string, ignoreExtension bool) (*Sniffed, io.R
 			return nil, nil, err
 		}
 
+		fmt.Println(codec.String(), confidence)
+
+		if confidence <= 0 {
+			continue
+		}
+
+		list = append(list, candidate{
+			codec:      codec,
+			confidence: confidence,
+			header:     header,
+		})
+
 		if confidence > best {
 			best = confidence
-			magic = header
-			guess = codec
 		}
 	}
 
-	if guess == nil {
+	if len(list) == 0 || best <= 0 {
 		return nil, nil, errors.New("unknown input format")
 	}
 
+	var top []candidate
+
+	for _, cand := range list {
+		if cand.confidence == best {
+			top = append(top, cand)
+		}
+	}
+
+	if hintedCodec != nil {
+		for _, cand := range top {
+			if cand.codec != hintedCodec {
+				continue
+			}
+
+			return &Sniffed{
+				Header:     cand.header,
+				Confidence: cand.confidence,
+				Codec:      cand.codec,
+			}, bytes.NewReader(buf), nil
+		}
+	}
+
+	sort.Slice(top, func(i, j int) bool {
+		return top[i].codec.String() < top[j].codec.String()
+	})
+
+	chosen := top[0]
+
 	return &Sniffed{
-		Header:     magic,
-		Confidence: best,
-		Codec:      guess,
+		Header:     chosen.header,
+		Confidence: chosen.confidence,
+		Codec:      chosen.codec,
 	}, bytes.NewReader(buf), nil
 }
 

internal/codec/dng/dng.go

@@ -0,0 +1,169 @@
+package dng
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"image"
+	"io"
+
+	"github.com/coalaura/ffwebp/internal/codec"
+	"github.com/coalaura/ffwebp/internal/opts"
+	"github.com/urfave/cli/v3"
+
+	// pure-go DNG preview extractor
+	"github.com/mdouchement/dng"
+)
+
+func init() {
+	codec.Register(impl{})
+}
+
+type impl struct{}
+
+func (impl) String() string {
+	return "dng"
+}
+
+func (impl) Extensions() []string {
+	return []string{"dng"}
+}
+
+func (impl) CanEncode() bool {
+	return false
+}
+
+func (impl) Flags(flags []cli.Flag) []cli.Flag {
+	return flags
+}
+
+func (impl) Sniff(reader io.ReaderAt) (int, []byte, error) {
+	header := make([]byte, 16)
+	if _, err := reader.ReadAt(header, 0); err != nil && err != io.EOF {
+		return 0, nil, err
+	}
+
+	if len(header) < 8 {
+		return 0, nil, nil
+	}
+
+	isLE := bytes.Equal(header[0:2], []byte{'I', 'I'})
+	isBE := bytes.Equal(header[0:2], []byte{'M', 'M'})
+
+	if !isLE && !isBE {
+		return 0, nil, nil
+	}
+
+	var ord binary.ByteOrder
+
+	if isLE {
+		ord = binary.LittleEndian
+	} else {
+		ord = binary.BigEndian
+	}
+
+	sig := ord.Uint16(header[2:4])
+
+	const (
+		tiffClassic   = 42
+		tiffBig       = 43
+		tagDNGVersion = 0xC612
+	)
+
+	switch sig {
+	case tiffClassic:
+		ifd0, err := readU32(reader, ord, 4)
+		if err != nil || ifd0 == 0 {
+			return 0, nil, nil
+		}
+
+		n, err := readU16(reader, ord, int64(ifd0))
+		if err != nil {
+			return 0, nil, nil
+		}
+
+		for i := 0; i < int(n); i++ {
+			off := int64(ifd0) + 2 + int64(i)*12
+
+			tag, err := readU16(reader, ord, off)
+			if err != nil {
+				return 0, nil, nil
+			}
+
+			if uint16(tag) == uint16(tagDNGVersion) {
+				return 110, header[:8], nil
+			}
+		}
+	case tiffBig:
+		ifd0, err := readU64(reader, ord, 8)
+		if err != nil || ifd0 == 0 {
+			return 0, nil, nil
+		}
+
+		var bcnt [8]byte
+
+		if _, err := reader.ReadAt(bcnt[:], int64(ifd0)); err != nil {
+			return 0, nil, nil
+		}
+
+		n := ord.Uint64(bcnt[:])
+		max := n
+
+		if max > 1024 {
+			max = 1024
+		}
+
+		for i := uint64(0); i < max; i++ {
+			off := int64(ifd0) + 8 + int64(i)*20
+
+			tag, err := readU16(reader, ord, off)
+			if err != nil {
+				return 0, nil, nil
+			}
+
+			if uint16(tag) == uint16(tagDNGVersion) {
+				return 110, header[:8], nil
+			}
+		}
+	}
+
+	return 0, nil, nil
+}
+
+func (impl) Decode(r io.Reader) (image.Image, error) {
+	return dng.Decode(r)
+}
+
+func (impl) Encode(w io.Writer, img image.Image, _ opts.Common) error {
+	return errors.New("dng: encode not supported")
+}
+
+func readU16(reader io.ReaderAt, ord binary.ByteOrder, off int64) (uint16, error) {
+	var b [2]byte
+
+	if _, err := reader.ReadAt(b[:], off); err != nil {
+		return 0, err
+	}
+
+	return ord.Uint16(b[:]), nil
+}
+
+func readU32(reader io.ReaderAt, ord binary.ByteOrder, off int64) (uint32, error) {
+	var b [4]byte
+
+	if _, err := reader.ReadAt(b[:], off); err != nil {
+		return 0, err
+	}
+
+	return ord.Uint32(b[:]), nil
+}
+
+func readU64(reader io.ReaderAt, ord binary.ByteOrder, off int64) (uint64, error) {
+	var b [8]byte
+
+	if _, err := reader.ReadAt(b[:], off); err != nil {
+		return 0, err
+	}
+
+	return ord.Uint64(b[:]), nil
+}

internal/codec/svg/svg.go

@@ -64,7 +64,7 @@ func (impl) Flags(flags []cli.Flag) []cli.Flag {
 }
 
 func (impl) Sniff(reader io.ReaderAt) (int, []byte, error) {
-	buf := make([]byte, 128)
+	buf := make([]byte, 256)
 
 	n, err := reader.ReadAt(buf, 0)
 	if err != nil && err != io.EOF {

internal/codec/tga/tga.go

@@ -1,14 +1,15 @@
 package tga
 
 import (
-	"image"
-	"io"
+    "encoding/binary"
+    "image"
+    "io"
 
-	"github.com/ftrvxmtrx/tga"
+    "github.com/ftrvxmtrx/tga"
 
-	"github.com/coalaura/ffwebp/internal/codec"
-	"github.com/coalaura/ffwebp/internal/opts"
-	"github.com/urfave/cli/v3"
+    "github.com/coalaura/ffwebp/internal/codec"
+    "github.com/coalaura/ffwebp/internal/opts"
+    "github.com/urfave/cli/v3"
 )
 
 func init() {
@@ -34,38 +35,62 @@ func (impl) Flags(flags []cli.Flag) []cli.Flag {
 }
 
 func (impl) Sniff(reader io.ReaderAt) (int, []byte, error) {
-	buf := make([]byte, 3)
+    // Validate full 18-byte TGA header to reduce false positives.
+    // Ref: https://www.fileformat.info/format/tga/egff.htm
+    hdr := make([]byte, 18)
+    if _, err := reader.ReadAt(hdr, 0); err != nil && err != io.EOF {
+        return 0, nil, err
+    }
+    if len(hdr) < 18 {
+        return 0, nil, nil
+    }
 
-	if _, err := reader.ReadAt(buf, 0); err != nil {
-		return 0, nil, err
-	}
+    idLength := hdr[0]
+    colorMapType := hdr[1]
+    imageType := hdr[2]
 
-	colorMapType := buf[1]
+    if colorMapType > 1 {
+        return 0, nil, nil
+    }
 
-	if colorMapType > 1 {
-		return 0, nil, nil
-	}
+    switch imageType {
+    case 1, 2, 3, 9, 10, 11:
+        // valid image types
+    default:
+        // Exclude type 0 (no image data) to avoid matching random files like ISO BMFF.
+        return 0, nil, nil
+    }
 
-	validImageTypes := map[byte]bool{
-		0:  true, // no image data
-		1:  true, // colormapped, uncompressed
-		2:  true, // truecolor, uncompressed
-		3:  true, // grayscale, uncompressed
-		9:  true, // colormapped, RLE
-		10: true, // truecolor, RLE
-		11: true, // grayscale, RLE
-	}
+    // Width/height must be > 0
+    width := binary.LittleEndian.Uint16(hdr[12:14])
+    height := binary.LittleEndian.Uint16(hdr[14:16])
+    if width == 0 || height == 0 {
+        return 0, nil, nil
+    }
 
-	imageType := buf[2]
+    // Pixel depth must be one of common values
+    bpp := hdr[16]
+    switch bpp {
+    case 8, 15, 16, 24, 32:
+        // ok
+    default:
+        return 0, nil, nil
+    }
 
-	if !validImageTypes[imageType] {
-		return 0, nil, nil
-	}
+    // If color map is present, validate that the length is non-zero
+    if colorMapType == 1 {
+        colorMapLength := binary.LittleEndian.Uint16(hdr[5:7])
+        if colorMapLength == 0 {
+            return 0, nil, nil
+        }
+    }
 
-	header := make([]byte, 3)
-	copy(header, buf)
+    // Basic sanity: idLength must not push us past file start (not strictly necessary for sniff)
+    _ = idLength
 
-	return 100, header, nil
+    header := make([]byte, 18)
+    copy(header, hdr)
+    return 100, header, nil
 }
 
 func (impl) Decode(reader io.Reader) (image.Image, error) {

internal/codec/tiff/tiff.go

@@ -62,24 +62,32 @@ func (impl) Flags(flags []cli.Flag) []cli.Flag {
 }
 
 func (impl) Sniff(reader io.ReaderAt) (int, []byte, error) {
-	magicLE := []byte{0x49, 0x49, 0x2A, 0x00}
-	magicBE := []byte{0x4D, 0x4D, 0x00, 0x2A}
+    // Recognize classic TIFF (II*\0 or MM\0*) and BigTIFF (signature 43)
+    buf := make([]byte, 16)
+    if _, err := reader.ReadAt(buf, 0); err != nil && err != io.EOF {
+        return 0, nil, err
+    }
 
-	buf := make([]byte, 4)
+    if len(buf) < 8 {
+        return 0, nil, nil
+    }
 
-	if _, err := reader.ReadAt(buf, 0); err != nil {
-		return 0, nil, err
-	}
+    if bytes.Equal(buf[0:4], []byte{0x49, 0x49, 0x2A, 0x00}) ||
+        bytes.Equal(buf[0:4], []byte{0x4D, 0x4D, 0x00, 0x2A}) {
+        return 100, buf[:8], nil
+    }
 
-	if bytes.Equal(buf, magicLE) {
-		return 100, magicLE, nil
-	}
+    // BigTIFF: byte order + 43 marker, bytesize=8
+    isLE := bytes.Equal(buf[0:2], []byte{'I', 'I'})
+    isBE := bytes.Equal(buf[0:2], []byte{'M', 'M'})
+    if isLE || isBE {
+        if (isLE && buf[2] == 0x2B && buf[3] == 0x00 && buf[4] == 0x08 && buf[5] == 0x00) ||
+            (isBE && buf[2] == 0x00 && buf[3] == 0x2B && buf[4] == 0x00 && buf[5] == 0x08) {
+            return 100, buf[:8], nil
+        }
+    }
 
-	if bytes.Equal(buf, magicBE) {
-		return 100, magicBE, nil
-	}
-
-	return 0, nil, nil
+    return 0, nil, nil
 }
 
 func (impl) Decode(reader io.Reader) (image.Image, error) {

internal/codec/xbm/xbm.go

@@ -54,7 +54,7 @@ func (impl) Sniff(reader io.ReaderAt) (int, []byte, error) {
 	buf = buf[:n]
 
 	if bytes.Contains(buf, []byte("#define")) && bytes.Contains(buf, []byte("bits[]")) {
-		return 90, buf, nil
+		return 80, buf, nil
 	}
 
 	return 0, nil, nil

internal/codec/xpm/xpm.go

@@ -53,8 +53,8 @@ func (impl) Sniff(reader io.ReaderAt) (int, []byte, error) {
 
 	buf = buf[:n]
 
-	if bytes.Contains(buf, []byte("/* XPM */")) && bytes.Contains(buf, []byte("bits[]")) {
-		return 90, buf, nil
+	if bytes.Contains(buf, []byte("/* XPM */")) && bytes.Contains(buf, []byte("[] = {")) {
+		return 80, buf, nil
 	}
 
 	return 0, nil, nil