SurfaceFormat UploadSurfaceToTexture(GLContext* gl, gfxASurface *aSurface, const nsIntRegion& aDstRegion, GLuint& aTexture, bool aOverwrite, const nsIntPoint& aSrcPoint, bool aPixelBuffer, GLenum aTextureUnit, GLenum aTextureTarget) { nsRefPtr<gfxImageSurface> imageSurface = aSurface->GetAsImageSurface(); unsigned char* data = nullptr; if (!imageSurface || (imageSurface->Format() != gfxImageFormatARGB32 && imageSurface->Format() != gfxImageFormatRGB24 && imageSurface->Format() != gfxImageFormatRGB16_565 && imageSurface->Format() != gfxImageFormatA8)) { // We can't get suitable pixel data for the surface, make a copy nsIntRect bounds = aDstRegion.GetBounds(); imageSurface = new gfxImageSurface(gfxIntSize(bounds.width, bounds.height), gfxImageFormatARGB32); nsRefPtr<gfxContext> context = new gfxContext(imageSurface); context->Translate(-gfxPoint(aSrcPoint.x, aSrcPoint.y)); context->SetSource(aSurface); context->Paint(); data = imageSurface->Data(); NS_ASSERTION(!aPixelBuffer, "Must be using an image compatible surface with pixel buffers!"); } else { // If a pixel buffer is bound the data pointer parameter is relative // to the start of the data block. if (!aPixelBuffer) { data = imageSurface->Data(); } data += DataOffset(aSrcPoint, imageSurface->Stride(), imageSurface->Format()); } MOZ_ASSERT(imageSurface); imageSurface->Flush(); return UploadImageDataToTexture(gl, data, imageSurface->Stride(), imageSurface->Format(), aDstRegion, aTexture, aOverwrite, aPixelBuffer, aTextureUnit, aTextureTarget); }
void TextureClientTile::EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aType) { if (!mSurface || mSurface->Format() != gfxPlatform::GetPlatform()->OptimalFormatForContent(aType)) { gfxImageSurface* tmpTile = new gfxImageSurface(gfxIntSize(aSize.width, aSize.height), gfxPlatform::GetPlatform()->OptimalFormatForContent(aType), aType != gfxASurface::CONTENT_COLOR); mSurface = new gfxReusableSurfaceWrapper(tmpTile); mContentType = aType; } }
already_AddRefed<gfxContext> MakeContext () { const int size = 200; nsRefPtr<gfxASurface> surface; surface = gfxPlatform::GetPlatform()->CreateOffscreenSurface(gfxIntSize(size, size), gfxASurface::ImageFormatRGB24); gfxContext *ctx = new gfxContext(surface); NS_IF_ADDREF(ctx); return ctx; }
static void GonkFrameBuilder(Image* aImage, void* aBuffer, uint32_t aWidth, uint32_t aHeight) { /** * Cast the generic Image back to our platform-specific type and * populate it. */ GonkIOSurfaceImage* videoImage = static_cast<GonkIOSurfaceImage*>(aImage); GonkIOSurfaceImage::Data data; data.mGraphicBuffer = static_cast<layers::GraphicBufferLocked*>(aBuffer); data.mPicSize = gfxIntSize(aWidth, aHeight); videoImage->SetData(data); }
gfxIntSize ImageContainerD3D10::GetCurrentSize() { MutexAutoLock lock(mActiveImageLock); if (!mActiveImage) { return gfxIntSize(0,0); } if (mActiveImage->GetFormat() == Image::PLANAR_YCBCR) { PlanarYCbCrImageD3D10 *yuvImage = static_cast<PlanarYCbCrImageD3D10*>(mActiveImage.get()); if (!yuvImage->HasData()) { return gfxIntSize(0,0); } return yuvImage->mSize; } else if (mActiveImage->GetFormat() == Image::CAIRO_SURFACE) { CairoImageD3D10 *cairoImage = static_cast<CairoImageD3D10*>(mActiveImage.get()); return cairoImage->mSize; } return gfxIntSize(0,0); }
already_AddRefed<gfxImageSurface> nsSVGFilterInstance::CreateImage() { nsRefPtr<gfxImageSurface> surface = new gfxImageSurface(gfxIntSize(mSurfaceRect.width, mSurfaceRect.height), gfxASurface::ImageFormatARGB32); if (!surface || surface->CairoStatus()) return nullptr; surface->SetDeviceOffset(gfxPoint(-mSurfaceRect.x, -mSurfaceRect.y)); return surface.forget(); }
void SharedDIBSurface::InitSurface(uint32_t aWidth, uint32_t aHeight, bool aTransparent) { long stride = long(aWidth * kBytesPerPixel); unsigned char* data = reinterpret_cast<unsigned char*>(mSharedDIB.GetBits()); gfxImageFormat format = aTransparent ? gfxImageFormat::ARGB32 : gfxImageFormat::RGB24; gfxImageSurface::InitWithData(data, gfxIntSize(aWidth, aHeight), stride, format); cairo_surface_set_user_data(mSurface, &SHAREDDIB_KEY, this, nullptr); }
void ContentClientRemote::SetBackingBuffer(gfxASurface* aBuffer, const nsIntRect& aRect, const nsIntPoint& aRotation) { #ifdef DEBUG gfxIntSize prevSize = gfxIntSize(BufferRect().width, BufferRect().height); gfxIntSize newSize = aBuffer->GetSize(); NS_ABORT_IF_FALSE(newSize == prevSize, "Swapped-in buffer size doesn't match old buffer's!"); #endif nsRefPtr<gfxASurface> oldBuffer; oldBuffer = SetBuffer(aBuffer, aRect, aRotation); }
bool DeprecatedTextureClientTile::EnsureAllocated(gfx::IntSize aSize, gfxContentType aType) { if (!mSurface || mSurface->Format() != gfxPlatform::GetPlatform()->OptimalFormatForContent(aType)) { #ifdef MOZ_ANDROID_OMTC // If we're using OMTC, we can save some cycles by not using shared // memory. Using shared memory here is a small, but significant // performance regression. gfxImageSurface* tmpTile = new gfxImageSurface(gfxIntSize(aSize.width, aSize.height), gfxPlatform::GetPlatform()->OptimalFormatForContent(aType), aType != GFX_CONTENT_COLOR); mSurface = new gfxReusableImageSurfaceWrapper(tmpTile); #else nsRefPtr<gfxSharedImageSurface> sharedImage = gfxSharedImageSurface::CreateUnsafe(mForwarder, gfxIntSize(aSize.width, aSize.height), gfxPlatform::GetPlatform()->OptimalFormatForContent(aType)); mSurface = new gfxReusableSharedImageSurfaceWrapper(mForwarder, sharedImage); #endif mContentType = aType; } return true; }
GLContext * GLContextProviderGLX::GetGlobalContext() { static bool triedToCreateContext = false; if (!triedToCreateContext && !gGlobalContext) { triedToCreateContext = true; gGlobalContext = CreateOffscreenPixmapContext(gfxIntSize(1, 1), ContextFormat(ContextFormat::BasicRGB24), PR_FALSE); if (gGlobalContext) gGlobalContext->SetIsGlobalSharedContext(PR_TRUE); } return gGlobalContext; }
virtual already_AddRefed<gfxImageSurface> GetImageForUpload(gfxASurface* aUpdateSurface) { nsRefPtr<gfxImageSurface> image = new gfxImageSurface(gfxIntSize(mUpdateRect.width, mUpdateRect.height), mUpdateFormat); nsRefPtr<gfxContext> tmpContext = new gfxContext(image); tmpContext->SetSource(aUpdateSurface); tmpContext->SetOperator(gfxContext::OPERATOR_SOURCE); tmpContext->Paint(); return image.forget(); }
/*static*/ bool ShadowLayerForwarder::PlatformGetDescriptorSurfaceSize( const SurfaceDescriptor& aDescriptor, OpenMode aMode, gfxIntSize* aSize, gfxASurface** aSurface) { if (SurfaceDescriptor::TSurfaceDescriptorGralloc != aDescriptor.type()) { return false; } sp<GraphicBuffer> buffer = GrallocBufferActor::GetFrom(aDescriptor.get_SurfaceDescriptorGralloc()); *aSize = gfxIntSize(buffer->getWidth(), buffer->getHeight()); return true; }
nsresult MediaEngineDefaultVideoSource::Start(SourceMediaStream* aStream, TrackID aID) { if (mState != kAllocated) { return NS_ERROR_FAILURE; } mTimer = do_CreateInstance(NS_TIMER_CONTRACTID); if (!mTimer) { return NS_ERROR_FAILURE; } mSource = aStream; // Allocate a single blank Image ImageFormat format = PLANAR_YCBCR; mImageContainer = layers::LayerManager::CreateImageContainer(); nsRefPtr<layers::Image> image = mImageContainer->CreateImage(&format, 1); mImage = static_cast<layers::PlanarYCbCrImage*>(image.get()); layers::PlanarYCbCrImage::Data data; // Allocate a single blank Image mCb = 16; mCr = 16; AllocateSolidColorFrame(data, mOpts.mWidth, mOpts.mHeight, 0x80, mCb, mCr); // SetData copies data, so we can free the frame mImage->SetData(data); ReleaseFrame(data); // AddTrack takes ownership of segment VideoSegment *segment = new VideoSegment(); segment->AppendFrame(image.forget(), USECS_PER_S / mOpts.mFPS, gfxIntSize(mOpts.mWidth, mOpts.mHeight)); mSource->AddTrack(aID, VIDEO_RATE, 0, segment); // We aren't going to add any more tracks mSource->AdvanceKnownTracksTime(STREAM_TIME_MAX); // Remember TrackID so we can end it later mTrackID = aID; // Start timer for subsequent frames mTimer->InitWithCallback(this, 1000 / mOpts.mFPS, nsITimer::TYPE_REPEATING_SLACK); mState = kStarted; return NS_OK; }
void nsDisplayCanvasBackground::Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) { nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame); nsPoint offset = ToReferenceFrame(); nsRect bgClipRect = frame->CanvasArea() + offset; if (mIsBottommostLayer && NS_GET_A(mExtraBackgroundColor) > 0) { aCtx->SetColor(mExtraBackgroundColor); aCtx->FillRect(bgClipRect); } bool snap; nsRect bounds = GetBounds(aBuilder, &snap); nsRenderingContext context; nsRefPtr<gfxContext> dest = aCtx->ThebesContext(); nsRefPtr<gfxASurface> surf; nsRefPtr<gfxContext> ctx; #ifndef MOZ_GFX_OPTIMIZE_MOBILE if (IsSingleFixedPositionImage(aBuilder, bgClipRect) && aBuilder->IsPaintingToWindow() && !aBuilder->IsCompositingCheap()) { surf = static_cast<gfxASurface*>(GetUnderlyingFrame()->Properties().Get(nsIFrame::CachedBackgroundImage())); nsRefPtr<gfxASurface> destSurf = dest->CurrentSurface(); if (surf && surf->GetType() == destSurf->GetType()) { BlitSurface(dest, mDestRect, surf); return; } surf = destSurf->CreateSimilarSurface(gfxASurface::CONTENT_COLOR_ALPHA, gfxIntSize(ceil(mDestRect.width), ceil(mDestRect.height))); if (surf) { ctx = new gfxContext(surf); ctx->Translate(-gfxPoint(mDestRect.x, mDestRect.y)); context.Init(aCtx->DeviceContext(), ctx); } } #endif nsCSSRendering::PaintBackground(mFrame->PresContext(), surf ? context : *aCtx, mFrame, surf ? bounds : mVisibleRect, nsRect(offset, mFrame->GetSize()), aBuilder->GetBackgroundPaintFlags(), &bgClipRect, mLayer); if (surf) { BlitSurface(dest, mDestRect, surf); GetUnderlyingFrame()->Properties().Set(nsIFrame::CachedBackgroundImage(), surf.forget().get()); GetUnderlyingFrame()->AddStateBits(NS_FRAME_HAS_CACHED_BACKGROUND); } }
nsresult imgFrame::LockImageData() { if (mPalettedImageData) return NS_ERROR_NOT_AVAILABLE; NS_ABORT_IF_FALSE(!mLocked, "Trying to lock already locked image data."); if (mLocked) { return NS_ERROR_FAILURE; } mLocked = PR_TRUE; if ((mOptSurface || mSinglePixel) && !mImageSurface) { // Recover the pixels mImageSurface = new gfxImageSurface(gfxIntSize(mSize.width, mSize.height), gfxImageSurface::ImageFormatARGB32); if (!mImageSurface || mImageSurface->CairoStatus()) return NS_ERROR_OUT_OF_MEMORY; gfxContext context(mImageSurface); context.SetOperator(gfxContext::OPERATOR_SOURCE); if (mSinglePixel) context.SetDeviceColor(mSinglePixelColor); else context.SetSource(mOptSurface); context.Paint(); mOptSurface = nsnull; #ifdef USE_WIN_SURFACE mWinSurface = nsnull; #endif #ifdef XP_MACOSX mQuartzSurface = nsnull; #endif } // We might write to the bits in this image surface, so we need to make the // surface ready for that. if (mImageSurface) mImageSurface->Flush(); #ifdef USE_WIN_SURFACE if (mWinSurface) mWinSurface->Flush(); #endif return NS_OK; }
bool DIBTextureClient::AllocateForSurface(gfx::IntSize aSize, TextureAllocationFlags aFlags) { MOZ_ASSERT(!IsAllocated()); mSize = aSize; mSurface = new gfxWindowsSurface(gfxIntSize(aSize.width, aSize.height), SurfaceFormatToImageFormat(mFormat)); if (!mSurface || mSurface->CairoStatus()) { NS_WARNING("Could not create surface"); mSurface = nullptr; return false; } return true; }
void BasicShadowableCanvasLayer::Initialize(const Data& aData) { BasicCanvasLayer::Initialize(aData); if (!HasShadow()) return; // XXX won't get here currently; need to figure out what to do on // canvas resizes if (IsSurfaceDescriptorValid(mBackBuffer)) { AutoOpenSurface backSurface(OPEN_READ_ONLY, mBackBuffer); if (gfxIntSize(mBounds.width, mBounds.height) != backSurface.Size()) { DestroyBackBuffer(); } } }
void nsDisplayCanvasBackgroundImage::Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) { nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame); nsPoint offset = ToReferenceFrame(); nsRect bgClipRect = frame->CanvasArea() + offset; nsRenderingContext context; nsRefPtr<gfxContext> dest = aCtx->ThebesContext(); nsRefPtr<gfxASurface> surf; nsRefPtr<gfxContext> ctx; gfxRect destRect; #ifndef MOZ_GFX_OPTIMIZE_MOBILE if (IsSingleFixedPositionImage(aBuilder, bgClipRect, &destRect) && aBuilder->IsPaintingToWindow() && !aBuilder->IsCompositingCheap() && !dest->CurrentMatrix().HasNonIntegerTranslation()) { // Snap image rectangle to nearest pixel boundaries. This is the right way // to snap for this context, because we checked HasNonIntegerTranslation above. destRect.Round(); surf = static_cast<gfxASurface*>(GetUnderlyingFrame()->Properties().Get(nsIFrame::CachedBackgroundImage())); nsRefPtr<gfxASurface> destSurf = dest->CurrentSurface(); if (surf && surf->GetType() == destSurf->GetType()) { BlitSurface(dest, destRect, surf); return; } surf = destSurf->CreateSimilarSurface(gfxASurface::CONTENT_COLOR_ALPHA, gfxIntSize(destRect.width, destRect.height)); if (surf) { ctx = new gfxContext(surf); ctx->Translate(-gfxPoint(destRect.x, destRect.y)); context.Init(aCtx->DeviceContext(), ctx); } } #endif PaintInternal(aBuilder, surf ? &context : aCtx, surf ? bgClipRect: mVisibleRect, &bgClipRect); if (surf) { BlitSurface(dest, destRect, surf); frame->Properties().Set(nsIFrame::CachedBackgroundImage(), surf.forget().get()); } }
int TestNewSurface () { int failures = 0; int destroyed = 0; nsRefPtr<gfxASurface> s = new gfxImageSurface (gfxIntSize(10, 10), gfxImageFormat::ARGB32); cairo_surface_t *cs = s->CairoSurface(); cairo_surface_set_user_data (cs, &destruction_key, &destroyed, SurfaceDestroyNotifier); failures += CheckInt (GetASurfaceRefCount(s.get()), 1); failures += CheckInt (cairo_surface_get_reference_count(cs), 1); failures += CheckInt (destroyed, 0); cairo_surface_reference(cs); failures += CheckInt (GetASurfaceRefCount(s.get()), 2); failures += CheckInt (cairo_surface_get_reference_count(cs), 2); failures += CheckInt (destroyed, 0); gfxASurface *savedWrapper = s.get(); s = nullptr; failures += CheckInt (cairo_surface_get_reference_count(cs), 1); failures += CheckInt (destroyed, 0); s = gfxASurface::Wrap(cs); failures += CheckPointer (s.get(), savedWrapper); failures += CheckInt (GetASurfaceRefCount(s.get()), 2); failures += CheckInt (cairo_surface_get_reference_count(cs), 2); failures += CheckInt (destroyed, 0); cairo_surface_destroy(cs); failures += CheckInt (GetASurfaceRefCount(s.get()), 1); failures += CheckInt (cairo_surface_get_reference_count(cs), 1); failures += CheckInt (destroyed, 0); s = nullptr; failures += CheckInt (destroyed, 1); return failures; }
NS_IMETHODIMP MediaEngineDefaultVideoSource::Notify(nsITimer* aTimer) { // Update the target color if (mCr <= 16) { if (mCb < 240) { mCb++; } else { mCr++; } } else if (mCb >= 240) { if (mCr < 240) { mCr++; } else { mCb--; } } else if (mCr >= 240) { if (mCb > 16) { mCb--; } else { mCr--; } } else { mCr--; } // Allocate a single solid color image ImageFormat format = PLANAR_YCBCR; nsRefPtr<layers::Image> image = mImageContainer->CreateImage(&format, 1); nsRefPtr<layers::PlanarYCbCrImage> ycbcr_image = static_cast<layers::PlanarYCbCrImage*>(image.get()); layers::PlanarYCbCrImage::Data data; AllocateSolidColorFrame(data, mOpts.mWidth, mOpts.mHeight, 0x80, mCb, mCr); ycbcr_image->SetData(data); // SetData copies data, so we can free the frame ReleaseFrame(data); // AddTrack takes ownership of segment VideoSegment segment; segment.AppendFrame(ycbcr_image.forget(), USECS_PER_S / mOpts.mFPS, gfxIntSize(mOpts.mWidth, mOpts.mHeight)); mSource->AppendToTrack(mTrackID, &segment); return NS_OK; }
void TextureClientShmem::EnsureAllocated(gfx::IntSize aSize, gfxASurface::gfxContentType aContentType) { if (aSize != mSize || aContentType != mContentType || !IsSurfaceDescriptorValid(mDescriptor)) { ReleaseResources(); mContentType = aContentType; mSize = aSize; if (!mForwarder->AllocSurfaceDescriptor(gfxIntSize(mSize.width, mSize.height), mContentType, &mDescriptor)) { NS_WARNING("creating SurfaceDescriptor failed!"); } } }
gfxIntSize ImageContainer::GetCurrentSize() { ReentrantMonitorAutoEnter mon(mReentrantMonitor); if (mRemoteData) { CrossProcessMutexAutoLock autoLock(*mRemoteDataMutex); // We don't need to ensure we have an active image here, as we need to // be in the mutex anyway, and this is easiest to return from there. return mRemoteData->mSize; } if (!mActiveImage) { return gfxIntSize(0,0); } return mActiveImage->GetSize(); }
already_AddRefed<gfxContext> gfxCachedTempSurface::Get(gfxASurface::gfxContentType aContentType, const gfxRect& aRect, gfxASurface* aSimilarTo) { if (mSurface) { /* Verify the current buffer is valid for this purpose */ if (mSize.width < aRect.width || mSize.height < aRect.height || mSurface->GetContentType() != aContentType) { mSurface = nsnull; } else { NS_ASSERTION(mType == aSimilarTo->GetType(), "Unexpected surface type change"); } } bool cleared = false; if (!mSurface) { mSize = gfxIntSize(PRInt32(ceil(aRect.width)), PRInt32(ceil(aRect.height))); mSurface = aSimilarTo->CreateSimilarSurface(aContentType, mSize); if (!mSurface) return nsnull; cleared = PR_TRUE; #ifdef DEBUG mType = aSimilarTo->GetType(); #endif } mSurface->SetDeviceOffset(-aRect.TopLeft()); nsRefPtr<gfxContext> ctx = new gfxContext(mSurface); ctx->Rectangle(aRect); ctx->Clip(); if (!cleared && aContentType != gfxASurface::CONTENT_COLOR) { ctx->SetOperator(gfxContext::OPERATOR_CLEAR); ctx->Paint(); ctx->SetOperator(gfxContext::OPERATOR_OVER); } CachedSurfaceExpirationTracker::MarkSurfaceUsed(this); return ctx.forget(); }
already_AddRefed<Image> CreateSharedRGBImage(ImageContainer *aImageContainer, nsIntSize aSize, gfxImageFormat aImageFormat) { NS_ASSERTION(aImageFormat == gfxImageFormatARGB32 || aImageFormat == gfxImageFormatRGB24 || aImageFormat == gfxImageFormatRGB16_565, "RGB formats supported only"); if (!aImageContainer) { NS_WARNING("No ImageContainer to allocate DeprecatedSharedRGBImage"); return nullptr; } ImageFormat format = SHARED_RGB; nsRefPtr<Image> image = aImageContainer->CreateImage(&format, 1); if (!image) { NS_WARNING("Failed to create DeprecatedSharedRGBImage"); return nullptr; } if (gfxPlatform::GetPlatform()->UseDeprecatedTextures()) { nsRefPtr<DeprecatedSharedRGBImage> rgbImageDep = static_cast<DeprecatedSharedRGBImage*>(image.get()); rgbImageDep->mSize = gfxIntSize(aSize.width, aSize.height); rgbImageDep->mImageFormat = aImageFormat; if (!rgbImageDep->AllocateBuffer(aSize, aImageFormat)) { NS_WARNING("Failed to allocate shared memory for DeprecatedSharedRGBImage"); return nullptr; } return rgbImageDep.forget(); } nsRefPtr<SharedRGBImage> rgbImage = static_cast<SharedRGBImage*>(image.get()); if (!rgbImage->Allocate(gfx::ToIntSize(aSize), gfx::ImageFormatToSurfaceFormat(aImageFormat))) { NS_WARNING("Failed to allocate a shared image"); return nullptr; } return image.forget(); }
void LayerManagerOGL::CopyToTarget(gfxContext *aTarget) { nsIntRect rect; mWidget->GetBounds(rect); GLint width = rect.width; GLint height = rect.height; if ((PRInt64(width) * PRInt64(height) * PRInt64(4)) > PR_INT32_MAX) { NS_ERROR("Widget size too big - integer overflow!"); return; } nsRefPtr<gfxImageSurface> imageSurface = new gfxImageSurface(gfxIntSize(width, height), gfxASurface::ImageFormatARGB32); mGLContext->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mGLContext->IsDoubleBuffered() ? 0 : mBackBufferFBO); #ifndef USE_GLES2 // GLES2 promises that binding to any custom FBO will attach // to GL_COLOR_ATTACHMENT0 attachment point. if (mGLContext->IsDoubleBuffered()) { mGLContext->fReadBuffer(LOCAL_GL_BACK); } else { mGLContext->fReadBuffer(LOCAL_GL_COLOR_ATTACHMENT0); } #endif NS_ASSERTION(imageSurface->Stride() == width * 4, "Image Surfaces being created with weird stride!"); mGLContext->ReadPixelsIntoImageSurface(0, 0, width, height, imageSurface); aTarget->SetOperator(gfxContext::OPERATOR_SOURCE); aTarget->Scale(1.0, -1.0); aTarget->Translate(-gfxPoint(0.0, height)); aTarget->SetSource(imageSurface); aTarget->Paint(); }
already_AddRefed<GLContext> GLContextProviderGLX::CreateOffscreen(const gfxIntSize& size, const SurfaceCaps& caps, ContextFlags flags) { LibType libType = GLXLibrary::SelectLibrary(flags); gCurrLib = libType; gfxIntSize dummySize = gfxIntSize(16, 16); nsRefPtr<GLContextGLX> glContext = CreateOffscreenPixmapContext(dummySize, libType); if (!glContext) return nullptr; if (!glContext->InitOffscreen(size, caps)) return nullptr; return glContext.forget(); }
already_AddRefed<gfxASurface> ContentClientBasic::CreateBuffer(ContentType aType, const nsIntRect& aRect, uint32_t aFlags) { nsRefPtr<gfxASurface> referenceSurface = GetBuffer(); if (!referenceSurface) { gfxContext* defaultTarget = mManager->GetDefaultTarget(); if (defaultTarget) { referenceSurface = defaultTarget->CurrentSurface(); } else { nsIWidget* widget = mManager->GetRetainerWidget(); if (!widget || !(referenceSurface = widget->GetThebesSurface())) { referenceSurface = mManager->GetTarget()->CurrentSurface(); } } } return referenceSurface->CreateSimilarSurface( aType, gfxIntSize(aRect.width, aRect.height)); }
GLContext* GLContextProviderGLX::GetGlobalContext(const ContextFlags aFlag) { // TODO: get GLX context sharing to work well with multiple threads if (!gUseContextSharing) { return nullptr; } LibType libType = GLXLibrary::SelectLibrary(aFlag); static bool triedToCreateContext[GLXLibrary::LIBS_MAX] = {false, false}; if (!triedToCreateContext[libType] && !gGlobalContext[libType]) { triedToCreateContext[libType] = true; gfxIntSize dummySize = gfxIntSize(16, 16); gGlobalContext[libType] = CreateOffscreenPixmapContext(dummySize, libType); if (gGlobalContext[libType]) gGlobalContext[libType]->SetIsGlobalSharedContext(true); } return gGlobalContext[libType]; }
already_AddRefed<gfxASurface> MacIOSurfaceImage::GetAsSurface() { mIOSurface->Lock(); size_t bytesPerRow = mIOSurface->GetBytesPerRow(); size_t ioWidth = mIOSurface->GetWidth(); size_t ioHeight = mIOSurface->GetHeight(); unsigned char* ioData = (unsigned char*)mIOSurface->GetBaseAddress(); nsRefPtr<gfxImageSurface> imgSurface = new gfxImageSurface(gfxIntSize(ioWidth, ioHeight), gfxASurface::ImageFormatARGB32); for (int i = 0; i < ioHeight; i++) { memcpy(imgSurface->Data() + i * imgSurface->Stride(), ioData + i * bytesPerRow, ioWidth * 4); } mIOSurface->Unlock(); return imgSurface.forget(); }
already_AddRefed<GLContext> GLContextProviderWGL::CreateOffscreen(const gfxIntSize& size, const SurfaceCaps& caps, ContextFlags flags) { LibType libToUse = WGLLibrary::SelectLibrary(flags); if (!sWGLLib[libToUse].EnsureInitialized(libToUse == WGLLibrary::MESA_LLVMPIPE_LIB)) { return nullptr; } nsRefPtr<GLContextWGL> glContext; // Always try to create a pbuffer context first, because we // want the context isolation. if (sWGLLib[libToUse].fCreatePbuffer && sWGLLib[libToUse].fChoosePixelFormat) { gfxIntSize dummySize = gfxIntSize(16, 16); glContext = CreatePBufferOffscreenContext(dummySize, libToUse); } // If it failed, then create a window context and use a FBO. if (!glContext) { glContext = CreateWindowOffscreenContext(flags); } if (!glContext || !glContext->Init()) { return nullptr; } if (!glContext->InitOffscreen(size, caps)) return nullptr; return glContext.forget(); }