HLS

ExoPlayer est compatible avec HLS et plusieurs formats de conteneur. Les formats d'échantillon audio et vidéo contenus doivent également être compatibles (pour en savoir plus, consultez la section Formats d'échantillon ). Nous encourageons vivement les producteurs de contenu HLS à générer des flux HLS de haute qualité, comme décrit dans cet article de blog.

Fonctionnalité	Compatible	Commentaires
Conteneurs
MPEG-TS	OUI
FMP4/CMAF	OUI
ADTS (AAC)	OUI
MP3	OUI
Sous-titres codés / sous-titres
CEA-608	OUI
CEA-708	OUI
WebVTT	OUI
Métadonnées
ID3	OUI
SCTE-35	NON
Protection du contenu
AES-128	OUI
Exemple AES-128	NON
Widevine	OUI	API 19+ (schéma "cenc") et 25+ (schéma "cbcs")
PlayReady SL2000	OUI	Android TV uniquement
Contrôle du serveur
Mises à jour delta	OUI
Blocage du rechargement de la playlist	OUI
Blocage du chargement des indices de préchargement	OUI	Sauf pour les plages d'octets dont la longueur n'est pas définie
Insertion d'annonces
Insertion d'annonces guidée par le serveur (interstitiels)	En partie	Uniquement la vidéo à la demande avec X-ASSET-URI. Les diffusions en direct et X-ASSET-LIST seront ajoutées ultérieurement.
Annonces IMA côté serveur et côté client	OUI	Guide d'insertion d'annonces
Lecture en direct
Lecture en direct normale	OUI
HLS à faible latence (Apple)	OUI
HLS à faible latence (communauté)	NON
CMCD (Common Media Client Data)	OUI	Guide d'intégration CMCD

Utiliser MediaItem

Pour lire un flux HLS, vous devez dépendre du module HLS.

Kotlin

implementation("androidx.media3:media3-exoplayer-hls:1.10.0")

Groovy

implementation "androidx.media3:media3-exoplayer-hls:1.10.0"

Vous pouvez ensuite créer un MediaItem pour un URI de playlist HLS et le transmettre au lecteur.

Kotlin

// Create a player instance.
val player = ExoPlayer.Builder(context).build()
// Set the media item to be played.
player.setMediaItem(MediaItem.fromUri(hlsUri))
// Prepare the player.
player.prepare()
Hls.kt

Java

// Create a player instance.
ExoPlayer player = new ExoPlayer.Builder(context).build();
// Set the media item to be played.
player.setMediaItem(MediaItem.fromUri(hlsUri));
// Prepare the player.
player.prepare();
Hls.java

Si votre URI ne se termine pas par .m3u8, vous pouvez transmettre MimeTypes.APPLICATION_M3U8 à setMimeType de MediaItem.Builder pour indiquer explicitement le type de contenu.

L'URI de l'élément multimédia peut pointer vers une playlist multimédia ou une playlist multivariante. Si l'URI pointe vers une playlist multivariante qui déclare plusieurs tags #EXT-X-STREAM-INF, ExoPlayer s'adaptera automatiquement entre les variantes, en tenant compte de la bande passante disponible et des capacités de l'appareil.

Utiliser HlsMediaSource

Pour plus d'options de personnalisation, vous pouvez créer un HlsMediaSource et le transmettre directement au lecteur au lieu d'un MediaItem.

Kotlin

// Create a data source factory.
val dataSourceFactory: DataSource.Factory = DefaultHttpDataSource.Factory()
// Create a HLS media source pointing to a playlist uri.
val hlsMediaSource =
  HlsMediaSource.Factory(dataSourceFactory).createMediaSource(MediaItem.fromUri(hlsUri))
// Create a player instance.
val player = ExoPlayer.Builder(context).build()
// Set the HLS media source as the playlist with a single media item.
player.setMediaSource(hlsMediaSource)
// Prepare the player.
player.prepare()
Hls.kt

Java

