Package com.google.android.exoplayer2.extractor

## Class ExtractorUtil

- java.lang.Object
- - com.google.android.exoplayer2.extractor.ExtractorUtil

-     public final class ExtractorUtil
      extends Object

  Extractor related utility methods.

- - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static void` | `checkContainerInput​(boolean expression, String message)` | If `expression` is false, throws a `container malformed ParserException` with the given message.
    `static boolean` | `peekFullyQuietly​(ExtractorInput input, byte[] output, int offset, int length, boolean allowEndOfInput)` | Peeks data from `input`, respecting `allowEndOfInput`.
    `static int` | `peekToLength​(ExtractorInput input, byte[] target, int offset, int length)` | Peeks `length` bytes from the input peek position, or all the bytes to the end of the input if there was less than `length` bytes left.
    `static boolean` | `readFullyQuietly​(ExtractorInput input, byte[] output, int offset, int length)` | Equivalent to `ExtractorInput.readFully(byte[], int, int)` except that it returns `false` instead of throwing an `EOFException` if the end of input is encountered without having fully satisfied the read.
    `static boolean` | `skipFullyQuietly​(ExtractorInput input, int length)` | Equivalent to `ExtractorInput.skipFully(int)` except that it returns `false` instead of throwing an `EOFException` if the end of input is encountered without having fully satisfied the skip.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### checkContainerInput

          @Pure
          public static void checkContainerInput​(boolean expression,
                                                 @Nullable
                                                 String message)
                                          throws ParserException

      If `expression` is false, throws a `container malformed ParserException` with the given message. Otherwise, does nothing.
      Throws:
        `ParserException`

    - #### peekToLength

          public static int peekToLength​(ExtractorInput input,
                                         byte[] target,
                                         int offset,
                                         int length)
                                  throws IOException

      Peeks `length` bytes from the input peek position, or all the bytes to the end of the input if there was less than `length` bytes left.

      If an exception is thrown, there is no guarantee on the peek position.

      Parameters:
        `input` - The stream input to peek the data from.
        `target` - A target array into which data should be written.
        `offset` - The offset into the target array at which to write.
        `length` - The maximum number of bytes to peek from the input.
      Returns:
        The number of bytes peeked.
      Throws:
        `IOException` - If an error occurs peeking from the input.

    - #### readFullyQuietly

          public static boolean readFullyQuietly​(ExtractorInput input,
                                                 byte[] output,
                                                 int offset,
                                                 int length)
                                          throws IOException

      Equivalent to `ExtractorInput.readFully(byte[], int, int)` except that it returns `false` instead of throwing an `EOFException` if the end of input is encountered without having fully satisfied the read.
      Throws:
        `IOException`

    - #### skipFullyQuietly

          public static boolean skipFullyQuietly​(ExtractorInput input,
                                                 int length)
                                          throws IOException

      Equivalent to `ExtractorInput.skipFully(int)` except that it returns `false` instead of throwing an `EOFException` if the end of input is encountered without having fully satisfied the skip.
      Throws:
        `IOException`

    - #### peekFullyQuietly

          public static boolean peekFullyQuietly​(ExtractorInput input,
                                                 byte[] output,
                                                 int offset,
                                                 int length,
                                                 boolean allowEndOfInput)
                                          throws IOException

      Peeks data from `input`, respecting `allowEndOfInput`. Returns true if the peek is successful.

      If `allowEndOfInput=false` then encountering the end of the input (whether before or after reading some data) will throw `EOFException`.

      If `allowEndOfInput=true` then encountering the end of the input (even after reading some data) will return `false`.

      This is slightly different to the behaviour of `ExtractorInput.peekFully(byte[], int, int, boolean)`, where `allowEndOfInput=true` only returns false (and suppresses the exception) if the end of the input is reached before reading any data.

      Throws:
        `IOException`