diff --git a/include/exiv2/types.hpp b/include/exiv2/types.hpp index 3829110a..23be50d5 100644 --- a/include/exiv2/types.hpp +++ b/include/exiv2/types.hpp @@ -380,18 +380,32 @@ namespace Exiv2 { EXIV2API std::string ws2s(const std::wstring& s); #endif /*! - @brief Return a \em long set to the value represented by \em s. + @brief Return a \em int64_t set to the value represented by \em s. - Besides strings that represent \em long values, the function also + Besides strings that represent \em int64_t values, the function also handles \em float, \em Rational and boolean (see also: stringTo(const std::string& s, bool& ok)). @param s String to parse @param ok Output variable indicating the success of the operation. - @return Returns the \em long value represented by \em s and sets \em ok + @return Returns the \em int64_t value represented by \em s and sets \em ok to \c true if the conversion was successful or \c false if not. */ - EXIV2API long parseLong(const std::string& s, bool& ok); + EXIV2API int64_t parseInt64(const std::string& s, bool& ok); + + /*! + @brief Return a \em uint32_t set to the value represented by \em s. + + Besides strings that represent \em uint32_t values, the function also + handles \em float, \em Rational and boolean + (see also: stringTo(const std::string& s, bool& ok)). + + @param s String to parse + @param ok Output variable indicating the success of the operation. + @return Returns the \em uint32_t value represented by \em s and sets \em ok + to \c true if the conversion was successful or \c false if not. + */ + EXIV2API uint32_t parseUint32(const std::string& s, bool& ok); /*! @brief Return a \em float set to the value represented by \em s. diff --git a/include/exiv2/value.hpp b/include/exiv2/value.hpp index 5c014eb9..b51c5642 100644 --- a/include/exiv2/value.hpp +++ b/include/exiv2/value.hpp @@ -143,13 +143,21 @@ namespace Exiv2 { */ virtual std::string toString(long n) const; /*! - @brief Convert the n-th component of the value to a long. + @brief Convert the n-th component of the value to an int64_t. The behaviour of this method may be undefined if there is no n-th component. @return The converted value. */ - virtual long toLong(long n =0) const =0; + virtual int64_t toInt64(long n =0) const =0; + /*! + @brief Convert the n-th component of the value to a float. + The behaviour of this method may be undefined if there is no + n-th component. + + @return The converted value. + */ + virtual uint32_t toUint32(long n =0) const =0; /*! @brief Convert the n-th component of the value to a float. The behaviour of this method may be undefined if there is no @@ -308,7 +316,8 @@ namespace Exiv2 { n-th component. */ std::string toString(long n) const override; - long toLong(long n = 0) const override; + int64_t toInt64(long n = 0) const override; + uint32_t toUint32(long n = 0) const override; float toFloat(long n = 0) const override; Rational toRational(long n = 0) const override; //@} @@ -385,7 +394,8 @@ namespace Exiv2 { long copy(byte* buf, ByteOrder byteOrder = invalidByteOrder) const override; long count() const override; long size() const override; - long toLong(long n = 0) const override; + int64_t toInt64(long n = 0) const override; + uint32_t toUint32(long n = 0) const override; float toFloat(long n = 0) const override; Rational toRational(long n = 0) const override; std::ostream& write(std::ostream& os) const override; @@ -739,12 +749,19 @@ namespace Exiv2 { long size() const override; long count() const override; /*! - @brief Convert the value to a long. + @brief Convert the value to an int64_t. + The optional parameter \em n is not used and is ignored. + + @return The converted value. + */ + int64_t toInt64(long n = 0) const override; + /*! + @brief Convert the value to an uint32_t. The optional parameter \em n is not used and is ignored. @return The converted value. */ - long toLong(long n = 0) const override; + uint32_t toUint32(long n = 0) const override; /*! @brief Convert the value to a float. The optional parameter \em n is not used and is ignored. @@ -818,7 +835,8 @@ namespace Exiv2 { n-th component. */ std::string toString(long n) const override; - long toLong(long n = 0) const override; + int64_t toInt64(long n = 0) const override; + uint32_t toUint32(long n = 0) const override; float toFloat(long n = 0) const override; Rational toRational(long n = 0) const override; /*! @@ -924,7 +942,8 @@ namespace Exiv2 { to \c false if there is no entry for the language qualifier. */ std::string toString(const std::string& qualifier) const; - long toLong(long n = 0) const override; + int64_t toInt64(long n = 0) const override; + uint32_t toUint32(long n = 0) const override; float toFloat(long n = 0) const override; Rational toRational(long n = 0) const override; /*! @@ -1032,8 +1051,10 @@ namespace Exiv2 { long count() const override; long size() const override; std::ostream& write(std::ostream& os) const override; - //! Return the value as a UNIX calender time converted to long. - long toLong(long n = 0) const override; + //! Return the value as a UNIX calender time converted to int64_t. + int64_t toInt64(long n = 0) const override; + //! Return the value as a UNIX calender time converted to uint32_t. + uint32_t toUint32(long n = 0) const override; //! Return the value as a UNIX calender time converted to float. float toFloat(long n = 0) const override; //! Return the value as a UNIX calender time converted to Rational. @@ -1138,7 +1159,9 @@ namespace Exiv2 { long size() const override; std::ostream& write(std::ostream& os) const override; //! Returns number of seconds in the day in UTC. - long toLong(long n = 0) const override; + int64_t toInt64(long n = 0) const override; + //! Returns number of seconds in the day in UTC. + uint32_t toUint32(long n = 0) const override; //! Returns number of seconds in the day in UTC converted to float. float toFloat(long n = 0) const override; //! Returns number of seconds in the day in UTC converted to Rational. @@ -1241,7 +1264,8 @@ namespace Exiv2 { component. */ std::string toString(long n) const override; - long toLong(long n = 0) const override; + int64_t toInt64(long n = 0) const override; + uint32_t toUint32(long n = 0) const override; float toFloat(long n = 0) const override; Rational toRational(long n = 0) const override; //! Return the size of the data area. @@ -1270,6 +1294,62 @@ namespace Exiv2 { ValueList value_; private: + //! Utility for toInt64, toUint32, etc. + template + inline I float_to_integer_helper(long n) const { + const auto v = value_.at(n); + if (static_cast(std::numeric_limits::min()) <= v && + v <= static_cast(std::numeric_limits::max())) { + return static_cast(v); + } else { + return 0; + } + } + + //! Utility for toInt64, toUint32, etc. + template + inline I rational_to_integer_helper(long n) const { + const auto& t = value_.at(n); + const auto a = t.first; + const auto b = t.second; + + // Protect against divide-by-zero. + if (b <= 0) { + return 0; + } + + // Check for integer overflow. + if (std::is_signed::value == std::is_signed::value) { + // conversion does not change sign + const auto imin = std::numeric_limits::min(); + const auto imax = std::numeric_limits::max(); + if (imax < b || a < imin || imax < a) { + return 0; + } + } else if (std::is_signed::value) { + // conversion is from unsigned to signed + const auto imax = + static_cast::type>(std::numeric_limits::max()); + if (imax < b || imax < a) { + return 0; + } + } else { + // conversion is from signed to unsigned + const auto imax = std::numeric_limits::max(); + if (a < 0) { + return 0; + } + // Inputs are not negative so convert them to unsigned. + const auto a_u = static_cast::type>(a); + const auto b_u = static_cast::type>(b); + if (imax < b_u || imax < a_u) { + return 0; + } + } + + return static_cast(a)/static_cast(b); + } + //! Internal virtual copy constructor. ValueType* clone_() const override; @@ -1585,46 +1665,62 @@ namespace Exiv2 { // Default implementation template - long ValueType::toLong(long n) const + int64_t ValueType::toInt64(long n) const + { + ok_ = true; + return static_cast(value_.at(n)); + } + template + uint32_t ValueType::toUint32(long n) const { ok_ = true; - return static_cast(value_.at(n)); + return static_cast(value_.at(n)); } // #55 crash when value_.at(n).first == LONG_MIN #define LARGE_INT 1000000 // Specialization for double template<> - inline long ValueType::toLong(long n) const + inline int64_t ValueType::toInt64(long n) const + { + return float_to_integer_helper(n); + } + template<> + inline uint32_t ValueType::toUint32(long n) const { - const double v = value_.at(n); - ok_ = (INT_MIN <= v && v <= INT_MAX); - if (!ok_) return 0; - return static_cast(v); + return float_to_integer_helper(n); } // Specialization for float template<> - inline long ValueType::toLong(long n) const + inline int64_t ValueType::toInt64(long n) const { - const double v = value_.at(n); - ok_ = (INT_MIN <= v && v <= INT_MAX); - if (!ok_) return 0; - return static_cast(v); + return float_to_integer_helper(n); + } + template<> + inline uint32_t ValueType::toUint32(long n) const + { + return float_to_integer_helper(n); } // Specialization for rational template<> - inline long ValueType::toLong(long n) const + inline int64_t ValueType::toInt64(long n) const { - ok_ = (value_.at(n).second > 0 && INT_MIN < value_.at(n).first && value_.at(n).first < INT_MAX ); - if (!ok_) return 0; - return value_.at(n).first / value_.at(n).second; + return rational_to_integer_helper(n); + } + template<> + inline uint32_t ValueType::toUint32(long n) const + { + return rational_to_integer_helper(n); } // Specialization for unsigned rational template<> - inline long ValueType::toLong(long n) const + inline int64_t ValueType::toInt64(long n) const + { + return rational_to_integer_helper(n); + } + template<> + inline uint32_t ValueType::toUint32(long n) const { - ok_ = (value_.at(n).second > 0 && value_.at(n).first < LARGE_INT); - if (!ok_) return 0; - return value_.at(n).first / value_.at(n).second; + return rational_to_integer_helper(n); } // Default implementation template diff --git a/samples/stringto-test.cpp b/samples/stringto-test.cpp index d4f8fe70..703ea81d 100644 --- a/samples/stringto-test.cpp +++ b/samples/stringto-test.cpp @@ -78,7 +78,7 @@ int main() std::cout << std::setw(12) << std::left << s; bool ok = false; - long l = Exiv2::parseLong(s, ok); + const auto l = Exiv2::parseInt64(s, ok); std::cout << std::setw(12) << std::left; if (ok) std::cout << l; diff --git a/samples/xmpsample.cpp b/samples/xmpsample.cpp index 7f237bf5..c465f0cb 100644 --- a/samples/xmpsample.cpp +++ b/samples/xmpsample.cpp @@ -88,7 +88,7 @@ try { UNUSED(getv2); assert(isEqual(getv2.toFloat(), 3.1415f)); assert(getv2.ok()); - assert(getv2.toLong() == 3); + assert(getv2.toInt64() == 3); assert(getv2.ok()); Exiv2::Rational R = getv2.toRational(); UNUSED(R); @@ -99,14 +99,14 @@ try { UNUSED(getv3); assert(isEqual(getv3.toFloat(), 5.0f/7.0f)); assert(getv3.ok()); - assert(getv3.toLong() == 0); // long(5.0 / 7.0) + assert(getv3.toInt64() == 0); // long(5.0 / 7.0) assert(getv3.ok()); assert(getv3.toRational() == Exiv2::Rational(5, 7)); assert(getv3.ok()); const Exiv2::Value &getv6 = xmpData["Xmp.dc.six"].value(); UNUSED(getv6); - assert(getv6.toLong() == 0); + assert(getv6.toInt64() == 0); assert(getv6.ok()); assert(getv6.toFloat() == 0.0f); assert(getv6.ok()); @@ -114,12 +114,12 @@ try { assert(getv6.ok()); const Exiv2::Value &getv7 = xmpData["Xmp.dc.seven"].value(); - getv7.toLong(); // this should fail + getv7.toInt64(); // this should fail assert(!getv7.ok()); const Exiv2::Value &getv8 = xmpData["Xmp.dc.eight"].value(); UNUSED(getv8); - assert(getv8.toLong() == 1); + assert(getv8.toInt64() == 1); assert(getv8.ok()); assert(getv8.toFloat() == 1.0f); assert(getv8.ok()); diff --git a/src/actions.cpp b/src/actions.cpp index ca8966e1..1c6899d6 100644 --- a/src/actions.cpp +++ b/src/actions.cpp @@ -573,7 +573,7 @@ namespace Action { // #1114 - show negative values for SByte if (md.typeId() == Exiv2::signedByte) { for ( long c = 0 ; c < md.value().count() ; c++ ) { - long value = md.value().toLong(c); + const auto value = md.value().toInt64(c); os << (c?" ":"") << std::dec << (value < 128 ? value : value - 256); } } else { diff --git a/src/canonmn_int.cpp b/src/canonmn_int.cpp index e046a010..9bef915c 100644 --- a/src/canonmn_int.cpp +++ b/src/canonmn_int.cpp @@ -65,359 +65,359 @@ namespace Exiv2 { //! ModelId, tag 0x0010 constexpr TagDetails canonModelId[] = { - { static_cast(0x00000811), "EOS M6 Mark II"}, - { static_cast(0x00000804), "Powershot G5 X Mark II"}, - { static_cast(0x00000805), "PowerShot SX70 HS"}, - { static_cast(0x00000808), "PowerShot G7 X Mark III"}, - { static_cast(0x00000812), "EOS M200"}, - { static_cast(0x1010000), "PowerShot A30" }, - { static_cast(0x1040000), "PowerShot S300 / Digital IXUS 300 / IXY Digital 300" }, - { static_cast(0x1060000), "PowerShot A20" }, - { static_cast(0x1080000), "PowerShot A10" }, - { static_cast(0x1090000), "PowerShot S110 / Digital IXUS v / IXY Digital 200" }, - { static_cast(0x1100000), "PowerShot G2" }, - { static_cast(0x1110000), "PowerShot S40" }, - { static_cast(0x1120000), "PowerShot S30" }, - { static_cast(0x1130000), "PowerShot A40" }, - { static_cast(0x1140000), "EOS D30" }, - { static_cast(0x1150000), "PowerShot A100" }, - { static_cast(0x1160000), "PowerShot S200 / Digital IXUS v2 / IXY Digital 200a" }, - { static_cast(0x1170000), "PowerShot A200" }, - { static_cast(0x1180000), "PowerShot S330 / Digital IXUS 330 / IXY Digital 300a" }, - { static_cast(0x1190000), "PowerShot G3" }, - { static_cast(0x1210000), "PowerShot S45" }, - { static_cast(0x1230000), "PowerShot SD100 / Digital IXUS II / IXY Digital 30" }, - { static_cast(0x1240000), "PowerShot S230 / Digital IXUS v3 / IXY Digital 320" }, - { static_cast(0x1250000), "PowerShot A70" }, - { static_cast(0x1260000), "PowerShot A60" }, - { static_cast(0x1270000), "PowerShot S400 / Digital IXUS 400 / IXY Digital 400" }, - { static_cast(0x1290000), "PowerShot G5" }, - { static_cast(0x1300000), "PowerShot A300" }, - { static_cast(0x1310000), "PowerShot S50" }, - { static_cast(0x1340000), "PowerShot A80" }, - { static_cast(0x1350000), "PowerShot SD10 / Digital IXUS i / IXY Digital L" }, - { static_cast(0x1360000), "PowerShot S1 IS" }, - { static_cast(0x1370000), "PowerShot Pro1" }, - { static_cast(0x1380000), "PowerShot S70" }, - { static_cast(0x1390000), "PowerShot S60" }, - { static_cast(0x1400000), "PowerShot G6" }, - { static_cast(0x1410000), "PowerShot S500 / Digital IXUS 500 / IXY Digital 500" }, - { static_cast(0x1420000), "PowerShot A75" }, - { static_cast(0x1440000), "PowerShot SD110 / Digital IXUS IIs / IXY Digital 30a" }, - { static_cast(0x1450000), "PowerShot A400" }, - { static_cast(0x1470000), "PowerShot A310" }, - { static_cast(0x1490000), "PowerShot A85" }, - { static_cast(0x1520000), "PowerShot S410 / Digital IXUS 430 / IXY Digital 450" }, - { static_cast(0x1530000), "PowerShot A95" }, - { static_cast(0x1540000), "PowerShot SD300 / Digital IXUS 40 / IXY Digital 50" }, - { static_cast(0x1550000), "PowerShot SD200 / Digital IXUS 30 / IXY Digital 40" }, - { static_cast(0x1560000), "PowerShot A520" }, - { static_cast(0x1570000), "PowerShot A510" }, - { static_cast(0x1590000), "PowerShot SD20 / Digital IXUS i5 / IXY Digital L2" }, - { static_cast(0x1640000), "PowerShot S2 IS" }, - { static_cast(0x1650000), "PowerShot SD430 / Digital IXUS Wireless / IXY Digital Wireless" }, - { static_cast(0x1660000), "PowerShot SD500 / Digital IXUS 700 / IXY Digital 600" }, - { static_cast(0x1668000), "EOS D60" }, - { static_cast(0x1700000), "PowerShot SD30 / Digital IXUS i Zoom / IXY Digital L3" }, - { static_cast(0x1740000), "PowerShot A430" }, - { static_cast(0x1750000), "PowerShot A410" }, - { static_cast(0x1760000), "PowerShot S80" }, - { static_cast(0x1780000), "PowerShot A620" }, - { static_cast(0x1790000), "PowerShot A610" }, - { static_cast(0x1800000), "PowerShot SD630 / Digital IXUS 65 / IXY Digital 80" }, - { static_cast(0x1810000), "PowerShot SD450 / Digital IXUS 55 / IXY Digital 60" }, - { static_cast(0x1820000), "PowerShot TX1" }, - { static_cast(0x1870000), "PowerShot SD400 / Digital IXUS 50 / IXY Digital 55" }, - { static_cast(0x1880000), "PowerShot A420" }, - { static_cast(0x1890000), "PowerShot SD900 / Digital IXUS 900 Ti / IXY Digital 1000" }, - { static_cast(0x1900000), "PowerShot SD550 / Digital IXUS 750 / IXY Digital 700" }, - { static_cast(0x1920000), "PowerShot A700" }, - { static_cast(0x1940000), "PowerShot SD700 IS / Digital IXUS 800 IS / IXY Digital 800 IS" }, - { static_cast(0x1950000), "PowerShot S3 IS" }, - { static_cast(0x1960000), "PowerShot A540" }, - { static_cast(0x1970000), "PowerShot SD600 / Digital IXUS 60 / IXY Digital 70" }, - { static_cast(0x1980000), "PowerShot G7" }, - { static_cast(0x1990000), "PowerShot A530" }, - { static_cast(0x2000000), "PowerShot SD800 IS / Digital IXUS 850 IS / IXY Digital 900 IS" }, - { static_cast(0x2010000), "PowerShot SD40 / Digital IXUS i7 / IXY Digital L4" }, - { static_cast(0x2020000), "PowerShot A710 IS" }, - { static_cast(0x2030000), "PowerShot A640" }, - { static_cast(0x2040000), "PowerShot A630" }, - { static_cast(0x2090000), "PowerShot S5 IS" }, - { static_cast(0x2100000), "PowerShot A460" }, - { static_cast(0x2120000), "PowerShot SD850 IS / Digital IXUS 950 IS / IXY Digital 810 IS" }, - { static_cast(0x2130000), "PowerShot A570 IS" }, - { static_cast(0x2140000), "PowerShot A560" }, - { static_cast(0x2150000), "PowerShot SD750 / Digital IXUS 75 / IXY Digital 90" }, - { static_cast(0x2160000), "PowerShot SD1000 / Digital IXUS 70 / IXY Digital 10" }, - { static_cast(0x2180000), "PowerShot A550" }, - { static_cast(0x2190000), "PowerShot A450" }, - { static_cast(0x2230000), "PowerShot G9" }, - { static_cast(0x2240000), "PowerShot A650 IS" }, - { static_cast(0x2260000), "PowerShot A720 IS" }, - { static_cast(0x2290000), "PowerShot SX100 IS" }, - { static_cast(0x2300000), "PowerShot SD950 IS / Digital IXUS 960 IS / IXY Digital 2000 IS" }, - { static_cast(0x2310000), "PowerShot SD870 IS / Digital IXUS 860 IS / IXY Digital 910 IS" }, - { static_cast(0x2320000), "PowerShot SD890 IS / Digital IXUS 970 IS / IXY Digital 820 IS" }, - { static_cast(0x2360000), "PowerShot SD790 IS / Digital IXUS 90 IS / IXY Digital 95 IS" }, - { static_cast(0x2370000), "PowerShot SD770 IS / Digital IXUS 85 IS / IXY Digital 25 IS" }, - { static_cast(0x2380000), "PowerShot A590 IS" }, - { static_cast(0x2390000), "PowerShot A580" }, - { static_cast(0x2420000), "PowerShot A470" }, - { static_cast(0x2430000), "PowerShot SD1100 IS / Digital IXUS 80 IS / IXY Digital 20 IS" }, - { static_cast(0x2460000), "PowerShot SX1 IS" }, - { static_cast(0x2470000), "PowerShot SX10 IS" }, - { static_cast(0x2480000), "PowerShot A1000 IS" }, - { static_cast(0x2490000), "PowerShot G10" }, - { static_cast(0x2510000), "PowerShot A2000 IS" }, - { static_cast(0x2520000), "PowerShot SX110 IS" }, - { static_cast(0x2530000), "PowerShot SD990 IS / Digital IXUS 980 IS / IXY Digital 3000 IS" }, - { static_cast(0x2540000), "PowerShot SD880 IS / Digital IXUS 870 IS / IXY Digital 920 IS" }, - { static_cast(0x2550000), "PowerShot E1" }, - { static_cast(0x2560000), "PowerShot D10" }, - { static_cast(0x2570000), "PowerShot SD960 IS / Digital IXUS 110 IS / IXY Digital 510 IS" }, - { static_cast(0x2580000), "PowerShot A2100 IS" }, - { static_cast(0x2590000), "PowerShot A480" }, - { static_cast(0x2600000), "PowerShot SX200 IS" }, - { static_cast(0x2610000), "PowerShot SD970 IS / Digital IXUS 990 IS / IXY Digital 830 IS" }, - { static_cast(0x2620000), "PowerShot SD780 IS / Digital IXUS 100 IS / IXY Digital 210 IS" }, - { static_cast(0x2630000), "PowerShot A1100 IS" }, - { static_cast(0x2640000), "PowerShot SD1200 IS / Digital IXUS 95 IS / IXY Digital 110 IS" }, - { static_cast(0x2700000), "PowerShot G11" }, - { static_cast(0x2710000), "PowerShot SX120 IS" }, - { static_cast(0x2720000), "PowerShot S90" }, - { static_cast(0x2750000), "PowerShot SX20 IS" }, - { static_cast(0x2760000), "PowerShot SD980 IS / Digital IXUS 200 IS / IXY Digital 930 IS" }, - { static_cast(0x2770000), "PowerShot SD940 IS / Digital IXUS 120 IS / IXY Digital 220 IS" }, - { static_cast(0x2800000), "PowerShot A495" }, - { static_cast(0x2810000), "PowerShot A490" }, - { static_cast(0x2820000), "PowerShot A3100/A3150 IS" }, - { static_cast(0x2830000), "PowerShot A3000 IS" }, - { static_cast(0x2840000), "PowerShot SD1400 IS / IXUS 130 / IXY 400F" }, - { static_cast(0x2850000), "PowerShot SD1300 IS / IXUS 105 / IXY 200F" }, - { static_cast(0x2860000), "PowerShot SD3500 IS / IXUS 210 / IXY 10S" }, - { static_cast(0x2870000), "PowerShot SX210 IS" }, - { static_cast(0x2880000), "PowerShot SD4000 IS / IXUS 300 HS / IXY 30S" }, - { static_cast(0x2890000), "PowerShot SD4500 IS / IXUS 1000 HS / IXY 50S" }, - { static_cast(0x2920000), "PowerShot G12" }, - { static_cast(0x2930000), "PowerShot SX30 IS" }, - { static_cast(0x2940000), "PowerShot SX130 IS" }, - { static_cast(0x2950000), "PowerShot S95" }, - { static_cast(0x2980000), "PowerShot A3300 IS" }, - { static_cast(0x2990000), "PowerShot A3200 IS" }, - { static_cast(0x3000000), "PowerShot ELPH 500 HS / IXUS 310 HS / IXY 31S" }, - { static_cast(0x3010000), "PowerShot Pro90 IS" }, - { static_cast(0x3010001), "PowerShot A800" }, - { static_cast(0x3020000), "PowerShot ELPH 100 HS / IXUS 115 HS / IXY 210F" }, - { static_cast(0x3030000), "PowerShot SX230 HS" }, - { static_cast(0x3040000), "PowerShot ELPH 300 HS / IXUS 220 HS / IXY 410F" }, - { static_cast(0x3050000), "PowerShot A2200" }, - { static_cast(0x3060000), "PowerShot A1200" }, - { static_cast(0x3070000), "PowerShot SX220 HS" }, - { static_cast(0x3080000), "PowerShot G1 X" }, - { static_cast(0x3090000), "PowerShot SX150 IS" }, - { static_cast(0x3100000), "PowerShot ELPH 510 HS / IXUS 1100 HS / IXY 51S" }, - { static_cast(0x3110000), "PowerShot S100 (new)" }, - { static_cast(0x3130000), "PowerShot SX40 HS" }, - { static_cast(0x3120000), "PowerShot ELPH 310 HS / IXUS 230 HS / IXY 600F" }, - { static_cast(0x3140000), "IXY 32S" }, - { static_cast(0x3160000), "PowerShot A1300" }, - { static_cast(0x3170000), "PowerShot A810" }, - { static_cast(0x3180000), "PowerShot ELPH 320 HS / IXUS 240 HS / IXY 420F" }, - { static_cast(0x3190000), "PowerShot ELPH 110 HS / IXUS 125 HS / IXY 220F" }, - { static_cast(0x3200000), "PowerShot D20" }, - { static_cast(0x3210000), "PowerShot A4000 IS" }, - { static_cast(0x3220000), "PowerShot SX260 HS" }, - { static_cast(0x3230000), "PowerShot SX240 HS" }, - { static_cast(0x3240000), "PowerShot ELPH 530 HS / IXUS 510 HS / IXY 1" }, - { static_cast(0x3250000), "PowerShot ELPH 520 HS / IXUS 500 HS / IXY 3" }, - { static_cast(0x3260000), "PowerShot A3400 IS" }, - { static_cast(0x3270000), "PowerShot A2400 IS" }, - { static_cast(0x3280000), "PowerShot A2300" }, - { static_cast(0x3320000), "PowerShot S100V" }, - { static_cast(0x3330000), "PowerShot G15" }, - { static_cast(0x3340000), "PowerShot SX50 HS" }, - { static_cast(0x3350000), "PowerShot SX160 IS" }, - { static_cast(0x3360000), "PowerShot S110 (new)" }, - { static_cast(0x3370000), "PowerShot SX500 IS" }, - { static_cast(0x3380000), "PowerShot N" }, - { static_cast(0x3390000), "IXUS 245 HS / IXY 430F" }, - { static_cast(0x3400000), "PowerShot SX280 HS" }, - { static_cast(0x3410000), "PowerShot SX270 HS" }, - { static_cast(0x3420000), "PowerShot A3500 IS" }, - { static_cast(0x3430000), "PowerShot A2600" }, - { static_cast(0x3440000), "PowerShot SX275 HS" }, - { static_cast(0x3450000), "PowerShot A1400" }, - { static_cast(0x3460000), "PowerShot ELPH 130 IS / IXUS 140 / IXY 110F" }, - { static_cast(0x3470000), "PowerShot ELPH 115/120 IS / IXUS 132/135 / IXY 90F/100F" }, - { static_cast(0x3490000), "PowerShot ELPH 330 HS / IXUS 255 HS / IXY 610F" }, - { static_cast(0x3510000), "PowerShot A2500" }, - { static_cast(0x3540000), "PowerShot G16" }, - { static_cast(0x3550000), "PowerShot S120" }, - { static_cast(0x3560000), "PowerShot SX170 IS" }, - { static_cast(0x3580000), "PowerShot SX510 HS" }, - { static_cast(0x3590000), "PowerShot S200 (new)" }, - { static_cast(0x3600000), "IXY 620F" }, - { static_cast(0x3610000), "PowerShot N100" }, - { static_cast(0x3640000), "PowerShot G1 X Mark II" }, - { static_cast(0x3650000), "PowerShot D30" }, - { static_cast(0x3660000), "PowerShot SX700 HS" }, - { static_cast(0x3670000), "PowerShot SX600 HS" }, - { static_cast(0x3680000), "PowerShot ELPH 140 IS / IXUS 150 / IXY 130" }, - { static_cast(0x3690000), "PowerShot ELPH 135 / IXUS 145 / IXY 120" }, - { static_cast(0x3700000), "PowerShot ELPH 340 HS / IXUS 265 HS / IXY 630" }, - { static_cast(0x3710000), "PowerShot ELPH 150 IS / IXUS 155 / IXY 140" }, - { static_cast(0x3740000), "EOS M3" }, - { static_cast(0x3750000), "PowerShot SX60 HS" }, - { static_cast(0x3760000), "PowerShot SX520 HS" }, - { static_cast(0x3770000), "PowerShot SX400 IS" }, - { static_cast(0x3780000), "PowerShot G7 X" }, - { static_cast(0x3790000), "PowerShot N2" }, - { static_cast(0x3800000), "PowerShot SX530 HS" }, - { static_cast(0x3820000), "PowerShot SX710 HS" }, - { static_cast(0x3830000), "PowerShot SX610 HS" }, - { static_cast(0x3840000), "EOS M10" }, - { static_cast(0x3850000), "PowerShot G3 X" }, - { static_cast(0x3860000), "PowerShot ELPH 165 HS / IXUS 165 / IXY 160" }, - { static_cast(0x3870000), "PowerShot ELPH 160 / IXUS 160" }, - { static_cast(0x3880000), "PowerShot ELPH 350 HS / IXUS 275 HS / IXY 640" }, - { static_cast(0x3890000), "PowerShot ELPH 170 IS / IXUS 170" }, - { static_cast(0x3910000), "PowerShot SX410 IS" }, - { static_cast(0x3930000), "PowerShot G9 X" }, - { static_cast(0x3940000), "EOS M5" }, - { static_cast(0x3950000), "PowerShot G5 X" }, - { static_cast(0x3970000), "PowerShot G7 X Mark II" }, - { static_cast(0x3980000), "EOS M100" }, - { static_cast(0x3990000), "PowerShot ELPH 360 HS / IXUS 285 HS / IXY 650" }, - { static_cast(0x4010000), "PowerShot SX540 HS" }, - { static_cast(0x4020000), "PowerShot SX420 IS" }, - { static_cast(0x4030000), "PowerShot ELPH 190 IS / IXUS 180 / IXY 190" }, - { static_cast(0x4040000), "PowerShot G1" }, - { static_cast(0x4040001), "PowerShot ELPH 180 IS / IXUS 175 / IXY 180" }, - { static_cast(0x4050000), "PowerShot SX720 HS" }, - { static_cast(0x4060000), "PowerShot SX620 HS" }, - { static_cast(0x4070000), "EOS M6" }, - { static_cast(0x4100000), "PowerShot G9 X Mark II" }, - { static_cast(0x412), "EOS M50 / Kiss M" }, - { static_cast(0x4150000), "PowerShot ELPH 185 / IXUS 185 / IXY 200" }, - { static_cast(0x4160000), "PowerShot SX430 IS" }, - { static_cast(0x4170000), "PowerShot SX730 HS" }, - { static_cast(0x4180000), "PowerShot G1 X Mark III" }, - { static_cast(0x6040000), "PowerShot S100 / Digital IXUS / IXY Digital" }, - { static_cast(0x801), "PowerShot SX740 HS" }, - { static_cast(0x804), "PowerShot G5 X Mark II" }, - { static_cast(0x805), "PowerShot SX70 HS" }, - { static_cast(0x808), "PowerShot G7 X Mark III" }, - { static_cast(0x811), "EOS M6 Mark II" }, - { static_cast(0x812), "EOS M200" }, - { static_cast(0x4007d673), "DC19/DC21/DC22" }, - { static_cast(0x4007d674), "XH A1" }, - { static_cast(0x4007d675), "HV10" }, - { static_cast(0x4007d676), "MD130/MD140/MD150/MD160/ZR850" }, - { static_cast(0x4007d777), "DC50" }, - { static_cast(0x4007d778), "HV20" }, - { static_cast(0x4007d779), "DC211" }, - { static_cast(0x4007d77a), "HG10" }, - { static_cast(0x4007d77b), "HR10" }, - { static_cast(0x4007d77d), "MD255/ZR950" }, - { static_cast(0x4007d81c), "HF11" }, - { static_cast(0x4007d878), "HV30" }, - { static_cast(0x4007d87c), "XH A1S" }, - { static_cast(0x4007d87e), "DC301/DC310/DC311/DC320/DC330" }, - { static_cast(0x4007d87f), "FS100" }, - { static_cast(0x4007d880), "HF10" }, - { static_cast(0x4007d882), "HG20/HG21" }, - { static_cast(0x4007d925), "HF21" }, - { static_cast(0x4007d926), "HF S11" }, - { static_cast(0x4007d978), "HV40" }, - { static_cast(0x4007d987), "DC410/DC411/DC420" }, - { static_cast(0x4007d988), "FS19/FS20/FS21/FS22/FS200" }, - { static_cast(0x4007d989), "HF20/HF200" }, - { static_cast(0x4007d98a), "HF S10/S100" }, - { static_cast(0x4007da8e), "HF R10/R16/R17/R18/R100/R106" }, - { static_cast(0x4007da8f), "HF M30/M31/M36/M300/M306" }, - { static_cast(0x4007da90), "HF S20/S21/S200" }, - { static_cast(0x4007da92), "FS31/FS36/FS37/FS300/FS305/FS306/FS307" }, - { static_cast(0x4007dca0), "EOS C300" }, - { static_cast(0x4007dda9), "HF G25" }, - { static_cast(0x4007dfb4), "XC10" }, - { static_cast(0x4007e1c3), "EOS C200" }, - { static_cast(0x80000001), "EOS-1D" }, - { static_cast(0x80000167), "EOS-1DS" }, - { static_cast(0x80000168), "EOS 10D" }, - { static_cast(0x80000169), "EOS-1D Mark III" }, - { static_cast(0x80000170), "EOS Digital Rebel / 300D / Kiss Digital" }, - { static_cast(0x80000174), "EOS-1D Mark II" }, - { static_cast(0x80000175), "EOS 20D" }, - { static_cast(0x80000176), "EOS Digital Rebel XSi / 450D / Kiss X2" }, - { static_cast(0x80000188), "EOS-1Ds Mark II" }, - { static_cast(0x80000189), "EOS Digital Rebel XT / 350D / Kiss Digital N" }, - { static_cast(0x80000190), "EOS 40D" }, - { static_cast(0x80000213), "EOS 5D" }, - { static_cast(0x80000215), "EOS-1Ds Mark III" }, - { static_cast(0x80000218), "EOS 5D Mark II" }, - { static_cast(0x80000219), "WFT-E1" }, - { static_cast(0x80000232), "EOS-1D Mark II N" }, - { static_cast(0x80000234), "EOS 30D" }, - { static_cast(0x80000236), "EOS Digital Rebel XTi / 400D / Kiss Digital X" }, - { static_cast(0x80000241), "WFT-E2" }, - { static_cast(0x80000246), "WFT-E3" }, - { static_cast(0x80000250), "EOS 7D" }, - { static_cast(0x80000252), "EOS Rebel T1i / 500D / Kiss X3" }, - { static_cast(0x80000254), "EOS Rebel XS / 1000D / Kiss F" }, - { static_cast(0x80000261), "EOS 50D" }, - { static_cast(0x80000269), "EOS-1D X" }, - { static_cast(0x80000270), "EOS Rebel T2i / 550D / Kiss X4" }, - { static_cast(0x80000271), "WFT-E4" }, - { static_cast(0x80000273), "WFT-E5" }, - { static_cast(0x80000281), "EOS-1D Mark IV" }, - { static_cast(0x80000285), "EOS 5D Mark III" }, - { static_cast(0x80000286), "EOS Rebel T3i / 600D / Kiss X5" }, - { static_cast(0x80000287), "EOS 60D" }, - { static_cast(0x80000288), "EOS Rebel T3 / 1100D / Kiss X50" }, - { static_cast(0x80000289), "EOS 7D Mark II" }, - { static_cast(0x80000297), "WFT-E2 II" }, - { static_cast(0x80000298), "WFT-E4 II" }, - { static_cast(0x80000301), "EOS Rebel T4i / 650D / Kiss X6i" }, - { static_cast(0x80000302), "EOS 6D" }, - { static_cast(0x80000324), "EOS-1D C" }, - { static_cast(0x80000325), "EOS 70D" }, - { static_cast(0x80000326), "EOS Rebel T5i / 700D / Kiss X7i" }, - { static_cast(0x80000327), "EOS Rebel T5 / 1200D / Kiss X70 / Hi" }, - { static_cast(0x80000328), "EOS-1D X MARK II" }, - { static_cast(0x80000331), "EOS M" }, - { static_cast(0x80000350), "EOS 80D" }, - { static_cast(0x80000355), "EOS M2" }, - { static_cast(0x80000346), "EOS Rebel SL1 / 100D / Kiss X7" }, - { static_cast(0x80000347), "EOS Rebel T6s / 760D / 8000D" }, - { static_cast(0x80000349), "EOS 5D Mark IV" }, - { static_cast(0x80000382), "EOS 5DS" }, - { static_cast(0x80000393), "EOS Rebel T6i / 750D / Kiss X8i" }, - { static_cast(0x80000401), "EOS 5DS R" }, - { static_cast(0x80000404), "EOS Rebel T6 / 1300D / Kiss X80" }, - { static_cast(0x80000405), "EOS Rebel T7i / 800D / Kiss X9i" }, - { static_cast(0x80000406), "EOS 6D Mark II" }, - { static_cast(0x80000408), "EOS 77D / 9000D" }, - { static_cast(0x80000417), "EOS Rebel SL2 / 200D / Kiss X9" }, - { static_cast(0x80000421), "EOS R5" }, - { static_cast(0x80000422), "EOS Rebel T100 / 4000D / 3000D" }, - { static_cast(0x80000424), "EOS R" }, - { static_cast(0x80000428), "EOS-1D X Mark III" }, - { static_cast(0x80000432), "EOS Rebel T7 / 2000D / 1500D / Kiss X90" }, - { static_cast(0x80000433), "EOS RP" }, - { static_cast(0x80000435), "EOS 850D / T8i / Kiss X10i" }, - { static_cast(0x80000436), "EOS SL3 / 250D / Kiss X10" }, - { static_cast(0x80000437), "EOS 90D" }, - { static_cast(0x80000453), "EOS R6" }, + { 0x00000811, "EOS M6 Mark II"}, + { 0x00000804, "Powershot G5 X Mark II"}, + { 0x00000805, "PowerShot SX70 HS"}, + { 0x00000808, "PowerShot G7 X Mark III"}, + { 0x00000812, "EOS M200"}, + { 0x1010000, "PowerShot A30" }, + { 0x1040000, "PowerShot S300 / Digital IXUS 300 / IXY Digital 300" }, + { 0x1060000, "PowerShot A20" }, + { 0x1080000, "PowerShot A10" }, + { 0x1090000, "PowerShot S110 / Digital IXUS v / IXY Digital 200" }, + { 0x1100000, "PowerShot G2" }, + { 0x1110000, "PowerShot S40" }, + { 0x1120000, "PowerShot S30" }, + { 0x1130000, "PowerShot A40" }, + { 0x1140000, "EOS D30" }, + { 0x1150000, "PowerShot A100" }, + { 0x1160000, "PowerShot S200 / Digital IXUS v2 / IXY Digital 200a" }, + { 0x1170000, "PowerShot A200" }, + { 0x1180000, "PowerShot S330 / Digital IXUS 330 / IXY Digital 300a" }, + { 0x1190000, "PowerShot G3" }, + { 0x1210000, "PowerShot S45" }, + { 0x1230000, "PowerShot SD100 / Digital IXUS II / IXY Digital 30" }, + { 0x1240000, "PowerShot S230 / Digital IXUS v3 / IXY Digital 320" }, + { 0x1250000, "PowerShot A70" }, + { 0x1260000, "PowerShot A60" }, + { 0x1270000, "PowerShot S400 / Digital IXUS 400 / IXY Digital 400" }, + { 0x1290000, "PowerShot G5" }, + { 0x1300000, "PowerShot A300" }, + { 0x1310000, "PowerShot S50" }, + { 0x1340000, "PowerShot A80" }, + { 0x1350000, "PowerShot SD10 / Digital IXUS i / IXY Digital L" }, + { 0x1360000, "PowerShot S1 IS" }, + { 0x1370000, "PowerShot Pro1" }, + { 0x1380000, "PowerShot S70" }, + { 0x1390000, "PowerShot S60" }, + { 0x1400000, "PowerShot G6" }, + { 0x1410000, "PowerShot S500 / Digital IXUS 500 / IXY Digital 500" }, + { 0x1420000, "PowerShot A75" }, + { 0x1440000, "PowerShot SD110 / Digital IXUS IIs / IXY Digital 30a" }, + { 0x1450000, "PowerShot A400" }, + { 0x1470000, "PowerShot A310" }, + { 0x1490000, "PowerShot A85" }, + { 0x1520000, "PowerShot S410 / Digital IXUS 430 / IXY Digital 450" }, + { 0x1530000, "PowerShot A95" }, + { 0x1540000, "PowerShot SD300 / Digital IXUS 40 / IXY Digital 50" }, + { 0x1550000, "PowerShot SD200 / Digital IXUS 30 / IXY Digital 40" }, + { 0x1560000, "PowerShot A520" }, + { 0x1570000, "PowerShot A510" }, + { 0x1590000, "PowerShot SD20 / Digital IXUS i5 / IXY Digital L2" }, + { 0x1640000, "PowerShot S2 IS" }, + { 0x1650000, "PowerShot SD430 / Digital IXUS Wireless / IXY Digital Wireless" }, + { 0x1660000, "PowerShot SD500 / Digital IXUS 700 / IXY Digital 600" }, + { 0x1668000, "EOS D60" }, + { 0x1700000, "PowerShot SD30 / Digital IXUS i Zoom / IXY Digital L3" }, + { 0x1740000, "PowerShot A430" }, + { 0x1750000, "PowerShot A410" }, + { 0x1760000, "PowerShot S80" }, + { 0x1780000, "PowerShot A620" }, + { 0x1790000, "PowerShot A610" }, + { 0x1800000, "PowerShot SD630 / Digital IXUS 65 / IXY Digital 80" }, + { 0x1810000, "PowerShot SD450 / Digital IXUS 55 / IXY Digital 60" }, + { 0x1820000, "PowerShot TX1" }, + { 0x1870000, "PowerShot SD400 / Digital IXUS 50 / IXY Digital 55" }, + { 0x1880000, "PowerShot A420" }, + { 0x1890000, "PowerShot SD900 / Digital IXUS 900 Ti / IXY Digital 1000" }, + { 0x1900000, "PowerShot SD550 / Digital IXUS 750 / IXY Digital 700" }, + { 0x1920000, "PowerShot A700" }, + { 0x1940000, "PowerShot SD700 IS / Digital IXUS 800 IS / IXY Digital 800 IS" }, + { 0x1950000, "PowerShot S3 IS" }, + { 0x1960000, "PowerShot A540" }, + { 0x1970000, "PowerShot SD600 / Digital IXUS 60 / IXY Digital 70" }, + { 0x1980000, "PowerShot G7" }, + { 0x1990000, "PowerShot A530" }, + { 0x2000000, "PowerShot SD800 IS / Digital IXUS 850 IS / IXY Digital 900 IS" }, + { 0x2010000, "PowerShot SD40 / Digital IXUS i7 / IXY Digital L4" }, + { 0x2020000, "PowerShot A710 IS" }, + { 0x2030000, "PowerShot A640" }, + { 0x2040000, "PowerShot A630" }, + { 0x2090000, "PowerShot S5 IS" }, + { 0x2100000, "PowerShot A460" }, + { 0x2120000, "PowerShot SD850 IS / Digital IXUS 950 IS / IXY Digital 810 IS" }, + { 0x2130000, "PowerShot A570 IS" }, + { 0x2140000, "PowerShot A560" }, + { 0x2150000, "PowerShot SD750 / Digital IXUS 75 / IXY Digital 90" }, + { 0x2160000, "PowerShot SD1000 / Digital IXUS 70 / IXY Digital 10" }, + { 0x2180000, "PowerShot A550" }, + { 0x2190000, "PowerShot A450" }, + { 0x2230000, "PowerShot G9" }, + { 0x2240000, "PowerShot A650 IS" }, + { 0x2260000, "PowerShot A720 IS" }, + { 0x2290000, "PowerShot SX100 IS" }, + { 0x2300000, "PowerShot SD950 IS / Digital IXUS 960 IS / IXY Digital 2000 IS" }, + { 0x2310000, "PowerShot SD870 IS / Digital IXUS 860 IS / IXY Digital 910 IS" }, + { 0x2320000, "PowerShot SD890 IS / Digital IXUS 970 IS / IXY Digital 820 IS" }, + { 0x2360000, "PowerShot SD790 IS / Digital IXUS 90 IS / IXY Digital 95 IS" }, + { 0x2370000, "PowerShot SD770 IS / Digital IXUS 85 IS / IXY Digital 25 IS" }, + { 0x2380000, "PowerShot A590 IS" }, + { 0x2390000, "PowerShot A580" }, + { 0x2420000, "PowerShot A470" }, + { 0x2430000, "PowerShot SD1100 IS / Digital IXUS 80 IS / IXY Digital 20 IS" }, + { 0x2460000, "PowerShot SX1 IS" }, + { 0x2470000, "PowerShot SX10 IS" }, + { 0x2480000, "PowerShot A1000 IS" }, + { 0x2490000, "PowerShot G10" }, + { 0x2510000, "PowerShot A2000 IS" }, + { 0x2520000, "PowerShot SX110 IS" }, + { 0x2530000, "PowerShot SD990 IS / Digital IXUS 980 IS / IXY Digital 3000 IS" }, + { 0x2540000, "PowerShot SD880 IS / Digital IXUS 870 IS / IXY Digital 920 IS" }, + { 0x2550000, "PowerShot E1" }, + { 0x2560000, "PowerShot D10" }, + { 0x2570000, "PowerShot SD960 IS / Digital IXUS 110 IS / IXY Digital 510 IS" }, + { 0x2580000, "PowerShot A2100 IS" }, + { 0x2590000, "PowerShot A480" }, + { 0x2600000, "PowerShot SX200 IS" }, + { 0x2610000, "PowerShot SD970 IS / Digital IXUS 990 IS / IXY Digital 830 IS" }, + { 0x2620000, "PowerShot SD780 IS / Digital IXUS 100 IS / IXY Digital 210 IS" }, + { 0x2630000, "PowerShot A1100 IS" }, + { 0x2640000, "PowerShot SD1200 IS / Digital IXUS 95 IS / IXY Digital 110 IS" }, + { 0x2700000, "PowerShot G11" }, + { 0x2710000, "PowerShot SX120 IS" }, + { 0x2720000, "PowerShot S90" }, + { 0x2750000, "PowerShot SX20 IS" }, + { 0x2760000, "PowerShot SD980 IS / Digital IXUS 200 IS / IXY Digital 930 IS" }, + { 0x2770000, "PowerShot SD940 IS / Digital IXUS 120 IS / IXY Digital 220 IS" }, + { 0x2800000, "PowerShot A495" }, + { 0x2810000, "PowerShot A490" }, + { 0x2820000, "PowerShot A3100/A3150 IS" }, + { 0x2830000, "PowerShot A3000 IS" }, + { 0x2840000, "PowerShot SD1400 IS / IXUS 130 / IXY 400F" }, + { 0x2850000, "PowerShot SD1300 IS / IXUS 105 / IXY 200F" }, + { 0x2860000, "PowerShot SD3500 IS / IXUS 210 / IXY 10S" }, + { 0x2870000, "PowerShot SX210 IS" }, + { 0x2880000, "PowerShot SD4000 IS / IXUS 300 HS / IXY 30S" }, + { 0x2890000, "PowerShot SD4500 IS / IXUS 1000 HS / IXY 50S" }, + { 0x2920000, "PowerShot G12" }, + { 0x2930000, "PowerShot SX30 IS" }, + { 0x2940000, "PowerShot SX130 IS" }, + { 0x2950000, "PowerShot S95" }, + { 0x2980000, "PowerShot A3300 IS" }, + { 0x2990000, "PowerShot A3200 IS" }, + { 0x3000000, "PowerShot ELPH 500 HS / IXUS 310 HS / IXY 31S" }, + { 0x3010000, "PowerShot Pro90 IS" }, + { 0x3010001, "PowerShot A800" }, + { 0x3020000, "PowerShot ELPH 100 HS / IXUS 115 HS / IXY 210F" }, + { 0x3030000, "PowerShot SX230 HS" }, + { 0x3040000, "PowerShot ELPH 300 HS / IXUS 220 HS / IXY 410F" }, + { 0x3050000, "PowerShot A2200" }, + { 0x3060000, "PowerShot A1200" }, + { 0x3070000, "PowerShot SX220 HS" }, + { 0x3080000, "PowerShot G1 X" }, + { 0x3090000, "PowerShot SX150 IS" }, + { 0x3100000, "PowerShot ELPH 510 HS / IXUS 1100 HS / IXY 51S" }, + { 0x3110000, "PowerShot S100 (new)" }, + { 0x3130000, "PowerShot SX40 HS" }, + { 0x3120000, "PowerShot ELPH 310 HS / IXUS 230 HS / IXY 600F" }, + { 0x3140000, "IXY 32S" }, + { 0x3160000, "PowerShot A1300" }, + { 0x3170000, "PowerShot A810" }, + { 0x3180000, "PowerShot ELPH 320 HS / IXUS 240 HS / IXY 420F" }, + { 0x3190000, "PowerShot ELPH 110 HS / IXUS 125 HS / IXY 220F" }, + { 0x3200000, "PowerShot D20" }, + { 0x3210000, "PowerShot A4000 IS" }, + { 0x3220000, "PowerShot SX260 HS" }, + { 0x3230000, "PowerShot SX240 HS" }, + { 0x3240000, "PowerShot ELPH 530 HS / IXUS 510 HS / IXY 1" }, + { 0x3250000, "PowerShot ELPH 520 HS / IXUS 500 HS / IXY 3" }, + { 0x3260000, "PowerShot A3400 IS" }, + { 0x3270000, "PowerShot A2400 IS" }, + { 0x3280000, "PowerShot A2300" }, + { 0x3320000, "PowerShot S100V" }, + { 0x3330000, "PowerShot G15" }, + { 0x3340000, "PowerShot SX50 HS" }, + { 0x3350000, "PowerShot SX160 IS" }, + { 0x3360000, "PowerShot S110 (new)" }, + { 0x3370000, "PowerShot SX500 IS" }, + { 0x3380000, "PowerShot N" }, + { 0x3390000, "IXUS 245 HS / IXY 430F" }, + { 0x3400000, "PowerShot SX280 HS" }, + { 0x3410000, "PowerShot SX270 HS" }, + { 0x3420000, "PowerShot A3500 IS" }, + { 0x3430000, "PowerShot A2600" }, + { 0x3440000, "PowerShot SX275 HS" }, + { 0x3450000, "PowerShot A1400" }, + { 0x3460000, "PowerShot ELPH 130 IS / IXUS 140 / IXY 110F" }, + { 0x3470000, "PowerShot ELPH 115/120 IS / IXUS 132/135 / IXY 90F/100F" }, + { 0x3490000, "PowerShot ELPH 330 HS / IXUS 255 HS / IXY 610F" }, + { 0x3510000, "PowerShot A2500" }, + { 0x3540000, "PowerShot G16" }, + { 0x3550000, "PowerShot S120" }, + { 0x3560000, "PowerShot SX170 IS" }, + { 0x3580000, "PowerShot SX510 HS" }, + { 0x3590000, "PowerShot S200 (new)" }, + { 0x3600000, "IXY 620F" }, + { 0x3610000, "PowerShot N100" }, + { 0x3640000, "PowerShot G1 X Mark II" }, + { 0x3650000, "PowerShot D30" }, + { 0x3660000, "PowerShot SX700 HS" }, + { 0x3670000, "PowerShot SX600 HS" }, + { 0x3680000, "PowerShot ELPH 140 IS / IXUS 150 / IXY 130" }, + { 0x3690000, "PowerShot ELPH 135 / IXUS 145 / IXY 120" }, + { 0x3700000, "PowerShot ELPH 340 HS / IXUS 265 HS / IXY 630" }, + { 0x3710000, "PowerShot ELPH 150 IS / IXUS 155 / IXY 140" }, + { 0x3740000, "EOS M3" }, + { 0x3750000, "PowerShot SX60 HS" }, + { 0x3760000, "PowerShot SX520 HS" }, + { 0x3770000, "PowerShot SX400 IS" }, + { 0x3780000, "PowerShot G7 X" }, + { 0x3790000, "PowerShot N2" }, + { 0x3800000, "PowerShot SX530 HS" }, + { 0x3820000, "PowerShot SX710 HS" }, + { 0x3830000, "PowerShot SX610 HS" }, + { 0x3840000, "EOS M10" }, + { 0x3850000, "PowerShot G3 X" }, + { 0x3860000, "PowerShot ELPH 165 HS / IXUS 165 / IXY 160" }, + { 0x3870000, "PowerShot ELPH 160 / IXUS 160" }, + { 0x3880000, "PowerShot ELPH 350 HS / IXUS 275 HS / IXY 640" }, + { 0x3890000, "PowerShot ELPH 170 IS / IXUS 170" }, + { 0x3910000, "PowerShot SX410 IS" }, + { 0x3930000, "PowerShot G9 X" }, + { 0x3940000, "EOS M5" }, + { 0x3950000, "PowerShot G5 X" }, + { 0x3970000, "PowerShot G7 X Mark II" }, + { 0x3980000, "EOS M100" }, + { 0x3990000, "PowerShot ELPH 360 HS / IXUS 285 HS / IXY 650" }, + { 0x4010000, "PowerShot SX540 HS" }, + { 0x4020000, "PowerShot SX420 IS" }, + { 0x4030000, "PowerShot ELPH 190 IS / IXUS 180 / IXY 190" }, + { 0x4040000, "PowerShot G1" }, + { 0x4040001, "PowerShot ELPH 180 IS / IXUS 175 / IXY 180" }, + { 0x4050000, "PowerShot SX720 HS" }, + { 0x4060000, "PowerShot SX620 HS" }, + { 0x4070000, "EOS M6" }, + { 0x4100000, "PowerShot G9 X Mark II" }, + { 0x412, "EOS M50 / Kiss M" }, + { 0x4150000, "PowerShot ELPH 185 / IXUS 185 / IXY 200" }, + { 0x4160000, "PowerShot SX430 IS" }, + { 0x4170000, "PowerShot SX730 HS" }, + { 0x4180000, "PowerShot G1 X Mark III" }, + { 0x6040000, "PowerShot S100 / Digital IXUS / IXY Digital" }, + { 0x801, "PowerShot SX740 HS" }, + { 0x804, "PowerShot G5 X Mark II" }, + { 0x805, "PowerShot SX70 HS" }, + { 0x808, "PowerShot G7 X Mark III" }, + { 0x811, "EOS M6 Mark II" }, + { 0x812, "EOS M200" }, + { 0x4007d673, "DC19/DC21/DC22" }, + { 0x4007d674, "XH A1" }, + { 0x4007d675, "HV10" }, + { 0x4007d676, "MD130/MD140/MD150/MD160/ZR850" }, + { 0x4007d777, "DC50" }, + { 0x4007d778, "HV20" }, + { 0x4007d779, "DC211" }, + { 0x4007d77a, "HG10" }, + { 0x4007d77b, "HR10" }, + { 0x4007d77d, "MD255/ZR950" }, + { 0x4007d81c, "HF11" }, + { 0x4007d878, "HV30" }, + { 0x4007d87c, "XH A1S" }, + { 0x4007d87e, "DC301/DC310/DC311/DC320/DC330" }, + { 0x4007d87f, "FS100" }, + { 0x4007d880, "HF10" }, + { 0x4007d882, "HG20/HG21" }, + { 0x4007d925, "HF21" }, + { 0x4007d926, "HF S11" }, + { 0x4007d978, "HV40" }, + { 0x4007d987, "DC410/DC411/DC420" }, + { 0x4007d988, "FS19/FS20/FS21/FS22/FS200" }, + { 0x4007d989, "HF20/HF200" }, + { 0x4007d98a, "HF S10/S100" }, + { 0x4007da8e, "HF R10/R16/R17/R18/R100/R106" }, + { 0x4007da8f, "HF M30/M31/M36/M300/M306" }, + { 0x4007da90, "HF S20/S21/S200" }, + { 0x4007da92, "FS31/FS36/FS37/FS300/FS305/FS306/FS307" }, + { 0x4007dca0, "EOS C300" }, + { 0x4007dda9, "HF G25" }, + { 0x4007dfb4, "XC10" }, + { 0x4007e1c3, "EOS C200" }, + { 0x80000001, "EOS-1D" }, + { 0x80000167, "EOS-1DS" }, + { 0x80000168, "EOS 10D" }, + { 0x80000169, "EOS-1D Mark III" }, + { 0x80000170, "EOS Digital Rebel / 300D / Kiss Digital" }, + { 0x80000174, "EOS-1D Mark II" }, + { 0x80000175, "EOS 20D" }, + { 0x80000176, "EOS Digital Rebel XSi / 450D / Kiss X2" }, + { 0x80000188, "EOS-1Ds Mark II" }, + { 0x80000189, "EOS Digital Rebel XT / 350D / Kiss Digital N" }, + { 0x80000190, "EOS 40D" }, + { 0x80000213, "EOS 5D" }, + { 0x80000215, "EOS-1Ds Mark III" }, + { 0x80000218, "EOS 5D Mark II" }, + { 0x80000219, "WFT-E1" }, + { 0x80000232, "EOS-1D Mark II N" }, + { 0x80000234, "EOS 30D" }, + { 0x80000236, "EOS Digital Rebel XTi / 400D / Kiss Digital X" }, + { 0x80000241, "WFT-E2" }, + { 0x80000246, "WFT-E3" }, + { 0x80000250, "EOS 7D" }, + { 0x80000252, "EOS Rebel T1i / 500D / Kiss X3" }, + { 0x80000254, "EOS Rebel XS / 1000D / Kiss F" }, + { 0x80000261, "EOS 50D" }, + { 0x80000269, "EOS-1D X" }, + { 0x80000270, "EOS Rebel T2i / 550D / Kiss X4" }, + { 0x80000271, "WFT-E4" }, + { 0x80000273, "WFT-E5" }, + { 0x80000281, "EOS-1D Mark IV" }, + { 0x80000285, "EOS 5D Mark III" }, + { 0x80000286, "EOS Rebel T3i / 600D / Kiss X5" }, + { 0x80000287, "EOS 60D" }, + { 0x80000288, "EOS Rebel T3 / 1100D / Kiss X50" }, + { 0x80000289, "EOS 7D Mark II" }, + { 0x80000297, "WFT-E2 II" }, + { 0x80000298, "WFT-E4 II" }, + { 0x80000301, "EOS Rebel T4i / 650D / Kiss X6i" }, + { 0x80000302, "EOS 6D" }, + { 0x80000324, "EOS-1D C" }, + { 0x80000325, "EOS 70D" }, + { 0x80000326, "EOS Rebel T5i / 700D / Kiss X7i" }, + { 0x80000327, "EOS Rebel T5 / 1200D / Kiss X70 / Hi" }, + { 0x80000328, "EOS-1D X MARK II" }, + { 0x80000331, "EOS M" }, + { 0x80000350, "EOS 80D" }, + { 0x80000355, "EOS M2" }, + { 0x80000346, "EOS Rebel SL1 / 100D / Kiss X7" }, + { 0x80000347, "EOS Rebel T6s / 760D / 8000D" }, + { 0x80000349, "EOS 5D Mark IV" }, + { 0x80000382, "EOS 5DS" }, + { 0x80000393, "EOS Rebel T6i / 750D / Kiss X8i" }, + { 0x80000401, "EOS 5DS R" }, + { 0x80000404, "EOS Rebel T6 / 1300D / Kiss X80" }, + { 0x80000405, "EOS Rebel T7i / 800D / Kiss X9i" }, + { 0x80000406, "EOS 6D Mark II" }, + { 0x80000408, "EOS 77D / 9000D" }, + { 0x80000417, "EOS Rebel SL2 / 200D / Kiss X9" }, + { 0x80000421, "EOS R5" }, + { 0x80000422, "EOS Rebel T100 / 4000D / 3000D" }, + { 0x80000424, "EOS R" }, + { 0x80000428, "EOS-1D X Mark III" }, + { 0x80000432, "EOS Rebel T7 / 2000D / 1500D / Kiss X90" }, + { 0x80000433, "EOS RP" }, + { 0x80000435, "EOS 850D / T8i / Kiss X10i" }, + { 0x80000436, "EOS SL3 / 250D / Kiss X10" }, + { 0x80000437, "EOS 90D" }, + { 0x80000453, "EOS R6" }, //{ (long int)tbd, "EOS Ra" }, //{ (long int)tbd, "EOS M50 Mark II" }, - {static_cast(0x80000520), "EOS D2000C"}, - {static_cast(0x80000560), "EOS D6000C"}}; + {0x80000520, "EOS D2000C"}, + {0x80000560, "EOS D6000C"}}; //! SerialNumberFormat, tag 0x0015 constexpr TagDetails canonSerialNumberFormat[] = { - { static_cast(0x90000000), N_("Format 1") }, - { static_cast(0xa0000000), N_("Format 2") }, + { 0x90000000, N_("Format 1") }, + { 0xa0000000, N_("Format 2") }, }; //! SuperMacro, tag 0x001a @@ -2621,7 +2621,7 @@ namespace Exiv2 { std::string model = pos->toString(); if (model.find("20D") != std::string::npos || model.find("350D") != std::string::npos || model.substr(model.size() - 8, 8) == "REBEL XT" || model.find("Kiss Digital N") != std::string::npos) { - uint32_t val = value.toLong(); + uint32_t val = value.toUint32(); uint32_t dn = (val & 0xffc0) >> 6; uint32_t fn = ((val >> 16) & 0xff) + ((val & 0x3f) << 8); os << std::dec << dn << "-" << std::setw(4) << std::setfill('0') << fn; @@ -2631,7 +2631,7 @@ namespace Exiv2 { if (model.find("30D") != std::string::npos || model.find("400D") != std::string::npos || model.find("REBEL XTi") != std::string::npos || model.find("Kiss Digital X") != std::string::npos || model.find("K236") != std::string::npos) { - uint32_t val = value.toLong(); + uint32_t val = value.toUint32(); uint32_t dn = (val & 0xffc00) >> 10; while (dn < 100) dn += 0x40; @@ -2703,7 +2703,7 @@ namespace Exiv2 { if ( value.typeId() != unsignedShort || value.count() == 0) return os << value; - long l = value.toLong(); + const auto l = value.toInt64(); if (l == 0) { os << "Off"; } @@ -2739,7 +2739,7 @@ namespace Exiv2 { if (!metadata || value.typeId() != unsignedShort || value.count() == 0) return os << value; - auto const lensType = value.toLong(); + auto const lensType = value.toInt64(); if (lensType == 0xffff){ return printCsLensFFFF(os, value, metadata); @@ -2755,8 +2755,8 @@ namespace Exiv2 { return os; } - int const exifFlMin = static_cast(static_cast(pos->value().toLong(1)) / pos->value().toFloat(2)); - int const exifFlMax = static_cast(static_cast(pos->value().toLong(0)) / pos->value().toFloat(2)); + int const exifFlMin = static_cast(static_cast(pos->value().toInt64(1)) / pos->value().toFloat(2)); + int const exifFlMax = static_cast(static_cast(pos->value().toInt64(0)) / pos->value().toFloat(2)); ExifKey aperKey("Exif.CanonCs.MaxAperture"); pos = metadata->findKey(aperKey); @@ -2765,7 +2765,7 @@ namespace Exiv2 { return os; } - auto exifAperMax = fnumber(canonEv(static_cast(pos->value().toLong(0)))); + auto exifAperMax = fnumber(canonEv(static_cast(pos->value().toInt64(0)))); // regex to extract short and tele focal length, max aperture at short and tele position // and the teleconverter factor from the lens label @@ -2865,8 +2865,8 @@ namespace Exiv2 { float fu = value.toFloat(2); if (fu == 0.0F) return os << value; - float len1 = value.toLong(0) / fu; - float len2 = value.toLong(1) / fu; + float len1 = value.toInt64(0) / fu; + float len2 = value.toInt64(1) / fu; std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(1); @@ -2887,7 +2887,7 @@ namespace Exiv2 { std::ios::fmtflags f( os.flags() ); if ( value.typeId() == unsignedShort && value.count() > 0) { - os << std::exp(canonEv(value.toLong()) / 32 * std::log(2.0F)) * 100.0F; + os << std::exp(canonEv(value.toInt64()) / 32 * std::log(2.0F)) * 100.0F; } os.flags(f); return os; @@ -2901,7 +2901,7 @@ namespace Exiv2 { if ( value.typeId() == unsignedShort && value.count() > 0) { // Ported from Exiftool by Will Stokes - os << std::exp(canonEv(value.toLong()) * std::log(2.0F)) * 100.0F / 32.0F; + os << std::exp(canonEv(value.toInt64()) * std::log(2.0F)) * 100.0F / 32.0F; } os.flags(f); return os; @@ -2919,7 +2919,7 @@ namespace Exiv2 { // see also printSi0x0017 std::ostringstream oss; oss.copyfmt(os); - int res = static_cast(100.0 * (static_cast(value.toLong()) / 32.0 + 5.0) + 0.5); + int res = static_cast(100.0 * (static_cast(value.toInt64()) / 32.0 + 5.0) + 0.5); os << std::fixed << std::setprecision(2) << res / 100.0; os.copyfmt(oss); } @@ -2933,7 +2933,7 @@ namespace Exiv2 { if ( value.typeId() != unsignedShort || value.count() == 0) return os << value; - long l = value.toLong(); + const auto l = value.toInt64(); os << l << ""; // Todo: determine unit return os; @@ -2943,18 +2943,18 @@ namespace Exiv2 { const Value& value, const ExifData*) { - if (value.toLong() == 0) return os << "--"; + if (value.toInt64() == 0) return os << "--"; - return os << value.toLong() - 128 << " °C"; + return os << value.toInt64() - 128 << " °C"; } std::ostream& CanonMakerNote::printSi0x000d(std::ostream& os, const Value& value, const ExifData*) { - if (value.toLong() == 65535) return os << "--"; + if (value.toInt64() == 65535) return os << "--"; - return os << value.toLong() / 32; + return os << value.toInt64() / 32; } std::ostream& CanonMakerNote::printSi0x000e(std::ostream& os, @@ -2964,10 +2964,10 @@ namespace Exiv2 { if ( value.typeId() != unsignedShort || value.count() == 0) return os << value; - long l = value.toLong(); - long num = (l & 0xf000) >> 12; + const auto l = value.toInt64(); + const auto num = (l & 0xf000) >> 12; os << num << " focus points; "; - long used = l & 0x0fff; + const auto used = l & 0x0fff; if (used == 0) { os << "none"; } @@ -2986,12 +2986,12 @@ namespace Exiv2 { if ( value.typeId() != unsignedShort || value.count() == 0) return os << value; - long l = value.toLong(); + const auto l = value.toInt64(); if (l == 0xffff) { os << "Infinite"; } else { - os << value.toLong()/100.0 << " m"; + os << value.toInt64()/100.0 << " m"; } os.flags(f); return os; @@ -3006,7 +3006,7 @@ namespace Exiv2 { std::ostringstream oss; oss.copyfmt(os); - long val = static_cast(value.toLong()); + const auto val = static_cast(value.toInt64()); if (val < 0) return os << value; os << std::setprecision(2) << "F" << fnumber(canonEv(val)); @@ -3022,7 +3022,7 @@ namespace Exiv2 { if ( value.typeId() != unsignedShort || value.count() == 0) return os << value; - URational ur = exposureTime(canonEv(value.toLong())); + URational ur = exposureTime(canonEv(value.toInt64())); os << ur.first; if (ur.second > 1) { os << "/" << ur.second; @@ -3041,7 +3041,7 @@ namespace Exiv2 { std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(2) - << value.toLong() / 8.0 - 6.0; + << value.toInt64() / 8.0 - 6.0; os.copyfmt(oss); return os; } @@ -3050,7 +3050,7 @@ namespace Exiv2 { const Value& value, const ExifData*) { - return os << value.toLong() / 10; + return os << value.toInt64() / 10; } std::ostream& CanonMakerNote::printFiFocusDistance(std::ostream& os, @@ -3065,12 +3065,12 @@ namespace Exiv2 { oss.copyfmt(os); os << std::fixed << std::setprecision(2); - long l = value.toLong(); + const auto l = value.toInt64(); if (l == -1) { os << "Infinite"; } else { - os << value.toLong()/100.0 << " m"; + os << value.toInt64()/100.0 << " m"; } os.copyfmt(oss); @@ -3081,7 +3081,7 @@ namespace Exiv2 { // ***************************************************************************** // free functions - float canonEv(long val) + float canonEv(int64_t val) { // temporarily remove sign int sign = 1; @@ -3090,8 +3090,9 @@ namespace Exiv2 { val = -val; } // remove fraction - auto frac = static_cast(val & 0x1f); - val -= long(frac); + const auto remainder = val & 0x1f; + val -= remainder; + float frac = static_cast(remainder); // convert 1/3 (0x0c) and 2/3 (0x14) codes if (frac == 0x0c) { frac = 32.0F / 3; diff --git a/src/canonmn_int.hpp b/src/canonmn_int.hpp index 777a41ec..83f4ff10 100644 --- a/src/canonmn_int.hpp +++ b/src/canonmn_int.hpp @@ -238,7 +238,7 @@ namespace Exiv2 { 128 -> 4 143 -> 4.46875 */ - float canonEv(long val); + float canonEv(int64_t val); }} // namespace Internal, Exiv2 diff --git a/src/casiomn_int.cpp b/src/casiomn_int.cpp index 84ff45f2..db1d7957 100644 --- a/src/casiomn_int.cpp +++ b/src/casiomn_int.cpp @@ -215,7 +215,7 @@ namespace Exiv2 { std::ios::fmtflags f( os.flags() ); std::ostringstream oss; oss.copyfmt(os); - os << std::fixed << std::setprecision(2) << value.toLong() / 1000.0 << _(" m"); + os << std::fixed << std::setprecision(2) << value.toInt64() / 1000.0 << _(" m"); os.copyfmt(oss); os.flags(f); return os; @@ -227,7 +227,7 @@ namespace Exiv2 { std::vector numbers; for(long i=0; i(l)); @@ -546,7 +546,7 @@ namespace Exiv2 { std::vector numbers; for(long i=0; i(l)); @@ -578,7 +578,7 @@ namespace Exiv2 { std::ostream& Casio2MakerNote::print0x2022(std::ostream& os, const Value& value, const ExifData*) { std::ios::fmtflags f( os.flags() ); - if(value.toLong()>=0x20000000) + if(value.toInt64()>=0x20000000) { os << N_("Inf"); os.flags(f); @@ -586,7 +586,7 @@ namespace Exiv2 { }; std::ostringstream oss; oss.copyfmt(os); - os << std::fixed << std::setprecision(2) << value.toLong() / 1000.0 << _(" m"); + os << std::fixed << std::setprecision(2) << value.toInt64() / 1000.0 << _(" m"); os.copyfmt(oss); os.flags(f); return os; diff --git a/src/crwimage_int.cpp b/src/crwimage_int.cpp index 6c8ae8f5..34227ca6 100644 --- a/src/crwimage_int.cpp +++ b/src/crwimage_int.cpp @@ -836,8 +836,8 @@ namespace Exiv2 { return decodeBasic(ciffComponent, pCrwMapping, image, byteOrder); } - long aperture = 0; - long shutterSpeed = 0; + int64_t aperture = 0; + int64_t shutterSpeed = 0; IfdId ifdId = ifdIdNotSet; switch (pCrwMapping->tag_) { @@ -861,8 +861,8 @@ namespace Exiv2 { if (ifdId == canonCsId && c == 23 && component_size >= 52) n = 3; value.read(ciffComponent.pData() + c*2, n*2, byteOrder); image.exifData().add(key, &value); - if (ifdId == canonSiId && c == 21) aperture = value.toLong(); - if (ifdId == canonSiId && c == 22) shutterSpeed = value.toLong(); + if (ifdId == canonSiId && c == 21) aperture = value.toInt64(); + if (ifdId == canonSiId && c == 22) shutterSpeed = value.toInt64(); c += n; } diff --git a/src/easyaccess.cpp b/src/easyaccess.cpp index caaf84ce..2f216e61 100644 --- a/src/easyaccess.cpp +++ b/src/easyaccess.cpp @@ -128,14 +128,14 @@ namespace Exiv2 { // Find the first ISO value which is not "0" const int cnt = EXV_COUNTOF(keys); auto md = ed.end(); - long iso_val = -1; + int64_t iso_val = -1; for (int idx = 0; idx < cnt; ) { md = findMetadatum(ed, keys + idx, cnt - idx); if (md == ed.end()) break; std::ostringstream os; md->write(os, &ed); bool ok = false; - iso_val = parseLong(os.str(), ok); + iso_val = parseInt64(os.str(), ok); if (ok && iso_val > 0) break; while (strcmp(keys[idx++], md->key().c_str()) != 0 && idx < cnt) {} md = ed.end(); @@ -144,7 +144,7 @@ namespace Exiv2 { // there is either a possible ISO "overflow" or no legacy // ISO tag at all. Check for SensitivityType tag and the referenced // ISO value (see EXIF 2.3 Annex G) - long iso_tmp_val = -1; + int64_t iso_tmp_val = -1; while (iso_tmp_val == -1 && (iso_val == 65535 || md == ed.end())) { auto md_st = findMetadatum(ed, sensitivityType, 1); // no SensitivityType? exit with existing data @@ -154,7 +154,7 @@ namespace Exiv2 { std::ostringstream os; md_st->write(os, &ed); bool ok = false; - const long st_val = parseLong(os.str(), ok); + const int64_t st_val = parseInt64(os.str(), ok); // SensitivityType out of range or cannot be parsed properly if (!ok || st_val < 1 || st_val > 7) break; @@ -169,7 +169,7 @@ namespace Exiv2 { std::ostringstream os_iso; md_st->write(os_iso, &ed); ok = false; - iso_tmp_val = parseLong(os_iso.str(), ok); + iso_tmp_val = parseInt64(os_iso.str(), ok); // something wrong with the value if (ok || iso_tmp_val > 0) { md = md_st; diff --git a/src/exif.cpp b/src/exif.cpp index 6435ec6e..6ebcd433 100644 --- a/src/exif.cpp +++ b/src/exif.cpp @@ -420,7 +420,7 @@ namespace Exiv2 { long Exifdatum::toLong(long n) const { - return value_.get() == nullptr ? -1 : value_->toLong(n); + return value_.get() == nullptr ? -1 : static_cast(value_->toInt64(n)); } float Exifdatum::toFloat(long n) const diff --git a/src/iptc.cpp b/src/iptc.cpp index 64e98a9d..c30b7e78 100644 --- a/src/iptc.cpp +++ b/src/iptc.cpp @@ -183,7 +183,7 @@ namespace Exiv2 { long Iptcdatum::toLong(long n) const { - return value_.get() == nullptr ? -1 : value_->toLong(n); + return value_.get() == nullptr ? -1 : static_cast(value_->toInt64(n)); } float Iptcdatum::toFloat(long n) const diff --git a/src/makernote_int.cpp b/src/makernote_int.cpp index 04c375eb..164b5bb8 100644 --- a/src/makernote_int.cpp +++ b/src/makernote_int.cpp @@ -1174,7 +1174,7 @@ namespace Exiv2 { pRoot->accept(finder); auto te = dynamic_cast(finder.result()); if (!te || !te->pValue() || te->pValue()->count() == 0) return buf; - auto count = static_cast(te->pValue()->toLong()); + auto count = te->pValue()->toUint32(); // Find Exif.Nikon3.SerialNumber finder.init(0x001d, nikon3Id); @@ -1245,13 +1245,13 @@ namespace Exiv2 { if (value->count() < 4) return -1; - switch (value->toLong(0)) { // Using encrypted values + switch (value->toInt64(0)) { // Using encrypted values case 231: // 231 == 9 case 234: // 234 == 12 case 205: // 205 == 13 case 138: // 138 == 15 case 112: // 112 == 16 - return value->toLong(3) == 8 ? 0 : -1; // 8 == 2 + return value->toInt64(3) == 8 ? 0 : -1; // 8 == 2 default: break; } @@ -1273,7 +1273,7 @@ namespace Exiv2 { if (value->count() < 1) return -1; - switch (value->toLong()) { // Using encrypted values + switch (value->toInt64()) { // Using encrypted values case 35: // 35 == 62 case 36: // 36 == 48 case 38: // 38 == 215 diff --git a/src/minoltamn_int.cpp b/src/minoltamn_int.cpp index d18f7279..a445369f 100644 --- a/src/minoltamn_int.cpp +++ b/src/minoltamn_int.cpp @@ -406,75 +406,75 @@ namespace Exiv2 { std::ostream& MinoltaMakerNote::printMinoltaExposureSpeedStd(std::ostream& os, const Value& value, const ExifData*) { // From the PHP JPEG Metadata Toolkit - os << (value.toLong()/8)-1; + os << (value.toInt64()/8)-1; return os; } std::ostream& MinoltaMakerNote::printMinoltaExposureTimeStd(std::ostream& os, const Value& value, const ExifData*) { // From the PHP JPEG Metadata Toolkit - os << (value.toLong()/8)-6; + os << (value.toInt64()/8)-6; return os; } std::ostream& MinoltaMakerNote::printMinoltaFNumberStd(std::ostream& os, const Value& value, const ExifData*) { // From the PHP JPEG Metadata Toolkit - os << (value.toLong()/8)-1; + os << (value.toInt64()/8)-1; return os; } std::ostream& MinoltaMakerNote::printMinoltaExposureCompensationStd(std::ostream& os, const Value& value, const ExifData*) { // From the PHP JPEG Metadata Toolkit - os << value.toLong()/256; + os << value.toInt64()/256; return os; } std::ostream& MinoltaMakerNote::printMinoltaFocalLengthStd(std::ostream& os, const Value& value, const ExifData*) { // From the PHP JPEG Metadata Toolkit - os << (value.toLong()/3)-2; + os << (value.toInt64()/3)-2; return os; } std::ostream& MinoltaMakerNote::printMinoltaDateStd(std::ostream& os, const Value& value, const ExifData*) { // From the PHP JPEG Metadata Toolkit - os << value.toLong() / 65536 << ":" << std::right << std::setw(2) << std::setfill('0') - << (value.toLong() - value.toLong() / 65536 * 65536) / 256 << ":" - << std::right << std::setw(2) << std::setfill('0') << value.toLong() % 256; + os << value.toInt64() / 65536 << ":" << std::right << std::setw(2) << std::setfill('0') + << (value.toInt64() - value.toInt64() / 65536 * 65536) / 256 << ":" + << std::right << std::setw(2) << std::setfill('0') << value.toInt64() % 256; return os; } std::ostream& MinoltaMakerNote::printMinoltaTimeStd(std::ostream& os, const Value& value, const ExifData*) { // From the PHP JPEG Metadata Toolkit - os << std::right << std::setw(2) << std::setfill('0') << value.toLong() / 65536 + os << std::right << std::setw(2) << std::setfill('0') << value.toInt64() / 65536 << ":" << std::right << std::setw(2) << std::setfill('0') - << (value.toLong() - value.toLong() / 65536 * 65536) / 256 << ":" - << std::right << std::setw(2) << std::setfill('0') << value.toLong() % 256; + << (value.toInt64() - value.toInt64() / 65536 * 65536) / 256 << ":" + << std::right << std::setw(2) << std::setfill('0') << value.toInt64() % 256; return os; } std::ostream& MinoltaMakerNote::printMinoltaFlashExposureCompStd(std::ostream& os, const Value& value, const ExifData*) { // From the PHP JPEG Metadata Toolkit - os << (value.toLong()-6)/3; + os << (value.toInt64()-6)/3; return os; } std::ostream& MinoltaMakerNote::printMinoltaWhiteBalanceStd(std::ostream& os, const Value& value, const ExifData*) { // From the PHP JPEG Metadata Toolkit - os << value.toLong()/256; + os << value.toInt64()/256; return os; } std::ostream& MinoltaMakerNote::printMinoltaBrightnessStd(std::ostream& os, const Value& value, const ExifData*) { // From the PHP JPEG Metadata Toolkit - os << (value.toLong()/8)-6; + os << (value.toInt64()/8)-6; return os; } @@ -957,7 +957,7 @@ namespace Exiv2 { std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(2) - << (float (value.toLong()-128)/24); + << (float (value.toInt64()-128)/24); os.copyfmt(oss); os.flags(f); return os; @@ -970,7 +970,7 @@ namespace Exiv2 { std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(2) - << (float (value.toLong()-300)/100); + << (float (value.toInt64()-300)/100); os.copyfmt(oss); os.flags(f); return os; @@ -2203,7 +2203,7 @@ namespace Exiv2 { } struct LensIdFct { - long id_; //!< Lens id + uint32_t id_; //!< Lens id PrintFct fct_; //!< Pretty-print function //! Comparison operator for find template bool operator==(long id) const { return id_ == id; } @@ -2236,7 +2236,7 @@ namespace Exiv2 { } // #1145 - respect lenses with shared LensID - unsigned long index = value.toLong(); + uint32_t index = value.toUint32(); const LensIdFct* lif = find(lensIdFct,index); if ( lif && metadata ) { if ( lif->fct_ ) diff --git a/src/nikonmn_int.cpp b/src/nikonmn_int.cpp index b65c9a50..b5da7e8b 100644 --- a/src/nikonmn_int.cpp +++ b/src/nikonmn_int.cpp @@ -275,7 +275,7 @@ namespace Exiv2 { const ExifData*) { if (value.count() > 1) { - os << value.toLong(1); + os << value.toInt64(1); } else { os << "(" << value << ")"; @@ -303,7 +303,7 @@ namespace Exiv2 { ByteOrder bo = getKeyString("Exif.MakerNote.ByteOrder",exifData) == "MM" ? bigEndian : littleEndian; byte p[4]; for (int n = 0; n < 4; n++) - p[n] = static_cast(value.toLong(6 + n)); + p[n] = static_cast(value.toInt64(6 + n)); os << getLong(p, bo); } @@ -371,7 +371,7 @@ namespace Exiv2 { const ExifData*) { if (value.count() >= 1) { - const unsigned long focusArea = value.toLong(0); + const uint32_t focusArea = value.toUint32(0); if (focusArea >= EXV_COUNTOF(nikonFocusarea)) { os << "Invalid value"; } else { @@ -380,7 +380,7 @@ namespace Exiv2 { } if (value.count() >= 2) { os << "; "; - unsigned long focusPoint = value.toLong(1); + const uint32_t focusPoint = value.toUint32(1); switch (focusPoint) { // Could use array nikonFocuspoints @@ -399,8 +399,8 @@ namespace Exiv2 { } } if (value.count() >= 3) { - unsigned long focusPointsUsed1 = value.toLong(2); - unsigned long focusPointsUsed2 = value.toLong(3); + const uint32_t focusPointsUsed1 = value.toUint32(2); + const uint32_t focusPointsUsed2 = value.toUint32(3); if (focusPointsUsed1 != 0 && focusPointsUsed2 != 0) { @@ -1526,7 +1526,7 @@ namespace Exiv2 { const Value& value, const ExifData*) { - double v = 100 * exp((value.toLong() / 12.0 - 5) * log(2.0)); + double v = 100 * exp((value.toInt64() / 12.0 - 5) * log(2.0)); return os << static_cast(v + 0.5); } @@ -1535,7 +1535,7 @@ namespace Exiv2 { const ExifData*) { if (value.count() > 1) { - os << value.toLong(1); + os << value.toInt64(1); } else { os << "(" << value << ")"; @@ -1559,7 +1559,7 @@ namespace Exiv2 { const Value& value, const ExifData*) { - long lensType = value.toLong(); + const uint32_t lensType = value.toUint32(); bool valid=false; if (lensType & 1) @@ -1600,8 +1600,8 @@ namespace Exiv2 { os << "(" << value << ")"; return os; } - long len1 = value.toLong(0); - long len2 = value.toLong(1); + const int64_t len1 = value.toInt64(0); + const int64_t len2 = value.toInt64(1); Rational fno1 = value.toRational(2); Rational fno2 = value.toRational(3); @@ -1676,12 +1676,12 @@ namespace Exiv2 { } else { // Mapping by Roger Larsson - unsigned focusmetering = value.toLong(0); - unsigned focuspoint = value.toLong(1); - unsigned focusused = (value.toLong(2) << 8) + value.toLong(3); + const uint32_t focusmetering = value.toUint32(0); + const uint32_t focuspoint = value.toUint32(1); + const uint32_t focusused = (value.toUint32(2) << 8) + value.toUint32(3); // TODO: enum {standard, wide} combination = standard; - const unsigned focuspoints = sizeof(nikonFocuspoints) - / sizeof(nikonFocuspoints[0]); + const size_t focuspoints = sizeof(nikonFocuspoints) + / sizeof(nikonFocuspoints[0]); if (focusmetering == 0 && focuspoint == 0 && focusused == 0) { // Special case, in Manual focus and with Nikon compacts @@ -1725,7 +1725,7 @@ namespace Exiv2 { // selected point was not the actually used one // (Roger Larsson: my interpretation, verify) os << sep; - for (unsigned fpid=0; fpid(value.toLong()); + auto val = static_cast(value.toInt64()); if (dModel) val = (val >> 8) | ((val & 0x00ff) << 8); if (val == 0x07ff) return os << _("All 11 Points"); @@ -1770,7 +1770,7 @@ namespace Exiv2 { if (value.count() != 1 || value.typeId() != unsignedShort) { return os << "(" << value << ")"; } - long l = value.toLong(0); + const auto l = value.toInt64(0); if (l == 0) return os << _("Single-frame"); if (!(l & 0x87)) os << _("Single-frame") << ", "; bool d70 = false; @@ -1803,8 +1803,8 @@ namespace Exiv2 { return os << "(" << value << ")"; } float a = value.toFloat(0); - long b = value.toLong(1); - long c = value.toLong(2); + const auto b = value.toInt64(1); + const auto c = value.toInt64(2); if (c == 0) return os << "(" << value << ")"; return os << a * b / c; } @@ -2621,7 +2621,7 @@ fmountlens[] = { */ if (metadata == nullptr) { - const unsigned char vid = static_cast(value.toLong(0)); + const unsigned char vid = static_cast(value.toInt64(0)); /* the 'FMntLens' name is added to the anonymous struct for * fmountlens[] @@ -2716,7 +2716,7 @@ fmountlens[] = { os.flags(f); return os; } - double dist = 0.01 * pow(10.0, value.toLong()/40.0); + double dist = 0.01 * pow(10.0, value.toInt64()/40.0); std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(2) << dist << " m"; @@ -2735,7 +2735,7 @@ fmountlens[] = { os.flags(f); return os; } - double aperture = pow(2.0, value.toLong()/24.0); + double aperture = pow(2.0, value.toInt64()/24.0); std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(1) << "F" << aperture; @@ -2751,7 +2751,7 @@ fmountlens[] = { if (value.count() != 1 || value.typeId() != unsignedByte) { return os << "(" << value << ")"; } - double focal = 5.0 * pow(2.0, value.toLong()/24.0); + double focal = 5.0 * pow(2.0, value.toInt64()/24.0); std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(1) << focal << " mm"; @@ -2769,7 +2769,7 @@ fmountlens[] = { os.flags(f); return os; } - double fstops = value.toLong()/12.0; + double fstops = value.toInt64()/12.0; std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(1) << "F" << fstops; @@ -2783,12 +2783,12 @@ fmountlens[] = { const ExifData*) { std::ios::fmtflags f( os.flags() ); - if (value.count() != 1 || value.typeId() != unsignedByte || value.toLong() == 0) { + if (value.count() != 1 || value.typeId() != unsignedByte || value.toInt64() == 0) { os << "(" << value << ")"; os.flags(f); return os; } - double epp = 2048.0/value.toLong(); + double epp = 2048.0/value.toInt64(); std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(1) << epp << " mm"; @@ -2807,7 +2807,7 @@ fmountlens[] = { os.flags(f); return os; } - auto temp = value.toLong(); + auto temp = value.toInt64(); if (temp == 0 || temp == 255) return os << _("n/a"); @@ -2827,7 +2827,7 @@ fmountlens[] = { if (value.count() != 1 || value.typeId() != unsignedByte) { return os << "(" << value << ")"; } - auto temp = value.toLong(); + auto temp = value.toInt64(); if (temp == 0 || temp == 255) return os << _("n/a"); @@ -2847,7 +2847,7 @@ fmountlens[] = { if (value.count() != 1 || value.typeId() != unsignedByte) { return os << "(" << value << ")"; } - auto temp = value.toLong(); + auto temp = value.toInt64(); if (temp == 0 || temp == 255) return os << _("n/a"); @@ -2871,9 +2871,9 @@ fmountlens[] = { } std::ostringstream oss; oss.copyfmt(os); - os << (value.toLong() & 0x80 ? _("External flash zoom override") : _("No external flash zoom override")); + os << (value.toInt64() & 0x80 ? _("External flash zoom override") : _("No external flash zoom override")); os << ", "; - os << (value.toLong() & 0x01 ? _("external flash attached") : _("external flash not attached")); + os << (value.toInt64() & 0x01 ? _("external flash attached") : _("external flash not attached")); os.copyfmt(oss); os.flags(f); @@ -2893,7 +2893,7 @@ fmountlens[] = { std::ostringstream oss; oss.copyfmt(os); - long temp = value.toLong(); + const auto temp = value.toInt64(); switch (temp & 0x07) { case 0: @@ -2959,7 +2959,7 @@ fmountlens[] = { } std::ostringstream oss; oss.copyfmt(os); - long temp = value.toLong(); + const auto temp = value.toInt64(); printTag(os, (temp >> 4), data); os << ", "; @@ -3105,7 +3105,7 @@ fmountlens[] = { } std::ostringstream oss; oss.copyfmt(os); - char sign = value.toLong() < 0 ? '-' : '+'; + char sign = value.toInt64() < 0 ? '-' : '+'; long h = long(std::abs(static_cast(value.toFloat() / 60.0F))) % 24; long min = long(std::abs(static_cast(value.toFloat() - h * 60))) % 60; os << std::fixed << "UTC " << sign << std::setw(2) << std::setfill('0') << h << ":" @@ -3122,7 +3122,7 @@ fmountlens[] = { if (value.count() != 1 || value.typeId() != unsignedByte) { return os << "(" << value << ")"; } - long pcval = value.toLong() - 0x80; + const auto pcval = value.toInt64() - 0x80; std::ostringstream oss; oss.copyfmt(os); switch(pcval) @@ -3169,7 +3169,7 @@ fmountlens[] = { std::string s; bool trim = true; for (int i = 9; i >= 0; --i) { - long l = value.toLong(i); + const auto l = value.toInt64(i); if (i > 0 && l == 0 && trim) continue; if (l != 0) trim = false; std::string d = s.empty() ? "" : "; "; @@ -3216,7 +3216,7 @@ fmountlens[] = { {23, "Nikon", "Nikkor Z 14-24mm f/2.8 S"}, // IB }; - auto lid = static_cast(value.toLong()); + auto lid = static_cast(value.toInt64()); auto it = std::find_if(std::begin(zmountlens), std::end(zmountlens), [=](const ZMntLens& z) { return z.lid == lid; }); if (it != std::end(zmountlens)) @@ -3232,7 +3232,7 @@ fmountlens[] = { return os << "(" << value << ")"; } - double aperture = pow(2.0, value.toLong()/384.0 - 1.0); + double aperture = pow(2.0, value.toInt64()/384.0 - 1.0); std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(1) << "F" << aperture; @@ -3248,7 +3248,7 @@ fmountlens[] = { } std::ostringstream oss; oss.copyfmt(os); - os << std::fixed << std::setprecision(1) << value.toLong() << " mm"; + os << std::fixed << std::setprecision(1) << value.toInt64() << " mm"; os.copyfmt(oss); return os; } diff --git a/src/olympusmn_int.cpp b/src/olympusmn_int.cpp index 4abeeff4..2a4e6c02 100644 --- a/src/olympusmn_int.cpp +++ b/src/olympusmn_int.cpp @@ -1108,16 +1108,16 @@ namespace Exiv2 { return os << value; } - if (value.toLong(0) == -1 && value.toLong(1) == -1 && value.toLong(2) == 1) os << _("Low Key"); - else if (value.toLong(0) == 0 && value.toLong(1) == -1 && value.toLong(2) == 1) os << _("Normal"); - else if (value.toLong(0) == 1 && value.toLong(1) == -1 && value.toLong(2) == 1) os << _("High Key"); - else os << value.toLong(0) << " " << value.toLong(1) << " " << value.toLong(2); + if (value.toInt64(0) == -1 && value.toInt64(1) == -1 && value.toInt64(2) == 1) os << _("Low Key"); + else if (value.toInt64(0) == 0 && value.toInt64(1) == -1 && value.toInt64(2) == 1) os << _("Normal"); + else if (value.toInt64(0) == 1 && value.toInt64(1) == -1 && value.toInt64(2) == 1) os << _("High Key"); + else os << value.toInt64(0) << " " << value.toInt64(1) << " " << value.toInt64(2); if (value.count() == 4) { - switch (value.toLong(3)) { + switch (value.toInt64(3)) { case 0: os << ", " << _("User-Selected"); break; case 1: os << ", " << _("Auto-Override"); break; - default: os << value.toLong(3); break; + default: os << value.toInt64(3); break; } } return os; @@ -1128,17 +1128,17 @@ namespace Exiv2 { { if ( value.count() != 3 || value.typeId() != signedShort - || value.toLong(1) != -2 - || value.toLong(2) != 1) { + || value.toInt64(1) != -2 + || value.toInt64(2) != 1) { return os << value; } - switch (value.toLong(0)) { + switch (value.toInt64(0)) { case -2: os << _("Off"); break; case -1: os << _("Low"); break; case 0: os << _("Standard"); break; case 1: os << _("High"); break; - default: os << value.toLong(0); break; + default: os << value.toInt64(0); break; } return os; @@ -1149,7 +1149,7 @@ namespace Exiv2 { if (value.count() != 3 || value.typeId() != unsignedLong) { return os << value; } - long l0 = value.toLong(0); + const auto l0 = value.toInt64(0); switch (l0) { case 0: os << _("Normal"); break; case 2: os << _("Fast"); break; @@ -1158,12 +1158,12 @@ namespace Exiv2 { } if (l0 != 0) { os << ", "; - long l1 = value.toLong(1); + const auto l1 = value.toInt64(1); os << _("Sequence number") << " " << l1; } if (l0 != 0 && l0 != 2) { os << ", "; - long l2 = value.toLong(2); + const auto l2 = value.toInt64(2); switch (l2) { case 1: os << _("Left to right"); break; case 2: os << _("Right to left"); break; @@ -1199,7 +1199,7 @@ namespace Exiv2 { return os << value; } if (value.count() == 1) { - auto l0 = static_cast(value.toLong(0)); + auto l0 = static_cast(value.toInt64(0)); if (l0 == 1) { os << _("Auto"); } @@ -1208,8 +1208,8 @@ namespace Exiv2 { } } else if (value.count() == 2) { - auto l0 = static_cast(value.toLong(0)); - auto l1 = static_cast(value.toLong(1)); + auto l0 = static_cast(value.toInt64(0)); + auto l1 = static_cast(value.toInt64(1)); if (l0 == 1) { switch (l1) { case 0: os << _("Auto"); break; @@ -1380,9 +1380,9 @@ namespace Exiv2 { return os << value; } - byte v0 = static_cast(value.toLong(0)); - byte v2 = static_cast(value.toLong(2)); - byte v3 = static_cast(value.toLong(3)); + byte v0 = static_cast(value.toInt64(0)); + byte v2 = static_cast(value.toInt64(2)); + byte v3 = static_cast(value.toInt64(3)); for (auto&& type : lensTypes) { if (type.val[0] == v0 && type.val[1] == v2 && type.val[2] == v3) { @@ -1401,7 +1401,7 @@ namespace Exiv2 { char ch; int size = value.size(); - for (int i = 0; i < size && ((ch = static_cast(value.toLong(i))) != '\0'); i++) { + for (int i = 0; i < size && ((ch = static_cast(value.toInt64(i))) != '\0'); i++) { os << ch; } return os; @@ -1426,8 +1426,8 @@ namespace Exiv2 { return os << value; } - byte v0 = static_cast(value.toLong(0)); - byte v2 = static_cast(value.toLong(2)); + byte v0 = static_cast(value.toInt64(0)); + byte v2 = static_cast(value.toInt64(2)); for (auto&& model : extenderModels) { if (model.val[0] == v0 && model.val[1] == v2) { @@ -1467,13 +1467,13 @@ namespace Exiv2 { if (value.count() < 1 || value.typeId() != unsignedShort) { return os << "(" << value << ")"; } - auto v = static_cast(value.toLong(0)); + auto v = static_cast(value.toInt64(0)); // If value 2 is present, it is used instead of value 1. if (value.count() > 1) { std::string p; // Used to enable ',' separation - v = static_cast(value.toLong(1)); + v = static_cast(value.toInt64(1)); for (auto&& mode : focusModes1) { if ((v &mode.val) != 0) { if (!p.empty()) { @@ -1547,8 +1547,8 @@ namespace Exiv2 { return os << value; } - auto v0 = static_cast(value.toLong(0)); - auto v1 = static_cast(value.toLong(1)); + auto v0 = static_cast(value.toInt64(0)); + auto v1 = static_cast(value.toInt64(1)); for (auto&& filter : artFilters) { if (filter.val[0] == v0 && filter.val[1] == v1) { @@ -1565,13 +1565,13 @@ namespace Exiv2 { return os << value; } - switch (value.toLong(0)) { + switch (value.toInt64(0)) { case 0: os << _("Off"); break; case 1: os << _("On"); break; - default: os << value.toLong(0); break; + default: os << value.toInt64(0); break; } os << " "; - os << value.toLong(1); + os << value.toInt64(1); return os; } // OlympusMakerNote::print0x1209 @@ -1660,7 +1660,7 @@ value, const ExifData* metadata) } } - auto v = static_cast(value.toLong(0)); + auto v = static_cast(value.toInt64(0)); if (!E3_E30model) { for (auto&& point : afPoints) { diff --git a/src/panasonicmn_int.cpp b/src/panasonicmn_int.cpp index 52b1baef..cbe1a65a 100644 --- a/src/panasonicmn_int.cpp +++ b/src/panasonicmn_int.cpp @@ -544,8 +544,8 @@ namespace Exiv2 { if (value.count() < 2 || value.typeId() != unsignedByte) { return os << value; } - long l0 = value.toLong(0); - long l1 = value.toLong(1); + const auto l0 = value.toInt64(0); + const auto l1 = value.toInt64(1); if (l0 == 0 && l1 == 1) os << _("Spot mode on or 9 area"); else if (l0 == 0 && l1 == 16) os << _("Spot mode off or 3-area (high speed)"); else if (l0 == 0 && l1 == 23) os << _("23-area"); @@ -575,7 +575,7 @@ namespace Exiv2 { std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(1) - << value.toLong() / 3 << _(" EV"); + << value.toInt64() / 3 << _(" EV"); os.copyfmt(oss); os.flags(f); @@ -590,7 +590,7 @@ namespace Exiv2 { { std::ostringstream oss; oss.copyfmt(os); - long time=value.toLong(); + const auto time=value.toInt64(); os << std::setw(2) << std::setfill('0') << time / 360000 << ":" << std::setw(2) << std::setfill('0') << (time % 360000) / 6000 << ":" << std::setw(2) << std::setfill('0') << (time % 6000) / 100 << "." @@ -622,7 +622,7 @@ namespace Exiv2 { const Value& value, const ExifData*) { - if(value.toLong()==65535) + if(value.toInt64()==65535) { os << N_("not set"); } @@ -638,7 +638,7 @@ namespace Exiv2 { const Value& value, const ExifData*) { - switch(value.toLong()) + switch(value.toInt64()) { case 65534: os << N_("Intelligent ISO"); @@ -661,11 +661,11 @@ namespace Exiv2 { { for(long i=0; i< value.size(); i++) { - if(value.toLong(i)==0) + if(value.toInt64(i)==0) { break; }; - os << static_cast(value.toLong(i)); + os << static_cast(value.toInt64(i)); }; return os; } @@ -677,7 +677,7 @@ namespace Exiv2 { // Manometer Pressure std::ostream& PanasonicMakerNote::printPressure(std::ostream& os, const Value& value, const ExifData*) { - switch(value.toLong()) + switch(value.toInt64()) { case 65535: os << N_("infinite"); @@ -692,14 +692,14 @@ namespace Exiv2 { std::ostream& PanasonicMakerNote::printAccelerometer(std::ostream& os, const Value& value, const ExifData*) { // value is stored as unsigned int, but should be read as int16_t. - const int16_t i = static_cast(value.toLong()); + const int16_t i = static_cast(value.toInt64()); return os << i; } // PanasonicMakerNote::printAccelerometer std::ostream& PanasonicMakerNote::printRollAngle(std::ostream& os, const Value& value, const ExifData*) { // value is stored as unsigned int, but should be read as int16_t. - const int16_t i = static_cast(value.toLong()); + const int16_t i = static_cast(value.toInt64()); std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(1) << i / 10.0; @@ -711,7 +711,7 @@ namespace Exiv2 { std::ostream& PanasonicMakerNote::printPitchAngle(std::ostream& os, const Value& value, const ExifData*) { // value is stored as unsigned int, but should be read as int16_t. - const int16_t i = static_cast(value.toLong()); + const int16_t i = static_cast(value.toInt64()); std::ostringstream oss; oss.copyfmt(os); os << std::fixed << std::setprecision(1) << -i / 10.0; diff --git a/src/pentaxmn_int.cpp b/src/pentaxmn_int.cpp index 8888247b..f4f758ed 100644 --- a/src/pentaxmn_int.cpp +++ b/src/pentaxmn_int.cpp @@ -1036,29 +1036,29 @@ namespace Exiv2 { std::ostream& PentaxMakerNote::printDate(std::ostream& os, const Value& value, const ExifData*) { /* I choose same format as is used inside EXIF itself */ - os << ((static_cast(value.toLong(0)) << 8) + value.toLong(1)); + os << ((static_cast(value.toInt64(0)) << 8) + value.toInt64(1)); os << ":"; - os << std::setw(2) << std::setfill('0') << value.toLong(2); + os << std::setw(2) << std::setfill('0') << value.toInt64(2); os << ":"; - os << std::setw(2) << std::setfill('0') << value.toLong(3); + os << std::setw(2) << std::setfill('0') << value.toInt64(3); return os; } std::ostream& PentaxMakerNote::printTime(std::ostream& os, const Value& value, const ExifData*) { std::ios::fmtflags f( os.flags() ); - os << std::setw(2) << std::setfill('0') << value.toLong(0); + os << std::setw(2) << std::setfill('0') << value.toInt64(0); os << ":"; - os << std::setw(2) << std::setfill('0') << value.toLong(1); + os << std::setw(2) << std::setfill('0') << value.toInt64(1); os << ":"; - os << std::setw(2) << std::setfill('0') << value.toLong(2); + os << std::setw(2) << std::setfill('0') << value.toInt64(2); os.flags(f); return os; } std::ostream& PentaxMakerNote::printExposure(std::ostream& os, const Value& value, const ExifData*) { - os << static_cast(value.toLong()) / 100 << " ms"; + os << static_cast(value.toInt64()) / 100 << " ms"; return os; } @@ -1066,7 +1066,7 @@ namespace Exiv2 { { std::ios::fmtflags f( os.flags() ); os << "F" << std::setprecision(2) - << static_cast(value.toLong()) / 10; + << static_cast(value.toInt64()) / 10; os.flags(f); return os; } @@ -1075,7 +1075,7 @@ namespace Exiv2 { { std::ios::fmtflags f( os.flags() ); os << std::fixed << std::setprecision(1) - << static_cast(value.toLong()) / 100 + << static_cast(value.toInt64()) / 100 << " mm"; os.flags(f); return os; @@ -1085,7 +1085,7 @@ namespace Exiv2 { { std::ios::fmtflags f( os.flags() ); os << std::setprecision(2) - << (static_cast(value.toLong()) - 50) / 10 + << (static_cast(value.toInt64()) - 50) / 10 << " EV"; os.flags(f); return os; @@ -1093,7 +1093,7 @@ namespace Exiv2 { std::ostream& PentaxMakerNote::printTemperature(std::ostream& os, const Value& value, const ExifData*) { - os << value.toLong() << " C"; + os << value.toInt64() << " C"; return os; } @@ -1101,7 +1101,7 @@ namespace Exiv2 { { std::ios::fmtflags f( os.flags() ); os << std::setprecision(2) - << static_cast(value.toLong()) / 256 + << static_cast(value.toInt64()) / 256 << " EV"; os.flags(f); return os; @@ -1109,7 +1109,7 @@ namespace Exiv2 { std::ostream& PentaxMakerNote::printBracketing(std::ostream& os, const Value& value, const ExifData*) { - long l0 = value.toLong(0); + const auto l0 = value.toInt64(0); if (l0 < 10) { os << std::setprecision(2) @@ -1120,13 +1120,13 @@ namespace Exiv2 { } if (value.count() == 2) { - long l1 = value.toLong(1); + const auto l1 = value.toInt64(1); os << " ("; if (l1 == 0) { os << _("No extended bracketing"); } else { - long type = l1 >> 8; - long range = l1 & 0xff; + auto type = l1 >> 8; + auto range = l1 & 0xff; switch (type) { case 1: os << _("WB-BA"); @@ -1181,8 +1181,8 @@ namespace Exiv2 { (timeIt->toLong(0) << 24) + (timeIt->toLong(1) << 16) + (timeIt->toLong(2) << 8); const uint32_t countEnc = - (value.toLong(0) << 24) + (value.toLong(1) << 16) + - (value.toLong(2) << 8) + (value.toLong(3) << 0); + (value.toUint32(0) << 24) + (value.toUint32(1) << 16) + + (value.toUint32(2) << 8) + (value.toUint32(3) << 0); // The shutter count is encoded using date and time values stored // in Pentax-specific tags. The prototype for the encoding/decoding // function is taken from Phil Harvey's ExifTool: Pentax.pm file, @@ -1412,7 +1412,7 @@ namespace Exiv2 { return os << Internal::readExiv2Config(section,value.toString(),undefined); } - unsigned long index = value.toLong(0)*256+value.toLong(1); + const auto index = value.toUint32(0)*256+value.toUint32(1); // std::cout << std::endl << "printLensType value =" << value.toLong() << " index = " << index << std::endl; const LensIdFct* lif = find(lensIdFct, index); diff --git a/src/pentaxmn_int.hpp b/src/pentaxmn_int.hpp index 147dcb51..597c9728 100644 --- a/src/pentaxmn_int.hpp +++ b/src/pentaxmn_int.hpp @@ -85,12 +85,12 @@ namespace Exiv2 { if ((value.count() != count && (value.count() < (count + ignoredcount) || value.count() > (count + ignoredcountmax))) || count > 4) { return printValue(os, value, metadata); } - unsigned long l = 0; + uint32_t l = 0; for (int c = 0; c < count; ++c) { - if (value.toLong(c) < 0 || value.toLong(c) > 255) { + if (value.toInt64(c) < 0 || value.toInt64(c) > 255) { return printValue(os, value, metadata); } - l += (value.toLong(c) << ((count - c - 1) * 8)); + l += (value.toUint32(c) << ((count - c - 1) * 8)); } const TagDetails* td = find(array, l); if (td) { diff --git a/src/preview.cpp b/src/preview.cpp index 049fd8c9..5748b459 100644 --- a/src/preview.cpp +++ b/src/preview.cpp @@ -798,8 +798,8 @@ namespace { if (sizes.count() == dataValue.count()) { if (sizes.count() == 1) { // this saves one copying of the buffer - uint32_t offset = dataValue.toLong(0); - uint32_t size = sizes.toLong(0); + uint32_t offset = dataValue.toUint32(0); + uint32_t size = sizes.toUint32(0); if (Safe::add(offset, size) <= static_cast(io.size())) dataValue.setDataArea(base + offset, size); } @@ -809,8 +809,8 @@ namespace { DataBuf buf(size_); uint32_t idxBuf = 0; for (long i = 0; i < sizes.count(); i++) { - uint32_t offset = dataValue.toLong(i); - uint32_t size = sizes.toLong(i); + uint32_t offset = dataValue.toUint32(i); + uint32_t size = sizes.toUint32(i); // the size_ parameter is originally computed by summing all values inside sizes // see the constructor of LoaderTiff diff --git a/src/properties.cpp b/src/properties.cpp index f9dd5e0c..3a55e5cf 100644 --- a/src/properties.cpp +++ b/src/properties.cpp @@ -3890,9 +3890,9 @@ namespace Exiv2 { {"Xmp.exif.WhiteBalance", print0xa403 }, {"Xmp.tiff.Orientation", print0x0112 }, {"Xmp.tiff.ResolutionUnit", printExifUnit }, - {"Xmp.tiff.XResolution", printLong }, + {"Xmp.tiff.XResolution", printInt64 }, {"Xmp.tiff.YCbCrPositioning", print0x0213 }, - {"Xmp.tiff.YResolution", printLong }, + {"Xmp.tiff.YResolution", printInt64 }, {"Xmp.iptc.Scene", EXV_PRINT_VOCABULARY_MULTI(iptcScene) }, {"Xmp.iptc.SubjectCode", EXV_PRINT_VOCABULARY_MULTI(iptcSubjectCode) }, {"Xmp.iptcExt.DigitalSourcefileType", EXV_PRINT_VOCABULARY(iptcExtDigitalSourcefileType) }, diff --git a/src/samsungmn_int.cpp b/src/samsungmn_int.cpp index ff695533..81f564ba 100644 --- a/src/samsungmn_int.cpp +++ b/src/samsungmn_int.cpp @@ -87,7 +87,7 @@ namespace Exiv2 { if (value.count() != 1 || value.typeId() != unsignedLong) { return os << value; } - long length = value.toLong(); + const auto length = value.toInt64(); if (length == 0) { os << _("Unknown"); } @@ -165,11 +165,11 @@ namespace Exiv2 { return os << value; } // Special case where no color modification is done - if (value.toLong() == 65535) { + if (value.toInt64() == 65535) { return os << _("Neutral"); } // Output seems to represent Hue in degrees - return os << value.toLong(); + return os << value.toInt64(); } //! Print the tag value minus 4 @@ -178,7 +178,7 @@ namespace Exiv2 { if (value.count() != 1 || value.typeId() != unsignedShort) { return os << value; } - return os << value.toLong(0) - 4; + return os << value.toInt64(0) - 4; } // Samsung PictureWizard Tag Info diff --git a/src/sonymn_int.cpp b/src/sonymn_int.cpp index e9fa72eb..0cc2f0bc 100644 --- a/src/sonymn_int.cpp +++ b/src/sonymn_int.cpp @@ -868,7 +868,7 @@ namespace Exiv2 { if (value.count() != 1) os << value; else { - long val = (value.toLong() & 0x7F); + const auto val = (value.toInt64() & 0x7F); switch (val) { case 0: os << N_("Manual"); @@ -910,7 +910,7 @@ namespace Exiv2 { return os; } } - long val = value.toLong(); + const auto val = value.toInt64(); switch (val) { case 255: os << N_("Infinity"); @@ -1028,7 +1028,7 @@ namespace Exiv2 { return os << N_("n/a"); } - os << std::round((value.toLong()/10.24)) << "%"; + os << std::round((value.toInt64()/10.24)) << "%"; return os; } @@ -1156,7 +1156,7 @@ namespace Exiv2 { std::string model = pos->toString(); for (auto& m : models) { if (m == model) - return os << value.toLong(); + return os << value.toInt64(); } return os << N_("n/a"); @@ -1164,7 +1164,7 @@ namespace Exiv2 { std::ostream& SonyMakerNote::printSonyMisc3cSequenceNumber(std::ostream& os, const Value& value, const ExifData*) { - return (value.count() != 1) ? os << "(" << value << ")" : os << (value.toLong()+1); + return (value.count() != 1) ? os << "(" << value << ")" : os << (value.toInt64()+1); } std::ostream& SonyMakerNote::printSonyMisc3cQuality2(std::ostream& os, const Value& value, const ExifData* metadata) @@ -1176,7 +1176,7 @@ namespace Exiv2 { if (pos == metadata->end()) return os << "(" << value << ")"; - long val = value.toLong(); + const auto val = value.toInt64(); std::string model = pos->toString(); // Value is interpreted differently if model is in list or not @@ -1231,7 +1231,7 @@ namespace Exiv2 { return os << N_("n/a"); } - long val = value.toLong(); + const auto val = value.toInt64(); return val > 0 ? os << (8*val) : os << N_("n/a"); } @@ -1252,7 +1252,7 @@ namespace Exiv2 { return os << N_("n/a"); } - long val = value.toLong(); + const auto val = value.toInt64(); if (val > 99) return os << "(" << val << ")"; diff --git a/src/tags_int.cpp b/src/tags_int.cpp index 62537bae..2e142931 100644 --- a/src/tags_int.cpp +++ b/src/tags_int.cpp @@ -591,11 +591,11 @@ namespace Exiv2 { {0x011a, "XResolution", N_("X-Resolution"), N_("The number of pixels per in the " "direction. When the image resolution is unknown, 72 [dpi] is designated."), - ifd0Id, imgStruct, unsignedRational, 1, printLong}, + ifd0Id, imgStruct, unsignedRational, 1, printInt64}, {0x011b, "YResolution", N_("Y-Resolution"), N_("The number of pixels per in the " "direction. The same value as is designated."), - ifd0Id, imgStruct, unsignedRational, 1, printLong}, + ifd0Id, imgStruct, unsignedRational, 1, printInt64}, {0x011c, "PlanarConfiguration", N_("Planar Configuration"), N_("Indicates whether pixel components are recorded in a chunky " "or planar format. In JPEG compressed files a JPEG marker " @@ -2591,7 +2591,7 @@ namespace Exiv2 { uint16_t bit = 0; uint16_t comma = 0; for (long i = 0; i < value.count(); i++ ) { // for each element in value array - auto bits = static_cast(value.toLong(i)); + auto bits = static_cast(value.toInt64(i)); for (uint16_t b = 0; b < 16; ++b) { // for every bit if (bits & (1 << b)) { if ( comma++ ) { @@ -2651,10 +2651,10 @@ namespace Exiv2 { return tag; } // tagNumber - std::ostream& printLong(std::ostream& os, const Value& value, const ExifData*) + std::ostream& printInt64(std::ostream& os, const Value& value, const ExifData*) { Rational r = value.toRational(); - if (r.second > 0) return os << static_cast(r.first) / r.second; + if (r.second > 0) return os << static_cast(r.first) / r.second; return os << "(" << value << ")"; } // printLong @@ -2745,10 +2745,10 @@ namespace Exiv2 { } for (int i = 0; i < 3; i++) { - os << value.toLong(i); + os << value.toInt64(i); os << "."; } - os << value.toLong(3); + os << value.toInt64(3); return os; } @@ -2933,13 +2933,13 @@ namespace Exiv2 { std::ostream& print0x8827(std::ostream& os, const Value& value, const ExifData*) { - return os << value.toLong(); + return os << value.toInt64(); } std::ostream& print0x9101(std::ostream& os, const Value& value, const ExifData*) { for (long i = 0; i < value.count(); ++i) { - long l = value.toLong(i); + const auto l = value.toInt64(i); switch (l) { case 0: break; case 1: os << "Y"; break; @@ -3169,7 +3169,7 @@ namespace Exiv2 { std::ostream& print0xa405(std::ostream& os, const Value& value, const ExifData*) { - long length = value.toLong(); + const auto length = value.toInt64(); if (length == 0) { os << _("Unknown"); } @@ -3258,7 +3258,7 @@ namespace Exiv2 { char s[5]; for (int i = 0; i < 4; ++i) { - s[i] = static_cast(value.toLong(i)); + s[i] = static_cast(value.toInt64(i)); } s[4] = '\0'; diff --git a/src/tags_int.hpp b/src/tags_int.hpp index ba319b96..20727ad4 100644 --- a/src/tags_int.hpp +++ b/src/tags_int.hpp @@ -232,7 +232,7 @@ namespace Exiv2 { const char* label_; //!< Translation of the tag value //! Comparison operator for use with the find template - bool operator==(long key) const { return val_ == key; } + bool operator==(int64_t key) const { return val_ == key; } }; // struct TagDetails /*! @@ -267,7 +267,7 @@ namespace Exiv2 { by looking up a reference table. */ template - std::ostream& printTag(std::ostream& os, const long& value, const ExifData*) + std::ostream& printTag(std::ostream& os, const int64_t value, const ExifData*) { const TagDetails* td = find(array, value); if (td) { @@ -286,7 +286,7 @@ namespace Exiv2 { template std::ostream& printTag(std::ostream& os, const Value& value, const ExifData* data) { - return printTag(os, value.toLong(), data); + return printTag(os, value.toInt64(), data); } //! Shortcut for the printTag template which requires typing the array name only once. @@ -299,7 +299,7 @@ namespace Exiv2 { template std::ostream& printTagBitmask(std::ostream& os, const Value& value, const ExifData*) { - const auto val = static_cast(value.toLong()); + const auto val = value.toUint32(); if (val == 0 && N > 0) { const TagDetailsBitmask* td = *(&array); if (td->mask_ == 0) return os << exvGettext(td->label_); @@ -423,8 +423,8 @@ namespace Exiv2 { //@{ //! Default print function, using the Value output operator std::ostream& printValue(std::ostream& os, const Value& value, const ExifData*); - //! Print the value converted to a long - std::ostream& printLong(std::ostream& os, const Value& value, const ExifData*); + //! Print the value converted to a int64_t + std::ostream& printInt64(std::ostream& os, const Value& value, const ExifData*); //! Print a Rational or URational value in floating point format std::ostream& printFloat(std::ostream& os, const Value& value, const ExifData*); //! Print a longitude or latitude value diff --git a/src/tiffcomposite_int.cpp b/src/tiffcomposite_int.cpp index b838acd6..a2ce2ef3 100644 --- a/src/tiffcomposite_int.cpp +++ b/src/tiffcomposite_int.cpp @@ -81,9 +81,12 @@ namespace Exiv2 { return io_.putb(data); } - void IoWrapper::setTarget(int id, uint32_t target) + void IoWrapper::setTarget(int id, int64_t target) { - if (pow_) pow_->setTarget(OffsetWriter::OffsetId(id), target); + if (target < 0 || target > std::numeric_limits::max()) { + throw Error(kerOffsetOutOfRange); + } + if (pow_) pow_->setTarget(OffsetWriter::OffsetId(id), static_cast(target)); } TiffComponent::TiffComponent(uint16_t tag, IfdId group) : tag_(tag), group_(group), pStart_(nullptr) @@ -319,7 +322,7 @@ namespace Exiv2 { size_ = buf->size(); } - void TiffEntryBase::setData(byte* pData, int32_t size, + void TiffEntryBase::setData(byte* pData, uint32_t size, const std::shared_ptr& storage) { pData_ = pData; @@ -390,13 +393,13 @@ namespace Exiv2 { } uint32_t size = 0; for (long i = 0; i < pSize->count(); ++i) { - size += static_cast(pSize->toLong(i)); + size += pSize->toUint32(i); } - auto offset = static_cast(pValue()->toLong(0)); + auto offset = pValue()->toUint32(0); // Todo: Remove limitation of JPEG writer: strips must be contiguous // Until then we check: last offset + last size - first offset == size? - if ( static_cast(pValue()->toLong(pValue()->count()-1)) - + static_cast(pSize->toLong(pSize->count()-1)) + if ( pValue()->toUint32(pValue()->count()-1) + + pSize->toUint32(pSize->count()-1) - offset != size) { #ifndef SUPPRESS_WARNINGS EXV_WARNING << "Directory " << groupName(group()) @@ -447,9 +450,9 @@ namespace Exiv2 { return; } for (long i = 0; i < pValue()->count(); ++i) { - const auto offset = static_cast(pValue()->toLong(i)); + const auto offset = pValue()->toUint32(i); const byte* pStrip = pData + baseOffset + offset; - const auto size = static_cast(pSize->toLong(i)); + const auto size = pSize->toUint32(i); if ( offset > sizeData || size > sizeData @@ -1038,7 +1041,7 @@ namespace Exiv2 { uint32_t TiffComponent::write(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) @@ -1048,7 +1051,7 @@ namespace Exiv2 { uint32_t TiffDirectory::doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) @@ -1104,7 +1107,7 @@ namespace Exiv2 { valueIdx = sizeDir; // Offset to the current IFD value dataIdx = sizeDir + sizeValue; // Offset to the entry's data area if (isRootDir) { // Absolute offset to the image data - imageIdx = offset + dataIdx + sizeData + sizeNext; + imageIdx = static_cast(offset + dataIdx + sizeData + sizeNext); imageIdx += imageIdx & 1; // Align image data to word boundary } @@ -1129,7 +1132,7 @@ namespace Exiv2 { if (hasNext_) { memset(buf, 0x0, 4); if (pNext_ && sizeNext) { - l2Data(buf, offset + dataIdx, byteOrder); + l2Data(buf, static_cast(offset + dataIdx), byteOrder); } ioWrapper.write(buf, 4); idx += 4; @@ -1174,7 +1177,7 @@ namespace Exiv2 { return idx; } // TiffDirectory::doWrite - uint32_t TiffDirectory::writeDirEntry(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, + uint32_t TiffDirectory::writeDirEntry(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, TiffComponent* pTiffComponent, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) { @@ -1188,7 +1191,7 @@ namespace Exiv2 { ioWrapper.write(buf, 8); if (pDirEntry->size() > 4) { pDirEntry->setOffset(offset + static_cast(valueIdx)); - l2Data(buf, pDirEntry->offset(), byteOrder); + l2Data(buf, static_cast(pDirEntry->offset()), byteOrder); ioWrapper.write(buf, 4); } else { @@ -1214,7 +1217,7 @@ namespace Exiv2 { uint32_t TiffEntryBase::doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t /*offset*/, + int64_t /*offset*/, uint32_t /*valueIdx*/, uint32_t /*dataIdx*/, uint32_t& /*imageIdx*/) @@ -1228,7 +1231,7 @@ namespace Exiv2 { } // TiffEntryBase::doWrite uint32_t TiffEntryBase::writeOffset(byte* buf, - int32_t offset, + int64_t offset, TiffType tiffType, ByteOrder byteOrder) { @@ -1241,7 +1244,7 @@ namespace Exiv2 { break; case ttUnsignedLong: case ttSignedLong: - rc = l2Data(buf, offset, byteOrder); + rc = l2Data(buf, static_cast(offset), byteOrder); break; default: throw Error(kerUnsupportedDataAreaOffsetType); @@ -1252,7 +1255,7 @@ namespace Exiv2 { uint32_t TiffDataEntry::doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t /*valueIdx*/, uint32_t dataIdx, uint32_t& /*imageIdx*/) @@ -1261,10 +1264,10 @@ namespace Exiv2 { DataBuf buf(pValue()->size()); uint32_t idx = 0; - const long prevOffset = pValue()->toLong(0); + const auto prevOffset = pValue()->toInt64(0); for (uint32_t i = 0; i < count(); ++i) { - const long newDataIdx = pValue()->toLong(i) - prevOffset - + static_cast(dataIdx); + const int64_t newDataIdx = pValue()->toInt64(i) - prevOffset + + static_cast(dataIdx); idx += writeOffset(buf.data(idx), offset + newDataIdx, tiffType(), @@ -1276,14 +1279,14 @@ namespace Exiv2 { uint32_t TiffImageEntry::doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t /*valueIdx*/, uint32_t dataIdx, uint32_t& imageIdx) { uint32_t o2 = imageIdx; // For makernotes, write TIFF image data to the data area - if (group() > mnId) o2 = offset + dataIdx; + if (group() > mnId) o2 = static_cast(offset + dataIdx); #ifdef EXIV2_DEBUG_MESSAGES std::cerr << "TiffImageEntry, Directory " << groupName(group()) << ", entry 0x" << std::setw(4) @@ -1308,7 +1311,7 @@ namespace Exiv2 { uint32_t TiffSubIfd::doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t /*valueIdx*/, uint32_t dataIdx, uint32_t& /*imageIdx*/) @@ -1327,7 +1330,7 @@ namespace Exiv2 { uint32_t TiffMnEntry::doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) @@ -1340,12 +1343,12 @@ namespace Exiv2 { uint32_t TiffIfdMakernote::doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t /*valueIdx*/, uint32_t /*dataIdx*/, uint32_t& imageIdx) { - mnOffset_ = offset; + mnOffset_ = static_cast(offset); setImageByteOrder(byteOrder); uint32_t len = writeHeader(ioWrapper, this->byteOrder()); len += ifd_.write(ioWrapper, this->byteOrder(), @@ -1357,7 +1360,7 @@ namespace Exiv2 { uint32_t TiffBinaryArray::doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) @@ -1420,7 +1423,7 @@ namespace Exiv2 { uint32_t TiffBinaryElement::doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t /*offset*/, + int64_t /*offset*/, uint32_t /*valueIdx*/, uint32_t /*dataIdx*/, uint32_t& /*imageIdx*/) @@ -1435,7 +1438,7 @@ namespace Exiv2 { uint32_t TiffComponent::writeData(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const { @@ -1444,7 +1447,7 @@ namespace Exiv2 { uint32_t TiffDirectory::doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const { @@ -1457,7 +1460,7 @@ namespace Exiv2 { uint32_t TiffEntryBase::doWriteData(IoWrapper&/*ioWrapper*/, ByteOrder /*byteOrder*/, - int32_t /*offset*/, + int64_t /*offset*/, uint32_t /*dataIdx*/, uint32_t& /*imageIdx*/) const { @@ -1466,7 +1469,7 @@ namespace Exiv2 { uint32_t TiffImageEntry::doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t /*offset*/, + int64_t /*offset*/, uint32_t /*dataIdx*/, uint32_t& /*imageIdx*/) const { @@ -1480,7 +1483,7 @@ namespace Exiv2 { uint32_t TiffDataEntry::doWriteData(IoWrapper& ioWrapper, ByteOrder /*byteOrder*/, - int32_t /*offset*/, + int64_t /*offset*/, uint32_t /*dataIdx*/, uint32_t& /*imageIdx*/) const { @@ -1497,7 +1500,7 @@ namespace Exiv2 { uint32_t TiffSubIfd::doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const { @@ -1514,7 +1517,7 @@ namespace Exiv2 { uint32_t TiffIfdMakernote::doWriteData(IoWrapper&/*ioWrapper*/, ByteOrder /*byteOrder*/, - int32_t /*offset*/, + int64_t /*offset*/, uint32_t /*dataIdx*/, uint32_t& /*imageIdx*/) const { diff --git a/src/tiffcomposite_int.hpp b/src/tiffcomposite_int.hpp index 59cc6ced..ee2cca75 100644 --- a/src/tiffcomposite_int.hpp +++ b/src/tiffcomposite_int.hpp @@ -149,7 +149,7 @@ namespace Exiv2 { */ int putb(byte data); //! Wrapper for OffsetWriter::setTarget(), using an int instead of the enum to reduce include deps - void setTarget(int id, uint32_t target); + void setTarget(int id, int64_t target); //@} private: @@ -244,7 +244,7 @@ namespace Exiv2 { */ uint32_t write(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx); @@ -271,7 +271,7 @@ namespace Exiv2 { */ uint32_t writeData(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const; /*! @@ -329,7 +329,7 @@ namespace Exiv2 { //! Implements write(). virtual uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) =0; @@ -342,7 +342,7 @@ namespace Exiv2 { //! Implements writeData(). virtual uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, - int32_t offset, + int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const =0; //! Implements writeImage(). @@ -435,7 +435,7 @@ namespace Exiv2 { */ void encode(TiffEncoder& encoder, const Exifdatum* datum); //! Set the offset - void setOffset(int32_t offset) { offset_ = offset; } + void setOffset(int64_t offset) { offset_ = offset; } /*! @brief Set pointer and size of the entry's data (not taking ownership of the data). @@ -451,7 +451,7 @@ namespace Exiv2 { you should pass std::shared_ptr(), which is essentially a nullptr. */ - void setData(byte* pData, int32_t size, const std::shared_ptr& storage); + void setData(byte* pData, uint32_t size, const std::shared_ptr& storage); /*! @brief Set the entry's data buffer. A shared_ptr is used to manage the DataBuf because TiffEntryBase has a clone method so it is possible (in theory) for @@ -480,7 +480,7 @@ namespace Exiv2 { @brief Return the offset to the data area relative to the base for the component (usually the start of the TIFF header) */ - int32_t offset() const { return offset_; } + int64_t offset() const { return offset_; } /*! @brief Return the unique id of the entry in the image */ @@ -514,7 +514,7 @@ namespace Exiv2 { the \em ioWrapper, return the number of bytes written. Only the \em ioWrapper and \em byteOrder arguments are used. */ - uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t valueIdx, uint32_t dataIdx, + uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) override; //@} @@ -526,7 +526,7 @@ namespace Exiv2 { @brief Implements writeData(). Standard TIFF entries have no data: write nothing and return 0. */ - uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t dataIdx, + uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const override; /*! @brief Implements writeImage(). Standard TIFF entries have no image data: @@ -543,7 +543,7 @@ namespace Exiv2 { //! Helper function to write an \em offset to a preallocated binary buffer static uint32_t writeOffset(byte* buf, - int32_t offset, + int64_t offset, TiffType tiffType, ByteOrder byteOrder); @@ -560,7 +560,7 @@ namespace Exiv2 { // DATA TiffType tiffType_; //!< Field TIFF type uint32_t count_; //!< The number of values of the indicated type - int32_t offset_; //!< Offset to the data area + int64_t offset_; //!< Offset to the data area /*! Size of the data buffer holding the value in bytes, there is no minimum size. @@ -708,7 +708,7 @@ namespace Exiv2 { on write. The type of the value can only be signed or unsigned short or long. */ - uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t valueIdx, uint32_t dataIdx, + uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) override; //@} @@ -719,7 +719,7 @@ namespace Exiv2 { @brief Implements writeData(). Write the data area to the \em ioWrapper. Return the number of bytes written. */ - uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t dataIdx, + uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const override; // Using doWriteImage from base class // Using doSize() from base class @@ -774,7 +774,7 @@ namespace Exiv2 { \em ioWrapper. Return the number of bytes written. The \em valueIdx and \em dataIdx arguments are not used. */ - uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t valueIdx, uint32_t dataIdx, + uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) override; //@} @@ -789,7 +789,7 @@ namespace Exiv2 { directory. It is used for TIFF image entries in the makernote (large preview images) so that the image data remains in the makernote IFD. */ - uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t dataIdx, + uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const override; /*! @brief Implements writeImage(). Write the image data area to the \em ioWrapper. @@ -899,7 +899,7 @@ namespace Exiv2 { additional data, including the next-IFD, if any, to the \em ioWrapper, return the number of bytes written. */ - uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t valueIdx, uint32_t dataIdx, + uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) override; //@} @@ -910,7 +910,7 @@ namespace Exiv2 { @brief This class does not really implement writeData(), it only has write(). This method must not be called; it commits suicide. */ - uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t dataIdx, + uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const override; /*! @brief Implements writeImage(). Write the image data of the TIFF @@ -951,7 +951,7 @@ namespace Exiv2 { //! @name Private Accessors //@{ //! Write a binary directory entry for a TIFF component. - static uint32_t writeDirEntry(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, + static uint32_t writeDirEntry(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, TiffComponent* pTiffComponent, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx); //@} @@ -1001,7 +1001,7 @@ namespace Exiv2 { return the number of bytes written. The \em valueIdx and \em imageIdx arguments are not used. */ - uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t valueIdx, uint32_t dataIdx, + uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) override; //@} @@ -1012,7 +1012,7 @@ namespace Exiv2 { @brief Implements writeData(). Write the sub-IFDs to the \em ioWrapper. Return the number of bytes written. */ - uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t dataIdx, + uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const override; /*! @brief Implements writeImage(). Write the image data of each sub-IFD to @@ -1076,7 +1076,7 @@ namespace Exiv2 { @brief Implements write() by forwarding the call to the actual concrete Makernote, if there is one. */ - uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t valueIdx, uint32_t dataIdx, + uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) override; //@} @@ -1202,7 +1202,7 @@ namespace Exiv2 { values and additional data to the \em ioWrapper, return the number of bytes written. */ - uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t valueIdx, uint32_t dataIdx, + uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) override; //@} @@ -1213,7 +1213,7 @@ namespace Exiv2 { @brief This class does not really implement writeData(), it only has write(). This method must not be called; it commits suicide. */ - uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t dataIdx, + uint32_t doWriteData(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t dataIdx, uint32_t& imageIdx) const override; /*! @brief Implements writeImage(). Write the image data of the IFD of @@ -1407,7 +1407,7 @@ namespace Exiv2 { /*! @brief Implements write(). Todo: Document it! */ - uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t valueIdx, uint32_t dataIdx, + uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) override; //@} @@ -1492,7 +1492,7 @@ namespace Exiv2 { /*! @brief Implements write(). Todo: Document it! */ - uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int32_t offset, uint32_t valueIdx, uint32_t dataIdx, + uint32_t doWrite(IoWrapper& ioWrapper, ByteOrder byteOrder, int64_t offset, uint32_t valueIdx, uint32_t dataIdx, uint32_t& imageIdx) override; //@} diff --git a/src/tiffimage_int.cpp b/src/tiffimage_int.cpp index 85c14d08..ae8681a1 100644 --- a/src/tiffimage_int.cpp +++ b/src/tiffimage_int.cpp @@ -2033,7 +2033,7 @@ namespace Exiv2 { pSourceDir->accept(finder); auto te = dynamic_cast(finder.result()); const Value* pV = te != nullptr ? te->pValue() : nullptr; - if (pV && pV->typeId() == unsignedLong && pV->count() == 1 && (pV->toLong() & 1) == 0) { + if (pV && pV->typeId() == unsignedLong && pV->count() == 1 && (pV->toInt64() & 1) == 0) { primaryGroups.push_back(te->group()); } } diff --git a/src/tiffvisitor_int.cpp b/src/tiffvisitor_int.cpp index 54ae7bdd..e9faf6fc 100644 --- a/src/tiffvisitor_int.cpp +++ b/src/tiffvisitor_int.cpp @@ -457,8 +457,8 @@ namespace Exiv2 { std::vector ints; std::vector uint; for (long i = 0; i < object->pValue()->count(); i++) { - ints.push_back(static_cast(object->pValue()->toLong(i))); - uint.push_back(static_cast(object->pValue()->toLong(i))); + ints.push_back(static_cast(object->pValue()->toInt64(i))); + uint.push_back(static_cast(object->pValue()->toInt64(i))); } // Check this is AFInfo2 (ints[0] = bytes in object) if ( ints.at(0) != object->pValue()->count()*2 ) return ; diff --git a/src/types.cpp b/src/types.cpp index f5c08c02..07abd7a9 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -713,30 +713,39 @@ namespace Exiv2 { return false; } - long parseLong(const std::string& s, bool& ok) + int64_t parseInt64(const std::string& s, bool& ok) { - long ret = stringTo(s, ok); + int64_t ret = stringTo(s, ok); if (ok) return ret; auto f = stringTo(s, ok); - if (ok) return static_cast(f); + if (ok) return static_cast(f); Rational r = stringTo(s, ok); if (ok) { - if (r.second == 0) { + if (r.second <= 0) { ok = false; return 0; } - return static_cast(static_cast(r.first) / r.second); + return static_cast(static_cast(r.first) / r.second); } bool b = stringTo(s, ok); if (ok) return b ? 1 : 0; - // everything failed, return from stringTo is probably the best fit + // everything failed, return from stringTo is probably the best fit return ret; } + uint32_t parseUint32(const std::string& s, bool& ok) + { + const int64_t x = parseInt64(s, ok); + if (ok && 0 <= x && x <= std::numeric_limits::max()) { + return static_cast(x); + } + return 0; + } + float parseFloat(const std::string& s, bool& ok) { auto ret = stringTo(s, ok); diff --git a/src/value.cpp b/src/value.cpp index 2f30c045..bfd330f6 100644 --- a/src/value.cpp +++ b/src/value.cpp @@ -218,7 +218,13 @@ namespace Exiv2 { return os.str(); } - long DataValue::toLong(long n) const + int64_t DataValue::toInt64(long n) const + { + ok_ = true; + return value_.at(n); + } + + uint32_t DataValue::toUint32(long n) const { ok_ = true; return value_.at(n); @@ -294,7 +300,13 @@ namespace Exiv2 { return os << value_; } - long StringValueBase::toLong(long n) const + int64_t StringValueBase::toInt64(long n) const + { + ok_ = true; + return value_.at(n); + } + + uint32_t StringValueBase::toUint32(long n) const { ok_ = true; return value_.at(n); @@ -688,9 +700,14 @@ namespace Exiv2 { return os << value_; } - long XmpTextValue::toLong(long /*n*/) const + int64_t XmpTextValue::toInt64(long /*n*/) const + { + return parseInt64(value_, ok_); + } + + uint32_t XmpTextValue::toUint32(long /*n*/) const { - return parseLong(value_, ok_); + return parseUint32(value_, ok_); } float XmpTextValue::toFloat(long /*n*/) const @@ -745,9 +762,14 @@ namespace Exiv2 { return value_.at(n); } - long XmpArrayValue::toLong(long n) const + int64_t XmpArrayValue::toInt64(long n) const + { + return parseInt64(value_.at(n), ok_); + } + + uint32_t XmpArrayValue::toUint32(long n) const { - return parseLong(value_.at(n), ok_); + return parseUint32(value_.at(n), ok_); } float XmpArrayValue::toFloat(long n) const @@ -869,7 +891,13 @@ namespace Exiv2 { return ""; } - long LangAltValue::toLong(long /*n*/) const + int64_t LangAltValue::toInt64(long /*n*/) const + { + ok_ = false; + return 0; + } + + uint32_t LangAltValue::toUint32(long /*n*/) const { ok_ = false; return 0; @@ -984,7 +1012,7 @@ namespace Exiv2 { return os; } - long DateValue::toLong(long /*n*/) const + int64_t DateValue::toInt64(long /*n*/) const { // Range of tm struct is limited to about 1970 to 2038 // This will return -1 if outside that range @@ -993,19 +1021,28 @@ namespace Exiv2 { tms.tm_mday = date_.day; tms.tm_mon = date_.month - 1; tms.tm_year = date_.year - 1900; - long l = static_cast(std::mktime(&tms)); + int64_t l = static_cast(std::mktime(&tms)); ok_ = (l != -1); return l; } + uint32_t DateValue::toUint32(long /*n*/) const + { + const int64_t t = toInt64(); + if (t < 0 || t > std::numeric_limits::max()) { + return 0; + } + return static_cast(t); + } + float DateValue::toFloat(long n) const { - return static_cast(toLong(n)); + return static_cast(toInt64(n)); } Rational DateValue::toRational(long n) const { - return {toLong(n), 1}; + return {static_cast(toInt64(n)), 1}; } TimeValue::TimeValue() @@ -1136,10 +1173,10 @@ namespace Exiv2 { return os; } - long TimeValue::toLong(long /*n*/) const + int64_t TimeValue::toInt64(long /*n*/) const { // Returns number of seconds in the day in UTC. - long result = (time_.hour - time_.tzHour) * 60 * 60; + int64_t result = (time_.hour - time_.tzHour) * 60 * 60; result += (time_.minute - time_.tzMinute) * 60; result += time_.second; if (result < 0) { @@ -1149,14 +1186,23 @@ namespace Exiv2 { return result; } + uint32_t TimeValue::toUint32(long /*n*/) const + { + const int64_t t = toInt64(); + if (t < 0 || t > std::numeric_limits::max()) { + return 0; + } + return static_cast(t); + } + float TimeValue::toFloat(long n) const { - return static_cast(toLong(n)); + return static_cast(toInt64(n)); } Rational TimeValue::toRational(long n) const { - return {toLong(n), 1}; + return {static_cast(toInt64(n)), 1}; } } // namespace Exiv2 diff --git a/src/xmp.cpp b/src/xmp.cpp index ce71364d..2fe61d7a 100644 --- a/src/xmp.cpp +++ b/src/xmp.cpp @@ -405,7 +405,7 @@ namespace Exiv2 { long Xmpdatum::toLong(long n) const { - return p_->value_.get() == nullptr ? -1 : p_->value_->toLong(n); + return p_->value_.get() == nullptr ? -1 : static_cast(p_->value_->toInt64(n)); } float Xmpdatum::toFloat(long n) const