コード例 #1
0
ファイル: metadata_exiv2.cpp プロジェクト: MaiTiano/fuppes
int exiv2_metadata_file_open(plugin_info* plugin, const char* fileName)
{
	try
	{
		Image::AutoPtr image = Exiv2::ImageFactory::open(fileName);
		
		if(!image->good())
		{
//		cerr << "Image could not be read by Exiv2: " << fileName << endl;
			return -1;
		}
		
		image->readMetadata();
		
		if(image->exifData().empty()) // && image->iptcData().empty())
		{
//		cout << "Image had no EXIF/IPTC metadata: " << fileName << endl;
			return -1;
		}
		
	    plugin->user_data = new Image::AutoPtr(image);	
	}
	catch(...)
	{
		cerr << "Exception in Exiv2 Metadata plugin" << endl;
		return -1;
	}
	
	return 0;
}
コード例 #2
0
ファイル: image.cpp プロジェクト: wjbeaver/Hide-Seep
 Image::AutoPtr ImageFactory::open(const byte* data, long size)
 {
     BasicIo::AutoPtr io(new MemIo(data, size));
     Image::AutoPtr image = open(io); // may throw
     if (image.get() == 0) throw Error(12);
     return image;
 }
コード例 #3
0
ファイル: iptctest.cpp プロジェクト: 007durgesh219/nomacs
// *****************************************************************************
// Main
int main(int argc, char* const argv[])
{
    try {

        if (argc != 2) {
            std::cout << "Usage: " << argv[0] << " image\n";
            std::cout << "Commands read from stdin.\n";
            return 1;
        }

        Image::AutoPtr image = ImageFactory::open(argv[1]);
        assert (image.get() != 0);
        image->readMetadata();

        // Process commands
        std::string line;
        int num = 0;
        std::getline(std::cin, line);
        while (line.length() && processLine(line, ++num, image->iptcData())) {
            std::getline(std::cin, line);
        }

        // Save any changes
        image->writeMetadata();

        return 0;
    }
    catch (AnyError& e) {
        std::cout << "Caught Exiv2 exception '" << e << "'\n";
        return -1;
    }
}
コード例 #4
0
ファイル: metadata_exiv2.cpp プロジェクト: MaiTiano/fuppes
/* Read the EXIF metadata into the struct
 * A non-zero return code indicates some data could not be read,
 * which may require further action.
 */
int exiv2ReadExif(plugin_info* plugin, metadata_t* metadata)
{
    int errors = 0;
    
    try
    {	
	    Image::AutoPtr image = *(Image::AutoPtr*)(plugin->user_data);
	    
		const ExifData& exif = image->exifData();
		
	    const ExifData::const_iterator noValue = exif.end();
	    ExifData::const_iterator value;
	
		errors += set_width(exif, metadata->width);
		errors += set_height(exif, metadata->height); 
		errors += set_date(exif, metadata->date); 
    }
    catch(Exiv2::Error& err)
    {
    	cerr << "Exiv2::Error: " << err.what() << endl;
    	return 1;
    }
    catch(...)
    {
    	cerr << "Exception in Exiv2 metadata plugin" << endl;
    	return 1;
    } 
    
	return errors;  // Non-zero indicates at least one field could not be read
}
コード例 #5
0
ファイル: image.cpp プロジェクト: wjbeaver/Hide-Seep
 Image::AutoPtr ImageFactory::create(int type)
 {
     BasicIo::AutoPtr io(new MemIo);
     Image::AutoPtr image = create(type, io);
     if (image.get() == 0) throw Error(13, type);
     return image;
 }
コード例 #6
0
ファイル: image.cpp プロジェクト: wjbeaver/Hide-Seep
 Image::AutoPtr ImageFactory::open(const std::wstring& wpath)
 {
     BasicIo::AutoPtr io(new FileIo(wpath));
     Image::AutoPtr image = open(io); // may throw
     if (image.get() == 0) throw WError(11, wpath);
     return image;
 }
