react-native-parity-blur 0.1.0

package/android/src/test/java/com/parityblur/MiniJson.kt

@@ -0,0 +1,179 @@
+package com.parityblur
+
+/**
+ * Minimal, dependency-free JSON parser used only by [PipelineFixturesTest] to load
+ * `test/pipeline-fixtures.json`. Deliberately hand-rolled (no Gson/Moshi/org.json dependency) so
+ * the Milestone 3 unit-test setup does not need a new external dependency resolved at build
+ * time -- the fixture file's shape (objects/arrays/numbers/strings/booleans, no unicode escapes
+ * beyond the basics) is fully covered by this small recursive-descent parser.
+ *
+ * Parses into plain Kotlin values: `Map<String, Any?>`, `List<Any?>`, `Double`, `String`,
+ * `Boolean`, or `null`.
+ */
+object MiniJson {
+
+  fun parse(text: String): Any? {
+    val p = Parser(text)
+    p.skipWhitespace()
+    val value = p.parseValue()
+    p.skipWhitespace()
+    check(p.atEnd()) { "Trailing content after JSON value at index ${p.pos}" }
+    return value
+  }
+
+  private class Parser(private val s: String) {
+    var pos = 0
+
+    fun atEnd() = pos >= s.length
+
+    fun skipWhitespace() {
+      while (pos < s.length && s[pos].isWhitespace()) pos++
+    }
+
+    fun parseValue(): Any? {
+      skipWhitespace()
+      require(pos < s.length) { "Unexpected end of JSON input" }
+      return when (s[pos]) {
+        '{' -> parseObject()
+        '[' -> parseArray()
+        '"' -> parseString()
+        't' -> parseLiteral("true", true)
+        'f' -> parseLiteral("false", false)
+        'n' -> parseLiteral("null", null)
+        else -> parseNumber()
+      }
+    }
+
+    private fun parseLiteral(literal: String, value: Any?): Any? {
+      require(s.startsWith(literal, pos)) { "Expected '$literal' at index $pos" }
+      pos += literal.length
+      return value
+    }
+
+    private fun parseObject(): Map<String, Any?> {
+      val map = LinkedHashMap<String, Any?>()
+      pos++ // '{'
+      skipWhitespace()
+      if (pos < s.length && s[pos] == '}') {
+        pos++
+        return map
+      }
+      while (true) {
+        skipWhitespace()
+        val key = parseString()
+        skipWhitespace()
+        require(pos < s.length && s[pos] == ':') { "Expected ':' at index $pos" }
+        pos++
+        val value = parseValue()
+        map[key] = value
+        skipWhitespace()
+        require(pos < s.length) { "Unterminated object" }
+        when (s[pos]) {
+          ',' -> {
+            pos++
+          }
+          '}' -> {
+            pos++
+            return map
+          }
+          else -> throw IllegalArgumentException("Expected ',' or '}' at index $pos")
+        }
+      }
+    }
+
+    private fun parseArray(): List<Any?> {
+      val list = ArrayList<Any?>()
+      pos++ // '['
+      skipWhitespace()
+      if (pos < s.length && s[pos] == ']') {
+        pos++
+        return list
+      }
+      while (true) {
+        list.add(parseValue())
+        skipWhitespace()
+        require(pos < s.length) { "Unterminated array" }
+        when (s[pos]) {
+          ',' -> {
+            pos++
+          }
+          ']' -> {
+            pos++
+            return list
+          }
+          else -> throw IllegalArgumentException("Expected ',' or ']' at index $pos")
+        }
+      }
+    }
+
+    private fun parseString(): String {
+      require(pos < s.length && s[pos] == '"') { "Expected string at index $pos" }
+      pos++
+      val sb = StringBuilder()
+      while (true) {
+        require(pos < s.length) { "Unterminated string" }
+        val c = s[pos]
+        when {
+          c == '"' -> {
+            pos++
+            return sb.toString()
+          }
+          c == '\\' -> {
+            pos++
+            require(pos < s.length) { "Unterminated escape" }
+            when (val esc = s[pos]) {
+              '"' -> sb.append('"')
+              '\\' -> sb.append('\\')
+              '/' -> sb.append('/')
+              'b' -> sb.append('\b')
+              'f' -> sb.append('\u000C')
+              'n' -> sb.append('\n')
+              'r' -> sb.append('\r')
+              't' -> sb.append('\t')
+              'u' -> {
+                val hex = s.substring(pos + 1, pos + 5)
+                sb.append(hex.toInt(16).toChar())
+                pos += 4
+              }
+              else -> throw IllegalArgumentException("Invalid escape '\\$esc' at index $pos")
+            }
+            pos++
+          }
+          else -> {
+            sb.append(c)
+            pos++
+          }
+        }
+      }
+    }
+
+    private fun parseNumber(): Double {
+      val start = pos
+      if (pos < s.length && (s[pos] == '-' || s[pos] == '+')) pos++
+      while (pos < s.length && (s[pos].isDigit() || s[pos] == '.' || s[pos] == 'e' || s[pos] == 'E' ||
+          s[pos] == '+' || s[pos] == '-')
+      ) {
+        pos++
+      }
+      val token = s.substring(start, pos)
+      require(token.isNotEmpty()) { "Expected number at index $start" }
+      return token.toDouble()
+    }
+  }
+}
+
+// -------------------------------------------------------------------- convenience accessors
+
+@Suppress("UNCHECKED_CAST")
+fun Any?.asJsonObject(): Map<String, Any?> = this as Map<String, Any?>
+
+@Suppress("UNCHECKED_CAST")
+fun Any?.asJsonArray(): List<Any?> = this as List<Any?>
+
+fun Any?.asJsonDouble(): Double = this as Double
+
+fun Any?.asJsonInt(): Int = (this as Double).toInt()
+
+fun Any?.asJsonString(): String = this as String
+
+fun Any?.asJsonBoolean(): Boolean = this as Boolean

