react-native-photo-video-editor 0.1.0

package/android/src/main/java/com/photovideoeditor/editor/README.md

@@ -0,0 +1,5 @@
+# Planned Android editor
+
+Milestone one contains no editing engine. A future full-screen editor will use Media3 Player for preview, Media3 Transformer for supported video transformations and export, Canvas/Bitmap for basic photo composition, and coroutines for asynchronous work. OpenGL ES or a deliberate GPU abstraction will be introduced only if measured real-time filter requirements justify it.
+
+`content://` inputs will be read through `ContentResolver`. Cache and output files will be streamed and lifecycle-managed without loading entire videos into memory. Gallery permissions will only be requested by a consuming app when gallery saving is explicitly enabled.

package/android/src/main/java/com/photovideoeditor/files/SourceResolver.kt

@@ -0,0 +1,29 @@
+package com.photovideoeditor.files
+
+import android.content.Context
+import android.net.Uri
+import java.io.File
+
+/**
+ * Resolves an editor source uri (file://, content://, or a bare path) to a
+ * local filesystem path that platform decoders (BitmapFactory, ExifInterface)
+ * can read directly. content:// sources are copied to a cache-dir temp file
+ * since those decoders require a real path.
+ */
+object SourceResolver {
+  fun resolvePath(context: Context, sourceUri: String, tempPrefix: String): String? {
+    val uri = Uri.parse(sourceUri)
+    return when (uri.scheme) {
+      "file", null -> uri.path ?: sourceUri
+      "content" -> {
+        val tempFile = File.createTempFile(tempPrefix, ".tmp", context.cacheDir)
+        val copied = context.contentResolver.openInputStream(uri)?.use { input ->
+          tempFile.outputStream().use { output -> input.copyTo(output) }
+          true
+        } ?: false
+        if (copied) tempFile.absolutePath else null
+      }
+      else -> null
+    }
+  }
+}

package/android/src/main/java/com/photovideoeditor/media/BitmapSampling.kt

@@ -0,0 +1,11 @@
+package com.photovideoeditor.media
+
+/** Pure sizing policy shared by previews and overlay decoding. */
+object BitmapSampling {
+  fun inSampleSize(width: Int, height: Int, maxEdge: Int): Int {
+    if (width <= 0 || height <= 0 || maxEdge <= 0) return 1
+    var sample = 1
+    while (maxOf(width, height) / (sample * 2) >= maxEdge) sample *= 2
+    return sample
+  }
+}

package/android/src/main/java/com/photovideoeditor/model/EditorRequest.kt

@@ -0,0 +1,3 @@
+package com.photovideoeditor.model
+
+internal data class EditorRequest(val uri: String, val mediaType: String, val mimeType: String?)

package/android/src/main/java/com/photovideoeditor/photo/export/PhotoExporter.kt

