CameraX Neural Image Generation Pipeline Architect

Role: Principal Android Performance Engineer specializing in low-latency neural image synthesis pipelines.

Context

• Target silicon platform: {{target_soc_architecture}}
• Minimum Android API level: {{min_android_sdk}}
• On-device model artifact structure: {{model_weight_format}}
• End-to-end latency budget: {{frame_latency_target_ms}}
• Memory allocation ceiling: {{memory_budget_mb}}
• Hardware acceleration fallback: {{fallback_inference_delegate}}

Task

Design and output an end-to-end production Kotlin and C++ NDK integration script that processes CameraX ImageAnalysis frames, converts them into continuous neural image generation inputs with zero heap allocations, and dispatches the execution graph across NPU and GPU delegates without dropping UI frames.

Method

1. Establish a CameraX ImageAnalysis pipeline configured with RGBA_8888 or YUV_420_888 output buffers synchronized to {{min_android_sdk}}.
2. Construct a direct HardwareBuffer/Surface bridge to marshal frames into NDK shared memory without intermediate byte array allocations, respecting {{memory_budget_mb}}.
3. Implement an inference queue manager in Kotlin Coroutines utilizing custom thread pools to isolate heavy generation workloads from the Main thread.
4. Bind the {{model_weight_format}} runtime bindings using C++ JNI wrappers, enforcing execution targeting {{target_soc_architecture}}.
5. Implement graceful delegate fallback logic using {{fallback_inference_delegate}} when thermal throttling or delegate initialization failures occur.
6. Enforce a frame-dropping scheduler that discards stale viewfinder inputs when processing exceeds {{frame_latency_target_ms}}.
7. Stream synthesized output bitmaps directly into a high-performance SurfaceView via a thread-safe double-buffering mechanism.

Constraints

• Code MUST compile against modern Android NDK standards without deprecated RenderScript or raw JNI global references.
• MUST NOT allocate memory inside the per-frame analyze() loop.
• All native memory pointers MUST include deterministic lifecycle deallocation hooks tied to Android LifecycleOwner.
• Thread synchronization primitives MUST prevent UI thread lock contention.

Output format

1. Architecture Overview: ASCII dataflow diagram mapping CameraX to NPU buffers.
2. Native Engine (C++): Complete JNI bridge and inference wrapper script.
3. Pipeline Implementation (Kotlin): Full CameraX ImageAnalysis and Coroutine execution script.
4. Memory & Thermal Strategy: Concrete parameter tuning summary.

Self-review

• Confirm no memory allocations occur inside the critical frame transformation path.
• Verify fallback delegate logic triggers cleanly if primary NPU acceleration faults.
• Validate that lifecycle cancellation terminates active background native threads.