// Create a data source factory.
DataSource.Factory dataSourceFactory = new DefaultHttpDataSource.Factory();
// Create a HLS media source pointing to a playlist uri.
HlsMediaSource hlsMediaSource =
    new HlsMediaSource.Factory(dataSourceFactory).createMediaSource(MediaItem.fromUri(hlsUri));
// Create a player instance.
ExoPlayer player = new ExoPlayer.Builder(context).build();
// Set the HLS media source as the playlist with a single media item.
player.setMediaSource(hlsMediaSource);
// Prepare the player.
player.prepare();
Hls.java

Accéder au fichier manifeste

Vous pouvez récupérer le fichier manifeste actuel en appelant Player.getCurrentManifest. Pour HLS, vous devez caster l'objet renvoyé en HlsManifest. Le rappel onTimelineChanged de Player.Listener est également appelé chaque fois que le fichier manifeste est chargé. Cela se produit une fois pour le contenu à la demande et peut-être plusieurs fois pour le contenu en direct. L'extrait de code suivant montre comment une application peut effectuer une action chaque fois que le fichier manifeste est chargé.

Kotlin

player.addListener(
  object : Player.Listener {
    override fun onTimelineChanged(
      timeline: Timeline,
      @Player.TimelineChangeReason reason: Int,
    ) {
      val manifest = player.currentManifest
      if (manifest is HlsManifest) {
        // Do something with the manifest.
      }
    }
  }
)
Hls.kt

Java

player.addListener(
    new Player.Listener() {
      @Override
      public void onTimelineChanged(
          Timeline timeline, @Player.TimelineChangeReason int reason) {
        Object manifest = player.getCurrentManifest();
        if (manifest != null) {
          HlsManifest hlsManifest = (HlsManifest) manifest;
          // Do something with the manifest.
        }
      }
    });
Hls.java

Lire des flux HLS avec des interstitiels

La spécification HLS définit les interstitiels HLS qui peuvent être utilisés pour inclure des informations interstitielles dans une playlist multimédia. Par défaut, ExoPlayer ignore ces interstitiels. La compatibilité peut être ajoutée à l'aide de HlsInterstitialsAdsLoader. Nous ne prenons pas en charge toutes les fonctionnalités de la spécification dès le début. Si votre flux n'est pas compatible, signalez-le en créant un problème sur GitHub et envoyez-nous l'URI de votre flux afin que nous puissions ajouter la compatibilité.

Utiliser un MediaItem avec l'API de playlist

Le moyen le plus pratique de lire des flux HLS avec des interstitiels consiste à créer une instance ExoPlayer avec un HlsInterstitialsAdsLoader.AdsMediaSourceFactory. Cela permet d'utiliser l'API de playlist basée sur MediaItem de l'Player interface pour lire les interstitiels HLS.

Le MediaSource.Factory d'ExoPlayer peut être injecté dans le compilateur lors de la création de l'instance du lecteur :

Kotlin

val hlsInterstitialsAdsLoader = HlsInterstitialsAdsLoader(context)
// Create a MediaSource.Factory for HLS streams with interstitials.
val hlsMediaSourceFactory =
  HlsInterstitialsAdsLoader.AdsMediaSourceFactory(
    hlsInterstitialsAdsLoader,
    playerView,
    DefaultMediaSourceFactory(context),
  )

// Build player with interstitials media source factory
val player = ExoPlayer.Builder(context).setMediaSourceFactory(hlsMediaSourceFactory).build()

// Set the player on the ads loader.
hlsInterstitialsAdsLoader.setPlayer(player)
playerView.setPlayer(player)
Hls.kt

Java

HlsInterstitialsAdsLoader hlsInterstitialsAdsLoader = new HlsInterstitialsAdsLoader(context);
// Create a MediaSource.Factory for HLS streams with interstitials.
MediaSource.Factory hlsMediaSourceFactory =
    new HlsInterstitialsAdsLoader.AdsMediaSourceFactory(
        hlsInterstitialsAdsLoader, playerView, new DefaultMediaSourceFactory(context));

