You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
401 lines
14 KiB
C++
401 lines
14 KiB
C++
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
// included header files
|
|
#include "rafimage.hpp"
|
|
|
|
#include "basicio.hpp"
|
|
#include "config.h"
|
|
#include "enforce.hpp"
|
|
#include "error.hpp"
|
|
#include "futils.hpp"
|
|
#include "image.hpp"
|
|
#include "image_int.hpp"
|
|
#include "jpgimage.hpp"
|
|
#include "safe_op.hpp"
|
|
#include "tiffimage.hpp"
|
|
|
|
#include <cinttypes>
|
|
#include <iostream>
|
|
|
|
// *****************************************************************************
|
|
// class member definitions
|
|
namespace Exiv2 {
|
|
RafImage::RafImage(BasicIo::UniquePtr io, bool /*create*/) :
|
|
Image(ImageType::raf, mdExif | mdIptc | mdXmp, std::move(io)) {
|
|
} // RafImage::RafImage
|
|
|
|
std::string RafImage::mimeType() const {
|
|
return "image/x-fuji-raf";
|
|
}
|
|
|
|
uint32_t RafImage::pixelWidth() const {
|
|
if (pixelWidth_ != 0)
|
|
return pixelWidth_;
|
|
|
|
auto widthIter = exifData_.findKey(Exiv2::ExifKey("Exif.Fujifilm.RawImageFullWidth"));
|
|
if (widthIter == exifData_.end() || widthIter->count() == 0)
|
|
return 0;
|
|
return widthIter->toUint32();
|
|
}
|
|
|
|
uint32_t RafImage::pixelHeight() const {
|
|
if (pixelHeight_ != 0)
|
|
return pixelHeight_;
|
|
|
|
auto heightIter = exifData_.findKey(Exiv2::ExifKey("Exif.Fujifilm.RawImageFullHeight"));
|
|
if (heightIter == exifData_.end() || heightIter->count() == 0)
|
|
return 0;
|
|
return heightIter->toUint32();
|
|
}
|
|
|
|
void RafImage::setExifData(const ExifData& /*exifData*/) {
|
|
// Todo: implement me!
|
|
throw(Error(ErrorCode::kerInvalidSettingForImage, "Exif metadata", "RAF"));
|
|
}
|
|
|
|
void RafImage::setIptcData(const IptcData& /*iptcData*/) {
|
|
// Todo: implement me!
|
|
throw(Error(ErrorCode::kerInvalidSettingForImage, "IPTC metadata", "RAF"));
|
|
}
|
|
|
|
void RafImage::setComment(const std::string&) {
|
|
// not supported
|
|
throw(Error(ErrorCode::kerInvalidSettingForImage, "Image comment", "RAF"));
|
|
}
|
|
|
|
void RafImage::printStructure(std::ostream& out, PrintStructureOption option, size_t depth) {
|
|
if (io_->open() != 0) {
|
|
throw Error(ErrorCode::kerDataSourceOpenFailed, io_->path(), strError());
|
|
}
|
|
// Ensure this is the correct image type
|
|
if (!isRafType(*io_, true)) {
|
|
if (io_->error() || io_->eof())
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
throw Error(ErrorCode::kerNotAnImage, "RAF");
|
|
}
|
|
|
|
// The following is based on https://libopenraw.freedesktop.org/formats/raf/ and
|
|
// https://exiftool.org/TagNames/FujiFilm.html#RAFHeader
|
|
|
|
const bool bPrint = option == kpsBasic || option == kpsRecursive;
|
|
if (bPrint) {
|
|
io_->seek(0, BasicIo::beg); // rewind
|
|
size_t address = io_->tell();
|
|
constexpr auto format = " %9zu | %9" PRIu32 " | ";
|
|
|
|
{
|
|
out << Internal::indent(depth) << "STRUCTURE OF RAF FILE: " << io().path() << '\n';
|
|
out << Internal::indent(depth) << " Address | Length | Payload" << '\n';
|
|
}
|
|
|
|
byte magicdata[17];
|
|
io_->readOrThrow(magicdata, 16);
|
|
magicdata[16] = 0;
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, 16U) // 0
|
|
<< " magic : " << reinterpret_cast<char*>(magicdata) << '\n';
|
|
}
|
|
|
|
address = io_->tell();
|
|
byte data1[5];
|
|
io_->read(data1, 4);
|
|
data1[4] = 0;
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, 4U) // 16
|
|
<< " data1 : " << std::string(reinterpret_cast<char*>(&data1)) << '\n';
|
|
}
|
|
|
|
address = io_->tell();
|
|
byte data2[9];
|
|
io_->read(data2, 8);
|
|
data2[8] = 0;
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, 8U) // 20
|
|
<< " data2 : " << std::string(reinterpret_cast<char*>(&data2)) << '\n';
|
|
}
|
|
|
|
address = io_->tell();
|
|
byte camdata[33];
|
|
io_->read(camdata, 32);
|
|
camdata[32] = 0;
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, 32U) // 28
|
|
<< " camera : " << std::string(reinterpret_cast<char*>(&camdata)) << '\n';
|
|
}
|
|
|
|
address = io_->tell();
|
|
byte dir_version[5];
|
|
io_->read(dir_version, 4);
|
|
dir_version[4] = 0;
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, 4U) // 60
|
|
<< " version : " << std::string(reinterpret_cast<char*>(&dir_version)) << '\n';
|
|
}
|
|
|
|
address = io_->tell();
|
|
DataBuf unknown(20);
|
|
io_->readOrThrow(unknown.data(), unknown.size());
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, 20U)
|
|
<< " unknown : " << Internal::binaryToString(makeSlice(unknown, 0, unknown.size())) << '\n';
|
|
}
|
|
|
|
address = io_->tell();
|
|
byte jpg_img_offset[4];
|
|
io_->read(jpg_img_offset, 4);
|
|
byte jpg_img_length[4];
|
|
size_t address2 = io_->tell();
|
|
io_->read(jpg_img_length, 4);
|
|
|
|
uint32_t jpg_img_off = Exiv2::getULong(jpg_img_offset, bigEndian);
|
|
uint32_t jpg_img_len = Exiv2::getULong(jpg_img_length, bigEndian);
|
|
{
|
|
std::stringstream j_off;
|
|
std::stringstream j_len;
|
|
j_off << jpg_img_off;
|
|
j_len << jpg_img_len;
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, 4U) << " JPEG offset : " << j_off.str()
|
|
<< '\n';
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address2, 4U) << " JPEG length : " << j_len.str()
|
|
<< '\n';
|
|
}
|
|
|
|
// RAFs can carry the payload in one or two parts
|
|
uint32_t meta_off[2], meta_len[2];
|
|
uint32_t cfa_off[2], cfa_len[2], comp[2], cfa_size[2], cfa_data[2];
|
|
for (size_t i = 0; i < 2; i++) {
|
|
address = io_->tell();
|
|
byte data[4];
|
|
io_->readOrThrow(data, 4);
|
|
meta_off[i] = Exiv2::getULong(data, bigEndian);
|
|
address2 = io_->tell();
|
|
io_->readOrThrow(data, 4);
|
|
meta_len[i] = Exiv2::getULong(data, bigEndian);
|
|
{
|
|
std::stringstream c_off;
|
|
std::stringstream c_len;
|
|
c_off << meta_off[i];
|
|
c_len << meta_len[i];
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, 4U) << "meta offset" << i + 1 << " : "
|
|
<< c_off.str() << '\n';
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address2, 4U) << "meta length" << i + 1
|
|
<< " : " << c_len.str() << '\n';
|
|
}
|
|
|
|
address = io_->tell();
|
|
io_->readOrThrow(data, 4);
|
|
cfa_off[i] = Exiv2::getULong(data, bigEndian);
|
|
address2 = io_->tell();
|
|
io_->readOrThrow(data, 4);
|
|
cfa_len[i] = Exiv2::getULong(data, bigEndian);
|
|
size_t address3 = io_->tell();
|
|
io_->readOrThrow(data, 4);
|
|
comp[i] = Exiv2::getULong(data, bigEndian);
|
|
size_t address4 = io_->tell();
|
|
io_->readOrThrow(data, 4);
|
|
cfa_size[i] = Exiv2::getULong(data, bigEndian);
|
|
size_t address5 = io_->tell();
|
|
io_->readOrThrow(data, 4);
|
|
cfa_data[i] = Exiv2::getULong(data, bigEndian);
|
|
{
|
|
std::stringstream c_off;
|
|
std::stringstream c_len;
|
|
std::stringstream c_comp;
|
|
std::stringstream c_size;
|
|
std::stringstream c_data;
|
|
c_off << cfa_off[i];
|
|
c_len << cfa_len[i];
|
|
c_comp << comp[i];
|
|
c_size << cfa_size[i];
|
|
c_data << cfa_data[i];
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, 4U) << " CFA offset" << i + 1 << " : "
|
|
<< c_off.str() << '\n';
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address2, 4U) << " CFA length" << i + 1
|
|
<< " : " << c_len.str() << '\n';
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address3, 4U) << "compression" << i + 1
|
|
<< " : " << c_comp.str() << '\n';
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address4, 4U) << " CFA chunk" << i + 1
|
|
<< " : " << c_size.str() << '\n';
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address5, 4U) << " unknown" << i + 1
|
|
<< " : " << c_data.str() << '\n';
|
|
}
|
|
}
|
|
|
|
io_->seek(jpg_img_off, BasicIo::beg); // rewind
|
|
address = io_->tell();
|
|
DataBuf payload(16); // header is different from chunks
|
|
io_->readOrThrow(payload.data(), payload.size());
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, jpg_img_len)
|
|
<< " JPEG data : " << Internal::binaryToString(makeSlice(payload, 0, payload.size())) << '\n';
|
|
}
|
|
|
|
io_->seek(meta_off[0], BasicIo::beg); // rewind
|
|
address = io_->tell();
|
|
io_->readOrThrow(payload.data(), payload.size());
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, meta_len[0])
|
|
<< " meta data1 : " << Internal::binaryToString(makeSlice(payload, 0, payload.size())) << '\n';
|
|
}
|
|
|
|
if (meta_off[1] && meta_len[1]) {
|
|
io_->seek(meta_off[1], BasicIo::beg); // rewind
|
|
address = io_->tell();
|
|
io_->readOrThrow(payload.data(), payload.size());
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, meta_len[1])
|
|
<< " meta data2 : " << Internal::binaryToString(makeSlice(payload, 0, payload.size())) << '\n';
|
|
}
|
|
}
|
|
|
|
io_->seek(cfa_off[0], BasicIo::beg); // rewind
|
|
address = io_->tell();
|
|
io_->readOrThrow(payload.data(), payload.size());
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, cfa_len[0])
|
|
<< " CFA data1 : " << Internal::binaryToString(makeSlice(payload, 0, payload.size())) << '\n';
|
|
}
|
|
|
|
if (cfa_off[1] && cfa_len[1]) {
|
|
io_->seek(cfa_off[1], BasicIo::beg); // rewind
|
|
address = io_->tell();
|
|
io_->readOrThrow(payload.data(), payload.size());
|
|
{
|
|
out << Internal::indent(depth) << Internal::stringFormat(format, address, cfa_len[1]) // cfa_off
|
|
<< " CFA data2 : " << Internal::binaryToString(makeSlice(payload, 0, payload.size())) << '\n';
|
|
}
|
|
}
|
|
}
|
|
} // RafImage::printStructure
|
|
|
|
void RafImage::readMetadata() {
|
|
#ifdef EXIV2_DEBUG_MESSAGES
|
|
std::cerr << "Reading RAF file " << io_->path() << "\n";
|
|
#endif
|
|
if (io_->open() != 0)
|
|
throw Error(ErrorCode::kerDataSourceOpenFailed, io_->path(), strError());
|
|
IoCloser closer(*io_);
|
|
// Ensure that this is the correct image type
|
|
if (!isRafType(*io_, false)) {
|
|
if (io_->error() || io_->eof())
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
throw Error(ErrorCode::kerNotAnImage, "RAF");
|
|
}
|
|
|
|
clearMetadata();
|
|
|
|
if (io_->seek(84, BasicIo::beg) != 0)
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
byte jpg_img_offset[4];
|
|
if (io_->read(jpg_img_offset, 4) != 4)
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
byte jpg_img_length[4];
|
|
if (io_->read(jpg_img_length, 4) != 4)
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
uint32_t jpg_img_off_u32 = Exiv2::getULong(jpg_img_offset, bigEndian);
|
|
uint32_t jpg_img_len_u32 = Exiv2::getULong(jpg_img_length, bigEndian);
|
|
|
|
Internal::enforce(Safe::add(jpg_img_off_u32, jpg_img_len_u32) <= io_->size(), ErrorCode::kerCorruptedMetadata);
|
|
|
|
auto jpg_img_off = static_cast<long>(jpg_img_off_u32);
|
|
auto jpg_img_len = static_cast<long>(jpg_img_len_u32);
|
|
|
|
Internal::enforce(jpg_img_len >= 12, ErrorCode::kerCorruptedMetadata);
|
|
|
|
DataBuf jpg_buf(jpg_img_len);
|
|
if (io_->seek(jpg_img_off, BasicIo::beg) != 0)
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
|
|
if (!jpg_buf.empty()) {
|
|
io_->read(jpg_buf.data(), jpg_buf.size());
|
|
if (io_->error() || io_->eof())
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
}
|
|
|
|
// Retrieve metadata from embedded JPEG preview image.
|
|
try {
|
|
auto jpg_io = std::make_unique<Exiv2::MemIo>(jpg_buf.data(), jpg_buf.size());
|
|
auto jpg_img = JpegImage(std::move(jpg_io), false);
|
|
jpg_img.readMetadata();
|
|
setByteOrder(jpg_img.byteOrder());
|
|
xmpData_ = jpg_img.xmpData();
|
|
exifData_ = jpg_img.exifData();
|
|
iptcData_ = jpg_img.iptcData();
|
|
comment_ = jpg_img.comment();
|
|
} catch (const Exiv2::Error&) {
|
|
}
|
|
|
|
exifData_["Exif.Image2.JPEGInterchangeFormat"] = getULong(jpg_img_offset, bigEndian);
|
|
exifData_["Exif.Image2.JPEGInterchangeFormatLength"] = getULong(jpg_img_length, bigEndian);
|
|
|
|
// Todo: parse the proprietary metadata structure
|
|
// at offset 92 for pixelWidth_ & pixelHeight_
|
|
// See https://libopenraw.freedesktop.org/formats/raf/
|
|
// and https://exiftool.org/TagNames/FujiFilm.html#RAF
|
|
|
|
// parse the tiff
|
|
byte readBuff[4];
|
|
if (io_->seek(100, BasicIo::beg) != 0)
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
if (io_->read(readBuff, 4) != 4)
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
uint32_t tiffOffset = Exiv2::getULong(readBuff, bigEndian);
|
|
|
|
if (io_->read(readBuff, 4) != 4)
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
uint32_t tiffLength = Exiv2::getULong(readBuff, bigEndian);
|
|
|
|
// sanity check. Does tiff lie inside the file?
|
|
Internal::enforce(Safe::add(tiffOffset, tiffLength) <= io_->size(), ErrorCode::kerCorruptedMetadata);
|
|
|
|
if (io_->seek(tiffOffset, BasicIo::beg) != 0)
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
|
|
// Check if this really is a tiff and then call the tiff parser.
|
|
// Check is needed because some older models just embed a raw bitstream.
|
|
// For those files we skip the parsing step.
|
|
if (io_->read(readBuff, 4) != 4) {
|
|
throw Error(ErrorCode::kerFailedToReadImageData);
|
|
}
|
|
io_->seek(-4, BasicIo::cur);
|
|
if (memcmp(readBuff, "\x49\x49\x2A\x00", 4) == 0 || memcmp(readBuff, "\x4D\x4D\x00\x2A", 4) == 0) {
|
|
DataBuf tiff(tiffLength);
|
|
io_->read(tiff.data(), tiff.size());
|
|
|
|
if (!io_->error() && !io_->eof()) {
|
|
TiffParser::decode(exifData_, iptcData_, xmpData_, tiff.c_data(), tiff.size());
|
|
}
|
|
}
|
|
}
|
|
|
|
void RafImage::writeMetadata() {
|
|
//! Todo: implement me!
|
|
throw(Error(ErrorCode::kerWritingImageFormatUnsupported, "RAF"));
|
|
} // RafImage::writeMetadata
|
|
|
|
// *************************************************************************
|
|
// free functions
|
|
Image::UniquePtr newRafInstance(BasicIo::UniquePtr io, bool create) {
|
|
auto image = std::make_unique<RafImage>(std::move(io), create);
|
|
if (!image->good()) {
|
|
return nullptr;
|
|
}
|
|
return image;
|
|
}
|
|
|
|
bool isRafType(BasicIo& iIo, bool advance) {
|
|
const int32_t len = 8;
|
|
byte buf[len];
|
|
iIo.read(buf, len);
|
|
if (iIo.error() || iIo.eof()) {
|
|
return false;
|
|
}
|
|
int rc = memcmp(buf, "FUJIFILM", 8);
|
|
if (!advance || rc != 0) {
|
|
iIo.seek(-len, BasicIo::cur);
|
|
}
|
|
return rc == 0;
|
|
}
|
|
|
|
} // namespace Exiv2
|