Chords/src/main/java/moe/nekojimi/chords/MusicHandler.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package moe.nekojimi.chords;

import java.io.Closeable;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.LinkedList;
import java.util.Queue;
import java.util.function.Consumer;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.UnsupportedAudioFileException;
import net.dv8tion.jda.api.audio.AudioSendHandler;
import org.apache.commons.io.input.buffer.CircularByteBuffer;

/**
 *
 * @author jimj316
 */
public class MusicHandler implements AudioSendHandler, Closeable, Consumer<Song>
{

    private static final int DESIRED_BUFFER_SIZE = 3840 * 500;

    private final LinkedList<Song> songQueue = new LinkedList<>();
    private Song currentSong;
    private AudioInputStream din = null;
//    private final Queue<byte[]> queue = new ConcurrentLinkedQueue<>();
    private final CircularByteBuffer audioBuffer = new CircularByteBuffer(3840 * 1024);
    private boolean playing = true;
    private int byteCount;

    private boolean arrayErr = false;
    private Consumer<Song> nowPlayingConsumer;

    public void setNowPlayingConsumer(Consumer<Song> nowPlayingConsumer)
    {
        this.nowPlayingConsumer = nowPlayingConsumer;
    }

    public MusicHandler()
    {
    }

    public void addSong(Song song)
    {
        System.out.println("Song added to queue: " + song.getLocation().getAbsolutePath());
        songQueue.add(song);
        if (!canProvide() && playing)
            nextSong();
    }

    public boolean removeSong(int i)
    {
        try
        {
            songQueue.remove(i);
            return true;
        } catch (ArrayIndexOutOfBoundsException ex)
        {
            return false;
        }
    }

    public boolean removeSong(Song song)
    {
        return songQueue.remove(song);
    }

    public boolean restartSong()
    {
        songQueue.addFirst(currentSong);
        currentSong = null;
        return nextSong(true);
    }

    private boolean nextSong()
    {
        return nextSong(false);
    }

    public boolean nextSong(boolean immediate)
    {
        if (immediate)
            audioBuffer.clear();

        AudioInputStream in = null;
        try
        {
            if (din != null)
            {
                din.close();
                din = null;
            }
            if (currentSong != null)
            {
                if (!currentSong.isKept())
                    currentSong.delete();
                currentSong = null;
            }
            currentSong = songQueue.poll();
            if (currentSong == null)
                return false;
            System.out.println("Playing song " + currentSong.getLocation().getAbsolutePath());
            if (nowPlayingConsumer != null)
                nowPlayingConsumer.accept(currentSong);
            arrayErr = false;
            in = AudioSystem.getAudioInputStream(currentSong.getLocation());
            AudioFormat decodedFormat = AudioSendHandler.INPUT_FORMAT;
            din = AudioSystem.getAudioInputStream(decodedFormat, in);
            byteCount = 3840;
            fillBuffer(false);
            System.out.println("Queue filled to " + audioBuffer.getCurrentNumberOfBytes());
            return true;
        } catch (UnsupportedAudioFileException | IOException ex)
        {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        } finally
        {
        }
        return false;
    }

    public boolean isPlaying()
    {
        return playing;
    }

    public void setPlaying(boolean playing)
    {
        if (!this.playing && playing)
            nextSong();
        this.playing = playing;
    }

    @Override
    public boolean canProvide()
    {
        // If we have something in our buffer we can provide it to the send system
        return audioBuffer.getCurrentNumberOfBytes() > byteCount && playing;
    }

    @Override
    public ByteBuffer provide20MsAudio()
    {
        fillBuffer(true);
        byte[] data = new byte[byteCount];
        audioBuffer.read(data, 0, data.length);
//        byte[] data = queue.poll();
        return ByteBuffer.wrap(data); // Wrap this in a java.nio.ByteBuffer
    }

    private void fillBuffer(boolean canSkip)
    {
        // use what we have in our buffer to send audio as PCM
        while (audioBuffer.getCurrentNumberOfBytes() < DESIRED_BUFFER_SIZE)
            if (!readData())
                if (!canSkip || !nextSong())
                    break;
    }

    private boolean readData()
    {
        if (din == null)
            return false;
        try
        {
            //				if (din.available() == 0)
            //					return false;
            int bytesToRead = DESIRED_BUFFER_SIZE - audioBuffer.getCurrentNumberOfBytes();
            int space = audioBuffer.getSpace();
            if (din.available() > 0 && din.available() < bytesToRead)
                bytesToRead = din.available();
            if (bytesToRead > space)
                bytesToRead = space;
            if (bytesToRead == 0)
                return false;
            byte[] bytes = new byte[bytesToRead];
            //				byte[] bytes = din.readNBytes(bytesToRead);
            int read = din.read(bytes);
//            System.out.println("Wanted: " + byteCount + " Space:" + space + " Available: " + din.available() + " To read: " + bytesToRead + " Read: " + read);
            if (read < 0)
                return false;
//            queue.add(bytes);

            audioBuffer.add(bytes, 0, read);
        } catch (IOException ex)
        {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            return false;
        } catch (ArrayIndexOutOfBoundsException ex)
        {
            if (!arrayErr)
                arrayErr = true;
            else
            {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
                return false;
            }
        }
        return true;
    }

    public Queue<Song> getSongQueue()
    {
        return songQueue;
    }

    public Song getCurrentSong()
    {
        return currentSong;
    }

    @Override
    public boolean isOpus()
    {
        return false; //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public void close() throws IOException
    {
        din.close();
    }

    @Override
    public void accept(Song t)
    {
        addSong(t);
    }


}