Java RendererCapabilities.FORMAT_HANDLED属性代码示例

/**
 * Finds the renderer to which the provided {@link TrackGroup} should be associated.
 * <p>
 * A {@link TrackGroup} is associated to a renderer that reports
 * {@link RendererCapabilities#FORMAT_HANDLED} support for one or more of the tracks in the group,
 * or {@link RendererCapabilities#FORMAT_EXCEEDS_CAPABILITIES} if no such renderer exists, or
 * {@link RendererCapabilities#FORMAT_UNSUPPORTED_SUBTYPE} if again no such renderer exists. In
 * the case that two or more renderers report the same level of support, the renderer with the
 * lowest index is associated.
 * <p>
 * If all renderers report {@link RendererCapabilities#FORMAT_UNSUPPORTED_TYPE} for all of the
 * tracks in the group, then {@code renderers.length} is returned to indicate that no association
 * was made.
 *
 * @param rendererCapabilities The {@link RendererCapabilities} of the renderers.
 * @param group The {@link TrackGroup} whose associated renderer is to be found.
 * @return The index of the associated renderer, or {@code renderers.length} if no
 *     association was made.
 * @throws ExoPlaybackException If an error occurs finding a renderer.
 */
private static int findRenderer(RendererCapabilities[] rendererCapabilities, TrackGroup group)
    throws ExoPlaybackException {
  int bestRendererIndex = rendererCapabilities.length;
  int bestFormatSupportLevel = RendererCapabilities.FORMAT_UNSUPPORTED_TYPE;
  for (int rendererIndex = 0; rendererIndex < rendererCapabilities.length; rendererIndex++) {
    RendererCapabilities rendererCapability = rendererCapabilities[rendererIndex];
    for (int trackIndex = 0; trackIndex < group.length; trackIndex++) {
      int formatSupportLevel = rendererCapability.supportsFormat(group.getFormat(trackIndex))
          & RendererCapabilities.FORMAT_SUPPORT_MASK;
      if (formatSupportLevel > bestFormatSupportLevel) {
        bestRendererIndex = rendererIndex;
        bestFormatSupportLevel = formatSupportLevel;
        if (bestFormatSupportLevel == RendererCapabilities.FORMAT_HANDLED) {
          // We can't do better.
          return bestRendererIndex;
        }
      }
    }
  }
  return bestRendererIndex;
}
 

/**
 * Returns the extent to which a renderer can support playback of the tracks associated to it.
 *
 * @param rendererIndex The renderer index.
 * @return One of {@link #RENDERER_SUPPORT_PLAYABLE_TRACKS},
 *     {@link #RENDERER_SUPPORT_EXCEEDS_CAPABILITIES_TRACKS},
 *     {@link #RENDERER_SUPPORT_UNSUPPORTED_TRACKS} and {@link #RENDERER_SUPPORT_NO_TRACKS}.
 */
public int getRendererSupport(int rendererIndex) {
  int bestRendererSupport = RENDERER_SUPPORT_NO_TRACKS;
  int[][] rendererFormatSupport = formatSupport[rendererIndex];
  for (int i = 0; i < rendererFormatSupport.length; i++) {
    for (int j = 0; j < rendererFormatSupport[i].length; j++) {
      int trackRendererSupport;
      switch (rendererFormatSupport[i][j] & RendererCapabilities.FORMAT_SUPPORT_MASK) {
        case RendererCapabilities.FORMAT_HANDLED:
          return RENDERER_SUPPORT_PLAYABLE_TRACKS;
        case RendererCapabilities.FORMAT_EXCEEDS_CAPABILITIES:
          trackRendererSupport = RENDERER_SUPPORT_EXCEEDS_CAPABILITIES_TRACKS;
          break;
        default:
          trackRendererSupport = RENDERER_SUPPORT_UNSUPPORTED_TRACKS;
          break;
      }
      bestRendererSupport = Math.max(bestRendererSupport, trackRendererSupport);
    }
  }
  return bestRendererSupport;
}
 

