Seleção de faixas

Quando um item de mídia contém várias faixas, a seleção de faixa é o processo que determina quais deles são escolhidos para reprodução. O processo de seleção de faixas configurado por TrackSelectionParameters, que permite várias restrições e substituições que influenciam a seleção de faixas a serem especificadas.

Consultar as faixas disponíveis

Ouça Player.Listener.onTracksChanged para receber notificações sobre mudanças às faixas, incluindo:

• As faixas disponíveis se tornarem conhecidas durante a preparação do item de mídia a ser tocado é concluído. O player precisa preparar um item de mídia para saber quais trilhas contém.
• As faixas disponíveis que mudam devido à transição da reprodução de uma mídia de um item para outro.
• Mudanças nas faixas selecionadas.

Kotlin

player.addListener(
  object : Player.Listener {
    override fun onTracksChanged(tracks: Tracks) {
      // Update UI using current tracks.
    }
  }
)

Java

player.addListener(
    new Player.Listener() {
      @Override
      public void onTracksChanged(Tracks tracks) {
        // Update UI using current tracks.
      }
    });

Você também pode consultar as faixas atuais chamando player.getCurrentTracks(). O Tracks retornado contém uma lista de objetos Track.Group, em que rastreia dentro de um um único Group apresentam o mesmo conteúdo, mas em formatos diferentes.

Como um exemplo de como as faixas podem ser agrupadas, considere uma reprodução adaptativa, em que um feed de vídeo principal é fornecido em cinco taxas de bits e um feed de vídeo alternativo (por exemplo, um ângulo de câmera diferente em uma partida esportiva) é fornecido em duas taxas de bits. Nesse caso, haverá dois grupos de faixa de vídeo, um correspondente ao vídeo principal um feed de vídeo com cinco faixas e um segundo para o feed de vídeos alternativos contendo duas trilhas.

As faixas de áudio com idiomas diferentes não são agrupadas porque o conteúdo idiomas diferentes não são considerados iguais. Por outro lado, as faixas de áudio no mesmo idioma, que só diferem em propriedades como taxa de bits, amostragem taxa, contagem de canais e assim por diante. Isso também se aplica a faixas de texto.

Cada Group pode ser consultado para determinar quais faixas são compatíveis com a reprodução, quais estão selecionadas no momento e quais Format cada faixa usa:

Kotlin

for (trackGroup in tracks.groups) {
  // Group level information.
  val trackType = trackGroup.type
  val trackInGroupIsSelected = trackGroup.isSelected
  val trackInGroupIsSupported = trackGroup.isSupported
  for (i in 0 until trackGroup.length) {
    // Individual track information.
    val isSupported = trackGroup.isTrackSupported(i)
    val isSelected = trackGroup.isTrackSelected(i)
    val trackFormat = trackGroup.getTrackFormat(i)
  }
}

Java

for (Tracks.Group trackGroup : tracks.getGroups()) {
  // Group level information.
  @C.TrackType int trackType = trackGroup.getType();
  boolean trackInGroupIsSelected = trackGroup.isSelected();
  boolean trackInGroupIsSupported = trackGroup.isSupported();
  for (int i = 0; i < trackGroup.length; i++) {
    // Individual track information.
    boolean isSupported = trackGroup.isTrackSupported(i);
    boolean isSelected = trackGroup.isTrackSelected(i);
    Format trackFormat = trackGroup.getTrackFormat(i);
  }
}

• Uma faixa terá suporte se o Player puder decodificar e renderizar o de amostra. Mesmo que vários grupos de faixas do mesmo tipo (por exemplo, vários grupos de faixas de áudio) são compatíveis, isso significa apenas que são são suportados individualmente e o player não necessariamente pode reproduzi-las ao mesmo tempo.
• Uma faixa será selecionada se tiver sido escolhida para reprodução de acordo com o TrackSelectionParameters Se várias faixas dentro de um grupo de faixas forem selecionada, o player usará essas faixas para reprodução adaptativa (por exemplo, várias faixas de vídeo com diferentes taxas de bits). Observe que apenas um desses faixas serão tocadas a qualquer momento.

