mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
371 lines
8.3 KiB
Go
371 lines
8.3 KiB
Go
// Copyright 2023 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
|
|
//go:build ignore
|
|
// +build ignore
|
|
|
|
package main
|
|
|
|
// print-jpeg-markers.go prints a JPEG's markers' position and type.
|
|
//
|
|
// Usage: go run print-jpeg-markers.go foo.jpeg
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
)
|
|
|
|
var (
|
|
xFlag = flag.Bool("x", false, "print extra information parsed from marker payloads")
|
|
)
|
|
|
|
func main() {
|
|
if err := main1(); err != nil {
|
|
os.Stderr.WriteString(err.Error() + "\n")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func main1() error {
|
|
flag.Parse()
|
|
args := flag.Args()
|
|
if len(args) != 1 {
|
|
return fmt.Errorf("usage: progname filename.jpeg")
|
|
}
|
|
src, err := os.ReadFile(args[0])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
pos := 0
|
|
if len(src) < 2 {
|
|
return posError(pos, len(src))
|
|
}
|
|
for pos <= (len(src) - 2) {
|
|
if src[pos] != 0xFF {
|
|
return posError(pos, len(src))
|
|
}
|
|
marker := src[pos+1]
|
|
fmt.Printf("pos = 0x%08X = %10d marker = 0xFF 0x%02X %s\n", pos, pos, marker, names[marker])
|
|
pos += 2
|
|
switch {
|
|
case (0xD0 <= marker) && (marker < 0xD9):
|
|
// RSTn (Restart) and SOI (Start Of Image) markers have no payload.
|
|
continue
|
|
case marker == 0xD9:
|
|
// EOI (End Of Image) marker.
|
|
return nil
|
|
}
|
|
|
|
if pos >= (len(src) - 2) {
|
|
return posError(pos, len(src))
|
|
}
|
|
payloadLength := (int(src[pos]) << 8) | int(src[pos+1])
|
|
pos += payloadLength
|
|
if (payloadLength < 2) || (pos < 0) || (pos > len(src)) {
|
|
return posError(pos, len(src))
|
|
}
|
|
if *xFlag {
|
|
parse(marker, src[pos+2-payloadLength:pos])
|
|
}
|
|
|
|
if marker != 0xDA { // SOS (Start Of Scan) marker.
|
|
continue
|
|
}
|
|
for pos < len(src) {
|
|
if src[pos] != 0xFF {
|
|
pos += 1
|
|
} else if pos >= (len(src) - 1) {
|
|
return posError(pos, len(src))
|
|
} else if m := src[pos+1]; (m != 0x00) && ((m < 0xD0) || (0xD7 < m)) {
|
|
break
|
|
} else {
|
|
pos += 2
|
|
}
|
|
}
|
|
}
|
|
return posError(pos, len(src))
|
|
}
|
|
|
|
func posError(pos int, lenSrc int) error {
|
|
return fmt.Errorf("bad JPEG, pos = 0x%08X = %10d, len(src) = 0x%08X = %10d",
|
|
pos, pos, lenSrc, lenSrc)
|
|
}
|
|
|
|
func parse(marker byte, payload []byte) {
|
|
if ((0xE0 <= marker) && (marker <= 0xEF)) || (marker == 0xFE) {
|
|
n := len(payload)
|
|
if n > 16 {
|
|
n = 16
|
|
}
|
|
buf := [16]byte{}
|
|
for i := range buf {
|
|
buf[i] = '.'
|
|
if i >= len(payload) {
|
|
continue
|
|
} else if c := payload[i]; (0x20 <= c) && (c < 0x7F) {
|
|
buf[i] = c
|
|
}
|
|
}
|
|
fmt.Printf("# contents[..%2d] %s\n", n, buf[:n])
|
|
}
|
|
|
|
switch marker {
|
|
case 0xC0, 0xC1, 0xC2:
|
|
parseSOF(marker, payload)
|
|
case 0xC4:
|
|
parseDHT(marker, payload)
|
|
case 0xDA:
|
|
parseSOS(marker, payload)
|
|
case 0xDB:
|
|
parseDQT(marker, payload)
|
|
|
|
// For APPN markers, see https://exiftool.org/TagNames/JPEG.html
|
|
case 0xE0:
|
|
if hasPrefix(payload, "JFIF\x00") {
|
|
parseJFIF(marker, payload)
|
|
}
|
|
case 0xE1:
|
|
if hasPrefix(payload, "Exif\x00\x00") {
|
|
parseExif(marker, payload)
|
|
} else if hasPrefix(payload, "http://ns.adobe.com/xap/1.0/\x00") {
|
|
parseXMP(marker, payload)
|
|
} else if hasPrefix(payload, "http://ns.adobe.com/xmp/extension/\x00") {
|
|
parseExtendedXMP(marker, payload)
|
|
}
|
|
case 0xE2:
|
|
if hasPrefix(payload, "ICC_PROFILE\x00") {
|
|
parseICC(marker, payload)
|
|
}
|
|
case 0xED:
|
|
if hasPrefix(payload, "Photoshop 3.0") {
|
|
parsePhotoshop(marker, payload)
|
|
}
|
|
case 0xEE:
|
|
if hasPrefix(payload, "Adobe") {
|
|
parseAdobe(marker, payload)
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseDHT(marker byte, payload []byte) {
|
|
for len(payload) > 17 {
|
|
c := payload[0] >> 4
|
|
h := payload[0] & 15
|
|
if (c > 1) || (h > 3) {
|
|
return
|
|
}
|
|
payload = payload[1:]
|
|
|
|
totalCount := 0
|
|
for _, count := range payload[:16] {
|
|
totalCount += int(count)
|
|
}
|
|
payload = payload[16:]
|
|
|
|
if len(payload) < totalCount {
|
|
return
|
|
}
|
|
payload = payload[totalCount:]
|
|
|
|
which := 'D'
|
|
if c > 0 {
|
|
which = 'A'
|
|
}
|
|
fmt.Printf("# h_identifier %cC | %X\n", which, h)
|
|
}
|
|
}
|
|
|
|
func parseDQT(marker byte, payload []byte) {
|
|
for len(payload) > 0 {
|
|
qIdent := payload[0] & 15
|
|
if qIdent > 3 {
|
|
return
|
|
}
|
|
bytesPerElement := 1 + (int(payload[0]) >> 4)
|
|
if bytesPerElement > 2 {
|
|
return
|
|
}
|
|
n := (64 * bytesPerElement) + 1
|
|
if len(payload) < n {
|
|
return
|
|
}
|
|
payload = payload[n:]
|
|
fmt.Printf("# q_identifier %02X\n", qIdent)
|
|
}
|
|
}
|
|
|
|
func parseSOF(marker byte, payload []byte) {
|
|
numComponents := 0
|
|
switch lp := len(payload); lp {
|
|
case 9, 12, 15, 18:
|
|
numComponents = (lp - 6) / 3
|
|
default:
|
|
return
|
|
}
|
|
|
|
h := (uint32(payload[1]) << 8) | uint32(payload[2])
|
|
w := (uint32(payload[3]) << 8) | uint32(payload[4])
|
|
isRGB := ""
|
|
if (numComponents == 3) &&
|
|
(payload[6] == 'R') && (payload[9] == 'G') && (payload[12] == 'B') {
|
|
isRGB = " (RGB)"
|
|
}
|
|
|
|
cTable := [4]byte{}
|
|
sTable := [4]byte{}
|
|
qTable := [4]byte{}
|
|
for i := 0; i < numComponents; i++ {
|
|
cTable[i] = payload[(3*i)+6]
|
|
sTable[i] = payload[(3*i)+7]
|
|
qTable[i] = payload[(3*i)+8]
|
|
}
|
|
|
|
fmt.Printf("# width 0x%04X = %5d\n", w, w)
|
|
fmt.Printf("# height 0x%04X = %5d\n", h, h)
|
|
fmt.Printf("# bit_depth %d\n", payload[0])
|
|
fmt.Printf("# num_components %d\n", numComponents)
|
|
fmt.Printf("# c_identifiers % 02X%s\n", cTable[:numComponents], isRGB)
|
|
fmt.Printf("# subsampling H|V % 02X\n", sTable[:numComponents])
|
|
fmt.Printf("# q_selectors % 02X\n", qTable[:numComponents])
|
|
}
|
|
|
|
func parseSOS(marker byte, payload []byte) {
|
|
numComponents := 0
|
|
switch lp := len(payload); lp {
|
|
case 6, 8, 10, 12:
|
|
numComponents = (lp - 4) / 2
|
|
default:
|
|
return
|
|
}
|
|
if numComponents != int(payload[0]) {
|
|
return
|
|
}
|
|
|
|
cTable := [4]byte{}
|
|
hTable := [4]byte{}
|
|
for i := 0; i < numComponents; i++ {
|
|
cTable[i] = payload[(2*i)+1]
|
|
hTable[i] = payload[(2*i)+2]
|
|
}
|
|
|
|
progSS := payload[(2*numComponents)+1] & 63
|
|
progSE := payload[(2*numComponents)+2] & 63
|
|
progAH := payload[(2*numComponents)+3] >> 4
|
|
progAL := payload[(2*numComponents)+3] & 15
|
|
|
|
fmt.Printf("# num_components %d\n", numComponents)
|
|
fmt.Printf("# c_selectors % 02X\n", cTable[:numComponents])
|
|
fmt.Printf("# h_selectors D|A % 02X\n", hTable[:numComponents])
|
|
fmt.Printf("# progression s: %2d, %2d; a: %2d, %2d\n", progSS, progSE, progAH, progAL)
|
|
}
|
|
|
|
func parseAdobe(marker byte, payload []byte) {
|
|
if len(payload) < 12 {
|
|
return
|
|
}
|
|
transform := "RGB or CMYK"
|
|
switch payload[11] {
|
|
case 1:
|
|
transform = "YCC"
|
|
case 2:
|
|
transform = "YCCK"
|
|
}
|
|
fmt.Printf("# transform %s\n", transform)
|
|
}
|
|
|
|
func parseExif(marker byte, payload []byte) {
|
|
// Not implemented.
|
|
}
|
|
|
|
func parseExtendedXMP(marker byte, payload []byte) {
|
|
// Not implemented.
|
|
}
|
|
|
|
func parseICC(marker byte, payload []byte) {
|
|
// Not implemented.
|
|
}
|
|
|
|
func parseJFIF(marker byte, payload []byte) {
|
|
// Not implemented.
|
|
}
|
|
|
|
func parsePhotoshop(marker byte, payload []byte) {
|
|
// Not implemented.
|
|
}
|
|
|
|
func parseXMP(marker byte, payload []byte) {
|
|
// Not implemented.
|
|
}
|
|
|
|
func hasPrefix(s []byte, prefix string) bool {
|
|
return (len(s) >= len(prefix)) &&
|
|
(string(s[:len(prefix)]) == prefix)
|
|
}
|
|
|
|
var names = [256]string{
|
|
0xC0: "SOF0 (Sequential/Baseline)",
|
|
0xC1: "SOF1 (Sequential/Extended)",
|
|
0xC2: "SOF2 (Progressive)",
|
|
0xC3: "SOF3",
|
|
0xC4: "DHT",
|
|
0xC5: "SOF5",
|
|
0xC6: "SOF6",
|
|
0xC7: "SOF7",
|
|
|
|
0xC8: "JPG",
|
|
0xC9: "SOF9",
|
|
0xCA: "SOF10",
|
|
0xCB: "SOF11",
|
|
0xCC: "DAC",
|
|
0xCD: "SOF13",
|
|
0xCE: "SOF14",
|
|
0xCF: "SOF15",
|
|
|
|
0xD0: "RST0",
|
|
0xD1: "RST1",
|
|
0xD2: "RST2",
|
|
0xD3: "RST3",
|
|
0xD4: "RST4",
|
|
0xD5: "RST5",
|
|
0xD6: "RST6",
|
|
0xD7: "RST7",
|
|
|
|
0xD8: "SOI",
|
|
0xD9: "EOI",
|
|
0xDA: "SOS",
|
|
0xDB: "DQT",
|
|
0xDC: "DNL",
|
|
0xDD: "DRI",
|
|
0xDE: "DHP",
|
|
0xDF: "EXP",
|
|
|
|
0xE0: "APP0",
|
|
0xE1: "APP1",
|
|
0xE2: "APP2",
|
|
0xE3: "APP3",
|
|
0xE4: "APP4",
|
|
0xE5: "APP5",
|
|
0xE6: "APP6",
|
|
0xE7: "APP7",
|
|
|
|
0xE8: "APP8",
|
|
0xE9: "APP9",
|
|
0xEA: "APP10",
|
|
0xEB: "APP11",
|
|
0xEC: "APP12",
|
|
0xED: "APP13",
|
|
0xEE: "APP14",
|
|
0xEF: "APP15",
|
|
|
|
0xFE: "COM",
|
|
}
|