Exiv2

SET( GENERIC_LIB_SOVERSION  "14" )

# options and their default values

OPTION( EXIV2_ENABLE_SHARED        "Build exiv2 as a shared library (dll)"                 ON  )

OPTION( EXIV2_ENABLE_XMP           "Build with XMP metadata support"                       ON  )

OPTION( EXIV2_ENABLE_LIBXMP        "Build a static convenience Library for XMP"            ON  )

ENDIF()

# set include path for FindXXX.cmake files

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/config/")

    message(STATUS Compiler: ${COMPILER} " Major:" ${GCC_MAJOR} " Minor:" ${GCC_MINOR})

ENDIF( MINGW OR UNIX )

IF( EXIV2_ENABLE_COMMERCIAL )

    SET (EXIV2_ENABLE_LENSDATA OFF)

    SET (EXIV2_ENABLE_NLS OFF)

bugfixes-test.sh   crw-test.sh     curliotest.sh       eps-preview-test.sh    eps-test.sh       exifdata-test.sh \

exiv2-test.sh      httpiotest.sh   icc-test.sh         imagetest.sh           iotest.sh         iptctest.sh      \

modify-test.sh     path-test.sh    preview-test.sh     sshiotest.sh           stringto-test.sh  tiff-test.sh     \

	cd test && ./$@

# convenience targets for running selected test scripts

MESSAGE( STATUS "------------------------------------------------------------------" )

MESSAGE( STATUS "${PACKAGE_STRING} configure results        <${PACKAGE_URL}>"        )

OptionOutput( "Building PNG support:               " EXIV2_ENABLE_PNG AND ZLIB_FOUND )

OptionOutput( "Building shared library:            " EXIV2_ENABLE_SHARED             )