コード例 #7
0
 Image::AutoPtr newCrwInstance(BasicIo::AutoPtr io, bool create)
 {
     Image::AutoPtr image = Image::AutoPtr(new CrwImage(io, create));
     if (!image->good()) {
         image.reset();
     }
     return image;
 }
コード例 #8
0
 Image::AutoPtr newExvInstance(BasicIo::AutoPtr io, bool create)
 {
     Image::AutoPtr image;
     if (create) {
         image = Image::AutoPtr(new ExvImage(io, true));
     }
     else {
         image = Image::AutoPtr(new ExvImage(io, false));
     }
     if (!image->good()) image.reset();
     return image;
 }
コード例 #9
0
Image::AutoPtr ImageFactory::create(int type,
                                    const std::string& path)
{
    std::auto_ptr<FileIo> fileIo(new FileIo(path));
    // Create or overwrite the file, then close it
    if (fileIo->open("w+b") != 0) {
        throw Error(10, path, "w+b", strError());
    }
    fileIo->close();
    BasicIo::AutoPtr io(fileIo);
    Image::AutoPtr image = create(type, io);
    if (image.get() == 0) throw Error(13, type);
    return image;
}
コード例 #10
0
ファイル: iptc.cpp プロジェクト: obklar/exiv2
    int IptcData::erase(const std::string& path) const
    {
        if (!fileExists(path, true)) return -1;
        Image::AutoPtr image = ImageFactory::instance().open(path);
        if (image.get() == 0) return -2;

        // Read all metadata then erase only Iptc data
        int rc = image->readMetadata();
        if (rc == 0) {
            image->clearIptcData();
            rc = image->writeMetadata();
        }
        return rc;
    } // IptcData::erase
コード例 #11
0
ファイル: geotag.cpp プロジェクト: 007durgesh219/nomacs
bool readImage(const char* path,Options& /* options */)
{
    using namespace Exiv2;
    bool bResult = false ;

    try {
        Image::AutoPtr image = ImageFactory::open(path);
        if ( image.get() ) {
            image->readMetadata();
            ExifData &exifData = image->exifData();
            bResult = !exifData.empty();
        }
    } catch ( ... ) {};
    return bResult ;
}
コード例 #12
0
    void PgfImage::readMetadata()
    {
#ifdef DEBUG
        std::cerr << "Exiv2::PgfImage::readMetadata: Reading PGF file " << io_->path() << "\n";
#endif
        if (io_->open() != 0)
        {
            throw Error(9, io_->path(), strError());
        }
        IoCloser closer(*io_);
        // Ensure that this is the correct image type
        if (!isPgfType(*io_, true))
        {
            if (io_->error() || io_->eof()) throw Error(14);
            throw Error(3, "PGF");
        }
        clearMetadata();

        readPgfMagicNumber(*io_);

        uint32_t headerSize = readPgfHeaderSize(*io_);

        readPgfHeaderStructure(*io_, &pixelWidth_, &pixelHeight_);

        // And now, the most interresting, the user data byte array where metadata are stored as small image.

        long size = 8 + headerSize - io_->tell();

#ifdef DEBUG
        std::cout << "Exiv2::PgfImage::readMetadata: Found Image data (" << size << " bytes)\n";
#endif

        if (size < 0) throw Error(20);
        if (size == 0) return;

        DataBuf imgData(size);
        std::memset(imgData.pData_, 0x0, imgData.size_);
        long bufRead = io_->read(imgData.pData_, imgData.size_);
        if (io_->error()) throw Error(14);
        if (bufRead != imgData.size_) throw Error(20);

        Image::AutoPtr image = Exiv2::ImageFactory::open(imgData.pData_, imgData.size_);
        image->readMetadata();
        exifData() = image->exifData();
        iptcData() = image->iptcData();
        xmpData()  = image->xmpData();

    } // PgfImage::readMetadata
