import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
@Override
public TrackFrameDataMessage decode(DataInput in, int version) throws IOException {
  long executorId = in.readLong();
  int frameCount = in.readInt();

  List<AudioFrame> frames = new ArrayList<>(frameCount);

  for (int i = 0; i < frameCount; i++) {
    long timecode = in.readLong();
    byte[] data = new byte[in.readInt()];
    in.readFully(data);

    frames.add(new AudioFrame(timecode, data, in.readInt(), null));
  }

  return new TrackFrameDataMessage(executorId, frames, in.readBoolean(), in.readLong());
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
private void handleTrackFrameData(TrackFrameDataMessage message) throws Exception {
  RemoteAudioTrackExecutor executor = playingTracks.get(message.executorId);

  if (executor != null) {
    if (message.seekedPosition >= 0) {
      executor.clearSeek(message.seekedPosition);
    }

    AudioFrameBuffer buffer = executor.getAudioBuffer();
    executor.receivedData();

    AudioDataFormat format = executor.getConfiguration().getOutputFormat();

    for (AudioFrame frame : message.frames) {
      buffer.consume(new AudioFrame(frame.timecode, frame.data, frame.volume, format));
    }

    if (message.finished) {
      buffer.setTerminateOnEmpty();
      trackEnded(executor, false);
    }
  }
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
private void tick() throws InterruptedException {
    if(getAverageBufferSize() > 100) {
        //Buffers have plenty to go on
        return;
    }

    AudioFrame provided = player.provide();

    if(subscribers.isEmpty()) {
        // ¯\_(ツ)_/¯
        return;
    }

    // Make sure we reconnect if we lose connection
    if(player.getPlayingTrack() == null) {
        log.info("Track was somehow skipped. Trying to reload the stream...");
        player.playTrack(new AudioLoader().loadSync(streamIdentifier));
        log.info("Loaded new track: " + player.getPlayingTrack().getInfo().title);
    }

    ArrayList<Subscriber> toUnsubscribe = new ArrayList<>();

    if(provided != null) {
        subscribers.forEach(sub -> {
            if(sub.size() > 50 * 5) {
                //Do we have 5 seconds of audio? If so let's unsub
                toUnsubscribe.add(sub);
                log.warn("Unsubscribed stream for having an abnormally long buffer");
            } else {
                sub.feed(provided);
            }
        });
    }

    toUnsubscribe.forEach(Subscriber::unsubscribe);
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
private AudioFrame provideShadowFrame() {
  InternalAudioTrack shadow = shadowTrack;
  AudioFrame frame = null;

  if (shadow != null) {
    frame = shadow.provide();

    if (frame != null && frame.isTerminator()) {
      shadowTrack = null;
      frame = null;
    }
  }

  return frame;
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
@Override
public AudioFrame provide(long timeout, TimeUnit unit) throws TimeoutException, InterruptedException {
  AudioFrame frame = provideDirectly(timeout, unit);
  if (outputHook != null) {
    frame = outputHook.outgoingFrame(this, frame);
  }
  return frame;
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
/**
 * Provide an audio frame bypassing hooks.
 * @param timeout Specifies the maximum time to wait for data. Pass 0 for non-blocking mode.
 * @param unit Specifies the time unit of the maximum wait time.
 * @return An audio frame if available, otherwise null
 */
public AudioFrame provideDirectly(long timeout, TimeUnit unit) throws TimeoutException, InterruptedException {
  InternalAudioTrack track;

  lastRequestTime = System.currentTimeMillis();

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

  while ((track = activeTrack) != null) {
    AudioFrame frame = timeout > 0 ? track.provide(timeout, unit) : track.provide();

    if (frame != null) {
      lastReceiveTime = System.nanoTime();
      shadowTrack = null;

      if (frame.isTerminator()) {
        handleTerminator(track);
        continue;
      }
    } else if (timeout == 0) {
      checkStuck(track);

      frame = provideShadowFrame();
    }

    return frame;
  }

  return null;
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
private void attemptRetrieveFrame() throws TimeoutException, InterruptedException {
  AudioFrame frame = player.provide(timeout, TimeUnit.MILLISECONDS);

  if (frame != null) {
    if (!format.equals(frame.format)) {
      throw new IllegalStateException("Frame read from the player uses a different format than expected.");
    }

    addFrame(frame.data);
  } else if (!provideSilence) {
    Thread.sleep(10);
  }
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
@Override
public void encode(DataOutput out, TrackFrameDataMessage message) throws IOException {
  out.writeLong(message.executorId);
  out.writeInt(message.frames.size());

  for (AudioFrame frame : message.frames) {
    out.writeLong(frame.timecode);
    out.writeInt(frame.data.length);
    out.write(frame.data);
    out.writeInt(frame.volume);
  }

  out.writeBoolean(message.finished);
  out.writeLong(message.seekedPosition);
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
/**
 * @param executorId The ID for the track executor
 * @param frames Frames provided by the node
 * @param finished If these are the last frames for the track
 * @param seekedPosition The position of the seek that was performed
 */
public TrackFrameDataMessage(long executorId, List<AudioFrame> frames, boolean finished, long seekedPosition) {
  this.executorId = executorId;
  this.frames = frames;
  this.finished = finished;
  this.seekedPosition = seekedPosition;
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
private void processProvidedFrame(AudioFrame frame) {
  if (frame != null && !frame.isTerminator()) {
    lastFrameTimecode.set(frame.timecode);

    if (pendingSeek.get() == NO_SEEK && !frameBuffer.hasClearOnInsert()) {
      markerTracker.checkPlaybackTimecode(frame.timecode);
    }
  }
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
@Override
public AudioFrame rebuild(AudioFrame frame) {
  if (frame.volume == newVolume) {
    return frame;
  }

  decoder.decode(frame.data, sampleBuffer);

  int targetVolume = newVolume;

  if (++frameIndex < 50) {
    targetVolume = (int) ((newVolume - frame.volume) * (frameIndex / 50.0) + frame.volume);
  }

  // Volume 0 is stored in the frame with volume 100 buffer
  if (targetVolume != 0) {
    volumeProcessor.applyVolume(frame.volume, targetVolume, sampleBuffer);
  }

  byte[] bytes = encoder.encode(sampleBuffer);

  // One frame per 20ms is consumed. To not spike the CPU usage, reencode only once per 5ms. By the time the buffer is
  // fully rebuilt, it is probably near to 3/4 its maximum size.
  try {
    Thread.sleep(5);
  } catch (InterruptedException e) {
    // Keep it interrupted, it will trip on the next interruptible operation
    Thread.currentThread().interrupt();
  }

  return new AudioFrame(frame.timecode, bytes, targetVolume, format);
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
@MessageHandler
private void handleTrackDataRequest(TrackFrameRequestMessage message, MessageOutput output) {
  List<AudioFrame> frames = new ArrayList<>();
  PlayingTrack track = tracks.get(message.executorId);
  boolean finished = false;

  if (track != null) {
    submitPendingMessages(track, output);

    track.lastFrameRequestTime = System.currentTimeMillis();
    track.volume.set(message.volume);

    if (message.seekPosition >= 0) {
      track.audioTrack.setPosition(message.seekPosition);
    }

    if (message.maximumFrames > 0) {
      track.lastNonZeroFrameRequestTime = track.lastFrameRequestTime;
    }

    finished = consumeFramesFromTrack(frames, track.audioTrack, message.maximumFrames);

    if (finished) {
      log.info("Clearing ended track {} (context {})", track.audioTrack.getIdentifier(), message.executorId);
      tracks.remove(message.executorId);
    }
  }

  output.send(new TrackFrameDataMessage(message.executorId, frames, finished, message.seekPosition));
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
private boolean consumeFramesFromTrack(List<AudioFrame> frames, InternalAudioTrack audioTrack, int maximumFrames) {
  AudioFrame frame;

  while (frames.size() < maximumFrames && (frame = audioTrack.provide()) != null) {
    if (frame.isTerminator()) {
      return true;
    } else {
      frames.add(frame);
    }
  }

  return false;
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
void feed(AudioFrame frame) {
    buffer.add(frame);
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
public AudioFrame provide() {
    return buffer.poll();
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
public AudioFrame provide() {
    return player.provide();
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
@Override
public AudioFrame provide() {
  return getActiveExecutor().provide();
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
private void passThrough(ByteBuffer buffer) throws InterruptedException {
  byte[] bytes = new byte[buffer.remaining()];
  buffer.get(bytes);

  context.frameConsumer.consume(new AudioFrame(currentTimecode, bytes, 100, inputFormat));
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
@Override
public AudioFrame provide() {
  AudioFrame frame = frameBuffer.provide();
  processProvidedFrame(frame);
  return frame;
}
 

import com.sedmelluq.discord.lavaplayer.track.playback.AudioFrame; //导入依赖的package包/类
@Override
public void process(long timecode, ShortBuffer buffer) throws InterruptedException {
  context.frameConsumer.consume(new AudioFrame(timecode, encoder.encode(buffer), context.volumeLevel.get(), context.outputFormat));
}