1 files changed, 335 insertions, 0 deletions
diff --git a/gfx/2d/DataSurfaceHelpers.cpp b/gfx/2d/DataSurfaceHelpers.cpp
new file mode 100644
index 0000000000..78bd79a24a
--- /dev/null
+++ b/gfx/2d/DataSurfaceHelpers.cpp
@@ -0,0 +1,335 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 <cstring>
+
+#include "2D.h"
+#include "DataSurfaceHelpers.h"
+#include "Logging.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/PodOperations.h"
+#include "Swizzle.h"
+#include "Tools.h"
+
+namespace mozilla {
+namespace gfx {
+
+int32_t StrideForFormatAndWidth(SurfaceFormat aFormat, int32_t aWidth) {
+  MOZ_ASSERT(aFormat <= SurfaceFormat::UNKNOWN);
+  MOZ_ASSERT(aWidth > 0);
+
+  // There's nothing special about this alignment, other than that it's what
+  // cairo_format_stride_for_width uses.
+  static const int32_t alignment = sizeof(int32_t);
+
+  const int32_t bpp = BytesPerPixel(aFormat);
+
+  if (aWidth >= (INT32_MAX - alignment) / bpp) {
+    return -1;  // too big
+  }
+
+  return (bpp * aWidth + alignment - 1) & ~(alignment - 1);
+}
+
+already_AddRefed<DataSourceSurface> CreateDataSourceSurfaceFromData(
+    const IntSize& aSize, SurfaceFormat aFormat, const uint8_t* aData,
+    int32_t aDataStride) {
+  RefPtr<DataSourceSurface> srcSurface =
+      Factory::CreateWrappingDataSourceSurface(const_cast<uint8_t*>(aData),
+                                               aDataStride, aSize, aFormat);
+  RefPtr<DataSourceSurface> destSurface =
+      Factory::CreateDataSourceSurface(aSize, aFormat, false);
+
+  if (!srcSurface || !destSurface) {
+    return nullptr;
+  }
+
+  if (CopyRect(srcSurface, destSurface,
+               IntRect(IntPoint(), srcSurface->GetSize()), IntPoint())) {
+    return destSurface.forget();
+  }
+
+  return nullptr;
+}
+
+already_AddRefed<DataSourceSurface> CreateDataSourceSurfaceWithStrideFromData(
+    const IntSize& aSize, SurfaceFormat aFormat, int32_t aStride,
+    const uint8_t* aData, int32_t aDataStride) {
+  RefPtr<DataSourceSurface> srcSurface =
+      Factory::CreateWrappingDataSourceSurface(const_cast<uint8_t*>(aData),
+                                               aDataStride, aSize, aFormat);
+  RefPtr<DataSourceSurface> destSurface =
+      Factory::CreateDataSourceSurfaceWithStride(aSize, aFormat, aStride,
+                                                 false);
+
+  if (!srcSurface || !destSurface) {
+    return nullptr;
+  }
+
+  if (CopyRect(srcSurface, destSurface,
+               IntRect(IntPoint(), srcSurface->GetSize()), IntPoint())) {
+    return destSurface.forget();
+  }
+
+  return nullptr;
+}
+
+uint8_t* DataAtOffset(DataSourceSurface* aSurface,
+                      const DataSourceSurface::MappedSurface* aMap,
+                      IntPoint aPoint) {
+  if (!SurfaceContainsPoint(aSurface, aPoint)) {
+    MOZ_CRASH("GFX: sample position needs to be inside surface!");
+  }
+
+  MOZ_ASSERT(Factory::CheckSurfaceSize(aSurface->GetSize()),
+             "surface size overflows - this should have been prevented when "
+             "the surface was created");
+
+  uint8_t* data = aMap->mData + aPoint.y * aMap->mStride +
+                  aPoint.x * BytesPerPixel(aSurface->GetFormat());
+
+  if (data < aMap->mData) {
+    MOZ_CRASH("GFX: out-of-range data access");
+  }
+
+  return data;
+}
+
+// This check is safe against integer overflow.
+bool SurfaceContainsPoint(SourceSurface* aSurface, const IntPoint& aPoint) {
+  IntSize size = aSurface->GetSize();
+  return aPoint.x >= 0 && aPoint.x < size.width && aPoint.y >= 0 &&
+         aPoint.y < size.height;
+}
+
+void CopySurfaceDataToPackedArray(uint8_t* aSrc, uint8_t* aDst,
+                                  IntSize aSrcSize, int32_t aSrcStride,
+                                  int32_t aBytesPerPixel) {
+  MOZ_ASSERT(aBytesPerPixel > 0,
+             "Negative stride for aDst not currently supported");
+  MOZ_ASSERT(BufferSizeFromStrideAndHeight(aSrcStride, aSrcSize.height) > 0,
+             "How did we end up with a surface with such a big buffer?");
+
+  int packedStride = aSrcSize.width * aBytesPerPixel;
+
+  if (aSrcStride == packedStride) {
+    // aSrc is already packed, so we can copy with a single memcpy.
+    memcpy(aDst, aSrc, packedStride * aSrcSize.height);
+  } else {
+    // memcpy one row at a time.
+    for (int row = 0; row < aSrcSize.height; ++row) {
+      memcpy(aDst, aSrc, packedStride);
+      aSrc += aSrcStride;
+      aDst += packedStride;
+    }
+  }
+}
+
+UniquePtr<uint8_t[]> SurfaceToPackedBGRA(DataSourceSurface* aSurface) {
+  SurfaceFormat format = aSurface->GetFormat();
+  if (format != SurfaceFormat::B8G8R8A8 && format != SurfaceFormat::B8G8R8X8) {
+    return nullptr;
+  }
+
+  IntSize size = aSurface->GetSize();
+  if (size.width < 0 || size.width >= INT32_MAX / 4) {
+    return nullptr;
+  }
+  int32_t stride = size.width * 4;
+  CheckedInt<size_t> bufferSize =
+      CheckedInt<size_t>(stride) * CheckedInt<size_t>(size.height);
+  if (!bufferSize.isValid()) {
+    return nullptr;
+  }
+  UniquePtr<uint8_t[]> imageBuffer(new (std::nothrow)
+                                       uint8_t[bufferSize.value()]);
+  if (!imageBuffer) {
+    return nullptr;
+  }
+
+  DataSourceSurface::MappedSurface map;
+  if (!aSurface->Map(DataSourceSurface::MapType::READ, &map)) {
+    return nullptr;
+  }
+
+  CopySurfaceDataToPackedArray(map.mData, imageBuffer.get(), size, map.mStride,
+                               4);
+
+  aSurface->Unmap();
+
+  if (format == SurfaceFormat::B8G8R8X8) {
+    // Convert BGRX to BGRA by setting a to 255.
+    SwizzleData(imageBuffer.get(), stride, SurfaceFormat::X8R8G8B8_UINT32,
+                imageBuffer.get(), stride, SurfaceFormat::A8R8G8B8_UINT32,
+                size);
+  }
+
+  return imageBuffer;
+}
+
+uint8_t* SurfaceToPackedBGR(DataSourceSurface* aSurface) {
+  SurfaceFormat format = aSurface->GetFormat();
+  MOZ_ASSERT(format == SurfaceFormat::B8G8R8X8, "Format not supported");
+
+  if (format != SurfaceFormat::B8G8R8X8) {
+    // To support B8G8R8A8 we'd need to un-pre-multiply alpha
+    return nullptr;
+  }
+
+  IntSize size = aSurface->GetSize();
+  if (size.width < 0 || size.width >= INT32_MAX / 3) {
+    return nullptr;
+  }
+  int32_t stride = size.width * 3;
+  CheckedInt<size_t> bufferSize =
+      CheckedInt<size_t>(stride) * CheckedInt<size_t>(size.height);
+  if (!bufferSize.isValid()) {
+    return nullptr;
+  }
+  uint8_t* imageBuffer = new (std::nothrow) uint8_t[bufferSize.value()];
+  if (!imageBuffer) {
+    return nullptr;
+  }
+
+  DataSourceSurface::MappedSurface map;
+  if (!aSurface->Map(DataSourceSurface::MapType::READ, &map)) {
+    delete[] imageBuffer;
+    return nullptr;
+  }
+
+  SwizzleData(map.mData, map.mStride, SurfaceFormat::B8G8R8X8, imageBuffer,
+              stride, SurfaceFormat::B8G8R8, size);
+
+  aSurface->Unmap();
+
+  return imageBuffer;
+}
+
+void ClearDataSourceSurface(DataSourceSurface* aSurface) {
+  DataSourceSurface::MappedSurface map;
+  if (!aSurface->Map(DataSourceSurface::MapType::WRITE, &map)) {
+    MOZ_ASSERT(false, "Failed to map DataSourceSurface");
+    return;
+  }
+
+  // We avoid writing into the gaps between the rows here since we can't be
+  // sure that some drivers don't use those bytes.
+
+  uint32_t width = aSurface->GetSize().width;
+  uint32_t bytesPerRow = width * BytesPerPixel(aSurface->GetFormat());
+  uint8_t* row = map.mData;
+  // converting to size_t here because otherwise the temporaries can overflow
+  // and we can end up with |end| being a bad address!
+  uint8_t* end = row + size_t(map.mStride) * size_t(aSurface->GetSize().height);
+
+  while (row != end) {
+    memset(row, 0, bytesPerRow);
+    row += map.mStride;
+  }
+
+  aSurface->Unmap();
+}
+
+size_t BufferSizeFromStrideAndHeight(int32_t aStride, int32_t aHeight,
+                                     int32_t aExtraBytes) {
+  if (MOZ_UNLIKELY(aHeight <= 0) || MOZ_UNLIKELY(aStride <= 0)) {
+    return 0;
+  }
+
+  // We limit the length returned to values that can be represented by int32_t
+  // because we don't want to allocate buffers any bigger than that. This
+  // allows for a buffer size of over 2 GiB which is already rediculously
+  // large and will make the process janky. (Note the choice of the signed type
+  // is deliberate because we specifically don't want the returned value to
+  // overflow if someone stores the buffer length in an int32_t variable.)
+
+  CheckedInt32 requiredBytes =
+      CheckedInt32(aStride) * CheckedInt32(aHeight) + CheckedInt32(aExtraBytes);
+  if (MOZ_UNLIKELY(!requiredBytes.isValid())) {
+    gfxWarning() << "Buffer size too big; returning zero " << aStride << ", "
+                 << aHeight << ", " << aExtraBytes;
+    return 0;
+  }
+  return requiredBytes.value();
+}
+
+size_t BufferSizeFromDimensions(int32_t aWidth, int32_t aHeight, int32_t aDepth,
+                                int32_t aExtraBytes) {
+  if (MOZ_UNLIKELY(aHeight <= 0) || MOZ_UNLIKELY(aWidth <= 0) ||
+      MOZ_UNLIKELY(aDepth <= 0)) {
+    return 0;
+  }
+
+  // Similar to BufferSizeFromStrideAndHeight, but with an extra parameter.
+
+  CheckedInt32 requiredBytes =
+      CheckedInt32(aWidth) * CheckedInt32(aHeight) * CheckedInt32(aDepth) +
+      CheckedInt32(aExtraBytes);
+  if (MOZ_UNLIKELY(!requiredBytes.isValid())) {
+    gfxWarning() << "Buffer size too big; returning zero " << aWidth << ", "
+                 << aHeight << ", " << aDepth << ", " << aExtraBytes;
+    return 0;
+  }
+  return requiredBytes.value();
+}
+
+/**
+ * aSrcRect: Rect relative to the aSrc surface
+ * aDestPoint: Point inside aDest surface
+ *
+ * aSrcRect and aDestPoint are in internal local coordinates.
+ * i.e. locations of pixels and not in the same coordinate space
+ * as aSrc->GetRect()
+ */
+bool CopyRect(DataSourceSurface* aSrc, DataSourceSurface* aDest,
+              IntRect aSrcRect, IntPoint aDestPoint) {
+  if (aSrcRect.Overflows() ||
+      IntRect(aDestPoint, aSrcRect.Size()).Overflows()) {
+    MOZ_CRASH("GFX: we should never be getting invalid rects at this point");
+  }
+
+  MOZ_RELEASE_ASSERT(aSrc->GetFormat() == aDest->GetFormat(),
+                     "GFX: different surface formats");
+  MOZ_RELEASE_ASSERT(IntRect(IntPoint(), aSrc->GetSize()).Contains(aSrcRect),
+                     "GFX: source rect too big for source surface");
+  MOZ_RELEASE_ASSERT(IntRect(IntPoint(), aDest->GetSize())
+                         .Contains(IntRect(aDestPoint, aSrcRect.Size())),
+                     "GFX: dest surface too small");
+
+  if (aSrcRect.IsEmpty()) {
+    return false;
+  }
+
+  DataSourceSurface::ScopedMap srcMap(aSrc, DataSourceSurface::READ);
+  DataSourceSurface::ScopedMap destMap(aDest, DataSourceSurface::WRITE);
+  if (MOZ2D_WARN_IF(!srcMap.IsMapped() || !destMap.IsMapped())) {
+    return false;
+  }
+
+  uint8_t* sourceData =
+      DataAtOffset(aSrc, srcMap.GetMappedSurface(), aSrcRect.TopLeft());
+  uint8_t* destData =
+      DataAtOffset(aDest, destMap.GetMappedSurface(), aDestPoint);
+
+  SwizzleData(sourceData, srcMap.GetStride(), aSrc->GetFormat(), destData,
+              destMap.GetStride(), aDest->GetFormat(), aSrcRect.Size());
+
+  return true;
+}
+
+already_AddRefed<DataSourceSurface> CreateDataSourceSurfaceByCloning(
+    DataSourceSurface* aSource) {
+  RefPtr<DataSourceSurface> copy = Factory::CreateDataSourceSurface(
+      aSource->GetSize(), aSource->GetFormat(), true);
+  if (copy) {
+    CopyRect(aSource, copy, IntRect(IntPoint(), aSource->GetSize()),
+             IntPoint());
+  }
+  return copy.forget();
+}
+
+}  // namespace gfx
+}  // namespace mozilla