EpsonFX80.java

package libsidplay.components.printer.epson;

import libsidplay.components.printer.PrinterModel;
import libsidplay.components.printer.RasterPrinter;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * FX-80 ESC/P interpreter. The raster uses 240 horizontal and 216 vertical
 * dots/inch, preserving all four graphics densities and 1/216 inch feeds.
 * Text uses the bundled Commodore bitmap font, mapped to ASCII.
 */
public final class EpsonFX80 extends RasterPrinter {

    private static final int[] GRAPHICS_DPI = {60, 120, 120, 240, 80, 72, 90};

    private final byte[] charset;
    private final int[] parameters = new int[3];
    private final int[] graphicsModes = new int[4];
    private final List<Integer> horizontalTabs = new ArrayList<>();
    private final List<Integer> verticalTabs = new ArrayList<>();
    private final int[][] downloaded = new int[256][];

    private boolean escape, elite, condensed, emphasized, doubleStrike, italic, underline;
    private boolean doubleWidth, singleLineWidth, userDefined, ninePin;
    private int script, command, parameterCount, parametersNeeded, tabCommand, lastTab;
    private int lineSpacing, pageLength, pagePosition, bottomMargin, leftMargin, rightMargin;
    private int graphicsRemaining, graphicsByte, downloadCharacter, downloadIndex, downloadRemaining;
    private double graphicsPosition, graphicsStep;

    public EpsonFX80(byte[] charset) {
        super(PrinterModel.EPSON_FX80.getWidth());
        this.charset = charset;
        reset();
    }

    @Override
    public void reset() {
        super.reset();
        initialize();
        pagePosition = 0;
        Arrays.fill(downloaded, null);
    }

    private void initialize() {
        escape = elite = condensed = emphasized = doubleStrike = italic = underline = false;
        doubleWidth = singleLineWidth = userDefined = ninePin = false;
        script = command = parameterCount = parametersNeeded = tabCommand = 0;
        graphicsRemaining = downloadRemaining = 0;
        lineSpacing = 36;
        pageLength = 11 * 216;
        bottomMargin = leftMargin = 0;
        rightMargin = width;
        x = 0;
        horizontalTabs.clear();
        for (int column = 8; column < 80; column += 8) {
            horizontalTabs.add(column * 24);
        }
        verticalTabs.clear();
        graphicsModes[0] = 0;
        graphicsModes[1] = 1;
        graphicsModes[2] = 2;
        graphicsModes[3] = 3;
    }

    @Override
    public void put(byte data) {
        int c = data & 0xff;
        // Binary payloads take precedence over every text/control code.
        if (graphicsRemaining != 0) {
            printGraphics(c);
            return;
        }
        if (downloadRemaining != 0) {
            if (downloadIndex == 0) {
                downloaded[downloadCharacter] = new int[12];
            }
            downloaded[downloadCharacter][downloadIndex++] = c;
            if (downloadIndex == 12) {
                downloadIndex = 0;
                downloadCharacter++;
            }
            downloadRemaining--;
            return;
        }
        if (parametersNeeded != 0) {
            parameters[parameterCount++] = c;
            if (parameterCount == parametersNeeded) {
                parametersNeeded = 0;
                applyParameters();
            }
            return;
        }
        if (tabCommand != 0) {
            List<Integer> tabs = tabCommand == 'D' ? horizontalTabs : verticalTabs;
            if (c == 0 || c <= lastTab) {
                tabCommand = 0;
            } else {
                if (tabs.size() < (tabCommand == 'D' ? 32 : 16)) {
                    tabs.add(c * (tabCommand == 'D' ? characterWidth() : lineSpacing));
                }
                lastTab = c;
            }
            return;
        }
        if (escape) {
            escape = false;
            escapeCommand(c);
            return;
        }
        switch (c) {
            case 8:
                x = Math.max(leftMargin, x - characterWidth());
                break;
            case 9:
                for (int tab : horizontalTabs) {
                    if (tab > x && tab < rightMargin) {
                        x = tab;
                        break;
                    }
                }
                break;
            case 10:
                advance(lineSpacing);
                singleLineWidth = false;
                break;
            case 11:
                verticalTab();
                break;
            case 12:
                formFeed();
                break;
            case 13:
                x = leftMargin;
                singleLineWidth = false;
                break;
            case 14:
                singleLineWidth = true;
                break;
            case 15:
                condensed = true;
                break;
            case 18:
                condensed = false;
                break;
            case 20:
                singleLineWidth = false;
                break;
            case 24:
                super.reset();
                x = leftMargin;
                break;
            case 27:
                escape = true;
                break;
            default:
                if (c >= 32 && c != 127) {
                    printCharacter(c);
                }
                break;
        }
    }

