com.sedmelluq.discord.lavaplayer.player.DefaultAudioPlayerManager Java Examples

public LocalMusicManager(Vertx vertx, MusicSettings settings, EventManager eventManager) {
    this.vertx = vertx;
    this.eventManager = eventManager;
    this.sourceManagers = new ArrayList<>();
    this.players = new HashMap<>();
    this.queues = new HashMap<>();
    this.pendingLeave = new HashMap<>();
    this.audioConnections = new HashMap<>();
    this.queueLimit = settings.queueLimit;

    playerManager = new DefaultAudioPlayerManager();
    playerManager.setFrameBufferDuration(300);
    playerManager.getConfiguration().setFilterHotSwapEnabled(true);
    playerManager.getConfiguration().setOpusEncodingQuality(10);
    playerManager.getConfiguration().setFrameBufferFactory(NonAllocatingAudioFrameBuffer::new);

    eventManager.registerEventHandler(DiscordEvent.CHANNEL_DELETE, this::onChannelDelete);
    eventManager.registerEventHandler(DiscordEvent.GUILD_DELETE, this::onLeave);
    eventManager.registerEventHandler(DiscordEvent.VOICE_STATE_UPDATE, this::onVoiceStateUpdate);

    LocalPlayerWrapper.configuration = playerManager.getConfiguration();
    LocalPlayerWrapper.settings = settings;
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
    String streamName = getChannelIdentifierFromUrl(reference.identifier);
    if (streamName == null) {
        return null;
    }

    JsonBrowser channelInfo = fetchChannelInfo(streamName);

    if (channelInfo == null) {
        return AudioReference.NO_TRACK;
    } else {
        final String displayName = channelInfo.get("display_name").text();
        final String status = channelInfo.get("status").text();

        return new TwitchStreamAudioTrack(new AudioTrackInfo(
                status,
                displayName,
                Long.MAX_VALUE,
                reference.identifier,
                true,
                reference.identifier
        ), this);
    }
}
 

private void init() {
    loadProperties();
    initializeDiscordBot();
    updateFileList();
    getUsers();

    playerManager = new DefaultAudioPlayerManager();
    playerManager.registerSourceManager(new LocalAudioSourceManager());
    playerManager.registerSourceManager(new YoutubeAudioSourceManager());
    playerManager.registerSourceManager(new VimeoAudioSourceManager());
    playerManager.registerSourceManager(new SoundCloudAudioSourceManager());

    musicPlayer = playerManager.createPlayer();
    musicPlayer.setVolume(75);

    leaveAfterPlayback = Boolean.parseBoolean(appProperties.getProperty("leaveAfterPlayback"));

    ConnectorNativeLibLoader.loadConnectorLibrary();

    initialized = true;
}
 

public BotApplicationManager() {
  guildContexts = new HashMap<>();
  controllerManager = new BotControllerManager();

  controllerManager.registerController(new MusicController.Factory());

  playerManager = new DefaultAudioPlayerManager();
  //playerManager.useRemoteNodes("localhost:8080");
  playerManager.getConfiguration().setResamplingQuality(AudioConfiguration.ResamplingQuality.LOW);
  playerManager.registerSourceManager(new YoutubeAudioSourceManager());
  playerManager.registerSourceManager(SoundCloudAudioSourceManager.createDefault());
  playerManager.registerSourceManager(new BandcampAudioSourceManager());
  playerManager.registerSourceManager(new VimeoAudioSourceManager());
  playerManager.registerSourceManager(new TwitchStreamAudioSourceManager());
  playerManager.registerSourceManager(new BeamAudioSourceManager());
  playerManager.registerSourceManager(new HttpAudioSourceManager());
  playerManager.registerSourceManager(new LocalAudioSourceManager());

  executorService = Executors.newScheduledThreadPool(1, new DaemonThreadFactory("bot"));
}
 