@@ -0,0 +1,201 @@
+package com.photovideoeditor.photo.export
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import android.net.Uri
+import android.os.Build
+import androidx.exifinterface.media.ExifInterface
+import com.photovideoeditor.files.SourceResolver
+import com.photovideoeditor.photo.render.PhotoAdjustmentRenderer
+import com.photovideoeditor.photo.render.PhotoAdjustments
+import com.photovideoeditor.photo.render.PhotoLayer
+import com.photovideoeditor.photo.render.PhotoLayerRenderer
+import com.photovideoeditor.photo.render.PhotoTransformState
+import org.json.JSONObject
+import java.io.File
+import java.io.FileOutputStream
+import java.util.UUID
+import kotlin.math.roundToInt
+
+data class PhotoExportResult(
+  val uri: String,
+  val width: Int,
+  val height: Int,
+  val fileSize: Long,
+  val mimeType: String
+)
+
+class PhotoExportException(val code: String, message: String) : Exception(message)
+
+/**
+ * Applies a [PhotoTransformState] to the full-resolution source photo and
+ * writes the result to a new file in the app cache dir. The source file is
+ * never modified. Bitmaps are downsampled to the requested export bounds (or
+ * a safe default) to avoid decoding an unbounded full-resolution image twice.
+ */
+object PhotoExporter {
+  private const val DEFAULT_MAX_DIMENSION = 4096
+
+  fun export(
+    context: Context,
+    sourceUri: String,
+    transform: PhotoTransformState,
+    adjustments: PhotoAdjustments,
+    layers: List<PhotoLayer>,
+    exportOptions: JSONObject?
+  ): PhotoExportResult {
+    val path = SourceResolver.resolvePath(context, sourceUri, "pve_export")
+      ?: throw PhotoExportException("E_SOURCE_NOT_FOUND", "The selected photo could not be found.")
+
+    val exif = try { ExifInterface(path) } catch (_: Exception) { null }
+    val exifOrientation = exif?.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
+      ?: ExifInterface.ORIENTATION_NORMAL
+
+    val maxWidth = exportOptions?.optInt("maxWidth", 0)?.takeIf { it > 0 }
+    val maxHeight = exportOptions?.optInt("maxHeight", 0)?.takeIf { it > 0 }
+
+    val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    BitmapFactory.decodeFile(path, bounds)
+    if (bounds.outWidth <= 0 || bounds.outHeight <= 0) {
+      throw PhotoExportException("E_SOURCE_UNREADABLE", "The selected photo could not be decoded.")
+    }
+
+    val decodeTarget = maxOf(maxWidth ?: DEFAULT_MAX_DIMENSION, maxHeight ?: DEFAULT_MAX_DIMENSION)
+    val sampleSize = computeSampleSize(bounds.outWidth, bounds.outHeight, decodeTarget)
+    val decoded = BitmapFactory.decodeFile(path, BitmapFactory.Options().apply { inSampleSize = sampleSize })
+      ?: throw PhotoExportException("E_OUT_OF_MEMORY", "The photo is too large to process on this device.")
+
+    val upright = applyExifOrientation(decoded, exifOrientation)
+    val transformed = applyTransform(upright, transform)
+    val adjusted = PhotoAdjustmentRenderer.apply(transformed, adjustments)
+    val layered = PhotoLayerRenderer.render(adjusted, layers) { uri -> resolveImageUri(context, uri) }
+    val cropped = cropBitmap(layered, transform)
+    val resized = resizeToFit(cropped, maxWidth, maxHeight)
+
+    val format = exportOptions?.optString("imageFormat", "jpeg")?.lowercase() ?: "jpeg"
+    val quality = qualityFor(exportOptions?.optString("quality", "high") ?: "high")
+    val (compressFormat, mimeType, extension) = encodingFor(format)
+
+    val outputDir = File(context.cacheDir, "photovideoeditor").apply { mkdirs() }
+    val outputFile = File(outputDir, "${UUID.randomUUID()}.$extension")
+    FileOutputStream(outputFile).use { stream ->
+      if (!resized.compress(compressFormat, quality, stream)) {
+        throw PhotoExportException("E_EXPORT_FAILED", "Unable to encode the exported photo.")
+      }
+    }
+
+    if (format == "jpeg" && (exportOptions?.optBoolean("preserveMetadata", true) != false)) {
+      preserveMetadata(exif, outputFile.absolutePath)
+    }
+
+    if (decoded !== upright) decoded.recycle()
+    if (upright !== transformed) upright.recycle()
+    if (transformed !== adjusted) transformed.recycle()
+    if (adjusted !== layered) adjusted.recycle()
+    if (layered !== cropped) layered.recycle()
+    if (cropped !== resized) cropped.recycle()
+
+    return PhotoExportResult(
+      uri = Uri.fromFile(outputFile).toString(),
+      width = resized.width,
+      height = resized.height,
+      fileSize = outputFile.length(),
+      mimeType = mimeType
+    )
+  }
+
+  private fun resolveImageUri(context: Context, uri: String): Bitmap? {
+    val path = SourceResolver.resolvePath(context, uri, "pve_layer_image_export") ?: return null
+    return BitmapFactory.decodeFile(path)
+  }
+
+  private fun computeSampleSize(width: Int, height: Int, target: Int): Int {
+    var sample = 1
+    while (width / (sample * 2) >= target && height / (sample * 2) >= target) sample *= 2
+    return sample
+  }
+
+  private fun applyExifOrientation(bitmap: Bitmap, orientation: Int): Bitmap {
+    val matrix = Matrix()
+    when (orientation) {
+      ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
+      ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
+      ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
+      ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.postScale(-1f, 1f)
+      ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.postScale(1f, -1f)
+      else -> return bitmap
+    }
+    return Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
+  }
+
+  private fun applyTransform(bitmap: Bitmap, transform: PhotoTransformState): Bitmap {
+    if (transform.rotationDegrees == 0 && transform.straightenDegrees == 0f) return bitmap
+    return Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, transform.toMatrix(), true)
+  }
+
+  private fun cropBitmap(bitmap: Bitmap, transform: PhotoTransformState): Bitmap {
+    if (transform.cropLeft <= 0f && transform.cropTop <= 0f && transform.cropRight >= 1f && transform.cropBottom >= 1f) {
+      return bitmap
+    }
+    val left = (transform.cropLeft * bitmap.width).roundToInt().coerceIn(0, bitmap.width - 1)
+    val top = (transform.cropTop * bitmap.height).roundToInt().coerceIn(0, bitmap.height - 1)
+    val right = (transform.cropRight * bitmap.width).roundToInt().coerceIn(left + 1, bitmap.width)
+    val bottom = (transform.cropBottom * bitmap.height).roundToInt().coerceIn(top + 1, bitmap.height)
+    return Bitmap.createBitmap(bitmap, left, top, right - left, bottom - top)
+  }
+
+  private fun resizeToFit(bitmap: Bitmap, maxWidth: Int?, maxHeight: Int?): Bitmap {
+    if (maxWidth == null && maxHeight == null) return bitmap
+    val widthLimit = maxWidth ?: bitmap.width
+    val heightLimit = maxHeight ?: bitmap.height
+    if (bitmap.width <= widthLimit && bitmap.height <= heightLimit) return bitmap
+    val scale = minOf(widthLimit.toFloat() / bitmap.width, heightLimit.toFloat() / bitmap.height)
+    val targetWidth = (bitmap.width * scale).roundToInt().coerceAtLeast(1)
+    val targetHeight = (bitmap.height * scale).roundToInt().coerceAtLeast(1)
+    return Bitmap.createScaledBitmap(bitmap, targetWidth, targetHeight, true)
+  }
+
+  private fun qualityFor(preset: String): Int = when (preset) {
+    "low" -> 50
+    "medium" -> 75
+    "original" -> 100
+    else -> 90
+  }
+
+  @Suppress("DEPRECATION")
+  private fun legacyWebp() = Bitmap.CompressFormat.WEBP
+
+  private fun encodingFor(format: String): Triple<Bitmap.CompressFormat, String, String> = when (format) {
+    "png" -> Triple(Bitmap.CompressFormat.PNG, "image/png", "png")
+    "webp" -> Triple(
+      if (Build.VERSION.SDK_INT >= 30) Bitmap.CompressFormat.WEBP_LOSSY else legacyWebp(),
+      "image/webp",
+      "webp"
+    )
+    else -> Triple(Bitmap.CompressFormat.JPEG, "image/jpeg", "jpg")
+  }
+
+  private fun preserveMetadata(source: ExifInterface?, outputPath: String) {
+    if (source == null) return
+    try {
+      val output = ExifInterface(outputPath)
+      listOf(
+        ExifInterface.TAG_DATETIME,
+        ExifInterface.TAG_DATETIME_DIGITIZED,
+        ExifInterface.TAG_MAKE,
+        ExifInterface.TAG_MODEL,
+        ExifInterface.TAG_GPS_LATITUDE,
+        ExifInterface.TAG_GPS_LATITUDE_REF,
+        ExifInterface.TAG_GPS_LONGITUDE,
+        ExifInterface.TAG_GPS_LONGITUDE_REF
+      ).forEach { tag -> source.getAttribute(tag)?.let { output.setAttribute(tag, it) } }
+      // Pixels are already upright post-transform; the copied source orientation tag must not be reapplied.
+      output.setAttribute(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL.toString())
+      output.saveAttributes()
+    } catch (_: Exception) {
+      // Best-effort only; a metadata write failure must not fail the export.
+    }
+  }
+}

