AudioFormat format = new AudioFormat(sampleRate, 16, 1, true, false);
DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
targetDataLine = (TargetDataLine) AudioSystem.getLine(info);
targetDataLine.open(format);
targetDataLine.start();

byte[] buffer = new byte[windowSize * 2];
float[] samples = new float[windowSize];
String lastResult = "";

while (targetDataLine.isOpen()) {
    int n = targetDataLine.read(buffer, 0, buffer.length);
    if (n <= 0) continue;

     // PCM16LE 转 float
     for (int i = 0; i != windowSize; ++i) {
          int low = buffer[2 * i] & 0xFF;
          int high = buffer[2 * i + 1];
          short s = (short)((high << 8) | low);
          samples[i] = (float) s / 32768;
     }

     for (int i = 0; i < samples.length; i++) {
          samples[i] = samples[i] / 32768.0f;
     }

     stream.acceptWaveform(samples, sampleRate);

     while (recognizer.isReady(stream)) {
          recognizer.decode(stream);
     }
}

String text = recognizer.getResult(stream).getText();
boolean isEndpoint = recognizer.isEndpoint(stream);

if (!text.isEmpty() && !text.equals(lastResult)) {
    lastResult = text;
    String finalLastResult = lastResult;
    Platform.runLater(() -> label.setText(finalLastResult));
}
if (isEndpoint) {
    recognizer.reset(stream);
    lastResult = "";
}

package top.lukeewin.subtitle.entity;

/**
 * @author Luke Ewin
 * @date 2025/8/22 17:00
 * @blog blog.lukeewin.top
 */
public class FontConfigEntity {
    private int size;
    private String color;

    public FontConfigEntity() {
    }

    public FontConfigEntity(int size, String color) {
        this.size = size;
        this.color = color;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

public void initialize(URL url, ResourceBundle rb) {
        try {
            Yaml yaml = new Yaml();
            ASRConfigEntity asrConfigEntity = new ASRConfigEntity();
            Map<String, Object> yamlMap = yaml.load(new FileInputStream("src/main/resources/application.yml"));
            Map<String, Object> streamingASRConfigMap = (Map<String, Object>) yamlMap.get("streaming_asr");
            String model_encoder = (String) streamingASRConfigMap.get("model_encoder");
            String model_decoder = (String) streamingASRConfigMap.get("model_decoder");
            String model_tokens = (String) streamingASRConfigMap.get("model_tokens");

            asrConfigEntity.setModelEncoder(model_encoder);
            asrConfigEntity.setModelDecoder(model_decoder);
            asrConfigEntity.setModelTokens(model_tokens);

            Map<String, Object> fontConfigMap = (Map<String, Object>) yamlMap.get("font");
            int fontSize = (int) fontConfigMap.get("size");
            String fontColor = (String) fontConfigMap.get("color");
            fontConfig = new FontConfigEntity(fontSize, fontColor);
            applyFontConfig();

            Task task = new Task(label, asrConfigEntity);
            new Thread(task).start();

            createContextMenu();
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
}

private void createContextMenu() {
        MenuItem settingsItem = new MenuItem("设置");
        settingsItem.setOnAction(event -> openSettings());

        final ContextMenu contextMenu = new ContextMenu();
        contextMenu.getItems().addAll(settingsItem);

        borderPane.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
            if (event.getButton() == MouseButton.SECONDARY) {
                contextMenu.show(borderPane, event.getScreenX(), event.getScreenY());
            } else {
                if (contextMenu.isShowing()) {
                    contextMenu.hide();
                }
            }
        });
}

private void openSettings() {
        // 打开设置窗口
        SettingsDialog settingsDialog = new SettingsDialog(label.getScene().getWindow(), fontConfig);
        FontConfigEntity newConfig = settingsDialog.showAndWait().orElse(null);
        if (newConfig != null) {
            this.fontConfig = newConfig;
            applyFontConfig();
            saveFontConfig();
        }
}

private void applyFontConfig() {
        label.setStyle("-fx-font-size: " + fontConfig.getSize() + "px; -fx-text-fill: " + fontConfig.getColor() + ";");
}

private void saveFontConfig() {
        try {
            Yaml yaml = new Yaml();
            Map<String, Object> yamlMap = yaml.load(new FileInputStream("src/main/resources/application.yml"));

            // 更新字体配置
            Map<String, Object> fontConfigMap = new HashMap<>();
            fontConfigMap.put("size", fontConfig.getSize());
            fontConfigMap.put("color", fontConfig.getColor());
            yamlMap.put("font", fontConfigMap);

            // 写回文件
            FileWriter writer = new FileWriter("src/main/resources/application.yml");
            yaml.dump(yamlMap, writer);
            writer.close();
        } catch (Exception e) {
            System.err.println("保存配置失败: " + e.getMessage());
        }
}

fontSizeSpinner = new Spinner<>(10, 72, initialConfig.getSize());
SpinnerValueFactory<Integer> valueFactory = fontSizeSpinner.getValueFactory();
	if (valueFactory instanceof SpinnerValueFactory.IntegerSpinnerValueFactory) {
        SpinnerValueFactory.IntegerSpinnerValueFactory intFactory = (SpinnerValueFactory.IntegerSpinnerValueFactory) valueFactory;
        if (value < intFactory.getMin()) {
            value = intFactory.getMin();
        } else if (value > intFactory.getMax()) {
            value = intFactory.getMax();
        }
    }
fontSizeSpinner.getValueFactory().setValue(value);