// Build player with interstitials media source factory
ExoPlayer player =
    new ExoPlayer.Builder(context).setMediaSourceFactory(hlsMediaSourceFactory).build();

// Set the player on the ads loader.
hlsInterstitialsAdsLoader.setPlayer(player);
playerView.setPlayer(player);
Hls.java

Avec une telle configuration de lecteur, la lecture des interstitiels HLS consiste simplement à définir un élément multimédia avec une AdsConfiguration sur le lecteur :

Kotlin

// Build an HLS media item with ads configuration to be played.
player.setMediaItem(
  MediaItem.Builder()
    .setUri("https://www.example.com/media.m3u8")
    .setAdsConfiguration(
      MediaItem.AdsConfiguration.Builder("hls://interstitials".toUri())
        .setAdsId("ad-tag-0") // must be unique within playlist
        .build()
    )
    .build()
)

player.prepare()
player.play()
Hls.kt

Java

// Build an HLS media item with ads configuration to be played.
player.setMediaItem(
    new MediaItem.Builder()
        .setUri("https://www.example.com/media.m3u8")
        .setAdsConfiguration(
            new AdsConfiguration.Builder(Uri.parse("hls://interstitials"))
                .setAdsId("ad-tag-0") // must be unique within playlist
                .build())
        .build());
player.prepare();
player.play();
Hls.java

Remarque : Le HlsInterstitialsAdsLoader.AdsMediaSourceFactory peut être utilisé pour n'importe quel flux HLS. Si la configuration des annonces est omise, la source est lue comme si elle avait été créée directement avec HlsMediaSource.Factory.

Utiliser l'API basée sur la source multimédia

Vous pouvez également créer l'instance ExoPlayer sans remplacer la fabrique de sources multimédias par défaut. Pour prendre en charge les interstitiels, une application peut ensuite utiliser HlsInterstitialsAdsLoader.AdsMediaSourceFactory directement pour créer un MediaSource et le fournir à ExoPlayer à l'aide de l'API de playlist basée sur la source multimédia :

Kotlin

val hlsInterstitialsAdsLoader = HlsInterstitialsAdsLoader(context)
// Create a MediaSource.Factory for HLS streams with interstitials.
val hlsMediaSourceFactory =
  HlsInterstitialsAdsLoader.AdsMediaSourceFactory(
    hlsInterstitialsAdsLoader,
    playerView,
    context,
  )

// Build player with default media source factory.
val player = ExoPlayer.Builder(context).build()

// Create an media source from an HLS media item with ads configuration.
val mediaSource =
  hlsMediaSourceFactory.createMediaSource(
    MediaItem.Builder()
      .setUri("https://www.example.com/media.m3u8")
      .setAdsConfiguration(
        MediaItem.AdsConfiguration.Builder("hls://interstitials".toUri())
          .setAdsId("ad-tag-0")
          .build()
      )
      .build()
  )

// Set the media source on the player.
player.setMediaSource(mediaSource)
player.prepare()
player.play()
Hls.kt

Java

HlsInterstitialsAdsLoader hlsInterstitialsAdsLoader = new HlsInterstitialsAdsLoader(context);
// Create a MediaSource.Factory for HLS streams with interstitials.
MediaSource.Factory hlsMediaSourceFactory =
    new HlsInterstitialsAdsLoader.AdsMediaSourceFactory(
        hlsInterstitialsAdsLoader, playerView, context);

// Build player with default media source factory.
ExoPlayer player = new ExoPlayer.Builder(context).build();

// Create an media source from an HLS media item with ads configuration.
MediaSource mediaSource =
    hlsMediaSourceFactory.createMediaSource(
        new MediaItem.Builder()
            .setUri("https://www.example.com/media.m3u8")
            .setAdsConfiguration(
                new MediaItem.AdsConfiguration.Builder(Uri.parse("hls://interstitials"))
                    .setAdsId("ad-tag-0")
                    .build())
            .build());

