Java Code Examples for com.google.android.exoplayer2.C#ENCODING_PCM_FLOAT

/**
 * Returns the frame size for audio with {@code channelCount} channels in the specified encoding.
 *
 * @param pcmEncoding The encoding of the audio data.
 * @param channelCount The channel count.
 * @return The size of one audio frame in bytes.
 */
public static int getPcmFrameSize(@C.PcmEncoding int pcmEncoding, int channelCount) {
  switch (pcmEncoding) {
    case C.ENCODING_PCM_8BIT:
      return channelCount;
    case C.ENCODING_PCM_16BIT:
      return channelCount * 2;
    case C.ENCODING_PCM_24BIT:
      return channelCount * 3;
    case C.ENCODING_PCM_32BIT:
    case C.ENCODING_PCM_FLOAT:
      return channelCount * 4;
    case C.ENCODING_PCM_A_LAW:
    case C.ENCODING_PCM_MU_LAW:
    case C.ENCODING_INVALID:
    case Format.NO_VALUE:
    default:
      throw new IllegalArgumentException();
  }
}
 

/**
 * Returns the frame size for audio with {@code channelCount} channels in the specified encoding.
 *
 * @param pcmEncoding The encoding of the audio data.
 * @param channelCount The channel count.
 * @return The size of one audio frame in bytes.
 */
public static int getPcmFrameSize(@C.PcmEncoding int pcmEncoding, int channelCount) {
  switch (pcmEncoding) {
    case C.ENCODING_PCM_8BIT:
      return channelCount;
    case C.ENCODING_PCM_16BIT:
      return channelCount * 2;
    case C.ENCODING_PCM_24BIT:
      return channelCount * 3;
    case C.ENCODING_PCM_32BIT:
    case C.ENCODING_PCM_FLOAT:
      return channelCount * 4;
    case C.ENCODING_INVALID:
    case Format.NO_VALUE:
    default:
      throw new IllegalArgumentException();
  }
}
 

/** Returns the PCM encoding for the given WAVE {@code type} value. */
public static @C.PcmEncoding int getEncodingForType(int type, int bitsPerSample) {
  switch (type) {
    case TYPE_PCM:
    case TYPE_WAVE_FORMAT_EXTENSIBLE:
      return Util.getPcmEncoding(bitsPerSample);
    case TYPE_FLOAT:
      return bitsPerSample == 32 ? C.ENCODING_PCM_FLOAT : C.ENCODING_INVALID;
    case TYPE_A_LAW:
      return C.ENCODING_PCM_A_LAW;
    case TYPE_MU_LAW:
      return C.ENCODING_PCM_MU_LAW;
    default:
      return C.ENCODING_INVALID;
  }
}
 

/**
 * Returns the frame size for audio with {@code channelCount} channels in the specified encoding.
 *
 * @param pcmEncoding The encoding of the audio data.
 * @param channelCount The channel count.
 * @return The size of one audio frame in bytes.
 */
public static int getPcmFrameSize(@C.PcmEncoding int pcmEncoding, int channelCount) {
  switch (pcmEncoding) {
    case C.ENCODING_PCM_8BIT:
      return channelCount;
    case C.ENCODING_PCM_16BIT:
      return channelCount * 2;
    case C.ENCODING_PCM_24BIT:
      return channelCount * 3;
    case C.ENCODING_PCM_32BIT:
    case C.ENCODING_PCM_FLOAT:
      return channelCount * 4;
    case C.ENCODING_PCM_A_LAW:
    case C.ENCODING_PCM_MU_LAW:
    case C.ENCODING_INVALID:
    case Format.NO_VALUE:
    default:
      throw new IllegalArgumentException();
  }
}
 