Como modificar os parâmetros de seleção de faixa

O processo de seleção de faixa pode ser configurado usando Player.setTrackSelectionParameters: Você pode fazer isso antes e durante a reprodução. O exemplo a seguir demonstra como receber a solicitação TrackSelectionParameters do player, modificá-las e atualizar as Player. com o resultado modificado:

Kotlin

player.trackSelectionParameters =
  player.trackSelectionParameters
    .buildUpon()
    .setMaxVideoSizeSd()
    .setPreferredAudioLanguage("hu")
    .build()

Java

player.setTrackSelectionParameters(
    player
        .getTrackSelectionParameters()
        .buildUpon()
        .setMaxVideoSizeSd()
        .setPreferredAudioLanguage("hu")
        .build());

Seleção de faixas com base em restrições

A maioria das opções em TrackSelectionParameters permite especificar restrições, independentes das faixas que estão realmente disponíveis. Disponível como estas:

• Largura, altura, frame rate e taxa de bits máximas e mínimas do vídeo.
• Contagem e taxa de bits máximas de canais de áudio.
• Tipos MIME preferidos para vídeo e áudio.
• Idiomas de áudio e sinalizações de papéis preferidos.
• Idiomas de texto e sinalizações de funções preferidos.

O ExoPlayer usa padrões sensíveis para essas restrições, por exemplo, restringir a resolução do vídeo para o tamanho da tela e preferindo o idioma do áudio que corresponde à configuração de localidade do sistema do usuário.

Há vários benefícios em usar a seleção de faixas com base em restrições em vez selecionar faixas específicas entre as que estão disponíveis:

• Você pode especificar restrições antes de saber quais faixas um item de mídia oferece. Isso significa que as restrições podem ser especificadas antes que o jogador tenha preparado um item de mídia, enquanto selecionar faixas específicas exige o código do aplicativo para aguardar até que as faixas disponíveis sejam conhecidas.
• As restrições são aplicadas a todos os itens de mídia em uma playlist, mesmo itens têm faixas disponíveis diferentes. Por exemplo, um idioma de áudio preferencial será aplicada automaticamente a todos os itens de mídia, mesmo que a Format da faixa nesse idioma varia de um item de mídia para o próximo. Isso não acontece quando você seleciona faixas específicas, conforme descrito abaixo.

Seleção de faixas específicas

É possível selecionar faixas específicas usando TrackSelectionParameters. Primeiro, as faixas atualmente disponíveis do player devem ser consultadas usando Player.getCurrentTracks: Depois de identificar as faixas a serem selecionadas, Elas podem ser definidas no TrackSelectionParameters usando um TrackSelectionOverride. Por exemplo, para selecionar a primeira faixa de uma audioTrackGroup específica:

Kotlin

player.trackSelectionParameters =
  player.trackSelectionParameters
    .buildUpon()
    .setOverrideForType(
      TrackSelectionOverride(audioTrackGroup.mediaTrackGroup, /* trackIndex= */ 0)
    )
    .build()

Java

player.setTrackSelectionParameters(
    player
        .getTrackSelectionParameters()
        .buildUpon()
        .setOverrideForType(
            new TrackSelectionOverride(
                audioTrackGroup.getMediaTrackGroup(), /* trackIndex= */ 0))
        .build());

Uma TrackSelectionOverride só será aplicada a itens de mídia que contenham uma TrackGroup corresponde exatamente ao especificado na substituição. Portanto, uma pode não ser aplicada a um item de mídia subsequente se esse item contiver trilhas diferentes.

Desativar grupos ou tipos de faixa

Tipos de faixa como vídeo, áudio ou texto podem ser completamente desativados usando TrackSelectionParameters.Builder.setTrackTypeDisabled: Um tipo de faixa desativado será desativado para todos os itens de mídia:

Kotlin

player.trackSelectionParameters =
  player.trackSelectionParameters
    .buildUpon()
    .setTrackTypeDisabled(C.TRACK_TYPE_VIDEO, /* disabled= */ true)
    .build()

Java

player.setTrackSelectionParameters(
    player
        .getTrackSelectionParameters()
        .buildUpon()
        .setTrackTypeDisabled(C.TRACK_TYPE_VIDEO, /* disabled= */ true)
        .build());

Também é possível impedir a seleção das faixas de um determinado TrackGroup especificando uma substituição vazia para esse grupo:

Kotlin

player.trackSelectionParameters =
  player.trackSelectionParameters
    .buildUpon()
    .addOverride(
      TrackSelectionOverride(disabledTrackGroup.mediaTrackGroup, /* trackIndices= */ listOf())
    )
    .build()

Java

player.setTrackSelectionParameters(
    player
        .getTrackSelectionParameters()
        .buildUpon()
        .addOverride(
            new TrackSelectionOverride(
                disabledTrackGroup.getMediaTrackGroup(),
                /* trackIndices= */ ImmutableList.of()))
        .build());

Como personalizar o seletor de faixa

A seleção da faixa é responsabilidade de um TrackSelector, uma instância que podem ser fornecidos sempre que um ExoPlayer é criado e recebido posteriormente. com ExoPlayer.getTrackSelector().

Kotlin

val trackSelector = DefaultTrackSelector(context)
val player = ExoPlayer.Builder(context).setTrackSelector(trackSelector).build()

Java

DefaultTrackSelector trackSelector = new DefaultTrackSelector(context);
ExoPlayer player = new ExoPlayer.Builder(context).setTrackSelector(trackSelector).build();

O DefaultTrackSelector é um TrackSelector flexível adequado para a maioria dos usos casos de uso diferentes. Ela usa o TrackSelectionParameters definido no Player, mas também fornece algumas opções avançadas de personalização que podem ser especificadas no DefaultTrackSelector.ParametersBuilder:

Kotlin

trackSelector.setParameters(
  trackSelector.buildUponParameters().setAllowVideoMixedMimeTypeAdaptiveness(true))
)

Java

trackSelector.setParameters(
    trackSelector.buildUponParameters().setAllowVideoMixedMimeTypeAdaptiveness(true));

Encapsulamento

Você pode ativar a reprodução encapsulada nos casos em que a combinação de renderizadores e para as faixas selecionadas. Para fazer isso, use DefaultTrackSelector.ParametersBuilder.setTunnelingEnabled(true):

Descarregamento de áudio

É possível ativar a reprodução de áudio descarregada quando a combinação de os renderizadores e as faixas selecionadas oferecem suporte a ela. Para fazer isso, especifique AudioOffloadModePreferences no seu TrackSelectionParameters.

Kotlin

val audioOffloadPreferences =
  AudioOffloadPreferences.Builder()
      .setAudioOffloadMode(AudioOffloadPreferences.AUDIO_OFFLOAD_MODE_ENABLED)
      // Add additional options as needed
      .setIsGaplessSupportRequired(true)
      .build()
player.trackSelectionParameters =
  player.trackSelectionParameters
    .buildUpon()
    .setAudioOffloadPreferences(audioOffloadPreferences)
    .build()

Java

AudioOffloadPreferences audioOffloadPreferences =
  new AudioOffloadPreferences.Builder()
      .setAudioOffloadMode(AudioOffloadPreferences.AUDIO_OFFLOAD_MODE_ENABLED)
      // Add additional options as needed
      .setIsGaplessSupportRequired(true)
      .build();
player.setTrackSelectionParameters(
  player.getTrackSelectionParameters()
    .buildUpon()
    .setAudioOffloadPreferences(audioOffloadPreferences)
    .build());
);