// Set the media source on the player.
player.setMediaSource(mediaSource);
player.prepare();
player.play();
Hls.java

Écouter les événements d'annonce

Un Listener peut être ajouté à HlsInterstitialsAdsLoader pour surveiller les événements concernant les changements d'état de la lecture des interstitiels HLS. Cela permet à une application ou à un SDK de suivre les annonces diffusées, les listes d'éléments en cours de chargement, les sources multimédias d'annonces en cours de préparation ou de détecter les erreurs de chargement de la liste d'éléments et de préparation des annonces. De plus, les métadonnées émises par les sources multimédias d'annonces peuvent être reçues pour une vérification précise de la lecture des annonces ou pour suivre la progression de la lecture des annonces.

Remarque : Un Player.Listener classique peut être utilisé pour suivre la lecture (d'annonces) plus en détail (voir Écouter les événements du lecteur).

Kotlin

class AdsLoaderListener : HlsInterstitialsAdsLoader.Listener {

  override fun onStart(mediaItem: MediaItem, adsId: Any, adViewProvider: AdViewProvider) {
    // Do something when HLS media item with interstitials is started.
  }

  override fun onMetadata(
    mediaItem: MediaItem,
    adsId: Any,
    adGroupIndex: Int,
    adIndexInAdGroup: Int,
    metadata: Metadata,
  ) {
    // Do something with metadata that is emitted by the ad media source of the given ad.
  }

  override fun onAdCompleted(
    mediaItem: MediaItem,
    adsId: Any,
    adGroupIndex: Int,
    adIndexInAdGroup: Int,
  ) {
    // Do something when ad completed playback.
  }

  // ... See JavaDoc for further callbacks of HlsInterstitialsAdsLoader.Listener.

  override fun onStop(mediaItem: MediaItem, adsId: Any, adPlaybackState: AdPlaybackState) {
    // Do something with the resulting ad playback state when stopped.
  }
}
Hls.kt

Java

@OptIn(markerClass = UnstableApi.class)
private static class AdsLoaderListener implements HlsInterstitialsAdsLoader.Listener {

  // implement HlsInterstitialsAdsLoader.Listener
  @Override
  public void onStart(MediaItem mediaItem, Object adsId, AdViewProvider adViewProvider) {
    // Do something when HLS media item with interstitials is started.
  }

  @Override
  public void onMetadata(
      MediaItem mediaItem,
      Object adsId,
      int adGroupIndex,
      int adIndexInAdGroup,
      Metadata metadata) {
    // Do something with metadata that is emitted by the ad media source of the given ad.
  }

  @Override
  public void onAdCompleted(
      MediaItem mediaItem, Object adsId, int adGroupIndex, int adIndexInAdGroup) {
    // Do something when ad completed playback.
  }

  // ... See JavaDoc for further callbacks

  @Override
  public void onStop(MediaItem mediaItem, Object adsId, AdPlaybackState adPlaybackState) {
    // Do something with the resulting ad playback state when stopped.
  }
}
Hls.java

Consultez la documentation JavaDoc de HlsInterstitialsAdsLoader.Listener pour obtenir la documentation détaillée de tous les rappels disponibles.

L'écouteur peut ensuite être ajouté au chargeur d'annonces :

Kotlin

val listener = AdsLoaderListener()
// Add the listener to the ads loader to receive ad loader events.
hlsInterstitialsAdsLoader.addListener(listener)
Hls.kt

Java

AdsLoaderListener listener = new AdsLoaderListener();
// Add the listener to the ads loader to receive ad loader events.
hlsInterstitialsAdsLoader.addListener(listener);
Hls.java

Cycle de vie HlsInterstitialsAdsLoader

Une instance de HlsInterstitialsAdsLoader ou HlsInterstitialsAdsLoader.AdsMediaSourceFactory peut être réutilisée pour plusieurs instances de lecteur qui créent plusieurs sources multimédias pour lesquelles des annonces doivent être chargées.

Une instance peut être créée, par exemple, dans la méthode onCreate d'une Activity, puis être réutilisée pour plusieurs instances de lecteur. Cela fonctionne tant qu'elle est utilisée par une seule instance de lecteur à la fois. Ceci est utile dans le cas d'utilisation courant où l'application est mise en arrière-plan, l'instance du lecteur est détruite, puis une nouvelle instance est créée lorsque l'application est de nouveau au premier plan.

Reprise de la lecture avec un état de lecture d'annonce

Pour éviter que les utilisateurs n'aient à regarder à nouveau les annonces, l'état de lecture des annonces peut être enregistré et restauré lorsque le lecteur est recréé. Pour ce faire, appelez getAdsResumptionStates() lorsque le lecteur est sur le point d'être libéré et stockez les objets AdsResumptionState renvoyés. Lorsque le lecteur est recréé, l'état peut être restauré en appelant addAdResumptionState() sur l'instance du chargeur d'annonces. AdsResumptionState est regroupable. Il peut donc être stocké dans un bundle onSaveInstanceState d'une Activity. Notez que la reprise des annonces n'est compatible qu'avec les flux VOD.

Kotlin

class HlsInterstitialsActivity : Activity() {

  companion object {
    const val ADS_RESUMPTION_STATE_KEY = "ads_resumption_state"
  }

  private var hlsInterstitialsAdsLoader: HlsInterstitialsAdsLoader? = null
  private var playerView: PlayerView? = null
  private var player: ExoPlayer? = null
  private var adsResumptionStates: List<HlsInterstitialsAdsLoader.AdsResumptionState>? = null

  @Suppress("DEPRECATION") // getParcelableArrayList without class type is deprecated in API 33+
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // Create the ads loader instance.
    hlsInterstitialsAdsLoader = HlsInterstitialsAdsLoader(this)
    // Restore ad resumption states.
    val bundles =
      if (Build.VERSION.SDK_INT >= 33) {
        savedInstanceState?.getParcelableArrayList(ADS_RESUMPTION_STATE_KEY, Bundle::class.java)
      } else {
        savedInstanceState?.getParcelableArrayList(ADS_RESUMPTION_STATE_KEY)
      }
    adsResumptionStates = bundles?.map(HlsInterstitialsAdsLoader.AdsResumptionState::fromBundle)
  }

  override fun onStart() {
    super.onStart()
    // Build a player and set it on the ads loader.
    initializePlayer()
    hlsInterstitialsAdsLoader?.setPlayer(player)
    // Add any stored ad resumption states to the ads loader.
    adsResumptionStates?.forEach { hlsInterstitialsAdsLoader?.addAdResumptionState(it) }
    adsResumptionStates = null // Consume the states
  }

  override fun onStop() {
    super.onStop()
    // Get ad resumption states.
    adsResumptionStates = hlsInterstitialsAdsLoader?.adsResumptionStates
    releasePlayer()
  }

  override fun onDestroy() {
    // Release the ads loader when not used anymore.
    hlsInterstitialsAdsLoader?.release()
    hlsInterstitialsAdsLoader = null
    super.onDestroy()
  }

  override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState)
    // Store the ad resumption states.
    adsResumptionStates?.let {
      outState.putParcelableArrayList(
        ADS_RESUMPTION_STATE_KEY,
        ArrayList(it.map(HlsInterstitialsAdsLoader.AdsResumptionState::toBundle)),
      )
    }
  }

  fun initializePlayer() {
    if (player == null) {
      // Create a media source factory for HLS streams.
      val hlsMediaSourceFactory =
        HlsInterstitialsAdsLoader.AdsMediaSourceFactory(
          checkNotNull(hlsInterstitialsAdsLoader),
          playerView!!,
          /* context= */ this,
        )
      // Build player with interstitials media source
      player =
        ExoPlayer.Builder(/* context= */ this)
          .setMediaSourceFactory(hlsMediaSourceFactory)
          .build()
      // Set the player on the ads loader.
      hlsInterstitialsAdsLoader?.setPlayer(player)
      playerView?.player = player
    }

    // Use a media item with an HLS stream URI, an ad tag URI and ads ID.
    player?.setMediaItem(
      MediaItem.Builder()
        .setUri("https://www.example.com/media.m3u8")
        .setMimeType(MimeTypes.APPLICATION_M3U8)
        .setAdsConfiguration(
          MediaItem.AdsConfiguration.Builder("hls://interstitials".toUri())
            .setAdsId("ad-tag-0") // must be unique within ExoPlayer playlist
            .build()
        )
        .build()
    )
    player?.prepare()
    player?.play()
  }

  fun releasePlayer() {
    player?.release()
    player = null
    hlsInterstitialsAdsLoader?.setPlayer(null)
    playerView?.player = null
  }
}
Hls.kt

