Capture haute vitesse et vidéo au ralenti avec CameraX 1.5

La capture d'actions rapides avec clarté est une fonctionnalité clé des applications d'appareil photo modernes. Elle est obtenue grâce à la capture haute vitesse , qui consiste à acquérir des images à des fréquences telles que 120 ou 240 FPS. Cette capture haute fidélité peut être utilisée à deux fins distinctes : créer une vidéo à fréquence d'images élevée pour une analyse détaillée image par image ou générer une vidéo au ralenti où l'action se déroule de manière spectaculaire à l'écran.

Auparavant, l'implémentation de ces fonctionnalités avec l'API Camera2 était un processus plus manuel. Désormais, avec la nouvelle API haute vitesse de CameraX 1.5, l'ensemble du processus est simplifié, ce qui vous permet de créer des vidéos à fréquence d'images élevée ou des clips au ralenti prêts à être lus. Cet article vous explique comment maîtriser les deux. Si vous ne connaissez pas CameraX, vous pouvez consulter la présentation de CameraX.

Principe du ralenti

Le principe fondamental du ralenti consiste à capturer une vidéo à une fréquence d'images beaucoup plus élevée que celle à laquelle elle est lue. Par exemple, si vous enregistrez un événement d'une seconde à 120 images par seconde (FPS) , puis que vous le lisez à 30 FPS, la vidéo durera quatre secondes. Cette "extension" du temps crée l'effet spectaculaire du ralenti, ce qui vous permet de voir des détails trop rapides pour l'œil nu.

Pour que la vidéo de sortie finale soit fluide, elle doit généralement être rendue à au moins 30 FPS. Cela signifie que pour créer une vidéo au ralenti 4x, la fréquence d'images de capture d'origine doit être d'au moins 120 FPS (120 FPS de capture ÷ 4 = 30 FPS de lecture).

Une fois les séquences à fréquence d'images élevée capturées, il existe deux façons principales d'obtenir le résultat souhaité :

• Ralenti géré par le lecteur (vidéo à fréquence d'images élevée) : l'enregistrement haute vitesse (par exemple, 120 FPS) est enregistré directement en tant que fichier vidéo à fréquence d'images élevée. Il incombe ensuite au lecteur vidéo de ralentir la vitesse de lecture. L'utilisateur peut ainsi basculer entre la lecture normale et la lecture au ralenti.
• Ralenti prêt à être lu (vidéo réencodée) : le flux vidéo haute vitesse est traité et réencodé dans un fichier avec une fréquence d'images standard (par exemple, 30 FPS). L'effet de ralenti est "intégré" en ajustant les horodatages des images. La vidéo résultante sera lue au ralenti dans n'importe quel lecteur vidéo standard sans traitement spécial. Bien que la vidéo soit lue au ralenti par défaut, les lecteurs vidéo peuvent toujours fournir des commandes de vitesse de lecture qui permettent à l'utilisateur d'augmenter la vitesse et de regarder la vidéo à sa vitesse d'origine.

L'API CameraX simplifie ce processus en vous offrant un moyen unifié de choisir l'approche souhaitée, comme vous le verrez ci-dessous.

Nouvelle API vidéo haute vitesse

La nouvelle solution CameraX repose sur deux composants principaux :

• Recorder#getHighSpeedVideoCapabilities(CameraInfo): cette méthode vous permet de vérifier si l'appareil photo peut enregistrer en haute vitesse et, le cas échéant, quelles résolutions (objets Quality) sont compatibles.
• HighSpeedVideoSessionConfig : il s'agit d'un objet de configuration spécial qui regroupe vos VideoCapture et Preview cas d'utilisation, indiquant à CameraX de créer une session d'appareil photo haute vitesse unifiée. Notez que, bien que le flux VideoCapture fonctionne à la fréquence d'images élevée configurée, le flux Preview est généralement limité à une fréquence standard d'au moins 30 FPS par le système de l'appareil photo pour garantir un affichage fluide à l'écran.

Premiers pas

Avant de commencer, assurez-vous d'avoir ajouté les dépendances CameraX nécessaires au fichier build.gradle.kts de votre application. Vous aurez besoin de l'artefact camera-video ainsi que des bibliothèques CameraX de base.

// build.gradle.kts (Module: app)

dependencies {

    val camerax_version = "1.5.1"


    implementation("androidx.camera:camera-core:$camerax_version")

    implementation("androidx.camera:camera-camera2:$camerax_version")

    implementation("androidx.camera:camera-lifecycle:$camerax_version")

    implementation("androidx.camera:camera-video:$camerax_version")

    implementation("androidx.camera:camera-view:$camerax_version")

}

Remarque concernant les API expérimentales

Il est important de noter que les API d'enregistrement haute vitesse sont actuellement expérimentales. Cela signifie qu'elles sont susceptibles d'être modifiées dans les futures versions. Pour les utiliser, vous devez vous inscrire en ajoutant l'annotation suivante à votre code :

@kotlin.OptIn(ExperimentalSessionConfig::class, ExperimentalHighSpeedVideo::class)

Implémentation

L'implémentation des deux résultats commence par les mêmes étapes de configuration. Le choix entre la création d'une vidéo à fréquence d'images élevée et une vidéo au ralenti se résume à un seul paramètre.

1. Configurer la capture haute vitesse

Tout d'abord, quel que soit votre objectif, vous devez obtenir le ProcessCameraProvider, vérifier les fonctionnalités de l'appareil et créer vos cas d'utilisation.

Le bloc de code suivant montre le flux de configuration complet dans une fonction de suspension. Vous pouvez appeler cette fonction à partir d'une étendue de coroutine, comme lifecycleScope.launch.

// Add the OptIn annotation at the top of your function or class

@kotlin.OptIn(ExperimentalSessionConfig::class, ExperimentalHighSpeedVideo::class)

private suspend fun setupCamera() {

    // Asynchronously get the CameraProvider

    val cameraProvider = ProcessCameraProvider.awaitInstance(this)



    // -- CHECK CAPABILITIES --

    val cameraInfo = cameraProvider.getCameraInfo(CameraSelector.DEFAULT_BACK_CAMERA)

    val videoCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo)

    if (videoCapabilities == null) {

        // This camera device does not support high-speed video.

        return

    }




    // -- CREATE USE CASES --

    val preview = Preview.Builder().build()    


    // You can create a Recorder with default settings.

    // CameraX will automatically select a suitable quality.

    val recorder = Recorder.Builder().build()


    // Alternatively, to use a specific resolution, you can configure the
    // Recorder with a QualitySelector. This is useful if your app has
    // specific resolution requirements or you want to offer user
    // preferences. 

    // To use a specific quality, you can uncomment the following lines.

    // Get the list of qualities supported for high-speed video. 

    // val supportedQualities = videoCapabilities.getSupportedQualities(DynamicRange.SDR)

    // Build the Recorder using the quality from the supported list.

    // val recorderWithQuality = Recorder.Builder()

    //     .setQualitySelector(QualitySelector.from(supportedQualities.first()))

    //     .build()



    // Create the VideoCapture use case, using either recorder or recorderWithQuality

    val videoCapture = VideoCapture.withOutput(recorder)

    // Now you are ready to configure the session for your desired output...

}

