在 Go 中将元数据从一个 JPEG 复制到另一个
我正在尝试将 EXIF 标签从一个 JPEG 复制到另一个没有元数据的 JPEG 中。我尝试按照此评论中的描述进行操作。
我的想法是复制标签源文件中的所有内容ffdb，直到第一个排除的内容，然后从第一个包含的图像源文件（没有标签）中复制所有内容ffdb。生成的文件已损坏（缺少 SOS 标记）。
完整的重现器，包括 Luatic 的建议，可在https://go.dev/play/p/9BLjuZk5qlr上找到。只需在包含带有标签的 test.jpg 文件的目录中运行它即可。
这是执行此操作的 Go 代码草案。
func copyExif(from, to string) error {
os.Rename(to, to+"~")
//defer os.Remove(to + "~")
tagsSrc, err := os.Open(from)
if err != nil {
return err
}
defer tagsSrc.Close()
imageSrc, err := os.Open(to + "~")
if err != nil {
return err
}
defer imageSrc.Close()
dest, err := os.Create(to)
if err != nil {
return err
}
defer dest.Close()
// copy from tagsSrc until ffdb, excluded
buf := make([]byte, 1000000)
n, err := tagsSrc.Read(buf)
if err != nil {
return err
}
x := 0
for i := 0; i < n-1; i++ {
if buf[i] == 0xff && buf[i+1] == 0xdb {
x = i
break
}
}
_, err = dest.Write(buf[:x])
if err != nil {
return err
}
// skip ffd8 from imageSrc, then copy the rest (there are no tags here)
skip := []byte{0, 0}
_, err = imageSrc.Read(skip)
if err != nil {
return err
}
_, err = io.Copy(dest, imageSrc)
if err != nil {
return err
}
return nil
}
检查结果文件，代码似乎执行了我之前描述的操作。
左上角是标签的来源。左下角是图像来源。右边是结果。
有人知道我错过了什么吗？谢谢。
事实证明这比预期更困难。我提到了这个资源，它解释了 JPEG 作为段流的一般结构，唯一的例外是保存实际图像数据的“熵编码段”(ECS)。
你的方法有问题
我的想法是复制标签源文件中的所有内容
ffdb，直到第一个排除的内容，然后从第一个包含的图像源文件（没有标签）中复制所有内容ffdb。生成的文件已损坏（缺少 SOS 标记）。
这对 JPEG 文件做出了非常强烈的假设，但这是不成立的。首先，ffdb很可能出现在段内的某个位置。段的顺序也非常松散，因此您无法保证之前或之后的内容ffdb（定义量化表的段）。即使它确实在大多数时间都有效，它仍然是一个非常脆弱、不可靠的解决方案。
正确的做法
正确的方法是迭代所有段，仅从提供元数据的文件中复制元数据段，并从提供图像数据的文件中仅复制非元数据段。
让事情变得复杂的是，由于某种原因，ECS 不遵循段约定。因此，在读取 SOS（扫描开始）后，我们需要通过查找下一个段标记跳到 ECS 的末尾：0xFF后跟一个既不是数据（零）也不是“重新启动标记”（0xD0- 0xD7）的字节。
为了进行测试，我将此图像与 EXIF 元数据一起使用。我的测试命令如下：
cp exif.jpg exif_stripped.jpg && exiftool -All= exif_stripped.jpg && go run main.go exif.jpg exif_stripped.jpg
我曾经exiftool剥离 EXIF 元数据，然后通过读取它来测试 Go 程序。然后，我使用exiftool exif_stripped.jpg（或您选择的图像查看器）查看元数据并与输出进行比较exiftool exif.jpg（旁注：您可能可以通过使用完全废弃这个 Go 程序exiftool）。
我编写的程序取代了 EXIF 元数据、注释和版权声明。我添加了一个简单的命令行界面用于测试。如果您只想保留 EXIF 元数据，只需将isMetaTagType函数更改为
func isMetaTagType(tagType byte) bool { return tagType == exif }
完整节目
package main
import (
"os"
"io"
"bufio"
"errors"
)
const (
soi = 0xD8
eoi = 0xD9
sos = 0xDA
exif = 0xE1
copyright = 0xEE
comment = 0xFE
)
func isMetaTagType(tagType byte) bool {
// Adapt as needed
return tagType == exif || tagType == copyright || tagType == comment
}
func copySegments(dst *bufio.Writer, src *bufio.Reader, filterSegment func(tagType byte) bool) error {
var buf [2]byte
_, err := io.ReadFull(src, buf[:])
if err != nil { return err }
if buf != [2]byte{0xFF, soi} {
return errors.New("expected SOI")
}
for {
_, err := io.ReadFull(src, buf[:])
if err != nil { return err }
if buf[0] != 0xFF {
return errors.New("invalid tag type")
}
if buf[1] == eoi {
// Hacky way to check for EOF
n, err := src.Read(buf[:1])
if err != nil && err != io.EOF { return err }
if n > 0 {
return errors.New("EOF expected after EOI")
}
return nil
}
sos := buf[1] == 0xDA
filter := filterSegment(buf[1])
if filter {
_, err = dst.Write(buf[:])
if err != nil { return err }
}
_, err = io.ReadFull(src, buf[:])
if err != nil { return err }
if filter {
_, err = dst.Write(buf[:])
if err != nil { return err }
}
// Note: Includes the length, but not the tag, so subtract 2
tagLength := ((uint16(buf[0]) << 8) | uint16(buf[1])) - 2
if filter {
_, err = io.CopyN(dst, src, int64(tagLength))
} else {
_, err = src.Discard(int(tagLength))
}
if err != nil { return err }
if sos {
// Find next tag `FF xx` in the stream where `xx != 0` to skip ECS
// See https://stackoverflow.com/questions/2467137/parsing-jpeg-file-format-format-of-entropy-coded-segments-ecs
for {
bytes, err := src.Peek(2)
if err != nil { return err }
if bytes[0] == 0xFF {
data, rstMrk := bytes[1] == 0, bytes[1] >= 0xD0 && bytes[1] <= 0xD7
if !data && !rstMrk {
break
}
}
if filter {
err = dst.WriteByte(bytes[0])
if err != nil { return err }
}
_, err = src.Discard(1)
if err != nil { return err }
}
}
}
}
func copyMetadata(outImagePath, imagePath, metadataImagePath string) error {
outFile, err := os.Create(outImagePath)
if err != nil { return err }
defer outFile.Close()
writer := bufio.NewWriter(outFile)
imageFile, err := os.Open(imagePath)
if err != nil { return err }
defer imageFile.Close()
imageReader := bufio.NewReader(imageFile)
metaFile, err := os.Open(metadataImagePath)
if err != nil { return err }
defer metaFile.Close()
metaReader := bufio.NewReader(metaFile)
_, err = writer.Write([]byte{0xFF, soi})
if err != nil { return err }
{
// Copy metadata segments
// It seems that they need to come first!
err = copySegments(writer, metaReader, isMetaTagType)
if err != nil { return err }
// Copy all non-metadata segments
err = copySegments(writer, imageReader, func(tagType byte) bool {
return !isMetaTagType(tagType)
})
if err != nil { return err }
}
_, err = writer.Write([]byte{0xFF, eoi})
if err != nil { return err }
// Flush the writer, otherwise the last couple buffered writes (including the EOI) won't get written!
return writer.Flush()
}
func replaceMetadata(toPath, fromPath string) error {
copyPath := toPath + "~"
err := os.Rename(toPath, copyPath)
if err != nil { return err }
defer os.Remove(copyPath)
return copyMetadata(toPath, copyPath, fromPath)
}
func main() {
if len(os.Args) < 3 {
println("args: FROM TO")
return
}
err := replaceMetadata(os.Args[2], os.Args[1])
if err != nil {
println("replacing metadata failed: " + err.Error())
}
}
| 归档时间： |
|
| 查看次数： |
397 次 |
| 最近记录： |