// Copyright 2017 PDFium Authors. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
|
|
#include "core/fxcrt/cfx_memorystream.h"
|
|
#include <algorithm>
|
|
#include "core/fxcrt/fx_safe_types.h"
|
|
namespace {
|
|
const int32_t kBlockSize = 64 * 1024;
|
|
} // namespace
|
|
CFX_MemoryStream::CFX_MemoryStream(bool bConsecutive)
|
: m_nTotalSize(0),
|
m_nCurSize(0),
|
m_nCurPos(0),
|
m_nGrowSize(kBlockSize),
|
m_dwFlags(Type::kTakeOver | (bConsecutive ? Type::kConsecutive : 0)) {}
|
|
CFX_MemoryStream::CFX_MemoryStream(uint8_t* pBuffer,
|
size_t nSize,
|
bool bTakeOver)
|
: m_nTotalSize(nSize),
|
m_nCurSize(nSize),
|
m_nCurPos(0),
|
m_nGrowSize(kBlockSize),
|
m_dwFlags(Type::kConsecutive | (bTakeOver ? Type::kTakeOver : 0)) {
|
m_Blocks.push_back(pBuffer);
|
}
|
|
CFX_MemoryStream::~CFX_MemoryStream() {
|
if (m_dwFlags & Type::kTakeOver) {
|
for (uint8_t* pBlock : m_Blocks)
|
FX_Free(pBlock);
|
}
|
}
|
|
FX_FILESIZE CFX_MemoryStream::GetSize() {
|
return static_cast<FX_FILESIZE>(m_nCurSize);
|
}
|
|
bool CFX_MemoryStream::IsEOF() {
|
return m_nCurPos >= static_cast<size_t>(GetSize());
|
}
|
|
FX_FILESIZE CFX_MemoryStream::GetPosition() {
|
return static_cast<FX_FILESIZE>(m_nCurPos);
|
}
|
|
bool CFX_MemoryStream::Flush() {
|
return true;
|
}
|
|
bool CFX_MemoryStream::ReadBlock(void* buffer,
|
FX_FILESIZE offset,
|
size_t size) {
|
if (!buffer || !size || offset < 0)
|
return false;
|
|
FX_SAFE_SIZE_T newPos = size;
|
newPos += offset;
|
if (!newPos.IsValid() || newPos.ValueOrDefault(0) == 0 ||
|
newPos.ValueOrDie() > m_nCurSize) {
|
return false;
|
}
|
|
m_nCurPos = newPos.ValueOrDie();
|
if (m_dwFlags & Type::kConsecutive) {
|
memcpy(buffer, m_Blocks[0] + static_cast<size_t>(offset), size);
|
return true;
|
}
|
|
size_t nStartBlock = static_cast<size_t>(offset) / m_nGrowSize;
|
offset -= static_cast<FX_FILESIZE>(nStartBlock * m_nGrowSize);
|
while (size) {
|
size_t nRead = std::min(size, m_nGrowSize - static_cast<size_t>(offset));
|
memcpy(buffer, m_Blocks[nStartBlock] + offset, nRead);
|
buffer = static_cast<uint8_t*>(buffer) + nRead;
|
size -= nRead;
|
++nStartBlock;
|
offset = 0;
|
}
|
return true;
|
}
|
|
size_t CFX_MemoryStream::ReadBlock(void* buffer, size_t size) {
|
if (m_nCurPos >= m_nCurSize)
|
return 0;
|
|
size_t nRead = std::min(size, m_nCurSize - m_nCurPos);
|
if (!ReadBlock(buffer, static_cast<int32_t>(m_nCurPos), nRead))
|
return 0;
|
|
return nRead;
|
}
|
|
bool CFX_MemoryStream::WriteBlock(const void* buffer,
|
FX_FILESIZE offset,
|
size_t size) {
|
if (!buffer || !size)
|
return false;
|
|
if (m_dwFlags & Type::kConsecutive) {
|
FX_SAFE_SIZE_T newPos = size;
|
newPos += offset;
|
if (!newPos.IsValid())
|
return false;
|
|
m_nCurPos = newPos.ValueOrDie();
|
if (m_nCurPos > m_nTotalSize) {
|
m_nTotalSize = (m_nCurPos + m_nGrowSize - 1) / m_nGrowSize * m_nGrowSize;
|
if (m_Blocks.empty())
|
m_Blocks.push_back(FX_Alloc(uint8_t, m_nTotalSize));
|
else
|
m_Blocks[0] = FX_Realloc(uint8_t, m_Blocks[0], m_nTotalSize);
|
}
|
|
memcpy(m_Blocks[0] + offset, buffer, size);
|
m_nCurSize = std::max(m_nCurSize, m_nCurPos);
|
|
return true;
|
}
|
|
FX_SAFE_SIZE_T newPos = size;
|
newPos += offset;
|
if (!newPos.IsValid())
|
return false;
|
if (!ExpandBlocks(newPos.ValueOrDie()))
|
return false;
|
|
m_nCurPos = newPos.ValueOrDie();
|
size_t nStartBlock = static_cast<size_t>(offset) / m_nGrowSize;
|
offset -= static_cast<FX_FILESIZE>(nStartBlock * m_nGrowSize);
|
while (size) {
|
size_t nWrite = std::min(size, m_nGrowSize - static_cast<size_t>(offset));
|
memcpy(m_Blocks[nStartBlock] + offset, buffer, nWrite);
|
buffer = static_cast<const uint8_t*>(buffer) + nWrite;
|
size -= nWrite;
|
++nStartBlock;
|
offset = 0;
|
}
|
return true;
|
}
|
|
void CFX_MemoryStream::EstimateSize(size_t nInitSize, size_t nGrowSize) {
|
if (m_dwFlags & Type::kConsecutive) {
|
if (m_Blocks.empty()) {
|
m_Blocks.push_back(
|
FX_Alloc(uint8_t, std::max(nInitSize, static_cast<size_t>(4096))));
|
}
|
m_nGrowSize = std::max(nGrowSize, static_cast<size_t>(4096));
|
} else if (m_Blocks.empty()) {
|
m_nGrowSize = std::max(nGrowSize, static_cast<size_t>(4096));
|
}
|
}
|
|
void CFX_MemoryStream::AttachBuffer(uint8_t* pBuffer, size_t nSize) {
|
if (!(m_dwFlags & Type::kConsecutive))
|
return;
|
|
m_Blocks.clear();
|
m_Blocks.push_back(pBuffer);
|
m_nTotalSize = nSize;
|
m_nCurSize = nSize;
|
m_nCurPos = 0;
|
m_dwFlags = Type::kConsecutive;
|
}
|
|
void CFX_MemoryStream::DetachBuffer() {
|
if (!(m_dwFlags & Type::kConsecutive))
|
return;
|
|
m_Blocks.clear();
|
m_nTotalSize = 0;
|
m_nCurSize = 0;
|
m_nCurPos = 0;
|
m_dwFlags = Type::kTakeOver;
|
}
|
|
bool CFX_MemoryStream::ExpandBlocks(size_t size) {
|
m_nCurSize = std::max(m_nCurSize, size);
|
if (size <= m_nTotalSize)
|
return true;
|
|
size = (size - m_nTotalSize + m_nGrowSize - 1) / m_nGrowSize;
|
size_t iCount = m_Blocks.size();
|
m_Blocks.resize(iCount + size);
|
while (size--) {
|
m_Blocks[iCount++] = FX_Alloc(uint8_t, m_nGrowSize);
|
m_nTotalSize += m_nGrowSize;
|
}
|
return true;
|
}
|
