Java C.TRACK_TYPE_TEXT属性代码示例

/**
 * Parses an hdlr atom.
 *
 * @param hdlr The hdlr atom to decode.
 * @return The track type.
 */
private static int parseHdlr(ParsableByteArray hdlr) {
  hdlr.setPosition(Atom.FULL_HEADER_SIZE + 4);
  int trackType = hdlr.readInt();
  if (trackType == TYPE_soun) {
    return C.TRACK_TYPE_AUDIO;
  } else if (trackType == TYPE_vide) {
    return C.TRACK_TYPE_VIDEO;
  } else if (trackType == TYPE_text || trackType == TYPE_sbtl || trackType == TYPE_subt
      || trackType == TYPE_clcp) {
    return C.TRACK_TYPE_TEXT;
  } else if (trackType == TYPE_meta) {
    return C.TRACK_TYPE_METADATA;
  } else {
    return C.TRACK_TYPE_UNKNOWN;
  }
}
 

/**
 * Maps a {@link C} {@code TRACK_TYPE_*} constant to the corresponding {@link C}
 * {@code DEFAULT_*_BUFFER_SIZE} constant.
 *
 * @param trackType The track type.
 * @return The corresponding default buffer size in bytes.
 */
public static int getDefaultBufferSize(int trackType) {
  switch (trackType) {
    case C.TRACK_TYPE_DEFAULT:
      return C.DEFAULT_MUXED_BUFFER_SIZE;
    case C.TRACK_TYPE_AUDIO:
      return C.DEFAULT_AUDIO_BUFFER_SIZE;
    case C.TRACK_TYPE_VIDEO:
      return C.DEFAULT_VIDEO_BUFFER_SIZE;
    case C.TRACK_TYPE_TEXT:
      return C.DEFAULT_TEXT_BUFFER_SIZE;
    case C.TRACK_TYPE_METADATA:
      return C.DEFAULT_METADATA_BUFFER_SIZE;
    default:
      throw new IllegalStateException();
  }
}
 

/**
 * Returns the {@link C}{@code .TRACK_TYPE_*} constant that corresponds to a specified mime type.
 * {@link C#TRACK_TYPE_UNKNOWN} if the mime type is not known or the mapping cannot be
 * established.
 *
 * @param mimeType The mimeType.
 * @return The {@link C}{@code .TRACK_TYPE_*} constant that corresponds to a specified mime type.
 */
public static int getTrackType(String mimeType) {
  if (TextUtils.isEmpty(mimeType)) {
    return C.TRACK_TYPE_UNKNOWN;
  } else if (isAudio(mimeType)) {
    return C.TRACK_TYPE_AUDIO;
  } else if (isVideo(mimeType)) {
    return C.TRACK_TYPE_VIDEO;
  } else if (isText(mimeType) || APPLICATION_CEA608.equals(mimeType)
      || APPLICATION_CEA708.equals(mimeType) || APPLICATION_MP4CEA608.equals(mimeType)
      || APPLICATION_SUBRIP.equals(mimeType) || APPLICATION_TTML.equals(mimeType)
      || APPLICATION_TX3G.equals(mimeType) || APPLICATION_MP4VTT.equals(mimeType)
      || APPLICATION_RAWCC.equals(mimeType) || APPLICATION_VOBSUB.equals(mimeType)
      || APPLICATION_PGS.equals(mimeType) || APPLICATION_DVBSUBS.equals(mimeType)) {
    return C.TRACK_TYPE_TEXT;
  } else if (APPLICATION_ID3.equals(mimeType)
      || APPLICATION_EMSG.equals(mimeType)
      || APPLICATION_SCTE35.equals(mimeType)
      || APPLICATION_CAMERA_MOTION.equals(mimeType)) {
    return C.TRACK_TYPE_METADATA;
  } else {
    return C.TRACK_TYPE_UNKNOWN;
  }
}
 