private static String getFormatSupportString(int formatSupport) {
  switch (formatSupport) {
    case RendererCapabilities.FORMAT_HANDLED:
      return "YES";
    case RendererCapabilities.FORMAT_EXCEEDS_CAPABILITIES:
      return "NO_EXCEEDS_CAPABILITIES";
    case RendererCapabilities.FORMAT_UNSUPPORTED_DRM:
      return "NO_UNSUPPORTED_DRM";
    case RendererCapabilities.FORMAT_UNSUPPORTED_SUBTYPE:
      return "NO_UNSUPPORTED_TYPE";
    case RendererCapabilities.FORMAT_UNSUPPORTED_TYPE:
      return "NO";
    default:
      return "?";
  }
}
 

/**
 * Finds the renderer to which the provided {@link TrackGroup} should be associated.
 * <p>
 * A {@link TrackGroup} is associated to a renderer that reports
 * {@link RendererCapabilities#FORMAT_HANDLED} support for one or more of the tracks in the group,
 * or {@link RendererCapabilities#FORMAT_EXCEEDS_CAPABILITIES} if no such renderer exists, or
 * {@link RendererCapabilities#FORMAT_UNSUPPORTED_SUBTYPE} if again no such renderer exists. In
 * the case that two or more renderers report the same level of support, the renderer with the
 * lowest index is associated.
 * <p>
 * If all renderers report {@link RendererCapabilities#FORMAT_UNSUPPORTED_TYPE} for all of the
 * tracks in the group, then {@code renderers.length} is returned to indicate that no association
 * was made.
 *
 * @param rendererCapabilities The {@link RendererCapabilities} of the renderers.
 * @param group The {@link TrackGroup} whose associated renderer is to be found.
 * @return The index of the associated renderer, or {@code renderers.length} if no
 *     association was made.
 * @throws ExoPlaybackException If an error occurs finding a renderer.
 */
private static int findRenderer(RendererCapabilities[] rendererCapabilities, TrackGroup group)
    throws ExoPlaybackException {
  int bestRendererIndex = rendererCapabilities.length;
  int bestSupportLevel = RendererCapabilities.FORMAT_UNSUPPORTED_TYPE;
  for (int rendererIndex = 0; rendererIndex < rendererCapabilities.length; rendererIndex++) {
    RendererCapabilities rendererCapability = rendererCapabilities[rendererIndex];
    for (int trackIndex = 0; trackIndex < group.length; trackIndex++) {
      int trackSupportLevel = rendererCapability.supportsFormat(group.getFormat(trackIndex));
      if (trackSupportLevel > bestSupportLevel) {
        bestRendererIndex = rendererIndex;
        bestSupportLevel = trackSupportLevel;
        if (bestSupportLevel == RendererCapabilities.FORMAT_HANDLED) {
          // We can't do better.
          return bestRendererIndex;
        }
      }
    }
  }
  return bestRendererIndex;
}
 

/**
 * Returns the extent to which a renderer can play the tracks in the track groups mapped to it.
 *
 * @param rendererIndex The renderer index.
 * @return One of {@link #RENDERER_SUPPORT_PLAYABLE_TRACKS},
 *     {@link #RENDERER_SUPPORT_EXCEEDS_CAPABILITIES_TRACKS},
 *     {@link #RENDERER_SUPPORT_UNSUPPORTED_TRACKS} and {@link #RENDERER_SUPPORT_NO_TRACKS}.
 */
public int getRendererSupport(int rendererIndex) {
  int bestRendererSupport = RENDERER_SUPPORT_NO_TRACKS;
  int[][] rendererFormatSupport = formatSupport[rendererIndex];
  for (int i = 0; i < rendererFormatSupport.length; i++) {
    for (int j = 0; j < rendererFormatSupport[i].length; j++) {
      int trackRendererSupport;
      switch (rendererFormatSupport[i][j] & RendererCapabilities.FORMAT_SUPPORT_MASK) {
        case RendererCapabilities.FORMAT_HANDLED:
          return RENDERER_SUPPORT_PLAYABLE_TRACKS;
        case RendererCapabilities.FORMAT_EXCEEDS_CAPABILITIES:
          trackRendererSupport = RENDERER_SUPPORT_EXCEEDS_CAPABILITIES_TRACKS;
          break;
        default:
          trackRendererSupport = RENDERER_SUPPORT_UNSUPPORTED_TRACKS;
          break;
      }
      bestRendererSupport = Math.max(bestRendererSupport, trackRendererSupport);
    }
  }
  return bestRendererSupport;
}
 

