// ***************************************************************** -*- C++ -*-
/*
* Copyright (C) 2004-2018 Exiv2 authors
* This program is part of the Exiv2 distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
*/
/*
File: rw2image.cpp
Author(s): Andreas Huggel (ahu) <ahuggel@gmx.net>
History: 06-Jan-09, ahu: created
*/
// *****************************************************************************
// included header files
#include "config.h"
#include "rw2image.hpp"
#include "rw2image_int.hpp"
#include "tiffcomposite_int.hpp"
#include "tiffimage_int.hpp"
#include "image.hpp"
#include "preview.hpp"
#include "error.hpp"
#include "futils.hpp"
// + standard includes
#ifdef EXIV2_DEBUG_MESSAGES
# include <iostream>
#endif
// *****************************************************************************
// class member definitions
namespace Exiv2 {
using namespace Internal;
Rw2Image::Rw2Image(BasicIo::AutoPtr io)
: Image(ImageType::rw2, mdExif | mdIptc | mdXmp, io)
{
} // Rw2Image::Rw2Image
std::string Rw2Image::mimeType() const
{
return "image/x-panasonic-rw2";
}
int Rw2Image::pixelWidth() const
{
ExifData::const_iterator imageWidth =
exifData_.findKey(Exiv2::ExifKey("Exif.PanasonicRaw.SensorWidth"));
if (imageWidth != exifData_.end() && imageWidth->count() > 0) {
return imageWidth->toLong();
}
return 0;
}
int Rw2Image::pixelHeight() const
{
ExifData::const_iterator imageHeight =
exifData_.findKey(Exiv2::ExifKey("Exif.PanasonicRaw.SensorHeight"));
if (imageHeight != exifData_.end() && imageHeight->count() > 0) {
return imageHeight->toLong();
}
return 0;
}
void Rw2Image::setExifData(const ExifData& /*exifData*/)
{
// Todo: implement me!
throw(Error(kerInvalidSettingForImage, "Exif metadata", "RW2"));
}
void Rw2Image::setIptcData(const IptcData& /*iptcData*/)
{
// Todo: implement me!
throw(Error(kerInvalidSettingForImage, "IPTC metadata", "RW2"));
}
void Rw2Image::setComment(const std::string& /*comment*/)
{
// not supported
throw(Error(kerInvalidSettingForImage, "Image comment", "RW2"));
}
void Rw2Image::printStructure(std::ostream& out, PrintStructureOption option, int depth) {
out << "RW2 IMAGE" << std::endl;
if (io_->open() != 0) throw Error(kerDataSourceOpenFailed, io_->path(), strError());
// Ensure that this is the correct image type
if ( imageType() == ImageType::none )
if (!isRw2Type(*io_, false)) {
if (io_->error() || io_->eof()) throw Error(kerFailedToReadImageData);
throw Error(kerNotAJpeg);
}
io_->seek(0,BasicIo::beg);
printTiffStructure(io(),out,option,depth-1);
} // Rw2Image::printStructure
void Rw2Image::readMetadata()
{
#ifdef EXIV2_DEBUG_MESSAGES
std::cerr << "Reading RW2 file " << io_->path() << "\n";
#endif
if (io_->open() != 0) {
throw Error(kerDataSourceOpenFailed, io_->path(), strError());
}
IoCloser closer(*io_);
// Ensure that this is the correct image type
if (!isRw2Type(*io_, false)) {
if (io_->error() || io_->eof()) throw Error(kerFailedToReadImageData);
throw Error(kerNotAnImage, "RW2");
}
clearMetadata();
ByteOrder bo = Rw2Parser::decode(exifData_,
iptcData_,
xmpData_,
io_->mmap(),
(uint32_t) io_->size());
setByteOrder(bo);
// A lot more metadata is hidden in the embedded preview image
// Todo: This should go into the Rw2Parser, but for that it needs the Image
PreviewManager loader(*this);
PreviewPropertiesList list = loader.getPreviewProperties();
// Todo: What if there are more preview images?
if (list.size() > 1) {
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "RW2 image contains more than one preview. None used.\n";
#endif
}
if (list.size() != 1) return;
ExifData exifData;
PreviewImage preview = loader.getPreviewImage(*list.begin());
Image::AutoPtr image = ImageFactory::open(preview.pData(), preview.size());
if (image.get() == 0) {
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Failed to open RW2 preview image.\n";
#endif
return;
}
image->readMetadata();
ExifData& prevData = image->exifData();
if (!prevData.empty()) {
// Filter duplicate tags
for (ExifData::const_iterator pos = exifData_.begin(); pos != exifData_.end(); ++pos) {
if (pos->ifdId() == panaRawId) continue;
ExifData::iterator dup = prevData.findKey(ExifKey(pos->key()));
if (dup != prevData.end()) {
#ifdef EXIV2_DEBUG_MESSAGES
std::cerr << "Filtering duplicate tag " << pos->key()
<< " (values '" << pos->value()
<< "' and '" << dup->value() << "')\n";
#endif
prevData.erase(dup);
}
}
}
// Remove tags not applicable for raw images
static const char* filteredTags[] = {
"Exif.Photo.ComponentsConfiguration",
"Exif.Photo.CompressedBitsPerPixel",
"Exif.Panasonic.ColorEffect",
"Exif.Panasonic.Contrast",
"Exif.Panasonic.NoiseReduction",
"Exif.Panasonic.ColorMode",
"Exif.Panasonic.OpticalZoomMode",
"Exif.Panasonic.Contrast",
"Exif.Panasonic.Saturation",
"Exif.Panasonic.Sharpness",
"Exif.Panasonic.FilmMode",
"Exif.Panasonic.SceneMode",
"Exif.Panasonic.WBRedLevel",
"Exif.Panasonic.WBGreenLevel",
"Exif.Panasonic.WBBlueLevel",
"Exif.Photo.ColorSpace",
"Exif.Photo.PixelXDimension",
"Exif.Photo.PixelYDimension",
"Exif.Photo.SceneType",
"Exif.Photo.CustomRendered",
"Exif.Photo.DigitalZoomRatio",
"Exif.Photo.SceneCaptureType",
"Exif.Photo.GainControl",
"Exif.Photo.Contrast",
"Exif.Photo.Saturation",
"Exif.Photo.Sharpness",
"Exif.Image.PrintImageMatching",
"Exif.Image.YCbCrPositioning"
};
for (unsigned int i = 0; i < EXV_COUNTOF(filteredTags); ++i) {
ExifData::iterator pos = prevData.findKey(ExifKey(filteredTags[i]));
if (pos != prevData.end()) {
#ifdef EXIV2_DEBUG_MESSAGES
std::cerr << "Exif tag " << pos->key() << " removed\n";
#endif
prevData.erase(pos);
}
}
// Add the remaining tags
for (ExifData::const_iterator pos = prevData.begin(); pos != prevData.end(); ++pos) {
exifData_.add(*pos);
}
} // Rw2Image::readMetadata
void Rw2Image::writeMetadata()
{
// Todo: implement me!
throw(Error(kerWritingImageFormatUnsupported, "RW2"));
} // Rw2Image::writeMetadata
ByteOrder Rw2Parser::decode(
ExifData& exifData,
IptcData& iptcData,
XmpData& xmpData,
const byte* pData,
uint32_t size
)
{
Rw2Header rw2Header;
return TiffParserWorker::decode(exifData,
iptcData,
xmpData,
pData,
size,
Tag::pana,
TiffMapping::findDecoder,
&rw2Header);
}
// *************************************************************************
// free functions
Image::AutoPtr newRw2Instance(BasicIo::AutoPtr io, bool /*create*/)
{
Image::AutoPtr image(new Rw2Image(io));
if (!image->good()) {
image.reset();
}
return image;
}
bool isRw2Type(BasicIo& iIo, bool advance)
{
const int32_t len = 24;
byte buf[len];
iIo.read(buf, len);
if (iIo.error() || iIo.eof()) {
return false;
}
Rw2Header header;
bool rc = header.read(buf, len);
if (!advance || !rc) {
iIo.seek(-len, BasicIo::cur);
}
return rc;
}
} // namespace Exiv2