package/android/src/main/java/com/photovideoeditor/photo/render/OverlayGeometry.kt

@@ -0,0 +1,22 @@
+package com.photovideoeditor.photo.render
+
+/** Pure coordinate mapping shared by preview and export renderers. */
+object OverlayGeometry {
+  data class Transform(
+    val centerX: Float,
+    val centerY: Float,
+    val scale: Float,
+    val rotationDegrees: Float,
+    val opacity: Float,
+    val shortSide: Float,
+  )
+
+  fun map(layer: PhotoLayer, frameWidth: Int, frameHeight: Int): Transform = Transform(
+    centerX = layer.x * frameWidth,
+    centerY = layer.y * frameHeight,
+    scale = layer.scale,
+    rotationDegrees = layer.rotationDegrees,
+    opacity = layer.opacity.coerceIn(0f, 1f),
+    shortSide = minOf(frameWidth, frameHeight).toFloat(),
+  )
+}

package/android/src/main/java/com/photovideoeditor/photo/render/PhotoAdjustmentRenderer.kt

@@ -0,0 +1,160 @@
+package com.photovideoeditor.photo.render
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.ColorMatrix
+import android.graphics.ColorMatrixColorFilter
+import android.graphics.Matrix
+import android.graphics.Paint
+import kotlin.math.pow
+import kotlin.math.roundToInt
+
+/**
+ * Applies the non-destructive [PhotoAdjustments] stack to a bitmap. The live
+ * preview and the exporter both call this, in this exact order, so what the
+ * user sees always matches what gets exported:
+ *
+ * color matrix (brightness/contrast/saturation/exposure/temperature) ->
+ * blur -> mirror -> preset filter blend.
+ */
+object PhotoAdjustmentRenderer {
+  fun apply(source: Bitmap, adjustments: PhotoAdjustments): Bitmap {
+    if (adjustments.isIdentity) return source
+    var bitmap = applyColorMatrix(source, adjustments)
+    if (adjustments.blurRadius >= 1f) bitmap = applyBoxBlur(bitmap, adjustments.blurRadius.roundToInt())
+    if (adjustments.mirror) bitmap = applyMirror(bitmap)
+    adjustments.filterPreset?.let { preset -> bitmap = applyPreset(bitmap, preset, adjustments.filterStrength / 100f) }
+    return bitmap
+  }
+
+  private fun applyColorMatrix(source: Bitmap, adjustments: PhotoAdjustments): Bitmap {
+    if (adjustments.brightness == 0f && adjustments.contrast == 0f && adjustments.saturation == 0f &&
+      adjustments.exposure == 0f && adjustments.temperature == 0f
+    ) return source
+
+    val matrix = ColorMatrix()
+    matrix.postConcat(scaleMatrix(2f.pow(adjustments.exposure / 100f)))
+    matrix.postConcat(translateMatrix(adjustments.brightness / 100f * 80f))
+    matrix.postConcat(contrastMatrix((adjustments.contrast + 100f) / 100f))
+    matrix.postConcat(ColorMatrix().apply { setSaturation((adjustments.saturation + 100f) / 100f) })
+    matrix.postConcat(temperatureMatrix(adjustments.temperature / 100f * 40f))
+
+    val result = Bitmap.createBitmap(source.width, source.height, Bitmap.Config.ARGB_8888)
+    Canvas(result).drawBitmap(source, 0f, 0f, Paint(Paint.ANTI_ALIAS_FLAG).apply { colorFilter = ColorMatrixColorFilter(matrix) })
+    return result
+  }
+
+  private fun scaleMatrix(scale: Float) = ColorMatrix(
+    floatArrayOf(
+      scale, 0f, 0f, 0f, 0f,
+      0f, scale, 0f, 0f, 0f,
+      0f, 0f, scale, 0f, 0f,
+      0f, 0f, 0f, 1f, 0f
+    )
+  )
+
+  private fun translateMatrix(offset: Float) = ColorMatrix(
+    floatArrayOf(
+      1f, 0f, 0f, 0f, offset,
+      0f, 1f, 0f, 0f, offset,
+      0f, 0f, 1f, 0f, offset,
+      0f, 0f, 0f, 1f, 0f
+    )
+  )
+
+  private fun contrastMatrix(scale: Float): ColorMatrix {
+    val translate = 128f * (1f - scale)
+    return ColorMatrix(
+      floatArrayOf(
+        scale, 0f, 0f, 0f, translate,
+        0f, scale, 0f, 0f, translate,
+        0f, 0f, scale, 0f, translate,
+        0f, 0f, 0f, 1f, 0f
+      )
+    )
+  }
+
+  private fun temperatureMatrix(tempShift: Float) = ColorMatrix(
+    floatArrayOf(
+      1f, 0f, 0f, 0f, tempShift,
+      0f, 1f, 0f, 0f, 0f,
+      0f, 0f, 1f, 0f, -tempShift,
+      0f, 0f, 0f, 1f, 0f
+    )
+  )
+
+  /** Same box-blur approximation used by the Blur adjustment slider. */
+  fun blur(source: Bitmap, radiusPx: Int): Bitmap = applyBoxBlur(source, radiusPx.coerceIn(1, 40))
+
+  /** Approximate Gaussian blur via three passes of separable box blur — a standard, cheap approximation. */
+  private fun applyBoxBlur(source: Bitmap, radius: Int): Bitmap {
+    val width = source.width
+    val height = source.height
+    var pixels = IntArray(width * height)
+    source.getPixels(pixels, 0, width, 0, 0, width, height)
+    repeat(3) {
+      pixels = boxBlurPass(pixels, width, height, radius, horizontal = true)
+      pixels = boxBlurPass(pixels, width, height, radius, horizontal = false)
+    }
+    val result = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    result.setPixels(pixels, 0, width, 0, 0, width, height)
+    return result
+  }
+
+  private fun boxBlurPass(pixels: IntArray, width: Int, height: Int, radius: Int, horizontal: Boolean): IntArray {
+    val output = IntArray(pixels.size)
+    val outerLimit = if (horizontal) height else width
+    val innerLimit = if (horizontal) width else height
+    for (outer in 0 until outerLimit) {
+      for (inner in 0 until innerLimit) {
+        var alpha = 0
+        var red = 0
+        var green = 0
+        var blue = 0
+        var count = 0
+        for (offset in -radius..radius) {
+          val sampleInner = (inner + offset).coerceIn(0, innerLimit - 1)
+          val index = if (horizontal) outer * width + sampleInner else sampleInner * width + outer
+          val pixel = pixels[index]
+          alpha += (pixel shr 24) and 0xFF
+          red += (pixel shr 16) and 0xFF
+          green += (pixel shr 8) and 0xFF
+          blue += pixel and 0xFF
+          count++
+        }
+        val outIndex = if (horizontal) outer * width + inner else inner * width + outer
+        output[outIndex] = ((alpha / count) shl 24) or ((red / count) shl 16) or ((green / count) shl 8) or (blue / count)
+      }
+    }
+    return output
+  }
+
+  /** Mirrors the left half of the image onto the right half. */
+  private fun applyMirror(source: Bitmap): Bitmap {
+    if (source.width < 2) return source
+    val halfWidth = source.width / 2
+    val leftHalf = Bitmap.createBitmap(source, 0, 0, halfWidth, source.height)
+    val result = Bitmap.createBitmap(source.width, source.height, Bitmap.Config.ARGB_8888)
+    val canvas = Canvas(result)
+    canvas.drawBitmap(leftHalf, 0f, 0f, null)
+    val flipMatrix = Matrix().apply {
+      postScale(-1f, 1f)
+      postTranslate(source.width.toFloat(), 0f)
+    }
+    canvas.drawBitmap(leftHalf, flipMatrix, null)
+    return result
+  }
+
+  private fun applyPreset(source: Bitmap, preset: String, strength: Float): Bitmap {
+    val matrix = PhotoFilterPresets.matrixFor(preset) ?: return source
+    val filtered = Bitmap.createBitmap(source.width, source.height, Bitmap.Config.ARGB_8888)
+    Canvas(filtered).drawBitmap(source, 0f, 0f, Paint(Paint.ANTI_ALIAS_FLAG).apply { colorFilter = ColorMatrixColorFilter(matrix) })
+    if (strength >= 1f) return filtered
+
+    val blended = Bitmap.createBitmap(source.width, source.height, Bitmap.Config.ARGB_8888)
+    val canvas = Canvas(blended)
+    canvas.drawBitmap(source, 0f, 0f, null)
+    canvas.drawBitmap(filtered, 0f, 0f, Paint(Paint.ANTI_ALIAS_FLAG).apply { alpha = (strength * 255f).roundToInt().coerceIn(0, 255) })
+    return blended
+  }
+}

