xymp
/
exiv2
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

some std::array conversions (#2148)

Browse Source 
Signed-off-by: Rosen Penev <rosenp@gmail.com>
main
Rosen Penev 3 years ago committed by GitHub
parent 573c3c79fc
commit b2b6d834ba
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 240 additions and 251 deletions
Show Stats Download Patch File Download Diff File

5
app/actions.cpp
Unescape Escape View File

@ -125,7 +125,7 @@ namespace {
multi-byte characters correctly. Replace code in the form
os << setw(width) << myString
with
os << make_pair( myString, width)
os << pair( myString, width)
*/
std::ostream& operator<<(std::ostream& os, const std::pair<std::string, int>& strAndWidth);
@ -317,8 +317,7 @@ namespace Action {
if (Params::instance().files_.size() > 1) {
std::cout << std::setw(20) << path_ << " ";
}
std::cout << std::make_pair( label, align_)
<< ": ";
std::cout << std::pair(label, align_) << ": ";
}
int Print::printTag(const Exiv2::ExifData& exifData,

4
include/exiv2/jpgimage.hpp
Unescape Escape View File

@ -379,8 +379,8 @@ namespace Exiv2 {
private:
// Constant data
static const char exiv2Id_[]; // EXV identifier
static const byte blank_[]; // Minimal exiv2 file
static constexpr char exiv2Id_[] = "Exiv2"; // EXV identifier
static constexpr byte blank_[] = {0xff, 0x01, 'E', 'x', 'i', 'v', '2', 0xff, 0xd9}; // Minimal exiv2 file
}; // class ExvImage

4
include/exiv2/value.hpp
Unescape Escape View File

@ -464,9 +464,7 @@ namespace Exiv2 {
//! Information pertaining to the defined character sets
struct CharsetTable {
//! Constructor
CharsetTable(CharsetId charsetId,
const char* name,
const char* code);
constexpr CharsetTable(CharsetId charsetId, const char* name, const char* code);
CharsetId charsetId_; //!< Charset id
const char* name_; //!< Name of the charset
const char* code_; //!< Code of the charset

2
src/convert.cpp
Unescape Escape View File

@ -1513,7 +1513,7 @@ namespace {
bool convertStringCharsetWindows(std::string& str, const char* from, const char* to)
{
bool ret = false;
const ConvFctList* p = find(convFctList, std::make_pair(from, to));
const ConvFctList* p = find(convFctList, std::pair(from, to));
std::string tmpstr = str;
if (p) ret = p->convFct_(tmpstr);
#ifndef SUPPRESS_WARNINGS

5
src/cr2image.cpp
Unescape Escape View File

@ -11,6 +11,7 @@
#include "tiffcomposite_int.hpp"
#include "tiffimage_int.hpp"
#include <array>
#include <iostream>
// *****************************************************************************
@ -136,8 +137,8 @@ namespace Exiv2 {
ExifData ed = exifData;
// Delete IFDs which do not occur in TIFF images
static const IfdId filteredIfds[] = {
panaRawId
static constexpr auto filteredIfds = std::array{
panaRawId,
};
for (auto&& filteredIfd : filteredIfds) {
#ifdef EXIV2_DEBUG_MESSAGES

61
src/exif.cpp
Unescape Escape View File

@ -24,6 +24,7 @@
// + standard includes
#include <algorithm>
#include <array>
#include <cstdio>
#include <iostream>
#include <utility>
@ -508,7 +509,7 @@ namespace Exiv2 {
// Delete IFD0 tags that are "not recorded" in compressed images
// Reference: Exif 2.2 specs, 4.6.8 Tag Support Levels, section A
static const char* filteredIfd0Tags[] = {
static constexpr auto filteredIfd0Tags = std::array{
"Exif.Image.PhotometricInterpretation",
"Exif.Image.StripOffsets",
"Exif.Image.RowsPerStrip",
@ -586,35 +587,35 @@ namespace Exiv2 {
// Delete preview tags if the preview is larger than 32kB.
// Todo: Enhance preview classes to be able to write and delete previews and use that instead.
// Table must be sorted by preview, the first tag in each group is the size
static const PreviewTags filteredPvTags[] = {
{ pttLen, "Exif.Minolta.ThumbnailLength" },
{ pttTag, "Exif.Minolta.ThumbnailOffset" },
{ pttLen, "Exif.Minolta.Thumbnail" },
{ pttLen, "Exif.NikonPreview.JPEGInterchangeFormatLength" },
{ pttIfd, "NikonPreview" },
{ pttLen, "Exif.Olympus.ThumbnailLength" },
{ pttTag, "Exif.Olympus.ThumbnailOffset" },
{ pttLen, "Exif.Olympus.ThumbnailImage" },
{ pttLen, "Exif.Olympus.Thumbnail" },
{ pttLen, "Exif.Olympus2.ThumbnailLength" },
{ pttTag, "Exif.Olympus2.ThumbnailOffset" },
{ pttLen, "Exif.Olympus2.ThumbnailImage" },
{ pttLen, "Exif.Olympus2.Thumbnail" },
{ pttLen, "Exif.OlympusCs.PreviewImageLength" },
{ pttTag, "Exif.OlympusCs.PreviewImageStart" },
{ pttTag, "Exif.OlympusCs.PreviewImageValid" },
{ pttLen, "Exif.Pentax.PreviewLength" },
{ pttTag, "Exif.Pentax.PreviewOffset" },
{ pttTag, "Exif.Pentax.PreviewResolution" },
{ pttLen, "Exif.PentaxDng.PreviewLength" },
{ pttTag, "Exif.PentaxDng.PreviewOffset" },
{ pttTag, "Exif.PentaxDng.PreviewResolution" },
{ pttLen, "Exif.SamsungPreview.JPEGInterchangeFormatLength" },
{ pttIfd, "SamsungPreview" },
{ pttLen, "Exif.Thumbnail.StripByteCounts" },
{ pttIfd, "Thumbnail" },
{ pttLen, "Exif.Thumbnail.JPEGInterchangeFormatLength" },
{ pttIfd, "Thumbnail" }
static constexpr auto filteredPvTags = std::array{
PreviewTags{pttLen, "Exif.Minolta.ThumbnailLength"},
PreviewTags{pttTag, "Exif.Minolta.ThumbnailOffset"},
PreviewTags{pttLen, "Exif.Minolta.Thumbnail"},
PreviewTags{pttLen, "Exif.NikonPreview.JPEGInterchangeFormatLength"},
PreviewTags{pttIfd, "NikonPreview"},
PreviewTags{pttLen, "Exif.Olympus.ThumbnailLength"},
PreviewTags{pttTag, "Exif.Olympus.ThumbnailOffset"},
PreviewTags{pttLen, "Exif.Olympus.ThumbnailImage"},
PreviewTags{pttLen, "Exif.Olympus.Thumbnail"},
PreviewTags{pttLen, "Exif.Olympus2.ThumbnailLength"},
PreviewTags{pttTag, "Exif.Olympus2.ThumbnailOffset"},
PreviewTags{pttLen, "Exif.Olympus2.ThumbnailImage"},
PreviewTags{pttLen, "Exif.Olympus2.Thumbnail"},
PreviewTags{pttLen, "Exif.OlympusCs.PreviewImageLength"},
PreviewTags{pttTag, "Exif.OlympusCs.PreviewImageStart"},
PreviewTags{pttTag, "Exif.OlympusCs.PreviewImageValid"},
PreviewTags{pttLen, "Exif.Pentax.PreviewLength"},
PreviewTags{pttTag, "Exif.Pentax.PreviewOffset"},
PreviewTags{pttTag, "Exif.Pentax.PreviewResolution"},
PreviewTags{pttLen, "Exif.PentaxDng.PreviewLength"},
PreviewTags{pttTag, "Exif.PentaxDng.PreviewOffset"},
PreviewTags{pttTag, "Exif.PentaxDng.PreviewResolution"},
PreviewTags{pttLen, "Exif.SamsungPreview.JPEGInterchangeFormatLength"},
PreviewTags{pttIfd, "SamsungPreview"},
PreviewTags{pttLen, "Exif.Thumbnail.StripByteCounts"},
PreviewTags{pttIfd, "Thumbnail"},
PreviewTags{pttLen, "Exif.Thumbnail.JPEGInterchangeFormatLength"},
PreviewTags{pttIfd, "Thumbnail"},
};
bool delTags = false;
for (auto&& filteredPvTag : filteredPvTags) {

58
src/image.cpp
Unescape Escape View File

@ -66,41 +66,41 @@ namespace {
};
/// \todo Use std::unordered_map for implementing the registry. Avoid to use ImageType::none
const Registry registry[] = {
//image type creation fct type check Exif mode IPTC mode XMP mode Comment mode
constexpr Registry registry[] = {
// image type creation fct type check Exif mode IPTC mode XMP mode Comment mode
//--------------- --------------- ---------- ----------- ----------- ----------- ------------
{ ImageType::jpeg, newJpegInstance, isJpegType, amReadWrite, amReadWrite, amReadWrite, amReadWrite },
{ ImageType::exv, newExvInstance, isExvType, amReadWrite, amReadWrite, amReadWrite, amReadWrite },
{ ImageType::cr2, newCr2Instance, isCr2Type, amReadWrite, amReadWrite, amReadWrite, amNone },
{ ImageType::crw, newCrwInstance, isCrwType, amReadWrite, amNone, amNone, amReadWrite },
{ ImageType::mrw, newMrwInstance, isMrwType, amRead, amRead, amRead, amNone },
{ ImageType::tiff, newTiffInstance, isTiffType, amReadWrite, amReadWrite, amReadWrite, amNone },
{ ImageType::webp, newWebPInstance, isWebPType, amReadWrite, amNone, amReadWrite, amNone },
{ ImageType::dng, newTiffInstance, isTiffType, amReadWrite, amReadWrite, amReadWrite, amNone },
{ ImageType::nef, newTiffInstance, isTiffType, amReadWrite, amReadWrite, amReadWrite, amNone },
{ ImageType::pef, newTiffInstance, isTiffType, amReadWrite, amReadWrite, amReadWrite, amNone },
{ ImageType::arw, newTiffInstance, isTiffType, amRead, amRead, amRead, amNone },
{ ImageType::rw2, newRw2Instance, isRw2Type, amRead, amRead, amRead, amNone },
{ ImageType::sr2, newTiffInstance, isTiffType, amRead, amRead, amRead, amNone },
{ ImageType::srw, newTiffInstance, isTiffType, amReadWrite, amReadWrite, amReadWrite, amNone },
{ ImageType::orf, newOrfInstance, isOrfType, amReadWrite, amReadWrite, amReadWrite, amNone },
{ImageType::jpeg, newJpegInstance, isJpegType, amReadWrite, amReadWrite, amReadWrite, amReadWrite},
{ImageType::exv, newExvInstance, isExvType, amReadWrite, amReadWrite, amReadWrite, amReadWrite},
{ImageType::cr2, newCr2Instance, isCr2Type, amReadWrite, amReadWrite, amReadWrite, amNone},
{ImageType::crw, newCrwInstance, isCrwType, amReadWrite, amNone, amNone, amReadWrite},
{ImageType::mrw, newMrwInstance, isMrwType, amRead, amRead, amRead, amNone},
{ImageType::tiff, newTiffInstance, isTiffType, amReadWrite, amReadWrite, amReadWrite, amNone},
{ImageType::webp, newWebPInstance, isWebPType, amReadWrite, amNone, amReadWrite, amNone},
{ImageType::dng, newTiffInstance, isTiffType, amReadWrite, amReadWrite, amReadWrite, amNone},
{ImageType::nef, newTiffInstance, isTiffType, amReadWrite, amReadWrite, amReadWrite, amNone},
{ImageType::pef, newTiffInstance, isTiffType, amReadWrite, amReadWrite, amReadWrite, amNone},
{ImageType::arw, newTiffInstance, isTiffType, amRead, amRead, amRead, amNone},
{ImageType::rw2, newRw2Instance, isRw2Type, amRead, amRead, amRead, amNone},
{ImageType::sr2, newTiffInstance, isTiffType, amRead, amRead, amRead, amNone},
{ImageType::srw, newTiffInstance, isTiffType, amReadWrite, amReadWrite, amReadWrite, amNone},
{ImageType::orf, newOrfInstance, isOrfType, amReadWrite, amReadWrite, amReadWrite, amNone},
#ifdef EXV_HAVE_LIBZ
{ ImageType::png, newPngInstance, isPngType, amReadWrite, amReadWrite, amReadWrite, amReadWrite },
{ImageType::png, newPngInstance, isPngType, amReadWrite, amReadWrite, amReadWrite, amReadWrite},
#endif // EXV_HAVE_LIBZ
{ ImageType::pgf, newPgfInstance, isPgfType, amReadWrite, amReadWrite, amReadWrite, amReadWrite },
{ ImageType::raf, newRafInstance, isRafType, amRead, amRead, amRead, amNone },
{ ImageType::eps, newEpsInstance, isEpsType, amNone, amNone, amReadWrite, amNone },
{ ImageType::xmp, newXmpInstance, isXmpType, amReadWrite, amReadWrite, amReadWrite, amNone },
{ ImageType::gif, newGifInstance, isGifType, amNone, amNone, amNone, amNone },
{ ImageType::psd, newPsdInstance, isPsdType, amReadWrite, amReadWrite, amReadWrite, amNone },
{ ImageType::tga, newTgaInstance, isTgaType, amNone, amNone, amNone, amNone },
{ ImageType::bmp, newBmpInstance, isBmpType, amNone, amNone, amNone, amNone },
{ ImageType::jp2, newJp2Instance, isJp2Type, amReadWrite, amReadWrite, amReadWrite, amNone },
{ImageType::pgf, newPgfInstance, isPgfType, amReadWrite, amReadWrite, amReadWrite, amReadWrite},
{ImageType::raf, newRafInstance, isRafType, amRead, amRead, amRead, amNone},
{ImageType::eps, newEpsInstance, isEpsType, amNone, amNone, amReadWrite, amNone},
{ImageType::xmp, newXmpInstance, isXmpType, amReadWrite, amReadWrite, amReadWrite, amNone},
{ImageType::gif, newGifInstance, isGifType, amNone, amNone, amNone, amNone},
{ImageType::psd, newPsdInstance, isPsdType, amReadWrite, amReadWrite, amReadWrite, amNone},
{ImageType::tga, newTgaInstance, isTgaType, amNone, amNone, amNone, amNone},
{ImageType::bmp, newBmpInstance, isBmpType, amNone, amNone, amNone, amNone},
{ImageType::jp2, newJp2Instance, isJp2Type, amReadWrite, amReadWrite, amReadWrite, amNone},
#ifdef EXV_ENABLE_BMFF
{ ImageType::bmff, newBmffInstance, isBmffType, amRead, amRead, amRead, amNone },
{ImageType::bmff, newBmffInstance, isBmffType, amRead, amRead, amRead, amNone},
#endif // EXV_ENABLE_BMFF
// End of list marker
{ ImageType::none, nullptr, nullptr, amNone, amNone, amNone, amNone }
{ImageType::none, nullptr, nullptr, amNone, amNone, amNone, amNone},
};
std::string pathOfFileUrl(const std::string& url) {

55
src/jp2image.cpp
Unescape Escape View File

@ -18,11 +18,11 @@
#include <iostream>
// JPEG-2000 box types
const uint32_t kJp2BoxTypeJp2Header = 0x6a703268; // 'jp2h'
const uint32_t kJp2BoxTypeImageHeader = 0x69686472; // 'ihdr'
const uint32_t kJp2BoxTypeColorHeader = 0x636f6c72; // 'colr'
const uint32_t kJp2BoxTypeUuid = 0x75756964; // 'uuid'
const uint32_t kJp2BoxTypeClose = 0x6a703263; // 'jp2c'
static constexpr uint32_t kJp2BoxTypeJp2Header = 0x6a703268; // 'jp2h'
static constexpr uint32_t kJp2BoxTypeImageHeader = 0x69686472; // 'ihdr'
static constexpr uint32_t kJp2BoxTypeColorHeader = 0x636f6c72; // 'colr'
static constexpr uint32_t kJp2BoxTypeUuid = 0x75756964; // 'uuid'
static constexpr uint32_t kJp2BoxTypeClose = 0x6a703263; // 'jp2c'
// from openjpeg-2.1.2/src/lib/openjp2/jp2.h
/*#define JPIP_JPIP 0x6a706970*/
@ -53,30 +53,31 @@ const uint32_t kJp2BoxTypeClose = 0x6a703263; // 'jp2c'
//
// See http://www.jpeg.org/public/wg1n2600.doc for information about embedding IPTC-NAA data in JPEG-2000 files
// See http://www.adobe.com/devnet/xmp/pdfs/xmp_specification.pdf for information about embedding XMP data in JPEG-2000 files
const unsigned char kJp2UuidExif[] = "JpgTiffExif->JP2";
const unsigned char kJp2UuidIptc[] = "\x33\xc7\xa4\xd2\xb8\x1d\x47\x23\xa0\xba\xf1\xa3\xe0\x97\xad\x38";
const unsigned char kJp2UuidXmp[] = "\xbe\x7a\xcf\xcb\x97\xa9\x42\xe8\x9c\x71\x99\x94\x91\xe3\xaf\xac";
static constexpr unsigned char kJp2UuidExif[] = "JpgTiffExif->JP2";
static constexpr unsigned char kJp2UuidIptc[] = "\x33\xc7\xa4\xd2\xb8\x1d\x47\x23\xa0\xba\xf1\xa3\xe0\x97\xad\x38";
static constexpr unsigned char kJp2UuidXmp[] = "\xbe\x7a\xcf\xcb\x97\xa9\x42\xe8\x9c\x71\x99\x94\x91\xe3\xaf\xac";
// See section B.1.1 (JPEG 2000 Signature box) of JPEG-2000 specification
const unsigned char Jp2Signature[12] = { 0x00, 0x00, 0x00, 0x0c, 0x6a, 0x50, 0x20, 0x20, 0x0d, 0x0a, 0x87, 0x0a };
const unsigned char Jp2Blank[] = { 0x00,0x00,0x00,0x0c,0x6a,0x50,0x20,0x20,0x0d,0x0a,0x87,0x0a,0x00,0x00,0x00,0x14,
0x66,0x74,0x79,0x70,0x6a,0x70,0x32,0x20,0x00,0x00,0x00,0x00,0x6a,0x70,0x32,0x20,
0x00,0x00,0x00,0x2d,0x6a,0x70,0x32,0x68,0x00,0x00,0x00,0x16,0x69,0x68,0x64,0x72,
0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x07,0x07,0x00,0x00,0x00,0x00,
0x00,0x0f,0x63,0x6f,0x6c,0x72,0x01,0x00,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,
0x00,0x6a,0x70,0x32,0x63,0xff,0x4f,0xff,0x51,0x00,0x29,0x00,0x00,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x07,
0x01,0x01,0xff,0x64,0x00,0x23,0x00,0x01,0x43,0x72,0x65,0x61,0x74,0x6f,0x72,0x3a,
0x20,0x4a,0x61,0x73,0x50,0x65,0x72,0x20,0x56,0x65,0x72,0x73,0x69,0x6f,0x6e,0x20,
0x31,0x2e,0x39,0x30,0x30,0x2e,0x31,0xff,0x52,0x00,0x0c,0x00,0x00,0x00,0x01,0x00,
0x05,0x04,0x04,0x00,0x01,0xff,0x5c,0x00,0x13,0x40,0x40,0x48,0x48,0x50,0x48,0x48,
0x50,0x48,0x48,0x50,0x48,0x48,0x50,0x48,0x48,0x50,0xff,0x90,0x00,0x0a,0x00,0x00,
0x00,0x00,0x00,0x2d,0x00,0x01,0xff,0x5d,0x00,0x14,0x00,0x40,0x40,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x93,0xcf,0xb4,
0x04,0x00,0x80,0x80,0x80,0x80,0x80,0xff,0xd9
};
static constexpr unsigned char Jp2Signature[] = {
0x00, 0x00, 0x00, 0x0c, 0x6a, 0x50, 0x20, 0x20, 0x0d, 0x0a, 0x87, 0x0a,
};
static constexpr unsigned char Jp2Blank[] = {
0x00, 0x00, 0x00, 0x0c, 0x6a, 0x50, 0x20, 0x20, 0x0d, 0x0a, 0x87, 0x0a, 0x00, 0x00, 0x00, 0x14, 0x66, 0x74,
0x79, 0x70, 0x6a, 0x70, 0x32, 0x20, 0x00, 0x00, 0x00, 0x00, 0x6a, 0x70, 0x32, 0x20, 0x00, 0x00, 0x00, 0x2d,
0x6a, 0x70, 0x32, 0x68, 0x00, 0x00, 0x00, 0x16, 0x69, 0x68, 0x64, 0x72, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
0x00, 0x01, 0x00, 0x01, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x63, 0x6f, 0x6c, 0x72, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x6a, 0x70, 0x32, 0x63, 0xff, 0x4f, 0xff, 0x51, 0x00,
0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x07, 0x01, 0x01, 0xff, 0x64, 0x00, 0x23, 0x00, 0x01, 0x43, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x3a,
0x20, 0x4a, 0x61, 0x73, 0x50, 0x65, 0x72, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x31, 0x2e,
0x39, 0x30, 0x30, 0x2e, 0x31, 0xff, 0x52, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x05, 0x04, 0x04, 0x00,
0x01, 0xff, 0x5c, 0x00, 0x13, 0x40, 0x40, 0x48, 0x48, 0x50, 0x48, 0x48, 0x50, 0x48, 0x48, 0x50, 0x48, 0x48,
0x50, 0x48, 0x48, 0x50, 0xff, 0x90, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x01, 0xff, 0x5d,
0x00, 0x14, 0x00, 0x40, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0x93, 0xcf, 0xb4, 0x04, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xd9,
};
//! @cond IGNORE
struct Jp2BoxHeader

3
src/jpgimage.cpp
Unescape Escape View File

@ -1243,9 +1243,6 @@ namespace Exiv2 {
return result;
}
const char ExvImage::exiv2Id_[] = "Exiv2";
const byte ExvImage::blank_[] = { 0xff,0x01,'E','x','i','v','2',0xff,0xd9 };
ExvImage::ExvImage(BasicIo::UniquePtr io, bool create)
: JpegBase(ImageType::exv, std::move(io), create, blank_, sizeof(blank_))
{

4
src/makernote_int.cpp
Unescape Escape View File

@ -1132,12 +1132,12 @@ namespace Exiv2::Internal {
}
int sony2010eSelector(uint16_t /*tag*/, const byte* /*pData*/, size_t /*size*/, TiffComponent* const pRoot)
{
static constexpr const char* models[] = {
static constexpr auto models = std::array{
"SLT-A58", "SLT-A99", "ILCE-3000", "ILCE-3500", "NEX-3N", "NEX-5R", "NEX-5T",
"NEX-6", "VG30E", "VG900", "DSC-RX100", "DSC-RX1", "DSC-RX1R", "DSC-HX300",
"DSC-HX50V", "DSC-TX30", "DSC-WX60", "DSC-WX200", "DSC-WX300",
};
return std::find(std::begin(models), std::end(models), getExifModel(pRoot)) != std::end(models) ? 0 : -1;
return std::find(models.begin(), models.end(), getExifModel(pRoot)) != std::end(models) ? 0 : -1;
}
int sony2FpSelector(uint16_t /*tag*/, const byte* /*pData*/, size_t /*size*/, TiffComponent* const pRoot)

5
src/minoltamn_int.cpp
Unescape Escape View File

@ -8,6 +8,7 @@
#include "exif.hpp"
#include "i18n.h" // NLS support.
#include <array>
#include <sstream>
#include <cstdio> // popen to call exiftool
@ -2137,7 +2138,7 @@ namespace Exiv2::Internal {
std::string maxAperture = getKeyString("Exif.Photo.MaxApertureValue" ,metadata);
std::string F1_8 = "434/256" ;
static constexpr const char* maxApertures[] = {
static constexpr auto maxApertures = std::array{
"926/256", // F3.5
"1024/256", // F4
"1110/256", // F4.5
@ -2155,7 +2156,7 @@ namespace Exiv2::Internal {
} catch (...) {}
if (model == "ILCE-6000" &&
std::find(std::begin(maxApertures), std::end(maxApertures), maxAperture) != std::end(maxApertures))
std::find(maxApertures.begin(), maxApertures.end(), maxAperture) != maxApertures.end())
try {
long focalLength = getKeyLong("Exif.Photo.FocalLength", metadata);
if (focalLength > 0) {

12
src/nikonmn_int.cpp
Unescape Escape View File

@ -10,6 +10,7 @@
#include "value.hpp"
// + standard includes
#include <array>
#include <cmath>
// *****************************************************************************
@ -2640,14 +2641,9 @@ if (!metadata) {
byte raw[] = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
static const char* tags[] = {
"LensIDNumber",
"LensFStops",
"MinFocalLength",
"MaxFocalLength",
"MaxApertureAtMinFocal",
"MaxApertureAtMaxFocal",
"MCUVersion"
static constexpr auto tags = std::array{
"LensIDNumber", "LensFStops", "MinFocalLength", "MaxFocalLength", "MaxApertureAtMinFocal",
"MaxApertureAtMaxFocal", "MCUVersion",
};
const std::string pre = std::string("Exif.") + group + std::string(".");

25
src/pngimage.cpp
Unescape Escape View File

@ -20,20 +20,21 @@
#include <iostream>
// Signature from front of PNG file
const unsigned char pngSignature[8] = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
const unsigned char pngBlank[] = { 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,
0xde,0x00,0x00,0x00,0x01,0x73,0x52,0x47,0x42,0x00,0xae,0xce,0x1c,0xe9,0x00,0x00,
0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x13,0x00,0x00,0x0b,0x13,0x01,0x00,
0x9a,0x9c,0x18,0x00,0x00,0x00,0x0c,0x49,0x44,0x41,0x54,0x08,0xd7,0x63,0xf8,0xff,
0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,0xe7,0x00,0x00,0x00,0x00,0x49,
0x45,0x4e,0x44,0xae,0x42,0x60,0x82
namespace {
// Signature from front of PNG file
constexpr unsigned char pngSignature[] = {
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
};
constexpr unsigned char pngBlank[] = {
0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53, 0xde, 0x00, 0x00, 0x00,
0x01, 0x73, 0x52, 0x47, 0x42, 0x00, 0xae, 0xce, 0x1c, 0xe9, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73,
0x00, 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13, 0x01, 0x00, 0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x0c, 0x49,
0x44, 0x41, 0x54, 0x08, 0xd7, 0x63, 0xf8, 0xff, 0xff, 0x3f, 0x00, 0x05, 0xfe, 0x02, 0xfe, 0xdc, 0xcc, 0x59,
0xe7, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
};
namespace
{
const auto nullComp = reinterpret_cast<const Exiv2::byte*>("\0\0");
const auto typeICCP = reinterpret_cast<const Exiv2::byte*>("iCCP");
inline bool compare(const char* str, const Exiv2::DataBuf& buf, size_t length)

5
src/rw2image.cpp
Unescape Escape View File

@ -13,6 +13,7 @@
#include "tiffimage_int.hpp"
// + standard includes
#include <array>
#ifdef EXIV2_DEBUG_MESSAGES
#include <iostream>
#endif
@ -143,7 +144,7 @@ namespace Exiv2 {
}
}
// Remove tags not applicable for raw images
static const char* filteredTags[] = {
static constexpr auto filteredTags = std::array{
"Exif.Photo.ComponentsConfiguration",
"Exif.Photo.CompressedBitsPerPixel",
"Exif.Panasonic.ColorEffect",
@ -171,7 +172,7 @@ namespace Exiv2 {
"Exif.Photo.Saturation",
"Exif.Photo.Sharpness",
"Exif.Image.PrintImageMatching",
"Exif.Image.YCbCrPositioning"
"Exif.Image.YCbCrPositioning",
};
for (auto&& filteredTag : filteredTags) {
auto pos = prevData.findKey(ExifKey(filteredTag));

13
src/sonymn_int.cpp
Unescape Escape View File

@ -9,6 +9,7 @@
#include "tiffcomposite_int.hpp"
#include "value.hpp"
#include <array>
#include <cmath>
// *****************************************************************************
@ -1118,12 +1119,12 @@ namespace Exiv2::Internal {
return os << "(" << value << ")";
// Models that support this tag
static constexpr const char* models[] = { "ILCA-68", "ILCA-77M2", "ILCA-99M2",
"ILCE-5000", "ILCE-5100", "ILCE-6000", "ILCE-6300", "ILCE-6500", "ILCE-7",
"ILCE-7M2", "ILCE-7R", "ILCE-7RM2", "ILCE-7S", "ILCE-7SM2", "ILCE-QX1",
"DSC-HX350", "DSC-HX400V", "DSC-HX60V", "DSC-HX80", "DSC-HX90", "DSC-HX90V",
"DSC-QX30", "DSC-RX0", "DSC-RX1RM2", "DSC-RX10", "DSC-RX10M2", "DSC-RX10M3",
"DSC-RX100M3", "DSC-RX100M4", "DSC-RX100M5", "DSC-WX220", "DSC-WX350", "DSC-WX500"
static constexpr auto models = std::array{
"ILCA-68", "ILCA-77M2", "ILCA-99M2", "ILCE-5000", "ILCE-5100", "ILCE-6000", "ILCE-6300",
"ILCE-6500", "ILCE-7", "ILCE-7M2", "ILCE-7R", "ILCE-7RM2", "ILCE-7S", "ILCE-7SM2",
"ILCE-QX1", "DSC-HX350", "DSC-HX400V", "DSC-HX60V", "DSC-HX80", "DSC-HX90", "DSC-HX90V",
"DSC-QX30", "DSC-RX0", "DSC-RX1RM2", "DSC-RX10", "DSC-RX10M2", "DSC-RX10M3", "DSC-RX100M3",
"DSC-RX100M4", "DSC-RX100M5", "DSC-WX220", "DSC-WX350", "DSC-WX500",
};
std::string model = pos->toString();

48
src/tags.cpp
Unescape Escape View File

@ -11,6 +11,8 @@
#include "tags_int.hpp"
#include "types.hpp"
#include <array>
// *****************************************************************************
// class member definitions
namespace Exiv2 {
@ -19,29 +21,29 @@ namespace Exiv2 {
//! List of all defined Exif sections.
constexpr SectionInfo sectionInfo[] = {
{ sectionIdNotSet, "(UnknownSection)", N_("Unknown section") },
{ imgStruct, "ImageStructure", N_("Image data structure") },
{ recOffset, "RecordingOffset", N_("Recording offset") },
{ imgCharacter, "ImageCharacteristics", N_("Image data characteristics") },
{ otherTags, "OtherTags", N_("Other data") },
{ exifFormat, "ExifFormat", N_("Exif data structure") },
{ exifVersion, "ExifVersion", N_("Exif version") },
{ imgConfig, "ImageConfig", N_("Image configuration") },
{ userInfo, "UserInfo", N_("User information") },
{ relatedFile, "RelatedFile", N_("Related file") },
{ dateTime, "DateTime", N_("Date and time") },
{ captureCond, "CaptureConditions", N_("Picture taking conditions") },
{ gpsTags, "GPS", N_("GPS information") },
{ iopTags, "Interoperability", N_("Interoperability information") },
{ mpfTags, "MPF", N_("CIPA Multi-Picture Format") },
{ makerTags, "Makernote", N_("Vendor specific information") },
{ dngTags, "DngTags", N_("Adobe DNG tags") },
{ panaRaw, "PanasonicRaw", N_("Panasonic RAW tags") },
{ tiffEp, "TIFF/EP", N_("TIFF/EP tags") },
{ tiffPm6, "TIFF&PM6", N_("TIFF PageMaker 6.0 tags") },
{ adobeOpi, "AdobeOPI", N_("Adobe OPI tags") },
{ lastSectionId, "(LastSection)", N_("Last section") }
constexpr auto sectionInfo = std::array{
SectionInfo{sectionIdNotSet, "(UnknownSection)", N_("Unknown section")},
SectionInfo{imgStruct, "ImageStructure", N_("Image data structure")},
SectionInfo{recOffset, "RecordingOffset", N_("Recording offset")},
SectionInfo{imgCharacter, "ImageCharacteristics", N_("Image data characteristics")},
SectionInfo{otherTags, "OtherTags", N_("Other data")},
SectionInfo{exifFormat, "ExifFormat", N_("Exif data structure")},
SectionInfo{exifVersion, "ExifVersion", N_("Exif version")},
SectionInfo{imgConfig, "ImageConfig", N_("Image configuration")},
SectionInfo{userInfo, "UserInfo", N_("User information")},
SectionInfo{relatedFile, "RelatedFile", N_("Related file")},
SectionInfo{dateTime, "DateTime", N_("Date and time")},
SectionInfo{captureCond, "CaptureConditions", N_("Picture taking conditions")},
SectionInfo{gpsTags, "GPS", N_("GPS information")},
SectionInfo{iopTags, "Interoperability", N_("Interoperability information")},
SectionInfo{mpfTags, "MPF", N_("CIPA Multi-Picture Format")},
SectionInfo{makerTags, "Makernote", N_("Vendor specific information")},
SectionInfo{dngTags, "DngTags", N_("Adobe DNG tags")},
SectionInfo{panaRaw, "PanasonicRaw", N_("Panasonic RAW tags")},
SectionInfo{tiffEp, "TIFF/EP", N_("TIFF/EP tags")},
SectionInfo{tiffPm6, "TIFF&PM6", N_("TIFF PageMaker 6.0 tags")},
SectionInfo{adobeOpi, "AdobeOPI", N_("Adobe OPI tags")},
SectionInfo{lastSectionId, "(LastSection)", N_("Last section")},
};
} // namespace Exiv2

34
src/tiffimage.cpp
Unescape Escape View File

@ -12,6 +12,7 @@
#include "tiffimage_int.hpp"
#include "types.hpp"
#include <array>
#include <iostream>
/* --------------------------------------------------------------------------
@ -54,10 +55,10 @@ namespace Exiv2 {
};
//! List of TIFF compression to MIME type mappings
constexpr MimeTypeList mimeTypeList[] = {
{32770, "image/x-samsung-srw"},
{34713, "image/x-nikon-nef"},
{65535, "image/x-pentax-pef"},
constexpr auto mimeTypeList = std::array{
MimeTypeList{32770, "image/x-samsung-srw"},
MimeTypeList{34713, "image/x-nikon-nef"},
MimeTypeList{65535, "image/x-pentax-pef"},
};
std::string TiffImage::mimeType() const
@ -68,8 +69,9 @@ namespace Exiv2 {
std::string key = "Exif." + primaryGroup() + ".Compression";
auto md = exifData_.findKey(ExifKey(key));
if (md != exifData_.end() && md->count() > 0) {
const MimeTypeList* i = find(mimeTypeList, static_cast<int>(md->toInt64()));
if (i) mimeType_ = std::string(i->mimeType_);
auto i = std::find(mimeTypeList.begin(), mimeTypeList.end(), static_cast<int>(md->toInt64()));
if (i != mimeTypeList.end())
mimeType_ = std::string(i->mimeType_);
}
return mimeType_;
}
@ -78,17 +80,11 @@ namespace Exiv2 {
{
if (!primaryGroup_.empty()) return primaryGroup_;
static const char* keys[] = {
"Exif.Image.NewSubfileType",
"Exif.SubImage1.NewSubfileType",
"Exif.SubImage2.NewSubfileType",
"Exif.SubImage3.NewSubfileType",
"Exif.SubImage4.NewSubfileType",
"Exif.SubImage5.NewSubfileType",
"Exif.SubImage6.NewSubfileType",
"Exif.SubImage7.NewSubfileType",
"Exif.SubImage8.NewSubfileType",
"Exif.SubImage9.NewSubfileType"
static constexpr auto keys = std::array{
"Exif.Image.NewSubfileType", "Exif.SubImage1.NewSubfileType", "Exif.SubImage2.NewSubfileType",
"Exif.SubImage3.NewSubfileType", "Exif.SubImage4.NewSubfileType", "Exif.SubImage5.NewSubfileType",
"Exif.SubImage6.NewSubfileType", "Exif.SubImage7.NewSubfileType", "Exif.SubImage8.NewSubfileType",
"Exif.SubImage9.NewSubfileType",
};
// Find the group of the primary image, default to "Image"
primaryGroup_ = std::string("Image");
@ -250,8 +246,8 @@ namespace Exiv2 {
ExifData ed = exifData;
// Delete IFDs which do not occur in TIFF images
static const IfdId filteredIfds[] = {
panaRawId
static constexpr auto filteredIfds = std::array{
panaRawId,
};
for (auto&& filteredIfd : filteredIfds) {
#ifdef EXIV2_DEBUG_MESSAGES

18
src/tiffimage_int.cpp
Unescape Escape View File

@ -8,6 +8,7 @@
#include "tiffvisitor_int.hpp"
#include "i18n.h" // NLS support.
#include <array>
#include <iostream>
// Shortcuts for the newTiffBinaryArray templates.
@ -2159,20 +2160,9 @@ namespace Exiv2::Internal {
if (!pSourceDir)
return;
const IfdId imageGroups[] = {
ifd0Id,
ifd1Id,
ifd2Id,
ifd3Id,
subImage1Id,
subImage2Id,
subImage3Id,
subImage4Id,
subImage5Id,
subImage6Id,
subImage7Id,
subImage8Id,
subImage9Id
static constexpr auto imageGroups = std::array{
ifd0Id, ifd1Id, ifd2Id, ifd3Id, subImage1Id, subImage2Id, subImage3Id,
subImage4Id, subImage5Id, subImage6Id, subImage7Id, subImage8Id, subImage9Id,
};
for (auto&& imageGroup : imageGroups) {

34
src/tiffvisitor_int.cpp
Unescape Escape View File

@ -441,27 +441,27 @@ namespace Exiv2::Internal {
const uint16_t nMasks = (nPoints+15)/(sizeof(uint16_t) * 8);
int nStart = 0;
/// \todo make this static
struct {
static const struct
{
uint16_t tag ;
uint16_t size ;
bool bSigned;
} records[] = {
{ 0x2600 , 1 , true }, // AFInfoSize
{ 0x2601 , 1 , true }, // AFAreaMode
{ 0x2602 , 1 , true }, // AFNumPoints
{ 0x2603 , 1 , true }, // AFValidPoints
{ 0x2604 , 1 , true }, // AFCanonImageWidth
{ 0x2605 , 1 , true }, // AFCanonImageHeight
{ 0x2606 , 1 , true }, // AFImageWidth"
{ 0x2607 , 1 , true }, // AFImageHeight
{ 0x2608 , nPoints , true }, // AFAreaWidths
{ 0x2609 , nPoints , true }, // AFAreaHeights
{ 0x260a , nPoints , true }, // AFXPositions
{ 0x260b , nPoints , true }, // AFYPositions
{ 0x260c , nMasks , false }, // AFPointsInFocus
{ 0x260d , nMasks , false }, // AFPointsSelected
{ 0x260e , nMasks , false }, // AFPointsUnusable
{0x2600, 1, true}, // AFInfoSize
{0x2601, 1, true}, // AFAreaMode
{0x2602, 1, true}, // AFNumPoints
{0x2603, 1, true}, // AFValidPoints
{0x2604, 1, true}, // AFCanonImageWidth
{0x2605, 1, true}, // AFCanonImageHeight
{0x2606, 1, true}, // AFImageWidth"
{0x2607, 1, true}, // AFImageHeight
{0x2608, nPoints, true}, // AFAreaWidths
{0x2609, nPoints, true}, // AFAreaHeights
{0x260a, nPoints, true}, // AFXPositions
{0x260b, nPoints, true}, // AFYPositions
{0x260c, nMasks, false}, // AFPointsInFocus
{0x260d, nMasks, false}, // AFPointsSelected
{0x260e, nMasks, false}, // AFPointsUnusable
};
// check we have enough data!
uint16_t count = 0;

64
src/types.cpp
Unescape Escape View File

@ -9,6 +9,7 @@
#include "safe_op.hpp"
// + standard includes
#include <array>
#include <cassert>
#include <cctype>
#include <climits>
@ -39,31 +40,31 @@ namespace {
}; // struct TypeInfoTable
//! Lookup list with information of Exiv2 types
const TypeInfoTable typeInfoTable[] = {
{ Exiv2::invalidTypeId, "Invalid", 0 },
{ Exiv2::unsignedByte, "Byte", 1 },
{ Exiv2::asciiString, "Ascii", 1 },
{ Exiv2::unsignedShort, "Short", 2 },
{ Exiv2::unsignedLong, "Long", 4 },
{ Exiv2::unsignedRational, "Rational", 8 },
{ Exiv2::signedByte, "SByte", 1 },
{ Exiv2::undefined, "Undefined", 1 },
{ Exiv2::signedShort, "SShort", 2 },
{ Exiv2::signedLong, "SLong", 4 },
{ Exiv2::signedRational, "SRational", 8 },
{ Exiv2::tiffFloat, "Float", 4 },
{ Exiv2::tiffDouble, "Double", 8 },
{ Exiv2::tiffIfd, "Ifd", 4 },
{ Exiv2::string, "String", 1 },
{ Exiv2::date, "Date", 8 },
{ Exiv2::time, "Time", 11 },
{ Exiv2::comment, "Comment", 1 },
{ Exiv2::directory, "Directory", 1 },
{ Exiv2::xmpText, "XmpText", 1 },
{ Exiv2::xmpAlt, "XmpAlt", 1 },
{ Exiv2::xmpBag, "XmpBag", 1 },
{ Exiv2::xmpSeq, "XmpSeq", 1 },
{ Exiv2::langAlt, "LangAlt", 1 }
constexpr auto typeInfoTable = std::array{
TypeInfoTable{Exiv2::invalidTypeId, "Invalid", 0},
TypeInfoTable{Exiv2::unsignedByte, "Byte", 1},
TypeInfoTable{Exiv2::asciiString, "Ascii", 1},
TypeInfoTable{Exiv2::unsignedShort, "Short", 2},
TypeInfoTable{Exiv2::unsignedLong, "Long", 4},
TypeInfoTable{Exiv2::unsignedRational, "Rational", 8},
TypeInfoTable{Exiv2::signedByte, "SByte", 1},
TypeInfoTable{Exiv2::undefined, "Undefined", 1},
TypeInfoTable{Exiv2::signedShort, "SShort", 2},
TypeInfoTable{Exiv2::signedLong, "SLong", 4},
TypeInfoTable{Exiv2::signedRational, "SRational", 8},
TypeInfoTable{Exiv2::tiffFloat, "Float", 4},
TypeInfoTable{Exiv2::tiffDouble, "Double", 8},
TypeInfoTable{Exiv2::tiffIfd, "Ifd", 4},
TypeInfoTable{Exiv2::string, "String", 1},
TypeInfoTable{Exiv2::date, "Date", 8},
TypeInfoTable{Exiv2::time, "Time", 11},
TypeInfoTable{Exiv2::comment, "Comment", 1},
TypeInfoTable{Exiv2::directory, "Directory", 1},
TypeInfoTable{Exiv2::xmpText, "XmpText", 1},
TypeInfoTable{Exiv2::xmpAlt, "XmpAlt", 1},
TypeInfoTable{Exiv2::xmpBag, "XmpBag", 1},
TypeInfoTable{Exiv2::xmpSeq, "XmpSeq", 1},
TypeInfoTable{Exiv2::langAlt, "LangAlt", 1},
};
} // namespace
@ -74,23 +75,24 @@ namespace Exiv2 {
const char* TypeInfo::typeName(TypeId typeId)
{
const TypeInfoTable* tit = find(typeInfoTable, typeId);
if (!tit)
auto tit = std::find(typeInfoTable.begin(), typeInfoTable.end(), typeId);
if (tit == typeInfoTable.end())
return nullptr;
return tit->name_;
}
TypeId TypeInfo::typeId(const std::string& typeName)
{
const TypeInfoTable* tit = find(typeInfoTable, typeName);
if (!tit) return invalidTypeId;
auto tit = std::find(typeInfoTable.begin(), typeInfoTable.end(), typeName);
if (tit == typeInfoTable.end())
return invalidTypeId;
return tit->typeId_;
}
size_t TypeInfo::typeSize(TypeId typeId)
{
const TypeInfoTable* tit = find(typeInfoTable, typeId);
if (!tit)
auto tit = std::find(typeInfoTable.begin(), typeInfoTable.end(), typeId);
if (tit == typeInfoTable.end())
return 0;
return tit->size_;
}

10
src/value.cpp
Unescape Escape View File

@ -343,21 +343,19 @@ namespace Exiv2 {
return os << value_.substr(0, pos);
}
CommentValue::CharsetTable::CharsetTable(CharsetId charsetId,
const char* name,
const char* code)
constexpr CommentValue::CharsetTable::CharsetTable(CharsetId charsetId, const char* name, const char* code)
: charsetId_(charsetId), name_(name), code_(code)
{
}
//! Lookup list of supported IFD type information
const CommentValue::CharsetTable CommentValue::CharsetInfo::charsetTable_[] = {
constexpr CommentValue::CharsetTable CommentValue::CharsetInfo::charsetTable_[] = {
CharsetTable(ascii, "Ascii", "ASCII\0\0\0"),
CharsetTable(jis, "Jis", "JIS\0\0\0\0\0"),
CharsetTable(unicode, "Unicode", "UNICODE\0"),
CharsetTable(undefined, "Undefined", "\0\0\0\0\0\0\0\0"),
CharsetTable(invalidCharsetId, "InvalidCharsetId", "\0\0\0\0\0\0\0\0"),
CharsetTable(lastCharsetId, "InvalidCharsetId", "\0\0\0\0\0\0\0\0")
CharsetTable(lastCharsetId, "InvalidCharsetId", "\0\0\0\0\0\0\0\0"),
};
const char* CommentValue::CharsetInfo::name(CharsetId charsetId)
@ -914,7 +912,7 @@ namespace Exiv2 {
static const std::regex reBasic(R"(^(\d{4})(\d{2})(\d{2}))");
std::smatch sm;
auto printWarning = [](){
auto printWarning = [] {
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << Error(ErrorCode::kerUnsupportedDateFormat) << "\n";
#endif

8
src/version.cpp
Unescape Escape View File

@ -16,6 +16,7 @@
#endif
// + standard includes
#include <array>
#include <fstream>
#include <regex>
#include <set>
@ -223,11 +224,14 @@ void Exiv2::dumpLibraryInfo(std::ostream& os,const std::vector<std::regex>& keys
// add edition in brackets
// 7.10 = 2003 8.00 = 2005 etc 12.00 = 2013 13.00 = 2015 (yet the installer labels it as 14.0!)
size_t edition = (_MSC_VER-600)/100;
const char* editions[] = { "0","1","2","3","4","5","6","2003", "2005", "2008", "2010", "2012","2013","2015","2017","2019"};
constexpr auto editions = std::array{
"0", "1", "2", "3", "4", "5", "6", "2003", "2005", "2008", "2010", "2012", "2013", "2015", "2017", "2019",
};
if ( edition == 13 && _MSC_VER >= 1910 ) edition++ ; // 2017 _MSC_VAR == 1910
if ( edition == 14 && _MSC_VER >= 1920 ) edition++ ; // 2019 _MSC_VAR == 1920
if ( edition > lengthof(editions) ) edition = 0 ;
if (edition > editions.size())
edition = 0;
if ( edition ) {
const size_t len = ::strlen(version);
snprintf(version+len, sizeof(version) - len, " (%s/%s)",editions[edition],bits==64?"x64":"x86");

Write Preview
Loading…
Cancel
Save