/**
 * Finds the renderer to which the provided {@link TrackGroup} should be mapped.
 * <p>
 * A {@link TrackGroup} is mapped to the renderer that reports the highest of (listed in
 * decreasing order of support) {@link RendererCapabilities#FORMAT_HANDLED},
 * {@link RendererCapabilities#FORMAT_EXCEEDS_CAPABILITIES},
 * {@link RendererCapabilities#FORMAT_UNSUPPORTED_DRM} and
 * {@link RendererCapabilities#FORMAT_UNSUPPORTED_SUBTYPE}. In the case that two or more renderers
 * report the same level of support, the renderer with the lowest index is associated.
 * <p>
 * If all renderers report {@link RendererCapabilities#FORMAT_UNSUPPORTED_TYPE} for all of the
 * tracks in the group, then {@code renderers.length} is returned to indicate that the group was
 * not mapped to any renderer.
 *
 * @param rendererCapabilities The {@link RendererCapabilities} of the renderers.
 * @param group The track group to map to a renderer.
 * @return The index of the renderer to which the track group was mapped, or
 *     {@code renderers.length} if it was not mapped to any renderer.
 * @throws ExoPlaybackException If an error occurs finding a renderer.
 */
private static int findRenderer(RendererCapabilities[] rendererCapabilities, TrackGroup group)
    throws ExoPlaybackException {
  int bestRendererIndex = rendererCapabilities.length;
  int bestFormatSupportLevel = RendererCapabilities.FORMAT_UNSUPPORTED_TYPE;
  for (int rendererIndex = 0; rendererIndex < rendererCapabilities.length; rendererIndex++) {
    RendererCapabilities rendererCapability = rendererCapabilities[rendererIndex];
    for (int trackIndex = 0; trackIndex < group.length; trackIndex++) {
      int formatSupportLevel = rendererCapability.supportsFormat(group.getFormat(trackIndex))
          & RendererCapabilities.FORMAT_SUPPORT_MASK;
      if (formatSupportLevel > bestFormatSupportLevel) {
        bestRendererIndex = rendererIndex;
        bestFormatSupportLevel = formatSupportLevel;
        if (bestFormatSupportLevel == RendererCapabilities.FORMAT_HANDLED) {
          // We can't do better.
          return bestRendererIndex;
        }
      }
    }
  }
  return bestRendererIndex;
}
 

/**
 * Builds the quality selection list based on the media tracks
 *
 * @param selector      The selector to get all the available tracks
 * @param rendererIndex The render index
 * @return The selection view
 */
public View buildQualityDialog(@NonNull MappingTrackSelector selector, int rendererIndex) {
    setRendererIndex(rendererIndex);
    setSelector(selector);


    // View for clearing the override to allow the selector to use its default selection logic.
    qualityAutoView = new TubiRadioButton(getContext());
    qualityAutoView.setText(R.string.track_selector_alert_auto);
    qualityAutoView.setFocusable(true);
    qualityAutoView.setOnClickListener(this);
    mBinding.viewTubiQualityDialogLl.addView(qualityAutoView);

    // Per-track views.
    trackViews = new TubiRadioButton[trackGroups.length][];
    for (int groupIndex = 0; groupIndex < trackGroups.length; groupIndex++) {
        TrackGroup group = trackGroups.get(groupIndex);
        trackViews[groupIndex] = new TubiRadioButton[group.length];
        for (int trackIndex = 0; trackIndex < group.length; trackIndex++) {
            TubiRadioButton trackView = new TubiRadioButton(getContext());
            trackView.setText(buildTrackName(group.getFormat(trackIndex)));
            if (trackInfo.getTrackFormatSupport(rendererIndex, groupIndex, trackIndex)
                    == RendererCapabilities.FORMAT_HANDLED) {
                trackView.setFocusable(true);
                trackView.setTag(Pair.create(groupIndex, trackIndex));
            } else {
                trackView.setFocusable(false);
                trackView.setEnabled(false);
            }
            trackView.setOnClickListener(this);
            trackViews[groupIndex][trackIndex] = trackView;
            mBinding.viewTubiQualityDialogLl.addView(trackView);
        }
    }

    updateViews();
    return this;
}
 