package/android/src/main/java/com/photovideoeditor/photo/render/PhotoAdjustments.kt

@@ -0,0 +1,55 @@
+package com.photovideoeditor.photo.render
+
+/**
+ * Non-destructive photo adjustment stack (Milestone 3). Every numeric field
+ * has a documented range and a zero/no-op default so "reset" is always just
+ * `PhotoAdjustments()`.
+ */
+data class PhotoAdjustments(
+  val brightness: Float = 0f, // -100..100
+  val contrast: Float = 0f, // -100..100
+  val saturation: Float = 0f, // -100..100
+  val exposure: Float = 0f, // -100..100
+  val temperature: Float = 0f, // -100..100
+  val blurRadius: Float = 0f, // 0..25 (px)
+  val mirror: Boolean = false,
+  val filterPreset: String? = null,
+  val filterStrength: Float = 100f // 0..100, only meaningful when filterPreset is set
+) {
+  val isIdentity: Boolean get() = this == PhotoAdjustments()
+
+  fun value(key: String): Float = when (key) {
+    "brightness" -> brightness
+    "contrast" -> contrast
+    "saturation" -> saturation
+    "exposure" -> exposure
+    "temperature" -> temperature
+    "blurRadius" -> blurRadius
+    "filterStrength" -> filterStrength
+    else -> 0f
+  }
+
+  fun with(key: String, value: Float): PhotoAdjustments = when (key) {
+    "brightness" -> copy(brightness = value)
+    "contrast" -> copy(contrast = value)
+    "saturation" -> copy(saturation = value)
+    "exposure" -> copy(exposure = value)
+    "temperature" -> copy(temperature = value)
+    "blurRadius" -> copy(blurRadius = value)
+    "filterStrength" -> copy(filterStrength = value)
+    else -> this
+  }
+
+  companion object {
+    /** Adjustment keys that map to a continuous slider (excludes mirror/filterPreset, which are selectors). */
+    val SLIDER_KEYS = listOf(
+      "brightness", "contrast", "saturation", "exposure", "temperature", "blurRadius"
+    )
+
+    fun rangeFor(key: String): Pair<Float, Float> = when (key) {
+      "blurRadius" -> 0f to 25f
+      "filterStrength" -> 0f to 100f
+      else -> -100f to 100f
+    }
+  }
+}

