How to use

isEndOfStream

method

in

com.google.android.exoplayer2.decoder.DecoderInputBuffer

@Override
protected AudioDecoderException decode(DecoderInputBuffer inputBuffer,
  SimpleOutputBuffer outputBuffer, boolean reset) {
 if (inputBuffer.isEndOfStream()) {
  outputBuffer.setFlags(C.BUFFER_FLAG_END_OF_STREAM);
 }
 return null;
}

int result = stream.readData(formatHolder, buffer, formatRequired);
if (result == C.RESULT_BUFFER_READ) {
 if (buffer.isEndOfStream()) {
  readEndOfStream = true;
  return streamIsFinal ? C.RESULT_BUFFER_READ : C.RESULT_NOTHING_READ;

private void assertInputBufferHasNoDefaultFlagsSet() {
 assertThat(inputBuffer.isEndOfStream()).isFalse();
 assertThat(inputBuffer.isDecodeOnly()).isFalse();
 assertThat(inputBuffer.isEncrypted()).isFalse();
}

@Override
public void render(long positionUs, long elapsedRealtimeUs) throws ExoPlaybackException {
 if (isEnded) {
  return;
 }
 playbackPositionUs = positionUs;
 while (lastSamplePositionUs < positionUs + SOURCE_READAHEAD_US) {
  formatHolder.format = null;
  buffer.clear();
  int result = readSource(formatHolder, buffer, false);
  if (result == C.RESULT_FORMAT_READ) {
   formatReadCount++;
   assertThat(expectedFormats).contains(formatHolder.format);
   onFormatChanged(formatHolder.format);
  } else if (result == C.RESULT_BUFFER_READ) {
   if (buffer.isEndOfStream()) {
    isEnded = true;
    return;
   }
   lastSamplePositionUs = buffer.timeUs;
   sampleBufferReadCount++;
   onBufferRead();
  } else {
   Assertions.checkState(result == C.RESULT_NOTHING_READ);
   return;
  }
 }
}

 return C.RESULT_FORMAT_READ;
case C.RESULT_BUFFER_READ:
 if (!buffer.isEndOfStream()) {
  if (buffer.timeUs < decodeOnlyUntilUs) {
   buffer.addFlag(C.BUFFER_FLAG_DECODE_ONLY);

@Override
public void render(long positionUs, long elapsedRealtimeUs) throws ExoPlaybackException {
 // Keep reading available samples as long as the sample time is not too far into the future.
 while (!hasReadStreamToEnd() && lastTimestampUs < positionUs + SAMPLE_WINDOW_DURATION_US) {
  buffer.clear();
  int result = readSource(formatHolder, buffer, /* formatRequired= */ false);
  if (result != C.RESULT_BUFFER_READ || buffer.isEndOfStream()) {
   return;
  }
  buffer.flip();
  lastTimestampUs = buffer.timeUs;
  if (listener != null) {
   float[] rotation = parseMetadata(buffer.data);
   if (rotation != null) {
    Util.castNonNull(listener).onCameraMotion(lastTimestampUs - offsetUs, rotation);
   }
  }
 }
}

/**
 * Asserts {@link SampleQueue#read} returns {@link C#RESULT_BUFFER_READ} and that the
 * {@link DecoderInputBuffer#isEndOfStream()} is set.
 *
 * @param formatRequired The value of {@code formatRequired} passed to readData.
 */
private void assertReadEndOfStream(boolean formatRequired) {
 clearFormatHolderAndInputBuffer();
 int result = sampleQueue.read(formatHolder, inputBuffer, formatRequired, true, 0);
 assertThat(result).isEqualTo(RESULT_BUFFER_READ);
 // formatHolder should not be populated.
 assertThat(formatHolder.format).isNull();
 // inputBuffer should not contain sample data, but end of stream flag should be set.
 assertInputBufferContainsNoSampleData();
 assertThat(inputBuffer.isEndOfStream()).isTrue();
 assertThat(inputBuffer.isDecodeOnly()).isFalse();
 assertThat(inputBuffer.isEncrypted()).isFalse();
}

if (inputBuffer.isEndOfStream()) {
 outputBuffer.addFlag(C.BUFFER_FLAG_END_OF_STREAM);
} else {

@Override
public void render(long positionUs, long elapsedRealtimeUs) throws ExoPlaybackException {
 if (isEnded) {
  return;
 }
 playbackPositionUs = positionUs;
 while (lastSamplePositionUs < positionUs + SOURCE_READAHEAD_US) {
  formatHolder.format = null;
  buffer.clear();
  int result = readSource(formatHolder, buffer, false);
  if (result == C.RESULT_FORMAT_READ) {
   formatReadCount++;
   assertThat(expectedFormats).contains(formatHolder.format);
   onFormatChanged(formatHolder.format);
  } else if (result == C.RESULT_BUFFER_READ) {
   if (buffer.isEndOfStream()) {
    isEnded = true;
    return;
   }
   lastSamplePositionUs = buffer.timeUs;
   sampleBufferReadCount++;
   onBufferRead();
  } else {
   Assertions.checkState(result == C.RESULT_NOTHING_READ);
   return;
  }
 }
}

} else if (result == C.RESULT_BUFFER_READ) {
 Assertions.checkState(flagsOnlyBuffer.isEndOfStream());
 inputStreamEnded = true;
 processEndOfStream();
 onInputFormatChanged(formatHolder.format);
} else if (result == C.RESULT_BUFFER_READ) {
 Assertions.checkState(flagsOnlyBuffer.isEndOfStream());
 inputStreamEnded = true;
 processEndOfStream();

if (buffer.isEndOfStream()) {
 if (codecReconfigurationState == RECONFIGURATION_STATE_QUEUE_PENDING) {

} else if (result == C.RESULT_BUFFER_READ) {
 Assertions.checkState(flagsOnlyBuffer.isEndOfStream());
 inputStreamEnded = true;
 outputStreamEnded = true;

 return true;
if (inputBuffer.isEndOfStream()) {
 inputStreamEnded = true;
 decoder.queueInputBuffer(inputBuffer);

} else if (result == C.RESULT_BUFFER_READ) {
 Assertions.checkState(flagsOnlyBuffer.isEndOfStream());
 inputStreamEnded = true;
 processEndOfStream();