public FfmpegDecoder(
    int numInputBuffers,
    int numOutputBuffers,
    int initialInputBufferSize,
    Format format,
    boolean outputFloat)
    throws FfmpegDecoderException {
  super(new DecoderInputBuffer[numInputBuffers], new SimpleOutputBuffer[numOutputBuffers]);
  Assertions.checkNotNull(format.sampleMimeType);
  codecName =
      Assertions.checkNotNull(
          FfmpegLibrary.getCodecName(format.sampleMimeType, format.pcmEncoding));
  extraData = getExtraData(format.sampleMimeType, format.initializationData);
  encoding = outputFloat ? C.ENCODING_PCM_FLOAT : C.ENCODING_PCM_16BIT;
  outputBufferSize = outputFloat ? OUTPUT_BUFFER_SIZE_32BIT : OUTPUT_BUFFER_SIZE_16BIT;
  nativeContext =
      ffmpegInitialize(codecName, extraData, outputFloat, format.sampleRate, format.channelCount);
  if (nativeContext == 0) {
    throw new FfmpegDecoderException("Initialization failed.");
  }
  setInitialInputBufferSize(initialInputBufferSize);
}
 

public AudioDecoder(
    int numInputBuffers,
    int numOutputBuffers,
    int initialInputBufferSize,
    Format format,
    boolean outputFloat)
    throws AudioSoftDecoderException {
  super(new DecoderInputBuffer[numInputBuffers], new SimpleOutputBuffer[numOutputBuffers]);
  if (!DecoderSoLibrary.isAvailable()) {
    throw new AudioSoftDecoderException("Failed to load decoder native libraries.");
  }
  Assertions.checkNotNull(format.sampleMimeType);
  codecName = Assertions.checkNotNull(getCodecName(format.sampleMimeType, format.pcmEncoding));
  extraData = getExtraData(format.sampleMimeType, format.initializationData);
  encoding = outputFloat ? C.ENCODING_PCM_FLOAT : C.ENCODING_PCM_16BIT;
  outputBufferSize = outputFloat ? OUTPUT_BUFFER_SIZE_32BIT : OUTPUT_BUFFER_SIZE_16BIT;
  nativeContext =
      ffmpegInitialize(codecName, extraData, outputFloat, format.sampleRate, format.channelCount);
  if (nativeContext == 0) {
    throw new AudioSoftDecoderException("Initialization failed.");
  }
  setInitialInputBufferSize(initialInputBufferSize);
}
 

private boolean shouldUseFloatOutput(Format inputFormat) {
  Assertions.checkNotNull(inputFormat.sampleMimeType);
  if (!enableFloatOutput || !supportsOutput(inputFormat.channelCount, C.ENCODING_PCM_FLOAT)) {
    return false;
  }
  switch (inputFormat.sampleMimeType) {
    case MimeTypes.AUDIO_RAW:
      // For raw audio, output in 32-bit float encoding if the bit depth is > 16-bit.
      return inputFormat.pcmEncoding == C.ENCODING_PCM_24BIT
          || inputFormat.pcmEncoding == C.ENCODING_PCM_32BIT
          || inputFormat.pcmEncoding == C.ENCODING_PCM_FLOAT;
    case MimeTypes.AUDIO_AC3:
      // AC-3 is always 16-bit, so there is no point outputting in 32-bit float encoding.
      return false;
    default:
      // For all other formats, assume that it's worth using 32-bit float encoding.
      return true;
  }
}
 

/** Returns the PCM encoding for the given WAVE {@code type} value. */
public static @C.PcmEncoding int getEncodingForType(int type, int bitsPerSample) {
  switch (type) {
    case TYPE_PCM:
    case TYPE_WAVE_FORMAT_EXTENSIBLE:
      return Util.getPcmEncoding(bitsPerSample);
    case TYPE_FLOAT:
      return bitsPerSample == 32 ? C.ENCODING_PCM_FLOAT : C.ENCODING_INVALID;
    case TYPE_A_LAW:
      return C.ENCODING_PCM_A_LAW;
    case TYPE_MU_LAW:
      return C.ENCODING_PCM_MU_LAW;
    default:
      return C.ENCODING_INVALID;
  }
}
 

private boolean shouldUseFloatOutput(Format inputFormat) {
  Assertions.checkNotNull(inputFormat.sampleMimeType);
  if (!enableFloatOutput || !supportsOutput(inputFormat.channelCount, C.ENCODING_PCM_FLOAT)) {
    return false;
  }
  switch (inputFormat.sampleMimeType) {
    case MimeTypes.AUDIO_RAW:
      // For raw audio, output in 32-bit float encoding if the bit depth is > 16-bit.
      return inputFormat.pcmEncoding == C.ENCODING_PCM_24BIT
          || inputFormat.pcmEncoding == C.ENCODING_PCM_32BIT
          || inputFormat.pcmEncoding == C.ENCODING_PCM_FLOAT;
    case MimeTypes.AUDIO_AC3:
      // AC-3 is always 16-bit, so there is no point outputting in 32-bit float encoding.
      return false;
    default:
      // For all other formats, assume that it's worth using 32-bit float encoding.
      return true;
  }
}
 