コード例 #13
0
ファイル: iptc.cpp プロジェクト: obklar/exiv2
    int IptcData::write(const std::string& path) 
    {
        // Remove the Iptc section from the file if there is no metadata 
        if (count() == 0) return erase(path);

        if (!fileExists(path, true)) return -1;
        Image::AutoPtr image = ImageFactory::instance().open(path);
        if (image.get() == 0) return -2;

        DataBuf buf(copy());

        // Read all metadata to preserve non-Iptc data
        int rc = image->readMetadata();
        if (rc == 0) {
            image->setIptcData(buf.pData_, buf.size_);
            rc = image->writeMetadata();
        }
        return rc;
    } // IptcData::write
コード例 #14
0
ファイル: iptc.cpp プロジェクト: obklar/exiv2
 int IptcData::read(const std::string& path)
 {
     if (!fileExists(path, true)) return -1;
     Image::AutoPtr image = ImageFactory::instance().open(path);
     if (image.get() == 0) {
         // We don't know this type of file
         return -2;
     }
     
     int rc = image->readMetadata();
     if (rc == 0) {
         if (image->sizeIptcData() > 0) {
             rc = read(image->iptcData(), image->sizeIptcData());
         }
         else {
             rc = 3;
         }
     }
     return rc;
 }
コード例 #15
0
ファイル: pgfimage.cpp プロジェクト: jfiguinha/Regards
    void PgfImage::doWriteMetadata(BasicIo& outIo)
    {
        if (!io_->isopen()) throw Error(20);
        if (!outIo.isopen()) throw Error(21);

#ifdef DEBUG
        std::cout << "Exiv2::PgfImage::doWriteMetadata: Writing PGF file " << io_->path() << "\n";
        std::cout << "Exiv2::PgfImage::doWriteMetadata: tmp file created " << outIo.path() << "\n";
#endif

        // Ensure that this is the correct image type
        if (!isPgfType(*io_, true))
        {
            if (io_->error() || io_->eof()) throw Error(20);
            throw Error(22);
        }

        // Ensure PGF version.
        byte mnb            = readPgfMagicNumber(*io_);

        readPgfHeaderSize(*io_);

        int w, h;
        DataBuf header      = readPgfHeaderStructure(*io_, w, h);

        Image::AutoPtr img  = ImageFactory::create(ImageType::png);

        img->setExifData(exifData_);
        img->setIptcData(iptcData_);
        img->setXmpData(xmpData_);
        img->writeMetadata();
        int     imgSize  = img->io().size();
        DataBuf imgBuf   = img->io().read(imgSize);

#ifdef DEBUG
        std::cout << "Exiv2::PgfImage::doWriteMetadata: Creating image to host metadata (" << imgSize << " bytes)\n";
#endif

        //---------------------------------------------------------------

        // Write PGF Signature.
        if (outIo.write(pgfSignature, 3) != 3) throw Error(21);

        // Write Magic number.
        if (outIo.putb(mnb) == EOF) throw Error(21);

        // Write new Header size.
        uint32_t newHeaderSize = header.size_ + imgSize;
        DataBuf buffer(4);
        memcpy (buffer.pData_, &newHeaderSize, 4);
        byteSwap_(buffer,0,bSwap_);
        if (outIo.write(buffer.pData_, 4) != 4) throw Error(21);

#ifdef DEBUG
        std::cout << "Exiv2::PgfImage: new PGF header size : " << newHeaderSize << " bytes\n";

        printf("%x\n", buffer.pData_[0]);
        printf("%x\n", buffer.pData_[1]);
        printf("%x\n", buffer.pData_[2]);
        printf("%x\n", buffer.pData_[3]);
#endif

        // Write Header data.
        if (outIo.write(header.pData_, header.size_) != header.size_) throw Error(21);

        // Write new metadata byte array.
        if (outIo.write(imgBuf.pData_, imgBuf.size_) != imgBuf.size_) throw Error(21);

        // Copy the rest of PGF image data.

        DataBuf buf(4096);
        long readSize = 0;
        while ((readSize=io_->read(buf.pData_, buf.size_)))
        {
            if (outIo.write(buf.pData_, readSize) != readSize) throw Error(21);
        }
        if (outIo.error()) throw Error(21);

    } // PgfImage::doWriteMetadata
