Android API Reference

This reference documents all public classes, methods, and types in the Android Video SDK.

DynamicProcessor

photos.eyeq.dynamic

The main entry point for running Dynamic AI inference. Loads a bundled model, prepares buffers, and provides methods for image and video processing.

class DynamicProcessor(context: Context)

Licensing

setLicense

Sets the license credentials required to initialize the inference engine. Must be called before init().

fun setLicense(apiKey: String, cert: String, recreate: Boolean = false)

checkCertificate

Validates an API key and certificate pair against the license server without affecting the currently loaded license.

fun checkCertificate(apiKey: String, cert: String): Int

Returns: Positive value = days remaining, -1 = expired, -2 = invalid key/certificate combination.

getDaysLeft

Returns remaining days on the current license.

fun getDaysLeft(): Int

Returns: Positive days remaining. -1 if expired or engine not initialized. -2 if key/certificate combination is invalid.

Initialization

init

Initializes the inference engine. Must be called after setLicense() and before any process calls.

fun init(): Int

Returns: Days remaining on the license. -1 if expired, -2 if key/certificate combination is invalid.

isInitialized

Whether the processor has been successfully initialized via init(). Returns false until init() completes, or after a failed initialization.

var isInitialized: Boolean

Image processing

processImage

Processes a bitmap through the full inference pipeline and returns the result as a new Bitmap. Runs inference and immediately applies the Dynamic effect via an offscreen GL render. For preview use cases, prefer processImagePreview() which is significantly faster.

fun processImage(bitmap: Bitmap, strength: Float = 1.0f): Bitmap

Returns: New Bitmap with the Dynamic effect applied at original resolution.

processImagePreview

Processes a bitmap through inference and returns raw DynamicOutputs. Faster than processImage() because it skips the offscreen GL render step. Use the returned outputs with DynamicView.setDynamicOutputs() to display the effect.

fun processImagePreview(bitmap: Bitmap, strength: Float = 1.0f): DynamicOutputs

Returns: DynamicOutputs for use with DynamicView.

Video processing

processVideoFrame

Processes a single video frame through the inference pipeline. Frames are skipped according to the interval set in setDeflickerParams(). Returns null when a frame is skipped or when a previous inference is still running.

fun processVideoFrame(
    frameBuffer: ByteBuffer,
    strength: Float,
    rotateOutput: Int = 0,
    flipVertical: Boolean = false
): DynamicOutputs?

Returns: DynamicOutputs for this frame, or null if skipped.

processVideoFrameDebug

Processes a single video frame, bypassing frame skipping. Always runs inference regardless of the skip interval. Intended for debugging and benchmarking.

fun processVideoFrameDebug(frameBuffer: ByteBuffer, strength: Float): DynamicOutputs

Returns: DynamicOutputs for this frame. Never null.

Deflickering

setDeflickerParams

Configures the temporal deflicker filter applied across frames. Higher averaging values produce smoother but slower-adapting results.

fun setDeflickerParams(skipFrames: Int, curveAvg: Float, imgAvg: Float)

startVideoFrames

Resets the deflicker state and the frame skip counter. Call when starting a new video session — before playback, before transcoding, or when a new camera session starts. Ensures inference runs on the very next frame and no blending artifacts from a previous session carry over.

fun startVideoFrames()

Output orientation

Methods for correcting DynamicOutputs orientation after inference when the render target has a different orientation than the inference input.

rotateOutputs

Rotates the DynamicOutputs arrays in place to match a target orientation. Use when inference was run on a rotated (upright) image but the outputs need to be applied back to the original sensor-rotated frame.

fun rotateOutputs(outputs: DynamicOutputs, rotation: Int)

flipOutputs

Flips the DynamicOutputs arrays vertically in place. Use when inference was run on an upright image but the render target expects the original flipped sensor orientation.

fun flipOutputs(outputs: DynamicOutputs)

DynamicView

photos.eyeq.dynamic.image

A GLSurfaceView that renders a Bitmap with the Dynamic effect applied in real time. All public methods are thread-safe — they queue their work onto the GL thread internally.

class DynamicView(context: Context, attrs: AttributeSet? = null) : GLSurfaceView

Typical usage:

1. Add DynamicView to your layout
2. Call setBitmap() to load the source image
3. Run inference with DynamicProcessor.processImagePreview() and pass the result to setDynamicOutputs()
4. Use setStrength() to let the user adjust effect intensity interactively
5. Call release() when the view is no longer needed

setBitmap

Loads a Bitmap as the source image to render. Must be called before setDynamicOutputs().