    private void escapeCommand(int c) {
        switch (c) {
            case '@':
                initialize();
                return;
            case '0':
                lineSpacing = 27;
                return;
            case '1':
                lineSpacing = 21;
                return;
            case '2':
                lineSpacing = 36;
                return;
            case '4':
            case '5':
                italic = c == '4';
                return;
            case 'E':
            case 'F':
                emphasized = c == 'E';
                return;
            case 'G':
            case 'H':
                doubleStrike = c == 'G';
                return;
            case 'M':
            case 'P':
                elite = c == 'M';
                return;
            case 'O':
                bottomMargin = 0;
                return;
            case 'T':
                script = 0;
                return;
            case 14:
                singleLineWidth = true;
                return;
            case 15:
                condensed = true;
                return;
            case 'B':
            case 'D':
                tabCommand = c;
                lastTab = 0;
                (c == 'D' ? horizontalTabs : verticalTabs).clear();
                return;
            case '*':
            case '^':
            case '&':
            case ':':
                expect(c, 3);
                return;
            case 'K':
            case 'L':
            case 'Y':
            case 'Z':
            case '$':
            case '\\':
            case '?':
                expect(c, 2);
                return;
            case '!':
            case '-':
            case '3':
            case 'A':
            case 'J':
            case 'C':
            case 'N':
            case 'Q':
            case 'l':
            case 'S':
            case 'W':
            case '%':
            case 'R':
            case 'U':
            case 's':
            case 'p':
            case 'x':
            case 'i':
                expect(c, 1);
                return;
            default:
                // Unsupported one-byte commands have no printed representation.
                return;
        }
    }

    private void expect(int command, int count) {
        this.command = command;
        parameterCount = 0;
        parametersNeeded = count;
    }

    private void applyParameters() {
        int n = parameters[0];
        switch (command) {
            case '!':
                elite = (n & 1) != 0;
                condensed = (n & 4) != 0;
                emphasized = (n & 8) != 0;
                doubleStrike = (n & 16) != 0;
                doubleWidth = (n & 32) != 0;
                italic = (n & 64) != 0;
                underline = (n & 128) != 0;
                break;
            case '-':
                underline = enabled(n);
                break;
            case 'W':
                doubleWidth = enabled(n);
                break;
            case '%':
                userDefined = enabled(n);
                break;
            case 'S':
                script = (n & 1) == 0 ? -1 : 1;
                break;
            case '3':
                lineSpacing = n;
                break;
            case 'A':
                lineSpacing = n * 3;
                break;
            case 'J':
                advance(n);
                break;
            case 'C':
                if (n == 0) {
                    expect('c', 1);
                } else {
                    pageLength = Math.max(1, n * lineSpacing);
                    pagePosition = 0;
                }
                break;
            case 'c':
                if (n != 0) {
                    pageLength = n * 216;
                    pagePosition = 0;
                }
                break;
            case 'N':
                bottomMargin = Math.min(n * lineSpacing, pageLength - 1);
                break;
            case 'l':
                int left = n * characterWidth();
                if (left < rightMargin) {
                    leftMargin = left;
                    x = Math.max(x, leftMargin);
                }
                break;
            case 'Q':
                int right = n * characterWidth();
                if (right > leftMargin && right <= width) {
                    rightMargin = right;
                }
                break;
            case '$':
                x = Math.min(rightMargin, leftMargin + (n | parameters[1] << 8) * 4);
                break;
            case '\\':
                int offset = (short) (n | parameters[1] << 8);
                x = Math.max(leftMargin, Math.min(rightMargin, x + offset * 2));
                break;
            case '?':
                int index = graphicsIndex(n);
                if (index >= 0 && parameters[1] < GRAPHICS_DPI.length) {
                    graphicsModes[index] = parameters[1];
                }
                break;
            case '*':
                startGraphics(n, parameters[1] | parameters[2] << 8, false);
                break;
            case '^':
                startGraphics(n & 1, parameters[1] | parameters[2] << 8, true);
                break;
            case 'K':
            case 'L':
            case 'Y':
            case 'Z':
                startGraphics(graphicsModes[graphicsIndex(command)], n | parameters[1] << 8, false);
                break;
            case '&':
                if (parameters[2] >= parameters[1]) {
                    downloadCharacter = parameters[1];
                    downloadIndex = 0;
                    downloadRemaining = (parameters[2] - parameters[1] + 1) * 12;
                }
                break;
            default:
                // Direction, speed and ROM character-set selection do not move paper.
                break;
        }
    }

