void DoRead(void* data, uint32 count, uint64 offset) override {
size_t sum;
if (!safe_add_to_size_t(static_cast<uint64>(count), offset, &sum) ||
!fStream->read(data, static_cast<size_t>(offset), static_cast<size_t>(count))) {
ThrowReadFile();
}
}
SkMemoryStream* transferBuffer(size_t offset, size_t size) override {
SkAutoTUnref<SkData> data(SkData::NewUninitialized(size));
if (offset > fStreamBuffer.bytesWritten()) {
// If the offset is not buffered, read from fStream directly and skip the buffering.
const size_t skipLength = offset - fStreamBuffer.bytesWritten();
if (fStream->skip(skipLength) != skipLength) {
return nullptr;
}
const size_t bytesRead = fStream->read(data->writable_data(), size);
if (bytesRead < size) {
data.reset(SkData::NewSubset(data.get(), 0, bytesRead));
}
} else {
const size_t alreadyBuffered = SkTMin(fStreamBuffer.bytesWritten() - offset, size);
if (alreadyBuffered > 0 &&
!fStreamBuffer.read(data->writable_data(), offset, alreadyBuffered)) {
return nullptr;
}
const size_t remaining = size - alreadyBuffered;
if (remaining) {
auto* dst = static_cast<uint8_t*>(data->writable_data()) + alreadyBuffered;
const size_t bytesRead = fStream->read(dst, remaining);
size_t newSize;
if (bytesRead < remaining) {
if (!safe_add_to_size_t(alreadyBuffered, bytesRead, &newSize)) {
return nullptr;
}
data.reset(SkData::NewSubset(data.get(), 0, newSize));
}
}
}
return new SkMemoryStream(data);
}
SkMemoryStream* transferBuffer(size_t offset, size_t size) override {
if (fStream->getLength() < offset) {
return nullptr;
}
size_t sum;
if (!safe_add_to_size_t(offset, size, &sum)) {
return nullptr;
}
// This will allow read less than the requested "size", because the JPEG codec wants to
// handle also a partial JPEG file.
const size_t bytesToRead = SkTMin(sum, fStream->getLength()) - offset;
if (bytesToRead == 0) {
return nullptr;
}
if (fStream->getMemoryBase()) { // directly copy if getMemoryBase() is available.
SkAutoTUnref<SkData> data(SkData::NewWithCopy(
static_cast<const uint8_t*>(fStream->getMemoryBase()) + offset, bytesToRead));
fStream.reset();
return new SkMemoryStream(data);
} else {
SkAutoTUnref<SkData> data(SkData::NewUninitialized(bytesToRead));
if (!fStream->seek(offset)) {
return nullptr;
}
const size_t bytesRead = fStream->read(data->writable_data(), bytesToRead);
if (bytesRead < bytesToRead) {
data.reset(SkData::NewSubset(data.get(), 0, bytesRead));
}
return new SkMemoryStream(data);
}
}
bool write(const void* buffer, size_t size) override {
size_t newSize;
if (!safe_add_to_size_t(this->bytesWritten(), size, &newSize) ||
newSize > kMaxStreamSize)
{
SkCodecPrintf("Error: Stream size exceeds the limit.\n");
return false;
}
return this->INHERITED::write(buffer, size);
}
bool read(void* data, size_t offset, size_t length) override {
if (length == 0) {
return true;
}
size_t sum;
if (!safe_add_to_size_t(offset, length, &sum)) {
return false;
}
return fStream->seek(offset) && (fStream->read(data, length) == length);
}
bool read(void* data, size_t offset, size_t length) override {
if (length == 0) {
return true;
}
size_t sum;
if (!safe_add_to_size_t(offset, length, &sum)) {
return false;
}
return this->bufferMoreData(sum) && fStreamBuffer.read(data, offset, length);
}
// For dng_stream
void read(void* data, uint32 count, uint64 offset) {
if (count == 0 && offset == 0) {
return;
}
size_t sum;
if (!safe_add_to_size_t(static_cast<uint64>(count), offset, &sum) ||
!this->bufferMoreData(sum)) {
ThrowReadFile();
}
if (!fStreamBuffer.read(data, static_cast<size_t>(offset), count)) {
ThrowReadFile();
}
}
// For PIEX
::piex::Error GetData(const size_t offset, const size_t length,
uint8* data) override {
if (offset == 0 && length == 0) {
return ::piex::Error::kOk;
}
size_t sum;
if (!safe_add_to_size_t(offset, length, &sum) || !this->bufferMoreData(sum)) {
return ::piex::Error::kFail;
}
if (!fStreamBuffer.read(data, offset, length)) {
return ::piex::Error::kFail;
}
return ::piex::Error::kOk;
}
