com.sedmelluq.discord.lavaplayer.track.playback.MutableAudioFrame Java Examples

public static long consumeTrack(AudioPlayer player) throws Exception {
  ByteBuffer buffer = ByteBuffer.allocate(960 * 2 * 2);

  MutableAudioFrame frame = new MutableAudioFrame();
  frame.setBuffer(buffer);

  CRC32 crc = new CRC32();
  int count = 0;

  while (player.getPlayingTrack() != null && player.provide(frame, 10, TimeUnit.SECONDS)) {
    buffer.flip();
    crc.update(buffer.array(), buffer.position(), buffer.remaining());
    count++;
  }

  System.out.println("Consumed " + count + " samples");

  return crc.getValue();
}
 

public LocalSendHandler(LocalPlayerWrapper audioPlayer) {
    this.audioPlayer = audioPlayer.getPlayer();
    this.frame = new MutableAudioFrame();

    this.frameBuffer = ByteBuffer.allocate(DISCORD_OPUS.maximumChunkSize());
    this.opusBuffer = ByteBuffer.allocate(DISCORD_OPUS.maximumChunkSize());

    frame.setBuffer(frameBuffer);
    frame.setFormat(DISCORD_OPUS);
}
 

public AudioPlayerSendHandler(AudioPlayer audioPlayer) {
    this.audioPlayer = audioPlayer;
    if (ExtraRuntimeOptions.DISABLE_NON_ALLOCATING_BUFFER) {
        this.frame = null;
    } else {
        this.frame = new MutableAudioFrame();
        frame.setFormat(StandardAudioDataFormats.DISCORD_OPUS);
        frame.setBuffer(ByteBuffer.allocate(StandardAudioDataFormats.DISCORD_OPUS.maximumChunkSize()));
    }
}
 

/**
 * @param audioPlayer Audio player to wrap.
 */
public AudioPlayerSendHandler(AudioPlayer audioPlayer) {
  this.audioPlayer = audioPlayer;
  this.buffer = ByteBuffer.allocate(1024);
  this.frame = new MutableAudioFrame();
  this.frame.setBuffer(buffer);
}
 

/**
 * @param context Processing context to determine the destination buffer from.
 * @param encoder Encoder to encode the chunk with.
 */
public BufferingPostProcessor(AudioProcessingContext context, AudioChunkEncoder encoder) {
  this.encoder = encoder;
  this.context = context;
  this.offeredFrame = new MutableAudioFrame();
  this.outputBuffer = ByteBuffer.allocateDirect(context.outputFormat.maximumChunkSize());

  offeredFrame.setFormat(context.outputFormat);
}
 

@Override
public boolean provide(MutableAudioFrame targetFrame, long timeout, TimeUnit unit)
    throws TimeoutException, InterruptedException {

  if (frameBuffer.provide(targetFrame, timeout, unit)) {
    processProvidedFrame(targetFrame);
    return true;
  }

  return true;
}
 

@Override
public boolean provide(MutableAudioFrame targetFrame) {
  if (frameBuffer.provide(targetFrame)) {
    processProvidedFrame(targetFrame);
    return true;
  }

  return true;
}
 

/**
 * @param context Configuration and output information for processing
 * @param inputFrequency Sample rate of the opus track
 * @param inputChannels Number of channels in the opus track
 */
public OpusPacketRouter(AudioProcessingContext context, int inputFrequency, int inputChannels) {
  this.context = context;
  this.inputFrequency = inputFrequency;
  this.inputChannels = inputChannels;
  this.headerBytes = new byte[2];
  this.offeredFrame = new MutableAudioFrame();
  this.lastFrameSize = 0;

  offeredFrame.setVolume(100);
  offeredFrame.setFormat(context.outputFormat);
}
 

@Override
public boolean provide(MutableAudioFrame targetFrame, long timeout, TimeUnit unit)
    throws TimeoutException, InterruptedException {

  InternalAudioTrack track;

  lastRequestTime = System.currentTimeMillis();

  if (timeout == 0 && paused.get()) {
    return false;
  }

  while ((track = activeTrack) != null) {
    if (timeout > 0 ? track.provide(targetFrame, timeout, unit) : track.provide(targetFrame)) {
      lastReceiveTime = System.nanoTime();
      shadowTrack = null;

      if (targetFrame.isTerminator()) {
        handleTerminator(track);
        continue;
      }

      return true;
    } else if (timeout == 0) {
      checkStuck(track);
      return provideShadowFrame(targetFrame);
    } else {
      return false;
    }
  }

  return false;
}
 

@Override
public boolean provide(MutableAudioFrame targetFrame) {
  try {
    return provide(targetFrame, 0, TimeUnit.MILLISECONDS);
  } catch (TimeoutException | InterruptedException e) {
    ExceptionTools.keepInterrupted(e);
    throw new RuntimeException(e);
  }
}
 

private boolean provideShadowFrame(MutableAudioFrame targetFrame) {
  InternalAudioTrack shadow = shadowTrack;

  if (shadow != null && shadow.provide(targetFrame)) {
    if (targetFrame.isTerminator()) {
      shadowTrack = null;
      return false;
    }

    return true;
  }

  return false;
}
 

@Override
public boolean provide(MutableAudioFrame targetFrame, long timeout, TimeUnit unit) throws TimeoutException,
    InterruptedException {

  synchronized (lock) {
    if (streamCursor != null) {
      throw new UnsupportedOperationException();
    }

    return fallback.provide(targetFrame, timeout, unit);
  }
}
 

@Override
public boolean provide(MutableAudioFrame targetFrame) {
  synchronized (lock) {
    if (streamCursor != null) {
      throw new UnsupportedOperationException();
    }

    return fallback.provide(targetFrame);
  }
}
 

@Override
public boolean provide(MutableAudioFrame targetFrame) {
  return getActiveExecutor().provide(targetFrame);
}
 

@Override
public boolean provide(MutableAudioFrame targetFrame, long timeout, TimeUnit unit)
    throws TimeoutException, InterruptedException {

  return getActiveExecutor().provide(targetFrame, timeout, unit);
}
 

AudioPlayerSenderHandler(IPlayer audioPlayer) {
    this.audioPlayer = (LavaplayerPlayerWrapper) audioPlayer;
    this.buffer = ByteBuffer.allocate(1024);
    this.frame = new MutableAudioFrame();
    this.frame.setBuffer(buffer);
}
 

public AudioPlayerSendHandler(AudioPlayer audioPlayer) {
  this.audioPlayer = audioPlayer;
  this.buffer = ByteBuffer.allocate(1024);
  this.frame = new MutableAudioFrame();
  this.frame.setBuffer(buffer);
}
 

public LavaplayerAudioProvider(AudioPlayer audioPlayer) {
    super(ByteBuffer.allocate(StandardAudioDataFormats.DISCORD_OPUS.maximumChunkSize()));
    this.audioPlayer = audioPlayer;
    this.frame = new MutableAudioFrame();
    this.frame.setBuffer(this.getBuffer());
}
 

public boolean provide(MutableAudioFrame targetFrame) {
    return player.provide(targetFrame);
}