Exiv2

#define EXV_HAVE_GXXCLASSVISIBILITY

#endif

#if defined(WIN32) && !defined(__CYGWIN__)

#else

#endif

/* Shared library support, see http://gcc.gnu.org/wiki/Visibility */

    po::options_description hidden("Hidden Options");

    hidden.add_options()

        ("source-dir", po::value< std::string >(), "directory of files to organize, may end in file wildcard")

        ("pattern", po::value< std::string >(), "subdirectory pattern for grouping files within dest-dir")

        ;

          prototype is replaced.

          @param type Task type.

                 task factory. That's what the auto pointer indicates.

        */

        void registerTask(TaskType type, Task::AutoPtr task);

    private:

        virtual Modify* clone_() const;

        Modify(const Modify& /*src*/) : Task() {}

        //! Add a metadatum to \em pImage according to \em modifyCmd

    class EXIV2API XPathIo : public FileIo {

    public:

        /*!

                    to read metadata. This file will be deleted in destructor.

        */

        static const std::string TEMP_FILE_EXT;

        /*!

                    to add or modify the metadata.

        */

        static const std::string GEN_FILE_EXT;

#pragma comment(lib, "ws2_32.lib")

#pragma comment(lib, "wldap32.lib")

/* Windows unicode path support */

// #define EXV_UNICODE_PATH

#pragma comment(lib, "ws2_32.lib")

#pragma comment(lib, "wldap32.lib")

/* Windows unicode path support */

// #define EXV_UNICODE_PATH

public:

    static bool compareTagValue(Exiv2::DataBuf &buf, const char *str);

    static bool compareTagValue(Exiv2::DataBuf& buf,const char arr[][5],int32_t arraysize);

}; // class UtilsVideo

} // namespace Exiv2

    return rc;

}

// found. Call multiple times to remove many.

// Returns 0 on success

