uint32 BufferPool::getBuffer(void)
{
DataBuf* buf = NULL;
// lock mutex for reset
MutexLocker ml(&_mutexReset);
// decrement free buffers counter
_semFree.wait();
// get bid from stack
buf = (DataBuf *) _psFree.pop();
// check if there are no more free buffers
if (!buf) {
fprintf(stderr, "BufferPool: NO MORE FREE BUFFERS...\n");
return 0;
}
// increment used buffers counter
_semUsed.post();
// return this bid
return buf->getBID();
}
int32 BufferPool::tryGetBuffer(uint32* bid)
{
int32 ret = 0;
// lock mutex for reset
MutexLocker ml(&_mutexReset);
// decrement free buffers counter
ret = _semFree.tryWait();
if (ret == FAILURE)
return FAILURE;
DataBuf* buf = (DataBuf*) _psFree.pop();
if (!buf) {
puts("Critical: null buffer in pool"); return FAILURE;
}
*bid = buf->getBID();
// increment used buffers counter
_semUsed.post();
// ok
return SUCCESS;
}
bool encode(DataBuf& buf, const OutBoundRpcMessage& msg) {
using exec::rpc::RpcHeader;
using google::protobuf::io::CodedOutputStream;
// Todo:
//
// - let a context manager to allocate a buffer `ByteBuf buf = ctx.alloc().buffer();`
// - builder pattern
//
#ifdef CODER_DEBUG
std::cerr << "Encoding outbound message " << msg << std::endl;
#endif
RpcHeader header;
header.set_mode(msg.m_mode);
header.set_coordination_id(msg.m_coord_id);
header.set_rpc_type(msg.m_rpc_type);
// calcute the length of the message
int header_length = header.ByteSize();
int proto_body_length = msg.m_pbody->ByteSize();
int full_length = HEADER_TAG_LENGTH + CodedOutputStream::VarintSize32(header_length) + header_length + \
PROTOBUF_BODY_TAG_LENGTH + CodedOutputStream::VarintSize32(proto_body_length) + proto_body_length;
/*
if(raw_body_length > 0) {
full_length += (RAW_BODY_TAG_LENGTH + getRawVarintSize(raw_body_length) + raw_body_length);
}
*/
buf.resize(full_length + CodedOutputStream::VarintSize32(full_length));
uint8_t* data = buf.data();
#ifdef CODER_DEBUG
std::cerr << "Writing full length " << full_length << std::endl;
#endif
data = CodedOutputStream::WriteVarint32ToArray(full_length, data);
#ifdef CODER_DEBUG
std::cerr << "Writing header length " << header_length << std::endl;
#endif
data = CodedOutputStream::WriteVarint32ToArray(HEADER_TAG, data);
data = CodedOutputStream::WriteVarint32ToArray(header_length, data);
data = header.SerializeWithCachedSizesToArray(data);
// write protobuf body length and body
#ifdef CODER_DEBUG
std::cerr << "Writing protobuf body length " << proto_body_length << std::endl;
#endif
data = CodedOutputStream::WriteVarint32ToArray(PROTOBUF_BODY_TAG, data);
data = CodedOutputStream::WriteVarint32ToArray(proto_body_length, data);
msg.m_pbody->SerializeWithCachedSizesToArray(data);
// Done! no read to write data body for client
return true;
}
void TiffImage::writeMetadata()
{
#ifdef DEBUG
std::cerr << "Writing TIFF file " << io_->path() << "\n";
#endif
// Read existing image
ByteOrder bo = byteOrder();
DataBuf buf;
if (io_->open() == 0) {
IoCloser closer(*io_);
// Ensure that this is the correct image type
if (isTiffType(*io_, false)) {
// Read the image into a memory buffer
buf.alloc(io_->size());
io_->read(buf.pData_, buf.size_);
if (io_->error() || io_->eof()) {
buf.reset();
}
TiffHeader tiffHeader;
if (0 == tiffHeader.read(buf.pData_, 8)) {
bo = tiffHeader.byteOrder();
}
}
}
if (bo == invalidByteOrder) {
bo = littleEndian;
}
setByteOrder(bo);
Blob blob;
WriteMethod wm = TiffParser::encode(blob,
buf.pData_,
buf.size_,
bo,
exifData_,
iptcData_,
xmpData_);
// Write updated or new buffer to file
BasicIo::AutoPtr tempIo(io_->temporary()); // may throw
assert(tempIo.get() != 0);
if (wm == wmNonIntrusive) {
// Buffer may be modified but size is unchanged, write buffer back
tempIo->write(buf.pData_, buf.size_);
}
else {
// Size of the buffer changed, write from blob
tempIo->write(&blob[0], static_cast<long>(blob.size()));
}
io_->close();
io_->transfer(*tempIo); // may throw
} // TiffImage::writeMetadata
DataBuf* BufferPool::use(uint32 bid)
{
DataBuf* buf = NULL;
// lock mutex for reset
MutexLocker ml(&_mutexReset);
if (bid < _bcount) {
buf = _bufs[bid];
buf->setInUse(true);
}
// ok
return buf;
}
PreviewImage::PreviewImage(const PreviewProperties& properties, DataBuf data)
: properties_(properties)
{
pData_ = data.pData_;
size_ = data.size_;
data.release();
}
void BufferPool::reset(void)
{
DataBuf* buf = NULL;
int32 ret = 0;
// lock mutex for reset
MutexLocker ml(&_mutexReset);
// empty buffers stack
for (uint32 j = 0; j < _bcount; j++) {
buf = (DataBuf *) _psFree.pop();
if (!buf)
break;
UOSUTIL_DOUT(("Get buffer from the stack: %u\n", buf->getBID()));
}
// reset "used" semaphore
while ((ret = _semUsed.tryWait()) != FAILURE)
UOSUTIL_DOUT(("Waiting on semaphore \"used\"\n"));
// reset "free" semaphore
while ((ret = _semFree.tryWait()) != FAILURE)
UOSUTIL_DOUT(("Waiting on semaphore \"free\"\n"));
// put all buffers in the buffers stack
for (uint32 i = 0; i < _bcount; i++) {
// reset buffer
_bufs[i]->setInUse(false);
_bufs[i]->setCount(0);
// push buffer pointer into the "free buffers" stack
_psFree.push(_bufs[i]);
// DEBUG
UOSUTIL_DOUT(("Buffer %u pushed.\n", _bufs[i]->getBID()));
}
// reset "free" semaphore
for (uint32 k = 0; k < _bcount; k++) {
UOSUTIL_DOUT(("Posting semaphore \"free\" (%u)\n", k));
_semFree.post();
}
}
void PngChunk::zlibUncompress(const byte* compressedText,
unsigned int compressedTextSize,
DataBuf& arr)
{
uLongf uncompressedLen = compressedTextSize * 2; // just a starting point
int zlibResult;
do
{
arr.alloc(uncompressedLen);
zlibResult = uncompress((Bytef*)arr.pData_, &uncompressedLen,
compressedText, compressedTextSize);
if (zlibResult == Z_OK)
{
// then it is all OK
arr.alloc(uncompressedLen);
}
else if (zlibResult == Z_BUF_ERROR)
{
// the uncompressedArray needs to be larger
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::parsePngChunk: doubling size for decompression.\n";
#endif
uncompressedLen *= 2;
// DoS protection. can't be bigger than 64k
if ( uncompressedLen > 131072 )
break;
}
else
{
// something bad happened
throw Error(14);
}
}
while (zlibResult == Z_BUF_ERROR);
if (zlibResult != Z_OK)
throw Error(14);
} // PngChunk::zlibUncompress
DataBuf nikonCrypt(uint16_t tag, const byte* pData, uint32_t size, TiffComponent* const pRoot)
{
DataBuf buf;
if (size < 4) return buf;
const NikonArrayIdx* nci = find(nikonArrayIdx, NikonArrayIdx::Key(tag, reinterpret_cast<const char*>(pData), size));
if (nci == 0 || nci->start_ == NA || size <= nci->start_) return buf;
// Find Exif.Nikon3.ShutterCount
TiffFinder finder(0x00a7, nikon3Id);
pRoot->accept(finder);
TiffEntryBase* te = dynamic_cast<TiffEntryBase*>(finder.result());
if (!te || !te->pValue() || te->pValue()->count() == 0) return buf;
uint32_t count = static_cast<uint32_t>(te->pValue()->toLong());
// Find Exif.Nikon3.SerialNumber
finder.init(0x001d, nikon3Id);
pRoot->accept(finder);
te = dynamic_cast<TiffEntryBase*>(finder.result());
if (!te || !te->pValue() || te->pValue()->count() == 0) return buf;
bool ok(false);
uint32_t serial = stringTo<uint32_t>(te->pValue()->toString(), ok);
if (!ok) {
std::string model = getExifModel(pRoot);
if (model.empty()) return buf;
if (model.find("D50") != std::string::npos) {
serial = 0x22;
}
else {
serial = 0x60;
}
}
buf.alloc(size);
memcpy(buf.pData_, pData, buf.size_);
ncrypt(buf.pData_ + nci->start_, buf.size_ - nci->start_, count, serial);
return buf;
}
void JpegBase::doWriteMetadata(BasicIo& outIo)
{
if (!io_->isopen()) throw Error(20);
if (!outIo.isopen()) throw Error(21);
// Ensure that this is the correct image type
if (!isThisType(*io_, true)) {
if (io_->error() || io_->eof()) throw Error(20);
throw Error(22);
}
const long bufMinSize = 16;
long bufRead = 0;
DataBuf buf(bufMinSize);
const long seek = io_->tell();
int count = 0;
int search = 0;
int insertPos = 0;
int skipApp1Exif = -1;
int skipApp13Ps3 = -1;
int skipCom = -1;
DataBuf psData;
// Write image header
if (writeHeader(outIo)) throw Error(21);
// Read section marker
int marker = advanceToMarker();
if (marker < 0) throw Error(22);
// First find segments of interest. Normally app0 is first and we want
// to insert after it. But if app0 comes after com, app1 and app13 then
// don't bother.
while (marker != sos_ && marker != eoi_ && search < 3) {
// Read size and signature (ok if this hits EOF)
bufRead = io_->read(buf.pData_, bufMinSize);
if (io_->error()) throw Error(20);
uint16_t size = getUShort(buf.pData_, bigEndian);
if (marker == app0_) {
if (size < 2) throw Error(22);
insertPos = count + 1;
if (io_->seek(size-bufRead, BasicIo::cur)) throw Error(22);
}
else if (marker == app1_ && memcmp(buf.pData_ + 2, exifId_, 6) == 0) {
if (size < 8) throw Error(22);
skipApp1Exif = count;
++search;
if (io_->seek(size-bufRead, BasicIo::cur)) throw Error(22);
}
else if (marker == app13_ && memcmp(buf.pData_ + 2, Photoshop::ps3Id_, 14) == 0) {
if (size < 16) throw Error(22);
skipApp13Ps3 = count;
++search;
// needed if bufMinSize!=16: io_->seek(16-bufRead, BasicIo::cur);
psData.alloc(size - 16);
// Load PS data now to allow reinsertion at any point
io_->read(psData.pData_, psData.size_);
if (io_->error() || io_->eof()) throw Error(20);
}
else if (marker == com_ && skipCom == -1) {
if (size < 2) throw Error(22);
// Jpegs can have multiple comments, but for now only handle
// the first one (most jpegs only have one anyway).
skipCom = count;
++search;
if (io_->seek(size-bufRead, BasicIo::cur)) throw Error(22);
}
else {
if (size < 2) throw Error(22);
if (io_->seek(size-bufRead, BasicIo::cur)) throw Error(22);
}
marker = advanceToMarker();
if (marker < 0) throw Error(22);
++count;
}
if (exifData_.count() > 0) ++search;
if (iptcData_.count() > 0) ++search;
if (!comment_.empty()) ++search;
io_->seek(seek, BasicIo::beg);
count = 0;
marker = advanceToMarker();
if (marker < 0) throw Error(22);
// To simplify this a bit, new segments are inserts at either the start
// or right after app0. This is standard in most jpegs, but has the
// potential to change segment ordering (which is allowed).
// Segments are erased if there is no assigned metadata.
while (marker != sos_ && search > 0) {
// Read size and signature (ok if this hits EOF)
bufRead = io_->read(buf.pData_, bufMinSize);
if (io_->error()) throw Error(20);
// Careful, this can be a meaningless number for empty
// images with only an eoi_ marker
uint16_t size = getUShort(buf.pData_, bigEndian);
if (insertPos == count) {
byte tmpBuf[18];
if (!comment_.empty()) {
// Write COM marker, size of comment, and string
tmpBuf[0] = 0xff;
tmpBuf[1] = com_;
if (comment_.length() + 3 > 0xffff) throw Error(37, "JPEG comment");
us2Data(tmpBuf + 2, static_cast<uint16_t>(comment_.length() + 3), bigEndian);
if (outIo.write(tmpBuf, 4) != 4) throw Error(21);
if (outIo.write((byte*)comment_.data(), (long)comment_.length())
!= (long)comment_.length()) throw Error(21);
if (outIo.putb(0)==EOF) throw Error(21);
if (outIo.error()) throw Error(21);
--search;
}
if (exifData_.count() > 0) {
DataBuf rawExif = exifData_.copy();
if (rawExif.size_ > 0) {
// Write APP1 marker, size of APP1 field, Exif id and Exif data
tmpBuf[0] = 0xff;
tmpBuf[1] = app1_;
if (rawExif.size_ + 8 > 0xffff) throw Error(37, "Exif");
us2Data(tmpBuf + 2, static_cast<uint16_t>(rawExif.size_ + 8), bigEndian);
memcpy(tmpBuf + 4, exifId_, 6);
if (outIo.write(tmpBuf, 10) != 10) throw Error(21);
// Write new Exif data buffer
if ( outIo.write(rawExif.pData_, rawExif.size_)
!= rawExif.size_) throw Error(21);
if (outIo.error()) throw Error(21);
--search;
}
}
if (psData.size_ > 0 || iptcData_.count() > 0) {
// Set the new IPTC IRB, keeps existing IRBs but removes the
// IPTC block if there is no new IPTC data to write
DataBuf newPsData = Photoshop::setIptcIrb(psData.pData_,
psData.size_,
iptcData_);
if (newPsData.size_ > 0) {
// Write APP13 marker, new size, and ps3Id
tmpBuf[0] = 0xff;
tmpBuf[1] = app13_;
if (newPsData.size_ + 16 > 0xffff) throw Error(37, "IPTC");
us2Data(tmpBuf + 2, static_cast<uint16_t>(newPsData.size_ + 16), bigEndian);
memcpy(tmpBuf + 4, Photoshop::ps3Id_, 14);
if (outIo.write(tmpBuf, 18) != 18) throw Error(21);
if (outIo.error()) throw Error(21);
// Write new Photoshop IRB data buffer
if ( outIo.write(newPsData.pData_, newPsData.size_)
!= newPsData.size_) throw Error(21);
if (outIo.error()) throw Error(21);
}
if (iptcData_.count() > 0) {
--search;
}
}
}
if (marker == eoi_) {
break;
}
else if (skipApp1Exif==count || skipApp13Ps3==count || skipCom==count) {
--search;
io_->seek(size-bufRead, BasicIo::cur);
}
else {
if (size < 2) throw Error(22);
buf.alloc(size+2);
io_->seek(-bufRead-2, BasicIo::cur);
io_->read(buf.pData_, size+2);
if (io_->error() || io_->eof()) throw Error(20);
if (outIo.write(buf.pData_, size+2) != size+2) throw Error(21);
if (outIo.error()) throw Error(21);
}
// Next marker
marker = advanceToMarker();
if (marker < 0) throw Error(22);
++count;
}
// Copy rest of the Io
io_->seek(-2, BasicIo::cur);
buf.alloc(4096);
long readSize = 0;
while ((readSize=io_->read(buf.pData_, buf.size_))) {
if (outIo.write(buf.pData_, readSize) != readSize) throw Error(21);
}
if (outIo.error()) throw Error(21);
} // JpegBase::doWriteMetadata
BufferPool::~BufferPool(void)
{
uint32 bid = 0, i = 0;
uint32 wait = 10, bc = 0;
MutexLocker ml(&_mutexReset);
/*
* Here we must free the unlocked buffers first,
* then wait some time for further buffers that will
* be freed by worker threads.
*/
while (bc < _bcount && i++ < wait) {
DataBuf* buf = (DataBuf*) _psFree.pop();
if (buf) {
// get buffer id
bid = buf->getBID();
// free selected buffer
delete _bufs[bid];
// reset pointer
_bufs[bid] = NULL;
// count freed buffers
bc++;
} else {
// wait some time
Thread::sleep(50);
}
}
/*
* Timeout expired, so check which buffers are not
* returned home.
*/
for (i = 0; i < _bcount; i++) {
if (_bufs[i]) {
// DEBUG
UOSUTIL_DOUT(("BufferPool: Buffer %d is NOT NULL\n", i));
if (!_bufs[i]->isInUse()) {
// DEBUG
UOSUTIL_DOUT(("BufferPool: Buffer %d is NOT IN USE\n", i));
UOSUTIL_DOUT(("BufferPool: Buffer %d will be DELETED\n", i));
delete _bufs[i];
} else {
// DEBUG
UOSUTIL_DOUT(("BufferPool: Buffer %d is IN USE: leaked\n", i));
}
} else {
// DEBUG
UOSUTIL_DOUT(("BufferPool: Buffer %d is NULL, ignored\n", i));
}
}
/*
* Delete other objects.
*/
delete[] _bufs;
}
void FileIo::transfer(BasicIo& src)
{
const bool wasOpen = (p_->fp_ != 0);
const std::string lastMode(p_->openMode_);
FileIo *fileIo = dynamic_cast<FileIo*>(&src);
if (fileIo) {
// Optimization if src is another instance of FileIo
fileIo->close();
// Check if the file can be written to, if it already exists
if (open("a+b") != 0) {
// Remove the (temporary) file
#ifdef EXV_UNICODE_PATH
if (fileIo->p_->wpMode_ == Impl::wpUnicode) {
::_wremove(fileIo->wpath().c_str());
}
else
#endif
{
::remove(fileIo->path().c_str());
}
#ifdef EXV_UNICODE_PATH
if (p_->wpMode_ == Impl::wpUnicode) {
throw WError(10, wpath(), "a+b", strError().c_str());
}
else
#endif
{
throw Error(10, path(), "a+b", strError());
}
}
close();
bool statOk = true;
mode_t origStMode = 0;
std::string spf;
char* pf = 0;
#ifdef EXV_UNICODE_PATH
std::wstring wspf;
wchar_t* wpf = 0;
if (p_->wpMode_ == Impl::wpUnicode) {
wspf = wpath();
wpf = const_cast<wchar_t*>(wspf.c_str());
}
else
#endif
{
spf = path();
pf = const_cast<char*>(spf.c_str());
}
// Get the permissions of the file, or linked-to file, on platforms which have lstat
#ifdef EXV_HAVE_LSTAT
# ifdef EXV_UNICODE_PATH
# error EXV_UNICODE_PATH and EXV_HAVE_LSTAT are not compatible. Stop.
# endif
struct stat buf1;
if (::lstat(pf, &buf1) == -1) {
statOk = false;
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << Error(2, pf, strError(), "::lstat") << "\n";
#endif
}
origStMode = buf1.st_mode;
DataBuf lbuf; // So that the allocated memory is freed. Must have same scope as pf
// In case path() is a symlink, get the path of the linked-to file
if (statOk && S_ISLNK(buf1.st_mode)) {
lbuf.alloc(buf1.st_size + 1);
memset(lbuf.pData_, 0x0, lbuf.size_);
pf = reinterpret_cast<char*>(lbuf.pData_);
if (::readlink(path().c_str(), pf, lbuf.size_ - 1) == -1) {
throw Error(2, path(), strError(), "readlink");
}
// We need the permissions of the file, not the symlink
if (::stat(pf, &buf1) == -1) {
statOk = false;
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << Error(2, pf, strError(), "::stat") << "\n";
#endif
}
origStMode = buf1.st_mode;
}
#else // EXV_HAVE_LSTAT
Impl::StructStat buf1;
if (p_->stat(buf1) == -1) {
statOk = false;
}
origStMode = buf1.st_mode;
#endif // !EXV_HAVE_LSTAT
// MSVCRT rename that does not overwrite existing files
#ifdef EXV_UNICODE_PATH
if (p_->wpMode_ == Impl::wpUnicode) {
if (fileExists(wpf) && ::_wremove(wpf) != 0) {
throw WError(2, wpf, strError().c_str(), "::_wremove");
}
if (::_wrename(fileIo->wpath().c_str(), wpf) == -1) {
throw WError(17, fileIo->wpath(), wpf, strError().c_str());
}
::_wremove(fileIo->wpath().c_str());
// Check permissions of new file
struct _stat buf2;
if (statOk && ::_wstat(wpf, &buf2) == -1) {
statOk = false;
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << Error(2, wpf, strError(), "::_wstat") << "\n";
#endif
}
if (statOk && origStMode != buf2.st_mode) {
// Set original file permissions
if (::_wchmod(wpf, origStMode) == -1) {
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << Error(2, wpf, strError(), "::_wchmod") << "\n";
#endif
}
}
} // if (p_->wpMode_ == Impl::wpUnicode)
else
#endif // EXV_UNICODE_PATH
{
if (fileExists(pf) && ::remove(pf) != 0) {
throw Error(2, pf, strError(), "::remove");
}
if (::rename(fileIo->path().c_str(), pf) == -1) {
throw Error(17, fileIo->path(), pf, strError());
}
::remove(fileIo->path().c_str());
// Check permissions of new file
struct stat buf2;
if (statOk && ::stat(pf, &buf2) == -1) {
statOk = false;
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << Error(2, pf, strError(), "::stat") << "\n";
#endif
}
if (statOk && origStMode != buf2.st_mode) {
// Set original file permissions
if (::chmod(pf, origStMode) == -1) {
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << Error(2, pf, strError(), "::chmod") << "\n";
#endif
}
}
}
} // if (fileIo)
else {
// Generic handling, reopen both to reset to start
if (open("w+b") != 0) {
#ifdef EXV_UNICODE_PATH
if (p_->wpMode_ == Impl::wpUnicode) {
throw WError(10, wpath(), "w+b", strError().c_str());
}
else
#endif
{
throw Error(10, path(), "w+b", strError());
}
}
if (src.open() != 0) {
#ifdef EXV_UNICODE_PATH
if (p_->wpMode_ == Impl::wpUnicode) {
throw WError(9, src.wpath(), strError().c_str());
}
else
#endif
{
throw Error(9, src.path(), strError());
}
}
write(src);
src.close();
}
if (wasOpen) {
if (open(lastMode) != 0) {
#ifdef EXV_UNICODE_PATH
if (p_->wpMode_ == Impl::wpUnicode) {
throw WError(10, wpath(), lastMode.c_str(), strError().c_str());
}
else
#endif
{
throw Error(10, path(), lastMode, strError());
}
}
}
else close();
if (error() || src.error()) {
#ifdef EXV_UNICODE_PATH
if (p_->wpMode_ == Impl::wpUnicode) {
throw WError(18, wpath(), strError().c_str());
}
else
#endif
{
throw Error(18, path(), strError());
}
}
} // FileIo::transfer
DataBuf PngChunk::parsePngChunk(const byte* pData, long size, long& index, int keysize)
{
DataBuf arr;
if(!strncmp((char*)PNG_CHUNK_TYPE(pData, index), "zTXt", 4))
{
// Extract a deflate compressed Latin-1 text chunk
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::parsePngChunk: We found a zTXt field\n";
#endif
// we get the compression method after the key
const byte* compressionMethod = &PNG_CHUNK_DATA(pData, index, keysize+1);
if ( *compressionMethod != 0x00 )
{
// then it isn't zlib compressed and we are sunk
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::parsePngChunk: Non-standard zTXt compression method.\n";
#endif
throw Error(14);
}
// compressed string after the compression technique spec
const byte* compressedText = &PNG_CHUNK_DATA(pData, index, keysize+2);
unsigned int compressedTextSize = getLong(&pData[index], bigEndian)-keysize-2;
// security check, also considering overflow wraparound from the addition --
// we may endup with a /smaller/ index if we wrap all the way around
long firstIndex = (long)(compressedText - pData);
long onePastLastIndex = firstIndex + compressedTextSize;
if ( onePastLastIndex > size || onePastLastIndex <= firstIndex)
throw Error(14);
zlibUncompress(compressedText, compressedTextSize, arr);
}
else if (!strncmp((char*)PNG_CHUNK_TYPE(pData, index), "tEXt", 4))
{
// Extract a non-compressed Latin-1 text chunk
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::parsePngChunk: We found a tEXt field\n";
#endif
// the text comes after the key, but isn't null terminated
const byte* text = &PNG_CHUNK_DATA(pData, index, keysize+1);
long textsize = getLong(&pData[index], bigEndian)-keysize-1;
// security check, also considering overflow wraparound from the addition --
// we may endup with a /smaller/ index if we wrap all the way around
long firstIndex = (long)(text - pData);
long onePastLastIndex = firstIndex + textsize;
if ( onePastLastIndex > size || onePastLastIndex <= firstIndex)
throw Error(14);
arr.alloc(textsize);
arr = DataBuf(text, textsize);
}
else if(!strncmp((char*)PNG_CHUNK_TYPE(pData, index), "iTXt", 4))
{
// Extract a deflate compressed or uncompressed UTF-8 text chunk
// we get the compression flag after the key
const byte* compressionFlag = &PNG_CHUNK_DATA(pData, index, keysize+1);
// we get the compression method after the compression flag
const byte* compressionMethod = &PNG_CHUNK_DATA(pData, index, keysize+1);
// language description string after the compression technique spec
const byte* languageText = &PNG_CHUNK_DATA(pData, index, keysize+1);
unsigned int languageTextSize = getLong(&pData[index], bigEndian)-keysize-1;
// translated keyword string after the language description
const byte* translatedKeyText = &PNG_CHUNK_DATA(pData, index, keysize+1);
unsigned int translatedKeyTextSize = getLong(&pData[index], bigEndian)-keysize-1;
if ( *compressionFlag == 0x00 )
{
// then it's an uncompressed iTXt chunk
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::parsePngChunk: We found an uncompressed iTXt field\n";
#endif
// the text comes after the translated keyword, but isn't null terminated
const byte* text = &PNG_CHUNK_DATA(pData, index, keysize+1);
long textsize = getLong(&pData[index], bigEndian)-keysize-1;
// security check, also considering overflow wraparound from the addition --
// we may endup with a /smaller/ index if we wrap all the way around
long firstIndex = (long)(text - pData);
long onePastLastIndex = firstIndex + textsize;
if ( onePastLastIndex > size || onePastLastIndex <= firstIndex)
throw Error(14);
arr.alloc(textsize);
arr = DataBuf(text, textsize);
}
else if ( *compressionMethod == 0x00 )
{
// then it's a zlib compressed iTXt chunk
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::parsePngChunk: We found a zlib compressed iTXt field\n";
#endif
// the compressed text comes after the translated keyword, but isn't null terminated
const byte* compressedText = &PNG_CHUNK_DATA(pData, index, keysize+1);
long compressedTextSize = getLong(&pData[index], bigEndian)-keysize-1;
// security check, also considering overflow wraparound from the addition --
// we may endup with a /smaller/ index if we wrap all the way around
long firstIndex = (long)(compressedText - pData);
long onePastLastIndex = firstIndex + compressedTextSize;
if ( onePastLastIndex > size || onePastLastIndex <= firstIndex)
throw Error(14);
zlibUncompress(compressedText, compressedTextSize, arr);
}
else
{
// then it isn't zlib compressed and we are sunk
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::parsePngChunk: Non-standard iTXt compression method.\n";
#endif
throw Error(14);
}
}
else
{
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::parsePngChunk: We found a field, not expected though\n";
#endif
throw Error(14);
}
return arr;
} // PngChunk::parsePngChunk
DataBuf PngChunk::readRawProfile(const DataBuf& text)
{
DataBuf info;
register long i;
register unsigned char *dp;
const char *sp;
unsigned int nibbles;
long length;
unsigned char unhex[103]={0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,1, 2,3,4,5,6,7,8,9,0,0,
0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,10,11,12,
13,14,15};
sp = (char*)text.pData_+1;
// Look for newline
while (*sp != '\n')
sp++;
// Look for length
while (*sp == '\0' || *sp == ' ' || *sp == '\n')
sp++;
length = (long) atol(sp);
while (*sp != ' ' && *sp != '\n')
sp++;
// Allocate space
if (length == 0)
{
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::readRawProfile: Unable To Copy Raw Profile: invalid profile length\n";
#endif
return DataBuf();
}
info.alloc(length);
if (info.size_ != length)
{
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::readRawProfile: Unable To Copy Raw Profile: cannot allocate memory\n";
#endif
return DataBuf();
}
// Copy profile, skipping white space and column 1 "=" signs
dp = (unsigned char*)info.pData_;
nibbles = length * 2;
for (i = 0; i < (long) nibbles; i++)
{
while (*sp < '0' || (*sp > '9' && *sp < 'a') || *sp > 'f')
{
if (*sp == '\0')
{
#ifdef DEBUG
std::cerr << "Exiv2::PngChunk::readRawProfile: Unable To Copy Raw Profile: ran out of data\n";
#endif
return DataBuf();
}
sp++;
}
if (i%2 == 0)
*dp = (unsigned char) (16*unhex[(int) *sp++]);
else
(*dp++) += unhex[(int) *sp++];
}
return info;
} // PngChunk::readRawProfile
void FileIo::transfer(BasicIo& src)
{
const bool wasOpen = (fp_ != 0);
const std::string lastMode(openMode_);
FileIo *fileIo = dynamic_cast<FileIo*>(&src);
if (fileIo) {
// Optimization if src is another instance of FileIo
fileIo->close();
// Check if the file can be written to, if it already exists
if (open("w+b") != 0) {
// Remove the (temporary) file
std::remove(fileIo->path_.c_str());
throw Error(10, path_, "w+b", strError());
}
close();
bool statOk = true;
struct stat buf1;
char* pf = const_cast<char*>(path_.c_str());
#ifdef EXV_HAVE_LSTAT
if (::lstat(pf, &buf1) == -1) {
statOk = false;
#ifndef SUPPRESS_WARNINGS
std::cerr << "Warning: " << Error(2, pf, strError(), "lstat") << "\n";
#endif
}
DataBuf lbuf; // So that the allocated memory is freed. Must have same scope as pf
// In case path_ is a symlink, get the path of the linked-to file
if (statOk && S_ISLNK(buf1.st_mode)) {
lbuf.alloc(buf1.st_size + 1);
memset(lbuf.pData_, 0x0, lbuf.size_);
pf = reinterpret_cast<char*>(lbuf.pData_);
if (readlink(path_.c_str(), pf, lbuf.size_ - 1) == -1) {
throw Error(2, path_, strError(), "readlink");
}
// We need the permissions of the file, not the symlink
if (::stat(pf, &buf1) == -1) {
statOk = false;
#ifndef SUPPRESS_WARNINGS
std::cerr << "Warning: " << Error(2, pf, strError(), "stat") << "\n";
#endif
}
}
#else
if (::stat(pf, &buf1) == -1) {
statOk = false;
#ifndef SUPPRESS_WARNINGS
std::cerr << "Warning: " << Error(2, pf, strError(), "stat") << "\n";
#endif
}
#endif // !EXV_HAVE_LSTAT
// MSVCRT rename that does not overwrite existing files
if (fileExists(pf) && std::remove(pf) != 0) {
throw Error(2, pf, strError(), "std::remove");
}
if (std::rename(fileIo->path_.c_str(), pf) == -1) {
throw Error(17, fileIo->path_, pf, strError());
}
std::remove(fileIo->path_.c_str());
// Check permissions of new file
struct stat buf2;
if (statOk && ::stat(pf, &buf2) == -1) {
statOk = false;
#ifndef SUPPRESS_WARNINGS
std::cerr << "Warning: " << Error(2, pf, strError(), "stat") << "\n";
#endif
}
if (statOk && buf1.st_mode != buf2.st_mode) {
// Set original file permissions
if (::chmod(pf, buf1.st_mode) == -1) {
#ifndef SUPPRESS_WARNINGS
std::cerr << "Warning: " << Error(2, pf, strError(), "chmod") << "\n";
#endif
}
}
}
else {
// Generic handling, reopen both to reset to start
if (open("w+b") != 0) {
throw Error(10, path_, "w+b", strError());
}
if (src.open() != 0) {
throw Error(9, src.path(), strError());
}
write(src);
src.close();
}
if (wasOpen) {
if (open(lastMode) != 0) {
throw Error(10, path_, lastMode, strError());
}
}
else close();
if (error() || src.error()) throw Error(18, path_, strError());
}
void JpegBase::doWriteMetadata(BasicIo& outIo)
{
if (!io_->isopen()) throw Error(20);
if (!outIo.isopen()) throw Error(21);
// Ensure that this is the correct image type
if (!isThisType(*io_, true)) {
if (io_->error() || io_->eof()) throw Error(20);
throw Error(22);
}
const long bufMinSize = 36;
long bufRead = 0;
DataBuf buf(bufMinSize);
const long seek = io_->tell();
int count = 0;
int search = 0;
int insertPos = 0;
int comPos = 0;
int skipApp1Exif = -1;
int skipApp1Xmp = -1;
int skipApp13Ps3 = -1;
int skipCom = -1;
DataBuf psData;
DataBuf rawExif;
// Write image header
if (writeHeader(outIo)) throw Error(21);
// Read section marker
int marker = advanceToMarker();
if (marker < 0) throw Error(22);
// First find segments of interest. Normally app0 is first and we want
// to insert after it. But if app0 comes after com, app1 and app13 then
// don't bother.
while (marker != sos_ && marker != eoi_ && search < 5) {
// Read size and signature (ok if this hits EOF)
bufRead = io_->read(buf.pData_, bufMinSize);
if (io_->error()) throw Error(20);
uint16_t size = getUShort(buf.pData_, bigEndian);
if (marker == app0_) {
if (size < 2) throw Error(22);
insertPos = count + 1;
if (io_->seek(size-bufRead, BasicIo::cur)) throw Error(22);
}
else if ( skipApp1Exif == -1
&& marker == app1_ && memcmp(buf.pData_ + 2, exifId_, 6) == 0) {
if (size < 8) throw Error(22);
skipApp1Exif = count;
++search;
// Seek to beginning and read the current Exif data
io_->seek(8 - bufRead, BasicIo::cur);
rawExif.alloc(size - 8);
io_->read(rawExif.pData_, rawExif.size_);
if (io_->error() || io_->eof()) throw Error(22);
}
else if (marker == app1_ && memcmp(buf.pData_ + 2, xmpId_, 29) == 0) {
if (size < 31) throw Error(22);
skipApp1Xmp = count;
++search;
if (io_->seek(size-bufRead, BasicIo::cur)) throw Error(22);
}
else if (marker == app13_ && memcmp(buf.pData_ + 2, Photoshop::ps3Id_, 14) == 0) {
#ifdef DEBUG
std::cerr << "Found APP13 Photoshop PS3 segment\n";
#endif
if (size < 16) throw Error(22);
skipApp13Ps3 = count;
++search;
io_->seek(16 - bufRead, BasicIo::cur);
psData.alloc(size - 16);
// Load PS data now to allow reinsertion at any point
io_->read(psData.pData_, size - 16);
if (io_->error() || io_->eof()) throw Error(20);
}
else if (marker == com_ && skipCom == -1) {
if (size < 2) throw Error(22);
// Jpegs can have multiple comments, but for now only handle
// the first one (most jpegs only have one anyway).
skipCom = count;
++search;
if (io_->seek(size-bufRead, BasicIo::cur)) throw Error(22);
}
else {
if (size < 2) throw Error(22);
if (io_->seek(size-bufRead, BasicIo::cur)) throw Error(22);
}
// As in jpeg-6b/wrjpgcom.c:
// We will insert the new comment marker just before SOFn.
// This (a) causes the new comment to appear after, rather than before,
// existing comments; and (b) ensures that comments come after any JFIF
// or JFXX markers, as required by the JFIF specification.
if ( comPos == 0
&& ( marker == sof0_
|| marker == sof1_
|| marker == sof2_
|| marker == sof3_
|| marker == sof5_
|| marker == sof6_
|| marker == sof7_
|| marker == sof9_
|| marker == sof10_
|| marker == sof11_
|| marker == sof13_
|| marker == sof14_
|| marker == sof15_)) {
comPos = count;
++search;
}
marker = advanceToMarker();
if (marker < 0) throw Error(22);
++count;
}
if (comPos == 0) {
if (marker == eoi_) comPos = count;
else comPos = insertPos;
++search;
}
if (exifData_.count() > 0) ++search;
if (writeXmpFromPacket() == false && xmpData_.count() > 0) ++search;
if (writeXmpFromPacket() == true && xmpPacket_.size() > 0) ++search;
if (iptcData_.count() > 0) ++search;
if (!comment_.empty()) ++search;
io_->seek(seek, BasicIo::beg);
count = 0;
marker = advanceToMarker();
if (marker < 0) throw Error(22);
// To simplify this a bit, new segments are inserts at either the start
// or right after app0. This is standard in most jpegs, but has the
// potential to change segment ordering (which is allowed).
// Segments are erased if there is no assigned metadata.
while (marker != sos_ && search > 0) {
// Read size and signature (ok if this hits EOF)
bufRead = io_->read(buf.pData_, bufMinSize);
if (io_->error()) throw Error(20);
// Careful, this can be a meaningless number for empty
// images with only an eoi_ marker
uint16_t size = getUShort(buf.pData_, bigEndian);
if (insertPos == count) {
byte tmpBuf[64];
// Write Exif data first so that - if there is no app0 - we
// create "Exif images" according to the Exif standard.
if (exifData_.count() > 0) {
Blob blob;
ByteOrder bo = byteOrder();
if (bo == invalidByteOrder) {
bo = littleEndian;
setByteOrder(bo);
}
WriteMethod wm = ExifParser::encode(blob,
rawExif.pData_,
rawExif.size_,
bo,
exifData_);
const byte* pExifData = rawExif.pData_;
uint32_t exifSize = rawExif.size_;
if (wm == wmIntrusive) {
pExifData = blob.size() > 0 ? &blob[0] : 0;
exifSize = static_cast<uint32_t>(blob.size());
}
if (exifSize > 0) {
// Write APP1 marker, size of APP1 field, Exif id and Exif data
tmpBuf[0] = 0xff;
tmpBuf[1] = app1_;
if (exifSize + 8 > 0xffff) throw Error(37, "Exif");
us2Data(tmpBuf + 2, static_cast<uint16_t>(exifSize + 8), bigEndian);
std::memcpy(tmpBuf + 4, exifId_, 6);
if (outIo.write(tmpBuf, 10) != 10) throw Error(21);
// Write new Exif data buffer
if ( outIo.write(pExifData, exifSize)
!= static_cast<long>(exifSize)) throw Error(21);
if (outIo.error()) throw Error(21);
--search;
}
}
if (writeXmpFromPacket() == false) {
if (XmpParser::encode(xmpPacket_, xmpData_) > 1) {
#ifndef SUPPRESS_WARNINGS
std::cerr << "Error: Failed to encode XMP metadata.\n";
#endif
}
}
if (xmpPacket_.size() > 0) {
// Write APP1 marker, size of APP1 field, XMP id and XMP packet
tmpBuf[0] = 0xff;
tmpBuf[1] = app1_;
if (xmpPacket_.size() + 31 > 0xffff) throw Error(37, "XMP");
us2Data(tmpBuf + 2, static_cast<uint16_t>(xmpPacket_.size() + 31), bigEndian);
std::memcpy(tmpBuf + 4, xmpId_, 29);
if (outIo.write(tmpBuf, 33) != 33) throw Error(21);
// Write new XMP packet
if ( outIo.write(reinterpret_cast<const byte*>(xmpPacket_.data()), static_cast<long>(xmpPacket_.size()))
!= static_cast<long>(xmpPacket_.size())) throw Error(21);
if (outIo.error()) throw Error(21);
--search;
}
if (psData.size_ > 0 || iptcData_.count() > 0) {
// Set the new IPTC IRB, keeps existing IRBs but removes the
// IPTC block if there is no new IPTC data to write
DataBuf newPsData = Photoshop::setIptcIrb(psData.pData_,
psData.size_,
iptcData_);
if (newPsData.size_ > 0) {
// Write APP13 marker, new size, and ps3Id
tmpBuf[0] = 0xff;
tmpBuf[1] = app13_;
if (newPsData.size_ + 16 > 0xffff) throw Error(37, "IPTC");
us2Data(tmpBuf + 2, static_cast<uint16_t>(newPsData.size_ + 16), bigEndian);
std::memcpy(tmpBuf + 4, Photoshop::ps3Id_, 14);
if (outIo.write(tmpBuf, 18) != 18) throw Error(21);
if (outIo.error()) throw Error(21);
// Write new Photoshop IRB data buffer
if ( outIo.write(newPsData.pData_, newPsData.size_)
!= newPsData.size_) throw Error(21);
if (outIo.error()) throw Error(21);
}
if (iptcData_.count() > 0) {
--search;
}
}
}
if (comPos == count) {
if (!comment_.empty()) {
byte tmpBuf[4];
// Write COM marker, size of comment, and string
tmpBuf[0] = 0xff;
tmpBuf[1] = com_;
if (comment_.length() + 3 > 0xffff) throw Error(37, "JPEG comment");
us2Data(tmpBuf + 2, static_cast<uint16_t>(comment_.length() + 3), bigEndian);
if (outIo.write(tmpBuf, 4) != 4) throw Error(21);
if (outIo.write((byte*)comment_.data(), (long)comment_.length())
!= (long)comment_.length()) throw Error(21);
if (outIo.putb(0)==EOF) throw Error(21);
if (outIo.error()) throw Error(21);
--search;
}
--search;
}
if (marker == eoi_) {
break;
}
else if ( skipApp1Exif == count
|| skipApp1Xmp == count
|| skipApp13Ps3 == count
|| skipCom == count) {
--search;
io_->seek(size-bufRead, BasicIo::cur);
}
else {
if (size < 2) throw Error(22);
buf.alloc(size+2);
io_->seek(-bufRead-2, BasicIo::cur);
io_->read(buf.pData_, size+2);
if (io_->error() || io_->eof()) throw Error(20);
if (outIo.write(buf.pData_, size+2) != size+2) throw Error(21);
if (outIo.error()) throw Error(21);
}
// Next marker
marker = advanceToMarker();
if (marker < 0) throw Error(22);
++count;
}
// Copy rest of the Io
io_->seek(-2, BasicIo::cur);
buf.alloc(4096);
long readSize = 0;
while ((readSize=io_->read(buf.pData_, buf.size_))) {
if (outIo.write(buf.pData_, readSize) != readSize) throw Error(21);
}
if (outIo.error()) throw Error(21);
} // JpegBase::doWriteMetadata
DataBuf::DataBuf(DataBuf& rhs)
: pData_(rhs.pData_), size_(rhs.size_)
{
rhs.release();
}
void Jp2Image::readMetadata()
{
#ifdef DEBUG
std::cerr << "Exiv2::Jp2Image::readMetadata: Reading JPEG-2000 file " << io_->path() << "\n";
#endif
if (io_->open() != 0)
{
throw Error(9, io_->path(), strError());
}
IoCloser closer(*io_);
// Ensure that this is the correct image type
if (!isJp2Type(*io_, true))
{
if (io_->error() || io_->eof()) throw Error(14);
throw Error(3, "JPEG-2000");
}
long position = 0;
Jp2BoxHeader box = {0,0};
Jp2BoxHeader subBox = {0,0};
Jp2ImageHeaderBox ihdr = {0,0,0,0,0,0,0,0};
Jp2UuidBox uuid = {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
while (io_->read((byte*)&box, sizeof(box)) == sizeof(box))
{
position = io_->tell();
box.boxLength = getLong((byte*)&box.boxLength, bigEndian);
#ifdef DEBUG
std::cout << "Exiv2::Jp2Image::readMetadata: Position: " << position << "\n";
std::cout << "Exiv2::Jp2Image::readMetadata: Find box type: " << std::string((const char*)&box.boxType)
<< " lenght: " << box.boxLength << "\n";
#endif
box.boxType = getLong((byte*)&box.boxType, bigEndian);
if (box.boxLength == 0)
{
#ifdef DEBUG
std::cout << "Exiv2::Jp2Image::readMetadata: Null Box size has been found. "
"This is the last box of file.\n";
#endif
return;
}
if (box.boxLength == 1)
{
// FIXME. Special case. the real box size is given in another place.
}
switch(box.boxType)
{
case kJp2BoxTypeJp2Header:
{
#ifdef DEBUG
std::cout << "Exiv2::Jp2Image::readMetadata: JP2Header box found\n";
#endif
if (io_->read((byte*)&subBox, sizeof(subBox)) == sizeof(subBox))
{
subBox.boxLength = getLong((byte*)&subBox.boxLength, bigEndian);
subBox.boxType = getLong((byte*)&subBox.boxType, bigEndian);
if((subBox.boxType == kJp2BoxTypeImageHeader) &&
(io_->read((byte*)&ihdr, sizeof(ihdr)) == sizeof(ihdr)))
{
#ifdef DEBUG
std::cout << "Exiv2::Jp2Image::readMetadata: Ihdr data found\n";
#endif
ihdr.imageHeight = getLong((byte*)&ihdr.imageHeight, bigEndian);
ihdr.imageWidth = getLong((byte*)&ihdr.imageWidth, bigEndian);
ihdr.componentCount = getShort((byte*)&ihdr.componentCount, bigEndian);
ihdr.compressionTypeProfile = getShort((byte*)&ihdr.compressionTypeProfile, bigEndian);
pixelWidth_ = ihdr.imageWidth;
pixelHeight_ = ihdr.imageHeight;
}
}
break;
}
case kJp2BoxTypeUuid:
{
#ifdef DEBUG
std::cout << "Exiv2::Jp2Image::readMetadata: UUID box found\n";
#endif
if (io_->read((byte*)&uuid, sizeof(uuid)) == sizeof(uuid))
{
DataBuf rawData;
long bufRead;
if(memcmp(uuid.uuid, kJp2UuidExif, sizeof(uuid)) == 0)
{
#ifdef DEBUG
std::cout << "Exiv2::Jp2Image::readMetadata: Exif data found\n";
#endif
// we've hit an embedded Exif block
rawData.alloc(box.boxLength - (sizeof(box) + sizeof(uuid)));
bufRead = io_->read(rawData.pData_, rawData.size_);
if (io_->error()) throw Error(14);
if (bufRead != rawData.size_) throw Error(20);
if (rawData.size_ > 0)
{
// Find the position of Exif header in bytes array.
const byte exifHeader[] = { 0x45, 0x78, 0x69, 0x66, 0x00, 0x00 };
long pos = -1;
for (long i=0 ; i < rawData.size_-(long)sizeof(exifHeader) ; i++)
{
if (memcmp(exifHeader, &rawData.pData_[i], sizeof(exifHeader)) == 0)
{
pos = i;
break;
}
}
// If found it, store only these data at from this place.
if (pos !=-1)
{
#ifdef DEBUG
std::cout << "Exiv2::Jp2Image::readMetadata: Exif header found at position " << pos << "\n";
#endif
pos = pos + sizeof(exifHeader);
ByteOrder bo = TiffParser::decode(exifData(),
iptcData(),
xmpData(),
rawData.pData_ + pos,
rawData.size_ - pos);
setByteOrder(bo);
}
}
else
{
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Failed to decode Exif metadata.\n";
#endif
exifData_.clear();
}
}
else if(memcmp(uuid.uuid, kJp2UuidIptc, sizeof(uuid)) == 0)
{
// we've hit an embedded IPTC block
#ifdef DEBUG
std::cout << "Exiv2::Jp2Image::readMetadata: Iptc data found\n";
#endif
rawData.alloc(box.boxLength - (sizeof(box) + sizeof(uuid)));
bufRead = io_->read(rawData.pData_, rawData.size_);
if (io_->error()) throw Error(14);
if (bufRead != rawData.size_) throw Error(20);
if (IptcParser::decode(iptcData_, rawData.pData_, rawData.size_))
{
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Failed to decode IPTC metadata.\n";
#endif
iptcData_.clear();
}
}
else if(memcmp(uuid.uuid, kJp2UuidXmp, sizeof(uuid)) == 0)
{
// we've hit an embedded XMP block
#ifdef DEBUG
std::cout << "Exiv2::Jp2Image::readMetadata: Xmp data found\n";
#endif
rawData.alloc(box.boxLength - (sizeof(box) + sizeof(uuid)));
bufRead = io_->read(rawData.pData_, rawData.size_);
if (io_->error()) throw Error(14);
if (bufRead != rawData.size_) throw Error(20);
xmpPacket_.assign(reinterpret_cast<char *>(rawData.pData_), rawData.size_);
std::string::size_type idx = xmpPacket_.find_first_of('<');
if (idx != std::string::npos && idx > 0)
{
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Removing " << static_cast<uint32_t>(idx)
<< " characters from the beginning of the XMP packet\n";
#endif
xmpPacket_ = xmpPacket_.substr(idx);
}
if (xmpPacket_.size() > 0 && XmpParser::decode(xmpData_, xmpPacket_))
{
#ifndef SUPPRESS_WARNINGS
EXV_WARNING << "Failed to decode XMP metadata.\n";
#endif
}
}
}
break;
}
default:
{
break;
}
}
// Move to the next box.
io_->seek(static_cast<long>(position - sizeof(box) + box.boxLength), BasicIo::beg);
if (io_->error() || io_->eof()) throw Error(14);
}
} // Jp2Image::readMetadata
int32 Interp::runFile(char* filename, uint32 linesz, void* context)
{
DataBuf dbLine;
FILE* fin = NULL;
char* param_string = NULL;
char* token = NULL;
char* line = NULL;
uint32 current_line = 1;
int32 ret = 0, out = 0, k = 0;
ret = dbLine.init(linesz);
if (ret == FAILURE)
return FAILURE;
dbLine.set(0);
dbLine.setCount(0);
dbLine.setLimit(2 * 1024 * 1024);
line = dbLine.toString();
fin = fopen(filename, "r");
if (!fin)
return FAILURE;
while (1) {
/* get a line */
out = Utils::getDelim(line, linesz, '\n', fin);
if (out < 0)
break;
/* remove '\n' and blanks */
while (--out && isspace(toascii(line[out])))
line[out] = 0;
/* remove blanks */
k = (int32) strlen(line);
while (k && isspace(toascii(*line))) {
k--; line++;
}
/* remove empty lines and comments */
if (line[0] == '#' || line[0] == '\0') {
current_line++; continue;
}
/* execute instruction */
param_string = line;
token = Utils::getToken(¶m_string, " \t");
if (token) {
ret = run(token, param_string, context);
switch (ret) {
case BADCOMMAND:
case PARAMPARSINGERROR:
case WRONGPARAMCOUNT:
case PERMISSIONDENIED:
sysHandler(token, current_line, ret, context);
return FAILURE;
default:
usrHandler(token, current_line, ret, context);
}
current_line++;
} else {
current_line++;
continue;
}
}
fclose(fin);
return SUCCESS;
}