private static String getFormatSupportString(int formatSupport) {
  switch (formatSupport) {
    case RendererCapabilities.FORMAT_HANDLED:
      return "YES";
    case RendererCapabilities.FORMAT_EXCEEDS_CAPABILITIES:
      return "NO_EXCEEDS_CAPABILITIES";
    case RendererCapabilities.FORMAT_UNSUPPORTED_SUBTYPE:
      return "NO_UNSUPPORTED_TYPE";
    case RendererCapabilities.FORMAT_UNSUPPORTED_TYPE:
      return "NO";
    default:
      return "?";
  }
}
 

private static String getFormatSupportString(int formatSupport) {
    switch (formatSupport) {
        case RendererCapabilities.FORMAT_HANDLED:
            return "YES";
        case RendererCapabilities.FORMAT_EXCEEDS_CAPABILITIES:
            return "NO_EXCEEDS_CAPABILITIES";
        case RendererCapabilities.FORMAT_UNSUPPORTED_SUBTYPE:
            return "NO_UNSUPPORTED_TYPE";
        case RendererCapabilities.FORMAT_UNSUPPORTED_TYPE:
            return "NO";
        default:
            return "?";
    }
}
 

/**
 * Returns the extent to which a renderer can support playback of the tracks associated to it.
 *
 * @param rendererIndex The renderer index.
 * @return One of {@link #RENDERER_SUPPORT_PLAYABLE_TRACKS},
 *     {@link #RENDERER_SUPPORT_UNPLAYABLE_TRACKS} and {@link #RENDERER_SUPPORT_NO_TRACKS}.
 */
public int getRendererSupport(int rendererIndex) {
  boolean hasTracks = false;
  int[][] rendererFormatSupport = formatSupport[rendererIndex];
  for (int i = 0; i < rendererFormatSupport.length; i++) {
    for (int j = 0; j < rendererFormatSupport[i].length; j++) {
      hasTracks = true;
      if ((rendererFormatSupport[i][j] & RendererCapabilities.FORMAT_SUPPORT_MASK)
          == RendererCapabilities.FORMAT_HANDLED) {
        return RENDERER_SUPPORT_PLAYABLE_TRACKS;
      }
    }
  }
  return hasTracks ? RENDERER_SUPPORT_UNPLAYABLE_TRACKS : RENDERER_SUPPORT_NO_TRACKS;
}
 

