void CachedExtent::Info() const { const char* extentType = "allocated tree block"; if (IsAllocated() == false && IsData() == false) extentType = "free tree block"; else if (IsAllocated() == false && IsData() == true) extentType = "free data extent"; else if (IsAllocated() == true && IsData() == true) extentType = "allocated data extent"; TRACE("%s at %" B_PRIu64 " length %" B_PRIu64 " refCount %i\n", extentType, offset, length, refCount); }
bool MacIOSurfaceTextureClientOGL::Lock(OpenMode aMode) { MOZ_ASSERT(!mIsLocked); mIsLocked = true; return IsValid() && IsAllocated(); }
inline void LHDretrieve_CCDtiming::getDataFromRawData(const void* params){ LHDretrieve_data::getDataFromRawData(); exposureTiming.resize(0); exposureTime.resize(0); if(!IsAllocated()) return; double threashold = 2500.0; double expStart_t=0; double expEnd_t=0; for(size_t i=0; i<size()-1; ++i){ if((1.0*data[i] - threashold) * (1.0*data[i+1] - threashold) <= 0.0){ // rising edge, exposure_start if((1.0*data[i] - threashold)<0.0) expStart_t = 0.5*get_t(i)+0.5*get_t(i+1); else{ expEnd_t = 0.5*get_t(i)+0.5*get_t(i+1); exposureTiming.push_back(0.5*expStart_t+0.5*expEnd_t); exposureTime.push_back(expEnd_t-expStart_t); } } } avgExposureTime=0.0; for(size_t i=0; i<exposureTime.size(); ++i) avgExposureTime += exposureTime[i]; avgExposureTime/=exposureTime.size(); }
void StreamTextureClientOGL::InitWith(gfx::SurfaceStream* aStream) { MOZ_ASSERT(!IsAllocated()); mStream = aStream; mGL = mStream->GLContext(); }
bool VertexBuffer::Clear() { if (!IsAllocated()) return false; // Error! ForceUnlock(); if (m_pD3D11Buffer) { m_pD3D11Buffer->Release(); m_pD3D11Buffer = nullptr; } m_bLockReadOnly = m_bUpdateVBO = false; if (m_pData) { delete [] m_pData; m_pData = nullptr; } else { // Error! return false; } // Update renderer statistics static_cast<PLRenderer::RendererBackend&>(GetRenderer()).GetWritableStatistics().nVertexBufferMem -= m_nSize; // Init m_nElements = 0; m_nSize = 0; m_nUsage = PLRenderer::Usage::Unknown; MemoryManager::Set(m_nOffset, -1, sizeof(int)*NumOfSemantics*MaxPipelineChannels); // Done return true; }
void MacIOSurfaceTextureClientOGL::InitWith(MacIOSurface* aSurface) { MOZ_ASSERT(IsValid()); MOZ_ASSERT(!IsAllocated()); mSurface = aSurface; }
bool CGUITextureBase::AllocateOnDemand() { if (m_visible) { // visible, so make sure we're allocated if (!IsAllocated() || (m_isAllocated == LARGE && !m_texture.size())) return AllocResources(); } else { // hidden, so deallocate as applicable if (m_allocateDynamically && IsAllocated()) FreeResources(); // reset animated textures (animgifs) ResetAnimState(); } return false; }
bool EGLImageTextureClient::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) { MOZ_ASSERT(IsValid()); MOZ_ASSERT(IsAllocated()); aOutDescriptor = EGLImageDescriptor((uintptr_t)mImage, mSize); return true; }
void Buffer::CopyFrom (const ConstBufferPtr &bufferPtr) { if (!IsAllocated ()) Allocate (bufferPtr.Size()); else if (bufferPtr.Size() > DataSize) throw ParameterTooLarge (SRC_POS); Memory::Copy (DataPtr, bufferPtr.Get(), bufferPtr.Size()); }
bool SurfaceTextureClient::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) { MOZ_ASSERT(IsValid()); MOZ_ASSERT(IsAllocated()); aOutDescriptor = SurfaceTextureDescriptor((uintptr_t)mSurfTex.get(), mSize); return true; }
IMAGE_PTR AtrousGabor::AccessGaussianBuffer(int level) { if(!IsAllocated()) throw "Resources not allocated"; if( (level < 0) || (level >= m_i_scales)) throw "Invalid Argument"; return gausslevel[level]; }
bool EGLImageTextureClient::Lock(OpenMode mode) { MOZ_ASSERT(!mIsLocked); if (!IsValid() || !IsAllocated()) { return false; } mIsLocked = true; return true; }
bool EGLImageTextureClient::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) { MOZ_ASSERT(IsValid()); MOZ_ASSERT(IsAllocated()); const EGLImageImage::Data* data = mImage->GetData(); aOutDescriptor = EGLImageDescriptor((uintptr_t)data->mImage, (uintptr_t)data->mSync, mSize); return true; }
IMAGE_PTR AtrousGabor::AccessGaussianLevel(int level) { if(!IsAllocated()) throw "Resources not allocated"; if( (level < 0) || (level >= m_i_scales)) throw "Invalid Argument"; return gausslevel[level] + m_i_border*m_i_stridepix + m_i_border; }
static int freehostmem(lua_State *L, ud_t *ud) { hostmem_t* hostmem = (hostmem_t*)ud->handle; int allocated = IsAllocated(ud); if(!freeuserdata(L, ud, "hostmem")) return 0; if(allocated) AlignedFree(hostmem->ptr); Free(L, hostmem); return 0; }
bool SharedTextureClientOGL::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) { MOZ_ASSERT(IsValid()); if (!IsAllocated()) { return false; } aOutDescriptor = SharedTextureDescriptor(mShareType, mHandle, mSize, mInverted); return true; }
bool StreamTextureClientOGL::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) { if (!IsAllocated()) { return false; } gfx::SurfaceStreamHandle handle = mStream->GetShareHandle(); aOutDescriptor = SurfaceStreamDescriptor(handle, false); return true; }
bool MemoryTextureClient::ToSurfaceDescriptor(SurfaceDescriptor& aDescriptor) { MOZ_ASSERT(IsValid()); if (!IsAllocated() || GetFormat() == gfx::FORMAT_UNKNOWN) { return false; } aDescriptor = SurfaceDescriptorMemory(reinterpret_cast<uintptr_t>(mBuffer), GetFormat()); return true; }
bool ShmemTextureClient::ToSurfaceDescriptor(SurfaceDescriptor& aDescriptor) { MOZ_ASSERT(IsValid()); if (!IsAllocated() || GetFormat() == gfx::FORMAT_UNKNOWN) { return false; } aDescriptor = SurfaceDescriptorShmem(mShmem, GetFormat()); return true; }
bool MacIOSurfaceTextureClientOGL::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) { MOZ_ASSERT(IsValid()); if (!IsAllocated()) { return false; } aOutDescriptor = SurfaceDescriptorMacIOSurface(mSurface->GetIOSurfaceID(), mSurface->GetContentsScaleFactor(), mSurface->HasAlpha()); return true; }
bool SharedTextureClientOGL::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) { if (!IsAllocated()) { return false; } nsIntSize nsSize(mSize.width, mSize.height); aOutDescriptor = SharedTextureDescriptor(mIsCrossProcess ? gl::GLContext::CrossProcess : gl::GLContext::SameProcess, mHandle, nsSize, mInverted); return true; }
gfx::DrawTarget* DIBTextureClient::BorrowDrawTarget() { MOZ_ASSERT(mIsLocked && IsAllocated()); if (!mDrawTarget) { mDrawTarget = gfxPlatform::GetPlatform()->CreateDrawTargetForSurface(mSurface, mSize); } return mDrawTarget; }
bool TextureClient::ShouldDeallocateInDestructor() const { if (!IsAllocated()) { return false; } // If we're meant to be deallocated by the host, // but we haven't been shared yet, then we should // deallocate on the client instead. return !IsSharedWithCompositor(); }
void SharedTextureClientOGL::InitWith(gl::SharedTextureHandle aHandle, gfx::IntSize aSize, bool aIsCrossProcess, bool aInverted) { MOZ_ASSERT(!IsAllocated()); mHandle = aHandle; mSize = aSize; mIsCrossProcess = aIsCrossProcess; mInverted = aInverted; }
bool TextureClientD3D11::Lock(OpenMode aMode) { if (!IsAllocated()) { return false; } MOZ_ASSERT(!mIsLocked, "The Texture is already locked!"); if (mTexture) { MOZ_ASSERT(!mTexture10); mIsLocked = LockD3DTexture(mTexture.get()); } else { MOZ_ASSERT(!mTexture); mIsLocked = LockD3DTexture(mTexture10.get()); } if (!mIsLocked) { return false; } if (NS_IsMainThread()) { // Make sure that successful write-lock means we will have a DrawTarget to // write into. if (aMode & OpenMode::OPEN_WRITE) { mDrawTarget = BorrowDrawTarget(); if (!mDrawTarget) { Unlock(); return false; } } if (mNeedsClear) { mDrawTarget = BorrowDrawTarget(); if (!mDrawTarget) { Unlock(); return false; } mDrawTarget->ClearRect(Rect(0, 0, GetSize().width, GetSize().height)); mNeedsClear = false; } if (mNeedsClearWhite) { mDrawTarget = BorrowDrawTarget(); if (!mDrawTarget) { Unlock(); return false; } mDrawTarget->FillRect(Rect(0, 0, GetSize().width, GetSize().height), ColorPattern(Color(1.0, 1.0, 1.0, 1.0))); mNeedsClearWhite = false; } } return true; }
void SparseMatrix::ToHostMatrix(float** mat, int* rows, int* cols) const { const float nan = std::numeric_limits<float>::quiet_NaN(); *mat = new float[Rows() * Columns()]; *rows = Rows(); *cols = Columns(); for (int i = 0; i < Rows(); i++) { for (int j = 0; j < Columns(); j++) { (*mat)[i * Columns() + j] = IsAllocated(i, j) ? Get(i, j) : nan; } } }
IMAGE_PTR AtrousGabor::AccessGaborImagLevel(int level) { if((m_i_orientations == 0)||(m_i_wavelengths == 0) ) throw "Object not configured for gabor computations"; if(!IsAllocated()) throw "Resources not allocated"; if( (level < 0) || (level >= m_i_orientations*m_i_kernels)) throw "Invalid Argument"; return imaglevel[level] + m_i_border*m_i_stridepix + m_i_border; }
IMAGE_PTR AtrousGabor::AccessLaplacianBuffer(int level) { if(!IsAllocated()) throw "Resources not allocated"; if(m_i_orientations == 0) throw "Object not configured for laplacian computations"; if( (level < 0) || (level >= m_i_scales)) throw "Invalid Argument"; return laplevel[level]; }
IMAGE_PTR AtrousGabor::AccessGaborEnergyBuffer(int level) { if((m_i_orientations == 0)||(m_i_wavelengths == 0) ) throw "Object not configured for gabor computations"; if(!IsAllocated()) throw "Resources not allocated"; if( (level < 0) || (level >= m_i_orientations*m_i_kernels)) throw "Invalid Argument"; return gaborlevel[level]; }
bool DIBTextureClient::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) { MOZ_ASSERT(IsValid()); if (!IsAllocated()) { return false; } MOZ_ASSERT(mSurface); // The host will release this ref when it receives the surface descriptor. // We AddRef in case we die before the host receives the pointer. aOutDescriptor = SurfaceDescriptorDIB(reinterpret_cast<uintptr_t>(mSurface.get())); mSurface->AddRef(); return true; }