Java C.RESULT_END_OF_INPUT属性代码示例

@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_UNSET ? 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_UNSET || 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 int read(ExtractorInput input, PositionHolder seekPosition)
    throws IOException, InterruptedException {
  int bytesRead = input.read(packetBuffer.data, 0, MAX_PACKET_SIZE);
  if (bytesRead == C.RESULT_END_OF_INPUT) {
    return RESULT_END_OF_INPUT;
  }

  // Feed whatever data we have to the reader, regardless of whether the read finished or not.
  packetBuffer.setPosition(0);
  packetBuffer.setLimit(bytesRead);

  if (!startedPacket) {
    // Pass data to the reader as though it's contained within a single infinitely long packet.
    reader.packetStarted(firstSampleTimestampUs, true);
    startedPacket = true;
  }
  // TODO: Make it possible for reader to consume the dataSource directly, so that it becomes
  // unnecessary to copy the data through packetBuffer.
  reader.consume(packetBuffer);
  return RESULT_CONTINUE;
}
 

@Override
public int read(ExtractorInput input, PositionHolder seekPosition) throws IOException,
    InterruptedException {
  int bytesRead = input.read(sampleData.data, 0, MAX_SYNC_FRAME_SIZE);
  if (bytesRead == C.RESULT_END_OF_INPUT) {
    return RESULT_END_OF_INPUT;
  }

  // Feed whatever data we have to the reader, regardless of whether the read finished or not.
  sampleData.setPosition(0);
  sampleData.setLimit(bytesRead);

  if (!startedPacket) {
    // Pass data to the reader as though it's contained within a single infinitely long packet.
    reader.packetStarted(firstSampleTimestampUs, true);
    startedPacket = true;
  }
  // TODO: Make it possible for the reader to consume the dataSource directly, so that it becomes
  // unnecessary to copy the data through packetBuffer.
  reader.consume(sampleData);
  return RESULT_CONTINUE;
}
 

@Override
public void load() throws IOException, InterruptedException {
  // We always load from the beginning, so reset the sampleSize to 0.
  sampleSize = 0;
  try {
    // Create and open the input.
    dataSource.open(new DataSpec(uri));
    // Load the sample data.
    int result = 0;
    while (result != C.RESULT_END_OF_INPUT) {
      sampleSize += result;
      if (sampleData == null) {
        sampleData = new byte[INITIAL_SAMPLE_SIZE];
      } else if (sampleSize == sampleData.length) {
        sampleData = Arrays.copyOf(sampleData, sampleData.length * 2);
      }
      result = dataSource.read(sampleData, sampleSize, sampleData.length - sampleSize);
    }
  } finally {
    Util.closeQuietly(dataSource);
  }
}
 

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

@Override
public int read(byte[] buffer, int offset, int readLength) throws EncryptedFileDataSourceException {
    // fast-fail if there's 0 quantity requested or we think we've already processed everything
    if (readLength == 0) {
        return 0;
    } else if (mBytesRemaining == 0) {
        return C.RESULT_END_OF_INPUT;
    }
    // constrain the read length and try to read from the cipher input stream
    int bytesToRead = getBytesToRead(readLength);
    int bytesRead;
    try {
        bytesRead = mInputStream.read(buffer, offset, bytesToRead);
    } catch (IOException e) {
        throw new EncryptedFileDataSourceException(e);
    }
    // if we get a -1 that means we failed to read - we're either going to EOF error or broadcast EOF
    if (bytesRead == -1) {
        if (mBytesRemaining != C.LENGTH_UNSET) {
            throw new EncryptedFileDataSourceException(new EOFException());
        }
        return C.RESULT_END_OF_INPUT;
    }
    // we can't decrement bytes remaining if it's just a flag representation (as opposed to a mutable numeric quantity)
    if (mBytesRemaining != C.LENGTH_UNSET) {
        mBytesRemaining -= bytesRead;
    }
    // notify
    if (mTransferListener != null) {
        mTransferListener.onBytesTransferred(this, bytesRead);
    }
    // report
    return bytesRead;
}
 

