Java C.RESULT_END_OF_INPUT属性代码示例

/**
 * 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;
}
 

/**
 * 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;
}
 

@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;
}
 

/**
 * 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;
}
 

@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;
}
 

@Override
public void peekFully(byte[] target, int offset, int length)
    throws IOException, InterruptedException {
  ensureSpaceForPeek(length);
  int peekBytes = Math.min(peekBufferLength - peekBufferPosition, length);
  System.arraycopy(peekBuffer, peekBufferPosition, target, offset, peekBytes);
  offset += peekBytes;
  int fillBytes = length - peekBytes;
  int remaining = fillBytes;
  int writePosition = peekBufferLength;
  while (remaining > 0) {
    if (Thread.interrupted()) {
      throw new InterruptedException();
    }
    int bytesRead = dataSource.read(peekBuffer, writePosition, remaining);
    if (bytesRead == C.RESULT_END_OF_INPUT) {
      throw new EOFException();
    }
    System.arraycopy(peekBuffer, writePosition, target, offset, bytesRead);
    remaining -= bytesRead;
    writePosition += bytesRead;
    offset += bytesRead;
  }
  peekBufferPosition += length;
  peekBufferLength += fillBytes;
}
 

/**
 * 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;
}
 

@SuppressWarnings("NonAtomicVolatileUpdate")
@Override
public void load() throws IOException, InterruptedException {
  DataSpec loadDataSpec = Util.getRemainderDataSpec(dataSpec, bytesLoaded);
  try {
    // Create and open the input.
    dataSource.open(loadDataSpec);
    // Load the sample data.
    int result = 0;
    while (result != C.RESULT_END_OF_INPUT) {
      bytesLoaded += result;
      result = getOutput().sampleData(dataSource, Integer.MAX_VALUE, true);
    }
    int sampleSize = bytesLoaded;
    getOutput().sampleMetadata(startTimeUs, C.SAMPLE_FLAG_SYNC, sampleSize, 0, null);
  } finally {
    dataSource.close();
  }
}
 

@Override
public int read(ExtractorInput input, PositionHolder seekPosition)
    throws IOException, InterruptedException {
  int currentFileSize = (int) input.getLength();

  // Increase the size of sampleData if necessary.
  if (sampleSize == sampleData.length) {
    sampleData = Arrays.copyOf(sampleData,
        (currentFileSize != C.LENGTH_UNBOUNDED ? currentFileSize : sampleData.length) * 3 / 2);
  }

  // Consume to the input.
  int bytesRead = input.read(sampleData, sampleSize, sampleData.length - sampleSize);
  if (bytesRead != C.RESULT_END_OF_INPUT) {
    sampleSize += bytesRead;
    if (currentFileSize == C.LENGTH_UNBOUNDED || sampleSize != currentFileSize) {
      return Extractor.RESULT_CONTINUE;
    }
  }

  // We've reached the end of the input, which corresponds to the end of the current file.
  processSample();
  return Extractor.RESULT_END_OF_INPUT;
}
 

@Override
public boolean advancePeekPosition(int length, boolean allowEndOfInput)
    throws IOException, InterruptedException {
  ensureSpaceForPeek(length);
  int bytesPeeked = Math.min(peekBufferLength - peekBufferPosition, length);
  peekBufferLength += length - bytesPeeked;
  while (bytesPeeked < length) {
    bytesPeeked = readFromDataSource(peekBuffer, peekBufferPosition, length, bytesPeeked,
        allowEndOfInput);
    if (bytesPeeked == C.RESULT_END_OF_INPUT) {
      return false;
    }
  }
  peekBufferPosition += length;
  return true;
}
 

private int readSample(ExtractorInput extractorInput) throws IOException, InterruptedException {
  if (sampleBytesRemaining == 0) {
    long headerPosition = maybeResynchronize(extractorInput);
    if (headerPosition == RESULT_END_OF_INPUT) {
      return RESULT_END_OF_INPUT;
    }
    if (basisTimeUs == -1) {
      basisTimeUs = seeker.getTimeUs(getPosition(extractorInput, inputBuffer));
    }
    sampleBytesRemaining = synchronizedHeader.frameSize;
  }

  long timeUs = basisTimeUs + (samplesRead * 1000000L / synchronizedHeader.sampleRate);

  // Start by draining any buffered bytes, then read directly from the extractor input.
  sampleBytesRemaining -= inputBuffer.drainToOutput(trackOutput, sampleBytesRemaining);
  if (sampleBytesRemaining > 0) {
    inputBuffer.mark();
    int bytesAppended = trackOutput.sampleData(extractorInput, sampleBytesRemaining, true);
    if (bytesAppended == C.RESULT_END_OF_INPUT) {
      return RESULT_END_OF_INPUT;
    }
    sampleBytesRemaining -= bytesAppended;
    // Return if we still need more data.
    if (sampleBytesRemaining > 0) {
      return RESULT_CONTINUE;
    }
  }

  trackOutput.sampleMetadata(timeUs, C.SAMPLE_FLAG_SYNC, synchronizedHeader.frameSize, 0, null);
  samplesRead += synchronizedHeader.samplesPerFrame;
  sampleBytesRemaining = 0;
  return RESULT_CONTINUE;
}
 

@Override
public int read(byte[] target, int offset, int length) throws IOException {
  length = getReadLength(length);
  if (readFully(target, offset, length, true)) {
    return length;
  }
  return C.RESULT_END_OF_INPUT;
}
 

@Override
public int skip(int length) throws IOException {
  length = getReadLength(length);
  if (skipFully(length, true)) {
    return length;
  }
  return C.RESULT_END_OF_INPUT;
}
 

private int readFromExtractorInput(int offset, int length)
    throws IOException, InterruptedException {
  int read = extractorInput.read(tempBuffer, offset, length);
  if (read == C.RESULT_END_OF_INPUT) {
    endOfExtractorInput = true;
    read = 0;
  }
  return read;
}
 

private int readSample(ExtractorInput extractorInput) throws IOException, InterruptedException {
  if (sampleBytesRemaining == 0) {
    if (!maybeResynchronize(extractorInput)) {
      return RESULT_END_OF_INPUT;
    }
    if (basisTimeUs == -1) {
      basisTimeUs = seeker.getTimeUs(extractorInput.getPosition());
      if (forcedFirstSampleTimestampUs != -1) {
        long embeddedFirstSampleTimestampUs = seeker.getTimeUs(0);
        basisTimeUs += forcedFirstSampleTimestampUs - embeddedFirstSampleTimestampUs;
      }
    }
    sampleBytesRemaining = synchronizedHeader.frameSize;
  }
  int bytesAppended = trackOutput.sampleData(extractorInput, sampleBytesRemaining, true);
  if (bytesAppended == C.RESULT_END_OF_INPUT) {
    return RESULT_END_OF_INPUT;
  }
  sampleBytesRemaining -= bytesAppended;
  if (sampleBytesRemaining > 0) {
    return RESULT_CONTINUE;
  }
  long timeUs = basisTimeUs + (samplesRead * C.MICROS_PER_SECOND / synchronizedHeader.sampleRate);
  trackOutput.sampleMetadata(timeUs, C.SAMPLE_FLAG_SYNC, synchronizedHeader.frameSize, 0, null);
  samplesRead += synchronizedHeader.samplesPerFrame;
  sampleBytesRemaining = 0;
  return RESULT_CONTINUE;
}