public FfmpegDecoder(
    int numInputBuffers,
    int numOutputBuffers,
    int initialInputBufferSize,
    Format format,
    boolean outputFloat)
    throws FfmpegDecoderException {
  super(new DecoderInputBuffer[numInputBuffers], new SimpleOutputBuffer[numOutputBuffers]);
  Assertions.checkNotNull(format.sampleMimeType);
  codecName =
      Assertions.checkNotNull(
          FfmpegLibrary.getCodecName(format.sampleMimeType, format.pcmEncoding));
  extraData = getExtraData(format.sampleMimeType, format.initializationData);
  encoding = outputFloat ? C.ENCODING_PCM_FLOAT : C.ENCODING_PCM_16BIT;
  outputBufferSize = outputFloat ? OUTPUT_BUFFER_SIZE_32BIT : OUTPUT_BUFFER_SIZE_16BIT;
  nativeContext =
      ffmpegInitialize(codecName, extraData, outputFloat, format.sampleRate, format.channelCount);
  if (nativeContext == 0) {
    throw new FfmpegDecoderException("Initialization failed.");
  }
  setInitialInputBufferSize(initialInputBufferSize);
}
 

private boolean shouldUseFloatOutput(Format inputFormat) {
  Assertions.checkNotNull(inputFormat.sampleMimeType);
  if (!enableFloatOutput || !supportsOutputEncoding(C.ENCODING_PCM_FLOAT)) {
    return false;
  }
  switch (inputFormat.sampleMimeType) {
    case MimeTypes.AUDIO_RAW:
      // For raw audio, output in 32-bit float encoding if the bit depth is > 16-bit.
      return inputFormat.pcmEncoding == C.ENCODING_PCM_24BIT
          || inputFormat.pcmEncoding == C.ENCODING_PCM_32BIT
          || inputFormat.pcmEncoding == C.ENCODING_PCM_FLOAT;
    case MimeTypes.AUDIO_AC3:
      // AC-3 is always 16-bit, so there is no point outputting in 32-bit float encoding.
      return false;
    default:
      // For all other formats, assume that it's worth using 32-bit float encoding.
      return true;
  }
}
 

/** Returns the WAVE type value for the given {@code encoding}. */
public static int getTypeForEncoding(@C.PcmEncoding int encoding) {
  switch (encoding) {
    case C.ENCODING_PCM_8BIT:
    case C.ENCODING_PCM_16BIT:
    case C.ENCODING_PCM_24BIT:
    case C.ENCODING_PCM_32BIT:
      return TYPE_PCM;
    case C.ENCODING_PCM_A_LAW:
      return TYPE_A_LAW;
    case C.ENCODING_PCM_MU_LAW:
      return TYPE_MU_LAW;
    case C.ENCODING_PCM_FLOAT:
      return TYPE_FLOAT;
    case C.ENCODING_INVALID:
    case Format.NO_VALUE:
    default:
      throw new IllegalArgumentException();
  }
}
 

/**
 * Returns whether {@code encoding} is one of the linear PCM encodings.
 *
 * @param encoding The encoding of the audio data.
 * @return Whether the encoding is one of the PCM encodings.
 */
public static boolean isEncodingLinearPcm(@C.Encoding int encoding) {
  return encoding == C.ENCODING_PCM_8BIT
      || encoding == C.ENCODING_PCM_16BIT
      || encoding == C.ENCODING_PCM_24BIT
      || encoding == C.ENCODING_PCM_32BIT
      || encoding == C.ENCODING_PCM_FLOAT;
}
 

