geeqie: src/exiv2.cc comparison

comparison src/exiv2.cc @ 1069:aeae25d5d50d

infrastructure for preprocessing of metadata

author	nadvornik
date	Sat, 18 Oct 2008 18:22:57 +0000
parents	90dcc0060e22
children	abf48b53216b

comparison

equal deleted inserted replaced

-:e67636316f4c
+:aeae25d5d50d
 #include "ui_fileops.h"
 }
 struct _ExifData
 {
-	Exiv2::Image::AutoPtr image;
-	Exiv2::Image::AutoPtr sidecar;
 	Exiv2::ExifData::const_iterator exifIter; /* for exif_get_next_item */
 	Exiv2::IptcData::const_iterator iptcIter; /* for exif_get_next_item */
 #if EXIV2_TEST_VERSION(0,16,0)
 	Exiv2::XmpData::const_iterator xmpIter; /* for exif_get_next_item */
 #endif
-	bool have_sidecar;
+	virtual ~_ExifData()
+	{
+	}
+	virtual void writeMetadata()
+	{
+		g_critical("Unsupported method of writing metadata");
+	}
+	virtual ExifData *original()
+	{
+		return NULL;
+	}
+	virtual Exiv2::Image *image() = 0;
+	virtual Exiv2::ExifData &exifData() = 0;
+	virtual Exiv2::IptcData &iptcData() = 0;
+#if EXIV2_TEST_VERSION(0,16,0)
+	virtual Exiv2::XmpData &xmpData() = 0;
+#endif
+	virtual void add_jpeg_color_profile(unsigned char *cp_data, guint cp_length) = 0;
+	virtual guchar *get_jpeg_color_profile(guint *data_len) = 0;
+};
+// This allows read-only access to the original metadata
+struct _ExifDataOriginal : public _ExifData
+{
+protected:
+	Exiv2::Image::AutoPtr image_;
 	/* the icc profile in jpeg is not technically exif - store it here */
-	unsigned char *cp_data;
+	unsigned char *cp_data_;
-	guint cp_length;
+	guint cp_length_;
-	_ExifData(gchar *path, gchar *sidecar_path)
+public:
-	{
-		have_sidecar = false;
+	_ExifDataOriginal(gchar *path)
-		cp_data = NULL;
+	{
-		cp_length = 0;
+		cp_data_ = NULL;
+		cp_length_ = 0;
 		gchar *pathl = path_from_utf8(path);
-		image = Exiv2::ImageFactory::open(pathl);
+		image_ = Exiv2::ImageFactory::open(pathl);
 		g_free(pathl);
 //		g_assert (image.get() != 0);
-		image->readMetadata();
+		image_->readMetadata();
 #if EXIV2_TEST_VERSION(0,16,0)
-		DEBUG_2("xmp count %li", image->xmpData().count());
+		if (image_->mimeType() == "application/rdf+xml")
-		if (sidecar_path && image->xmpData().empty())
+			{
-			{
+			//Exiv2 sidecar converts xmp to exif and iptc, we don't want it.
-			gchar *sidecar_pathl = path_from_utf8(sidecar_path);
+			image_->clearExifData();
-			sidecar = Exiv2::ImageFactory::open(sidecar_pathl);
+			image_->clearIptcData();
-			g_free(sidecar_pathl);
+			}
-			sidecar->readMetadata();
+#endif
-			have_sidecar = sidecar->good();
-			DEBUG_2("sidecar xmp count %li", sidecar->xmpData().count());
-			}
-#endif
 #if EXIV2_TEST_VERSION(0,14,0)
-		if (image->mimeType() == std::string("image/jpeg"))
+		if (image_->mimeType() == "image/jpeg")
 			{
 			/* try to get jpeg color profile */
-			Exiv2::BasicIo &io = image->io();
+			Exiv2::BasicIo &io = image_->io();
 			gint open = io.isopen();
 			if (!open) io.open();
 			unsigned char *mapped = (unsigned char*)io.mmap();
 			if (mapped) exif_jpeg_parse_color(this, mapped, io.size());
 			io.munmap();
 			if (!open) io.close();
 			}
 #endif
 	}
-	~_ExifData()
+	virtual ~_ExifDataOriginal()
 	{
-		if (cp_data) g_free(cp_data);
+		if (cp_data_) g_free(cp_data_);
 	}
-	void writeMetadata()
+	virtual Exiv2::Image *image()
 	{
-		if (have_sidecar) sidecar->writeMetadata();
+		return image_.get();
-		image->writeMetadata();
+	}
-	}
+	virtual Exiv2::ExifData &exifData ()
-	Exiv2::ExifData &exifData ()
+	{
-	{
+		return image_->exifData();
-		return image->exifData();
+	}
-	}
+	virtual Exiv2::IptcData &iptcData ()
-	Exiv2::IptcData &iptcData ()
+	{
-	{
+		return image_->iptcData();
-		return image->iptcData();
+	}
-	}
+#if EXIV2_TEST_VERSION(0,16,0)
-#if EXIV2_TEST_VERSION(0,16,0)
+	virtual Exiv2::XmpData &xmpData ()
-	Exiv2::XmpData &xmpData ()
+	{
-	{
+		return image_->xmpData();
-		return have_sidecar ? sidecar->xmpData() : image->xmpData();
+	}
-	}
+#endif
-#endif
+	virtual void add_jpeg_color_profile(unsigned char *cp_data, guint cp_length)
+	{
+		if (cp_data_) g_free(cp_data_);
+		cp_data_ = cp_data;
+		cp_length_ = cp_length;
+	}
+	virtual guchar *get_jpeg_color_profile(guint *data_len)
+	{
+		if (cp_data_)
+		{
+			if (data_len) *data_len = cp_length_;
+			return (unsigned char *) g_memdup(cp_data_, cp_length_);
+		}
+		return NULL;
+	}
 };
