gfx/layers/TextureDIB.cpp

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "TextureDIB.h"
   7 #include "gfx2DGlue.h"
   8
   9 namespace mozilla {
  10
  11 using namespace gfx;
  12
  13 namespace layers {
  14
  15 DIBTextureClient::DIBTextureClient(gfx::SurfaceFormat aFormat, TextureFlags aFlags)
  16   : TextureClient(aFlags)
  17   , mFormat(aFormat)
  18   , mIsLocked(false)
  19 {
  20   MOZ_COUNT_CTOR(DIBTextureClient);
  21 }
  22
  23 DIBTextureClient::~DIBTextureClient()
  24 {
  25   MOZ_COUNT_DTOR(DIBTextureClient);
  26 }
  27
  28 TemporaryRef<TextureClient>
  29 DIBTextureClient::CreateSimilar(TextureFlags aFlags,
  30                                 TextureAllocationFlags aAllocFlags) const
  31 {
  32   RefPtr<TextureClient> tex = new DIBTextureClient(mFormat, mFlags | aFlags);
  33
  34   if (!tex->AllocateForSurface(mSize, aAllocFlags)) {
  35     return nullptr;
  36   }
  37
  38   return tex;
  39 }
  40
  41 bool
  42 DIBTextureClient::Lock(OpenMode)
  43 {
  44   MOZ_ASSERT(!mIsLocked);
  45   if (!IsValid()) {
  46     return false;
  47   }
  48   mIsLocked = true;
  49   return true;
  50 }
  51
  52 void
  53 DIBTextureClient::Unlock()
  54 {
  55   MOZ_ASSERT(mIsLocked, "Unlocked called while the texture is not locked!");
  56   if (mDrawTarget) {
  57     if (mReadbackSink) {
  58       RefPtr<SourceSurface> snapshot = mDrawTarget->Snapshot();
  59       RefPtr<DataSourceSurface> dataSurf = snapshot->GetDataSurface();
  60       mReadbackSink->ProcessReadback(dataSurf);
  61     }
  62
  63     mDrawTarget->Flush();
  64     mDrawTarget = nullptr;
  65   }
  66
  67   mIsLocked = false;
  68 }
  69
  70 bool
  71 DIBTextureClient::ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor)
  72 {
  73   MOZ_ASSERT(IsValid());
  74   if (!IsAllocated()) {
  75     return false;
  76   }
  77   MOZ_ASSERT(mSurface);
  78   // The host will release this ref when it receives the surface descriptor.
  79   // We AddRef in case we die before the host receives the pointer.
  80   aOutDescriptor = SurfaceDescriptorDIB(reinterpret_cast<uintptr_t>(mSurface.get()));
  81   mSurface->AddRef();
  82   return true;
  83 }
  84
  85 gfx::DrawTarget*
  86 DIBTextureClient::BorrowDrawTarget()
  87 {
  88   MOZ_ASSERT(mIsLocked && IsAllocated());
  89
  90   if (!mDrawTarget) {
  91     mDrawTarget =
  92       gfxPlatform::GetPlatform()->CreateDrawTargetForSurface(mSurface, mSize);
  93   }
  94
  95   return mDrawTarget;
  96 }
  97
  98 bool
  99 DIBTextureClient::AllocateForSurface(gfx::IntSize aSize, TextureAllocationFlags aFlags)
 100 {
 101   MOZ_ASSERT(!IsAllocated());
 102   mSize = aSize;
 103
 104   mSurface = new gfxWindowsSurface(gfxIntSize(aSize.width, aSize.height),
 105                                    SurfaceFormatToImageFormat(mFormat));
 106   if (!mSurface || mSurface->CairoStatus())
 107   {
 108     NS_WARNING("Could not create surface");
 109     mSurface = nullptr;
 110     return false;
 111   }
 112
 113   return true;
 114 }
 115
 116 DIBTextureHost::DIBTextureHost(TextureFlags aFlags,
 117                                const SurfaceDescriptorDIB& aDescriptor)
 118   : TextureHost(aFlags)
 119   , mIsLocked(false)
 120 {
 121   // We added an extra ref for transport, so we shouldn't AddRef now.
 122   mSurface =
 123     dont_AddRef(reinterpret_cast<gfxWindowsSurface*>(aDescriptor.surface()));
 124   MOZ_ASSERT(mSurface);
 125
 126   mSize = ToIntSize(mSurface->GetSize());
 127   mFormat = ImageFormatToSurfaceFormat(
 128     gfxPlatform::GetPlatform()->OptimalFormatForContent(mSurface->GetContentType()));
 129 }
 130
 131 NewTextureSource*
 132 DIBTextureHost::GetTextureSources()
 133 {
 134   if (!mTextureSource) {
 135     Updated();
 136   }
 137
 138   return mTextureSource;
 139 }
 140
 141 void
 142 DIBTextureHost::Updated(const nsIntRegion* aRegion)
 143 {
 144   if (!mTextureSource) {
 145     mTextureSource = mCompositor->CreateDataTextureSource(mFlags);
 146   }
 147
 148   nsRefPtr<gfxImageSurface> imgSurf = mSurface->GetAsImageSurface();
 149
 150   RefPtr<DataSourceSurface> surf = Factory::CreateWrappingDataSourceSurface(imgSurf->Data(), imgSurf->Stride(), mSize, mFormat);
 151
 152   if (!mTextureSource->Update(surf, const_cast<nsIntRegion*>(aRegion))) {
 153     mTextureSource = nullptr;
 154   }
 155 }
 156
 157 bool
 158 DIBTextureHost::Lock()
 159 {
 160   MOZ_ASSERT(!mIsLocked);
 161   mIsLocked = true;
 162   return true;
 163 }
 164
 165 void
 166 DIBTextureHost::Unlock()
 167 {
 168   MOZ_ASSERT(mIsLocked);
 169   mIsLocked = false;
 170 }
 171
 172 void
 173 DIBTextureHost::SetCompositor(Compositor* aCompositor)
 174 {
 175   mCompositor = aCompositor;
 176 }
 177
 178 void
 179 DIBTextureHost::DeallocateDeviceData()
 180 {
 181   if (mTextureSource) {
 182     mTextureSource->DeallocateDeviceData();
 183   }
 184 }
 185
 186 }
 187 }