private MusicManager() {
    this.audioPlayerManager = new DefaultAudioPlayerManager();
    this.audioPlayerManager.getConfiguration().setFrameBufferFactory(NonAllocatingAudioFrameBuffer::new);
    this.audioPlayerManager.getConfiguration().setFilterHotSwapEnabled(true);
    AudioSourceManagers.registerRemoteSources(this.audioPlayerManager);
    this.guildMusics = new ConcurrentHashMap<>();
    this.guildJoining = new ConcurrentHashMap<>();

    //IPv6 rotation config
    final String ipv6Block = CredentialManager.getInstance().get(Credential.IPV6_BLOCK);
    if (!Config.IS_SNAPSHOT && ipv6Block != null && !ipv6Block.isBlank()) {
        LOGGER.info("Configuring YouTube IP rotator");
        final List<IpBlock> blocks = Collections.singletonList(new Ipv6Block(ipv6Block));
        final AbstractRoutePlanner planner = new RotatingNanoIpRoutePlanner(blocks);

        new YoutubeIpRotatorSetup(planner)
                .forSource(this.audioPlayerManager.source(YoutubeAudioSourceManager.class))
                .setup();
    }
}
 

public static void main(String[] args) throws LineUnavailableException, IOException {
  AudioPlayerManager manager = new DefaultAudioPlayerManager();
  AudioSourceManagers.registerRemoteSources(manager);
  manager.getConfiguration().setOutputFormat(COMMON_PCM_S16_BE);

  AudioPlayer player = manager.createPlayer();

  manager.loadItem("ytsearch: epic soundtracks", new FunctionalResultHandler(null, playlist -> {
    player.playTrack(playlist.getTracks().get(0));
  }, null, null));

  AudioDataFormat format = manager.getConfiguration().getOutputFormat();
  AudioInputStream stream = AudioPlayerInputStream.createStream(player, format, 10000L, false);
  SourceDataLine.Info info = new DataLine.Info(SourceDataLine.class, stream.getFormat());
  SourceDataLine line = (SourceDataLine) AudioSystem.getLine(info);

  line.open(stream.getFormat());
  line.start();

  byte[] buffer = new byte[COMMON_PCM_S16_BE.maximumChunkSize()];
  int chunkSize;

  while ((chunkSize = stream.read(buffer)) >= 0) {
    line.write(buffer, 0, chunkSize);
  }
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
  AudioItem track = processAsSingleTrack(reference);

  if (track == null) {
    track = playlistLoader.load(reference.identifier, httpInterfaceManager, this::buildTrackFromInfo);
  }

  if (track == null) {
    track = processAsLikedTracks(reference);
  }

  if (track == null && allowSearch) {
    track = processAsSearchQuery(reference);
  }

  return track;
}
 

/**
 * @param playerManager Audio player manager
 * @param nodeAddress Address of this node
 * @param scheduledExecutor Scheduler to use to schedule reconnects
 * @param httpInterfaceManager HTTP interface manager to use for communicating with node
 * @param abandonedTrackManager Abandoned track manager, where the playing tracks are sent if node goes offline
 */
public RemoteNodeProcessor(DefaultAudioPlayerManager playerManager, String nodeAddress,
                           ScheduledThreadPoolExecutor scheduledExecutor, HttpInterfaceManager httpInterfaceManager,
                           AbandonedTrackManager abandonedTrackManager) {

  this.playerManager = playerManager;
  this.nodeAddress = nodeAddress;
  this.scheduledExecutor = scheduledExecutor;
  this.httpInterfaceManager = httpInterfaceManager;
  this.abandonedTrackManager = abandonedTrackManager;
  queuedMessages = new LinkedBlockingQueue<>();
  playingTracks = new ConcurrentHashMap<>();
  mapper = new RemoteMessageMapper();
  threadRunning = new AtomicBoolean();
  connectionState = new AtomicInteger(ConnectionState.OFFLINE.id());
  tickHistory = new ArrayDeque<>(NODE_REQUEST_HISTORY);
  closed = false;
}
 