@Override
public int read(byte[] buffer, int offset, int readLength) throws AssetDataSourceException {
  if (readLength == 0) {
    return 0;
  } else if (bytesRemaining == 0) {
    return C.RESULT_END_OF_INPUT;
  }

  int bytesRead;
  try {
    int bytesToRead = bytesRemaining == C.LENGTH_UNSET ? readLength
        : (int) Math.min(bytesRemaining, readLength);
    bytesRead = inputStream.read(buffer, offset, bytesToRead);
  } catch (IOException e) {
    throw new AssetDataSourceException(e);
  }

  if (bytesRead == -1) {
    if (bytesRemaining != C.LENGTH_UNSET) {
      // End of stream reached having not read sufficient data.
      throw new AssetDataSourceException(new EOFException());
    }
    return C.RESULT_END_OF_INPUT;
  }
  if (bytesRemaining != C.LENGTH_UNSET) {
    bytesRemaining -= bytesRead;
  }
  if (listener != null) {
    listener.onBytesTransferred(this, bytesRead);
  }
  return bytesRead;
}
 

@Override
public int read(byte[] buffer, int offset, int readLength) throws IOException {
  Assertions.checkState(cipherInputStream != null);
  int bytesRead = cipherInputStream.read(buffer, offset, readLength);
  if (bytesRead < 0) {
    return C.RESULT_END_OF_INPUT;
  }
  return bytesRead;
}
 

@Override
public int read(byte[] buffer, int offset, int readLength) throws RawResourceDataSourceException {
  if (readLength == 0) {
    return 0;
  } else if (bytesRemaining == 0) {
    return C.RESULT_END_OF_INPUT;
  }

  int bytesRead;
  try {
    int bytesToRead = bytesRemaining == C.LENGTH_UNSET ? readLength
        : (int) Math.min(bytesRemaining, readLength);
    bytesRead = inputStream.read(buffer, offset, bytesToRead);
  } catch (IOException e) {
    throw new RawResourceDataSourceException(e);
  }

  if (bytesRead == -1) {
    if (bytesRemaining != C.LENGTH_UNSET) {
      // End of stream reached having not read sufficient data.
      throw new RawResourceDataSourceException(new EOFException());
    }
    return C.RESULT_END_OF_INPUT;
  }
  if (bytesRemaining != C.LENGTH_UNSET) {
    bytesRemaining -= bytesRead;
  }
  if (listener != null) {
    listener.onBytesTransferred(this, bytesRead);
  }
  return bytesRead;
}
 

@Override
public int read(byte[] buffer, int offset, int readLength) throws IOException {
  Assertions.checkState(opened);
  while (true) {
    if (currentSegmentIndex == segments.size() || bytesRemaining == 0) {
      return C.RESULT_END_OF_INPUT;
    }
    Segment current = segments.get(currentSegmentIndex);
    if (current.isErrorSegment()) {
      if (!current.exceptionCleared) {
        current.exceptionThrown = true;
        throw (IOException) current.exception.fillInStackTrace();
      } else {
        currentSegmentIndex++;
      }
    } else {
      // Read at most bytesRemaining.
      readLength = (int) Math.min(readLength, bytesRemaining);
      // Do not allow crossing of the segment boundary.
      readLength = Math.min(readLength, current.length - current.bytesRead);
      // Perform the read and return.
      System.arraycopy(current.data, current.bytesRead, buffer, offset, readLength);
      bytesRemaining -= readLength;
      current.bytesRead += readLength;
      if (current.bytesRead == current.length) {
        currentSegmentIndex++;
      }
      return readLength;
    }
  }
}
 

@Override
public int sampleData(ExtractorInput input, int length, boolean allowEndOfInput)
    throws IOException, InterruptedException {
  byte[] newData = new byte[length];
  int bytesAppended = input.read(newData, 0, length);
  if (bytesAppended == C.RESULT_END_OF_INPUT) {
    if (allowEndOfInput) {
      return C.RESULT_END_OF_INPUT;
    }
    throw new EOFException();
  }
  newData = Arrays.copyOf(newData, bytesAppended);
  sampleData = TestUtil.joinByteArrays(sampleData, newData);
  return bytesAppended;
}
 