private void updateButtonVisibilities() {
    debugRootView.removeAllViews();

    retryButton.setVisibility(playerNeedsSource ? View.VISIBLE : View.GONE);
    debugRootView.addView(retryButton);

    if (player == null) {
        return;
    }

    MappedTrackInfo mappedTrackInfo = trackSelector.getCurrentMappedTrackInfo();
    if (mappedTrackInfo == null) {
        return;
    }

    for (int i = 0; i < mappedTrackInfo.length; i++) {
        TrackGroupArray trackGroups = mappedTrackInfo.getTrackGroups(i);
        if (trackGroups.length != 0) {
            Button button = new Button(this);
            int label;
            switch (player.getRendererType(i)) {
                case C.TRACK_TYPE_AUDIO:
                    label = R.string.audio;
                    break;
                case C.TRACK_TYPE_VIDEO:
                    label = R.string.video;
                    break;
                case C.TRACK_TYPE_TEXT:
                    label = R.string.text;
                    break;
                default:
                    continue;
            }
            button.setText(label);
            button.setTag(i);
            button.setOnClickListener(this);
            debugRootView.addView(button, debugRootView.getChildCount() - 1);
        }
    }
}
 

@Override
protected TrackSelection[] selectTracks(RendererCapabilities[] rendererCapabilities,
    TrackGroupArray[] rendererTrackGroupArrays, int[][][] rendererFormatSupports)
    throws ExoPlaybackException {
  // Make a track selection for each renderer.
  int rendererCount = rendererCapabilities.length;
  TrackSelection[] rendererTrackSelections = new TrackSelection[rendererCount];
  Parameters params = paramsReference.get();
  boolean videoTrackAndRendererPresent = false;

  for (int i = 0; i < rendererCount; i++) {
    if (C.TRACK_TYPE_VIDEO == rendererCapabilities[i].getTrackType()) {
      rendererTrackSelections[i] = selectVideoTrack(rendererCapabilities[i],
          rendererTrackGroupArrays[i], rendererFormatSupports[i], params.maxVideoWidth,
          params.maxVideoHeight, params.maxVideoBitrate, params.allowNonSeamlessAdaptiveness,
          params.allowMixedMimeAdaptiveness, params.viewportWidth, params.viewportHeight,
          params.orientationMayChange, adaptiveTrackSelectionFactory,
          params.exceedVideoConstraintsIfNecessary, params.exceedRendererCapabilitiesIfNecessary);
      videoTrackAndRendererPresent |= rendererTrackGroupArrays[i].length > 0;
    }
  }

  for (int i = 0; i < rendererCount; i++) {
    switch (rendererCapabilities[i].getTrackType()) {
      case C.TRACK_TYPE_VIDEO:
        // Already done. Do nothing.
        break;
      case C.TRACK_TYPE_AUDIO:
        rendererTrackSelections[i] = selectAudioTrack(rendererTrackGroupArrays[i],
            rendererFormatSupports[i], params.preferredAudioLanguage,
            params.exceedRendererCapabilitiesIfNecessary, params.allowMixedMimeAdaptiveness,
            videoTrackAndRendererPresent ? null : adaptiveTrackSelectionFactory);
        break;
      case C.TRACK_TYPE_TEXT:
        rendererTrackSelections[i] = selectTextTrack(rendererTrackGroupArrays[i],
            rendererFormatSupports[i], params.preferredTextLanguage,
            params.preferredAudioLanguage, params.exceedRendererCapabilitiesIfNecessary);
        break;
      default:
        rendererTrackSelections[i] = selectOtherTrack(rendererCapabilities[i].getTrackType(),
            rendererTrackGroupArrays[i], rendererFormatSupports[i],
            params.exceedRendererCapabilitiesIfNecessary);
        break;
    }
  }
  return rendererTrackSelections;
}
 

/**
 * @param output The output.
 * @param outputLooper The looper associated with the thread on which the output should be
 *     called. If the output makes use of standard Android UI components, then this should
 *     normally be the looper associated with the application's main thread, which can be obtained
 *     using {@link android.app.Activity#getMainLooper()}. Null may be passed if the output
 *     should be called directly on the player's internal rendering thread.
 * @param decoderFactory A factory from which to obtain {@link SubtitleDecoder} instances.
 */
public TextRenderer(Output output, Looper outputLooper, SubtitleDecoderFactory decoderFactory) {
  super(C.TRACK_TYPE_TEXT);
  this.output = Assertions.checkNotNull(output);
  this.outputHandler = outputLooper == null ? null : new Handler(outputLooper, this);
  this.decoderFactory = decoderFactory;
  formatHolder = new FormatHolder();
}