La capture d'actions rapides avec clarté est une fonctionnalité clé des applications d'appareil photo modernes. Pour ce faire, nous utilisons 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 pratique. Désormais, avec la nouvelle API haute vitesse dans 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 encore CameraX, vous pouvez vous familiariser avec l'aperçu de CameraX.

Le principe du ralenti

Le principe fondamental du ralenti est de 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 à la fréquence standard de 30 fps, la vidéo durera quatre secondes. Cette "étirement" du temps crée l'effet spectaculaire de ralenti, ce qui vous permet de voir des détails qui sont trop rapides pour l'œil nu.

Pour que la vidéo 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 x4, la fréquence d'images de la vidéo 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 ips) 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 codes temporels des images. La vidéo obtenue 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 une méthode unifiée pour 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 la caméra peut enregistrer en haute vitesse et, le cas échéant, quelles résolutions (objets Quality) sont prises en charge.
• HighSpeedVideoSessionConfig : il s'agit d'un objet de configuration spécial qui regroupe vos cas d'utilisation VideoCapture et Preview, et indique à CameraX de créer une session de caméra haute vitesse unifiée. Notez que, bien que le flux VideoCapture fonctionne à la fréquence d'images élevée configurée, le flux d'aperçu sera généralement limité à une fréquence standard d'au moins 30 FPS par le système de caméras 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 principales.

  // 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 prochaines versions. Pour les utiliser, vous devez les activer en ajoutant l'annotation suivante à votre code :

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

Implémentation

L'implémentation pour les 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 ou d'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 capacité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 portée 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 résultat

Maintenant, vous devez choisir le type de vidéo que vous souhaitez créer. Ce code s'exécuterait 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 fréquence de lecture standard.

Exemple :

• Si vous enregistrez à 120 FPS, la vidéo sera lue à x0,25 (120 ÷ 30 = 4).
• Si vous enregistrez une vidéo à 240 fps, elle sera lue à 1/8 de la vitesse normale (240 ÷ 30 = 8).

Tout mettre en place : 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. La préparation des options de sortie, le démarrage de l'enregistrement et la gestion des événements vidéo sont identiques à ceux d'une capture vidéo standard.

Cet article se concentre sur la configuration à haut débit. Nous n'aborderons donc pas le processus d'enregistrement en détail. Pour obtenir un guide complet sur la préparation d'un objet FileOutputOptions ou MediaStoreOutputOptions et 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)

    }

Prise en charge des vidéos au ralenti dans Google Photos

Lorsque vous activez setSlowMotionEnabled(true) dans CameraX, le fichier vidéo obtenu est conçu pour être immédiatement reconnaissable et lisible au ralenti dans les lecteurs vidéo et les applications 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 d'une UI distincte dans la miniature : dans votre bibliothèque Google Photos, les vidéos au ralenti peuvent être identifiées par des éléments d'UI spécifiques, ce qui les distingue des vidéos normales.

• Segments de vitesse réglables pendant la lecture : lorsque vous regardez une vidéo au ralenti, Google Photos vous permet de choisir les parties de la vidéo qui sont lues au ralenti et celles qui sont lues à vitesse normale, ce qui vous offre 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.

Remarque sur la compatibilité des appareils

L'API haute vitesse de CameraX s'appuie sur le système CamcorderProfile Android sous-jacent pour déterminer les résolutions et les fréquences d'images haute vitesse qu'un appareil prend en charge. Les profils de caméscope sont validés par la suite de tests de compatibilité Android (CTS), ce qui vous permet d'avoir confiance dans les 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 de caméscope intégrée ne garantit pas le fonctionnement de l'API haute vitesse CameraX. Cette différence se produit, car les fabricants d'appareils sont responsables du remplissage des entrées CamcorderProfile dans le micrologiciel de leurs appareils. Or, il arrive que des profils haut débit nécessaires, comme CamcorderProfile.QUALITY_HIGH_SPEED_1080P et CamcorderProfile.QUALITY_HIGH_SPEED_720P, ne soient pas inclus. Lorsque ces profils sont manquants, Recorder.getHighSpeedVideoCapabilities() renvoie null.

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

Conclusion

L'API vidéo haute vitesse CameraX est à la fois puissante et flexible. Que vous ayez besoin de séquences à haute fréquence d'images 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 donner à vos utilisateurs un contrôle plus créatif.