Processor.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * JXClient is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff
 * Copyright (C) 2006-2017,2019-2023 Andreas Kirschbaum
 * Copyright (C) 2010-2012,2014-2018,2020-2023 Nicolas Weeger
 */
 
package com.realtime.crossfire.jxclient.sound;
 
import java.io.IOException;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioFormat.Encoding;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import javax.sound.sampled.UnsupportedAudioFileException;
import org.jetbrains.annotations.NotNull;
 
public class Processor implements Runnable {
 
    private static final float MIN_VALUE = 1.0E-3F;
 
    private static final float MAX_VOLUME = 0.2F;
 
    private static final float VOLUME_STEP_PER_SAMPLE = 1.00005F;
 
    @NotNull
    private final CharSequence name;
 
    @NotNull
    private final AudioFileLoader audioFileLoader;
 
    private int state;
 
    private float volume = MIN_VALUE;
 
    public Processor(@NotNull final CharSequence name, @NotNull final AudioFileLoader audioFileLoader) {
        this.name = name;
        this.audioFileLoader = audioFileLoader;
    }
 
    public void terminate(final boolean fadeOut) {
        state = fadeOut ? 2 : 4;
    }
 
    @Override
    public void run() {
        try {
            AudioInputStream audioInputStream = openAudioInputStream();
            try {
                final SourceDataLine sourceDataLine = AudioSystem.getSourceDataLine(audioInputStream.getFormat());
                final AudioFormat audioFormat = sourceDataLine.getFormat();
 
                if (audioFormat.getChannels() > 2) {
                    System.err.println("music "+name+": cannot handle more than two channels");
                    return;
                }
                if (audioFormat.getEncoding() != Encoding.PCM_SIGNED) {
                    System.err.println("music "+name+": encoding must be PCM_SIGNED");
                    return;
                }
                if (audioFormat.getSampleSizeInBits() != 16) {
                    System.err.println("music "+name+": sample size must be 16 bits");
                    return;
                }
                if (audioFormat.isBigEndian()) {
                    System.err.println("music "+name+": cannot handle little endian encoding");
                    return;
                }
 
                sourceDataLine.open(audioInputStream.getFormat());
                try {
                    sourceDataLine.start();
                    try {
                        final byte[] buf = new byte[8192];
                        while (state < 3 && !Thread.currentThread().isInterrupted()) {
                            int len = audioInputStream.read(buf, 0, buf.length);
                            if (len == -1) {
                                final AudioInputStream newAudioInputStream = openAudioInputStream();
                                if (!newAudioInputStream.getFormat().matches(audioInputStream.getFormat())) {
                                    newAudioInputStream.close();
                                    System.err.println("music "+name+": file format has changed");
                                    break;
                                }
                                final AudioInputStream oldAudioInputStream = audioInputStream;
                                audioInputStream = newAudioInputStream;
                                oldAudioInputStream.close();
                                len = audioInputStream.read(buf, 0, buf.length);
                                if (len == -1) {
                                    System.err.println("music "+name+": cannot re-read file");
                                    break;
                                }
                            }
 
                            for (int i = 0; i+3 < len && state < 3; i += 4) {
                                switch (state) {
                                case 0: // fade in
                                    volume *= VOLUME_STEP_PER_SAMPLE;
                                    if (volume >= 1.0F) {
                                        state = 1;
                                        volume = 1.0F;
                                    }
                                    break;
 
                                case 1: // play
                                    break;
 
                                case 2: // fade out
                                    volume /= VOLUME_STEP_PER_SAMPLE;
                                    if (volume <= MIN_VALUE) {
                                        state = 3;
                                        len = i;
                                    }
                                    break;
 
                                default:
                                    throw new AssertionError();
                                }
 
                                convertSample(buf, i);
                                convertSample(buf, i+2);
                            }
 
                            sourceDataLine.write(buf, 0, len);
                        }
                        if (state == 3) {
                            sourceDataLine.drain();
                        }
                    } finally {
                        sourceDataLine.stop();
                    }
                } finally {
                    sourceDataLine.close();
                }
            } finally {
                audioInputStream.close();
            }
        } catch (final IOException|LineUnavailableException|UnsupportedAudioFileException ex) {
            System.err.println("music "+name+": "+ex.getMessage());
        }
    }
 
    private void convertSample(final byte @NotNull [] buf, final int i) {
        final float value = (short)((buf[i]&0xFF)+(buf[i+1]&0xFF)*0x100)*volume*MAX_VOLUME;
        final short s = (short)value;
        if (s >= 0) {
            buf[i] = (byte)s;
            buf[i+1] = (byte)(s/0x100);
        } else {
            buf[i] = (byte)s;
            buf[i+1] = (byte)((s+0x10000)/0x100);
        }
    }
 
    @NotNull
    private AudioInputStream openAudioInputStream() throws IOException, UnsupportedAudioFileException {
        final AudioInputStream rawInputStream = AudioSystem.getAudioInputStream(audioFileLoader.getInputStream(name));
        final AudioFormat baseFormat = rawInputStream.getFormat();
        final AudioFormat decodedFormat = new AudioFormat(Encoding.PCM_SIGNED, baseFormat.getSampleRate(), 16, baseFormat.getChannels(), baseFormat.getChannels()*2, baseFormat.getSampleRate(), false);
        return AudioSystem.getAudioInputStream(decodedFormat, rawInputStream);
    }
 
}