Java

@OptIn(markerClass = UnstableApi.class)
public static class HlsInterstitialsActivity extends Activity {

  public static final String ADS_RESUMPTION_STATE_KEY = "ads_resumption_state";

  @Nullable private HlsInterstitialsAdsLoader hlsInterstitialsAdsLoader;
  @Nullable private PlayerView playerView;
  @Nullable private ExoPlayer player;

  private List<HlsInterstitialsAdsLoader.AdsResumptionState> adsResumptionStates;

  @SuppressWarnings(
      "deprecation") // getParcelableArrayList without class type is deprecated in API 33+
  @Override
  protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Create the ads loader instance.
    hlsInterstitialsAdsLoader = new HlsInterstitialsAdsLoader(this);
    // Restore ad resumption states.
    if (savedInstanceState != null) {
      ArrayList<Bundle> bundles;
      if (Build.VERSION.SDK_INT >= 33) {
        bundles =
            savedInstanceState.getParcelableArrayList(ADS_RESUMPTION_STATE_KEY, Bundle.class);
      } else {
        bundles = savedInstanceState.getParcelableArrayList(ADS_RESUMPTION_STATE_KEY);
      }
      if (bundles != null) {
        adsResumptionStates = new ArrayList<>();
        for (Bundle bundle : bundles) {
          adsResumptionStates.add(
              HlsInterstitialsAdsLoader.AdsResumptionState.fromBundle(bundle));
        }
      }
    }
  }

  @Override
  protected void onStart() {
    super.onStart();
    // Build a player and set it on the ads loader.
    initializePlayer();
    // Add any stored ad resumption states to the ads loader.
    if (adsResumptionStates != null) {
      for (HlsInterstitialsAdsLoader.AdsResumptionState state : adsResumptionStates) {
        hlsInterstitialsAdsLoader.addAdResumptionState(state);
      }
      adsResumptionStates = null; // Consume the states
    }
  }

  @Override
  protected void onStop() {
    super.onStop();
    // Get ad resumption states before releasing the player.
    if (hlsInterstitialsAdsLoader != null) {
      adsResumptionStates = hlsInterstitialsAdsLoader.getAdsResumptionStates();
    }
    releasePlayer();
  }

  @Override
  protected void onDestroy() {
    // Release the ads loader when not used anymore.
    if (hlsInterstitialsAdsLoader != null) {
      hlsInterstitialsAdsLoader.release();
      hlsInterstitialsAdsLoader = null;
    }
    super.onDestroy();
  }

  @Override
  protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    // Store the ad resumption states.
    if (adsResumptionStates != null) {
      ArrayList<Bundle> bundles = new ArrayList<>();
      for (HlsInterstitialsAdsLoader.AdsResumptionState state : adsResumptionStates) {
        bundles.add(state.toBundle());
      }
      outState.putParcelableArrayList(ADS_RESUMPTION_STATE_KEY, bundles);
    }
  }

  private void initializePlayer() {
    if (player == null) {
      // Create a media source factory for HLS streams.
      MediaSource.Factory hlsMediaSourceFactory =
          new HlsInterstitialsAdsLoader.AdsMediaSourceFactory(
              checkNotNull(hlsInterstitialsAdsLoader), playerView, /* context= */ this);
      // Build player with interstitials media source
      player =
          new ExoPlayer.Builder(/* context= */ this)
              .setMediaSourceFactory(hlsMediaSourceFactory)
              .build();
      // Set the player on the ads loader.
      hlsInterstitialsAdsLoader.setPlayer(player);
      playerView.setPlayer(player);
    }

    // Use a media item with an HLS stream URI, an ad tag URI and ads ID.
    player.setMediaItem(
        new MediaItem.Builder()
            .setUri("https://www.example.com/media.m3u8")
            .setMimeType(MimeTypes.APPLICATION_M3U8)
            .setAdsConfiguration(
                new MediaItem.AdsConfiguration.Builder(Uri.parse("hls://interstitials"))
                    .setAdsId("ad-tag-0") // must be unique within ExoPlayer playlist
                    .build())
            .build());
    player.prepare();
    player.play();
  }

  private void releasePlayer() {
    if (player != null) {
      player.release();
      player = null;
    }
    if (hlsInterstitialsAdsLoader != null) {
      hlsInterstitialsAdsLoader.setPlayer(null);
    }
    if (playerView != null) {
      playerView.setPlayer(null);
    }
  }
}
Hls.java