package/android/src/test/java/com/parityblur/PipelineFixturesTest.kt

@@ -0,0 +1,222 @@
+package com.parityblur
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.File
+
+/**
+ * Loads `test/pipeline-fixtures.json` (the language-neutral fixture table shared with the JS
+ * suite, docs/PIPELINE_SPEC.md §11) and asserts every [PipelineMath] / [AndroidBlurCalibration]
+ * function matches it within 1e-6, per this milestone's required-tests brief.
+ *
+ * `parseColor` fixtures are intentionally NOT asserted here: Android's `overlayColor` native prop
+ * arrives already parsed into an ARGB Int by React Native's own color parser (see
+ * ParityBlurViewNativeComponent.ts), so there is no Kotlin string-color-parsing step to mirror
+ * (see the deviation note atop PipelineMath.kt).
+ */
+class PipelineFixturesTest {
+
+  private val fixtures: Map<String, Any?> by lazy {
+    val file = locateFixturesFile()
+    MiniJson.parse(file.readText()).asJsonObject()
+  }
+
+  private val TOL = 1e-6
+
+  private fun rows(name: String): List<Map<String, Any?>> =
+    (fixtures[name] ?: error("Missing fixture group '$name'"))
+      .asJsonArray()
+      .map { it.asJsonObject() }
+
+  private fun rectOf(map: Map<String, Any?>): PipelineMath.Rect = PipelineMath.Rect(
+    x = map.getValue("x").asJsonDouble(),
+    y = map.getValue("y").asJsonDouble(),
+    width = map.getValue("width").asJsonDouble(),
+    height = map.getValue("height").asJsonDouble()
+  )
+
+  private fun assertRectEquals(expected: PipelineMath.Rect, actual: PipelineMath.Rect, label: String) {
+    assertEquals("$label.x", expected.x, actual.x, TOL)
+    assertEquals("$label.y", expected.y, actual.y, TOL)
+    assertEquals("$label.width", expected.width, actual.width, TOL)
+    assertEquals("$label.height", expected.height, actual.height, TOL)
+  }
+
+  // ------------------------------------------------------------------------------ units.ts
+
+  @Test
+  fun sigmaPxFromDp() {
+    for (row in rows("sigmaPxFromDp")) {
+      val actual = PipelineMath.sigmaPxFromDp(
+        row.getValue("blurRadiusDp").asJsonDouble(),
+        row.getValue("displayScale").asJsonDouble()
+      )
+      assertEquals(row.toString(), row.getValue("expected").asJsonDouble(), actual, TOL)
+    }
+  }
+
+  @Test
+  fun sigmaSnapshotFromPx() {
+    for (row in rows("sigmaSnapshotFromPx")) {
+      val actual = PipelineMath.sigmaSnapshotFromPx(
+        row.getValue("sigmaPx").asJsonDouble(),
+        row.getValue("downsample").asJsonInt()
+      )
+      assertEquals(row.toString(), row.getValue("expected").asJsonDouble(), actual, TOL)
+    }
+  }
+
+  // ----------------------------------------------------------------- androidCalibration.ts
+
+  @Test
+  fun radiusForSigma() {
+    for (row in rows("radiusForSigma")) {
+      val expected = row.getValue("expected").asJsonObject()
+      val actual = AndroidBlurCalibration.radiusForSigma(row.getValue("sigmaSnapshot").asJsonDouble())
+      assertEquals("$row noBlur", expected.getValue("noBlur").asJsonBoolean(), actual.noBlur)
+      assertEquals(
+        "$row radiusPlatform",
+        expected.getValue("radiusPlatform").asJsonDouble(),
+        actual.radiusPlatform,
+        TOL
+      )
+    }
+  }
+
+  // --------------------------------------------------------------------- downsample.ts
+
+  @Test
+  fun autoDownsample() {
+    for (row in rows("autoDownsample")) {
+      val actual = PipelineMath.autoDownsample(
+        row.getValue("sigmaPx").asJsonDouble(),
+        row.getValue("captureAreaPx").asJsonDouble(),
+        row.getValue("quality").asJsonString()
+      )
+      assertEquals(row.toString(), row.getValue("expected").asJsonInt(), actual)
+    }
+  }
+
+  // -------------------------------------------------------------------- captureRect.ts
+
+  @Test
+  fun supportMarginPx() {
+    for (row in rows("supportMarginPx")) {
+      val actual = PipelineMath.supportMarginPx(row.getValue("sigmaPx").asJsonDouble())
+      assertEquals(row.toString(), row.getValue("expected").asJsonDouble(), actual, TOL)
+    }
+  }
+
+  @Test
+  fun expandCaptureRect() {
+    for (row in rows("expandCaptureRect")) {
+      val actual = PipelineMath.expandCaptureRect(
+        rectOf(row.getValue("visibleRect").asJsonObject()),
+        rectOf(row.getValue("targetBounds").asJsonObject()),
+        row.getValue("sigmaPx").asJsonDouble()
+      )
+      assertRectEquals(rectOf(row.getValue("expected").asJsonObject()), actual, row.toString())
+    }
+  }
+
+  @Test
+  fun snapshotRectFor() {
+    for (row in rows("snapshotRectFor")) {
+      val actual = PipelineMath.snapshotRectFor(
+        rectOf(row.getValue("captureRectPx").asJsonObject()),
+        row.getValue("downsample").asJsonInt()
+      )
+      assertRectEquals(rectOf(row.getValue("expected").asJsonObject()), actual, row.toString())
+    }
+  }
+
+  @Test
+  fun cropRectFor() {
+    for (row in rows("cropRectFor")) {
+      val downsample = row.getValue("downsample").asJsonInt()
+      // The fixture provides captureRectPx (not the intermediate snapshotRect); derive the
+      // snapshot rect first exactly as the real pipeline sequences it (expand -> snapshotRectFor
+      // -> cropRectFor -- see PipelineMath.kt / captureRect.ts buildCapturePlan).
+      val snapshotRect = PipelineMath.snapshotRectFor(
+        rectOf(row.getValue("captureRectPx").asJsonObject()),
+        downsample
+      )
+      val actual = PipelineMath.cropRectFor(
+        rectOf(row.getValue("visibleRect").asJsonObject()),
+        snapshotRect,
+        downsample
+      )
+      assertRectEquals(rectOf(row.getValue("expected").asJsonObject()), actual, row.toString())
+    }
+  }
+
+  // -------------------------------------------------------------------- saturation.ts
+
+  @Test
+  fun saturationMatrix() {
+    for (row in rows("saturationMatrix")) {
+      val expected = row.getValue("expected").asJsonArray().map { it.asJsonDouble() }
+      val actual = PipelineMath.saturationMatrix(row.getValue("s").asJsonDouble())
+      assertEquals(20, expected.size)
+      assertEquals(20, actual.size)
+      for (i in 0 until 20) {
+        assertEquals("$row [$i]", expected[i], actual[i], TOL)
+      }
+    }
+  }
+
+  // ----------------------------------------------------------------------- overlay.ts
+
+  @Test
+  fun sourceOver() {
+    for (row in rows("sourceOver")) {
+      fun rgba(key: String): PipelineMath.RGBA {
+        val m = row.getValue(key).asJsonObject()
+        return PipelineMath.RGBA(
+          m.getValue("r").asJsonDouble(),
+          m.getValue("g").asJsonDouble(),
+          m.getValue("b").asJsonDouble(),
+          m.getValue("a").asJsonDouble()
+        )
+      }
+      val expected = rgba("expected")
+      val actual = PipelineMath.sourceOver(rgba("src"), rgba("dst"))
+      assertEquals("$row r", expected.r, actual.r, TOL)
+      assertEquals("$row g", expected.g, actual.g, TOL)
+      assertEquals("$row b", expected.b, actual.b, TOL)
+      assertEquals("$row a", expected.a, actual.a, TOL)
+    }
+  }
+
+  // -------------------------------------------------------------------------- fixture lookup
+
+  private fun locateFixturesFile(): File {
+    val cwd = File(System.getProperty("user.dir") ?: ".").absoluteFile
+    val candidates = LinkedHashSet<File>()
+    candidates += File(cwd, "../test/pipeline-fixtures.json")
+    candidates += File(cwd, "test/pipeline-fixtures.json")
+    // Defensive fallback: walk upward from the working dir (bounded, not a filesystem scan)
+    // in case the test task's working directory differs from the usual module dir.
+    var dir: File? = cwd
+    var steps = 0
+    while (dir != null && steps < 6) {
+      candidates += File(dir, "test/pipeline-fixtures.json")
+      dir = dir.parentFile
+      steps++
+    }
+    for (candidate in candidates) {
+      val resolved = runCatching { candidate.canonicalFile }.getOrNull() ?: continue
+      if (resolved.isFile) return resolved
+    }
+    throw AssertionError(
+      "Could not locate test/pipeline-fixtures.json (cwd=$cwd). Checked: " +
+        candidates.joinToString { it.path }
+    )
+  }
+
+  @Test
+  fun fixtureFileIsFound() {
+    assertTrue(locateFixturesFile().isFile)
+  }
+}