private static int getMaximumEncodedRateBytesPerSecond(@C.Encoding int encoding) {
  switch (encoding) {
    case C.ENCODING_AC3:
      return 640 * 1000 / 8;
    case C.ENCODING_E_AC3:
    case C.ENCODING_E_AC3_JOC:
      return 6144 * 1000 / 8;
    case C.ENCODING_AC4:
      return 2688 * 1000 / 8;
    case C.ENCODING_DTS:
      // DTS allows an 'open' bitrate, but we assume the maximum listed value: 1536 kbit/s.
      return 1536 * 1000 / 8;
    case C.ENCODING_DTS_HD:
      return 18000 * 1000 / 8;
    case C.ENCODING_DOLBY_TRUEHD:
      return 24500 * 1000 / 8;
    case C.ENCODING_INVALID:
    case C.ENCODING_PCM_16BIT:
    case C.ENCODING_PCM_24BIT:
    case C.ENCODING_PCM_32BIT:
    case C.ENCODING_PCM_8BIT:
    case C.ENCODING_PCM_A_LAW:
    case C.ENCODING_PCM_FLOAT:
    case C.ENCODING_PCM_MU_LAW:
    case Format.NO_VALUE:
    default:
      throw new IllegalArgumentException();
  }
}
 

/**
 * Returns whether {@code encoding} is one of the linear PCM encodings.
 *
 * @param encoding The encoding of the audio data.
 * @return Whether the encoding is one of the PCM encodings.
 */
public static boolean isEncodingLinearPcm(@C.Encoding int encoding) {
  return encoding == C.ENCODING_PCM_8BIT
      || encoding == C.ENCODING_PCM_16BIT
      || encoding == C.ENCODING_PCM_24BIT
      || encoding == C.ENCODING_PCM_32BIT
      || encoding == C.ENCODING_PCM_FLOAT;
}
 

/**
 * Peeks and returns a {@code WavHeader}.
 *
 * @param input Input stream to peek the WAV header from.
 * @throws ParserException If the input file is an incorrect RIFF WAV.
 * @throws IOException If peeking from the input fails.
 * @throws InterruptedException If interrupted while peeking from input.
 * @return A new {@code WavHeader} peeked from {@code input}, or null if the input is not a
 *     supported WAV format.
 */
public static WavHeader peek(ExtractorInput input) throws IOException, InterruptedException {
  Assertions.checkNotNull(input);

  // Allocate a scratch buffer large enough to store the format chunk.
  ParsableByteArray scratch = new ParsableByteArray(16);

  // Attempt to read the RIFF chunk.
  ChunkHeader chunkHeader = ChunkHeader.peek(input, scratch);
  if (chunkHeader.id != Util.getIntegerCodeForString("RIFF")) {
    return null;
  }

  input.peekFully(scratch.data, 0, 4);
  scratch.setPosition(0);
  int riffFormat = scratch.readInt();
  if (riffFormat != Util.getIntegerCodeForString("WAVE")) {
    Log.e(TAG, "Unsupported RIFF format: " + riffFormat);
    return null;
  }

  // Skip chunks until we find the format chunk.
  chunkHeader = ChunkHeader.peek(input, scratch);
  while (chunkHeader.id != Util.getIntegerCodeForString("fmt ")) {
    input.advancePeekPosition((int) chunkHeader.size);
    chunkHeader = ChunkHeader.peek(input, scratch);
  }

  Assertions.checkState(chunkHeader.size >= 16);
  input.peekFully(scratch.data, 0, 16);
  scratch.setPosition(0);
  int type = scratch.readLittleEndianUnsignedShort();
  int numChannels = scratch.readLittleEndianUnsignedShort();
  int sampleRateHz = scratch.readLittleEndianUnsignedIntToInt();
  int averageBytesPerSecond = scratch.readLittleEndianUnsignedIntToInt();
  int blockAlignment = scratch.readLittleEndianUnsignedShort();
  int bitsPerSample = scratch.readLittleEndianUnsignedShort();

  int expectedBlockAlignment = numChannels * bitsPerSample / 8;
  if (blockAlignment != expectedBlockAlignment) {
    throw new ParserException("Expected block alignment: " + expectedBlockAlignment + "; got: "
        + blockAlignment);
  }

  @C.PcmEncoding int encoding;
  switch (type) {
    case TYPE_PCM:
    case TYPE_WAVE_FORMAT_EXTENSIBLE:
      encoding = Util.getPcmEncoding(bitsPerSample);
      break;
    case TYPE_FLOAT:
      encoding = bitsPerSample == 32 ? C.ENCODING_PCM_FLOAT : C.ENCODING_INVALID;
      break;
    case TYPE_A_LAW:
      encoding = C.ENCODING_PCM_A_LAW;
      break;
    case TYPE_MU_LAW:
      encoding = C.ENCODING_PCM_MU_LAW;
      break;
    default:
      Log.e(TAG, "Unsupported WAV format type: " + type);
      return null;
  }

  if (encoding == C.ENCODING_INVALID) {
    Log.e(TAG, "Unsupported WAV bit depth " + bitsPerSample + " for type " + type);
    return null;
  }

  // If present, skip extensionSize, validBitsPerSample, channelMask, subFormatGuid, ...
  input.advancePeekPosition((int) chunkHeader.size - 16);

  return new WavHeader(numChannels, sampleRateHz, averageBytesPerSecond, blockAlignment,
      bitsPerSample, encoding);
}
 

