ExoPlayer 多路流切换

 val mediaDataSourceFactory: DataSource.Factory = DefaultDataSource.Factory(this)

        var array = ArrayList<MediaItem>()
        var mediaSources = ArrayList<MediaSource>()

        //加入480资源，包含音频和视频Track
        array.add(MediaItem.fromUri("asset://android_asset/viNM94G2aJw000_G/Video@MV@480/data"))
        //加入1080，包含音频和视频Track
        array.add(MediaItem.fromUri("asset://android_asset/viNM94G2aJw000_G/Video@MV@1080/data"))

        //再加入2组音频，可以实现音频切换效果，下面的ACC是高品质伴奏
        array.add(MediaItem.fromUri("asset://android_asset/viNM94G2aJw000_G/Audio@ACC@Q_1/data"))
        //加入原唱
        array.add(MediaItem.fromUri("asset://android_asset/viNM94G2aJw000_G/Audio@ORI@Q_1/data"))

        val mediaSourceFactory = DefaultMediaSourceFactory(mediaDataSourceFactory)

        array.forEach {
            mediaSources.add(mediaSourceFactory.createMediaSource(it))
        }

        var targetMergingMediaSource = MergingMediaSource(mediaSources[0],mediaSources[1],mediaSources[2])

public static void switchToOtherVideoTrack(ExoPlayer exoPlayer, @NotNull Tracks tracks, int width, int heigth) {
        if (tracks == null || exoPlayer == null) return;
        ImmutableList<Tracks.Group> groups = tracks.getGroups();
        for (Tracks.Group group :
                groups) {
            if (group == null) continue;
            if (group.getType() != C.TRACK_TYPE_VIDEO) {
                continue; //非视频的不切换
            }
            boolean selected = group.isSelected();
            if (selected) {
                continue; //当前播的不切换
            }
            for (int trackIndex = 0; trackIndex < group.length; trackIndex++) {
            //获取一种匹配的视频，理论上group.length一般是1
                Format trackFormat = group.getTrackFormat(trackIndex);
                if (trackFormat.width != width || trackFormat.height != heigth) {
                    continue;
                }

                TrackSelectionParameters trackSelectionParameters = exoPlayer.getTrackSelectionParameters();
                TrackSelectionParameters selectionParameters = trackSelectionParameters
                        .buildUpon()
                        .setOverrideForType(
                                new TrackSelectionOverride(
                                        group.getMediaTrackGroup(), ImmutableList.of(trackIndex) //设置目标媒体资源组和目标Track索引
                                )
                        )
                        .setTrackTypeDisabled(group.getType(), /* disabled= */ false) //保证改Track不被关闭
                        .build();

                exoPlayer.setTrackSelectionParameters(selectionParameters);
                Log.d("SelectTrackHelper", "--->group :" + group + ", selected=" + selected + ",group=" + group.getType() + "," + trackFormat);
            }
        }
    }