private Main() {
  this.musicManagers = new ConcurrentHashMap<>();

  this.playerManager = new DefaultAudioPlayerManager();
  AudioSourceManagers.registerRemoteSources(playerManager);
  AudioSourceManagers.registerLocalSource(playerManager);
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
  AudioReference httpReference = getAsHttpReference(reference);
  if (httpReference == null) {
    return null;
  }

  if (httpReference.containerDescriptor != null) {
    return createTrack(AudioTrackInfoBuilder.create(reference, null).build(), httpReference.containerDescriptor);
  } else {
    return handleLoadResult(detectContainer(httpReference));
  }
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
  String streamName = getChannelNameFromUrl(reference.identifier);
  if (streamName == null) {
    return null;
  }

  JsonBrowser channelInfo = fetchStreamChannelInfo(streamName);

  if (channelInfo == null) {
    return AudioReference.NO_TRACK;
  } else {
    String displayName = channelInfo.get("name").text();
    String id = getPlayedStreamId(channelInfo);

    if (displayName == null || id == null) {
      throw new IllegalStateException("Expected id and name fields from Beam channel info.");
    }

    return new BeamAudioTrack(new AudioTrackInfo(
        displayName,
        streamName,
        Units.DURATION_MS_UNKNOWN,
        id + "|" + streamName + "|" + reference.identifier,
        true,
        "https://beam.pro/" + streamName
    ), this);
  }
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
  try {
    return loadItemOnce(reference);
  } catch (FriendlyException exception) {
    // In case of a connection reset exception, try once more.
    if (HttpClientTools.isRetriableNetworkException(exception.getCause())) {
      return loadItemOnce(reference);
    } else {
      throw exception;
    }
  }
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
  final Matcher m = GETYARN_REGEX.matcher(reference.identifier);

  if (!m.matches()) {
    return null;
  }

  return extractVideoUrlFromPage(reference);
}
 

/**
 * @param playerManager Audio player manager
 */
public RemoteNodeManager(DefaultAudioPlayerManager playerManager) {
  this.playerManager = playerManager;
  this.httpInterfaceManager = RemoteNodeProcessor.createHttpInterfaceManager();
  this.processors = new ArrayList<>();
  this.abandonedTrackManager = new AbandonedTrackManager();
  this.enabled = new AtomicBoolean();
  this.lock = new Object();
  this.activeProcessors = new ArrayList<>();
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
  if (!trackUrlPattern.matcher(reference.identifier).matches()) {
    return null;
  }

  try (HttpInterface httpInterface = httpInterfaceManager.getInterface()) {
    return loadFromTrackPage(httpInterface, reference.identifier);
  } catch (IOException e) {
    throw new FriendlyException("Loading Vimeo track information failed.", SUSPICIOUS, e);
  }
}
 

@Autowired
public PlayingTrackManager(StatisticsManager statisticsManager) {
  this.statisticsManager = statisticsManager;
  manager = new DefaultAudioPlayerManager();
  tracks = new ConcurrentHashMap<>();

  manager.setUseSeekGhosting(false);
  AudioSourceManagers.registerRemoteSources(manager);
}
 

private Main() {
  this.musicManagers = new HashMap<>();

  this.playerManager = new DefaultAudioPlayerManager();
  AudioSourceManagers.registerRemoteSources(playerManager);
  AudioSourceManagers.registerLocalSource(playerManager);
}
 

public PlayerControl()
{
    java.util.logging.Logger.getLogger("org.apache.http.client.protocol.ResponseProcessCookies").setLevel(Level.OFF);

    this.playerManager = new DefaultAudioPlayerManager();
    playerManager.registerSourceManager(new YoutubeAudioSourceManager());
    playerManager.registerSourceManager(new SoundCloudAudioSourceManager());
    playerManager.registerSourceManager(new BandcampAudioSourceManager());
    playerManager.registerSourceManager(new VimeoAudioSourceManager());
    playerManager.registerSourceManager(new TwitchStreamAudioSourceManager());
    playerManager.registerSourceManager(new HttpAudioSourceManager());
    playerManager.registerSourceManager(new LocalAudioSourceManager());

    musicManagers = new HashMap<String, GuildMusicManager>();
}
 