@Override
public void queueInput(ByteBuffer inputBuffer) {
  // Prepare the output buffer.
  int position = inputBuffer.position();
  int limit = inputBuffer.limit();
  int size = limit - position;
  int resampledSize;
  switch (inputAudioFormat.encoding) {
    case C.ENCODING_PCM_8BIT:
      resampledSize = size * 2;
      break;
    case C.ENCODING_PCM_24BIT:
      resampledSize = (size / 3) * 2;
      break;
    case C.ENCODING_PCM_32BIT:
      resampledSize = size / 2;
      break;
    case C.ENCODING_PCM_16BIT:
    case C.ENCODING_PCM_FLOAT:
    case C.ENCODING_PCM_A_LAW:
    case C.ENCODING_PCM_MU_LAW:
    case C.ENCODING_INVALID:
    case Format.NO_VALUE:
    default:
      throw new IllegalStateException();
  }

  // Resample the little endian input and update the input/output buffers.
  ByteBuffer buffer = replaceOutputBuffer(resampledSize);
  switch (inputAudioFormat.encoding) {
    case C.ENCODING_PCM_8BIT:
      // 8->16 bit resampling. Shift each byte from [0, 256) to [-128, 128) and scale up.
      for (int i = position; i < limit; i++) {
        buffer.put((byte) 0);
        buffer.put((byte) ((inputBuffer.get(i) & 0xFF) - 128));
      }
      break;
    case C.ENCODING_PCM_24BIT:
      // 24->16 bit resampling. Drop the least significant byte.
      for (int i = position; i < limit; i += 3) {
        buffer.put(inputBuffer.get(i + 1));
        buffer.put(inputBuffer.get(i + 2));
      }
      break;
    case C.ENCODING_PCM_32BIT:
      // 32->16 bit resampling. Drop the two least significant bytes.
      for (int i = position; i < limit; i += 4) {
        buffer.put(inputBuffer.get(i + 2));
        buffer.put(inputBuffer.get(i + 3));
      }
      break;
    case C.ENCODING_PCM_16BIT:
    case C.ENCODING_PCM_FLOAT:
    case C.ENCODING_PCM_A_LAW:
    case C.ENCODING_PCM_MU_LAW:
    case C.ENCODING_INVALID:
    case Format.NO_VALUE:
    default:
      // Never happens.
      throw new IllegalStateException();
  }
  inputBuffer.position(inputBuffer.limit());
  buffer.flip();
}
 