Personnaliser la lecture

ExoPlayer vous offre plusieurs façons d'adapter l'expérience de lecture aux besoins de votre application. Pour obtenir des exemples, consultez la page Personnalisation.

Désactiver la préparation sans segment

Par défaut, ExoPlayer utilise la préparation sans segment. Cela signifie qu'ExoPlayer n'utilisera que les informations de la playlist multivariante pour préparer le flux, ce qui fonctionne si les tags #EXT-X-STREAM-INF contiennent l'attribut CODECS.

Vous devrez peut-être désactiver cette fonctionnalité si vos segments multimédias contiennent des pistes de sous-titres codés muxées qui ne sont pas déclarées dans la playlist multivariante avec un tag #EXT-X-MEDIA:TYPE=CLOSED-CAPTIONS. Sinon, ces pistes de sous-titres codés ne seront pas détectées ni lues. Vous pouvez désactiver la préparation sans segment dans HlsMediaSource.Factory, comme indiqué dans l'extrait suivant. Notez que cela augmentera le temps de démarrage, car ExoPlayer devra télécharger un segment multimédia pour découvrir ces pistes supplémentaires. Il est préférable de déclarer les pistes de sous-titres codés dans la playlist multivariante.

Kotlin

val hlsMediaSource =
  HlsMediaSource.Factory(dataSourceFactory)
    .setAllowChunklessPreparation(false)
    .createMediaSource(MediaItem.fromUri(hlsUri))