fun setBitmap(bitmap: Bitmap)

setDynamicOutputs

Applies DynamicOutputs from inference to the rendered image. Call after receiving outputs from DynamicProcessor.processImagePreview().

fun setDynamicOutputs(outputs: DynamicOutputs)

setStrength

Adjusts the intensity of the Dynamic effect without re-running inference. Use for interactive tuning after setDynamicOutputs() has been called.

fun setStrength(strength: Float)

Throws: IllegalArgumentException if strength is outside the 0.0–1.0 range.

release

Releases all GL resources held by this view. Call in onDestroyView() or onDestroy(). The view must not be used after calling this.

fun release()

DynamicEffectMedia

photos.eyeq.dynamic.media

A GlEffect that applies the Dynamic effect to video frames via the Media3 GL pipeline. Compatible with:

• ExoPlayer via ExoPlayer.setVideoEffects() — real-time playback
• Transformer via EditedMediaItem.Builder.setEffects() — offline video transcoding
• LifecycleCameraController via LifecycleCameraController.setEffects() — real-time camera preview

class DynamicEffectMedia(
    context: Context,
    asyncInput: Boolean = true,
    listener: DynamicListener,
    initListener: (() -> Unit)? = null
) : GlEffect

Inference output delivery

setDynamicOutputs

Delivers DynamicOutputs from inference to the GL thread. Safe to call from any thread — queued and applied before the next frame.

fun setDynamicOutputs(outputs: DynamicOutputs?)

Snapshot orientation

Correct the orientation of the inference input snapshot when the video stream is rotated or mirrored (e.g., front camera, landscape sensor). Set these before inference begins.

setSnapshotTransform

Applies a combined rotation and flip transform to the inference input snapshot. Transforms are applied in order: flipVer → flipHor → rotation.

fun setSnapshotTransform(rotation: Int = 0, flipVer: Boolean = false, flipHor: Boolean = false)

setSnapshotRotation

Rotates the inference input snapshot clockwise.

fun setSnapshotRotation(rotation: Int)

setSnapshotFlip

Flips the inference input snapshot along one or both axes.

fun setSnapshotFlip(flipVer: Boolean = false, flipHor: Boolean = false)

setSnapshotFlipVert

Flips the inference input snapshot vertically (GL origin correction).

fun setSnapshotFlipVert(flipVer: Boolean)

setSnapshotFlipHor

Flips the inference input snapshot horizontally (front camera mirror correction).

fun setSnapshotFlipHor(flipHor: Boolean)

LUT

setLut

Sets the 3D LUT data and controls whether it is applied during rendering. Safe to call from any thread — queued and applied before the next frame.

fun setLut(lut: FloatArray?, enabled: Boolean = true)

setLutEnabled

Enables or disables LUT rendering without replacing the current LUT data.

fun setLutEnabled(enabled: Boolean)

getLutEnabled

Returns whether the LUT is currently enabled and has valid data. Must be called on the GL thread.

fun getLutEnabled(): Boolean

Lifecycle

onInitialized

Registers a callback to be invoked when the GL context is ready.

fun onInitialized(listener: () -> Unit)

release

Releases all GL resources held by this effect. Must be called when no longer needed.

fun release()

DynamicListener

photos.eyeq.dynamic

Callback interface for receiving video frames ready for inference. Implement this interface and pass it to the DynamicEffectMedia constructor.

interface DynamicListener

onInputReady

Called when DynamicEffectMedia provides a new 256×256 RGBA frame for synchronous inference. Run inference and return the output immediately. Used when asyncInput = false.

open fun onInputReady(pixels: ByteBuffer): DynamicOutputs?

Returns: DynamicOutputs result, or null to skip.

onInputReadyAsync

Called when a new frame is ready for asynchronous processing. Run inference on a background thread and deliver outputs back via DynamicEffectMedia.setDynamicOutputs(). Used when asyncInput = true (default).

open fun onInputReadyAsync(pixels: ByteBuffer)

onBench

Called periodically with the current FPS reported by DynamicEffectMedia. Useful for benchmarking.

open fun onBench(fps: Float)

DynamicOutputs

photos.eyeq.dynamic

Holds the inference output arrays produced by DynamicProcessor. Pass to DynamicEffectMedia.setDynamicOutputs() or DynamicView.setDynamicOutputs() to apply the Dynamic effect.

data class DynamicOutputs(
    var global: FloatArray,
    var local: FloatArray,
    var fusion: FloatArray,
    var lut: FloatBuffer? = null
)