package/ios/BlurEngine.swift

@@ -0,0 +1,106 @@
+import Foundation
+import Metal
+import MetalPerformanceShaders
+import UIKit
+
+/// Process-wide blur engine (plan §15.1, §26, §27).
+///
+/// Created LAZILY the first time an eligible blur view actually needs blur resources — never at
+/// module load, package link, or view init. Reduce-Transparency fallback instances and views
+/// that never reach an eligible capture state must never call `BlurEngine.shared()`.
+final class BlurEngine {
+
+  private static var _shared: BlurEngine?
+  static var isInitialized: Bool { _shared != nil }
+
+  /// Lazy accessor. Returns nil when Metal is unavailable (the caller falls back to
+  /// fallbackColor rendering — plan §25/§27 fallback instances allocate nothing).
+  static func shared() -> BlurEngine? {
+    if let s = _shared { return s }
+    guard let device = MTLCreateSystemDefaultDevice(),
+          let queue = device.makeCommandQueue() else {
+      return nil
+    }
+    let s = BlurEngine(device: device, queue: queue)
+    _shared = s
+    ParityBlurDebug.log("engine-init")
+    return s
+  }
+
+  let device: MTLDevice
+  let queue: MTLCommandQueue
+
+  /// MPS gaussian kernel cache keyed by sigma quantized to 1/16 (bounds cache size; a 1/16-px
+  /// sigma step is far below visible threshold). Cleared on memory pressure.
+  private var kernelCache: [Int: MPSImageGaussianBlur] = [:]
+
+  /// Compiled post-process pipeline (crop + saturation + overlay — ColorPipeline.swift).
+  private var postPipeline: MTLComputePipelineState?
+  private var linearSampler: MTLSamplerState?
+
+  /// Per-window contexts, weakly keyed so they die with their window (plan §15.2, §26).
+  private let windowContexts = NSMapTable<UIWindow, WindowBlurContext>.weakToStrongObjects()
+
+  private var memoryWarningObserver: NSObjectProtocol?
+
+  private init(device: MTLDevice, queue: MTLCommandQueue) {
+    self.device = device
+    self.queue = queue
+    memoryWarningObserver = NotificationCenter.default.addObserver(
+      forName: UIApplication.didReceiveMemoryWarningNotification,
+      object: nil,
+      queue: .main
+    ) { [weak self] _ in
+      self?.handleMemoryWarning()
+    }
+  }
+
+  func gaussian(sigma: Float) -> MPSImageGaussianBlur {
+    let key = max(1, Int((sigma * 16).rounded()))
+    if let k = kernelCache[key] { return k }
+    let k = MPSImageGaussianBlur(device: device, sigma: Float(key) / 16.0)
+    k.edgeMode = .clamp // spec §5: CLAMP on the clamped outer boundary, both platforms
+    kernelCache[key] = k
+    return k
+  }
+
+  /// Lazily compiled compute pipeline for the post pass. Returns nil on compile failure
+  /// (callers fall back to a plain blit — blur-only, no saturation/overlay — and log once).
+  func postProcessPipeline() -> MTLComputePipelineState? {
+    if let p = postPipeline { return p }
+    do {
+      let library = try device.makeLibrary(source: ColorPipeline.metalSource, options: nil)
+      guard let fn = library.makeFunction(name: "parityblur_post") else { return nil }
+      let p = try device.makeComputePipelineState(function: fn)
+      postPipeline = p
+      return p
+    } catch {
+      NSLog("[ParityBlur] post-process kernel compile failed: %@", "\(error)")
+      return nil
+    }
+  }
+
+  func sampler() -> MTLSamplerState? {
+    if let s = linearSampler { return s }
+    let desc = MTLSamplerDescriptor()
+    desc.minFilter = .linear
+    desc.magFilter = .linear // spec §3.4/§9.12: bilinear resolves the fractional crop origin
+    desc.sAddressMode = .clampToEdge
+    desc.tAddressMode = .clampToEdge
+    linearSampler = device.makeSamplerState(descriptor: desc)
+    return linearSampler
+  }
+
+  func windowContext(for window: UIWindow) -> WindowBlurContext {
+    if let ctx = windowContexts.object(forKey: window) { return ctx }
+    let ctx = WindowBlurContext()
+    windowContexts.setObject(ctx, forKey: window)
+    return ctx
+  }
+
+  private func handleMemoryWarning() {
+    // Plan §26: trim caches; per-view snapshot buffers are trimmed by their owners via this
+    // same notification. Kernels and the pipeline recompile/reallocate lazily on next use.
+    kernelCache.removeAll()
+  }
+}

