Transformations

Transcoder entre les formats

Vous pouvez spécifier les formats audio et vidéo de sortie que vous souhaitez générer lorsque vous créez un Transformer. Par exemple, le code suivant montre comment configurer Transformer pour générer une vidéo H.264/AVC et un son AAC :

Transformer.Builder(context)
    .setVideoMimeType(MimeTypes.VIDEO_H264)
    .setAudioMimeType(MimeTypes.AUDIO_AAC)
    .build()

new Transformer.Builder(context)
    .setVideoMimeType(MimeTypes.VIDEO_H264)
    .setAudioMimeType(MimeTypes.AUDIO_AAC)
    .build();

Si le format multimédia d'entrée correspond déjà aux configurations audio ou vidéo, Transformer passe automatiquement au transmuxing, c'est-à-dire à la copie des échantillons compressés du conteneur d'entrée vers le conteneur de sortie sans modification. Cela évite les coûts de calcul et la perte de qualité potentielle liés au décodage et au réencodage dans le même format.

Supprimer l'audio ou la vidéo

Supprimez l'audio ou la vidéo à l'aide de EditedMediaItem.Builder, par exemple :

EditedMediaItem.Builder(inputMediaItem).setRemoveAudio(true).build()

new EditedMediaItem.Builder(inputMediaItem).setRemoveAudio(true).build();

Couper un extrait

Vous pouvez supprimer tout contenu multimédia en dehors des codes temporels de début et de fin spécifiés en définissant la configuration de découpage sur l'élément multimédia d'entrée. Par exemple, pour produire un extrait contenant uniquement le contenu multimédia entre 10 et 20 secondes :

val inputMediaItem = MediaItem.Builder()
    .setUri(uri)
    .setClippingConfiguration(
        ClippingConfiguration.Builder()
            .setStartPositionMs(10_000)
            .setEndPositionMs(20_000)
            .build())
    .build()

MediaItem inputMediaItem =
    new MediaItem.Builder()
        .setUri(uri)
        .setClippingConfiguration(
            new MediaItem.ClippingConfiguration.Builder()
                .setStartPositionMs(10_000)
                .setEndPositionMs(20_000)
                .build())
        .build();

Listes de montage MP4

Pour un découpage plus rapide, Transformer est compatible avec les listes de montage MP4, ce qui permet des modifications "de découpage uniquement" plus efficaces sans réencodage complet de la vidéo. Cette méthode utilise des échantillons encodés existants et un "préroll" dans la liste de montage, qui indique au lecteur de commencer la lecture à un point spécifique, en ignorant efficacement le segment initial indésirable.

Pour effectuer des modifications de coupe uniquement beaucoup plus rapidement, appelez experimentalSetMp4EditListTrimEnabled(true).

Transformer.Builder(context)
    .experimentalSetMp4EditListTrimEnabled(true)
    .build()

new Transformer.Builder(context)
    .experimentalSetMp4EditListTrimEnabled(true)
    .build();

Il est important de noter que tous les lecteurs multimédias n'acceptent pas la position "pré-roll". Cela signifie que lorsque ce type de lecteur est utilisé, la lecture du fichier commence au tout début de l'échantillon encodé, quelles que soient les informations de la liste de montage qui pourraient spécifier un point de départ différent.

Optimiser les versions réduites

Pour réduire la latence de découpage du début d'une vidéo, activez l'optimisation du découpage.

Transformer.Builder(context)
    .experimentalSetTrimOptimizationEnabled(true)
    .build()

new Transformer.Builder(context)
    .experimentalSetTrimOptimizationEnabled(true)
    .build();

Cela accélère l'exportation en décodant et en réencodant le moins possible de la vidéo, puis en assemblant les données réencodées avec le reste de la vidéo d'origine. L'optimisation repose sur la possibilité d'assembler une partie du fichier d'entrée avec la sortie nouvellement encodée. Cela signifie que le format de sortie de l'encodeur et le format d'entrée doivent être compatibles. Par exemple, si le fichier a été produit à l'origine sur un appareil avec une implémentation d'encodeur différente, il est probable qu'il ne soit pas possible d'appliquer l'optimisation. Pour que l'optimisation réussisse, l'encodeur fourni à Transformer via EncoderFactory doit avoir un niveau et un profil compatibles avec le format d'entrée.