    private boolean enabled(int n) {
        return n == 1 || n == '1';
    }

    private int graphicsIndex(int command) {
        switch (command) {
            case 'K':
                return 0;
            case 'L':
                return 1;
            case 'Y':
                return 2;
            case 'Z':
                return 3;
            default:
                return -1;
        }
    }

    private void startGraphics(int mode, int columns, boolean ninePin) {
        this.ninePin = ninePin;
        graphicsRemaining = columns * (ninePin ? 2 : 1);
        graphicsByte = 0;
        graphicsPosition = x;
        // Consume even unsupported density payloads without interpreting them as text.
        graphicsStep = mode < GRAPHICS_DPI.length ? 240.0 / GRAPHICS_DPI[mode] : 0;
    }

    private void printGraphics(int c) {
        int firstRow = ninePin && (graphicsByte & 1) != 0 ? 8 : 0;
        int pins = firstRow == 8 ? 1 : 8;
        if (graphicsStep != 0) {
            for (int pin = 0; pin < pins; pin++) {
                if ((c & 0x80 >> pin) != 0) {
                    for (int dx = 0; dx < Math.max(1, (int) Math.round(graphicsStep)); dx++) {
                        int column = (int) Math.round(graphicsPosition) + dx;
                        if (column < rightMargin) {
                            for (int dy = 0; dy < 3; dy++) {
                                plot(column, (firstRow + pin) * 3 + dy);
                            }
                        }
                    }
                }
            }
        }
        graphicsByte++;
        graphicsRemaining--;
        if (!ninePin || (graphicsByte & 1) == 0) {
            graphicsPosition += graphicsStep;
            x = Math.min(rightMargin, (int) Math.round(graphicsPosition));
        }
        pending = true;
    }

    private int characterWidth() {
        int cell = condensed ? (elite ? 12 : 14) : (elite ? 20 : 24);
        return cell * (doubleWidth || singleLineWidth ? 2 : 1);
    }

    private void printCharacter(int c) {
        int cell = characterWidth();
        if (x + cell > rightMargin) {
            advance(lineSpacing);
            x = leftMargin;
            singleLineWidth = false;
            cell = characterWidth();
        }
        int[] custom = userDefined ? downloaded[c] : null;
        int columns = custom == null ? 6 : 12;
        int height = custom == null ? 7 : 8;
        int ascii = c & 0x7f;
        int glyph = ascii >= 'a' && ascii <= 'z' ? 256 + ascii - 32 : ascii;
        for (int row = 0; row < height; row++) {
            for (int dx = 0; dx < cell; dx++) {
                int column = dx * columns / cell;
                boolean pixel = custom == null
                        ? (charset[glyph * 7 + row] & 0x80 >> column) != 0
                        : column < 11 && (custom[column + 1] & 0x80 >> row) != 0;
                if (pixel) {
                    int skew = italic ? (height - 1 - row) / 2 : 0;
                    int top = script == 0 ? row * 3 : row * 2 + (script > 0 ? 12 : 0);
                    for (int dy = 0; dy < (script == 0 ? 3 : 2); dy++) {
                        textDot(x + dx + skew, top + dy);
                    }
                }
            }
        }
        if (underline) {
            for (int dx = 0; dx < cell; dx++) {
                plot(x + dx, 24);
            }
        }
        x += cell;
        pending = true;
    }

    private void textDot(int column, int row) {
        if (column < rightMargin) {
            plot(column, row);
            if (emphasized && column + 1 < rightMargin) {
                plot(column + 1, row);
            }
            if (doubleStrike) {
                plot(column, row + 1);
            }
        }
    }

    private void advance(int dots) {
        feed(dots);
        pagePosition = (pagePosition + dots) % pageLength;
        if (bottomMargin != 0 && pagePosition >= pageLength - bottomMargin) {
            feed(pageLength - pagePosition);
            pagePosition = 0;
        }
    }

    private void verticalTab() {
        for (int tab : verticalTabs) {
            if (tab > pagePosition && tab < pageLength) {
                advance(tab - pagePosition);
                x = leftMargin;
                singleLineWidth = false;
                return;
            }
        }
        if (verticalTabs.isEmpty()) {
            advance(lineSpacing);
        } else {
            formFeed();
        }
    }

    private void formFeed() {
        feed(pageLength - pagePosition);
        pagePosition = 0;
        x = leftMargin;
        singleLineWidth = false;
    }

    @Override
    public void flush() {
        if (pending) {
            advance(Math.max(lineSpacing, getBufferedHeight()));
        }
        x = leftMargin;
    }
}