Java C类代码示例

import com.google.android.exoplayer2.C; //导入依赖的package包/类
private MediaSource buildMediaSource(Uri uri, String overrideExtension) {
    int type = Util.inferContentType(!TextUtils.isEmpty(overrideExtension) ? "." + overrideExtension
            : uri.getLastPathSegment());
    switch (type) {
        case C.TYPE_SS:
            return new SsMediaSource(uri, buildDataSourceFactory(false),
                    new DefaultSsChunkSource.Factory(mediaDataSourceFactory), mainHandler, null);
        case C.TYPE_DASH:
            return new DashMediaSource(uri, buildDataSourceFactory(false),
                    new DefaultDashChunkSource.Factory(mediaDataSourceFactory), mainHandler, null);
        case C.TYPE_HLS:
            return new HlsMediaSource(uri, mediaDataSourceFactory, mainHandler, null);
        case C.TYPE_OTHER:
            return new ExtractorMediaSource(uri, mediaDataSourceFactory, new DefaultExtractorsFactory(),
                    mainHandler, null);
        default: {
            throw new IllegalStateException("Unsupported type: " + type);
        }
    }
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
@Override
public VideoProgressUpdate getContentProgress() {
  if (player == null) {
    return lastContentProgress;
  } else if (pendingContentPositionMs != C.TIME_UNSET) {
    sentPendingContentPositionMs = true;
    return new VideoProgressUpdate(pendingContentPositionMs, contentDurationMs);
  } else if (fakeContentProgressElapsedRealtimeMs != C.TIME_UNSET) {
    long elapsedSinceEndMs = SystemClock.elapsedRealtime() - fakeContentProgressElapsedRealtimeMs;
    long fakePositionMs = fakeContentProgressOffsetMs + elapsedSinceEndMs;
    return new VideoProgressUpdate(fakePositionMs, contentDurationMs);
  } else if (playingAd || contentDurationMs == C.TIME_UNSET) {
    return VideoProgressUpdate.VIDEO_TIME_NOT_READY;
  } else {
    return new VideoProgressUpdate(player.getCurrentPosition(), contentDurationMs);
  }
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
@Override
public int getIndexOfPeriod(Object uid) {
  if (!(uid instanceof Pair)) {
    return C.INDEX_UNSET;
  }
  Pair<?, ?> sourceIndexAndPeriodId = (Pair<?, ?>) uid;
  if (!(sourceIndexAndPeriodId.first instanceof Integer)) {
    return C.INDEX_UNSET;
  }
  int sourceIndex = (Integer) sourceIndexAndPeriodId.first;
  Object periodId = sourceIndexAndPeriodId.second;
  if (sourceIndex < 0 || sourceIndex >= timelines.length) {
    return C.INDEX_UNSET;
  }
  int periodIndexInSource = timelines[sourceIndex].getIndexOfPeriod(periodId);
  return periodIndexInSource == C.INDEX_UNSET ? C.INDEX_UNSET
      : getFirstPeriodIndexInSource(sourceIndex) + periodIndexInSource;
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
/**
 * 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;
  }
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
@Override
public long open(DataSpec dataSpec) throws FileDataSourceException {
    try {
        uri = dataSpec.uri;
        file = new RandomAccessFile(dataSpec.uri.getPath(), "r");
        boolean ass = isEncrypted(file);
        if (ass) {
            file.seek(dataSpec.position + length);
        }
        bytesRemaining = dataSpec.length == C.LENGTH_UNSET ? file.length() - dataSpec.position
                : dataSpec.length;
        if (bytesRemaining < 0) {
            throw new EOFException();
        }

    } catch (IOException e) {
        throw new FileDataSourceException(e);
    }

    opened = true;
    if (listener != null) {
        listener.onTransferStart(this, dataSpec);
    }

    return bytesRemaining;
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
@Override
public int readData(FormatHolder formatHolder, DecoderInputBuffer buffer,
    boolean requireFormat) {
  if (pendingDiscontinuity) {
    return C.RESULT_NOTHING_READ;
  }
  if (sentEos) {
    buffer.setFlags(C.BUFFER_FLAG_END_OF_STREAM);
    return C.RESULT_BUFFER_READ;
  }
  int result = stream.readData(formatHolder, buffer, requireFormat);
  // TODO: Clear gapless playback metadata if a format was read (if applicable).
  if (endUs != C.TIME_END_OF_SOURCE && ((result == C.RESULT_BUFFER_READ
      && buffer.timeUs >= endUs) || (result == C.RESULT_NOTHING_READ
      && mediaPeriod.getBufferedPositionUs() == C.TIME_END_OF_SOURCE))) {
    buffer.clear();
    buffer.setFlags(C.BUFFER_FLAG_END_OF_STREAM);
    sentEos = true;
    return C.RESULT_BUFFER_READ;
  }
  if (result == C.RESULT_BUFFER_READ && !buffer.isEndOfStream()) {
    buffer.timeUs -= startUs;
  }
  return result;
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
/**
 * Splits an array of NAL units.
 * <p>
 * If the input consists of NAL start code delimited units, then the returned array consists of
 * the split NAL units, each of which is still prefixed with the NAL start code. For any other
 * input, null is returned.
 *
 * @param data An array of data.
 * @return The individual NAL units, or null if the input did not consist of NAL start code
 *     delimited units.
 */
public static byte[][] splitNalUnits(byte[] data) {
  if (!isNalStartCode(data, 0)) {
    // data does not consist of NAL start code delimited units.
    return null;
  }
  List<Integer> starts = new ArrayList<>();
  int nalUnitIndex = 0;
  do {
    starts.add(nalUnitIndex);
    nalUnitIndex = findNalStartCode(data, nalUnitIndex + NAL_START_CODE.length);
  } while (nalUnitIndex != C.INDEX_UNSET);
  byte[][] split = new byte[starts.size()][];
  for (int i = 0; i < starts.size(); i++) {
    int startIndex = starts.get(i);
    int endIndex = i < starts.size() - 1 ? starts.get(i + 1) : data.length;
    byte[] nal = new byte[endIndex - startIndex];
    System.arraycopy(data, startIndex, nal, 0, nal.length);
    split[i] = nal;
  }
  return split;
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
/**
 * @param playlistTracker The {@link HlsPlaylistTracker} from which to obtain media playlists.
 * @param variants The available variants.
 * @param dataSourceFactory An {@link HlsDataSourceFactory} to create {@link DataSource}s for the
 *     chunks.
 * @param timestampAdjusterProvider A provider of {@link TimestampAdjuster} instances. If
 *     multiple {@link HlsChunkSource}s are used for a single playback, they should all share the
 *     same provider.
 * @param muxedCaptionFormats List of muxed caption {@link Format}s. Null if no closed caption
 *     information is available in the master playlist.
 */
public HlsChunkSource(HlsPlaylistTracker playlistTracker, HlsUrl[] variants,
    HlsDataSourceFactory dataSourceFactory, TimestampAdjusterProvider timestampAdjusterProvider,
    List<Format> muxedCaptionFormats) {
  this.playlistTracker = playlistTracker;
  this.variants = variants;
  this.timestampAdjusterProvider = timestampAdjusterProvider;
  this.muxedCaptionFormats = muxedCaptionFormats;
  Format[] variantFormats = new Format[variants.length];
  int[] initialTrackSelection = new int[variants.length];
  for (int i = 0; i < variants.length; i++) {
    variantFormats[i] = variants[i].format;
    initialTrackSelection[i] = i;
  }
  mediaDataSource = dataSourceFactory.createDataSource(C.DATA_TYPE_MEDIA);
  encryptionDataSource = dataSourceFactory.createDataSource(C.DATA_TYPE_DRM);
  trackGroup = new TrackGroup(variantFormats);
  trackSelection = new InitializationTrackSelection(trackGroup, initialTrackSelection);
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
public long getBufferedPositionUs() {
  if (loadingFinished) {
    return C.TIME_END_OF_SOURCE;
  } else if (isPendingReset()) {
    return pendingResetPositionUs;
  } else {
    long bufferedPositionUs = lastSeekPositionUs;
    HlsMediaChunk lastMediaChunk = mediaChunks.getLast();
    HlsMediaChunk lastCompletedMediaChunk = lastMediaChunk.isLoadCompleted() ? lastMediaChunk
        : mediaChunks.size() > 1 ? mediaChunks.get(mediaChunks.size() - 2) : null;
    if (lastCompletedMediaChunk != null) {
      bufferedPositionUs = Math.max(bufferedPositionUs, lastCompletedMediaChunk.endTimeUs);
    }
    int sampleQueueCount = sampleQueues.size();
    for (int i = 0; i < sampleQueueCount; i++) {
      bufferedPositionUs = Math.max(bufferedPositionUs,
          sampleQueues.valueAt(i).getLargestQueuedTimestampUs());
    }
    return bufferedPositionUs;
  }
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
@Override
public Window getWindow(int windowIndex, Window window, boolean setIds,
    long defaultPositionProjectionUs) {
  Assertions.checkIndex(windowIndex, 0, 1);
  Object id = setIds ? ID : null;
  long windowDefaultStartPositionUs = this.windowDefaultStartPositionUs;
  if (isDynamic) {
    windowDefaultStartPositionUs += defaultPositionProjectionUs;
    if (windowDefaultStartPositionUs > windowDurationUs) {
      // The projection takes us beyond the end of the live window.
      windowDefaultStartPositionUs = C.TIME_UNSET;
    }
  }
  return window.set(id, C.TIME_UNSET, C.TIME_UNSET, isSeekable, isDynamic,
      windowDefaultStartPositionUs, windowDurationUs, 0, 0, windowPositionInPeriodUs);
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
private void configureRetry(ExtractingLoadable loadable) {
  if (length != C.LENGTH_UNSET
      || (seekMap != null && seekMap.getDurationUs() != C.TIME_UNSET)) {
    // We're playing an on-demand stream. Resume the current loadable, which will
    // request data starting from the point it left off.
  } else {
    // We're playing a stream of unknown length and duration. Assume it's live, and
    // therefore that the data at the uri is a continuously shifting window of the latest
    // available media. For this case there's no way to continue loading from where a
    // previous load finished, so it's necessary to load from the start whenever commencing
    // a new load.
    lastSeekPositionUs = 0;
    notifyReset = prepared;
    int trackCount = sampleQueues.size();
    for (int i = 0; i < trackCount; i++) {
      sampleQueues.valueAt(i).reset(!prepared || trackEnabledStates[i]);
    }
    loadable.setLoadPosition(0, 0);
  }
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
/**
 * Returns the index of the track that contains the earliest current sample, or
 * {@link C#INDEX_UNSET} if no samples remain.
 */
private int getTrackIndexOfEarliestCurrentSample() {
  int earliestSampleTrackIndex = C.INDEX_UNSET;
  long earliestSampleOffset = Long.MAX_VALUE;
  for (int trackIndex = 0; trackIndex < tracks.length; trackIndex++) {
    Mp4Track track = tracks[trackIndex];
    int sampleIndex = track.sampleIndex;
    if (sampleIndex == track.sampleTable.sampleCount) {
      continue;
    }

    long trackSampleOffset = track.sampleTable.offsets[sampleIndex];
    if (trackSampleOffset < earliestSampleOffset) {
      earliestSampleOffset = trackSampleOffset;
      earliestSampleTrackIndex = trackIndex;
    }
  }

  return earliestSampleTrackIndex;
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
/**
 * update the resume position of the main movice
 *
 * @param controller
 */
public static void updateMovieResumePosition(PlayerUIController controller) {

    if (controller == null) {
        return;
    }

    SimpleExoPlayer moviePlayer = controller.getContentPlayer();

    if (moviePlayer != null && moviePlayer.getPlaybackState() != ExoPlayer.STATE_IDLE) {
        int resumeWindow = moviePlayer.getCurrentWindowIndex();
        long resumePosition = moviePlayer.isCurrentWindowSeekable() ? Math.max(0, moviePlayer.getCurrentPosition())
                : C.TIME_UNSET;
        controller.setMovieResumeInfo(resumeWindow, resumePosition);
    }
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
@Override
public long getPosition(long timeUs) {
  long earliestSamplePosition = Long.MAX_VALUE;
  for (Mp4Track track : tracks) {
    TrackSampleTable sampleTable = track.sampleTable;
    int sampleIndex = sampleTable.getIndexOfEarlierOrEqualSynchronizationSample(timeUs);
    if (sampleIndex == C.INDEX_UNSET) {
      // Handle the case where the requested time is before the first synchronization sample.
      sampleIndex = sampleTable.getIndexOfLaterOrEqualSynchronizationSample(timeUs);
    }
    long offset = sampleTable.offsets[sampleIndex];
    if (offset < earliestSamplePosition) {
      earliestSamplePosition = offset;
    }
  }
  return earliestSamplePosition;
}
 

import com.google.android.exoplayer2.C; //导入依赖的package包/类
/**
 * @param flags Flags that control the extractor's behavior.
 * @param timestampAdjuster Adjusts sample timestamps. May be null if no adjustment is needed.
 * @param sideloadedTrack Sideloaded track information, in the case that the extractor
 *     will not receive a moov box in the input data.
 */
public FragmentedMp4Extractor(@Flags int flags, TimestampAdjuster timestampAdjuster,
    Track sideloadedTrack) {
  this.flags = flags | (sideloadedTrack != null ? FLAG_SIDELOADED : 0);
  this.timestampAdjuster = timestampAdjuster;
  this.sideloadedTrack = sideloadedTrack;
  atomHeader = new ParsableByteArray(Atom.LONG_HEADER_SIZE);
  nalStartCode = new ParsableByteArray(NalUnitUtil.NAL_START_CODE);
  nalPrefix = new ParsableByteArray(5);
  nalBuffer = new ParsableByteArray();
  encryptionSignalByte = new ParsableByteArray(1);
  extendedTypeScratch = new byte[16];
  containerAtoms = new Stack<>();
  pendingMetadataSampleInfos = new LinkedList<>();
  trackBundles = new SparseArray<>();
  durationUs = C.TIME_UNSET;
  segmentIndexEarliestPresentationTimeUs = C.TIME_UNSET;
  enterReadingAtomHeaderState();
}