@SuppressLint("InflateParams")
private View buildView(Context context) {
  LayoutInflater inflater = LayoutInflater.from(context);
  View view = inflater.inflate(R.layout.track_selection_dialog, null);
  ViewGroup root = (ViewGroup) view.findViewById(R.id.root);

  TypedArray attributeArray = context.getTheme().obtainStyledAttributes(
      new int[] {android.R.attr.selectableItemBackground});
  int selectableItemBackgroundResourceId = attributeArray.getResourceId(0, 0);
  attributeArray.recycle();

  // View for disabling the renderer.
  disableView = (CheckedTextView) inflater.inflate(
      android.R.layout.simple_list_item_single_choice, root, false);
  disableView.setBackgroundResource(selectableItemBackgroundResourceId);
  disableView.setText(R.string.selection_disabled);
  disableView.setFocusable(true);
  disableView.setOnClickListener(this);
  root.addView(disableView);

  // View for clearing the override to allow the selector to use its default selection logic.
  defaultView = (CheckedTextView) inflater.inflate(
      android.R.layout.simple_list_item_single_choice, root, false);
  defaultView.setBackgroundResource(selectableItemBackgroundResourceId);
  defaultView.setText(R.string.selection_default);
  defaultView.setFocusable(true);
  defaultView.setOnClickListener(this);
  root.addView(inflater.inflate(R.layout.list_divider, root, false));
  root.addView(defaultView);

  // Per-track views.
  boolean haveSupportedTracks = false;
  boolean haveAdaptiveTracks = false;
  trackViews = new CheckedTextView[trackGroups.length][];
  for (int groupIndex = 0; groupIndex < trackGroups.length; groupIndex++) {
    TrackGroup group = trackGroups.get(groupIndex);
    boolean groupIsAdaptive = trackGroupsAdaptive[groupIndex];
    haveAdaptiveTracks |= groupIsAdaptive;
    trackViews[groupIndex] = new CheckedTextView[group.length];
    for (int trackIndex = 0; trackIndex < group.length; trackIndex++) {
      if (trackIndex == 0) {
        root.addView(inflater.inflate(R.layout.list_divider, root, false));
      }
      int trackViewLayoutId = groupIsAdaptive ? android.R.layout.simple_list_item_multiple_choice
          : android.R.layout.simple_list_item_single_choice;
      CheckedTextView trackView = (CheckedTextView) inflater.inflate(
          trackViewLayoutId, root, false);
      trackView.setBackgroundResource(selectableItemBackgroundResourceId);
      trackView.setText(buildTrackName(group.getFormat(trackIndex)));
      if (trackInfo.getTrackFormatSupport(rendererIndex, groupIndex, trackIndex)
          == RendererCapabilities.FORMAT_HANDLED) {
        trackView.setFocusable(true);
        trackView.setTag(Pair.create(groupIndex, trackIndex));
        trackView.setOnClickListener(this);
        haveSupportedTracks = true;
      } else {
        trackView.setFocusable(false);
        trackView.setEnabled(false);
      }
      trackViews[groupIndex][trackIndex] = trackView;
      root.addView(trackView);
    }
  }

  if (!haveSupportedTracks) {
    // Indicate that the default selection will be nothing.
    defaultView.setText(R.string.selection_default_none);
  } else if (haveAdaptiveTracks) {
    // View for using random adaptation.
    enableRandomAdaptationView = (CheckedTextView) inflater.inflate(
        android.R.layout.simple_list_item_multiple_choice, root, false);
    enableRandomAdaptationView.setBackgroundResource(selectableItemBackgroundResourceId);
    enableRandomAdaptationView.setText(R.string.enable_random_adaptation);
    enableRandomAdaptationView.setOnClickListener(this);
    root.addView(inflater.inflate(R.layout.list_divider, root, false));
    root.addView(enableRandomAdaptationView);
  }

  updateViews();
  return view;
}
 

private static boolean isFormatHandled(int formatSupport) {
  return (formatSupport & RendererCapabilities.FORMAT_SUPPORT_MASK)
      == RendererCapabilities.FORMAT_HANDLED;
}
 

protected static boolean isSupported(int formatSupport, boolean allowExceedsCapabilities) {
  int maskedSupport = formatSupport & RendererCapabilities.FORMAT_SUPPORT_MASK;
  return maskedSupport == RendererCapabilities.FORMAT_HANDLED || (allowExceedsCapabilities
      && maskedSupport == RendererCapabilities.FORMAT_EXCEEDS_CAPABILITIES);
}
 

/**
 * Returns the extent to which the renderer supports adaptation between supported tracks in a
 * specified {@link TrackGroup}.
 * <p>
 * Tracks for which {@link #getTrackFormatSupport(int, int, int)} returns
 * {@link RendererCapabilities#FORMAT_HANDLED} are always considered.
 * Tracks for which {@link #getTrackFormatSupport(int, int, int)} returns
 * {@link RendererCapabilities#FORMAT_UNSUPPORTED_TYPE} or
 * {@link RendererCapabilities#FORMAT_UNSUPPORTED_SUBTYPE} are never considered.
 * Tracks for which {@link #getTrackFormatSupport(int, int, int)} returns
 * {@link RendererCapabilities#FORMAT_EXCEEDS_CAPABILITIES} are considered only if
 * {@code includeCapabilitiesExceededTracks} is set to {@code true}.
 *
 * @param rendererIndex The renderer index.
 * @param groupIndex The index of the group.
 * @param includeCapabilitiesExceededTracks True if formats that exceed the capabilities of the
 *     renderer should be included when determining support. False otherwise.
 * @return One of {@link RendererCapabilities#ADAPTIVE_SEAMLESS},
 *     {@link RendererCapabilities#ADAPTIVE_NOT_SEAMLESS} and
 *     {@link RendererCapabilities#ADAPTIVE_NOT_SUPPORTED}.
 */
