SidTuneInfoDetails.java

package ui.common.util;

import libsidplay.sidtune.SidTune;
import libsidplay.sidtune.SidTuneError;
import libsidplay.sidtune.SidTuneInfo;

import java.io.File;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.function.Function;
import java.util.function.ToDoubleFunction;

/**
 * Additional PSIDv5/RSIDv5 info rows shared by the desktop, REST and TeaVM players.
 */
public final class SidTuneInfoDetails {

    public static final String BUNDLE = "ui.common.util.SidTuneInfoDetails";

    private static final String[] ADDRESS_STEPS = {
            "+$0020", "+$0040", "+$0080", "+$0100", "+$0020 / +$0060", "+$0020 / +$00E0", "+$0100 / +$0300"
    };
    private static final String[] PANNING_LAYOUTS = {"standard", "lcr", "centerFirst", "fullyCentered"};
    private static final String[] PANNING_MODES = {"direct", "reverse", "group", "spread"};

    private final boolean v5;
    private final Map<String, String> values = new LinkedHashMap<>();

    public SidTuneInfoDetails(SidTune tune, double databaseSongLength, double defaultSongLength,
                              Function<String, String> text) {
        v5 = tune != SidTune.RESET && tune.getPSidVersion() == 5;
        if (!v5) {
            return;
        }
        SidTuneInfo info = tune.getInfo();
        int multiSidConfig = info.getMultiSidConfig();
        int sidCount = multiSidConfig & 15;
        sidCount = sidCount == 0 ? 1 : sidCount;
        int mappedSidCount = info.getSIDCount();
        values.put("SidTuneInfo.sidCount", Integer.toString(sidCount));
        if (mappedSidCount != sidCount) {
            values.put("SidTuneInfo.mappedSidCount", Integer.toString(mappedSidCount));
        }
        values.put("SidTuneInfo.sidModel", info.getSIDModel(0).toString());
        if (sidCount > 1) {
            int config = multiSidConfig >> 4 & 15;
            values.put("SidTuneInfo.addressConfiguration", config + " (" + ADDRESS_STEPS[config] + ")");
            values.put("SidTuneInfo.sidAddressStart", address(info.getSIDChipBase(1)));
            int start = info.getSidAddressConfigStart();
            boolean customStart = (start >= 0x42 && start <= 0x7e || start >= 0xe0 && start <= 0xfe)
                    && (start & 1) == 0;
            values.put("SidTuneInfo.sidAddressStartSource", text.apply("SidTuneInfoValue."
                    + (customStart ? "custom" : "default")));
        }
        values.put("SidTuneInfo.panningLayout", text.apply("SidTuneInfoValue." + PANNING_LAYOUTS[info.getPanningLayout()]));
        values.put("SidTuneInfo.panningMode", text.apply("SidTuneInfoValue." + PANNING_MODES[info.getPanningMode()]));
        for (int sid = 0; sid < mappedSidCount; sid++) {
            float channel = info.getChannel(sid);
            values.put("SidTuneInfo.sidChip." + (sid + 1), address(info.getSIDChipBase(sid))
                    + " / " + (channel == 0 ? "L" : channel == 1 ? "R" : "C"));
        }
        values.put("SidTuneInfo.fmOpl", text.apply("SidTuneInfoValue." + (info.isFmOpl() ? "required" : "notRequired")));
        if (info.isFmOpl()) {
            values.put("SidTuneInfo.fmOplDevice", "SFX Sound Expander / FM-YAM");
            values.put("SidTuneInfo.fmOplAddressRange", "$DF00-$DFFF");
        }
        values.put("SidTuneInfo.songLengthsIncluded", text.apply("SidTuneInfoValue."
                + (info.isSongLengthsIncluded() ? "included" : "absent")));
        if (info.isSongLengthsIncluded()) {
            for (int song = 1; song <= info.getSongs(); song++) {
                values.put("SidTuneInfo.embeddedSongLength." + song, length(info.getSongLength(song)));
            }
        }
        values.put("SidTuneInfo.selectedSong", Integer.toString(info.getSelectedSong()));
        long embeddedLength = info.isSongLengthsIncluded() ? info.getSongLength() : 0;
        String source;
        double playbackLength;
        if (embeddedLength > 0) {
            source = "embedded";
            playbackLength = embeddedLength / 1000.;
        } else if (databaseSongLength > 0) {
            source = "database";
            playbackLength = databaseSongLength;
        } else {
            source = "configuredDefault";
            playbackLength = defaultSongLength;
        }
        values.put("SidTuneInfo.playbackLength", playbackLength > 0 ? length(Math.round(playbackLength * 1000))
                : text.apply("SidTuneInfoValue.unlimited"));
        values.put("SidTuneInfo.lengthSource", text.apply("SidTuneInfoValue." + source));
    }

    public static SidTuneInfoDetails forFile(SidTune tune, File file, ToDoubleFunction<SidTune> databaseLength,
                                             double defaultSongLength, Function<String, String> text) {
        if (tune == SidTune.RESET || tune.getPSidVersion() != 5 || databaseLength == null
                || tune.getInfo().isSongLengthsIncluded() && tune.getInfo().getSongLength() > 0) {
            return new SidTuneInfoDetails(tune, 0, defaultSongLength, text);
        }
        SidTune lengthTune = tune;
        if (tune.getInfo().getCurrentSong() == 0) {
            try {
                // SidDatabase requires a selected song. Use a separate tune to preserve the caller's selection.
                lengthTune = SidTune.load(file);
                lengthTune.getInfo().setSelectedSong(tune.getInfo().getSelectedSong());
            } catch (IOException | SidTuneError e) {
                throw new IllegalStateException("Cannot read SID song length", e);
            }
        }
        return new SidTuneInfoDetails(tune, databaseLength.applyAsDouble(lengthTune), defaultSongLength, text);
    }

    public Map<String, String> getValues() {
        return values;
    }

    public boolean replacesAttribute(String name) {
        return v5 && (name.equals("HVSCEntry.sidModel1") || name.equals("HVSCEntry.sidModel2")
                || name.equals("HVSCEntry.sidModel3") || name.equals("HVSCEntry.sidChipBase1")
                || name.equals("HVSCEntry.sidChipBase2") || name.equals("HVSCEntry.sidChipBase3"));
    }

    public static String localizeName(String name, Function<String, String> text) {
        int separator = name.lastIndexOf('.');
        String suffix = name.substring(separator + 1);
        return Character.isDigit(suffix.charAt(0))
                ? text.apply(name.substring(0, separator)).replace("{0}", suffix) : text.apply(name);
    }

    private static String address(int address) {
        return String.format(Locale.ROOT, "$%04X", address);
    }

    private static String length(long milliseconds) {
        return String.format(Locale.ROOT, "%02d:%02d.%03d", milliseconds / 60000,
                milliseconds / 1000 % 60, milliseconds % 1000);
    }
}