Premiers pas

Pour commencer à utiliser Transformer, procédez comme suit:

1. Ajoutez Media3 Transformer en tant que dépendance dans votre projet.
2. Créez une EditedMediaItem représentant le contenu multimédia à traiter et à modifier. s'y appliquent.
3. Créer un Transformer, décrivant la sortie requise et un écouteur pour les événements d'achèvement et d'erreur.
4. Lancez l'opération d'exportation, en transmettant le EditedMediaItem à modifier et une chemin de sortie. Pendant l'exportation, vous pouvez interroger la progression en cours ou annuler la opération.
5. Une fois l'exportation terminée, gérez le résultat si nécessaire. Par exemple, vous pouvez partager la sortie avec une autre application ou la télécharger sur un serveur.

Lisez la suite pour en savoir plus sur ces étapes et consultez TransformerActivity dans les démonstration du transformateur l'application pour 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 sur la bibliothèque dans le fichier build.gradle du module de votre application:

implementation("androidx.media3:media3-transformer:1.4.1")
implementation("androidx.media3:media3-effect:1.4.1")
implementation("androidx.media3:media3-common:1.4.1")

implementation "androidx.media3:media3-transformer:1.4.1"
implementation "androidx.media3:media3-effect:1.4.1"
implementation "androidx.media3:media3-common:1.4.1"

où 1.4.1 est votre version préférée. La dernière version peut être trouvé en consultant la version commentaires.

Pour en savoir plus sur les modules de bibliothèque disponibles, consultez le Google Maven AndroidX Media3 .

Activer la compatibilité avec Java 8

Si ce n'est pas déjà fait, vous devez activer la compatibilité avec Java 8 dans tous les build.gradle qui dépendent de Transformer en ajoutant ce qui suit au fichier android. :

compileOptions {
  targetCompatibility JavaVersion.VERSION_1_8
}

Lancer une transformation

Voici un exemple de création d'un EditedMediaItem pour supprimer l'audio d'une entrée. puis la création et la configuration d'une instance Transformer à exporter Vidéo H.265/HEVC, générant le résultat dans outputPath.

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)

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 les éléments multimédias ExoPlayer. . L'entrée peut être progressive ou adaptative mais la sortie est toujours un flux progressif. Pour les entrées adaptatives, la valeur les canaux ayant la résolution la plus élevée sont toujours sélectionnés pour la transformation. L'entrée peut utiliser 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 le même Transformer instance, mais les exportations simultanées avec la même instance ne sont pas compatibles.

Remarque sur les fils de discussion

Les instances Transformer doivent être accessibles depuis un seul thread d'application. méthodes d'écouteur sont appelées sur le même thread. Dans la plupart des cas, le le thread d'application peut simplement être le thread principal de l'application. En interne, Transformer effectue son travail en arrière-plan et envoie ses appels à l'écouteur. sur le thread de l'application.

Écouter des événements

La méthode start est asynchrone. Le résultat est immédiat et l'application est notifié des événements via l'écouteur transmis au compilateur Transformer.

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)
  }
}

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 le fichier et le débit moyen 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 numérique. La valeur renvoyée indique l'état de progression. Si la progression est PROGRESS_STATE_AVAILABLE, alors la valeur ProgressHolder fournie 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.

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)
        }
      }
    }
)

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 comme les codecs vidéo matériels sont limitées, en particulier sur les appareils bas de gamme, il est donc important de le faire pour libérer des ressources si la sortie n'est pas nécessaire.