mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-02 15:15:23 +00:00
88696a303a
This patch:
- Makes the following substitutions (plus necessary namespace qualifiers:
gfxImageFormat::ARGB32 --> SurfaceFormat::A8R8G8B8_UINT32
gfxImageFormat::RGB24 --> SurfaceFormat::X8R8G8B8_UINT32
gfxImageFormat::A8 --> SurfaceFormat::A8
gfxImageFormat::RGB16_565 --> SurfaceFormat::R5G6B5_UINT16
gfxImageFormat::Unknown --> SurfaceFormat::UNKNOWN
- Changes gfxImageFormat to be a typedef to gfx::SurfaceFormat. This will be
removed soon.
- Removes gfxCairoFormatToImageFormat() and gfxImageFormatToCairoFormat() and
replace calls to them with CairoFormatToGfxFormat() and
GfxFormatToCairoFormat().
- Removes ParamTraits<gfxImageFormat>.
- Add namespace qualifiers to SurfaceFormat instances where necessary.
--HG--
extra : rebase_source : f56e92b1593957a9e4e00171100bc7605816e696
144 lines
4.6 KiB
C++
144 lines
4.6 KiB
C++
/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40; -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "SharedSurfaceGLX.h"
|
|
#include "gfxXlibSurface.h"
|
|
#include "GLXLibrary.h"
|
|
#include "GLContextProvider.h"
|
|
#include "GLContextGLX.h"
|
|
#include "GLScreenBuffer.h"
|
|
#include "mozilla/gfx/SourceSurfaceCairo.h"
|
|
#include "mozilla/layers/LayersSurfaces.h"
|
|
#include "mozilla/layers/ShadowLayerUtilsX11.h"
|
|
#include "mozilla/layers/ISurfaceAllocator.h"
|
|
#include "mozilla/X11Util.h"
|
|
|
|
namespace mozilla {
|
|
namespace gl {
|
|
|
|
/* static */
|
|
UniquePtr<SharedSurface_GLXDrawable>
|
|
SharedSurface_GLXDrawable::Create(GLContext* prodGL,
|
|
const SurfaceCaps& caps,
|
|
const gfx::IntSize& size,
|
|
bool deallocateClient,
|
|
bool inSameProcess)
|
|
{
|
|
UniquePtr<SharedSurface_GLXDrawable> ret;
|
|
Display* display = DefaultXDisplay();
|
|
Screen* screen = XDefaultScreenOfDisplay(display);
|
|
Visual* visual = gfxXlibSurface::FindVisual(screen, gfx::SurfaceFormat::A8R8G8B8_UINT32);
|
|
|
|
RefPtr<gfxXlibSurface> surf = gfxXlibSurface::Create(screen, visual, size);
|
|
if (!deallocateClient)
|
|
surf->ReleasePixmap();
|
|
|
|
ret.reset(new SharedSurface_GLXDrawable(prodGL, size, inSameProcess, surf));
|
|
return Move(ret);
|
|
}
|
|
|
|
|
|
SharedSurface_GLXDrawable::SharedSurface_GLXDrawable(GLContext* gl,
|
|
const gfx::IntSize& size,
|
|
bool inSameProcess,
|
|
const RefPtr<gfxXlibSurface>& xlibSurface)
|
|
: SharedSurface(SharedSurfaceType::GLXDrawable,
|
|
AttachmentType::Screen,
|
|
gl,
|
|
size,
|
|
true,
|
|
true)
|
|
, mXlibSurface(xlibSurface)
|
|
, mInSameProcess(inSameProcess)
|
|
{}
|
|
|
|
void
|
|
SharedSurface_GLXDrawable::ProducerReleaseImpl()
|
|
{
|
|
mGL->MakeCurrent();
|
|
mGL->fFlush();
|
|
}
|
|
|
|
void
|
|
SharedSurface_GLXDrawable::LockProdImpl()
|
|
{
|
|
mGL->Screen()->SetReadBuffer(LOCAL_GL_FRONT);
|
|
GLContextGLX::Cast(mGL)->OverrideDrawable(mXlibSurface->GetGLXPixmap());
|
|
}
|
|
|
|
void
|
|
SharedSurface_GLXDrawable::UnlockProdImpl()
|
|
{
|
|
GLContextGLX::Cast(mGL)->RestoreDrawable();
|
|
}
|
|
|
|
bool
|
|
SharedSurface_GLXDrawable::ToSurfaceDescriptor(layers::SurfaceDescriptor* const out_descriptor)
|
|
{
|
|
if (!mXlibSurface)
|
|
return false;
|
|
|
|
*out_descriptor = layers::SurfaceDescriptorX11(mXlibSurface, mInSameProcess);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SharedSurface_GLXDrawable::ReadbackBySharedHandle(gfx::DataSourceSurface* out_surface)
|
|
{
|
|
MOZ_ASSERT(out_surface);
|
|
RefPtr<gfx::DataSourceSurface> dataSurf =
|
|
new gfx::DataSourceSurfaceCairo(mXlibSurface->CairoSurface());
|
|
|
|
gfx::DataSourceSurface::ScopedMap mapSrc(dataSurf, gfx::DataSourceSurface::READ);
|
|
if (!mapSrc.IsMapped()) {
|
|
return false;
|
|
}
|
|
|
|
gfx::DataSourceSurface::ScopedMap mapDest(out_surface, gfx::DataSourceSurface::WRITE);
|
|
if (!mapDest.IsMapped()) {
|
|
return false;
|
|
}
|
|
|
|
if (mapDest.GetStride() == mapSrc.GetStride()) {
|
|
memcpy(mapDest.GetData(),
|
|
mapSrc.GetData(),
|
|
out_surface->GetSize().height * mapDest.GetStride());
|
|
} else {
|
|
for (int32_t i = 0; i < dataSurf->GetSize().height; i++) {
|
|
memcpy(mapDest.GetData() + i * mapDest.GetStride(),
|
|
mapSrc.GetData() + i * mapSrc.GetStride(),
|
|
std::min(mapSrc.GetStride(), mapDest.GetStride()));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* static */
|
|
UniquePtr<SurfaceFactory_GLXDrawable>
|
|
SurfaceFactory_GLXDrawable::Create(GLContext* prodGL,
|
|
const SurfaceCaps& caps,
|
|
const RefPtr<layers::ISurfaceAllocator>& allocator,
|
|
const layers::TextureFlags& flags)
|
|
{
|
|
MOZ_ASSERT(caps.alpha, "GLX surfaces require an alpha channel!");
|
|
|
|
typedef SurfaceFactory_GLXDrawable ptrT;
|
|
UniquePtr<ptrT> ret(new ptrT(prodGL, caps, allocator,
|
|
flags & ~layers::TextureFlags::ORIGIN_BOTTOM_LEFT));
|
|
return Move(ret);
|
|
}
|
|
|
|
UniquePtr<SharedSurface>
|
|
SurfaceFactory_GLXDrawable::CreateShared(const gfx::IntSize& size)
|
|
{
|
|
bool deallocateClient = !!(mFlags & layers::TextureFlags::DEALLOCATE_CLIENT);
|
|
return SharedSurface_GLXDrawable::Create(mGL, mCaps, size, deallocateClient,
|
|
mAllocator->IsSameProcess());
|
|
}
|
|
|
|
} // namespace gl
|
|
} // namespace mozilla
|