コード例 #16
0
ファイル: rw2image.cpp プロジェクト: jfiguinha/Regards
    void Rw2Image::readMetadata()
    {
#ifdef DEBUG
        std::cerr << "Reading RW2 file " << io_->path() << "\n";
#endif
        if (io_->open() != 0) {
            throw Error(9, 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(14);
            throw Error(3, "RW2");
        }
        clearMetadata();
        std::ofstream devnull;
        printStructure(devnull, kpsRecursive, 0);
        ByteOrder bo = Rw2Parser::decode(exifData_,
                                         iptcData_,
                                         xmpData_,
                                         io_->mmap(),
                                         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 DEBUG
                    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 DEBUG
                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
コード例 #17
0
ファイル: exiv2-metadata.cpp プロジェクト: bgromov/rawstudio
gboolean
exiv2_load_meta_interface(const gchar *service, RAWFILE *rawfile, guint offset, RSMetadata *meta)
{
	try {
		Image::AutoPtr img = ImageFactory::open((byte*)raw_get_map(rawfile), raw_get_filesize(rawfile));
		img->readMetadata();
		ExifData &exifData = img->exifData();

#if EXIV2_TEST_VERSION(0,17,0)
		/* We perfer XMP data, so copy it to EXIF */
		XmpData &xmpData = img->xmpData();
		if (!xmpData.empty())
			copyXmpToExif(xmpData, exifData);
#endif

		/* Parse Exif Data */
		if (!exifData.empty())
		{
			ExifData::const_iterator i;
			i = exifData.findKey(ExifKey("Exif.Image.Make"));
			if (i != exifData.end())
				set_metadata_maker(i->toString(), meta);
			
			i = exifData.findKey(ExifKey("Exif.Image.Model"));
			if (i != exifData.end())
				meta->model_ascii = g_strdup(i->toString().c_str());

#if EXIV2_TEST_VERSION(0,19,0)
			i = orientation(exifData);
			if (i != exifData.end())
			{
				std::auto_ptr<Exiv2::Value> val = i->getValue();
				if (val->count())
				{
					switch (val->toLong())
					{
							case 6: meta->orientation = 90;
								break;
							case 8: meta->orientation = 270;
								break;
					}
				}
			}
#endif

			i = exifData.findKey(ExifKey("Exif.Image.DateTimeOriginal"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.Image.DateTime"));
			if (i != exifData.end())
			{
				meta->time_ascii = g_strdup(i->toString().c_str());
				meta->timestamp = rs_exiftime_to_unixtime(meta->time_ascii);
			}

			i = exifData.findKey(ExifKey("Exif.Image.ExposureTime"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.Photo.ExposureTime"));
			if (i != exifData.end())
				meta->shutterspeed = 1.0 / i->getValue()->toFloat();
			else
			{
				i = exifData.findKey(ExifKey("Exif.Image.ShutterSpeedValue"));
				if (i == exifData.end())
					i = exifData.findKey(ExifKey("Exif.Photo.ShutterSpeedValue"));
				if (i != exifData.end())
					meta->shutterspeed = 1.0 / i->toFloat();
			}

			i = exifData.findKey(ExifKey("Exif.Image.FNumber"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.Photo.FNumber"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.Image.ApertureValue"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.Photo.ApertureValue"));
			if (i != exifData.end())
				meta->aperture = i->toFloat();

			i = exifData.findKey(ExifKey("Exif.Image.FocalLength"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.Photo.FocalLength"));
			if (i != exifData.end())
				meta->focallength = i->toFloat()-0.01;

#if EXIV2_TEST_VERSION(0,19,0)
			i = isoSpeed(exifData);
			if (i != exifData.end())
				meta->iso = i->toLong();

			/* Text based Lens Identifier */
			i = lensName(exifData);
			if (i != exifData.end())
			{
				TypeId type = i->typeId();
				if (type == unsignedShort || type == unsignedLong || type == signedShort || type == signedLong || type == unsignedByte || type == signedByte)
					meta->lens_id = i->toLong();
				else if (type == asciiString || type == string)
					meta->fixed_lens_identifier = g_strdup(i->toString().c_str());
			}
#endif

			/* Canon*/
			i = exifData.findKey(ExifKey("Exif.CanonCs.Lens"));
			if (i != exifData.end()
					&& i->value().count() >= 3
					&& i->value().typeId() == unsignedShort) 
			{
				float fu = i->value().toFloat(2);
				if (fu != 0.0) 
				{
					meta->lens_min_focal = i->toFloat(0) / fu;
					meta->lens_max_focal = i->toFloat(1) /fu;
				}
			}
			i = exifData.findKey(ExifKey("Exif.CanonCs.MinAperture"));
			if (i != exifData.end())
				meta->lens_min_aperture = (gfloat) exp(CanonEv(i->toFloat())*log(2)/2);
			i = exifData.findKey(ExifKey("Exif.CanonCs.MaxAperture"));
			if (i != exifData.end())
				meta->lens_max_aperture = (gfloat) exp(CanonEv(i->toFloat())*log(2)/2);

			/* Olympus */
			i = exifData.findKey(ExifKey("Exif.OlympusEq.MinFocalLength"));
			if (i != exifData.end())
				meta->lens_min_focal = i->toFloat();
			i = exifData.findKey(ExifKey("Exif.OlympusEq.MaxFocalLength"));
			if (i != exifData.end())
				meta->lens_max_focal = i->toFloat();


			/* Nikon */
			i = exifData.findKey(ExifKey("Exif.NikonLd1.MinFocalLength"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.NikonLd2.MinFocalLength"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.NikonLd3.MinFocalLength"));
			if (i != exifData.end())
				meta->lens_min_focal = 5.0 * pow(2.0, i->toLong()/24.0);

			i = exifData.findKey(ExifKey("Exif.NikonLd1.MaxFocalLength"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.NikonLd2.MaxFocalLength"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.NikonLd3.MaxFocalLength"));
			if (i != exifData.end())
				meta->lens_max_focal = 5.0 * pow(2.0, i->toLong()/24.0);

			i = exifData.findKey(ExifKey("Exif.NikonLd1.MaxApertureAtMinFocal"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.NikonLd2.MaxApertureAtMinFocal"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.NikonLd3.MaxApertureAtMinFocal"));
			if (i != exifData.end())
				meta->lens_min_aperture = i->toLong()/12.0;
			
			i = exifData.findKey(ExifKey("Exif.NikonLd1.MaxApertureAtMaxFocal"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.NikonLd2.MaxApertureAtMaxFocal"));
			if (i == exifData.end())
				i = exifData.findKey(ExifKey("Exif.NikonLd3.MaxApertureAtMaxFocal"));
			if (i != exifData.end())
				meta->lens_max_aperture = i->toLong()/12.0;
				
			/* Fuji */
			i = exifData.findKey(ExifKey("Exif.Fujifilm.MinFocalLength"));
			if (i != exifData.end())
				meta->lens_min_focal = i->toFloat();
			i = exifData.findKey(ExifKey("Exif.Fujifilm.MaxFocalLength"));
			if (i != exifData.end())
				meta->lens_max_focal = i->toFloat();

			return TRUE;
		}
	} catch (Exiv2::Error& e) {
    g_debug("Exiv2 Metadata Loader:'%s'", e.what());
	}
	return FALSE;
}