// Run the test for a texture client and a surface
void TestTextureClientSurface(TextureClient* texture, gfxImageSurface* surface) {
// client allocation
ASSERT_TRUE(texture->AsTextureClientSurface() != nullptr);
TextureClientSurface* client = texture->AsTextureClientSurface();
client->AllocateForSurface(ToIntSize(surface->GetSize()));
ASSERT_TRUE(texture->IsAllocated());
// client painting
client->UpdateSurface(surface);
nsRefPtr<gfxASurface> aSurface = client->GetAsSurface();
nsRefPtr<gfxImageSurface> clientSurface = aSurface->GetAsImageSurface();
ASSERT_TRUE(texture->Lock(OPEN_READ_ONLY));
AssertSurfacesEqual(surface, clientSurface);
texture->Unlock();
// client serialization
texture->SetID(1);
SurfaceDescriptor descriptor;
ASSERT_TRUE(texture->ToSurfaceDescriptor(descriptor));
ASSERT_NE(descriptor.type(), SurfaceDescriptor::Tnull_t);
// host deserialization
RefPtr<TextureHost> host = CreateBackendIndependentTextureHost(texture->GetID(),
descriptor, nullptr,
texture->GetFlags());
ASSERT_TRUE(host.get() != nullptr);
ASSERT_EQ(host->GetFlags(), texture->GetFlags());
ASSERT_EQ(host->GetID(), texture->GetID());
// host read
ASSERT_TRUE(host->Lock());
nsRefPtr<gfxImageSurface> hostSurface = host->GetAsSurface();
host->Unlock();
AssertSurfacesEqual(surface, hostSurface.get());
// host deallocation
host->DeallocateSharedData();
}
// Run the test for a texture client and a surface
void TestTextureClientSurface(TextureClient* texture, gfxImageSurface* surface) {
// client allocation
ASSERT_TRUE(texture->AsTextureClientSurface() != nullptr);
TextureClientSurface* client = texture->AsTextureClientSurface();
client->AllocateForSurface(ToIntSize(surface->GetSize()));
ASSERT_TRUE(texture->IsAllocated());
ASSERT_TRUE(texture->Lock(OPEN_READ_WRITE));
// client painting
client->UpdateSurface(surface);
nsRefPtr<gfxASurface> aSurface = client->GetAsSurface();
nsRefPtr<gfxImageSurface> clientSurface = aSurface->GetAsImageSurface();
AssertSurfacesEqual(surface, clientSurface);
texture->Unlock();
// client serialization
SurfaceDescriptor descriptor;
ASSERT_TRUE(texture->ToSurfaceDescriptor(descriptor));
ASSERT_NE(descriptor.type(), SurfaceDescriptor::Tnull_t);
// host deserialization
RefPtr<TextureHost> host = CreateBackendIndependentTextureHost(descriptor, nullptr,
texture->GetFlags());
ASSERT_TRUE(host.get() != nullptr);
ASSERT_EQ(host->GetFlags(), texture->GetFlags());
// host read
ASSERT_TRUE(host->Lock());
RefPtr<mozilla::gfx::DataSourceSurface> hostDataSurface = host->GetAsSurface();
host->Unlock();
nsRefPtr<gfxImageSurface> hostSurface =
new gfxImageSurface(hostDataSurface->GetData(),
ThebesIntSize(hostDataSurface->GetSize()),
hostDataSurface->Stride(),
SurfaceFormatToImageFormat(hostDataSurface->GetFormat()));
AssertSurfacesEqual(surface, hostSurface.get());
}
SimpleTiledLayerTile
SimpleTiledLayerBuffer::ValidateTile(SimpleTiledLayerTile aTile,
const nsIntPoint& aTileOrigin,
const nsIntRegion& aDirtyRegion)
{
PROFILER_LABEL("SimpleTiledLayerBuffer", "ValidateTile");
static gfx::IntSize kTileSize(TILEDLAYERBUFFER_TILE_SIZE, TILEDLAYERBUFFER_TILE_SIZE);
gfx::SurfaceFormat tileFormat = gfxPlatform::GetPlatform()->Optimal2DFormatForContent(GetContentType());
// if this is true, we're using a separate buffer to do our drawing first
bool doBufferedDrawing = true;
bool fullPaint = false;
RefPtr<TextureClient> textureClient = mManager->GetSimpleTileTexturePool(tileFormat)->GetTextureClientWithAutoRecycle();
if (!textureClient) {
NS_WARNING("TextureClient allocation failed");
return SimpleTiledLayerTile();
}
if (!textureClient->Lock(OPEN_WRITE)) {
NS_WARNING("TextureClient lock failed");
return SimpleTiledLayerTile();
}
TextureClientSurface *textureClientSurf = textureClient->AsTextureClientSurface();
if (!textureClientSurf) {
doBufferedDrawing = false;
}
RefPtr<DrawTarget> drawTarget;
nsRefPtr<gfxImageSurface> clientAsImageSurface;
unsigned char *bufferData = nullptr;
// these are set/updated differently based on doBufferedDrawing
nsIntRect drawBounds;
nsIntRegion drawRegion;
nsIntRegion invalidateRegion;
if (doBufferedDrawing) {
// try to obtain the TextureClient as an ImageSurface, so that we can
// access the pixels directly
nsRefPtr<gfxASurface> asurf = textureClientSurf->GetAsSurface();
clientAsImageSurface = asurf ? asurf->GetAsImageSurface() : nullptr;
if (clientAsImageSurface) {
int32_t bufferStride = clientAsImageSurface->Stride();
if (!aTile.mCachedBuffer) {
aTile.mCachedBuffer = SharedBuffer::Create(clientAsImageSurface->GetDataSize());
fullPaint = true;
}
bufferData = (unsigned char*) aTile.mCachedBuffer->Data();
drawTarget = gfxPlatform::GetPlatform()->CreateDrawTargetForData(bufferData,
kTileSize,
bufferStride,
tileFormat);
if (fullPaint) {
drawBounds = nsIntRect(aTileOrigin.x, aTileOrigin.y, GetScaledTileLength(), GetScaledTileLength());
drawRegion = nsIntRegion(drawBounds);
} else {
drawBounds = aDirtyRegion.GetBounds();
drawRegion = nsIntRegion(drawBounds);
if (GetContentType() == gfxContentType::COLOR_ALPHA)
drawTarget->ClearRect(Rect(drawBounds.x - aTileOrigin.x, drawBounds.y - aTileOrigin.y,
drawBounds.width, drawBounds.height));
}
} else {
// failed to obtain the client as an ImageSurface
doBufferedDrawing = false;
}
}
// this might get set above if we couldn't extract out a buffer
if (!doBufferedDrawing) {
drawTarget = textureClient->AsTextureClientDrawTarget()->GetAsDrawTarget();
fullPaint = true;
drawBounds = nsIntRect(aTileOrigin.x, aTileOrigin.y, GetScaledTileLength(), GetScaledTileLength());
drawRegion = nsIntRegion(drawBounds);
if (GetContentType() == gfxContentType::COLOR_ALPHA)
drawTarget->ClearRect(Rect(0, 0, drawBounds.width, drawBounds.height));
}
// do the drawing
RefPtr<gfxContext> ctxt = new gfxContext(drawTarget);
ctxt->Scale(mResolution, mResolution);
ctxt->Translate(gfxPoint(-aTileOrigin.x, -aTileOrigin.y));
mCallback(mThebesLayer, ctxt,
drawRegion,
fullPaint ? DrawRegionClip::CLIP_NONE : DrawRegionClip::DRAW_SNAPPED, // XXX DRAW or DRAW_SNAPPED?
invalidateRegion,
mCallbackData);
ctxt = nullptr;
drawTarget = nullptr;
if (doBufferedDrawing) {
memcpy(clientAsImageSurface->Data(), bufferData, clientAsImageSurface->GetDataSize());
clientAsImageSurface = nullptr;
bufferData = nullptr;
}
textureClient->Unlock();
if (!mCompositableClient->AddTextureClient(textureClient)) {
NS_WARNING("Failed to add tile TextureClient [simple]");
return SimpleTiledLayerTile();
}
// aTile.mCachedBuffer was set earlier
aTile.mTileBuffer = textureClient;
aTile.mManager = mManager;
aTile.mLastUpdate = TimeStamp::Now();
return aTile;
}
