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; } }