Hls.kt

Java

HlsMediaSource hlsMediaSource =
    new HlsMediaSource.Factory(dataSourceFactory)
        .setAllowChunklessPreparation(false)
        .createMediaSource(MediaItem.fromUri(hlsUri));
Hls.java

Créer du contenu HLS de haute qualité

Pour tirer le meilleur parti d'ExoPlayer, vous pouvez suivre certaines consignes afin d'améliorer votre contenu HLS. Pour obtenir une explication complète, consultez notre article Medium sur la lecture HLS dans ExoPlayer. Voici les points principaux :

• Utilisez des durées de segment précises.
• Utilisez un flux multimédia continu. Évitez les modifications de la structure multimédia entre les segments.
• Utilisez le tag #EXT-X-INDEPENDENT-SEGMENTS.
• Préférez les flux démultiplexés aux fichiers qui incluent à la fois la vidéo et l'audio.
• Incluez toutes les informations possibles dans la playlist multivariante.

Les consignes suivantes s'appliquent spécifiquement aux diffusions en direct :

• Utilisez le tag #EXT-X-PROGRAM-DATE-TIME.
• Utilisez le tag #EXT-X-DISCONTINUITY-SEQUENCE.
• Fournissez une longue fenêtre en direct. Une minute ou plus est idéal.