2. Choisir votre sortie

Vous décidez maintenant du type de vidéo que vous souhaitez créer. Ce code s'exécutera dans la fonction setupCamera() suspend présentée ci-dessus.

Option A : Créer une vidéo à fréquence d'images élevée

Choisissez cette option si vous souhaitez que le fichier final ait une fréquence d'images élevée (par exemple, une vidéo à 120 FPS).

// Create a builder for the high-speed session

val sessionConfigBuilder = HighSpeedVideoSessionConfig.Builder(videoCapture)

    .setPreview(preview)


// Query and apply a supported frame rate. Common supported frame rates include 120 and 240 fps.

val supportedFrameRateRanges =

    cameraInfo.getSupportedFrameRateRanges(sessionConfigBuilder.build())


sessionConfigBuilder.setFrameRateRange(supportedFrameRateRanges.first())

Option B : Créer une vidéo au ralenti prête à être lue

Choisissez cette option si vous souhaitez qu'une vidéo soit lue automatiquement au ralenti dans n'importe quel lecteur vidéo standard.

// Create a builder for the high-speed session

val sessionConfigBuilder = HighSpeedVideoSessionConfig.Builder(videoCapture)

    .setPreview(preview)



// This is the key: enable automatic slow-motion!

sessionConfigBuilder.setSlowMotionEnabled(true)



// Query and apply a supported frame rate. Common supported frame rates include 120, 240, and 480 fps.

val supportedFrameRateRanges =

   cameraInfo.getSupportedFrameRateRanges(sessionConfigBuilder.build())

sessionConfigBuilder.setFrameRateRange(supportedFrameRateRanges.first())

Ce seul indicateur est essentiel pour créer une vidéo au ralenti prête à être lue. Lorsque setSlowMotionEnabled est défini sur "true", CameraX traite le flux haute vitesse et l'enregistre en tant que fichier vidéo standard à 30 FPS. La vitesse du ralenti est déterminée par le rapport entre la fréquence d'images de capture et cette vitesse de lecture standard.

Exemple :

• Un enregistrement à 120 FPS produit une vidéo lue à 1/4 de la vitesse (120 ÷ 30 = 4).
• Un enregistrement à 240 FPS produit une vidéo lue à 1/8 de la vitesse (240 ÷ 30 = 8).

Tout combiner : enregistrer la vidéo