EXIVSIMPLE_API int RemoveMeta(HIMAGE img, const char *key)

	LPCTSTR base = pModule->GetBaseName() ;

    LPCTSTR result = base ;

    if ( bQuiet ) {

	    if (   _strnicmp(base,"MSVCR",5) == 0 ) result = NULL ;

	    if (   _strnicmp(base,"MSVCP",5) == 0 ) result = NULL ;

	    if (   _strnicmp(base,"API-MS-Win",10) == 0 ) result = NULL ;

int main(int argc, char** argv)

{

            FILE_SHARE_DELETE|FILE_SHARE_READ|FILE_SHARE_WRITE,

            NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

 * option is TRUE, directories will be recursively emptied then deleted.

 * If force is TRUE, file attributes will be changed to allow the program

 * to delete the file.  The verbose option will cause non-fatal error messages

 * error messages

 */

BOOL del(wchar_t* name, BOOL recurse, BOOL force, BOOL verbose, BOOL quiet) {

std::string makePath(std::string dir,std::string file)

{

}

const char* makePath(const char* dir,const char* file)

                      << path << "\n";

            return 1;

        }

                  + basename + Util::suffix(path);

        if (   Util::dirname(newPath)  == Util::dirname(path)

            && Util::basename(newPath) == Util::basename(path)) {

                    break;

                case Params::renamePolicy:

                    newPath = Util::dirname(path)

                        + "_" + Exiv2::toString(seq++)

                        + Util::suffix(path);

                    break;

                    case 'R':

                        fileExistsPolicy = Params::renamePolicy;

                        newPath = Util::dirname(path)

                            + "_" + Exiv2::toString(seq++)

                            + Util::suffix(path);

                        break;

    {

        std::string directory = Params::instance().directory_;

        if (directory.empty()) directory = Util::dirname(path);

                              + Util::basename(path, true) + ext;

        return newPath;

    }

#ifdef DEBUG

            std::cout << "Exiv2::Jp2Image::readMetadata: Position: " << position << "\n";

            std::cout << "Exiv2::Jp2Image::readMetadata: Find box type: " << std::string((const char*)&box.boxType)

#endif

            box.boxType   = getLong((byte*)&box.boxType, bigEndian);

#ifdef DEBUG

            std::cout << "Exiv2::Jp2Image::doWriteMetadata: Find box type: " << bheaderBuf.pData_ + 4

#endif

            if (box.boxLength == 0)

                {

#ifdef DEBUG

#endif

                    if (outIo.write(boxBuf.pData_, boxBuf.size_) != boxBuf.size_) throw Error(21);

                            memcpy(boxData.pData_ + 8 + 16, rawExif.pData_, rawExif.size_);

#ifdef DEBUG

                                      << boxData.size_ << ")\n";

#endif

                            if (outIo.write(boxData.pData_, boxData.size_) != boxData.size_) throw Error(21);

                            memcpy(boxData.pData_ + 8 + 16, rawIptc.pData_, rawIptc.size_);

#ifdef DEBUG

                                      << boxData.size_ << ")\n";

#endif

                            if (outIo.write(boxData.pData_, boxData.size_) != boxData.size_) throw Error(21);

                        memcpy(boxData.pData_ + 8 + 16, xmp.pData_,   xmp.size_);

#ifdef DEBUG

                                  << boxData.size_ << ")\n";

#endif

                        if (outIo.write(boxData.pData_, boxData.size_) != boxData.size_) throw Error(21);

                default:

                {

#ifdef DEBUG

#endif

                    if (outIo.write(boxBuf.pData_, boxBuf.size_) != boxBuf.size_) throw Error(21);

        for (ExifData::const_iterator pos = exifData.begin(); pos != exifData.end(); ++pos) {

            if (pos->groupName() == group_) {

                /*

                   tags that especially could cause problems are:

                   "NewSubfileType" - the result is no longer a thumbnail, it is a standalone image

                   "Orientation" - this tag typically appears only in the "Image" group. Deleting it ensures

        { "MediaLangCode",      N_("Media Language Code"),          "Integer",               xmpText, xmpExternal, N_("A 16-bit integer that specifies the language code for this media.")   },

        { "MediaModifyDate",    N_("Media Track Modify Date"),      "Integer",               xmpText, xmpExternal, N_("A 32-bit integer that indicates (in seconds since midnight, January 1, 1904) when the media header was last modified.")   },

        { "MediaTimeScale",     N_("Media Time Scale"),             "Integer",               xmpText, xmpExternal, N_("A time value that indicates the time scale for this media-that is, the number of time units that pass per second in its time coordinate system." )   },

        { "SampleCount",        N_("Audio Sample Count"),           "Integer",               xmpText, xmpExternal, N_("Sample taken for Analyzing Audio Stream")   },

        { "SampleRate",         N_("Audio Sample Rate"),            "Integer",               xmpText, xmpExternal, N_("The audio sample rate. Can be any value, but commonly 32000, 41100, or 48000.") },

        { "SampleType",         N_("Audio Sample Type"),            "closed Choice of Text", xmpText, xmpExternal, N_("The audio sample type. One of: 8Int, 16Int, 32Int, 32Float.") },

                                                N_("A list (concatenated and separated) of additional measurements, facts, characteristics, or assertions about the record. Meant to provide a mechanism for structured content such as key-value pairs.")

            },

                                            N_("The category of information pertaining to evidence of an occurrence in nature, in a collection, or in a dataset (specimen, observation, etc.)."),

        },

            { "occurrenceID",                   N_("Occurrence ID"),                        "Text",      xmpText,   xmpExternal,      

                                                N_("An identifier for the Occurrence (as opposed to a particular digital record of the occurrence). In the absence of a persistent global unique identifier, construct one from a combination of identifiers in the record that will most closely make the occurrenceID globally unique.")

            },

                                                N_("The amount of effort expended during an Event.")

            },

            { "Date",                           N_("Event Date"),                  "Date",      xmpText,    xmpExternal,      

            },

            { "earliestDate",                   N_("Event Earliest Date"),                  "Date",      xmpText,    xmpExternal,      

                                                N_("The date-time or interval during which an Event started. For occurrences, this is the date-time when the event was recorded. Not suitable for a time in a geological context. Recommended best practice is to use an encoding scheme, such as ISO 8601:2004(E).")

            throw Error(3, "Photoshop");

        }

        if (io_->read(buf, 4) != 4)

        {

            throw Error(3, "Photoshop");

                N_("Release Mode"),

                sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonyReleaseMode)),

        TagInfo(0xB04A, "SequenceNumber", N_("Sequence Number"),

                sony1Id, makerTags, unsignedShort, -1, EXV_PRINT_TAG(sonySequenceNumber)),

        TagInfo(0xB04B, "AntiBlur", N_("Anti-Blur"),

                N_("Anti-Blur"),

        { 34892, N_("Linear Raw")         }

    };

        { 1, N_("No dithering or halftoning")           },

        { 2, N_("Ordered dither or halftone technique") },

        { 3, N_("Randomized process")                   }

                N_("The pixel composition. In JPEG compressed data a JPEG "

                "marker is used instead of this tag."),

                ifd0Id, imgStruct, unsignedShort, 1, EXV_PRINT_TAG(exifPhotometricInterpretation)),

                N_("For black and white TIFF files that represent shades of gray, "

                   "the technique used to convert from gray to black and white pixels."),

        TagInfo(0x0108, "CellWidth", N_("Cell Width"),

                N_("The width of the dithering or halftoning matrix used to create a "

                   "dithered or halftoned bilevel file."),

    bool strtol(const char* nptr, long& n);

    /*!

             by \em replaceText.

     */

    void replace(std::string& text, const std::string& searchText, const std::string& replaceText);

    return result;

}

    for(int32_t i=0; i<size; i++ )

        if(toupper(buf.pData_[i]) != str[i])

            return false;

/// are visited next. The fields of a struct or items of an array are visited after the qualifiers

/// of the parent.

///

/// performed.

///

///   \li \c #kXMP_IterJustChildren - Visit just the immediate children of the root. Skip the root

    ///   internal. You can use this flag together with \c #kXMPUtil_ReplaceOldValues to replace the

    ///   values of existing top-level properties.

    ///

    ///   the destination, replacing any existing values. The values of properties in the

    ///   destination that are not in the source are not modified.<br>

    ///   The keep-or-replace-old notion also applies within structs and arrays. Top-level

// are distinguished by their XML element content.

//

// NOTE: The RDF syntax does not explicitly include the xml:lang attribute although it can appear in

static void

RDF_PropertyElement ( XMP_Node * xmpParent, const XML_Node & xmlNode, bool isTopLevel )

		} else {

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

			// some of the cases want to break from the loop. A break in a switch just exits the case.

			#if TraceIterators

				// We've got some leftover input, process it first then continue with the current

				// buffer. Try to fill the pendingInput buffer before parsing further. We use a loop

				// then having a partial UTF-8 end and need to absorb more.

				size_t pendingOverlap = kXMLPendingInputMax - parser.pendingCount;

	if ( arrayNode->children.empty() ) goto EXIT;	// ! Need to set the output pointer and length.

	// Build the result, quoting the array items, adding separators. Hurl if any item isn't simple.

	currItem = arrayNode->children[0];