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

Remove DataBuf::copyBytes and use std::copy instead

Browse Source
This commit is contained in:
Luis Díaz Más 2022-03-22 18:07:25 +01:00
parent c5c315b6e7
commit ae4df71233
19 changed files with 98 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
app/actions.cpp
View File

@ -171,12 +171,12 @@ int setModeAndPrintStructure(Exiv2::PrintStructureOption option, const std::stri
std::stringstream output(std::stringstream::out | std::stringstream::binary);
result = printStructure(output, option, path);
if (result == 0) {
size_t size = output.str().size();
Exiv2::DataBuf iccProfile(size);
Exiv2::DataBuf ascii(size * 3 + 1);
ascii.write_uint8(size * 3, 0);
iccProfile.copyBytes(0, output.str().c_str(), size);
if (Exiv2::base64encode(iccProfile.c_data(), size, reinterpret_cast<char*>(ascii.data()), size * 3)) {
std::string str = output.str();
Exiv2::DataBuf iccProfile(str.size());
Exiv2::DataBuf ascii(str.size() * 3 + 1);
ascii.write_uint8(str.size() * 3, 0);
std::copy(str.begin(), str.end(), iccProfile.begin());
if (Exiv2::base64encode(iccProfile.c_data(), str.size(), reinterpret_cast<char*>(ascii.data()), str.size() * 3)) {
long chunk = 60;
std::string code = std::string("data:") + ascii.c_str();
size_t length = code.size();

11
app/exiv2.cpp
View File

@ -12,6 +12,7 @@
#include "i18n.h" // NLS support.
#include "xmp_exiv2.hpp"
#include <algorithm>
#include <cctype>
#include <cstring>
#include <fstream>
@ -941,20 +942,20 @@ static int readFileToBuf(FILE* f, Exiv2::DataBuf& buf) {
std::vector<Exiv2::byte> bytes(buff_size);
int nBytes = 0;
bool more{true};
std::array<char, buff_size> buff;
while (more) {
char buff[buff_size];
auto n = static_cast<int>(fread(buff, 1, buff_size, f));
auto n = fread(buff.data(), 1, buff_size, f);
more = n > 0;
if (more) {
bytes.resize(nBytes + n);
memcpy(bytes.data() + nBytes, buff, n);
std::copy_n(buff.begin(), n, bytes.begin() + nBytes);
nBytes += n;
}
}
if (nBytes) {
buf.alloc(nBytes);
buf.copyBytes(0, bytes.data(), nBytes);
std::copy(bytes.begin(), bytes.end(), buf.begin());
}
return nBytes;
}
@ -1004,7 +1005,7 @@ void Params::getStdin(Exiv2::DataBuf& buf) {
// copy stdinBuf to buf
if (!stdinBuf.empty()) {
buf.alloc(stdinBuf.size());
buf.copyBytes(0, stdinBuf.c_data(), buf.size());
std::copy(stdinBuf.begin(), stdinBuf.end(), buf.begin());
}
#ifdef DEBUG
std::cerr << "getStdin stdinBuf.size_ = " << stdinBuf.size() << std::endl;

3
include/exiv2/types.hpp
View File

@ -198,9 +198,6 @@ struct EXIV2API DataBuf {
uint64_t read_uint64(size_t offset, ByteOrder byteOrder) const;
void write_uint64(size_t offset, uint64_t x, ByteOrder byteOrder);
//! Copy bytes into the buffer (starting at address &pData_[offset]).
void copyBytes(size_t offset, const void* buf, size_t bufsize);
//! Equivalent to: memcmp(&pData_[offset], buf, bufsize)
int cmpBytes(size_t offset, const void* buf, size_t bufsize) const;

2
include/exiv2/value.hpp
View File

@ -10,10 +10,10 @@
#include "types.hpp"
// + standard includes
#include <cmath>
#include <cstring>
#include <iomanip>
#include <map>
#include <cmath>
// *****************************************************************************
// namespace extensions

11
samples/mmap-test.cpp
View File

@ -28,13 +28,16 @@ int main(int argc, char* const argv[]) {
}
// Map it to memory
const Exiv2::byte* pData = file.mmap();
DataBuf buf(file.size());
std::vector<byte> buf(file.size());
// Read from the memory mapped region
buf.copyBytes(0, pData, buf.size());
std::copy_n(pData, buf.size(), buf.begin());
// Reopen file in write mode and write to it
file.write(buf.c_data(), buf.size());
file.write(buf.data(), buf.size());
// Read from the mapped region again
buf.copyBytes(0, pData, buf.size());
std::copy_n(pData, buf.size(), buf.begin());
file.close();
return EXIT_SUCCESS;

2
src/cr2header_int.cpp
View File

@ -44,7 +44,7 @@ DataBuf Cr2Header::write() const {
buf.write_uint16(2, tag(), byteOrder());
buf.write_uint32(4, 0x00000010, byteOrder());
buf.copyBytes(8, cr2sig_, 4);
std::copy_n(cr2sig_, 4, buf.begin() + 8);
// Write a dummy value for the RAW IFD offset. The offset-writer is used to set this offset in a second pass.
buf.write_uint32(12, 0x00000000, byteOrder());
return buf;

4
src/crwimage_int.cpp
View File

@ -874,7 +874,7 @@ void CrwMap::encode0x0805(const Image& image, const CrwMapping* pCrwMapping, Cif
if (cc && cc->size() > size)
size = cc->size();
DataBuf buf(size);
buf.copyBytes(0, comment.data(), comment.size());
std::copy(comment.begin(), comment.end(), buf.begin());
pHead->add(pCrwMapping->crwTagId_, pCrwMapping->crwDir_, std::move(buf));
} else {
if (cc) {
@ -984,7 +984,7 @@ void CrwMap::encode0x1810(const Image& image, const CrwMapping* pCrwMapping, Cif
}
DataBuf buf(size);
if (cc)
buf.copyBytes(8, cc->pData() + 8, cc->size() - 8);
std::copy_n(cc->pData() + 8, cc->size() - 8, buf.begin() + 8);
if (edX != edEnd && edX->size() == 4) {
edX->copy(buf.data(), pHead->byteOrder());
}

2
src/image.cpp
View File

@ -362,7 +362,7 @@ void Image::printIFDStructure(BasicIo& io, std::ostream& out, Exiv2::PrintStruct
// Overflow check
enforce(allocate64 <= std::numeric_limits<size_t>::max(), ErrorCode::kerCorruptedMetadata);
DataBuf buf(allocate64); // allocate a buffer
buf.copyBytes(0, dir.c_data(8), 4); // copy dir[8:11] into buffer (short strings)
std::copy_n(dir.c_data(8), 4, buf.begin()); // copy dir[8:11] into buffer (short strings)
// We have already checked that this multiplication cannot overflow.
const size_t count_x_size = count * size;

45
src/jp2image.cpp
View File

@ -16,6 +16,7 @@
#include "tiffimage.hpp"
#include "types.hpp"
#include <algorithm>
#include <array>
#include <iostream>
@ -224,7 +225,7 @@ void Jp2Image::readMetadata() {
throw Error(ErrorCode::kerCorruptedMetadata);
}
DataBuf icc(iccLength);
icc.copyBytes(0, data.c_data(pad), icc.size());
std::copy_n(data.c_data(pad), icc.size(), icc.begin());
#ifdef EXIV2_DEBUG_MESSAGES
const char* iccPath = "/tmp/libexiv2_jp2.icc";
FILE* f = fopen(iccPath, "wb");
@ -645,8 +646,8 @@ void Jp2Image::encodeJp2Header(const DataBuf& boxBuf, DataBuf& outBuf) {
enforce(newlen <= output.size() - outlen, ErrorCode::kerCorruptedMetadata);
ul2Data(reinterpret_cast<byte*>(&newBox.length), psize, bigEndian);
ul2Data(reinterpret_cast<byte*>(&newBox.type), newBox.type, bigEndian);
output.copyBytes(outlen, &newBox, sizeof(newBox));
output.copyBytes(outlen + sizeof(newBox), pad, psize);
std::copy_n(reinterpret_cast<char*>(&newBox), sizeof(newBox), output.begin() + outlen);
std::copy_n(pad, psize, output.begin() + outlen + sizeof(newBox));
} else {
const char* pad = "\x02\x00\x00";
uint32_t psize = 3;
@ -654,13 +655,13 @@ void Jp2Image::encodeJp2Header(const DataBuf& boxBuf, DataBuf& outBuf) {
enforce(newlen <= output.size() - outlen, ErrorCode::kerCorruptedMetadata);
ul2Data(reinterpret_cast<byte*>(&newBox.length), static_cast<uint32_t>(newlen), bigEndian);
ul2Data(reinterpret_cast<byte*>(&newBox.type), newBox.type, bigEndian);
output.copyBytes(outlen, &newBox, sizeof(newBox));
output.copyBytes(outlen + sizeof(newBox), pad, psize);
output.copyBytes(outlen + sizeof(newBox) + psize, iccProfile_.c_data(), iccProfile_.size());
std::copy_n(reinterpret_cast<char*>(&newBox), sizeof(newBox), output.begin() + outlen);
std::copy_n(pad, psize, output.begin() + outlen + sizeof(newBox));
std::copy(iccProfile_.begin(), iccProfile_.end(), output.begin() + outlen + sizeof(newBox) + psize);
}
} else {
enforce(newlen <= output.size() - outlen, ErrorCode::kerCorruptedMetadata);
output.copyBytes(outlen, boxBuf.c_data(inlen), subBox.length);
std::copy_n(boxBuf.c_data(inlen), subBox.length, output.begin() + outlen);
}
outlen += newlen;
@ -669,7 +670,7 @@ void Jp2Image::encodeJp2Header(const DataBuf& boxBuf, DataBuf& outBuf) {
// allocate the correct number of bytes, copy the data and update the box header
outBuf.alloc(outlen);
outBuf.copyBytes(0, output.c_data(), outlen);
std::copy_n(output.c_data(), outlen, outBuf.begin());
auto oBox = reinterpret_cast<Internal::Jp2BoxHeader*>(outBuf.data());
ul2Data(reinterpret_cast<byte*>(&oBox->type), kJp2BoxTypeHeader, bigEndian);
ul2Data(reinterpret_cast<byte*>(&oBox->length), static_cast<uint32_t>(outlen), bigEndian);
@ -744,7 +745,7 @@ void Jp2Image::doWriteMetadata(BasicIo& outIo) {
// Read whole box : Box header + Box data (not fixed size - can be null).
DataBuf boxBuf(box.length); // Box header (8 bytes) + box data.
boxBuf.copyBytes(0, bheaderBuf.c_data(), 8); // Copy header.
std::copy_n(bheaderBuf.begin(), 8, boxBuf.begin()); // Copy header.
io_->readOrThrow(boxBuf.data(8), box.length - 8, ErrorCode::kerInputDataReadFailed); // Extract box data.
switch (box.type) {
@ -767,15 +768,15 @@ void Jp2Image::doWriteMetadata(BasicIo& outIo) {
ExifParser::encode(blob, littleEndian, exifData_);
if (!blob.empty()) {
DataBuf rawExif(blob.size());
rawExif.copyBytes(0, &blob[0], blob.size());
std::copy(blob.begin(), blob.end(), rawExif.begin());
DataBuf boxData(8 + 16 + rawExif.size());
ul2Data(boxDataSize, static_cast<uint32_t>(boxData.size()), bigEndian);
ul2Data(boxUUIDtype, kJp2BoxTypeUuid, bigEndian);
boxData.copyBytes(0, boxDataSize, 4);
boxData.copyBytes(4, boxUUIDtype, 4);
boxData.copyBytes(8, kJp2UuidExif, 16);
boxData.copyBytes(8 + 16, rawExif.c_data(), rawExif.size());
std::copy_n(boxDataSize, 4, boxData.begin());
std::copy_n(boxUUIDtype, 4, boxData.begin() + 4);
std::copy_n(kJp2UuidExif, 16, boxData.begin() + 8);
std::copy(rawExif.begin(), rawExif.end(), boxData.begin() + 8 + 16);
#ifdef EXIV2_DEBUG_MESSAGES
std::cout << "Exiv2::Jp2Image::doWriteMetadata: Write box with Exif metadata (length: " << boxData.size()
@ -794,10 +795,10 @@ void Jp2Image::doWriteMetadata(BasicIo& outIo) {
DataBuf boxData(8 + 16 + rawIptc.size());
ul2Data(boxDataSize, static_cast<uint32_t>(boxData.size()), bigEndian);
ul2Data(boxUUIDtype, kJp2BoxTypeUuid, bigEndian);
boxData.copyBytes(0, boxDataSize, 4);
boxData.copyBytes(4, boxUUIDtype, 4);
boxData.copyBytes(8, kJp2UuidIptc, 16);
boxData.copyBytes(8 + 16, rawIptc.c_data(), rawIptc.size());
std::copy_n(boxDataSize, 4, boxData.begin());
std::copy_n(boxUUIDtype, 4, boxData.begin() + 4);
std::copy_n(kJp2UuidExif, 16, boxData.begin() + 8);
std::copy(rawIptc.begin(), rawIptc.end(), boxData.begin() + 8 + 16);
#ifdef EXIV2_DEBUG_MESSAGES
std::cout << "Exiv2::Jp2Image::doWriteMetadata: Write box with Iptc metadata (length: " << boxData.size()
@ -822,10 +823,10 @@ void Jp2Image::doWriteMetadata(BasicIo& outIo) {
DataBuf boxData(8 + 16 + xmp.size());
ul2Data(boxDataSize, static_cast<uint32_t>(boxData.size()), bigEndian);
ul2Data(boxUUIDtype, kJp2BoxTypeUuid, bigEndian);
boxData.copyBytes(0, boxDataSize, 4);
boxData.copyBytes(4, boxUUIDtype, 4);
boxData.copyBytes(8, kJp2UuidXmp, 16);
boxData.copyBytes(8 + 16, xmp.c_data(), xmp.size());
std::copy_n(boxDataSize, 4, boxData.begin());
std::copy_n(boxUUIDtype, 4, boxData.begin() + 4);
std::copy_n(kJp2UuidExif, 16, boxData.begin() + 8);
std::copy(xmp.begin(), xmp.end(), boxData.begin() + 8 + 16);
#ifdef EXIV2_DEBUG_MESSAGES
std::cout << "Exiv2::Jp2Image::doWriteMetadata: Write box with XMP metadata (length: " << boxData.size()

30
src/jpgimage.cpp
View File

@ -272,11 +272,11 @@ void JpegBase::readMetadata() {
while (marker != sos_ && marker != eoi_ && search > 0) {
// 2-byte buffer for reading the size.
byte sizebuf[2];
std::array<byte, 2> sizebuf;
uint16_t size = 0; // Size of the segment, including the 2-byte size field
if (markerHasLength(marker)) {
io_->readOrThrow(sizebuf, 2, ErrorCode::kerFailedToReadImageData);
size = getUShort(sizebuf, bigEndian);
io_->readOrThrow(sizebuf.data(), sizebuf.size(), ErrorCode::kerFailedToReadImageData);
size = getUShort(sizebuf.data(), bigEndian);
enforce(size >= 2, ErrorCode::kerFailedToReadImageData);
}
@ -285,7 +285,7 @@ void JpegBase::readMetadata() {
/// \todo check if it makes sense to check for size
if (size > 0) {
io_->readOrThrow(buf.data(2), size - 2, ErrorCode::kerFailedToReadImageData);
buf.copyBytes(0, sizebuf, 2);
std::copy(sizebuf.begin(), sizebuf.end(), buf.begin());
}
if (!foundExifData && marker == app1_ && size >= 8 // prevent out-of-bounds read in memcmp on next line
@ -363,9 +363,9 @@ void JpegBase::readMetadata() {
DataBuf profile(Safe::add(iccProfile_.size(), icc_size));
if (!iccProfile_.empty()) {
profile.copyBytes(0, iccProfile_.c_data(), iccProfile_.size());
std::copy(iccProfile_.begin(), iccProfile_.end(), profile.begin());
}
profile.copyBytes(iccProfile_.size(), buf.c_data(2 + 14), icc_size);
std::copy_n(buf.c_data(2 + 14), icc_size, profile.data() + iccProfile_.size());
setIccProfile(std::move(profile), chunk == chunks);
} else if (pixelHeight_ == 0 && inRange2(marker, sof0_, sof3_, sof5_, sof15_)) {
// We hit a SOFn (start-of-frame) marker
@ -479,11 +479,11 @@ void JpegBase::printStructure(std::ostream& out, PrintStructureOption option, in
bool bLF = bPrint;
// 2-byte buffer for reading the size.
byte sizebuf[2];
std::array<byte, 2> sizebuf;
uint16_t size = 0;
if (markerHasLength(marker)) {
io_->readOrThrow(sizebuf, 2, ErrorCode::kerFailedToReadImageData);
size = getUShort(sizebuf, bigEndian);
io_->readOrThrow(sizebuf.data(), sizebuf.size(), ErrorCode::kerFailedToReadImageData);
size = getUShort(sizebuf.data(), bigEndian);
// `size` is the size of the segment, including the 2-byte size field
// that we just read.
enforce(size >= 2, ErrorCode::kerFailedToReadImageData);
@ -493,7 +493,7 @@ void JpegBase::printStructure(std::ostream& out, PrintStructureOption option, in
DataBuf buf(size);
if (size > 0) {
io_->readOrThrow(buf.data(2), size - 2, ErrorCode::kerFailedToReadImageData);
buf.copyBytes(0, sizebuf, 2);
std::copy(sizebuf.begin(), sizebuf.end(), buf.begin());
}
if (bPrint && markerHasLength(marker))
@ -732,11 +732,11 @@ void JpegBase::writeMetadata() {
DataBuf JpegBase::readNextSegment(byte marker) {
// 2-byte buffer for reading the size.
byte sizebuf[2];
std::array<byte, 2> sizebuf;
uint16_t size = 0;
if (markerHasLength(marker)) {
io_->readOrThrow(sizebuf, 2, ErrorCode::kerFailedToReadImageData);
size = getUShort(sizebuf, bigEndian);
io_->readOrThrow(sizebuf.data(), sizebuf.size(), ErrorCode::kerFailedToReadImageData);
size = getUShort(sizebuf.data(), bigEndian);
// `size` is the size of the segment, including the 2-byte size field
// that we just read.
enforce(size >= 2, ErrorCode::kerFailedToReadImageData);
@ -746,7 +746,7 @@ DataBuf JpegBase::readNextSegment(byte marker) {
DataBuf buf(size);
if (size > 0) {
io_->readOrThrow(buf.data(2), size - 2, ErrorCode::kerFailedToReadImageData);
buf.copyBytes(0, sizebuf, 2);
std::copy(sizebuf.begin(), sizebuf.end(), buf.begin());
}
return buf;
}
@ -805,7 +805,7 @@ void JpegBase::doWriteMetadata(BasicIo& outIo) {
++search;
if (buf.size() > 8) {
rawExif.alloc(buf.size() - 8);
rawExif.copyBytes(0, buf.c_data(8), buf.size() - 8);
std::copy_n(buf.c_data(8), rawExif.size(), rawExif.begin());
}
} else if (skipApp1Xmp == notfound && marker == app1_ &&
buf.size() >= 31 && // prevent out-of-bounds read in memcmp on next line

26
src/makernote_int.cpp
View File

@ -188,7 +188,7 @@ bool OlympusMnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrder
if (!pData || size < sizeOfSignature())
return false;
header_.alloc(sizeOfSignature());
header_.copyBytes(0, pData, header_.size());
std::copy_n(pData, header_.size(), header_.data());
return !(header_.size() < sizeOfSignature() || 0 != header_.cmpBytes(0, signature_, 6));
}
@ -223,7 +223,7 @@ bool Olympus2MnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrde
if (!pData || size < sizeOfSignature())
return false;
header_.alloc(sizeOfSignature());
header_.copyBytes(0, pData, header_.size());
std::copy_n(pData, header_.size(), header_.data());
return !(header_.size() < sizeOfSignature() || 0 != header_.cmpBytes(0, signature_, 10));
}
@ -263,7 +263,7 @@ bool FujiMnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrder*/)
if (!pData || size < sizeOfSignature())
return false;
header_.alloc(sizeOfSignature());
header_.copyBytes(0, pData, header_.size());
std::copy_n(pData, header_.size(), header_.data());
// Read offset to the IFD relative to the start of the makernote
// from the header. Note that we ignore the byteOrder argument
start_ = header_.read_uint32(8, byteOrder_);
@ -299,7 +299,7 @@ bool Nikon2MnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrder*
if (0 != memcmp(pData, signature_, 6))
return false;
buf_.alloc(sizeOfSignature());
buf_.copyBytes(0, pData, buf_.size());
std::copy_n(pData, buf_.size(), buf_.data());
start_ = sizeOfSignature();
return true;
} // Nikon2MnHeader::read
@ -318,7 +318,7 @@ size_t Nikon3MnHeader::sizeOfSignature() {
Nikon3MnHeader::Nikon3MnHeader() : byteOrder_(invalidByteOrder), start_(sizeOfSignature()) {
buf_.alloc(sizeOfSignature());
buf_.copyBytes(0, signature_, buf_.size());
std::copy_n(signature_, buf_.size(), buf_.data());
}
size_t Nikon3MnHeader::size() const {
@ -343,7 +343,7 @@ bool Nikon3MnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrder*
if (0 != memcmp(pData, signature_, 6))
return false;
buf_.alloc(sizeOfSignature());
buf_.copyBytes(0, pData, buf_.size());
std::copy_n(pData, buf_.size(), buf_.data());
TiffHeader th;
if (!th.read(buf_.data(10), 8))
return false;
@ -389,7 +389,7 @@ bool PanasonicMnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrd
if (0 != memcmp(pData, signature_, 9))
return false;
buf_.alloc(sizeOfSignature());
buf_.copyBytes(0, pData, buf_.size());
std::copy_n(pData, buf_.size(), buf_.data());
start_ = sizeOfSignature();
return true;
} // PanasonicMnHeader::read
@ -425,7 +425,7 @@ bool PentaxDngMnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrd
if (!pData || size < sizeOfSignature())
return false;
header_.alloc(sizeOfSignature());
header_.copyBytes(0, pData, header_.size());
std::copy_n(pData, header_.size(), header_.data());
return !(header_.size() < sizeOfSignature() || 0 != header_.cmpBytes(0, signature_, 7));
}
@ -456,7 +456,7 @@ bool PentaxMnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrder*
if (!pData || size < sizeOfSignature())
return false;
header_.alloc(sizeOfSignature());
header_.copyBytes(0, pData, header_.size());
std::copy_n(pData, header_.size(), header_.data());
return !(header_.size() < sizeOfSignature() || 0 != header_.cmpBytes(0, signature_, 3));
}
@ -510,7 +510,7 @@ bool SigmaMnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrder*/
if (0 != memcmp(pData, signature1_, 8) && 0 != memcmp(pData, signature2_, 8))
return false;
buf_.alloc(sizeOfSignature());
buf_.copyBytes(0, pData, buf_.size());
std::copy_n(pData, buf_.size(), buf_.data());
start_ = sizeOfSignature();
return true;
} // SigmaMnHeader::read
@ -544,7 +544,7 @@ bool SonyMnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrder*/)
if (0 != memcmp(pData, signature_, sizeOfSignature()))
return false;
buf_.alloc(sizeOfSignature());
buf_.copyBytes(0, pData, buf_.size());
std::copy_n(pData, buf_.size(), buf_.data());
start_ = sizeOfSignature();
return true;
} // SonyMnHeader::read
@ -583,7 +583,7 @@ bool Casio2MnHeader::read(const byte* pData, size_t size, ByteOrder /*byteOrder*
if (0 != memcmp(pData, signature_, sizeOfSignature()))
return false;
buf_.alloc(sizeOfSignature());
buf_.copyBytes(0, pData, buf_.size());
std::copy_n(pData, buf_.size(), buf_.data());
start_ = sizeOfSignature();
return true;
} // Casio2MnHeader::read
@ -891,7 +891,7 @@ DataBuf nikonCrypt(uint16_t tag, const byte* pData, size_t size, TiffComponent*
}
}
buf.alloc(size);
buf.copyBytes(0, pData, buf.size());
std::copy_n(pData, buf.size(), buf.data());
ncrypt(buf.data(nci->start_), static_cast<uint32_t>(buf.size()) - nci->start_, count, serial);
return buf;
}

4
src/pgfimage.cpp
View File

@ -180,7 +180,7 @@ void PgfImage::doWriteMetadata(BasicIo& outIo) {
// Write new Header size.
uint32_t newHeaderSize = static_cast<uint32_t>(header.size() + imgSize);
DataBuf buffer(4);
buffer.copyBytes(0, &newHeaderSize, 4);
std::copy_n(&newHeaderSize, 4, buffer.data());
byteSwap_(buffer, 0, bSwap_);
if (outIo.write(buffer.c_data(), 4) != 4)
throw Error(ErrorCode::kerImageWriteFailed);
@ -259,7 +259,7 @@ DataBuf PgfImage::readPgfHeaderStructure(BasicIo& iIo, uint32_t& width, uint32_t
throw Error(ErrorCode::kerInputDataReadFailed);
DataBuf work(8); // don't disturb the binary data - doWriteMetadata reuses it
work.copyBytes(0, header.c_data(), 8);
std::copy_n(header.c_data(), 8, work.begin());
width = byteSwap_(work, 0, bSwap_);
height = byteSwap_(work, 4, bSwap_);

2
src/pngchunk_int.cpp
View File

@ -490,7 +490,7 @@ DataBuf PngChunk::readRawProfile(const DataBuf& text, bool iTXt) {
if (iTXt) {
info.alloc(text.size());
info.copyBytes(0, text.c_data(), text.size());
std::copy(text.cbegin(), text.cend(), info.begin());
return info;
}

4
src/pngimage.cpp
View File

@ -341,7 +341,7 @@ void PngImage::printStructure(std::ostream& out, PrintStructureOption option, in
if (bSoft && !dataBuf.empty()) {
DataBuf s(dataBuf.size() + 1); // allocate buffer with an extra byte
s.copyBytes(0, dataBuf.c_data(), dataBuf.size()); // copy in the dataBuf
std::copy(dataBuf.begin(), dataBuf.end(), s.begin()); // copy in the dataBuf
s.write_uint8(dataBuf.size(), 0); // nul terminate it
const auto str = s.c_str(); // give it name
out << Internal::indent(depth) << buff.c_str() << ": " << str;
@ -526,7 +526,7 @@ void PngImage::doWriteMetadata(BasicIo& outIo) {
// Read whole chunk : Chunk header + Chunk data (not fixed size - can be null) + CRC (4 bytes).
DataBuf chunkBuf(8 + dataOffset + 4); // Chunk header (8 bytes) + Chunk data + CRC (4 bytes).
chunkBuf.copyBytes(0, cheaderBuf.c_data(), 8); // Copy header.
std::copy_n(cheaderBuf.begin(), 8, chunkBuf.begin()); // Copy header.
bufRead = io_->read(chunkBuf.data(8), dataOffset + 4); // Extract chunk data + CRC
if (io_->error())
throw Error(ErrorCode::kerFailedToReadImageData);

9
src/preview.cpp
View File

@ -12,6 +12,7 @@
#include "tiffimage.hpp"
#include "tiffimage_int.hpp"
#include <algorithm>
#include <climits>
namespace {
@ -739,7 +740,7 @@ DataBuf LoaderTiff::getData() const {
// That's why we check again for each step here to really make sure we don't overstep
enforce(Safe::add(idxBuf, size) <= size_, ErrorCode::kerCorruptedMetadata);
if (size != 0 && Safe::add(offset, size) <= static_cast<uint32_t>(io.size())) {
buf.copyBytes(idxBuf, base + offset, size);
std::copy_n(base + offset, size, buf.begin() + idxBuf);
}
idxBuf += size;
@ -953,9 +954,9 @@ DataBuf makePnm(size_t width, size_t height, const DataBuf &rgb) {
const std::string header = "P6\n" + toString(width) + " " + toString(height) + "\n255\n";
const auto headerBytes = reinterpret_cast<const byte *>(header.data());
DataBuf dest(static_cast<long>(header.size() + rgb.size()));
dest.copyBytes(0, headerBytes, header.size());
dest.copyBytes(header.size(), rgb.c_data(), rgb.size());
DataBuf dest(header.size() + rgb.size());
std::copy_n(headerBytes, header.size(), dest.begin());
std::copy_n(rgb.c_data(), rgb.size(), dest.begin() + header.size());
return dest;
}

2
src/tiffvisitor_int.cpp
View File

@ -512,7 +512,7 @@ void TiffEncoder::encodeIptc() {
if (rawIptc.size() % 4 != 0) {
// Pad the last unsignedLong value with 0s
buf.alloc((rawIptc.size() / 4) * 4 + 4);
buf.copyBytes(0, rawIptc.c_data(), rawIptc.size());
std::copy(rawIptc.begin(), rawIptc.end(), buf.begin());
} else {
buf = std::move(rawIptc); // Note: This resets rawIptc
}

9
src/types.cpp
View File

@ -164,15 +164,6 @@ void Exiv2::DataBuf::write_uint64(size_t offset, uint64_t x, ByteOrder byteOrder
ull2Data(&pData_[offset], x, byteOrder);
}
void Exiv2::DataBuf::copyBytes(size_t offset, const void* buf, size_t bufsize) {
if (pData_.size() < bufsize || offset > pData_.size() - bufsize) {
throw std::overflow_error("Overflow in Exiv2::DataBuf::copyBytes");
}
if (bufsize > 0) {
memcpy(&pData_[offset], buf, bufsize);
}
}
int Exiv2::DataBuf::cmpBytes(size_t offset, const void* buf, size_t bufsize) const {
if (pData_.size() < bufsize || offset > pData_.size() - bufsize) {
throw std::overflow_error("Overflow in Exiv2::DataBuf::cmpBytes");

12
src/webpimage.cpp
View File

@ -680,18 +680,18 @@ void WebPImage::decodeChunks(long filesize) {
if (s_header) {
us2Data(size_buff2, static_cast<uint16_t>(sizePayload - 6), bigEndian);
rawExifData.copyBytes(0, reinterpret_cast<char*>(&exifLongHeader), 4);
rawExifData.copyBytes(4, reinterpret_cast<char*>(&size_buff2), 2);
std::copy_n(reinterpret_cast<char*>(&exifLongHeader), 4, rawExifData.begin());
std::copy_n(reinterpret_cast<char*>(&size_buff2), 2, rawExifData.begin() + 4);
}
if (be_header || le_header) {
us2Data(size_buff2, static_cast<uint16_t>(sizePayload - 6), bigEndian);
rawExifData.copyBytes(0, reinterpret_cast<char*>(&exifLongHeader), 4);
rawExifData.copyBytes(4, reinterpret_cast<char*>(&size_buff2), 2);
rawExifData.copyBytes(6, reinterpret_cast<char*>(&exifShortHeader), 6);
std::copy_n(reinterpret_cast<char*>(&exifLongHeader), 4, rawExifData.begin());
std::copy_n(reinterpret_cast<char*>(&size_buff2), 2, rawExifData.begin() + 4);
std::copy_n(reinterpret_cast<char*>(&exifShortHeader), 6, rawExifData.begin() + 6);
}
rawExifData.copyBytes(offset, payload.c_data(), payload.size());
std::copy(payload.begin(), payload.end(), rawExifData.begin() + offset);
#ifdef EXIV2_DEBUG_MESSAGES
std::cout << "Display Hex Dump [size:" << static_cast<unsigned long>(sizePayload) << "]" << std::endl;