package/android/src/main/java/com/photovideoeditor/photo/render/PhotoEditSession.kt

@@ -0,0 +1,121 @@
+package com.photovideoeditor.photo.render
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import androidx.exifinterface.media.ExifInterface
+import com.photovideoeditor.files.SourceResolver
+import com.photovideoeditor.media.BitmapSampling
+
+/**
+ * Owns an in-memory, downsampled working copy of the source photo for fast,
+ * memory-safe live preview. The full-resolution source is decoded again, once,
+ * only at export time (see [com.photovideoeditor.photo.export.PhotoExporter]).
+ */
+class PhotoEditSession(private val context: Context, sourceUri: String, maxPreviewDimension: Int = 1600) {
+  var state: PhotoTransformState = PhotoTransformState()
+    private set
+  var adjustments: PhotoAdjustments = PhotoAdjustments()
+    private set
+  val layerStack = PhotoLayerStack()
+
+  val baseBitmap: Bitmap? = decodeUpright(context, sourceUri, maxPreviewDimension)
+
+  private var cachedBaseBitmap: Bitmap? = null
+  private var cachedKey: Pair<PhotoTransformState, PhotoAdjustments>? = null
+  private var cachedPreviewBitmap: Bitmap? = null
+  private var cachedPreviewBase: Bitmap? = null
+  private var cachedPreviewLayerRevision = -1L
+  private val imageLayerCache = mutableMapOf<String, Bitmap?>()
+
+  fun update(transform: (PhotoTransformState) -> PhotoTransformState) {
+    state = transform(state)
+  }
+
+  fun updateAdjustments(transform: (PhotoAdjustments) -> PhotoAdjustments) {
+    adjustments = transform(adjustments)
+  }
+
+  /** Rotate/straighten + adjustments, cached so dragging a layer doesn't re-run the full pipeline every frame. */
+  private fun computeBase(): Bitmap? {
+    val base = baseBitmap ?: return null
+    val key = Pair(state, adjustments)
+    cachedBaseBitmap?.let { if (cachedKey == key) return it }
+    val transformed = if (state.rotationDegrees == 0 && state.straightenDegrees == 0f) {
+      base
+    } else {
+      Bitmap.createBitmap(base, 0, 0, base.width, base.height, state.toMatrix(), true)
+    }
+    val adjusted = PhotoAdjustmentRenderer.apply(transformed, adjustments)
+    cachedBaseBitmap = adjusted
+    cachedKey = key
+    return adjusted
+  }
+
+  /** Renders rotate/straighten + adjustments + layers — the crop overlay draws the crop live on top of this. */
+  fun renderPreview(): Bitmap? {
+    val base = computeBase() ?: return null
+    val layers = layerStack.layers
+    cachedPreviewBitmap?.let { cached ->
+      if (cachedPreviewBase === base && cachedPreviewLayerRevision == layerStack.revision) return cached
+    }
+    return PhotoLayerRenderer.render(base, layers, ::resolveImageUri).also {
+      cachedPreviewBitmap = it
+      cachedPreviewBase = base
+      cachedPreviewLayerRevision = layerStack.revision
+    }
+  }
+
+  /** Releases large preview and sticker/overlay bitmaps when the editor leaves the screen. */
+  fun release() {
+    val owned = buildSet {
+      baseBitmap?.let(::add)
+      cachedBaseBitmap?.let(::add)
+      cachedPreviewBitmap?.let(::add)
+      imageLayerCache.values.filterNotNull().forEach(::add)
+    }
+    owned.forEach { if (!it.isRecycled) it.recycle() }
+    cachedBaseBitmap = null
+    cachedPreviewBitmap = null
+    cachedPreviewBase = null
+    cachedPreviewLayerRevision = -1L
+    imageLayerCache.clear()
+  }
+
+  /** Resolves a sticker-uri or overlay-uri layer's image URI to a decoded bitmap, caching by URI. */
+  private fun resolveImageUri(uri: String): Bitmap? {
+    imageLayerCache[uri]?.let { return it }
+    if (imageLayerCache.containsKey(uri)) return null
+    val path = SourceResolver.resolvePath(context, uri, "pve_layer_image")
+    val bitmap = path?.let { BitmapFactory.decodeFile(it) }
+    imageLayerCache[uri] = bitmap
+    return bitmap
+  }
+
+  private fun decodeUpright(context: Context, sourceUri: String, maxDimension: Int): Bitmap? {
+    val path = SourceResolver.resolvePath(context, sourceUri, "pve_preview") ?: return null
+    val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    BitmapFactory.decodeFile(path, bounds)
+    if (bounds.outWidth <= 0 || bounds.outHeight <= 0) return null
+
+    val sample = BitmapSampling.inSampleSize(bounds.outWidth, bounds.outHeight, maxDimension)
+    val decoded = BitmapFactory.decodeFile(path, BitmapFactory.Options().apply { inSampleSize = sample }) ?: return null
+
+    val orientation = try {
+      ExifInterface(path).getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
+    } catch (_: Exception) {
+      ExifInterface.ORIENTATION_NORMAL
+    }
+    val matrix = Matrix()
+    when (orientation) {
+      ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
+      ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
+      ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
+      ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.postScale(-1f, 1f)
+      ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.postScale(1f, -1f)
+      else -> return decoded
+    }
+    return Bitmap.createBitmap(decoded, 0, 0, decoded.width, decoded.height, matrix, true)
+  }
+}