package/ios/ColorPipeline.swift

@@ -0,0 +1,72 @@
+import Foundation
+import simd
+
+/// Post-blur color pass (spec §9 steps 9-11): fractional crop (bilinear), saturation matrix,
+/// overlay source-over — one compute dispatch writing straight into the CAMetalLayer drawable.
+/// All math matches PipelineMath/{saturationMatrix,sourceOver} exactly; the fixture suite pins
+/// the CPU reference, and M5 calibration compares the GPU output cross-platform.
+enum ColorPipeline {
+
+  /// Uniforms layout shared with the MSL kernel below (float4 alignment).
+  struct Uniforms {
+    /// Fractional crop origin inside the blurred snapshot texture, snapshot px.
+    var cropOrigin: SIMD2<Float>
+    var _pad: SIMD2<Float> = .zero
+    /// Saturation matrix rows (RGB coefficients only; offsets are all 0 per spec §7).
+    var satR: SIMD4<Float>
+    var satG: SIMD4<Float>
+    var satB: SIMD4<Float>
+    /// Overlay color, STRAIGHT alpha (spec §8).
+    var overlay: SIMD4<Float>
+  }
+
+  static func uniforms(
+    cropX: Double, cropY: Double, saturation: Double, overlay: PipelineMath.RGBA
+  ) -> Uniforms {
+    let m = PipelineMath.saturationMatrix(saturation)
+    return Uniforms(
+      cropOrigin: SIMD2(Float(cropX), Float(cropY)),
+      satR: SIMD4(Float(m[0]), Float(m[1]), Float(m[2]), 0),
+      satG: SIMD4(Float(m[5]), Float(m[6]), Float(m[7]), 0),
+      satB: SIMD4(Float(m[10]), Float(m[11]), Float(m[12]), 0),
+      overlay: SIMD4(Float(overlay.r), Float(overlay.g), Float(overlay.b), Float(overlay.a))
+    )
+  }
+
+  /// v1 backdrop is opaque (spec §6): source-over reduces to srcC*srcA + dstC*(1-srcA), out a=1.
+  /// The sampler is linear so the fractional crop origin is resolved by bilinear filtering
+  /// (spec §3.4); reads are raw encoded values (gamma-space, .bgra8Unorm view) so saturation and
+  /// overlay composite in the same domain as Android's ColorMatrix/Paint pipeline.
+  static let metalSource = """
+  #include <metal_stdlib>
+  using namespace metal;
+
+  struct PBUniforms {
+    float2 cropOrigin;
+    float2 _pad;
+    float4 satR;
+    float4 satG;
+    float4 satB;
+    float4 overlay;
+  };
+
+  kernel void parityblur_post(
+      texture2d<float, access::sample> src [[texture(0)]],
+      texture2d<float, access::write> dst [[texture(1)]],
+      sampler linearSampler [[sampler(0)]],
+      constant PBUniforms &u [[buffer(0)]],
+      uint2 gid [[thread_position_in_grid]]) {
+    if (gid.x >= dst.get_width() || gid.y >= dst.get_height()) {
+      return;
+    }
+    float2 srcSize = float2(src.get_width(), src.get_height());
+    float2 coord = (u.cropOrigin + float2(gid) + 0.5) / srcSize;
+    float3 c = src.sample(linearSampler, coord).rgb;
+    float3 sat = clamp(
+        float3(dot(c, u.satR.rgb), dot(c, u.satG.rgb), dot(c, u.satB.rgb)),
+        0.0, 1.0);
+    float3 outc = u.overlay.rgb * u.overlay.a + sat * (1.0 - u.overlay.a);
+    dst.write(float4(outc, 1.0), gid);
+  }
+  """
+}

