在 Go 中将元数据从一个 JPEG 复制到另一个

目前golang学习网上已经有很多关于Golang的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《在 Go 中将元数据从一个 JPEG 复制到另一个》，也希望能帮助到大家，如果阅读完后真的对你学习Golang有帮助，欢迎动动手指，评论留言并分享~

我正在尝试将 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
}

检查结果文件，代码似乎执行了我之前描述的操作。

左上角是标签的来源。左下角是图像来源。右边是结果。

有人知道我错过了什么吗？谢谢。

正确答案

事实证明这比预想的要困难。我参考了 this resource，它解释了 jpeg 作为段流的一般结构，唯一的例外是保存实际图像数据的“熵编码段”(ecs)。

您的方法存在问题

我的想法是复制标签源文件中的所有内容，直到排除第一个 ffdb 为止，然后从包含的第一个 ffdb 开始复制图像源文件（没有标签）中的所有内容。生成的文件已损坏（缺少 sos 标记）。

这对 jpeg 文件做出了非常强烈的假设，但这是不成立的。首先，ffdb 很可能出现在段内的某个位置。段的顺序也非常松散，因此您无法保证 ffdb （定义量化表的段）之前或之后的内容。即使它在大多数情况下确实有效，它仍然是一个非常脆弱、不可靠的解决方案。

正确的方法

正确的方法是迭代所有片段，仅从提供元数据的文件中复制元数据片段，并且仅从提供图像数据的文件中复制非元数据片段。

使事情变得复杂的是，由于某种原因，ecs 不遵循段约定。因此，在读取 sos（扫描开始）后，我们需要通过查找下一个段标记跳到 ecs 的末尾： 0xff 后跟一个既不是数据（零）也不是“重新启动标记”的字节（0xd0 - 0xd7 ）。

为了进行测试，我使用了 this image with EXIF metadata。我的测试命令如下所示：

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 的输出进行比较（旁注：您可能可以通过使用 exiftool 完全废弃这个 go 程序）。

我编写的程序替换了 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())
    }
}

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。