BufferPtr ShmPool::findBuffer(const QSize &size, quint32 stride, Shm::Format format)
{
Q_D(ShmPool);
auto it = d->reuseBuffer(size, stride, format);
if (it == d->buffers.end())
return BufferPtr();
return BufferPtr(*it);
}
T Serializer::Deserialize ()
{
uint64 size;
DataStream->ReadCompleteBuffer (BufferPtr ((byte *) &size, sizeof (size)));
if (Endian::Big (size) != sizeof (T))
throw ParameterIncorrect (SRC_POS);
T data;
DataStream->ReadCompleteBuffer (BufferPtr ((byte *) &data, sizeof (data)));
return Endian::Big (data);
}
BufferPtr ShmPool::createBuffer(const QImage &image)
{
Q_D(ShmPool);
if (image.isNull())
return BufferPtr();
auto it = d->reuseBuffer(image.size(), image.bytesPerLine(),
static_cast<Shm::Format>(ShmFormats::fromQt(image.format())));
if (it == d->buffers.end())
return BufferPtr();
(*it)->copy(image.bits());
return BufferPtr(*it);
}
BufferPtr ShmPool::createBuffer(const QSize &size, quint32 stride, const void *source, Shm::Format format)
{
Q_D(ShmPool);
if (size.isEmpty())
return BufferPtr();
auto it = d->reuseBuffer(size, stride, format);
if (it == d->buffers.end())
return BufferPtr();
if (source)
(*it)->copy(source);
return BufferPtr(*it);
}
BufferPtr UGraphicsDevice::CreateBuffer(const void* inRawData, int inRawDataSize, D3D11_BIND_FLAG inBindFlags, uint32_t inCPUAccessFlags, D3D11_USAGE inUsage)
{
D3D11_BUFFER_DESC bufferDesc;
ZeroMemory(&bufferDesc, sizeof(D3D11_BUFFER_DESC));
bufferDesc.ByteWidth = inRawDataSize;
bufferDesc.Usage = inUsage;
bufferDesc.BindFlags = inBindFlags;
bufferDesc.CPUAccessFlags = inCPUAccessFlags;
bufferDesc.MiscFlags = 0;
bufferDesc.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA initialData;
ZeroMemory(&initialData, sizeof(D3D11_SUBRESOURCE_DATA));
initialData.pSysMem = inRawData;
ID3D11Buffer* buffer = nullptr;
HRESULT hr = mD3dDevice->CreateBuffer(&bufferDesc, inRawData ? &initialData : nullptr, &buffer);
if (FAILED(hr))
{
LOG(LogGraphicsDevice, Error, "CreateBuffer() Failed to create device buffer\n");
return nullptr;
}
return BufferPtr(buffer, AutoReleaseD3D);
}
BufferPtr IteratorBase::fetchPointBuffer(boost::int32_t const& cloud_id,
std::string const& schema_xml,
boost::uint32_t capacity)
{
BufferMap::const_iterator i = m_buffers.find(cloud_id);
if (i != m_buffers.end())
{
getReader().log()->get(logDEBUG2) << "IteratorBase::fetchPointBuffer: found existing PointBuffer with id " << cloud_id << std::endl;
return i->second;
}
else
{
std::stringstream query;
Schema schema = Schema::from_xml(schema_xml);
BufferPtr output = BufferPtr(new PointBuffer(schema, capacity));
std::pair<int, BufferPtr> p(cloud_id, output);
m_buffers.insert(p);
getReader().log()->get(logDEBUG2) << "IteratorBase::fetchPointBuffer: creating new PointBuffer with id " << cloud_id << std::endl;
return p.second;
}
}
BufferPtr IteratorBase::fetchPointBuffer(Statement statement, sdo_pc* pc)
{
boost::int32_t id = statement->GetInteger(&pc->pc_id);
BufferMap::const_iterator i = m_buffers.find(id);
if (i != m_buffers.end())
{
getReader().log()->get(logDEBUG2) << "IteratorBase::fetchPointBuffer: found existing PointBuffer with id " << id << std::endl;
return i->second;
}
else
{
boost::uint32_t block_capacity(0);
Schema schema = m_reader.fetchSchema(statement, pc, block_capacity, getReader().getName());
m_orientation = schema.getOrientation();
getReader().log()->get(logDEBUG2) << "Incoming schema orientation is " << m_orientation << std::endl;
BufferPtr output = BufferPtr(new PointBuffer(schema, block_capacity));
std::pair<int, BufferPtr> p(id, output);
m_buffers.insert(p);
getReader().log()->get(logDEBUG2) << "IteratorBase::fetchPointBuffer: creating new PointBuffer with id " << id << std::endl;
return p.second;
}
}
IteratorBase::IteratorBase(const pdal::drivers::oci::Reader& reader)
: m_initialQueryStatement(Statement())
, m_at_end(false)
, m_at_end_of_blocks(false)
, m_at_end_of_clouds(false)
, m_block(BlockPtr(new Block(reader.getConnection())))
, m_active_cloud_id(0)
, m_oracle_buffer(BufferPtr())
, m_buffer_position(0)
, m_orientation(schema::POINT_INTERLEAVED)
, m_reader(reader)
{
m_querytype = reader.getQueryType();
if (m_querytype == QUERY_SDO_PC)
{
m_initialQueryStatement = getNextCloud(m_block, m_active_cloud_id);
}
if (m_querytype == QUERY_SDO_BLK_PC_VIEW)
{
m_initialQueryStatement = reader.getInitialQueryStatement();
m_block = reader.getBlock();
m_active_cloud_id = m_initialQueryStatement->GetInteger(&m_block->pc->pc_id);
}
return;
}
BufferPtr Buffer::GetRange (size_t offset, size_t size) const
{
if (offset + size > DataSize)
throw ParameterIncorrect (SRC_POS);
return BufferPtr (DataPtr + offset, size);
}
wstring Serializer::DeserializeWString ()
{
uint64 size = Deserialize <uint64> ();
vector <wchar_t> data ((size_t) size / sizeof (wchar_t));
DataStream->ReadCompleteBuffer (BufferPtr ((byte *) &data[0], (size_t) size));
return wstring (&data[0]);
}
Image& Image::operator=(const Image& source)
{
width_ = source.width_;
height_ = source.height_;
pixelSize_ = source.pixelSize_;
bufferSize_ = source.bufferSize_;
data_ = BufferPtr(new Byte[bufferSize_]);
memcpy(this->data().get(), source.data().get(), this->bufferSize());
return(*this);
}
void VolumePassword::Deserialize (shared_ptr <Stream> stream)
{
Serializer sr (stream);
uint64 passwordSize;
sr.Deserialize ("PasswordSize", passwordSize);
PasswordSize = static_cast <size_t> (passwordSize);
sr.Deserialize ("PasswordBuffer", BufferPtr (PasswordBuffer));
Buffer wipeBuffer (128 * 1024);
sr.Deserialize ("WipeData", wipeBuffer);
}
IteratorBase::IteratorBase(const pdal::drivers::sqlite::Reader& reader)
: m_at_end(false)
, m_active_buffer(BufferPtr())
, m_buffer_position(0)
, m_reader(reader)
{
pdal::Options const& options = reader.getOptions();
std::string const& connection = options.getValueOrThrow<std::string>("connection");
std::string const& query = options.getValueOrThrow<std::string>("query");
return;
}
uint64 MemoryStream::Read (const BufferPtr &buffer)
{
if (Data.size() == 0)
throw ParameterIncorrect (SRC_POS);
ConstBufferPtr streamBuf (*this);
size_t len = buffer.Size();
if (streamBuf.Size() - ReadPosition < len)
len = streamBuf.Size() - ReadPosition;
BufferPtr(buffer).CopyFrom (streamBuf.GetRange (ReadPosition, len));
ReadPosition += len;
return len;
}
void StringConverter::ToWideBuffer (const wstring &str, wchar_t *buffer, size_t bufferSize)
{
if (str.length() < 1)
{
buffer[0] = 0;
return;
}
BufferPtr (
(byte *) buffer,
bufferSize).CopyFrom (
ConstBufferPtr ((byte *) (wstring (str).c_str()),
(str.length() + 1) * sizeof (wchar_t)
)
);
}
void init_texture(int width, int height)
{
if (displayBuffer_ == nullptr || width != depthWidth_ || height != depthHeight_)
{
depthWidth_ = width;
depthHeight_ = height;
const int byteLength = depthWidth_ * depthHeight_ * 4;
displayBuffer_ = BufferPtr(new uint8_t[byteLength]);
std::fill(&displayBuffer_[0], &displayBuffer_[0] + byteLength, 0);
texture_.create(depthWidth_, depthHeight_);
sprite_.setTexture(texture_);
sprite_.setPosition(0, 0);
}
}
static int fuse_service_write (const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi)
{
try
{
if (!FuseService::CheckAccessRights())
return -EACCES;
if (strcmp (path, FuseService::GetVolumeImagePath()) == 0)
{
FuseService::WriteVolumeSectors (BufferPtr ((byte *) buf, size), offset);
return size;
}
if (strcmp (path, FuseService::GetControlPath()) == 0)
{
if (FuseService::AuxDeviceInfoReceived())
return -EACCES;
FuseService::ReceiveAuxDeviceInfo (ConstBufferPtr ((const byte *)buf, size));
return size;
}
}
#ifdef TC_FREEBSD
// FreeBSD apparently retries failed write operations forever, which may lead to a system crash.
catch (VolumeReadOnly&)
{
return size;
}
catch (VolumeProtected&)
{
return size;
}
#endif
catch (...)
{
return FuseService::ExceptionToErrorCode();
}
return -ENOENT;
}
BufferPtr BufferD3D11::createBuffer( Device* owner )
{
return BufferPtr( new BufferD3D11( owner ) );
}
}
return keyfiles;
}
shared_ptr <VolumePassword> TextUserInterface::AskPassword (const wxString &message, bool verify) const
{
wxString msg = LangString["ENTER_PASSWORD"] + L": ";
if (!message.empty())
msg = message + L": ";
SetTerminalEcho (false);
finally_do ({ TextUserInterface::SetTerminalEcho (true); });
wchar_t passwordBuf[4096];
finally_do_arg (BufferPtr, BufferPtr (reinterpret_cast <byte *> (passwordBuf), sizeof (passwordBuf)), { finally_arg.Erase(); });
make_shared_auto (VolumePassword, password);
bool verPhase = false;
while (true)
{
ShowString (verPhase ? wxString (_("Re-enter password: "******"\n");
static int fuse_service_read (const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi)
{
try
{
if (!FuseService::CheckAccessRights())
return -EACCES;
if (strcmp (path, FuseService::GetVolumeImagePath()) == 0)
{
try
{
// Test for read beyond the end of the volume
if ((uint64) offset + size > FuseService::GetVolumeSize())
size = FuseService::GetVolumeSize() - offset;
size_t sectorSize = FuseService::GetVolumeSectorSize();
if (size % sectorSize != 0 || offset % sectorSize != 0)
{
// Support for non-sector-aligned read operations is required by some loop device tools
// which may analyze the volume image before attaching it as a device
uint64 alignedOffset = offset - (offset % sectorSize);
uint64 alignedSize = size + (offset % sectorSize);
if (alignedSize % sectorSize != 0)
alignedSize += sectorSize - (alignedSize % sectorSize);
SecureBuffer alignedBuffer (alignedSize);
FuseService::ReadVolumeSectors (alignedBuffer, alignedOffset);
BufferPtr ((byte *) buf, size).CopyFrom (alignedBuffer.GetRange (offset % sectorSize, size));
}
else
{
FuseService::ReadVolumeSectors (BufferPtr ((byte *) buf, size), offset);
}
}
catch (MissingVolumeData)
{
return 0;
}
return size;
}
if (strcmp (path, FuseService::GetControlPath()) == 0)
{
shared_ptr <Buffer> infoBuf = FuseService::GetVolumeInfo();
BufferPtr outBuf ((byte *)buf, size);
if (offset >= (off_t) infoBuf->Size())
return 0;
if (offset + size > infoBuf->Size())
size = infoBuf->Size () - offset;
outBuf.CopyFrom (infoBuf->GetRange (offset, size));
return size;
}
}
catch (...)
{
return FuseService::ExceptionToErrorCode();
}
return -ENOENT;
}
MemoryStream::MemoryStream (const ConstBufferPtr &data) :
ReadPosition (0)
{
Data = vector <byte> (data.Size());
BufferPtr (&Data[0], Data.size()).CopyFrom (data);
}
void FatFormatter::Format (WriteSectorCallback &writeSector, uint64 deviceSize, uint32 clusterSize, uint32 sectorSize)
{
fatparams fatParams;
#if TC_MAX_VOLUME_SECTOR_SIZE > 0xFFFF
#error TC_MAX_VOLUME_SECTOR_SIZE > 0xFFFF
#endif
fatParams.sector_size = (uint16) sectorSize;
if (deviceSize / fatParams.sector_size > 0xffffFFFF)
throw ParameterIncorrect (SRC_POS);
fatParams.num_sectors = (uint32) (deviceSize / fatParams.sector_size);
fatParams.cluster_size = clusterSize / fatParams.sector_size;
memcpy (fatParams.volume_name, "NO NAME ", 11);
GetFatParams (&fatParams);
fatparams *ft = &fatParams;
SecureBuffer sector (ft->sector_size);
uint32 sectorNumber = 0;
/* Write the data area */
sector.Zero();
uint32 volumeId;
RandomNumberGenerator::GetDataFast (BufferPtr ((byte *) &volumeId, sizeof (volumeId)));
PutBoot (ft, (byte *) sector, volumeId);
writeSector (sector); ++sectorNumber;
/* fat32 boot area */
if (ft->size_fat == 32)
{
/* fsinfo */
PutFSInfo((byte *) sector, ft);
writeSector (sector); ++sectorNumber;
/* reserved */
while (sectorNumber < 6)
{
sector.Zero();
sector[508+3] = 0xaa; /* TrailSig */
sector[508+2] = 0x55;
writeSector (sector); ++sectorNumber;
}
/* bootsector backup */
sector.Zero();
PutBoot (ft, (byte *) sector, volumeId);
writeSector (sector); ++sectorNumber;
PutFSInfo((byte *) sector, ft);
writeSector (sector); ++sectorNumber;
}
/* reserved */
while (sectorNumber < (uint32)ft->reserved)
{
sector.Zero();
writeSector (sector); ++sectorNumber;
}
/* write fat */
for (uint32 x = 1; x <= ft->fats; x++)
{
for (uint32 n = 0; n < ft->fat_length; n++)
{
sector.Zero();
if (n == 0)
{
byte fat_sig[12];
if (ft->size_fat == 32)
{
fat_sig[0] = (byte) ft->media;
fat_sig[1] = fat_sig[2] = 0xff;
fat_sig[3] = 0x0f;
fat_sig[4] = fat_sig[5] = fat_sig[6] = 0xff;
fat_sig[7] = 0x0f;
fat_sig[8] = fat_sig[9] = fat_sig[10] = 0xff;
fat_sig[11] = 0x0f;
memcpy (sector, fat_sig, 12);
}
else if (ft->size_fat == 16)
{
fat_sig[0] = (byte) ft->media;
fat_sig[1] = 0xff;
fat_sig[2] = 0xff;
fat_sig[3] = 0xff;
memcpy (sector, fat_sig, 4);
}
else if (ft->size_fat == 12)
{
fat_sig[0] = (byte) ft->media;
fat_sig[1] = 0xff;
fat_sig[2] = 0xff;
fat_sig[3] = 0x00;
memcpy (sector, fat_sig, 4);
}
}
if (!writeSector (sector))
return;
}
}
/* write rootdir */
for (uint32 x = 0; x < ft->size_root_dir / ft->sector_size; x++)
{
sector.Zero();
if (!writeSector (sector))
return;
}
}
