Скопируйте метаданные из одного JPEG в другой в Go

Я пытаюсь скопировать теги EXIF ​​​​из одного JPEG в другой, у которого нет метаданных. Пытался сделать то, что описано в этом комментарии.

Моя идея состоит в том, чтобы скопировать все из исходного файла тегов до первого исключенного ffdb, а затем скопировать все из исходного файла изображения (в котором нет тегов), начиная с первого включенного ffdb. Результирующий файл поврежден (отсутствует маркер SOS).

Полный репродуктор, включая предложение Луатика, доступен по адресу 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
}

При проверке файлов результатов кажется, что код делает то, что я описал ранее.

Вверху слева источник тегов. В левом нижнем углу источник изображения. Справа результат.

Кто-нибудь знает, что мне не хватает? Спасибо.

Не могли бы вы предоставить изображения, которые вы тестируете?

Luatic 27.07.2023 11:36

Кроме того, не могли бы вы уточнить, что вы подразумеваете под «копировать метаданные»? Если у обоих изображений есть метаданные, следует ли полностью отбросить «старые» метаданные и заменить их новыми метаданными? Вас интересуют только EXIF ​​или также уведомления об авторских правах и комментарии?

Luatic 27.07.2023 11:39

Второе изображение вообще не имеет метаданных. Вы можете использовать любой jpeg с exif в качестве источника для exif и любой jpeg, написанный jpeg.Encode, в качестве источника данных изображения. Я обновлю вопрос полным примером.

neclepsio 27.07.2023 11:55

Я добавил полный репродуктор, доступный по адресу go.dev/play/p/9BLjuZk5qlr. Просто запустите его в папке, содержащей test.jpg с тегами.

neclepsio 27.07.2023 12:19
Создание API ввода вопросов на разных языках программирования (Python, PHP, Go и Node.js)
Создание API ввода вопросов на разных языках программирования (Python, PHP, Go и Node.js)
API ввода вопросов - это полезный инструмент для интеграции моделей машинного обучения, таких как ChatGPT, в приложения, требующие обработки...
5
4
82
1
Перейти к ответу Данный вопрос помечен как решенный

Ответы 1

Ответ принят как подходящий

Это оказывается сложнее, чем ожидалось. Я сослался на этот ресурс, который объясняет общую структуру 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())
    }
}

Спасибо за ваши большие усилия! Что-то еще не так. Мой подход к удалению метаданных заключается в простом декодировании и перекодировании с помощью пакета изображений, в этом случае при повторном чтении с использованием вашего тестового изображения я получаю: «недопустимый формат JPEG: короткие данные Хаффмана». Используя свое изображение, я получаю: «EOF ожидается после EOI». Я отлажу и отчитаюсь. Еще раз спасибо!

neclepsio 27.07.2023 15:06

Пожалуйста! Теперь это странно, мой просмотрщик изображений и exiftool не жалуются. Я тестировал Python Pillow и Java ImageIO, и оба, кажется, принимают exif_stripped.jpg, но я могу подтвердить, что jpeg.Decode Go выдает эту ошибку. Я посмотрю - либо многие декодеры JPEG здесь слишком снисходительны, либо Go слишком строг.

Luatic 27.07.2023 16:21

@neclepsio нашел, забыл сбросить писателя 😅. Замена return nil на return writer.Flush() в copyMetadata помогает. Мне фактически не хватало буфера в конце файла, поэтому EOI и т. д. отсутствовали. Я очень удивлен тем, что Pillow, ImageIO, средства просмотра изображений и т. д. даже не выводят предупреждение, и я приятно удивлен тем, что Go! Забавный факт: попытка удалить метаданные из exif_stripped.jpg после обработки привела к ошибке, а простое чтение — нет. Безумно мягкое программное обеспечение.

Luatic 27.07.2023 18:02

Спасибо! Приложение камеры Pixel 4a добавляет данные после EOI, поэтому я также удалил проверку EOF после EOI.

neclepsio 28.07.2023 09:47

Другие вопросы по теме