Pour commencer à utiliser Transformer
, procédez comme suit:
- Ajoutez Media3 Transformer en tant que dépendance dans votre projet.
- Créez un
EditedMediaItem
représentant le contenu multimédia à traiter et les modifications à lui appliquer. - Créez un
Transformer
, décrivant la sortie requise et un écouteur pour les événements d'achèvement et d'erreur. - Démarrez l'opération d'exportation en transmettant le
EditedMediaItem
à modifier et un chemin de sortie. Lors de l'exportation, vous pouvez interroger la progression en cours ou annuler l'opération. - Une fois l'exportation terminée, gérez la sortie si nécessaire. Par exemple, vous pouvez partager la sortie avec une autre application ou l'importer sur un serveur.
Lisez la suite pour en savoir plus sur ces étapes, ainsi que la section TransformerActivity
dans l'application de démonstration du transformateur pour obtenir un exemple complet.
Ajouter Media3 Transformer en tant que dépendance
Le moyen le plus simple de commencer à utiliser Transformer consiste à ajouter des dépendances Gradle à la bibliothèque dans le fichier build.gradle
de votre module d'application:
Kotlin
implementation("androidx.media3:media3-transformer:1.3.1") implementation("androidx.media3:media3-effect:1.3.1") implementation("androidx.media3:media3-common:1.3.1")
Groovy
implementation "androidx.media3:media3-transformer:1.3.1" implementation "androidx.media3:media3-effect:1.3.1" implementation "androidx.media3:media3-common:1.3.1"
où 1.3.1 est votre version préférée. La dernière version est disponible en consultant les notes de version.
Pour en savoir plus sur les modules de bibliothèque disponibles, consultez la page Google Maven AndroidX Media3.
Activer la compatibilité avec Java 8
Si ce n'est pas déjà fait, vous devez activer la prise en charge de Java 8 dans tous les fichiers build.gradle
qui dépendent de Transformer en ajoutant ce qui suit à la section android
:
compileOptions {
targetCompatibility JavaVersion.VERSION_1_8
}
Démarrer une transformation
Voici un exemple de création d'un EditedMediaItem
pour supprimer le son d'un fichier d'entrée, puis de création et de configuration d'une instance Transformer
pour exporter une vidéo H.265/HEVC, générant le résultat dans outputPath
.
Kotlin
val inputMediaItem = MediaItem.fromUri("path_to_input_file") val editedMediaItem = EditedMediaItem.Builder(inputMediaItem).setRemoveAudio(true).build() val transformer = Transformer.Builder(context) .setVideoMimeType(MimeTypes.VIDEO_H265) .addListener(transformerListener) .build() transformer.start(editedMediaItem, outputPath)
Java
MediaItem inputMediaItem = MediaItem.fromUri("path_to_input_file"); EditedMediaItem editedMediaItem = new EditedMediaItem.Builder(inputMediaItem).setRemoveAudio(true).build(); Transformer transformer = new Transformer.Builder(context) .setVideoMimeType(MimeTypes.VIDEO_H265) .addListener(transformerListener) .build(); transformer.start(editedMediaItem, outputPath);
Pour en savoir plus sur les éléments multimédias, consultez la page Éléments multimédias ExoPlayer. L'entrée peut être un flux progressif ou adaptatif, mais la sortie est toujours un flux progressif. Pour les entrées adaptatives, les pistes avec la résolution la plus élevée sont toujours sélectionnées pour la transformation. L'entrée peut être de n'importe quel format de conteneur compatible avec ExoPlayer, mais la sortie est toujours un fichier MP4.
Vous pouvez exécuter plusieurs opérations d'exportation de manière séquentielle sur la même instance Transformer
, mais les exportations simultanées avec la même instance ne sont pas acceptées.
Remarque sur les threads
Les instances Transformer doivent être accessibles à partir d'un seul thread d'application, et les méthodes d'écouteur sont appelées sur le même thread. Dans la plupart des cas, le thread d'application ne peut être que le thread principal de l'application. En interne, Transformer effectue son travail en arrière-plan et publie ses appels aux méthodes d'écouteur sur le thread de l'application.
Écouter des événements
La méthode start
est asynchrone. Il est renvoyé immédiatement, et l'application est informée des événements via l'écouteur transmis au compilateur Transformer
.
Kotlin
val transformerListener: Transformer.Listener = object : Transformer.Listener { override fun onCompleted(composition: Composition, result: ExportResult) { playOutput() } override fun onError(composition: Composition, result: ExportResult, exception: ExportException) { displayError(exception) } }
Java
Transformer.Listener transformerListener = new Transformer.Listener() { @Override public void onCompleted(Composition composition, ExportResult result) { playOutput(); } @Override public void onError(Composition composition, ExportResult result, ExportException exception) { displayError(exception); } };
ExportResult
inclut des informations sur le fichier de sortie, y compris la taille du fichier et les débits moyens pour l'audio et la vidéo, le cas échéant.
Recevoir des informations sur la progression
Appelez Transformer.getProgress
pour interroger la progression actuelle d'une transformation. La valeur renvoyée indique l'état de progression. Si l'état de progression est PROGRESS_STATE_AVAILABLE
, le ProgressHolder
fourni est mis à jour avec le pourcentage de progression actuel. L'exemple suivant montre comment interroger régulièrement la progression d'une transformation, où la méthode updateProgressInUi
peut être implémentée pour mettre à jour une barre de progression.
Kotlin
transformer.start(inputMediaItem, outputPath) val progressHolder = ProgressHolder() mainHandler.post( object : Runnable { override fun run() { val progressState: @ProgressState Int = transformer.getProgress(progressHolder) updateProgressInUi(progressState, progressHolder) if (progressState != Transformer.PROGRESS_STATE_NOT_STARTED) { mainHandler.postDelayed(/* r= */this, /* delayMillis= */500) } } } )
Java
transformer.start(inputMediaItem, outputPath); ProgressHolder progressHolder = new ProgressHolder(); mainHandler.post( new Runnable() { @Override public void run() { @Transformer.ProgressState int progressState = transformer.getProgress(progressHolder); updateProgressInUi(progressState, progressHolder); if (progressState != PROGRESS_STATE_NOT_STARTED) { mainHandler.postDelayed(/* r= */ this, /* delayMillis= */ 500); } } });
Annuler une transformation
Si l'utilisateur choisit de quitter un flux d'exportation, annulez l'opération d'exportation avec Transformer.cancel
. Les ressources telles que les codecs vidéo matériels sont limitées, en particulier sur les appareils d'entrée de gamme. Il est donc important de le faire pour libérer des ressources si la sortie n'est pas nécessaire.