react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/CompressionProfile.kt

@@ -0,0 +1,195 @@
+package com.customcamera
+
+import android.app.ActivityManager
+import android.content.Context
+
+/**
+ * The quality strategy the user picks for Compress and Export By, and the machinery that turns a
+ * chosen strategy into the concrete encoder knobs THIS device can safely drive.
+ *
+ * The profile is the default that picks the balance of size, quality, speed and RAM that suits
+ * the device it is running on, so the same choice is safe on a 2 GB phone and fast on a 12 GB one.
+ *
+ * A profile never changes WHAT the pipeline preserves — orientation, aspect ratio, colours,
+ * transparency and A/V sync are invariants of the transcode itself (see [VideoRotationTranscoder]
+ * and [ImageExporter]); the profile only moves the knobs that trade size against quality and load.
+ */
+enum class CompressionProfile {
+  RECOMMENDED;
+
+  companion object {
+    /** The profile in force until the user chooses otherwise. */
+    val DEFAULT: CompressionProfile = RECOMMENDED
+
+    /** Parse a persisted/host-supplied name back to a profile, falling back to [DEFAULT]. */
+    fun fromNameOrDefault(name: String?): CompressionProfile =
+      entries.firstOrNull { it.name.equals(name, ignoreCase = true) } ?: DEFAULT
+  }
+}
+
+/**
+ * Coarse device memory/performance class, resolved once from [ActivityManager]. It is the single
+ * input (besides the profile) to every plan, so "what can this device handle" is decided in one
+ * place instead of being re-guessed at each encoder.
+ */
+enum class RamTier { LOW, MEDIUM, HIGH }
+
+/**
+ * The video encoder knobs a resolved (profile, device) pair produces. Read by the real encode
+ * ([VideoRotationTranscoder.compress]) and, in lockstep, by the transcoder's own bit-rate estimate
+ * ([VideoRotationTranscoder.estimateCompressedBytes]); [bitrateScale] in particular feeds both, so
+ * that estimate never drifts from the encode. The compression MENU no longer quotes from that
+ * estimate for video — it shows a proportional band (the original with the chosen percent removed
+ * at the top) — so these knobs shape the file that is written, not the number the row displays.
+ */
+data class VideoCompressionPlan(
+  /**
+   * Multiplies the percent-derived target bitrate before it is clamped. <1 shrinks the file, >1
+   * protects quality. The one knob the estimate also reads, so estimate and encoder never diverge.
+   */
+  val bitrateScale: Float = 1f,
+  /**
+   * Longest encoded edge in px, aspect preserved; 0 = no cap. A pure quality/stability knob: the
+   * estimate is bitrate x duration, so capping resolution does not change the quoted size — it only
+   * lightens decode/encode work and holds down peak memory on small devices.
+   */
+  val maxEncodedEdge: Int = 0,
+  /**
+   * Encode into HEVC when the source is re-encodable and the device has an HEVC encoder — more
+   * reduction at equal quality. Never forced on a LOW device (the extra cost is not worth the risk).
+   */
+  val preferHevc: Boolean = false,
+  /** GOP length in seconds (KEY_I_FRAME_INTERVAL). Longer = fewer keyframes = smaller file. */
+  val keyFrameIntervalSeconds: Int = 1,
+  /**
+   * KEY_OPERATING_RATE hint in fps; 0 leaves it unset. A high value asks the codec to run flat out
+   * (fast, hot) and is only handed to devices that can take it.
+   */
+  val operatingRate: Int = 0,
+  /** KEY_PRIORITY: 0 realtime (push the hardware), 1 best-effort (gentler, fewer ANRs). */
+  val encoderPriority: Int = 1
+)
+
+/**
+ * The still-image knobs a resolved (profile, device) pair produces, consumed by
+ * [ImageExporter.compress]. Container choice (JPEG/WebP) is NOT a profile knob — it stays with the
+ * source's transparency so a profile can never turn an alpha PNG into a white-flattened JPEG.
+ */
+data class ImageCompressionPlan(
+  /** Upper bound of the quality search band. */
+  val qualityCeiling: Int = 95,
+  /** Lower bound of the quality search band. */
+  val qualityFloor: Int = 20,
+  /** Downscale ladder tried in order; a lone [1f] never downsamples (dimensions preserved). */
+  val scaleSteps: List<Float> = listOf(1f, 0.75f, 0.5f, 0.35f),
+  /** Pre-cap on the longest edge before compressing; 0 = no cap. */
+  val maxDimension: Int = 0,
+  /**
+   * inSampleSize floor when decoding the source — 2 halves each edge up front on tiny-heap devices
+   * so a very large photo never has to land at full size in memory just to be re-encoded.
+   */
+  val minDecodeSampleSize: Int = 1
+)
+
+/**
+ * Resolves a [CompressionProfile] plus a device [RamTier] into the concrete plans above. Kept out
+ * of the profile enum so the (device -> tier) probe and the (profile, tier -> knobs) tables live
+ * together and can be reasoned about as one policy.
+ */
+object CompressionPlans {
+
+  /**
+   * This device's [RamTier], from [ActivityManager]. LOW is anything flagged low-RAM, at or below
+   * ~3 GB total, or with a small per-app heap ([ActivityManager.getMemoryClass]) — the devices that
+   * OOM/ANR under heavy transcodes, so they get the lightweight path. HIGH needs both plenty of RAM
+   * (>~6 GB) and a wide CPU (>=8 cores) before the aggressive path is unlocked; everything else is
+   * MEDIUM. An unreadable probe leaves the value unknown (0) rather than misclassifying it as LOW.
+   */
+  fun ramTier(context: Context): RamTier {
+    val am = context.applicationContext
+      .getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+      ?: return RamTier.MEDIUM
+    val totalRamMb = runCatching {
+      val info = ActivityManager.MemoryInfo()
+      am.getMemoryInfo(info)
+      info.totalMem / (1024L * 1024L)
+    }.getOrDefault(0L)
+    val memoryClassMb = runCatching { am.memoryClass }.getOrDefault(0)
+    val lowRamFlag = runCatching { am.isLowRamDevice }.getOrDefault(false)
+    val cores = runCatching { Runtime.getRuntime().availableProcessors() }.getOrDefault(1)
+    return when {
+      lowRamFlag || (totalRamMb in 1..3072) || (memoryClassMb in 1..192) -> RamTier.LOW
+      totalRamMb > 6144 && cores >= 8 -> RamTier.HIGH
+      else -> RamTier.MEDIUM
+    }
+  }
+
+  /**
+   * Video encoder knobs for [profile] on a device of [tier], given whether an HEVC encoder
+   * [hevcAvailable] exists. HEVC is only ever requested on a MEDIUM/HIGH device with the encoder
+   * present; a LOW device stays on its source codec (usually AVC) to avoid the extra cost.
+   * The threading hints (operating rate, priority) push the hardware only on a HIGH device.
+   *
+   * The resolution caps are set so an ORDINARY CAPTURE IS NEVER DOWNSCALED on any tier. They used to
+   * sit at 720p/1080p, which quietly cost every LOW-tier user their 1080p detail and every
+   * MEDIUM-tier user their 4K detail — and cost it for nothing, because an output's size is bit rate
+   * × duration, so capping resolution saves no bytes at all. What it does buy is stability: fewer
+   * pixels per frame means less encoder memory and less work, which is why a cap still exists for the
+   * smaller tiers, now placed a full resolution class above what the camera records. HIGH is
+   * uncapped outright.
+   */
+  fun resolveVideoPlan(
+    profile: CompressionProfile,
+    tier: RamTier,
+    hevcAvailable: Boolean
+  ): VideoCompressionPlan {
+    val hevc = hevcAvailable && tier != RamTier.LOW
+    val operatingRate = if (tier == RamTier.HIGH) 480 else 0
+    val priority = if (tier == RamTier.HIGH) 0 else 1
+    return when (profile) {
+      CompressionProfile.RECOMMENDED -> VideoCompressionPlan(
+        bitrateScale = 1f,
+        maxEncodedEdge = when (tier) {
+          // 1080p and everything below it passes through untouched; only a 4K source is reduced,
+          // and only on a device that would struggle to encode one at full size.
+          RamTier.LOW -> 1920
+          // 4K passes through too; the cap exists only for the 8K sources a few phones now shoot.
+          RamTier.MEDIUM -> 3840
+          RamTier.HIGH -> 0
+        },
+        preferHevc = hevc,
+        keyFrameIntervalSeconds = 2,
+        operatingRate = operatingRate,
+        encoderPriority = priority
+      )
+    }
+  }
+
+  /**
+   * Still-image knobs for [profile] on a device of [tier]. RECOMMENDED band and caps track the tier.
+   * A LOW tier also raises the decode subsample floor so a large photo is halved before it ever reaches
+   * the heap.
+   */
+  fun resolveImagePlan(profile: CompressionProfile, tier: RamTier): ImageCompressionPlan {
+    val minDecodeSample = if (tier == RamTier.LOW) 2 else 1
+    return when (profile) {
+      CompressionProfile.RECOMMENDED -> ImageCompressionPlan(
+        qualityCeiling = 95,
+        qualityFloor = 35,
+        scaleSteps = listOf(1f, 0.85f, 0.7f, 0.5f),
+        maxDimension = if (tier == RamTier.LOW) 2560 else 0,
+        minDecodeSampleSize = minDecodeSample
+      )
+    }
+  }
+
+  /**
+   * Quality passed to [ImageExporter.export] for a container conversion (Export By). Export keeps
+   * the image's pixel dimensions, so the profile only moves the encoder quality: standard 95 for RECOMMENDED.
+   */
+  fun exportImageQuality(profile: CompressionProfile): Int = when (profile) {
+    CompressionProfile.RECOMMENDED -> 95
+  }
+}
+
+