public int getAdaptiveSupport(int rendererIndex, int groupIndex,
    boolean includeCapabilitiesExceededTracks) {
  int trackCount = trackGroups[rendererIndex].get(groupIndex).length;
  // Iterate over the tracks in the group, recording the indices of those to consider.
  int[] trackIndices = new int[trackCount];
  int trackIndexCount = 0;
  for (int i = 0; i < trackCount; i++) {
    int fixedSupport = getTrackFormatSupport(rendererIndex, groupIndex, i);
    if (fixedSupport == RendererCapabilities.FORMAT_HANDLED
        || (includeCapabilitiesExceededTracks
        && fixedSupport == RendererCapabilities.FORMAT_EXCEEDS_CAPABILITIES)) {
      trackIndices[trackIndexCount++] = i;
    }
  }
  trackIndices = Arrays.copyOf(trackIndices, trackIndexCount);
  return getAdaptiveSupport(rendererIndex, groupIndex, trackIndices);
}
 

@SuppressLint("InflateParams")
private View buildView(LayoutInflater inflater) {
    View view = inflater.inflate(R.layout.track_selection_dialog, null);
    ViewGroup root = (ViewGroup) view.findViewById(R.id.root);

    // View for disabling the renderer.
    disableView = (CheckedTextView) inflater.inflate(
            android.R.layout.simple_list_item_single_choice, root, false);
    disableView.setText(R.string.selection_disabled);
    disableView.setFocusable(true);
    disableView.setOnClickListener(this);
    root.addView(disableView);

    // View for clearing the override to allow the selector to use its default selection logic.
    defaultView = (CheckedTextView) inflater.inflate(
            android.R.layout.simple_list_item_single_choice, root, false);
    defaultView.setText(R.string.selection_default);
    defaultView.setFocusable(true);
    defaultView.setOnClickListener(this);
    root.addView(inflater.inflate(R.layout.list_divider_v2, root, false));
    root.addView(defaultView);

    // Per-track views.
    boolean haveSupportedTracks = false;
    boolean haveAdaptiveTracks = false;
    trackViews = new CheckedTextView[trackGroups.length][];
    for (int groupIndex = 0; groupIndex < trackGroups.length; groupIndex++) {
        TrackGroup group = trackGroups.get(groupIndex);
        boolean groupIsAdaptive = trackGroupsAdaptive[groupIndex];
        haveAdaptiveTracks |= groupIsAdaptive;
        trackViews[groupIndex] = new CheckedTextView[group.length];
        for (int trackIndex = 0; trackIndex < group.length; trackIndex++) {
            if (trackIndex == 0) {
                root.addView(inflater.inflate(R.layout.list_divider_v2, root, false));
            }
            int trackViewLayoutId = groupIsAdaptive ? android.R.layout.simple_list_item_multiple_choice
                    : android.R.layout.simple_list_item_single_choice;
            CheckedTextView trackView = (CheckedTextView) inflater.inflate(
                    trackViewLayoutId, root, false);
            trackView.setText(buildTrackName(group.getFormat(trackIndex)));
            if (trackInfo.getTrackFormatSupport(rendererIndex, groupIndex, trackIndex)
                    == RendererCapabilities.FORMAT_HANDLED) {
                trackView.setFocusable(true);
                trackView.setTag(Pair.create(groupIndex, trackIndex));
                trackView.setOnClickListener(this);
                haveSupportedTracks = true;
            } else {
                trackView.setFocusable(false);
                trackView.setEnabled(false);
            }
            trackViews[groupIndex][trackIndex] = trackView;
            root.addView(trackView);
        }
    }

    if (!haveSupportedTracks) {
        // Indicate that the default selection will be nothing.
        defaultView.setText(R.string.selection_default_none);
    } else if (haveAdaptiveTracks) {
        // View for using random adaptation.
        enableRandomAdaptationView = (CheckedTextView) inflater.inflate(
                android.R.layout.simple_list_item_multiple_choice, root, false);
        enableRandomAdaptationView.setText(R.string.enable_random_adaptation);
        enableRandomAdaptationView.setOnClickListener(this);
        root.addView(inflater.inflate(R.layout.list_divider_v2, root, false));
        root.addView(enableRandomAdaptationView);
    }

    updateViews();
    return view;
}