Java C类代码示例

import com.google.android.exoplayer.C; //导入依赖的package包/类
@Override
public int readData(int track, long positionUs, MediaFormatHolder formatHolder,
  SampleHolder sampleHolder) {
    Assertions.checkState(mPrepared);
    Assertions.checkState(mTrackStates.get(track) != TRACK_STATE_DISABLED);
    if (mPendingDiscontinuities.get(track)) {
        return NOTHING_READ;
    }
    if (mTrackStates.get(track) != TRACK_STATE_FORMAT_SENT) {
        mSampleExtractor.getTrackMediaFormat(track, formatHolder);
        mTrackStates.set(track, TRACK_STATE_FORMAT_SENT);
        return FORMAT_READ;
    }

    mPendingSeekPositionUs = C.UNKNOWN_TIME_US;
    return mSampleExtractor.readSample(track, sampleHolder);
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
public void testParsesValidMp4File() throws Exception {
  TestUtil.consumeTestData(extractor,
      getTestInputData(true /* includeStss */, false /* mp4vFormat */));

  // The seek map is correct.
  assertSeekMap(extractorOutput.seekMap, true);

  // The video and audio formats are set correctly.
  assertEquals(2, extractorOutput.trackOutputs.size());
  MediaFormat videoFormat = extractorOutput.trackOutputs.get(0).format;
  MediaFormat audioFormat = extractorOutput.trackOutputs.get(1).format;
  assertEquals(MimeTypes.VIDEO_H264, videoFormat.mimeType);
  assertEquals(VIDEO_WIDTH, videoFormat.width);
  assertEquals(VIDEO_HEIGHT, videoFormat.height);
  assertEquals(MimeTypes.AUDIO_AAC, audioFormat.mimeType);

  // The timestamps and sizes are set correctly.
  FakeTrackOutput videoTrackOutput = extractorOutput.trackOutputs.get(0);
  videoTrackOutput.assertSampleCount(SAMPLE_TIMESTAMPS.length);
  for (int i = 0; i < SAMPLE_TIMESTAMPS.length; i++) {
    byte[] sampleData = getOutputSampleData(i, true);
    int sampleFlags = SAMPLE_IS_SYNC[i] ? C.SAMPLE_FLAG_SYNC : 0;
    long sampleTimestampUs = getVideoTimestampUs(SAMPLE_TIMESTAMPS[i]);
    videoTrackOutput.assertSample(i, sampleData, sampleTimestampUs, sampleFlags, null);
  }
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
/**
 * Reads up to {@code length} bytes of data and stores them into {@code buffer}, starting at
 * index {@code offset}.
 * <p>
 * This method blocks until at least one byte of data can be read, the end of the opened range is
 * detected, or an exception is thrown.
 *
 * @param buffer The buffer into which the read data should be stored.
 * @param offset The start offset into {@code buffer} at which data should be written.
 * @param readLength The maximum number of bytes to read.
 * @return The number of bytes read, or {@link C#RESULT_END_OF_INPUT} if the end of the opened
 *     range is reached.
 * @throws IOException If an error occurs reading from the source.
 */
private int readInternal(byte[] buffer, int offset, int readLength) throws IOException {
  readLength = bytesToRead == C.LENGTH_UNBOUNDED ? readLength
      : (int) Math.min(readLength, bytesToRead - bytesRead);
  if (readLength == 0) {
    // We've read all of the requested data.
    return C.RESULT_END_OF_INPUT;
  }

  int read = inputStream.read(buffer, offset, readLength);
  if (read == -1) {
    if (bytesToRead != C.LENGTH_UNBOUNDED && bytesToRead != bytesRead) {
      // The server closed the connection having not sent sufficient data.
      throw new EOFException();
    }
    return C.RESULT_END_OF_INPUT;
  }

  bytesRead += read;
  if (listener != null) {
    listener.onBytesTransferred(read);
  }
  return read;
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
/**
 * Appends data to the rolling buffer.
 *
 * @param dataSource The source from which to read.
 * @param length The maximum length of the read.
 * @param allowEndOfInput True if encountering the end of the input having appended no data is
 *     allowed, and should result in {@link C#RESULT_END_OF_INPUT} being returned. False if it
 *     should be considered an error, causing an {@link EOFException} to be thrown.
 * @return The number of bytes appended, or {@link C#RESULT_END_OF_INPUT} if the input has ended.
 * @throws IOException If an error occurs reading from the source.
 */
public int appendData(DataSource dataSource, int length, boolean allowEndOfInput)
    throws IOException {
  length = prepareForAppend(length);
  int bytesAppended = dataSource.read(lastAllocation.data,
      lastAllocation.translateOffset(lastAllocationOffset), length);
  if (bytesAppended == C.RESULT_END_OF_INPUT) {
    if (allowEndOfInput) {
      return C.RESULT_END_OF_INPUT;
    }
    throw new EOFException();
  }
  lastAllocationOffset += bytesAppended;
  totalBytesWritten += bytesAppended;
  return bytesAppended;
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
public StreamElement(String baseUri, String chunkTemplate, int type, String subType,
    long timescale, String name, int qualityLevels, int maxWidth, int maxHeight,
    int displayWidth, int displayHeight, String language, TrackElement[] tracks,
    List<Long> chunkStartTimes, long lastChunkDuration) {
  this.baseUri = baseUri;
  this.chunkTemplate = chunkTemplate;
  this.type = type;
  this.subType = subType;
  this.timescale = timescale;
  this.name = name;
  this.qualityLevels = qualityLevels;
  this.maxWidth = maxWidth;
  this.maxHeight = maxHeight;
  this.displayWidth = displayWidth;
  this.displayHeight = displayHeight;
  this.language = language;
  this.tracks = tracks;
  this.chunkCount = chunkStartTimes.size();
  this.chunkStartTimes = chunkStartTimes;
  lastChunkDurationUs =
      Util.scaleLargeTimestamp(lastChunkDuration, C.MICROS_PER_SECOND, timescale);
  chunkStartTimesUs =
      Util.scaleLargeTimestamps(chunkStartTimes, C.MICROS_PER_SECOND, timescale);
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
@Override
public void consume(ParsableByteArray seiBuffer, long pesTimeUs, boolean startOfPacket) {
  int b;
  while (seiBuffer.bytesLeft() > 1 /* last byte will be rbsp_trailing_bits */) {
    // Parse payload type.
    int payloadType = 0;
    do {
      b = seiBuffer.readUnsignedByte();
      payloadType += b;
    } while (b == 0xFF);
    // Parse payload size.
    int payloadSize = 0;
    do {
      b = seiBuffer.readUnsignedByte();
      payloadSize += b;
    } while (b == 0xFF);
    // Process the payload. We only support EIA-608 payloads currently.
    if (Eia608Parser.isSeiMessageEia608(payloadType, payloadSize, seiBuffer)) {
      output.sampleData(seiBuffer, payloadSize);
      output.sampleMetadata(pesTimeUs, C.SAMPLE_FLAG_SYNC, payloadSize, 0, null);
    } else {
      seiBuffer.skipBytes(payloadSize);
    }
  }
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
@Override
public int read(byte[] target, int offset, int length) throws IOException, InterruptedException {
  if (Thread.interrupted()) {
    throw new InterruptedException();
  }
  int peekBytes = Math.min(peekBufferLength, length);
  System.arraycopy(peekBuffer, 0, target, offset, peekBytes);
  offset += peekBytes;
  length -= peekBytes;
  int bytesRead = length != 0 ? dataSource.read(target, offset, length) : 0;
  if (bytesRead == C.RESULT_END_OF_INPUT) {
    return C.RESULT_END_OF_INPUT;
  }
  updatePeekBuffer(peekBytes);
  bytesRead += peekBytes;
  position += bytesRead;
  return bytesRead;
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
@Override
public boolean readFully(byte[] target, int offset, int length, boolean allowEndOfInput)
    throws IOException, InterruptedException {
  int peekBytes = Math.min(peekBufferLength, length);
  System.arraycopy(peekBuffer, 0, target, offset, peekBytes);
  offset += peekBytes;
  int remaining = length - peekBytes;
  while (remaining > 0) {
    if (Thread.interrupted()) {
      throw new InterruptedException();
    }
    int bytesRead = dataSource.read(target, offset, remaining);
    if (bytesRead == C.RESULT_END_OF_INPUT) {
      if (allowEndOfInput && remaining == length) {
        return false;
      }
      throw new EOFException();
    }
    offset += bytesRead;
    remaining -= bytesRead;
  }
  updatePeekBuffer(peekBytes);
  position += length;
  return true;
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
@Override
public void skipFully(int length) throws IOException, InterruptedException {
  int peekBytes = Math.min(peekBufferLength, length);
  int remaining = length - peekBytes;
  while (remaining > 0) {
    if (Thread.interrupted()) {
      throw new InterruptedException();
    }
    int bytesRead = dataSource.read(SCRATCH_SPACE, 0, Math.min(SCRATCH_SPACE.length, remaining));
    if (bytesRead == C.RESULT_END_OF_INPUT) {
      throw new EOFException();
    }
    remaining -= bytesRead;
  }
  updatePeekBuffer(peekBytes);
  position += length;
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
@Override
public long open(DataSpec dataSpec) throws FileDataSourceException {
  try {
    uriString = dataSpec.uri.toString();
    file = new RandomAccessFile(dataSpec.uri.getPath(), "r");
    file.seek(dataSpec.position);
    bytesRemaining = dataSpec.length == C.LENGTH_UNBOUNDED ? 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();
  }

  return bytesRemaining;
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
@Override
public void fixedTrack(MediaPresentationDescription manifest, int periodIndex,
    int adaptationSetIndex, int representationIndex) {
  List<AdaptationSet> adaptationSets = manifest.getPeriod(periodIndex).adaptationSets;
  AdaptationSet adaptationSet = adaptationSets.get(adaptationSetIndex);
  Format representationFormat = adaptationSet.representations.get(representationIndex).format;
  String mediaMimeType = getMediaMimeType(representationFormat);
  if (mediaMimeType == null) {
    Log.w(TAG, "Skipped track " + representationFormat.id + " (unknown media mime type)");
    return;
  }
  MediaFormat trackFormat = getTrackFormat(adaptationSet.type, representationFormat,
      mediaMimeType, manifest.dynamic ? C.UNKNOWN_TIME_US : manifest.duration * 1000);
  if (trackFormat == null) {
    Log.w(TAG, "Skipped track " + representationFormat.id + " (unknown media format)");
    return;
  }
  tracks.add(new ExposedTrack(trackFormat, adaptationSetIndex, representationFormat));
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
public void consume(long pesTimeUs, ParsableByteArray seiBuffer) {
  int b;
  while (seiBuffer.bytesLeft() > 1 /* last byte will be rbsp_trailing_bits */) {
    // Parse payload type.
    int payloadType = 0;
    do {
      b = seiBuffer.readUnsignedByte();
      payloadType += b;
    } while (b == 0xFF);
    // Parse payload size.
    int payloadSize = 0;
    do {
      b = seiBuffer.readUnsignedByte();
      payloadSize += b;
    } while (b == 0xFF);
    // Process the payload.
    if (Eia608Parser.isSeiMessageEia608(payloadType, payloadSize, seiBuffer)) {
      output.sampleData(seiBuffer, payloadSize);
      output.sampleMetadata(pesTimeUs, C.SAMPLE_FLAG_SYNC, payloadSize, 0, null);
    } else {
      seiBuffer.skipBytes(payloadSize);
    }
  }
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
@Override
public int read(byte[] buffer, int offset, int max) throws IOException {
  try {
    int bytesRead = currentDataSource.read(buffer, offset, max);
    if (bytesRead >= 0) {
      if (currentDataSource == cacheReadDataSource) {
        totalCachedBytesRead += bytesRead;
      }
      readPosition += bytesRead;
      if (bytesRemaining != C.LENGTH_UNBOUNDED) {
        bytesRemaining -= bytesRead;
      }
    } else {
      closeCurrentSource();
      if (bytesRemaining > 0 && bytesRemaining != C.LENGTH_UNBOUNDED) {
        openNextSource();
        return read(buffer, offset, max);
      }
    }
    return bytesRead;
  } catch (IOException e) {
    handleBeforeThrow(e);
    throw e;
  }
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
/**
 * Reads up to {@code length} bytes of data and stores them into {@code buffer}, starting at
 * index {@code offset}.
 * <p>
 * This method blocks until at least one byte of data can be read, the end of the opened range is
 * detected, or an exception is thrown.
 *
 * @param buffer The buffer into which the read data should be stored.
 * @param offset The start offset into {@code buffer} at which data should be written.
 * @param readLength The maximum number of bytes to read.
 * @return The number of bytes read, or {@link C#RESULT_END_OF_INPUT} if the end of the opened
 *     range is reached.
 * @throws IOException If an error occurs reading from the source.
 */
private int readInternal(byte[] buffer, int offset, int readLength) throws IOException {
  readLength = bytesToRead == C.LENGTH_UNBOUNDED ? readLength
      : (int) Math.min(readLength, bytesToRead - bytesRead);
  if (readLength == 0) {
    // We've read all of the requested data.
    return C.RESULT_END_OF_INPUT;
  }

  int read = responseByteStream.read(buffer, offset, readLength);
  if (read == -1) {
    if (bytesToRead != C.LENGTH_UNBOUNDED && bytesToRead != bytesRead) {
      // The server closed the connection having not sent sufficient data.
      throw new EOFException();
    }
    return C.RESULT_END_OF_INPUT;
  }

  bytesRead += read;
  if (listener != null) {
    listener.onBytesTransferred(read);
  }
  return read;
}
 

import com.google.android.exoplayer.C; //导入依赖的package包/类
/**
 * Reads up to {@code length} bytes of data and stores them into {@code buffer}, starting at index
 * {@code offset}.
 *
 * <p>This method blocks until at least one byte of data can be read, the end of the opened range
 * is detected, or an exception is thrown.
 *
 * @param buffer     The buffer into which the read data should be stored.
 * @param offset     The start offset into {@code buffer} at which data should be written.
 * @param readLength The maximum number of bytes to read.
 * @return The number of bytes read, or {@link C#RESULT_END_OF_INPUT} if the end of the opened
 *     range is reached.
 * @throws IOException If an error occurs reading from the source.
 */
private int readInternal(byte[] buffer, int offset, int readLength) throws IOException {
  readLength = bytesToRead == C.LENGTH_UNBOUNDED ? readLength
      : (int) Math.min(readLength, bytesToRead - bytesRead);
  if (readLength == 0) {
    // We've read all of the requested data.
    return C.RESULT_END_OF_INPUT;
  }

  int read = responseByteStream.read(buffer, offset, readLength);
  if (read == -1) {
    if (bytesToRead != C.LENGTH_UNBOUNDED && bytesToRead != bytesRead) {
      // The server closed the connection having not sent sufficient data.
      throw new EOFException();
    }
    return C.RESULT_END_OF_INPUT;
  }

  bytesRead += read;
  if (listener != null) {
    listener.onBytesTransferred(read);
  }
  return read;
}