Comprendere il ciclo di vita del miglioramento dei contenuti multimediali in modalità Surface

L'API Media Enhancement fornisce una soluzione di AI on-device a bassa latenza che tutela la privacy e sfrutta l'accelerazione hardware per offrire miglioramenti multimediali di alta qualità senza aumentare le dimensioni dell'APK. Per saperne di più, consulta Informazioni sulle funzionalità di miglioramento dei contenuti multimediali.

Il seguente diagramma dell'architettura mostra il ciclo di vita dell'esecuzione in modalità asincrona dell'API Media Enhancement. Questa modalità collega direttamente i buffer hardware per eliminare il collo di bottiglia delle prestazioni dovuto alla copia dei frame non compressi avanti e indietro tra i buffer di memoria della CPU e della GPU.

Diagramma che illustra il ciclo di vita asincrono da superficie a superficie in 7 passaggi dell'API Media Enhancement.
Figura 1. Ciclo di vita dell'esecuzione della modalità di superficie asincrona e i sette passaggi attuabili della pipeline di miglioramento.

La pipeline di miglioramento viene implementata tramite i seguenti passaggi:

Fase 1. Configura la sessione di miglioramento

1. Fornisci la superficie di input: la tua app fornisce al framework di miglioramento un handle della superficie di input per accedere ai frame da elaborare.

2. Imposta la superficie di output: la tua app esegue il provisioning e l'associazione dei target di rendering (ad esempio SurfaceView o TextureView) direttamente al framework.

Fase 2. Produce un frame di input

3. Prepara i contenuti multimediali di base: l'app recupera i contenuti multimediali di base non compressi. Ad esempio, leggendo un file da un disco locale.

4. Inserimento dei dati dei frame: l'app scrive il payload dell'immagine non elaborata direttamente nella pipeline della piattaforma di input associata.

Fase 3. Elabora e migliora

5. Esegui l'elaborazione con l'AI: il framework elabora il frame sulla GPU o sulla NPU del dispositivo, applicando miglioramenti tramite il machine learning come la mappatura dei toni, la rimozione della sfocatura o l'aumento della risoluzione.

6. Fornisci il frame migliorato: il motore invia il frame migliorato a risoluzione massima direttamente alla superficie di output associata.

Fase 4. Visualizza o salva il risultato

7. Finalizza l'output: l'app riceve il buffer dello stream hardware elaborato per eseguirne il rendering nell'interfaccia utente o salvarlo nuovamente nello spazio di archiviazione.

EnhancementSession è un oggetto di contesto pesante che mantiene una pipeline di memoria GPU o NPU persistente. Alloca RAM video (VRAM) dedicata e handle di sistema nativi. Per evitare gravi perdite di memoria e potenziali arresti anomali di OutOfMemoryError, segui questi principi del ciclo di vita:

  • Creazione di istanze lazy: non creare una sessione finché l'utente non avvia un'azione di miglioramento.
  • Riutilizzo strategico: mantieni e riutilizza una singola istanza di sessione durante l'elaborazione di stream o frame con configurazioni identiche (dimensioni e pulsanti on/off).
  • Chiusura del prompt: richiama immediatamente session.release() al termine delle attività visive per liberare le risorse hardware condivise.

Inizializza il motore di miglioramento

Questo metodo orchestra un controllo in due passaggi. Verifica se l'hardware del dispositivo supporta l'accelerazione e poi si assicura che siano presenti i moduli di machine learning richiesti.

L'esecuzione di questo passaggio come prerequisito evita errori di inizializzazione in fase di runtime convalidando le funzionalità prima che l'app tenti di elaborare i contenuti multimediali.

class MediaSetupViewModel(application: Application) : AndroidViewModel(application) {
    private val enhancementClient = Enhancement.getClient(application)
    fun initializeEnhancementEngine() {
        viewModelScope.launch {
            try {
                // 1. Verify hardware capability
                val isSupported = enhancementClient.isDeviceSupportedAsync()
                if (!isSupported) {
                    notifyUiDeviceIncompatible()
                    return@launch
                }
                // 2. Verify and download the Google Play services ML modules
                val isInstalled = enhancementClient.isModuleInstalledAsync()
                if (!isInstalled) {
                    notifyUiDownloadingModels()
                    enhancementClient.installModule().await()
                }
                notifyUiEngineReady()
            } catch (e: Exception) {
                // Handle potential errors during session creation or image
                // processing.
                handleInitializationError(e)
            }
        }
    }
}

Implementazione: modalità di superficie (surface in, surface out)

La modalità di esecuzione Surface (EnhancementMode.SURFACE) evita l'overhead delle prestazioni dovuto allo spostamento dei frame tra i buffer di memoria della CPU e della GPU. La libreria di miglioramento mappa invece direttamente i buffer hardware non elaborati, leggendo i frame da una superficie di input, elaborandoli in modo nativo e inviandoli direttamente a una superficie di output.

Istantanee di superficie a singolo fotogramma

Questo metodo viene utilizzato per applicare in modo efficiente gli effetti a un singolo frame immagine decodificato dall'hardware.

// Provisions input Surface (for example, ImageReader) and output Surface (for
// example, SurfaceView)
val inputSurface: Surface = imageReader.surface
val outputSurface: Surface = surfaceView.holder.surface
// 1. Configure parameters for SURFACE mode
val surfaceOptions = EnhancementOptions(
    imageReader.width,
    imageReader.height,
    EnhancementMode.SURFACE,
    enableTonemap = true,
    enableDeblurDenoise = true,
    enableFaceDetection = false
).also {
    // 2. Bind hardware surfaces
    it.setInputSurface(inputSurface)
    it.setOutputSurface(outputSurface)
}

// 3. Create the session to process the hardware frame
val singleFrameSession = enhancementClient.createSessionAsync(surfaceOptions, executor)
// The API processes the single frame. Upon completion, release the session.
singleFrameSession.release()