SelectTrackHelper.switchToOtherVideoTrack(simpleExoPlayer,simpleExoPlayer.currentTracks,848,476)

 private void reselectTracksInternal() throws ExoPlaybackException {
    float playbackSpeed = mediaClock.getPlaybackParameters().speed;
    // Reselect tracks on each period in turn, until the selection changes.
    MediaPeriodHolder periodHolder = queue.getPlayingPeriod();
    MediaPeriodHolder readingPeriodHolder = queue.getReadingPeriod();
    boolean selectionsChangedForReadPeriod = true;
    TrackSelectorResult newTrackSelectorResult;

    //查找匹配当前参数的periodHolder
    while (true) {
      if (periodHolder == null || !periodHolder.prepared) {
        // The reselection did not change any prepared periods.
        return;
      }
     //这里是重点，会调用到MappingTrackSelector#selectTracks方法，返回新的结果
      newTrackSelectorResult = periodHolder.selectTracks(playbackSpeed, playbackInfo.timeline);
      if (!newTrackSelectorResult.isEquivalent(periodHolder.getTrackSelectorResult())) {
        // Selected tracks have changed for this period.
       //判断新的结果和当前是不是一样，一样的话重新选择，不一样说明选择成功
        break;
      }
      if (periodHolder == readingPeriodHolder) {
        // The track reselection didn't affect any period that has been read.
        selectionsChangedForReadPeriod = false;
      }
      periodHolder = periodHolder.getNext();
    }

    //重建流数组，如果匹配的解码位置比较靠前的话
    if (selectionsChangedForReadPeriod) {
      // Update streams and rebuffer for the new selection, recreating all streams if reading ahead.
      MediaPeriodHolder playingPeriodHolder = queue.getPlayingPeriod();
      boolean recreateStreams = queue.removeAfter(playingPeriodHolder);

      boolean[] streamResetFlags = new boolean[renderers.length];
      long periodPositionUs =
          playingPeriodHolder.applyTrackSelection(
              newTrackSelectorResult, playbackInfo.positionUs, recreateStreams, streamResetFlags);
      playbackInfo =
          handlePositionDiscontinuity(
              playbackInfo.periodId, periodPositionUs, playbackInfo.requestedContentPositionUs);
      if (playbackInfo.playbackState != Player.STATE_ENDED
          && periodPositionUs != playbackInfo.positionUs) {
        playbackInfoUpdate.setPositionDiscontinuity(Player.DISCONTINUITY_REASON_INTERNAL);
        resetRendererPosition(periodPositionUs);
      }

     //按照Renders顺序，分别对比每个Renderer和每个SampleStream，判断当前正在使用的渲染器Track流是否匹配
     //注意：这里是循环，说明我们切换多路流时可以同时切换音频和视频等轨道

      boolean[] rendererWasEnabledFlags = new boolean[renderers.length];
      for (int i = 0; i < renderers.length; i++) {
        Renderer renderer = renderers[i];
        
        //获取第i轨道正在使用的渲染器，注意这里是可以渲染
        rendererWasEnabledFlags[i] = isRendererEnabled(renderer);  
        //获取第i轨道当前正在使用的SampleStream
        SampleStream sampleStream = playingPeriodHolder.sampleStreams[i];
         //当前渲染器正在使用才会被检测
        if (rendererWasEnabledFlags[i]) { 
          
          if (sampleStream != renderer.getStream()) {
            // We need to disable the renderer.
           //如果当前渲染器的码流和目标码流不匹配，则关闭当前渲染器

            disableRenderer(renderer); 
          } else if (streamResetFlags[i]) {
            // The renderer will continue to consume from its current stream, but needs to be reset.
            renderer.resetPosition(rendererPositionUs);
//如果码流匹配，统一同步播放位置
          }
        }
      }
//重新创建被关闭的渲染器
      enableRenderers(rendererWasEnabledFlags);
     
    } else {
//如果还没播放，则直接走启动逻辑
      // Release and re-prepare/buffer periods after the one whose selection changed.
      queue.removeAfter(periodHolder);
      if (periodHolder.prepared) {
        long loadingPeriodPositionUs =
            max(periodHolder.info.startPositionUs, periodHolder.toPeriodTime(rendererPositionUs));
        periodHolder.applyTrackSelection(newTrackSelectorResult, loadingPeriodPositionUs, false);
      }
    }
    handleLoadingMediaPeriodChanged(/* loadingTrackSelectionChanged= */ true);
    if (playbackInfo.playbackState != Player.STATE_ENDED) {
      //这里会通过开始时间，查询SeekPoint，设置采样队列时间界值
      maybeContinueLoading();
      updatePlaybackPositions();
      handler.sendEmptyMessage(MSG_DO_SOME_WORK);
    }
  }

loadable.setLoadPosition(
    checkNotNull(seekMap).getSeekPoints(pendingResetPositionUs).first.position,
    pendingResetPositionUs);

 for (SampleQueue sampleQueue : sampleQueues) {
        sampleQueue.setStartTimeUs(pendingResetPositionUs);
    }

if (buffer.timeUs < startTimeUs) {
//这里对inputBuffer添加标记
  buffer.addFlag(C.BUFFER_FLAG_DECODE_ONLY); 
}

if (isDecodeOnlyBuffer && !isLastBuffer) {
  skipOutputBuffer(codec, bufferIndex, presentationTimeUs);
  return true;
}

   public void render(long positionUs, long elapsedRealtimeUs) throws ExoPlaybackException {
   
      if (bypassEnabled) {
        TraceUtil.beginSection("bypassRender");
        while (bypassRender(positionUs, elapsedRealtimeUs)) {}
        TraceUtil.endSection();
      } else if (codec != null) {
        long renderStartTimeMs = SystemClock.elapsedRealtime();
        TraceUtil.beginSection("drainAndFeed");
        //消费InputBuffer数据
        while (drainOutputBuffer(positionUs, elapsedRealtimeUs)
            && shouldContinueRendering(renderStartTimeMs)) {}
            //读取InputBuffer数据
        while (feedInputBuffer() && shouldContinueRendering(renderStartTimeMs)) {}
        TraceUtil.endSection();
      } else {
        decoderCounters.skippedInputBufferCount += skipSource(positionUs);
        // We need to read any format changes despite not having a codec so that drmSession can be
        // updated, and so that we have the most recent format should the codec be initialized. We
        // may also reach the end of the stream. Note that readSource will not read a sample into a
        // flags-only buffer.
        readToFlagsOnlyBuffer(/* requireFormat= */ false);
      }
      decoderCounters.ensureUpdated();
   
  }

  boolean treatDroppedBuffersAsSkipped = joiningDeadlineMs != C.TIME_UNSET;
    if (shouldDropBuffersToKeyframe(earlyUs, elapsedRealtimeUs, isLastBuffer)
        && maybeDropBuffersToKeyframe(
            codec, bufferIndex, presentationTimeUs, positionUs, treatDroppedBuffersAsSkipped)) {
      return false;
    } else if (shouldDropOutputBuffer(earlyUs, elapsedRealtimeUs, isLastBuffer)) {
      if (treatDroppedBuffersAsSkipped) {
        skipOutputBuffer(codec, bufferIndex, presentationTimeUs);
      } else {
        dropOutputBuffer(codec, bufferIndex, presentationTimeUs);
      }
      updateVideoFrameProcessingOffsetCounters(earlyUs);
      return true;
    }