@PostConstruct
public void init() {
    try {
        sourceMethod = DefaultAudioPlayerManager.class.getDeclaredMethod("checkSourcesForItem",
                AudioReference.class, AudioLoadResultHandler.class, boolean[].class);
        sourceMethod.setAccessible(true);
    } catch (NoSuchMethodException e) {
        log.warn("Could not get LavaPlayer init method");
    }
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
    try {
        return loadItemOnce(reference);
    } catch (FriendlyException exception) {
        // In case of a connection reset exception, try once more.
        if (HttpClientTools.isRetriableNetworkException(exception.getCause())) {
            return loadItemOnce(reference);
        } else {
            throw exception;
        }
    }
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
    refreshToken();
    if (accessToken == null)
        return null;

    AudioItem item;
    for (Function<AudioReference, AudioItem> loader : loaders) {
        if ((item = loader.apply(reference)) != null)
            return item;
    }
    return null;
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
    Matcher trackMatcher = trackUrlPattern.matcher(reference.identifier);

    if (trackMatcher.matches()) {
        return loadTrack(trackMatcher.group(1));
    }

    return null;
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
    AudioReference httpReference = getAsHttpReference(reference);
    if (httpReference == null) {
        return null;
    }

    if (httpReference.containerDescriptor != null) {
        return createTrack(AudioTrackInfoBuilder.create(reference, null).build(), httpReference.containerDescriptor);
    } else {
        return handleLoadResult(detectContainer(httpReference));
    }
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
    try {
        URI uri = new URI(reference.identifier);
        if (allowedHosts.contains(uri.getHost()) || StringUtils.endsWithAny(uri.getHost(), allowedHighDomains)) {
            return super.loadItem(manager, reference);
        }
    } catch (URISyntaxException e) {
        // fall down
    }
    return null;
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
  Matcher trackMatcher = trackUrlPattern.matcher(reference.identifier);

  if (trackMatcher.matches()) {
    return loadTrack(trackMatcher.group(1));
  }

  return null;
}
 

@Override
@Transactional
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
    String uuid = extractUUID(reference.identifier);
    if (uuid == null) {
        return null;
    }
    Playlist playlist = playlistService.getPlaylist(uuid);
    if (playlist == null) {
        return null;
    }
    List<PlaylistItem> items = new ArrayList<>(playlist.getItems());
    if (CollectionUtils.isNotEmpty(items)) {
        List<AudioTrack> tracks = new ArrayList<>(items.size());
        items.forEach(e -> {
            try {
                AudioTrack track = getTracksFor(manager, e);
                if (track != null) {
                    tracks.add(track);
                }
            } catch (Exception ex) {
                // fall down and ignore it
            }
        });
        if (!tracks.isEmpty()) {
            storedPlaylistService.refreshStoredPlaylist(playlist, tracks);
            return new StoredPlaylist(playlist, tracks);
        }
    }
    onError(playlist, "discord.command.audio.playlist.notFound");
    return null;
}
 

private boolean checkSourcesForItem(DefaultAudioPlayerManager manager, AudioReference reference, AudioLoadResultHandler resultHandler) {
    if (sourceMethod == null) {
        return false;
    }
    try {
        Object result = sourceMethod.invoke(manager, reference, resultHandler, new boolean[1]);
        return Boolean.TRUE.equals(result);
    } catch (IllegalAccessException | InvocationTargetException e) {
        log.warn("Could not invoke checkSourcesForItem of LavaPlayer");
        return false;
    }
}
 

public Discord() {
	command = new Command();
	audioPlayerManager = new DefaultAudioPlayerManager();
	audioQueue = new AudioQueue();
	messageSender = new MessageSender();
	discordThread = new DiscordThread();
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
  File file = new File(reference.identifier);

  if (file.exists() && file.isFile() && file.canRead()) {
    return handleLoadResult(detectContainerForFile(reference, file));
  } else {
    return null;
  }
}
 

@Override
public AudioItem loadItem(DefaultAudioPlayerManager manager, AudioReference reference) {
  if (trackUrlPattern.matcher(reference.identifier).matches()) {
    return loadTrack(reference.identifier);
  } else if (albumUrlPattern.matcher(reference.identifier).matches()) {
    return loadAlbum(reference.identifier);
  }
  return null;
}