package/android/src/main/java/com/photovideoeditor/photo/render/PhotoFilterPresets.kt

@@ -0,0 +1,64 @@
+package com.photovideoeditor.photo.render
+
+import android.graphics.ColorMatrix
+
+/** A small set of original, neutrally named preset filters (no third-party looks or names copied). */
+object PhotoFilterPresets {
+  val PRESET_IDS = listOf("mono", "noir", "fade", "chrome", "warmth")
+
+  fun labelFor(id: String): String = when (id) {
+    "mono" -> "Mono"
+    "noir" -> "Noir"
+    "fade" -> "Fade"
+    "chrome" -> "Chrome"
+    "warmth" -> "Warmth"
+    else -> id
+  }
+
+  fun matrixFor(id: String): ColorMatrix? = when (id) {
+    "mono" -> ColorMatrix().apply { setSaturation(0f) }
+    "noir" -> ColorMatrix().apply {
+      setSaturation(0f)
+      postConcat(
+        ColorMatrix(
+          floatArrayOf(
+            1.3f, 0f, 0f, 0f, -40f,
+            0f, 1.3f, 0f, 0f, -40f,
+            0f, 0f, 1.3f, 0f, -40f,
+            0f, 0f, 0f, 1f, 0f
+          )
+        )
+      )
+    }
+    "fade" -> ColorMatrix(
+      floatArrayOf(
+        0.9f, 0f, 0f, 0f, 25f,
+        0f, 0.9f, 0f, 0f, 25f,
+        0f, 0f, 0.9f, 0f, 25f,
+        0f, 0f, 0f, 1f, 0f
+      )
+    )
+    "chrome" -> ColorMatrix().apply {
+      setSaturation(1.4f)
+      postConcat(
+        ColorMatrix(
+          floatArrayOf(
+            1.1f, 0f, 0f, 0f, 0f,
+            0f, 1.1f, 0f, 0f, 0f,
+            0f, 0f, 1.1f, 0f, 0f,
+            0f, 0f, 0f, 1f, 0f
+          )
+        )
+      )
+    }
+    "warmth" -> ColorMatrix(
+      floatArrayOf(
+        1f, 0f, 0f, 0f, 18f,
+        0f, 1f, 0f, 0f, 6f,
+        0f, 0f, 1f, 0f, -12f,
+        0f, 0f, 0f, 1f, 0f
+      )
+    )
+    else -> null
+  }
+}