third_party/exiv2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove useless static_casts

Browse Source
This commit is contained in:
Luis Díaz Más 2022-03-22 18:54:41 +01:00 committed by Luis Diaz
parent ae4df71233
commit d7f35e33f0
18 changed files with 82 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/exiv2.cpp
View File

@ -937,10 +937,10 @@ int Params::nonoption(const std::string& argv) {
return rc;
} // Params::nonoption
static int readFileToBuf(FILE* f, Exiv2::DataBuf& buf) {
static size_t readFileToBuf(FILE* f, Exiv2::DataBuf& buf) {
const int buff_size = 4 * 1028;
std::vector<Exiv2::byte> bytes(buff_size);
int nBytes = 0;
size_t nBytes = 0;
bool more{true};
std::array<char, buff_size> buff;
while (more) {

2
include/exiv2/webpimage.hpp
View File

@ -64,7 +64,7 @@ class EXIV2API WebPImage : public Image {
void doWriteMetadata(BasicIo& outIo);
//! @name NOT Implemented
//@{
static long getHeaderOffset(const byte* data, long data_size, const byte* header, long header_size);
static long getHeaderOffset(const byte* data, size_t data_size, const byte* header, size_t header_size);
static bool equalsWebPTag(Exiv2::DataBuf& buf, const char* str);
void debugPrintHex(byte* data, long size);
void decodeChunks(long filesize);

2
src/basicio.cpp
View File

@ -728,7 +728,7 @@ void MemIo::transfer(BasicIo& src) {
}
size_t MemIo::write(BasicIo& src) {
if (static_cast<BasicIo*>(this) == &src)
if (this == &src)
return 0;
if (!src.isopen())
return 0;

16
src/bmffimage.cpp
View File

@ -506,7 +506,7 @@ void BmffImage::parseTiff(uint32_t root_tag, uint64_t length) {
if (length > 8) {
enforce(length - 8 <= io_->size() - io_->tell(), ErrorCode::kerCorruptedMetadata);
enforce(length - 8 <= std::numeric_limits<uint64_t>::max(), ErrorCode::kerCorruptedMetadata);
DataBuf data(static_cast<size_t>(length) - 8);
DataBuf data(static_cast<size_t>(length - 8u));
const size_t bufRead = io_->read(data.data(), data.size());
if (io_->error())
@ -514,8 +514,7 @@ void BmffImage::parseTiff(uint32_t root_tag, uint64_t length) {
if (bufRead != data.size())
throw Error(ErrorCode::kerInputDataReadFailed);
Internal::TiffParserWorker::decode(exifData(), iptcData(), xmpData(), data.c_data(),
static_cast<uint32_t>(data.size()), root_tag,
Internal::TiffParserWorker::decode(exifData(), iptcData(), xmpData(), data.c_data(), data.size(), root_tag,
Internal::TiffMapping::findDecoder);
}
}
@ -526,13 +525,12 @@ void BmffImage::parseXmp(uint64_t length, uint64_t start) {
enforce(length <= io_->size() - start, ErrorCode::kerCorruptedMetadata);
long restore = io_->tell();
enforce(start <= std::numeric_limits<uint64_t>::max(), ErrorCode::kerCorruptedMetadata);
io_->seek(static_cast<long>(start), BasicIo::beg);
enforce(length < std::numeric_limits<uint64_t>::max(), ErrorCode::kerCorruptedMetadata);
DataBuf xmp(static_cast<size_t>(length + 1));
xmp.write_uint8(static_cast<size_t>(length), 0); // ensure xmp is null terminated!
if (io_->read(xmp.data(), static_cast<size_t>(length)) != length)
size_t lengthSizeT = static_cast<size_t>(length);
DataBuf xmp(lengthSizeT + 1);
xmp.write_uint8(lengthSizeT, 0); // ensure xmp is null terminated!
if (io_->read(xmp.data(), lengthSizeT) != lengthSizeT)
throw Error(ErrorCode::kerInputDataReadFailed);
if (io_->error())
throw Error(ErrorCode::kerFailedToReadImageData);
@ -554,7 +552,7 @@ void BmffImage::parseCr3Preview(DataBuf& data, std::ostream& out, bool bTrace, u
enforce(here >= 0 && here <= std::numeric_limits<long>::max() - static_cast<long>(relative_position),
ErrorCode::kerCorruptedMetadata);
NativePreview nativePreview;
nativePreview.position_ = here + static_cast<long>(relative_position);
nativePreview.position_ = here + relative_position;
nativePreview.width_ = data.read_uint16(width_offset, endian_);
nativePreview.height_ = data.read_uint16(height_offset, endian_);
nativePreview.size_ = data.read_uint32(size_offset, endian_);

2
src/crwimage_int.cpp
View File

@ -244,7 +244,7 @@ void CiffDirectory::readDirectory(const byte* pData, size_t size, ByteOrder byte
std::cout << "Directory at offset " << std::dec << o << ", " << count << " entries \n";
#endif
o += 2;
if (static_cast<uint32_t>(count) * 10 > size - o)
if (count * 10u > size - o)
throw Error(ErrorCode::kerCorruptedMetadata);
for (uint16_t i = 0; i < count; ++i) {

2
src/image.cpp
View File

@ -602,7 +602,7 @@ void Image::setComment(std::string_view comment) {
void Image::setIccProfile(Exiv2::DataBuf&& iccProfile, bool bTestValid) {
if (bTestValid) {
if (iccProfile.size() < static_cast<long>(sizeof(long))) {
if (iccProfile.size() < sizeof(long)) {
throw Error(ErrorCode::kerInvalidIccProfile);
}
const size_t size = iccProfile.read_uint32(0, bigEndian);

2
src/mrwimage.cpp
View File

@ -106,7 +106,7 @@ void MrwImage::readMetadata() {
io_->read(buf.data(), buf.size());
enforce(!io_->error() && !io_->eof(), ErrorCode::kerFailedToReadImageData);
ByteOrder bo = TiffParser::decode(exifData_, iptcData_, xmpData_, buf.c_data(), static_cast<uint32_t>(buf.size()));
ByteOrder bo = TiffParser::decode(exifData_, iptcData_, xmpData_, buf.c_data(), buf.size());
setByteOrder(bo);
} // MrwImage::readMetadata

4
src/pgfimage.cpp
View File

@ -90,13 +90,13 @@ void PgfImage::readMetadata() {
// And now, the most interesting, the user data byte array where metadata are stored as small image.
enforce(headerSize <= std::numeric_limits<size_t>::max() - 8, ErrorCode::kerCorruptedMetadata);
long size = static_cast<long>(headerSize) + 8 - io_->tell();
size_t size = headerSize + 8 - static_cast<size_t>(io_->tell());
#ifdef EXIV2_DEBUG_MESSAGES
std::cout << "Exiv2::PgfImage::readMetadata: Found Image data (" << size << " bytes)\n";
#endif
if (size < 0 || static_cast<size_t>(size) > io_->size())
if (size > io_->size())
throw Error(ErrorCode::kerInputDataReadFailed);
if (size == 0)
return;

34
src/preview.cpp
View File

@ -31,7 +31,7 @@ bool cmpPreviewProperties(const PreviewProperties &lhs, const PreviewProperties
}
/// @brief Decode a Hex string.
DataBuf decodeHex(const byte *src, long srcSize);
DataBuf decodeHex(const byte *src, size_t srcSize);
/// @brief Decode a Base64 string.
DataBuf decodeBase64(const std::string &src);
@ -409,12 +409,12 @@ DataBuf LoaderNative::getData() const {
return {data + nativePreview_.position_, nativePreview_.size_};
}
if (nativePreview_.filter_ == "hex-ai7thumbnail-pnm") {
const DataBuf ai7thumbnail = decodeHex(data + nativePreview_.position_, static_cast<long>(nativePreview_.size_));
const DataBuf ai7thumbnail = decodeHex(data + nativePreview_.position_, nativePreview_.size_);
const DataBuf rgb = decodeAi7Thumbnail(ai7thumbnail);
return makePnm(width_, height_, rgb);
}
if (nativePreview_.filter_ == "hex-irb") {
const DataBuf psData = decodeHex(data + nativePreview_.position_, static_cast<long>(nativePreview_.size_));
const DataBuf psData = decodeHex(data + nativePreview_.position_, nativePreview_.size_);
const byte *record;
uint32_t sizeHdr = 0;
uint32_t sizeData = 0;
@ -479,7 +479,7 @@ LoaderExifJpeg::LoaderExifJpeg(PreviewId id, const Image &image, int parIdx) : L
}
}
if (Safe::add(offset_, size_) > static_cast<uint32_t>(image_.io().size()))
if (Safe::add(offset_, size_) > image_.io().size())
return;
valid_ = true;
@ -648,7 +648,7 @@ LoaderTiff::LoaderTiff(PreviewId id, const Image &image, int parIdx) :
if (offsetCount != pos->value().count())
return;
for (size_t i = 0; i < offsetCount; i++) {
size_ += pos->toUint32(static_cast<long>(i));
size_ += pos->toUint32(i);
}
if (size_ == 0)
@ -727,7 +727,7 @@ DataBuf LoaderTiff::getData() const {
dataValue.setDataArea(base + offset, size);
} else {
// FIXME: the buffer is probably copied twice, it should be optimized
enforce(size_ <= static_cast<uint32_t>(io.size()), ErrorCode::kerCorruptedMetadata);
enforce(size_ <= io.size(), ErrorCode::kerCorruptedMetadata);
DataBuf buf(size_);
uint32_t idxBuf = 0;
for (size_t i = 0; i < sizes.count(); i++) {
@ -792,7 +792,7 @@ LoaderXmpJpeg::LoaderXmpJpeg(PreviewId id, const Image &image, int parIdx) : Loa
width_ = widthDatum->toUint32();
height_ = heightDatum->toUint32();
preview_ = decodeBase64(imageDatum->toString());
size_ = static_cast<uint32_t>(preview_.size());
size_ = preview_.size();
valid_ = true;
}
@ -817,7 +817,7 @@ bool LoaderXmpJpeg::readDimensions() {
return valid();
}
DataBuf decodeHex(const byte *src, long srcSize) {
DataBuf decodeHex(const byte *src, size_t srcSize) {
// create decoding table
byte invalid = 16;
std::array<byte, 256> decodeHexTable;
@ -831,17 +831,17 @@ DataBuf decodeHex(const byte *src, long srcSize) {
// calculate dest size
long validSrcSize = 0;
for (long srcPos = 0; srcPos < srcSize; srcPos++) {
for (size_t srcPos = 0; srcPos < srcSize; srcPos++) {
if (decodeHexTable[src[srcPos]] != invalid)
validSrcSize++;
}
const long destSize = validSrcSize / 2;
const size_t destSize = validSrcSize / 2;
// allocate dest buffer
DataBuf dest(destSize);
// decode
for (long srcPos = 0, destPos = 0; destPos < destSize; destPos++) {
for (size_t srcPos = 0, destPos = 0; destPos < destSize; destPos++) {
byte buffer = 0;
for (int bufferPos = 1; bufferPos >= 0 && srcPos < srcSize; srcPos++) {
byte srcValue = decodeHexTable[src[srcPos]];
@ -880,7 +880,7 @@ DataBuf decodeBase64(const std::string &src) {
// allocate dest buffer
if (destSize > LONG_MAX)
return {}; // avoid integer overflow
DataBuf dest(static_cast<long>(destSize));
DataBuf dest(destSize);
// decode
for (unsigned long srcPos = 0, destPos = 0; destPos < destSize;) {
@ -901,7 +901,7 @@ DataBuf decodeBase64(const std::string &src) {
DataBuf decodeAi7Thumbnail(const DataBuf &src) {
const byte *colorTable = src.c_data();
const long colorTableSize = 256 * 3;
const size_t colorTableSize = 256 * 3;
if (src.size() < colorTableSize) {
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Invalid size of AI7 thumbnail: " << src.size() << "\n";
@ -909,10 +909,10 @@ DataBuf decodeAi7Thumbnail(const DataBuf &src) {
return {};
}
const byte *imageData = src.c_data(colorTableSize);
const long imageDataSize = static_cast<long>(src.size()) - colorTableSize;
const size_t imageDataSize = src.size() - colorTableSize;
const bool rle = (imageDataSize >= 3 && imageData[0] == 'R' && imageData[1] == 'L' && imageData[2] == 'E');
std::string dest;
for (long i = rle ? 3 : 0; i < imageDataSize;) {
for (size_t i = rle ? 3 : 0; i < imageDataSize;) {
byte num = 1;
byte value = imageData[i++];
if (rle && value == 0xFD) {
@ -1029,8 +1029,8 @@ PreviewPropertiesList PreviewManager::getPreviewProperties() const {
auto loader = Loader::create(id, image_);
if (loader && loader->readDimensions()) {
PreviewProperties props = loader->getProperties();
DataBuf buf = loader->getData(); // #16 getPreviewImage()
props.size_ = static_cast<uint32_t>(buf.size()); // update the size
DataBuf buf = loader->getData(); // #16 getPreviewImage()
props.size_ = buf.size(); // update the size
list.push_back(props);
}
}

5
src/psdimage.cpp
View File

@ -217,7 +217,7 @@ void PsdImage::readResourceBlock(uint16_t resourceId, uint32_t resourceSize) {
io_->read(rawIPTC.data(), rawIPTC.size());
if (io_->error() || io_->eof())
throw Error(ErrorCode::kerFailedToReadImageData);
if (IptcParser::decode(iptcData_, rawIPTC.c_data(), static_cast<uint32_t>(rawIPTC.size()))) {
if (IptcParser::decode(iptcData_, rawIPTC.c_data(), rawIPTC.size())) {
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Failed to decode IPTC metadata.\n";
#endif
@ -484,8 +484,7 @@ void PsdImage::doWriteMetadata(BasicIo& outIo) {
readTotal = 0;
while (readTotal < pResourceSize) {
/// \todo almost same code as in lines 403-410. Factor out & reuse!
size_t toRead = (pResourceSize - readTotal) < lbuf.size() ? static_cast<long>(pResourceSize - readTotal)
: static_cast<long>(lbuf.size());
size_t toRead = (pResourceSize - readTotal) < lbuf.size() ? pResourceSize - readTotal : lbuf.size();
if (io_->read(lbuf.data(), toRead) != toRead) {
throw Error(ErrorCode::kerNotAnImage, "Photoshop");
}

4
src/tiffcomposite_int.cpp
View File

@ -217,7 +217,7 @@ void TiffEntryBase::setData(const std::shared_ptr<DataBuf>& buf) {
size_ = buf->size();
}
void TiffEntryBase::setData(byte* pData, uint32_t size, const std::shared_ptr<DataBuf>& storage) {
void TiffEntryBase::setData(byte* pData, size_t size, const std::shared_ptr<DataBuf>& storage) {
pData_ = pData;
size_ = size;
storage_ = storage;
@ -352,7 +352,7 @@ uint32_t TiffIfdMakernote::baseOffset() const {
return pHeader_->baseOffset(mnOffset_);
}
bool TiffIfdMakernote::readHeader(const byte* pData, uint32_t size, ByteOrder byteOrder) {
bool TiffIfdMakernote::readHeader(const byte* pData, size_t size, ByteOrder byteOrder) {
if (!pHeader_)
return true;
return pHeader_->read(pData, size, byteOrder);

4
src/tiffcomposite_int.hpp
View File

@ -422,7 +422,7 @@ class TiffEntryBase : public TiffComponent {
you should pass std::shared_ptr<DataBuf>(), which is essentially
a nullptr.
*/
void setData(byte* pData, uint32_t size, const std::shared_ptr<DataBuf>& storage);
void setData(byte* pData, size_t size, const std::shared_ptr<DataBuf>& 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
@ -1113,7 +1113,7 @@ class TiffIfdMakernote : public TiffComponent {
The default implementation simply returns true.
*/
bool readHeader(const byte* pData, uint32_t size, ByteOrder byteOrder);
bool readHeader(const byte* pData, size_t size, ByteOrder byteOrder);
/*!
@brief Set the byte order for the makernote.
*/

3
src/tiffimage.cpp
View File

@ -220,8 +220,7 @@ ByteOrder TiffParser::decode(ExifData& exifData, IptcData& iptcData, XmpData& xm
}
}
return TiffParserWorker::decode(exifData, iptcData, xmpData, pData, static_cast<uint32_t>(size), root,
TiffMapping::findDecoder);
return TiffParserWorker::decode(exifData, iptcData, xmpData, pData, size, root, TiffMapping::findDecoder);
} // TiffParser::decode
WriteMethod TiffParser::encode(BasicIo& io, const byte* pData, size_t size, ByteOrder byteOrder,

24
src/tiffvisitor_int.cpp
View File

@ -310,7 +310,7 @@ void TiffDecoder::decodeIptc(const TiffEntryBase* object) {
size_t size = 0;
getObjData(pData, size, 0x83bb, ifd0Id, object);
if (pData) {
if (0 == IptcParser::decode(iptcData_, pData, static_cast<uint32_t>(size))) {
if (0 == IptcParser::decode(iptcData_, pData, size)) {
return;
}
#ifndef SUPPRESS_WARNINGS
@ -516,7 +516,7 @@ void TiffEncoder::encodeIptc() {
} else {
buf = std::move(rawIptc); // Note: This resets rawIptc
}
value->read(buf.data(), static_cast<long>(buf.size()), byteOrder_);
value->read(buf.data(), buf.size(), byteOrder_);
Exifdatum iptcDatum(iptcNaaKey, value.get());
exifData_.add(iptcDatum);
pos = exifData_.findKey(irbKey); // needed after add()
@ -530,7 +530,7 @@ void TiffEncoder::encodeIptc() {
exifData_.erase(pos);
if (!irbBuf.empty()) {
auto value = Value::create(unsignedByte);
value->read(irbBuf.data(), static_cast<long>(irbBuf.size()), invalidByteOrder);
value->read(irbBuf.data(), irbBuf.size(), invalidByteOrder);
Exifdatum iptcDatum(irbKey, value.get());
exifData_.add(iptcDatum);
}
@ -559,7 +559,7 @@ void TiffEncoder::encodeXmp() {
if (!xmpPacket.empty()) {
// Set the XMP Exif tag to the new value
auto value = Value::create(unsignedByte);
value->read(reinterpret_cast<const byte*>(&xmpPacket[0]), static_cast<long>(xmpPacket.size()), invalidByteOrder);
value->read(reinterpret_cast<const byte*>(&xmpPacket[0]), xmpPacket.size(), invalidByteOrder);
Exifdatum xmpDatum(xmpKey, value.get());
exifData_.add(xmpDatum);
}
@ -697,7 +697,7 @@ void TiffEncoder::visitBinaryArrayEnd(TiffBinaryArray* object) {
DataBuf buf = cryptFct(object->tag(), pData, size, pRoot_);
if (!buf.empty()) {
pData = buf.c_data();
size = static_cast<int32_t>(buf.size());
size = buf.size();
}
if (!object->updOrigDataBuf(pData, size)) {
setDirty();
@ -837,7 +837,7 @@ void TiffEncoder::encodeImageEntry(TiffImageEntry* object, const Exifdatum* datu
uint32_t sizeTotal = 0;
object->strips_.clear();
for (size_t i = 0; i < pos->count(); ++i) {
uint32_t len = pos->toUint32(static_cast<long>(i));
uint32_t len = pos->toUint32(i);
object->strips_.emplace_back(zero, len);
sizeTotal += len;
}
@ -1225,12 +1225,12 @@ void TiffReader::visitMnEntry(TiffMnEntry* object) {
void TiffReader::visitIfdMakernote(TiffIfdMakernote* object) {
object->setImageByteOrder(byteOrder()); // set the byte order for the image
if (!object->readHeader(object->start(), static_cast<uint32_t>(pLast_ - object->start()), byteOrder())) {
if (!object->readHeader(object->start(), pLast_ - object->start(), byteOrder())) {
#ifndef SUPPRESS_WARNINGS
EXV_ERROR << "Failed to read " << groupName(object->ifd_.group()) << " IFD Makernote header.\n";
#ifdef EXIV2_DEBUG_MESSAGES
if (static_cast<uint32_t>(pLast_ - object->start()) >= 16) {
hexdump(std::cerr, object->start(), 16);
if (pLast_ - object->start() >= 16u) {
hexdump(std::cerr, object->start(), 16u);
}
#endif // EXIV2_DEBUG_MESSAGES
#endif // SUPPRESS_WARNINGS
@ -1291,10 +1291,10 @@ void TiffReader::readTiffEntry(TiffEntryBase* object) {
if (count > std::numeric_limits<uint32_t>::max() / typeSize) {
throw Error(ErrorCode::kerArithmeticOverflow);
}
auto size = static_cast<uint32_t>(typeSize * count);
size_t size = typeSize * count;
uint32_t offset = getLong(p, byteOrder());
byte* pData = p;
if (size > 4 && (baseOffset() + offset >= size_ || static_cast<int32_t>(baseOffset()) + offset <= 0)) {
if (size > 4 && (baseOffset() + offset >= size_ || baseOffset() + offset <= 0)) {
// #1143
if (object->tag() == 0x2001 && std::string(groupName(object->group())) == "Sony1") {
// This tag is Exif.Sony1.PreviewImage, which refers to a preview image which is
@ -1335,7 +1335,7 @@ void TiffReader::readTiffEntry(TiffEntryBase* object) {
pData = const_cast<byte*>(pData_) + baseOffset() + offset;
// check for size being invalid
if (size > static_cast<uint32_t>(pLast_ - pData)) {
if (size > static_cast<size_t>(pLast_ - pData)) {
#ifndef SUPPRESS_WARNINGS
EXV_ERROR << "Upper boundary of data for "
<< "directory " << groupName(object->group()) << ", entry 0x" << std::setw(4) << std::setfill('0')

4
src/value.cpp
View File

@ -155,8 +155,8 @@ DataValue* DataValue::clone_() const {
}
std::ostream& DataValue::write(std::ostream& os) const {
std::vector<byte>::size_type end = value_.size();
for (std::vector<byte>::size_type i = 0; i != end; ++i) {
size_t end = value_.size();
for (size_t i = 0; i != end; ++i) {
os << static_cast<int>(value_.at(i));
if (i < end - 1)
os << " ";

46
src/webpimage.cpp
View File

@ -184,10 +184,8 @@ void WebPImage::doWriteMetadata(BasicIo& outIo) {
const uint32_t size_u32 = Exiv2::getULong(size_buff, littleEndian);
// Check that `size_u32` is safe to cast to `long`.
enforce(size_u32 <= static_cast<size_t>(std::numeric_limits<unsigned int>::max()),
Exiv2::ErrorCode::kerCorruptedMetadata);
const auto size = static_cast<long>(size_u32);
DataBuf payload(size);
enforce(size_u32 <= std::numeric_limits<uint32_t>::max(), Exiv2::ErrorCode::kerCorruptedMetadata);
DataBuf payload(size_u32);
io_->readOrThrow(payload.data(), payload.size(), Exiv2::ErrorCode::kerCorruptedMetadata);
if (payload.size() % 2) {
byte c = 0;
@ -200,7 +198,7 @@ void WebPImage::doWriteMetadata(BasicIo& outIo) {
has_vp8x = true;
}
if (equalsWebPTag(chunkId, WEBP_CHUNK_HEADER_VP8X) && !has_size) {
enforce(size >= 10, Exiv2::ErrorCode::kerCorruptedMetadata);
enforce(size_u32 >= 10, Exiv2::ErrorCode::kerCorruptedMetadata);
has_size = true;
byte size_buf[WEBP_TAG_SIZE];
@ -229,7 +227,7 @@ void WebPImage::doWriteMetadata(BasicIo& outIo) {
}
#endif
if (equalsWebPTag(chunkId, WEBP_CHUNK_HEADER_VP8) && !has_size) {
enforce(size >= 10, Exiv2::ErrorCode::kerCorruptedMetadata);
enforce(size_u32 >= 10, Exiv2::ErrorCode::kerCorruptedMetadata);
has_size = true;
byte size_buf[2];
@ -247,13 +245,13 @@ void WebPImage::doWriteMetadata(BasicIo& outIo) {
/* Chunk with lossless image data. */
if (equalsWebPTag(chunkId, WEBP_CHUNK_HEADER_VP8L) && !has_alpha) {
enforce(size >= 5, Exiv2::ErrorCode::kerCorruptedMetadata);
enforce(size_u32 >= 5, Exiv2::ErrorCode::kerCorruptedMetadata);
if ((payload.read_uint8(4) & WEBP_VP8X_ALPHA_BIT) == WEBP_VP8X_ALPHA_BIT) {
has_alpha = true;
}
}
if (equalsWebPTag(chunkId, WEBP_CHUNK_HEADER_VP8L) && !has_size) {
enforce(size >= 5, Exiv2::ErrorCode::kerCorruptedMetadata);
enforce(size_u32 >= 5, Exiv2::ErrorCode::kerCorruptedMetadata);
has_size = true;
byte size_buf_w[2];
byte size_buf_h[3];
@ -277,13 +275,13 @@ void WebPImage::doWriteMetadata(BasicIo& outIo) {
/* Chunk with animation frame. */
if (equalsWebPTag(chunkId, WEBP_CHUNK_HEADER_ANMF) && !has_alpha) {
enforce(size >= 6, Exiv2::ErrorCode::kerCorruptedMetadata);
enforce(size_u32 >= 6, Exiv2::ErrorCode::kerCorruptedMetadata);
if ((payload.read_uint8(5) & 0x2) == 0x2) {
has_alpha = true;
}
}
if (equalsWebPTag(chunkId, WEBP_CHUNK_HEADER_ANMF) && !has_size) {
enforce(size >= 12, Exiv2::ErrorCode::kerCorruptedMetadata);
enforce(size_u32 >= 12, Exiv2::ErrorCode::kerCorruptedMetadata);
has_size = true;
byte size_buf[WEBP_TAG_SIZE];
@ -317,17 +315,15 @@ void WebPImage::doWriteMetadata(BasicIo& outIo) {
const uint32_t size_u32 = Exiv2::getULong(size_buff, littleEndian);
// Check that `size_u32` is safe to cast to `long`.
enforce(size_u32 <= static_cast<size_t>(std::numeric_limits<unsigned int>::max()),
Exiv2::ErrorCode::kerCorruptedMetadata);
const auto size = static_cast<long>(size_u32);
enforce(size_u32 <= std::numeric_limits<uint32_t>::max(), Exiv2::ErrorCode::kerCorruptedMetadata);
DataBuf payload(size);
io_->readOrThrow(payload.data(), size, Exiv2::ErrorCode::kerCorruptedMetadata);
DataBuf payload(size_u32);
io_->readOrThrow(payload.data(), size_u32, Exiv2::ErrorCode::kerCorruptedMetadata);
if (io_->tell() % 2)
io_->seek(+1, BasicIo::cur); // skip pad
if (equalsWebPTag(chunkId, WEBP_CHUNK_HEADER_VP8X)) {
enforce(size >= 1, Exiv2::ErrorCode::kerCorruptedMetadata);
enforce(size_u32 >= 1, Exiv2::ErrorCode::kerCorruptedMetadata);
if (has_icc) {
const uint8_t x = payload.read_uint8(0);
payload.write_uint8(0, x | WEBP_VP8X_ICC_BIT);
@ -643,26 +639,22 @@ void WebPImage::decodeChunks(long filesize) {
bool s_header = false;
bool le_header = false;
bool be_header = false;
long pos = getHeaderOffset(payload.c_data(), static_cast<long>(payload.size()),
reinterpret_cast<byte*>(&exifLongHeader), 4);
long pos = getHeaderOffset(payload.c_data(), payload.size(), reinterpret_cast<byte*>(&exifLongHeader), 4);
if (pos == -1) {
pos = getHeaderOffset(payload.c_data(), static_cast<long>(payload.size()),
reinterpret_cast<byte*>(&exifLongHeader), 6);
pos = getHeaderOffset(payload.c_data(), payload.size(), reinterpret_cast<byte*>(&exifLongHeader), 6);
if (pos != -1) {
s_header = true;
}
}
if (pos == -1) {
pos = getHeaderOffset(payload.c_data(), static_cast<long>(payload.size()),
reinterpret_cast<byte*>(&exifTiffLEHeader), 3);
pos = getHeaderOffset(payload.c_data(), payload.size(), reinterpret_cast<byte*>(&exifTiffLEHeader), 3);
if (pos != -1) {
le_header = true;
}
}
if (pos == -1) {
pos = getHeaderOffset(payload.c_data(), static_cast<long>(payload.size()),
reinterpret_cast<byte*>(&exifTiffBEHeader), 4);
pos = getHeaderOffset(payload.c_data(), payload.size(), reinterpret_cast<byte*>(&exifTiffBEHeader), 4);
if (pos != -1) {
be_header = true;
}
@ -835,14 +827,14 @@ void WebPImage::inject_VP8X(BasicIo& iIo, bool has_xmp, bool has_exif, bool has_
}
}
long WebPImage::getHeaderOffset(const byte* data, long data_size, const byte* header, long header_size) {
long WebPImage::getHeaderOffset(const byte* data, size_t data_size, const byte* header, size_t header_size) {
if (data_size < header_size) {
return -1;
}
long pos = -1;
for (long i = 0; i < data_size - header_size; i++) {
for (size_t i = 0; i < data_size - header_size; i++) {
if (memcmp(header, &data[i], header_size) == 0) {
pos = i;
pos = static_cast<long>(i);
break;
}
}

12
unitTests/test_bmpimage.cpp
View File

@ -85,7 +85,7 @@ TEST(BmpImage, readMetadataReadsImageDimensionsWhenDataIsAvailable) {
0x20, 0x03, 0x00, 0x00, // The bitmap height in pixels (unsigned 16 bit) off:22, size:4
};
auto memIo = std::make_unique<MemIo>(header.data(), static_cast<long>(header.size()));
auto memIo = std::make_unique<MemIo>(header.data(), header.size());
BmpImage bmp(std::move(memIo));
ASSERT_NO_THROW(bmp.readMetadata());
ASSERT_EQ(1280, bmp.pixelWidth());
@ -104,7 +104,7 @@ TEST(BmpImage, readMetadataThrowsWhenImageIsNotBMP) {
0x20, 0x03, 0x00, 0x00, // The bitmap height in pixels (unsigned 16 bit) off:22, size:4
};
auto memIo = std::make_unique<MemIo>(header.data(), static_cast<long>(header.size()));
auto memIo = std::make_unique<MemIo>(header.data(), header.size());
BmpImage bmp(std::move(memIo));
try {
bmp.readMetadata();
@ -117,7 +117,7 @@ TEST(BmpImage, readMetadataThrowsWhenImageIsNotBMP) {
TEST(BmpImage, readMetadataThrowsWhenThereIsNotEnoughInfoToRead) {
const std::array<unsigned char, 1> header{'B'};
auto memIo = std::make_unique<MemIo>(header.data(), static_cast<long>(header.size()));
auto memIo = std::make_unique<MemIo>(header.data(), header.size());
BmpImage bmp(std::move(memIo));
try {
bmp.readMetadata();
@ -147,7 +147,7 @@ TEST(newBmpInstance, createsValidInstace) {
0x00, 0x00, // Reserved
0x00, 0x00, 0x00, 0x00 // Offset of the byte where the bitmap image data can be found
};
auto memIo = std::make_unique<MemIo>(bitmapHeader.data(), static_cast<long>(bitmapHeader.size()));
auto memIo = std::make_unique<MemIo>(bitmapHeader.data(), bitmapHeader.size());
auto img = newBmpInstance(std::move(memIo), false);
ASSERT_TRUE(img->good());
}
@ -166,7 +166,7 @@ TEST(isBmpType, withValidSignatureReturnsTrue) {
0x00, 0x00, // Reserved
0x00, 0x00, 0x00, 0x00 // Offset of the byte where the bitmap image data can be found
};
MemIo memIo(bitmapHeader.data(), static_cast<long>(bitmapHeader.size()));
MemIo memIo(bitmapHeader.data(), bitmapHeader.size());
ASSERT_TRUE(isBmpType(memIo, false));
}
@ -178,6 +178,6 @@ TEST(isBmpType, withInvalidSignatureReturnsFalse) {
0x00, 0x00, // Reserved
0x00, 0x00, 0x00, 0x00 // Offset of the byte where the bitmap image data can be found
};
MemIo memIo(bitmapHeader.data(), static_cast<long>(bitmapHeader.size()));
MemIo memIo(bitmapHeader.data(), bitmapHeader.size());
ASSERT_FALSE(isBmpType(memIo, false));
}

6
unitTests/test_pngimage.cpp
View File

@ -18,7 +18,7 @@ TEST(PngChunk, keyTxtChunkExtractsKeywordCorrectlyInPresenceOfNullChar) {
0x20, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x79,
0x70, 0x65, 0x20, 0x65, 0x78, 0x69, 0x66, 0x00, 0x00, 0x78};
DataBuf chunkBuf(data.data(), static_cast<long>(data.size()));
DataBuf chunkBuf(data.data(), data.size());
DataBuf key = Internal::PngChunk::keyTXTChunk(chunkBuf, true);
ASSERT_EQ(21, key.size());
@ -31,13 +31,13 @@ TEST(PngChunk, keyTxtChunkThrowsExceptionWhenThereIsNoNullChar) {
0x77, 0x20, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20,
0x74, 0x79, 0x70, 0x65, 0x20, 0x65, 0x78, 0x69, 0x66, 0x78};
DataBuf chunkBuf(data.data(), static_cast<long>(data.size()));
DataBuf chunkBuf(data.data(), data.size());
ASSERT_THROW(Internal::PngChunk::keyTXTChunk(chunkBuf, true), Exiv2::Error);
}
TEST(PngChunk, keyTxtChunkThrowsIfSizeIsNotEnough) {
const std::array<std::uint8_t, 4> data{0x00, 0x00, 0x22, 0x41};
DataBuf chunkBuf(data.data(), static_cast<long>(data.size()));
DataBuf chunkBuf(data.data(), data.size());
ASSERT_THROW(Internal::PngChunk::keyTXTChunk(chunkBuf, true), Exiv2::Error);
DataBuf emptyChunk(data.data(), 0);