@Override
public void queueInput(ByteBuffer inputBuffer) {
  // Prepare the output buffer.
  int position = inputBuffer.position();
  int limit = inputBuffer.limit();
  int size = limit - position;
  int resampledSize;
  switch (encoding) {
    case C.ENCODING_PCM_8BIT:
      resampledSize = size * 2;
      break;
    case C.ENCODING_PCM_24BIT:
      resampledSize = (size / 3) * 2;
      break;
    case C.ENCODING_PCM_32BIT:
      resampledSize = size / 2;
      break;
    case C.ENCODING_PCM_16BIT:
    case C.ENCODING_PCM_FLOAT:
    case C.ENCODING_PCM_A_LAW:
    case C.ENCODING_PCM_MU_LAW:
    case C.ENCODING_INVALID:
    case Format.NO_VALUE:
    default:
      throw new IllegalStateException();
  }

  // Resample the little endian input and update the input/output buffers.
  ByteBuffer buffer = replaceOutputBuffer(resampledSize);
  switch (encoding) {
    case C.ENCODING_PCM_8BIT:
      // 8->16 bit resampling. Shift each byte from [0, 256) to [-128, 128) and scale up.
      for (int i = position; i < limit; i++) {
        buffer.put((byte) 0);
        buffer.put((byte) ((inputBuffer.get(i) & 0xFF) - 128));
      }
      break;
    case C.ENCODING_PCM_24BIT:
      // 24->16 bit resampling. Drop the least significant byte.
      for (int i = position; i < limit; i += 3) {
        buffer.put(inputBuffer.get(i + 1));
        buffer.put(inputBuffer.get(i + 2));
      }
      break;
    case C.ENCODING_PCM_32BIT:
      // 32->16 bit resampling. Drop the two least significant bytes.
      for (int i = position; i < limit; i += 4) {
        buffer.put(inputBuffer.get(i + 2));
        buffer.put(inputBuffer.get(i + 3));
      }
      break;
    case C.ENCODING_PCM_16BIT:
    case C.ENCODING_PCM_FLOAT:
    case C.ENCODING_PCM_A_LAW:
    case C.ENCODING_PCM_MU_LAW:
    case C.ENCODING_INVALID:
    case Format.NO_VALUE:
    default:
      // Never happens.
      throw new IllegalStateException();
  }
  inputBuffer.position(inputBuffer.limit());
  buffer.flip();
}
 

@Override
public void queueInput(ByteBuffer inputBuffer) {
  // Prepare the output buffer.
  int position = inputBuffer.position();
  int limit = inputBuffer.limit();
  int size = limit - position;
  int resampledSize;
  switch (encoding) {
    case C.ENCODING_PCM_8BIT:
      resampledSize = size * 2;
      break;
    case C.ENCODING_PCM_24BIT:
      resampledSize = (size / 3) * 2;
      break;
    case C.ENCODING_PCM_32BIT:
      resampledSize = size / 2;
      break;
    case C.ENCODING_PCM_16BIT:
    case C.ENCODING_PCM_FLOAT:
    case C.ENCODING_PCM_A_LAW:
    case C.ENCODING_PCM_MU_LAW:
    case C.ENCODING_INVALID:
    case Format.NO_VALUE:
    default:
      throw new IllegalStateException();
  }

  // Resample the little endian input and update the input/output buffers.
  ByteBuffer buffer = replaceOutputBuffer(resampledSize);
  switch (encoding) {
    case C.ENCODING_PCM_8BIT:
      // 8->16 bit resampling. Shift each byte from [0, 256) to [-128, 128) and scale up.
      for (int i = position; i < limit; i++) {
        buffer.put((byte) 0);
        buffer.put((byte) ((inputBuffer.get(i) & 0xFF) - 128));
      }
      break;
    case C.ENCODING_PCM_24BIT:
      // 24->16 bit resampling. Drop the least significant byte.
      for (int i = position; i < limit; i += 3) {
        buffer.put(inputBuffer.get(i + 1));
        buffer.put(inputBuffer.get(i + 2));
      }
      break;
    case C.ENCODING_PCM_32BIT:
      // 32->16 bit resampling. Drop the two least significant bytes.
      for (int i = position; i < limit; i += 4) {
        buffer.put(inputBuffer.get(i + 2));
        buffer.put(inputBuffer.get(i + 3));
      }
      break;
    case C.ENCODING_PCM_16BIT:
    case C.ENCODING_PCM_FLOAT:
    case C.ENCODING_PCM_A_LAW:
    case C.ENCODING_PCM_MU_LAW:
    case C.ENCODING_INVALID:
    case Format.NO_VALUE:
    default:
      // Never happens.
      throw new IllegalStateException();
  }
  inputBuffer.position(inputBuffer.limit());
  buffer.flip();
}
 

@Override
public int getOutputEncoding() {
  return C.ENCODING_PCM_FLOAT;
}