package/ios/MetalPresentationSurface.swift

@@ -0,0 +1,51 @@
+import UIKit
+
+/// CAMetalLayer-backed presentation surface (plan §15.5): the blurred result is composited by
+/// Core Animation directly from the drawable — zero GPU→CPU readback in the present path
+/// (M0-verified). The layer bilinearly scales drawable pixels up to the view's bounds, which is
+/// the spec §9.12 upsample step.
+final class MetalPresentationView: UIView {
+  override class var layerClass: AnyClass { CAMetalLayer.self }
+  var metalLayer: CAMetalLayer { layer as! CAMetalLayer }
+
+  private let maskLayer = CAShapeLayer()
+  private var cornerRadii: [CGFloat] = [0, 0, 0, 0] // TL, TR, BR, BL
+
+  /// Rounded clipping of the blur OUTPUT only (plan §31): children are siblings of this view
+  /// and keep normal RN overflow semantics.
+  func setCornerRadii(topLeft: CGFloat, topRight: CGFloat, bottomRight: CGFloat, bottomLeft: CGFloat) {
+    let next = [topLeft, topRight, bottomRight, bottomLeft]
+    guard next != cornerRadii else { return }
+    cornerRadii = next
+    updateMask()
+  }
+
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    updateMask()
+  }
+
+  private func updateMask() {
+    let (tl, tr, br, bl) = (cornerRadii[0], cornerRadii[1], cornerRadii[2], cornerRadii[3])
+    if tl <= 0 && tr <= 0 && br <= 0 && bl <= 0 {
+      layer.mask = nil
+      return
+    }
+    let path = CGMutablePath()
+    let r = bounds
+    guard r.width > 0, r.height > 0 else { return }
+    path.move(to: CGPoint(x: r.minX + tl, y: r.minY))
+    path.addLine(to: CGPoint(x: r.maxX - tr, y: r.minY))
+    path.addArc(tangent1End: CGPoint(x: r.maxX, y: r.minY), tangent2End: CGPoint(x: r.maxX, y: r.minY + tr), radius: max(tr, 0.001))
+    path.addLine(to: CGPoint(x: r.maxX, y: r.maxY - br))
+    path.addArc(tangent1End: CGPoint(x: r.maxX, y: r.maxY), tangent2End: CGPoint(x: r.maxX - br, y: r.maxY), radius: max(br, 0.001))
+    path.addLine(to: CGPoint(x: r.minX + bl, y: r.maxY))
+    path.addArc(tangent1End: CGPoint(x: r.minX, y: r.maxY), tangent2End: CGPoint(x: r.minX, y: r.maxY - bl), radius: max(bl, 0.001))
+    path.addLine(to: CGPoint(x: r.minX, y: r.minY + tl))
+    path.addArc(tangent1End: CGPoint(x: r.minX, y: r.minY), tangent2End: CGPoint(x: r.minX + tl, y: r.minY), radius: max(tl, 0.001))
+    path.closeSubpath()
+    maskLayer.frame = bounds
+    maskLayer.path = path
+    layer.mask = maskLayer
+  }
+}