Java C.LENGTH_UNSET属性代码示例

@Override
public long open(DataSpec dataSpec) throws FileDataSourceException {
  try {
    uri = dataSpec.uri;
    file = new RandomAccessFile(dataSpec.uri.getPath(), "r");
    file.seek(dataSpec.position);
    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;
}
 

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

private void startLoading() {
  ExtractingLoadable loadable = new ExtractingLoadable(uri, dataSource, extractorHolder,
      loadCondition);
  if (prepared) {
    Assertions.checkState(isPendingReset());
    if (durationUs != C.TIME_UNSET && pendingResetPositionUs >= durationUs) {
      loadingFinished = true;
      pendingResetPositionUs = C.TIME_UNSET;
      return;
    }
    loadable.setLoadPosition(seekMap.getPosition(pendingResetPositionUs), pendingResetPositionUs);
    pendingResetPositionUs = C.TIME_UNSET;
  }
  extractedSamplesCountAtStartOfLoad = getExtractedSamplesCount();

  int minRetryCount = minLoadableRetryCount;
  if (minRetryCount == ExtractorMediaSource.MIN_RETRY_COUNT_DEFAULT_FOR_MEDIA) {
    // We assume on-demand before we're prepared.
    minRetryCount = !prepared || length != C.LENGTH_UNSET
        || (seekMap != null && seekMap.getDurationUs() != C.TIME_UNSET)
        ? ExtractorMediaSource.DEFAULT_MIN_LOADABLE_RETRY_COUNT_ON_DEMAND
        : ExtractorMediaSource.DEFAULT_MIN_LOADABLE_RETRY_COUNT_LIVE;
  }
  loader.startLoading(loadable, this, minRetryCount);
}
 

private static byte[] executePost(HttpDataSource.Factory dataSourceFactory, String url,
    byte[] data, Map<String, String> requestProperties) throws IOException {
  HttpDataSource dataSource = dataSourceFactory.createDataSource();
  if (requestProperties != null) {
    for (Map.Entry<String, String> requestProperty : requestProperties.entrySet()) {
      dataSource.setRequestProperty(requestProperty.getKey(), requestProperty.getValue());
    }
  }
  DataSpec dataSpec = new DataSpec(Uri.parse(url), data, 0, 0, C.LENGTH_UNSET, null,
      DataSpec.FLAG_ALLOW_GZIP);
  DataSourceInputStream inputStream = new DataSourceInputStream(dataSource, dataSpec);
  try {
    return Util.toByteArray(inputStream);
  } finally {
    Util.closeQuietly(inputStream);
  }
}
 

/**
 * Does a byte by byte search to try and find the next level 1 element. This method is called if
 * some invalid data is encountered in the parser.
 *
 * @param input The {@link ExtractorInput} from which data has to be read.
 * @return id of the next level 1 element that has been found.
 * @throws EOFException If the end of input was encountered when searching for the next level 1
 *     element.
 * @throws IOException If an error occurs reading from the input.
 * @throws InterruptedException If the thread is interrupted.
 */
private long maybeResyncToNextLevel1Element(ExtractorInput input) throws IOException,
    InterruptedException {
  input.resetPeekPosition();
  while (true) {
    input.peekFully(scratch, 0, MAX_ID_BYTES);
    int varintLength = VarintReader.parseUnsignedVarintLength(scratch[0]);
    if (varintLength != C.LENGTH_UNSET && varintLength <= MAX_ID_BYTES) {
      int potentialId = (int) VarintReader.assembleVarint(scratch, varintLength, false);
      if (output.isLevel1Element(potentialId)) {
        input.skipFully(varintLength);
        return potentialId;
      }
    }
    input.skipFully(1);
  }
}
 

@Override
public long open(DataSpec dataSpec) throws IOException {
  try {
    uri = dataSpec.uri;
    flags = dataSpec.flags;
    key = CacheUtil.getKey(dataSpec);
    readPosition = dataSpec.position;
    currentRequestIgnoresCache = (ignoreCacheOnError && seenCacheError)
        || (dataSpec.length == C.LENGTH_UNSET && ignoreCacheForUnsetLengthRequests);
    if (dataSpec.length != C.LENGTH_UNSET || currentRequestIgnoresCache) {
      bytesRemaining = dataSpec.length;
    } else {
      bytesRemaining = cache.getContentLength(key);
      if (bytesRemaining != C.LENGTH_UNSET) {
        bytesRemaining -= dataSpec.position;
        if (bytesRemaining <= 0) {
          throw new DataSourceException(DataSourceException.POSITION_OUT_OF_RANGE);
        }
      }
    }
    openNextSource(true);
    return bytesRemaining;
  } catch (IOException e) {
    handleBeforeThrow(e);
    throw e;
  }
}
 

@Override
public long open(DataSpec dataSpec) throws AssetDataSourceException {
  try {
    uri = dataSpec.uri;
    String path = uri.getPath();
    if (path.startsWith("/android_asset/")) {
      path = path.substring(15);
    } else if (path.startsWith("/")) {
      path = path.substring(1);
    }
    inputStream = assetManager.open(path, AssetManager.ACCESS_RANDOM);
    long skipped = inputStream.skip(dataSpec.position);
    if (skipped < dataSpec.position) {
      // assetManager.open() returns an AssetInputStream, whose skip() implementation only skips
      // fewer bytes than requested if the skip is beyond the end of the asset's data.
      throw new EOFException();
    }
    if (dataSpec.length != C.LENGTH_UNSET) {
      bytesRemaining = dataSpec.length;
    } else {
      bytesRemaining = inputStream.available();
      if (bytesRemaining == Integer.MAX_VALUE) {
        // assetManager.open() returns an AssetInputStream, whose available() implementation
        // returns Integer.MAX_VALUE if the remaining length is greater than (or equal to)
        // Integer.MAX_VALUE. We don't know the true length in this case, so treat as unbounded.
        bytesRemaining = C.LENGTH_UNSET;
      }
    }
  } catch (IOException e) {
    throw new AssetDataSourceException(e);
  }

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

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

private int readSample(ExtractorInput extractorInput) throws IOException, InterruptedException {
  if (sampleBytesRemaining == 0) {
    extractorInput.resetPeekPosition();
    if (!extractorInput.peekFully(scratch.data, 0, 4, true)) {
      return RESULT_END_OF_INPUT;
    }
    scratch.setPosition(0);
    int sampleHeaderData = scratch.readInt();
    if ((sampleHeaderData & HEADER_MASK) != (synchronizedHeaderData & HEADER_MASK)
        || MpegAudioHeader.getFrameSize(sampleHeaderData) == C.LENGTH_UNSET) {
      // We have lost synchronization, so attempt to resynchronize starting at the next byte.
      extractorInput.skipFully(1);
      synchronizedHeaderData = 0;
      return RESULT_CONTINUE;
    }
    MpegAudioHeader.populateHeader(sampleHeaderData, synchronizedHeader);
    if (basisTimeUs == C.TIME_UNSET) {
      basisTimeUs = seeker.getTimeUs(extractorInput.getPosition());
      if (forcedFirstSampleTimestampUs != C.TIME_UNSET) {
        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.BUFFER_FLAG_KEY_FRAME, synchronizedHeader.frameSize, 0,
      null);
  samplesRead += synchronizedHeader.samplesPerFrame;
  sampleBytesRemaining = 0;
  return RESULT_CONTINUE;
}
 

/**
 * On platform API levels 19 and 20, okhttp's implementation of {@link InputStream#close} can
 * block for a long time if the stream has a lot of data remaining. Call this method before
 * closing the input stream to make a best effort to cause the input stream to encounter an
 * unexpected end of input, working around this issue. On other platform API levels, the method
 * does nothing.
 *
 * @param connection The connection whose {@link InputStream} should be terminated.
 * @param bytesRemaining The number of bytes remaining to be read from the input stream if its
 *     length is known. {@link C#LENGTH_UNSET} otherwise.
 */
private static void maybeTerminateInputStream(HttpURLConnection connection, long bytesRemaining) {
  if (Util.SDK_INT != 19 && Util.SDK_INT != 20) {
    return;
  }

  try {
    InputStream inputStream = connection.getInputStream();
    if (bytesRemaining == C.LENGTH_UNSET) {
      // If the input stream has already ended, do nothing. The socket may be re-used.
      if (inputStream.read() == -1) {
        return;
      }
    } else if (bytesRemaining <= MAX_BYTES_TO_DRAIN) {
      // There isn't much data left. Prefer to allow it to drain, which may allow the socket to be
      // re-used.
      return;
    }
    String className = inputStream.getClass().getName();
    if (className.equals("com.android.okhttp.internal.http.HttpTransport$ChunkedInputStream")
        || className.equals(
        "com.android.okhttp.internal.http.HttpTransport$FixedLengthInputStream")) {
      Class<?> superclass = inputStream.getClass().getSuperclass();
      Method unexpectedEndOfInput = superclass.getDeclaredMethod("unexpectedEndOfInput");
      unexpectedEndOfInput.setAccessible(true);
      unexpectedEndOfInput.invoke(inputStream);
    }
  } catch (Exception e) {
    // If an IOException then the connection didn't ever have an input stream, or it was closed
    // already. If another type of exception then something went wrong, most likely the device
    // isn't using okhttp.
  }
}
 

@Override
public long open(DataSpec dataSpec) throws IOException {
  uri = dataSpec.uri;
  readPosition = (int) dataSpec.position;
  bytesRemaining = (int) ((dataSpec.length == C.LENGTH_UNSET)
      ? (data.length - dataSpec.position) : dataSpec.length);
  if (bytesRemaining <= 0 || readPosition + bytesRemaining > data.length) {
    throw new IOException("Unsatisfiable range: [" + readPosition + ", " + dataSpec.length
        + "], length: " + data.length);
  }
  return bytesRemaining;
}
 

private static void consumeTestData(Extractor extractor, FakeExtractorInput input, long timeUs,
    FakeExtractorOutput output, boolean retryFromStartIfLive)
    throws IOException, InterruptedException {
  extractor.seek(input.getPosition(), timeUs);
  PositionHolder seekPositionHolder = new PositionHolder();
  int readResult = Extractor.RESULT_CONTINUE;
  while (readResult != Extractor.RESULT_END_OF_INPUT) {
    try {
      // Extractor.read should not read seekPositionHolder.position. Set it to a value that's
      // likely to cause test failure if a read does occur.
      seekPositionHolder.position = Long.MIN_VALUE;
      readResult = extractor.read(input, seekPositionHolder);
      if (readResult == Extractor.RESULT_SEEK) {
        long seekPosition = seekPositionHolder.position;
        Assertions.checkState(0 <= seekPosition && seekPosition <= Integer.MAX_VALUE);
        input.setPosition((int) seekPosition);
      }
    } catch (SimulatedIOException e) {
      if (!retryFromStartIfLive) {
        continue;
      }
      boolean isOnDemand = input.getLength() != C.LENGTH_UNSET
          || (output.seekMap != null && output.seekMap.getDurationUs() != C.TIME_UNSET);
      if (isOnDemand) {
        continue;
      }
      input.setPosition(0);
      for (int i = 0; i < output.numberOfTracks; i++) {
        output.trackOutputs.valueAt(i).clear();
      }
      extractor.seek(0, 0);
    }
  }
}
 

private int getBytesToRead(int bytesToRead) {
    if (mBytesRemaining == C.LENGTH_UNSET) {
        return bytesToRead;
    }
    return (int) Math.min(mBytesRemaining, bytesToRead);
}
 

@Override
public long getLength() {
  return simulateUnknownLength ? C.LENGTH_UNSET : data.length;
}
 

public static SimpleCacheSpan createOpenHole(String key, long position) {
  return new SimpleCacheSpan(key, position, C.LENGTH_UNSET, C.TIME_UNSET, null);
}