/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2020, Google Inc. * * exif.cpp - EXIF tag creation using libexif */ #include "exif.h" #include "libcamera/internal/log.h" using namespace libcamera; LOG_DEFINE_CATEGORY(EXIF) /* * List of EXIF tags that we set directly because they are not supported * by libexif version 0.6.21. */ enum class _ExifTag { OFFSET_TIME = 0x9010, OFFSET_TIME_ORIGINAL = 0x9011, OFFSET_TIME_DIGITIZED = 0x9012, }; /* * The Exif class should be instantiated and specific properties set * through the exposed public API. * * Once all desired properties have been set, the user shall call * generate() to process the entries and generate the Exif data. * * Calls to generate() must check the return code to determine if any error * occurred during the construction of the Exif data, and if successful the * data can be obtained using the data() method. */ Exif::Exif() : valid_(false), data_(nullptr), exifData_(0), size_(0) { /* Create an ExifMem allocator to construct entries. */ mem_ = exif_mem_new_default(); if (!mem_) { LOG(EXIF, Error) << "Failed to allocate ExifMem Allocator"; return; } data_ = exif_data_new_mem(mem_); if (!data_) { LOG(EXIF, Error) << "Failed to allocate an ExifData structure"; return; } valid_ = true; exif_data_set_option(data_, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION); exif_data_set_data_type(data_, EXIF_DATA_TYPE_COMPRESSED); /* * Big-Endian: EXIF_BYTE_ORDER_MOTOROLA * Little Endian: EXIF_BYTE_ORDER_INTEL */ exif_data_set_byte_order(data_, EXIF_BYTE_ORDER_INTEL); setString(EXIF_IFD_EXIF, EXIF_TAG_EXIF_VERSION, EXIF_FORMAT_UNDEFINED, "0231"); /* Create the mandatory EXIF fields with default data. */ exif_data_fix(data_); } Exif::~Exif() { if (exifData_) free(exifData_); if (data_) exif_data_unref(data_); if (mem_) exif_mem_unref(mem_); } ExifEntry *Exif::createEntry(ExifIfd ifd, ExifTag tag) { ExifContent *content = data_->ifd[ifd]; ExifEntry *entry = exif_content_get_entry(content, tag); if (entry) { exif_entry_ref(entry); return entry; } entry = exif_entry_new_mem(mem_); if (!entry) { LOG(EXIF, Error) << "Failed to allocated new entry"; valid_ = false; return nullptr; } exif_content_add_entry(content, entry); exif_entry_initialize(entry, tag); return entry; } ExifEntry *Exif::createEntry(ExifIfd ifd, ExifTag tag, ExifFormat format, unsigned long components, unsigned int size) { ExifContent *content = data_->ifd[ifd]; /* Replace any existing entry with the same tag. */ ExifEntry *existing = exif_content_get_entry(content, tag); exif_content_remove_entry(content, existing); ExifEntry *entry = exif_entry_new_mem(mem_); if (!entry) { LOG(EXIF, Error) << "Failed to allocated new entry"; valid_ = false; return nullptr; } void *buffer = exif_mem_alloc(mem_, size); if (!buffer) { LOG(EXIF, Error) << "Failed to allocate buffer for variable entry"; exif_mem_unref(mem_); valid_ = false; return nullptr; } entry->data = static_cast<unsigned char *>(buffer); entry->components = components; entry->format = format; entry->size = size; entry->tag = tag; exif_content_add_entry(content, entry); return entry; } void Exif::setShort(ExifIfd ifd, ExifTag tag, uint16_t item) { ExifEntry *entry = createEntry(ifd, tag); if (!entry) return; exif_set_short(entry->data, EXIF_BYTE_ORDER_INTEL, item); exif_entry_unref(entry); } void Exif::setLong(ExifIfd ifd, ExifTag tag, uint32_t item) { ExifEntry *entry = createEntry(ifd, tag); if (!entry) return; exif_set_long(entry->data, EXIF_BYTE_ORDER_INTEL, item); exif_entry_unref(entry); } void Exif::setRational(ExifIfd ifd, ExifTag tag, ExifRational item) { ExifEntry *entry = createEntry(ifd, tag); if (!entry) return; exif_set_rational(entry->data, EXIF_BYTE_ORDER_INTEL, item); exif_entry_unref(entry); } void Exif::setString(ExifIfd ifd, ExifTag tag, ExifFormat format, const std::string &item) { /* Pad 1 extra byte for null-terminated string in ASCII format. */ size_t length = format == EXIF_FORMAT_ASCII ? item.length() + 1 : item.length(); ExifEntry *entry = createEntry(ifd, tag, format, length, length); if (!entry) return; memcpy(entry->data, item.c_str(), length); exif_entry_unref(entry); } void Exif::setMake(const std::string &make) { setString(EXIF_IFD_0, EXIF_TAG_MAKE, EXIF_FORMAT_ASCII, make); } void Exif::setModel(const std::string &model) { setString(EXIF_IFD_0, EXIF_TAG_MODEL, EXIF_FORMAT_ASCII, model); } void Exif::setSize(const Size &size) { setLong(EXIF_IFD_EXIF, EXIF_TAG_PIXEL_Y_DIMENSION, size.height); setLong(EXIF_IFD_EXIF, EXIF_TAG_PIXEL_X_DIMENSION, size.width); } void Exif::setTimestamp(time_t timestamp) { struct tm tm; localtime_r(×tamp, &tm); char str[20]; strftime(str, sizeof(str), "%Y:%m:%d %H:%M:%S", &tm); std::string ts(str); setString(EXIF_IFD_0, EXIF_TAG_DATE_TIME, EXIF_FORMAT_ASCII, ts); setString(EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_ORIGINAL, EXIF_FORMAT_ASCII, ts); setString(EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_DIGITIZED, EXIF_FORMAT_ASCII, ts); /* Query and set timezone information if available. */ int r = strftime(str, sizeof(str), "%z", &tm); if (r > 0) { std::string tz(str); tz.insert(3, 1, ':'); setString(EXIF_IFD_EXIF, static_cast<ExifTag>(_ExifTag::OFFSET_TIME), EXIF_FORMAT_ASCII, tz); setString(EXIF_IFD_EXIF, static_cast<ExifTag>(_ExifTag::OFFSET_TIME_ORIGINAL), EXIF_FORMAT_ASCII, tz); setString(EXIF_IFD_EXIF, static_cast<ExifTag>(_ExifTag::OFFSET_TIME_DIGITIZED), EXIF_FORMAT_ASCII, tz); } } void Exif::setOrientation(int orientation) { int value; switch (orientation) { case 0: default: value = 1; break; case 90: value = 8; break; case 180: value = 3; break; case 270: value = 6; break; } setShort(EXIF_IFD_0, EXIF_TAG_ORIENTATION, value); } [[nodiscard]] int Exif::generate() { if (exifData_) { free(exifData_); exifData_ = nullptr; } if (!valid_) { LOG(EXIF, Error) << "Generated EXIF data is invalid"; return -1; } exif_data_save_data(data_, &exifData_, &size_); LOG(EXIF, Debug) << "Created EXIF instance (" << size_ << " bytes)"; return 0; }