+// This allows read-write access to the metadata
+struct _ExifDataProcessed : public _ExifData
+{
+protected:
+	_ExifDataOriginal *imageData_;
+	_ExifDataOriginal *sidecarData_;
+	Exiv2::ExifData exifData_;
+	Exiv2::IptcData iptcData_;
+#if EXIV2_TEST_VERSION(0,16,0)
+	Exiv2::XmpData xmpData_;
+#endif
+public:
+	_ExifDataProcessed(gchar *path, gchar *sidecar_path)
+	{
+		imageData_ = new _ExifDataOriginal(path);
+		sidecarData_ = NULL;
+#if EXIV2_TEST_VERSION(0,16,0)
+		xmpData_ = imageData_->xmpData();
+		DEBUG_2("xmp count %li", xmpData_.count());
+		if (sidecar_path && xmpData_.empty())
+			{
+			sidecarData_ = new _ExifDataOriginal(sidecar_path);
+			xmpData_ = sidecarData_->xmpData();
+			}
+#endif
+		exifData_ = imageData_->exifData();
+		iptcData_ = imageData_->iptcData();
+	}
+	virtual ~_ExifDataProcessed()
+	{
+		if (imageData_) delete imageData_;
+		if (sidecarData_) delete sidecarData_;
+	}
+	virtual ExifData *original()
+	{
+		return imageData_;
+	}
+	virtual void writeMetadata()
+	{
+		if (sidecarData_)
+			{
+			sidecarData_->image()->setXmpData(xmpData_);
+			//Exiv2 sidecar converts xmp to exif and iptc, we don't want it.
+			sidecarData_->image()->clearExifData();
+			sidecarData_->image()->clearIptcData();
+			sidecarData_->image()->writeMetadata();
+			}
+		else
+			{
+			imageData_->image()->setExifData(exifData_);
+			imageData_->image()->setIptcData(iptcData_);
+			imageData_->image()->setXmpData(xmpData_);
+			imageData_->image()->writeMetadata();
+			}
+	}
+	virtual Exiv2::Image *image()
+	{
+		return imageData_->image();
+	}
+	virtual Exiv2::ExifData &exifData ()
+	{
+		return exifData_;
+	}
+	virtual Exiv2::IptcData &iptcData ()
+	{
+		return iptcData_;
+	}
+#if EXIV2_TEST_VERSION(0,16,0)
+	virtual Exiv2::XmpData &xmpData ()
+	{
+		return xmpData_;
+	}
+#endif
+	virtual void add_jpeg_color_profile(unsigned char *cp_data, guint cp_length)
+	{
+		imageData_->add_jpeg_color_profile(cp_data, cp_length);
+	}
+	virtual guchar *get_jpeg_color_profile(guint *data_len)
+	{
+		return imageData_->get_jpeg_color_profile(data_len);
+	}
+};
 extern "C" {
 ExifData *exif_read(gchar *path, gchar *sidecar_path)
 {
 	DEBUG_1("exif read %s, sidecar: %s", path, sidecar_path ? sidecar_path : "-");
 	try {
-		return new ExifData(path, sidecar_path);
+		return new _ExifDataProcessed(path, sidecar_path);
 	}
 	catch (Exiv2::AnyError& e) {
 		std::cout << "Caught Exiv2 exception '" << e << "'\n";
 		return NULL;
 	}
 }
 void exif_free(ExifData *exif)
 {
+	g_assert(dynamic_cast<_ExifDataProcessed *>(exif)); // this should not be called on ExifDataOriginal
 	delete exif;
 }
+ExifData *exif_get_original(ExifData *exif)
+{
+	return exif->original();
+}
 ExifItem *exif_get_item(ExifData *exif, const gchar *key)
 {
 	try {
 		Exiv2::Metadatum *item = NULL;
 	}
 }
 void exif_add_jpeg_color_profile(ExifData *exif, unsigned char *cp_data, guint cp_length)
 {
-	if (exif->cp_data) g_free(exif->cp_data);
+	exif->add_jpeg_color_profile(cp_data, cp_length);
-	exif->cp_data = cp_data;
-	exif->cp_length =cp_length;
 }
 guchar *exif_get_color_profile(ExifData *exif, guint *data_len)
 {
-	if (exif->cp_data)
+	guchar *ret = exif->get_jpeg_color_profile(data_len);
-		{
+	if (ret) return ret;
-		if (data_len) *data_len = exif->cp_length;
-		return (unsigned char *) g_memdup(exif->cp_data, exif->cp_length);
-		}
 	ExifItem *prof_item = exif_get_item(exif, "Exif.Image.InterColorProfile");
 	if (prof_item && exif_item_get_format_id(prof_item) == EXIF_FORMAT_UNDEFINED)
-		return (unsigned char *) exif_item_get_data(prof_item, data_len);
+		ret = (guchar *)exif_item_get_data(prof_item, data_len);
-	return NULL;
+	return ret;
 }
 #if EXIV2_TEST_VERSION(0,17,90)
 guchar *exif_get_preview(ExifData *exif, guint *data_len, gint requested_width, gint requested_height)
 {
 	if (!exif) return NULL;
-	const char* path = exif->image->io().path().c_str();
+	const char* path = exif->image()->io().path().c_str();
 	/* given image pathname, first do simple (and fast) file extension test */
 	gboolean is_raw = filter_file_class(path, FORMAT_CLASS_RAWIMAGE);
 	if (!is_raw && requested_width == 0) return NULL;
 	try {
-		Exiv2::PreviewManager pm(*exif->image);
+		Exiv2::PreviewManager pm(*exif->image());
 		Exiv2::PreviewPropertiesList list = pm.getPreviewProperties();
 		if (!list.empty())
 			{
 extern "C" guchar *exif_get_preview(ExifData *exif, guint *data_len, gint requested_width, gint requested_height)
 {
 	unsigned long offset;
 	if (!exif) return NULL;
-	const char* path = exif->image->io().path().c_str();
+	const char* path = exif->image()->io().path().c_str();
 	/* given image pathname, first do simple (and fast) file extension test */
 	if (!filter_file_class(path, FORMAT_CLASS_RAWIMAGE)) return NULL;
 	try {
 		guchar *map_data;
 		size_t map_len;
 		UnmapData *ud;
 		int fd;
-		RawFile rf(exif->image->io());
+		RawFile rf(exif->image()->io());
 		offset = rf.preview_offset();
 		DEBUG_1("%s: offset %lu", path, offset);
 		fd = open(path, O_RDONLY);
 		if (fd == -1)

Mercurial > geeqie

comparison src/exiv2.cc @ 1069:aeae25d5d50d