Une fois que vous avez configuré votre HighSpeedVideoSessionConfig et que vous l'avez lié au cycle de vie, la dernière étape consiste à démarrer l'enregistrement. Le processus de préparation des options de sortie, de démarrage de l'enregistrement et de gestion des événements vidéo est le même que pour une capture vidéo standard.

Cet article se concentre sur la configuration haute vitesse. Nous n'aborderons donc pas le processus d'enregistrement en détail. Pour obtenir un guide complet sur tous les aspects, de la préparation d'un objet FileOutputOptions ou MediaStoreOutputOptions à la gestion des rappels VideoRecordEvent, veuillez consulter la documentation VideoCapture.

// Bind the session config to the lifecycle

cameraProvider.bindToLifecycle(

    this as LifecycleOwner,

    CameraSelector.DEFAULT_BACK_CAMERA,

    sessionConfigBuilder.build() // Bind the config object from Option A or B

)



// Start the recording using the VideoCapture use case

val recording = videoCapture.output

    .prepareRecording(context, outputOptions) // See docs for creating outputOptions

    .start(ContextCompat.getMainExecutor(context)) { recordEvent ->

        // Handle recording events (e.g., Start, Pause, Finalize)

    }

Compatibilité de Google Photos avec les vidéos au ralenti

Lorsque vous activez setSlowMotionEnabled(true) dans CameraX, le fichier vidéo résultant est conçu pour être immédiatement reconnaissable et lisible au ralenti dans les lecteurs vidéo et les applications de galerie standards. Google Photos, en particulier, offre des fonctionnalités améliorées pour ces vidéos au ralenti, lorsque la fréquence d'images de capture est de 120, 240, 360, 480 ou 960 FPS :

• Reconnaissance distincte de l'interface utilisateur dans la miniature : dans votre bibliothèque Google Photos, les vidéos au ralenti peuvent être identifiées par des éléments d'interface utilisateur spécifiques, ce qui les distingue des vidéos normales.

Miniature vidéo normale	Miniature de la vidéo au ralenti

• Segments à vitesse réglable pendant la lecture : lors de la lecture d'une vidéo au ralenti, Google Photos fournit des commandes permettant d'ajuster les parties de la vidéo qui sont lues au ralenti et celles qui sont lues à vitesse normale, ce qui donne aux utilisateurs un contrôle créatif. La vidéo modifiée peut ensuite être exportée en tant que nouveau fichier vidéo à l'aide du bouton Partager, en conservant les segments au ralenti que vous avez définis.

Lecture vidéo normale	Lecture vidéo au ralenti  avec commandes de  modification

Remarque concernant la compatibilité des appareils

L'API haute vitesse de CameraX s'appuie sur le système Android CamcorderProfile sous-jacent pour déterminer les résolutions et les fréquences d'images haute vitesse compatibles avec un appareil. Les CamcorderProfiles sont validés par la suite de tests de compatibilité Android (CTS), ce qui vous permet d'être sûr des capacités d'enregistrement vidéo signalées par l'appareil.

Cela signifie que la capacité d'un appareil à enregistrer des vidéos au ralenti avec son application d'appareil photo intégrée ne garantit pas le fonctionnement de l'API haute vitesse de CameraX. Cette différence se produit, car les fabricants d'appareils sont responsables du remplissage des entrées CamcorderProfile dans le micrologiciel de leur appareil, et parfois les profils haute vitesse nécessaires tels que CamcorderProfile.QUALITY_HIGH_SPEED_1080P et CamcorderProfile.QUALITY_HIGH_SPEED_720P ne sont pas inclus. Lorsque ces profils sont manquants, Recorder.getHighSpeedVideoCapabilities() renvoie null.

Il est donc essentiel d'utiliser toujours Recorder.getHighSpeedVideoCapabilities() pour vérifier les fonctionnalités compatibles par programmation, car il s'agit du moyen le plus fiable de garantir une expérience cohérente sur différents appareils. Si vous essayez de lier un HighSpeedVideoSessionConfig sur un appareil où Recorder.getHighSpeedVideoCapabilities() renvoie la valeur "null", l'opération échouera avec une IllegalArgumentException. Vous pouvez confirmer la compatibilité sur les appareils Google Pixel, car ils incluent systématiquement ces profils haute vitesse. De plus, divers appareils d'autres fabricants, tels que le Motorola Edge 30, l'OPPO Find N2 Flip et le Sony Xperia 1 V, sont également compatibles avec les fonctionnalités vidéo haute vitesse.

Conclusion

L'API vidéo haute vitesse de CameraX est à la fois puissante et flexible. Que vous ayez besoin de séquences à fréquence d'images élevée pour une analyse technique ou que vous souhaitiez ajouter des effets de ralenti cinématographiques à votre application, HighSpeedVideoSessionConfig fournit une solution unifiée et simple. En comprenant le rôle de l'indicateur setSlowMotionEnabled, vous pouvez facilement prendre en charge les deux cas d'utilisation et offrir à vos utilisateurs un contrôle créatif accru.