gecko-dev/gfx/gl/SharedSurfaceGLX.cpp

/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4; -*- */
/* 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/layers/TextureForwarder.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 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::LayersIPCChannel>& 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 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