/**
 * 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 {
  if (readLength == 0) {
    return 0;
  }
  if (bytesToRead != C.LENGTH_UNSET) {
    long bytesRemaining = bytesToRead - bytesRead;
    if (bytesRemaining == 0) {
      return C.RESULT_END_OF_INPUT;
    }
    readLength = (int) Math.min(readLength, bytesRemaining);
  }

  int read = inputStream.read(buffer, offset, readLength);
  if (read == -1) {
    if (bytesToRead != C.LENGTH_UNSET) {
      // End of stream reached having not read sufficient data.
      throw new EOFException();
    }
    return C.RESULT_END_OF_INPUT;
  }

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

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

/**
 * Reads and discards all data specified by the {@code dataSpec}.
 *
 * @param dataSpec Defines the data to be read.
 * @param dataSource The {@link DataSource} to read the data from.
 * @param buffer The buffer to be used while downloading.
 * @param priorityTaskManager If not null it's used to check whether it is allowed to proceed with
 *     caching.
 * @param priority The priority of this task.
 * @return Number of read bytes, or 0 if no data is available because the end of the opened range
 * has been reached.
 */
private static long readAndDiscard(DataSpec dataSpec, DataSource dataSource, byte[] buffer,
    PriorityTaskManager priorityTaskManager, int priority)
    throws IOException, InterruptedException {
  while (true) {
    if (priorityTaskManager != null) {
      // Wait for any other thread with higher priority to finish its job.
      priorityTaskManager.proceed(priority);
    }
    try {
      dataSource.open(dataSpec);
      long totalRead = 0;
      while (true) {
        if (Thread.interrupted()) {
          throw new InterruptedException();
        }
        int read = dataSource.read(buffer, 0, buffer.length);
        if (read == C.RESULT_END_OF_INPUT) {
          return totalRead;
        }
        totalRead += read;
      }
    } catch (PriorityTaskManager.PriorityTooLowException exception) {
      // catch and try again
    } finally {
      Util.closeQuietly(dataSource);
    }
  }
}
 

/**
 * Reads an EBML variable-length integer (varint) from an {@link ExtractorInput} such that
 * reading can be resumed later if an error occurs having read only some of it.
 * <p>
 * If an value is successfully read, then the reader will automatically reset itself ready to
 * read another value.
 * <p>
 * If an {@link IOException} or {@link InterruptedException} is throw, the read can be resumed
 * later by calling this method again, passing an {@link ExtractorInput} providing data starting
 * where the previous one left off.
 *
 * @param input The {@link ExtractorInput} from which the integer should be read.
 * @param allowEndOfInput True if encountering the end of the input having read 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.
 * @param removeLengthMask Removes the variable-length integer length mask from the value.
 * @param maximumAllowedLength Maximum allowed length of the variable integer to be read.
 * @return The read value, or {@link C#RESULT_END_OF_INPUT} if {@code allowEndOfStream} is true
 *     and the end of the input was encountered, or {@link C#RESULT_MAX_LENGTH_EXCEEDED} if the
 *     length of the varint exceeded maximumAllowedLength.
 * @throws IOException If an error occurs reading from the input.
 * @throws InterruptedException If the thread is interrupted.
 */
public long readUnsignedVarint(ExtractorInput input, boolean allowEndOfInput,
    boolean removeLengthMask, int maximumAllowedLength) throws IOException, InterruptedException {
  if (state == STATE_BEGIN_READING) {
    // Read the first byte to establish the length.
    if (!input.readFully(scratch, 0, 1, allowEndOfInput)) {
      return C.RESULT_END_OF_INPUT;
    }
    int firstByte = scratch[0] & 0xFF;
    length = parseUnsignedVarintLength(firstByte);
    if (length == C.LENGTH_UNSET) {
      throw new IllegalStateException("No valid varint length mask found");
    }
    state = STATE_READ_CONTENTS;
  }

  if (length > maximumAllowedLength) {
    state = STATE_BEGIN_READING;
    return C.RESULT_MAX_LENGTH_EXCEEDED;
  }

  if (length != 1) {
    // Read the remaining bytes.
    input.readFully(scratch, 1, length - 1);
  }

  state = STATE_BEGIN_READING;
  return assembleVarint(scratch, length, removeLengthMask);
}