OptionOutput( "XMP metadata support:               " EXIV2_ENABLE_XMP                )

    class EXIV2API BasicIo {

    public:

        //! BasicIo auto_ptr type

        typedef std::auto_ptr<BasicIo> AutoPtr;

        //! Seek starting positions

        enum Position { beg, cur, end };

    class EXIV2API IptcKey : public Key {

    public:

        //! Shortcut for an %IptcKey auto pointer.

        typedef std::auto_ptr<IptcKey> AutoPtr;

        //! @name Creators

        //@{

// + standard includes

#include <string>

#include <vector>

// *****************************************************************************

// namespace extensions

    class EXIV2API Image {

    public:

        //! Image auto_ptr type

        typedef std::auto_ptr<Image> AutoPtr;

        //! @name Creators

        //@{

        int imageType() const { return imageType_; }

    protected:

        // DATA

        BasicIo::AutoPtr  io_;                //!< Image data IO pointer

    class EXIV2API Key {

    public:

        //! Shortcut for a %Key auto pointer.

        typedef std::auto_ptr<Key> AutoPtr;

        //! @name Creators

        //@{

#include <string>

#include <iosfwd>

#include <memory>

// *****************************************************************************

// namespace extensions

          @brief Get all registered namespaces (for both Exiv2 and XMPsdk)

         */

        static void registeredNamespaces(Exiv2::Dictionary& nsDict);

    }; // class XmpProperties

    class EXIV2API XmpKey : public Key {

    public:

        //! Shortcut for an %XmpKey auto pointer.

        typedef std::auto_ptr<XmpKey> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API ExifKey : public Key {

    public:

        //! Shortcut for an %ExifKey auto pointer.

        typedef std::auto_ptr<ExifKey> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API Value {

    public:

        //! Shortcut for a %Value auto pointer.

        typedef std::auto_ptr<Value> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API DataValue : public Value {

    public:

        //! Shortcut for a %DataValue auto pointer.

        typedef std::auto_ptr<DataValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API StringValueBase : public Value {

    public:

        //! Shortcut for a %StringValueBase auto pointer.

        typedef std::auto_ptr<StringValueBase> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API StringValue : public StringValueBase {

    public:

        //! Shortcut for a %StringValue auto pointer.

        typedef std::auto_ptr<StringValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API AsciiValue : public StringValueBase {

    public:

        //! Shortcut for a %AsciiValue auto pointer.

        typedef std::auto_ptr<AsciiValue> AutoPtr;

        //! @name Creators

        //@{

        }; // class CharsetInfo

        //! Shortcut for a %CommentValue auto pointer.

        typedef std::auto_ptr<CommentValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API XmpValue : public Value {

    public:

        //! Shortcut for a %XmpValue auto pointer.

        typedef std::auto_ptr<XmpValue> AutoPtr;

        //! XMP array types.

        enum XmpArrayType { xaNone, xaAlt, xaBag, xaSeq };

    class EXIV2API XmpTextValue : public XmpValue {

    public:

        //! Shortcut for a %XmpTextValue auto pointer.

        typedef std::auto_ptr<XmpTextValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API XmpArrayValue : public XmpValue {

    public:

        //! Shortcut for a %XmpArrayValue auto pointer.

        typedef std::auto_ptr<XmpArrayValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API LangAltValue : public XmpValue {

    public:

        //! Shortcut for a %LangAltValue auto pointer.

        typedef std::auto_ptr<LangAltValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API DateValue : public Value {

    public:

        //! Shortcut for a %DateValue auto pointer.

        typedef std::auto_ptr<DateValue> AutoPtr;

        //! @name Creators

        //@{

    class EXIV2API TimeValue : public Value {

    public:

        //! Shortcut for a %TimeValue auto pointer.

        typedef std::auto_ptr<TimeValue> AutoPtr;

        //! @name Creators

        //@{

    class ValueType : public Value {

    public:

        //! Shortcut for a %ValueType\<T\> auto pointer.

        typedef std::auto_ptr<ValueType<T> > AutoPtr;

        //! @name Creators

        //@{

TARGET_LINK_LIBRARIES( geotag    ${PRIVATE_VAR} exiv2lib Threads::Threads ${EXPAT_LIBRARIES} ${ZLIB_LIBRARIES})

INSTALL( TARGETS       geotag    ${INSTALL_TARGET_STANDARD_ARGS} )

# ******************************************************************************

# Man page

INSTALL( FILES exiv2samples.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1 )

         key-test.cpp         \

         largeiptc-test.cpp   \

         mmap-test.cpp        \

         prevtest.cpp         \

         remotetest.cpp       \

         stringto-test.cpp    \

    Exiv2::BasicIo::AutoPtr memIo(new Exiv2::MemIo);

    memIo->transfer(*fileIo);

    Exiv2::Image::AutoPtr readImg = Exiv2::ImageFactory::open(memIo);

    assert(readImg.get() != 0);

    readImg->readMetadata();

// WARNING:             auto_ptr is not supported in C++11 implemented by gcc 4.9/C++11 and later

#include <exiv2/exiv2.hpp>

#include <iostream>

#include <iomanip>

            Task* t = i->second;

            return t->clone();

        }

        return Task::AutoPtr(0);

    } // TaskFactory::create

    Print::~Print()

                      << _("Failed to open the file\n");

            return -1;

        }

        assert(image.get() != 0);

        image->readMetadata();

        Exiv2::ExifData& exifData = image->exifData();

        if ( bStdin )  Params::instance().getStdin(stdIn);

        Exiv2::BasicIo::AutoPtr ioStdin = Exiv2::BasicIo::AutoPtr(new Exiv2::MemIo(stdIn.pData_,stdIn.size_));

        Exiv2::Image::AutoPtr sourceImage = bStdin ? Exiv2::ImageFactory::open(ioStdin) : Exiv2::ImageFactory::open(source);

        assert(sourceImage.get() != 0);

        sourceImage->readMetadata();

    class Task {

    public:

        //! Shortcut for an auto pointer.

        typedef std::auto_ptr<Task> AutoPtr;

        //! Virtual destructor.

        virtual ~Task();

        //! Virtual copy construction.

    public:

        virtual ~Print();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Print> AutoPtr;

        AutoPtr clone() const;

        //! Print the Jpeg comment

    public:

        virtual ~Rename();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Rename> AutoPtr;

        AutoPtr clone() const;

    private:

    public:

        virtual ~Adjust();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Adjust> AutoPtr;

        AutoPtr clone() const;

    private:

    public:

        virtual ~Erase();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Erase> AutoPtr;

        AutoPtr clone() const;

        /*!

    public:

        virtual ~Extract();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Extract> AutoPtr;

        AutoPtr clone() const;

        /*!

    public:

        virtual ~Insert();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Insert> AutoPtr;

        AutoPtr clone() const;

        /*!

    public:

        virtual ~Modify();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<Modify> AutoPtr;

        AutoPtr clone() const;

        Modify() {}

        //! Apply modification commands to the \em pImage, return 0 if successful.

    public:

        virtual ~FixIso();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<FixIso> AutoPtr;

        AutoPtr clone() const;

    private:

    public:

        virtual ~FixCom();

        virtual int run(const std::string& path);

        typedef std::auto_ptr<FixCom> AutoPtr;

        AutoPtr clone() const;

    private:

    using namespace Exiv2::Internal;

    AsfVideo::AsfVideo(BasicIo::AutoPtr io)

        : Image(ImageType::asf, mdNone, io)

    {

    } // AsfVideo::AsfVideo

    std::string AsfVideo::mimeType() const

    {

    Image::AutoPtr newAsfInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new AsfVideo(io));

        if (!image->good()) {

            image.reset();

        }

        // buffer, which is a workaround to ensure that the links don't get broken.

        if (ret != 0 || (buf.st_size > 1048576 && nlink == 1)) {

            pid_t pid = ::getpid();

            std::auto_ptr<FileIo> fileIo;

#ifdef EXV_UNICODE_PATH

            if (p_->wpMode_ == Impl::wpUnicode) {

                std::wstring tmpname = wpath() + s2ws(toString(pid));

                fileIo = std::auto_ptr<FileIo>(new FileIo(tmpname));

            }

            else

#endif

            {

                std::string tmpname = path() + toString(pid);

                fileIo = std::auto_ptr<FileIo>(new FileIo(tmpname));

            }

            if (fileIo->open("w+b") != 0) {

#ifdef EXV_UNICODE_PATH

                }

            }

            fileIo->p_->copyXattrFrom(*this);

            basicIo = fileIo;

        }

        else {

            basicIo.reset(new MemIo);

// class member definitions

namespace Exiv2 {

    BmpImage::BmpImage(BasicIo::AutoPtr io)

        : Image(ImageType::bmp, mdNone, io)

    {

    } // BmpImage::BmpImage

    std::string BmpImage::mimeType() const

    {

    // free functions

    Image::AutoPtr newBmpInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new BmpImage(io));

        if (!image->good())

        {

            image.reset();

    using namespace Internal;

    Cr2Image::Cr2Image(BasicIo::AutoPtr io, bool /*create*/)

        : Image(ImageType::cr2, mdExif | mdIptc | mdXmp, io)

    {

    } // Cr2Image::Cr2Image

                     ed.end());

        }

        std::auto_ptr<TiffHeaderBase> header(new Cr2Header(byteOrder));

        OffsetWriter offsetWriter;

        offsetWriter.setOrigin(OffsetWriter::cr2RawIfdOffset, Cr2Header::offset2addr(), byteOrder);

        return TiffParserWorker::encode(io,

    // free functions

    Image::AutoPtr newCr2Instance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new Cr2Image(io, create));

        if (!image->good()) {

            image.reset();

        }

    using namespace Internal;

    CrwImage::CrwImage(BasicIo::AutoPtr io, bool /*create*/)

        : Image(ImageType::crw, mdExif | mdComment, io)

    {

    } // CrwImage::CrwImage

    // free functions

    Image::AutoPtr newCrwInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new CrwImage(io, create));

        if (!image->good()) {

            image.reset();

        }

    void CiffComponent::add(AutoPtr component)

    {

        doAdd(component);

    }

    void CiffEntry::doAdd(AutoPtr /*component*/)

            }

            m->setDir(this->tag());

            m->read(pData, size, o, byteOrder);

            add(m);

            o += 10;

        }

    }  // CiffDirectory::readDirectory

                // Directory doesn't exist yet, add it

                m_ = AutoPtr(new CiffDirectory(csd.crwDir_, csd.parent_));

                cc_ = m_.get();

                add(m_);

            }

            // Recursive call to next lower level directory

            cc_ = cc_->add(crwDirs, crwTagId);

                // Tag doesn't exist yet, add it

                m_ = AutoPtr(new CiffEntry(crwTagId, tag()));

                cc_ = m_.get();

                add(m_);

            }

        }

        return cc_;

    class CiffComponent {

    public:

        //! CiffComponent auto_ptr type

        typedef std::auto_ptr<CiffComponent> AutoPtr;

        //! Container type to hold all metadata

        typedef std::vector<CiffComponent*> Components;

    class CiffHeader {

    public:

        //! CiffHeader auto_ptr type

        typedef std::auto_ptr<CiffHeader> AutoPtr;

        //! @name Creators

        //@{

namespace Exiv2

{

    EpsImage::EpsImage(BasicIo::AutoPtr io, bool create)

            : Image(ImageType::eps, mdXmp, io)

    {

        //LogMsg::setLevel(LogMsg::debug);

        if (create) {

    // free functions

    Image::AutoPtr newEpsInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new EpsImage(io, create));

        if (!image->good()) {

            image.reset();

        }

    class Thumbnail {

    public:

        //! Shortcut for a %Thumbnail auto pointer.

        typedef std::auto_ptr<Thumbnail> AutoPtr;

        //! @name Creators

        //@{

    class TiffThumbnail : public Thumbnail {

    public:

        //! Shortcut for a %TiffThumbnail auto pointer.

        typedef std::auto_ptr<TiffThumbnail> AutoPtr;

        //! @name Manipulators

        //@{

    class JpegThumbnail : public Thumbnail {

    public:

        //! Shortcut for a %JpegThumbnail auto pointer.

        typedef std::auto_ptr<JpegThumbnail> AutoPtr;

        //! @name Manipulators

        //@{

    template<typename T>

    Exiv2::Exifdatum& setValue(Exiv2::Exifdatum& exifDatum, const T& value)

    {

        std::auto_ptr<Exiv2::ValueType<T> > v

            = std::auto_ptr<Exiv2::ValueType<T> >(new Exiv2::ValueType<T>);

        v->value_.push_back(value);

        exifDatum.value_ = v;

        return exifDatum;

    }

    Value::AutoPtr Exifdatum::getValue() const

    {

        return value_.get() == 0 ? Value::AutoPtr(0) : value_->clone();

    }

    long Exifdatum::sizeDataArea() const

        // Encode and check if the result fits into a JPEG Exif APP1 segment

        MemIo mio1;

        std::auto_ptr<TiffHeaderBase> header(new TiffHeader(byteOrder, 0x00000008, false));

        WriteMethod wm = TiffParserWorker::encode(mio1,

                                                  pData,

                                                  size,

// class member definitions

namespace Exiv2 {

    GifImage::GifImage(BasicIo::AutoPtr io)

        : Image(ImageType::gif, mdNone, io)

    {

    } // GifImage::GifImage

    // free functions

    Image::AutoPtr newGifInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new GifImage(io));

        if (!image->good())

        {

            image.reset();

#include <cstring>

#include <cassert>

#include <iostream>

#include <sys/types.h>

#include <sys/stat.h>

    Image::Image(int              imageType,

                 uint16_t         supportedMetadata,

                 BasicIo::AutoPtr io)

        : io_(io),

          pixelWidth_(0),

          pixelHeight_(0),

          imageType_(imageType),

        static std::map<int,std::string> tags;

        static bool init  = true;

        static char buffer[80];

        if ( init ) {

            int idx;

            const TagInfo* ti ;

            for (ti = Internal::  mnTagList(), idx = 0; ti[idx].tag_ != 0xffff; ++idx) tags[ti[idx].tag_] = ti[idx].name_;

            for (ti = Internal:: mpfTagList(), idx = 0; ti[idx].tag_ != 0xffff; ++idx) tags[ti[idx].tag_] = ti[idx].name_;

            for (ti = Internal::Nikon1MakerNote::tagList(), idx = 0

                                                      ; ti[idx].tag_ != 0xffff; ++idx) tags[ti[idx].tag_] = ti[idx].name_;

        }

        init = false;

        try {

            result = tags[tag].c_str();

    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;

    }

        }

        for (unsigned int i = 0; registry[i].imageType_ != ImageType::none; ++i) {

            if (registry[i].isThisType_(*io, false)) {

                return registry[i].newInstance_(io, false);

            }

        }

        return Image::AutoPtr();

    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;

    }

    Image::AutoPtr ImageFactory::create(int type,

                                        const std::wstring& wpath)

    {

        std::auto_ptr<FileIo> fileIo(new FileIo(wpath));

        // Create or overwrite the file, then close it

        if (fileIo->open("w+b") != 0) {

            throw WError(10, wpath, "w+b", strError().c_str());

    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;

    }

        // BasicIo instance does not need to be open

        const Registry* r = find(registry, type);

        if (0 != r) {

            return r->newInstance_(io, true);

        }

        return Image::AutoPtr();

    } // ImageFactory::create

    Value::AutoPtr Iptcdatum::getValue() const

    {

        return value_.get() == 0 ? Value::AutoPtr(0) : value_->clone();

    }

    const Value& Iptcdatum::value() const

    {

        UShortValue::AutoPtr v(new UShortValue);

        v->value_.push_back(value);

        value_ = v;

        return *this;

    }

namespace Exiv2

{

    Jp2Image::Jp2Image(BasicIo::AutoPtr io, bool create)

            : Image(ImageType::jp2, mdExif | mdIptc | mdXmp, io)

    {

        if (create)

        {

    // free functions

    Image::AutoPtr newJp2Instance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new Jp2Image(io, create));

        if (!image->good())

        {

            image.reset();

    } // Photoshop::setIptcIrb

    JpegBase::JpegBase(int type, BasicIo::AutoPtr io, bool create,

                       const byte initData[], long dataSize)

        : Image(type, mdExif | mdIptc | mdXmp | mdComment, io)

    {

        if (create) {

            initImage(initData, dataSize);

        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xDA,0x00,0x0C,0x03,0x01,0x00,0x02,

        0x11,0x03,0x11,0x00,0x3F,0x00,0xA0,0x00,0x0F,0xFF,0xD9 };

    JpegImage::JpegImage(BasicIo::AutoPtr io, bool create)

        : JpegBase(ImageType::jpeg, io, create, blank_, sizeof(blank_))

    {

    }

    Image::AutoPtr newJpegInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new JpegImage(io, create));

        if (!image->good()) {

            image.reset();

        }

    const char ExvImage::exiv2Id_[] = "Exiv2";

    const byte ExvImage::blank_[] = { 0xff,0x01,'E','x','i','v','2',0xff,0xd9 };

    ExvImage::ExvImage(BasicIo::AutoPtr io, bool create)

        : JpegBase(ImageType::exv, io, create, blank_, sizeof(blank_))

    {

    }

    Image::AutoPtr newExvInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image;

        image = Image::AutoPtr(new ExvImage(io, create));

        if (!image->good()) image.reset();

        return image;

    }

    using namespace Exiv2::Internal;

    MatroskaVideo::MatroskaVideo(BasicIo::AutoPtr io)

        : Image(ImageType::mkv, mdNone, io)

    {

    } // MatroskaVideo::MatroskaVideo

    Image::AutoPtr newMkvInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new MatroskaVideo(io));

        if (!image->good()) {

            image.reset();

        }

// class member definitions

namespace Exiv2 {

    MrwImage::MrwImage(BasicIo::AutoPtr io, bool /*create*/)

        : Image(ImageType::mrw, mdExif | mdIptc | mdXmp, io)

    {

    } // MrwImage::MrwImage

    // free functions

    Image::AutoPtr newMrwInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new MrwImage(io, create));

        if (!image->good()) {

            image.reset();

        }

    using namespace Internal;

    OrfImage::OrfImage(BasicIo::AutoPtr io, bool create)

        : TiffImage(/*ImageType::orf, mdExif | mdIptc | mdXmp,*/ io,create)

    {

    	setTypeSupported(ImageType::orf, mdExif | mdIptc | mdXmp);

    } // OrfImage::OrfImage

                     ed.end());

        }

        std::auto_ptr<TiffHeaderBase> header(new OrfHeader(byteOrder));

        return TiffParserWorker::encode(io,

                                        pData,

                                        size,

    // free functions

    Image::AutoPtr newOrfInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new OrfImage(io, create));

        if (!image->good()) {

            image.reset();

        }

        return result;

    }

    PgfImage::PgfImage(BasicIo::AutoPtr io, bool create)

            : Image(ImageType::pgf, mdExif | mdIptc| mdXmp | mdComment, io)

            , bSwap_(isBigEndianPlatform())

    {

        if (create)

        {

    // free functions

    Image::AutoPtr newPgfInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new PgfImage(io, create));

        if (!image->good())

        {

            image.reset();

    using namespace Internal;

    PngImage::PngImage(BasicIo::AutoPtr io, bool create)

            : Image(ImageType::png, mdExif | mdIptc | mdXmp | mdComment, io)

    {

        if (create)

        {

    // free functions

    Image::AutoPtr newPngInstance(BasicIo::AutoPtr io, bool create)

    {

        Image::AutoPtr image(new PngImage(io, create));

        if (!image->good())

        {

            image.reset();

        virtual ~Loader() {}

        //! Loader auto pointer

        typedef std::auto_ptr<Loader> AutoPtr;

        //! Create a Loader subclass for requested id

        static AutoPtr create(PreviewId id, const Image &image);

#include <cstring>

#include <cstdlib>

#include <cctype>

// *****************************************************************************

namespace {

    }

    XmpProperties::NsRegistry XmpProperties::nsRegistry_;

    Internal::RWLock XmpProperties::rwLock_;

    const XmpNsInfo* XmpProperties::lookupNsRegistry(const XmpNsInfo::Prefix& prefix)

    {

        Internal::ScopedReadLock srl(rwLock_);

        return lookupNsRegistryUnsafe(prefix);

    }

            && ns2.substr(ns2.size() - 1, 1) != "#") ns2 += "/";

        // Check if there is already a registered namespace with this prefix

        const XmpNsInfo* xnp = lookupNsRegistryUnsafe(XmpNsInfo::Prefix(prefix));

        if (xnp) {

#ifndef SUPPRESS_WARNINGS

            if (strcmp(xnp->ns_, ns2.c_str()) != 0) {

// class member definitions

namespace Exiv2 {

    PsdImage::PsdImage(BasicIo::AutoPtr io)

        : Image(ImageType::psd, mdExif | mdIptc | mdXmp, io)

    {

    } // PsdImage::PsdImage

    // free functions

    Image::AutoPtr newPsdInstance(BasicIo::AutoPtr io, bool /*create*/)

    {

        Image::AutoPtr image(new PsdImage(io));

        if (!image->good())

        {

            image.reset();

    using namespace Exiv2::Internal;

    QuickTimeVideo::QuickTimeVideo(BasicIo::AutoPtr io)