Cette optimisation ne fonctionne qu'avec les entrées MP4 à un seul élément, sans effets, à l'exception des effets vidéo "no op" et des rotations divisibles par 90 degrés. Si l'optimisation échoue, le Transformer revient automatiquement à l'exportation normale et indique le résultat de l'optimisation dans ExportResult.OptimizationResult.

Nous validons cette fonctionnalité et prévoyons de la rendre non expérimentale dans une prochaine version.

Montage vidéo

EditedMediaItems : listes de processeurs audio et d'effets vidéo à appliquer dans l'ordre. La bibliothèque inclut des implémentations d'effets vidéo pour les cas d'utilisation courants. Vous pouvez également écrire des effets personnalisés et les transmettre lors de la création d'éléments multimédias modifiés.

Vous pouvez redimensionner les contenus multimédias, ce qui peut être utile pour économiser des ressources de traitement ou de la bande passante lorsque vous traitez des entrées à très haute résolution, comme des vidéos 4K ou 8K. Par exemple, pour mettre à l'échelle de manière proportionnelle à une hauteur de 480 pixels :

EditedMediaItem.Builder(MediaItem.fromUri(uri))
    .setEffects(Effects(
        /* audioProcessors= */ listOf(),
        /* videoEffects= */ listOf(Presentation.createForHeight(480))
    )).build()

new EditedMediaItem.Builder(MediaItem.fromUri(uri))
    .setEffects(new Effects(
        /* audioProcessors= */ ImmutableList.of(),
        /* videoEffects= */ ImmutableList.of(Presentation.createForHeight(480))))
    .build();

Vous pouvez également effectuer une mise à l'échelle selon un facteur donné, par exemple pour diviser la taille par deux :

val editedMediaItem = EditedMediaItem.Builder(MediaItem.fromUri(uri))
    .setEffects(Effects(
        /* audioProcessors= */ listOf(),
        /* videoEffects= */ listOf(
            ScaleAndRotateTransformation.Builder().setScale(.5f, .5f).build())
    )).build()

new EditedMediaItem.Builder(MediaItem.fromUri(uri))
    .setEffects(new Effects(
        /* audioProcessors= */ ImmutableList.of(),
        /* videoEffects= */ ImmutableList.of(
            new ScaleAndRotateTransformation.Builder().setScale(.5f, .5f).build())))
    .build();

Vous pouvez configurer la rotation de la même manière :

EditedMediaItem.Builder(MediaItem.fromUri(uri))
    .setEffects(Effects(
        /* audioProcessors= */ listOf(),
        /* videoEffects= */ listOf(
            ScaleAndRotateTransformation.Builder()
                .setRotationDegrees(90f)
                .build())
    )).build()

new EditedMediaItem.Builder(MediaItem.fromUri(uri))
    .setEffects(new Effects(
        /* audioProcessors= */ ImmutableList.of(),
        /* videoEffects= */ ImmutableList.of(
            new ScaleAndRotateTransformation.Builder().setRotationDegrees(90f).build())))
    .build();

Effets vidéo personnalisés

Le constructeur Effects accepte une liste d'effets audio et vidéo à appliquer. En interne, le framework d'effets de Transformer convertit la liste des effets vidéo en une séquence de programmes de nuanceurs GL qui sont appliqués dans l'ordre. Dans certains cas, le framework d'effets est capable d'appliquer plusieurs effets avec un seul programme de nuanceur. Par exemple, un programme de nuanceur peut appliquer plusieurs transformations de matrice consécutives, ce qui améliore l'efficacité et la qualité.

Les effets vidéo sont également compatibles avec l'aperçu dans ExoPlayer, à l'aide de ExoPlayer.setVideoEffects. Pour obtenir un exemple d'utilisation de cette API, consultez l'application de démonstration des effets.

L'application de démonstration inclut des exemples d'effets vidéo personnalisés.

Montages audio

Les effets audio sont implémentés en appliquant une séquence d'instances AudioProcessor à l'audio brut (PCM). ExoPlayer permet de transmettre des processeurs audio à DefaultAudioSink.Builder, ce qui permet de prévisualiser les modifications audio.