ConvertServlet.java

package server.restful.servlets;

import com.beust.jcommander.Parameter;
import com.beust.jcommander.Parameters;
import com.beust.jcommander.ParametersDelegate;
import com.google.zxing.WriterException;
import jakarta.servlet.AsyncContext;
import jakarta.servlet.annotation.HttpConstraint;
import jakarta.servlet.annotation.ServletSecurity;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import libsidplay.common.Engine;
import libsidplay.components.cart.CartridgeType;
import libsidplay.components.mos656x.PALEmulation;
import libsidplay.config.IC1541Section;
import libsidplay.config.IEmulationSection;
import libsidplay.config.ISidPlay2Section;
import libsidplay.sidtune.SidTune;
import org.apache.http.HttpHeaders;
import server.restful.common.ContentTypeAndFileExtensions;
import server.restful.common.JSIDPlay2Servlet;
import server.restful.common.async.DefaultThreadFactory;
import server.restful.common.async.HttpAsyncContextRunnable;
import server.restful.common.converter.LocaleConverter;
import server.restful.common.converter.WebResourceConverter;
import server.restful.common.filters.HeadRequestFilter;
import server.restful.common.filters.RTMPBasedRateLimiterFilter;
import server.restful.common.parameter.ServletParameterParser;
import server.restful.common.parameter.requestpath.FileRequestPathServletParameters;
import server.restful.common.playback.PlaybackLaunch;
import server.restful.common.playback.PlaybackService;
import server.restful.common.rtmp.HlsType;
import server.restful.common.text2speech.TextToSpeech;
import server.restful.common.text2speech.TextToSpeechBean;
import server.restful.common.text2speech.TextToSpeechType;
import sidplay.Player;
import sidplay.audio.AACDriver.AACStreamDriver;
import sidplay.audio.AVIDriver.AVIFileDriver;
import sidplay.audio.AudioDriver;
import sidplay.audio.FLACDriver.FLACStreamDriver;
import sidplay.audio.FLVDriver.FLVFileDriver;
import sidplay.audio.FLVDriver.FLVStreamDriver;
import sidplay.audio.JWAVDriver.JWAVStreamDriver;
import sidplay.audio.MP3Driver.MP3StreamDriver;
import sidplay.audio.MP4Driver.MP4FileDriver;
import sidplay.audio.ProxyDriver;
import sidplay.audio.SIDDumpDriver.SIDDumpStreamDriver;
import sidplay.audio.SIDRegDriver.Format;
import sidplay.audio.SIDRegDriver.SIDRegStreamDriver;
import sidplay.audio.ThrottlingDriver;
import sidplay.ini.IniConfig;
import ui.common.Convenience;
import ui.common.ConvenienceResult;
import ui.common.util.InternetUtil;
import ui.entities.config.Configuration;

import javax.imageio.ImageIO;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.*;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import static jakarta.xml.bind.DatatypeConverter.printBase64Binary;
import static java.lang.Integer.MIN_VALUE;
import static java.lang.Math.min;
import static java.lang.String.format;
import static java.nio.charset.StandardCharsets.UTF_8;
import static libsidutils.IOUtils.*;
import static libsidutils.ZipFileUtils.newFileInputStream;
import static org.apache.tomcat.util.http.fileupload.FileUploadBase.ATTACHMENT;
import static org.apache.tomcat.util.http.fileupload.FileUploadBase.CONTENT_DISPOSITION;
import static server.restful.JSIDPlay2Server.CONTEXT_ROOT_SERVLET;
import static server.restful.common.ContentTypeAndFileExtensions.*;
import static server.restful.common.IServletSystemProperties.ConvertServlet.*;
import static server.restful.common.IServletSystemProperties.JSIDPlay2Server.CACHE_CONTROL_RESPONSE_HEADER_UNCACHED;
import static server.restful.common.QrCode.createBarCodeImage;
import static server.restful.common.ServletUtil.*;
import static server.restful.common.filters.HeadRequestFilter.FILTER_PARAMETER_CONTENT_TYPE;
import static server.restful.common.filters.RTMPBasedRateLimiterFilter.FILTER_PARAMETER_MAX_RTMP_PER_SERVLET;
import static server.restful.common.rtmp.PlayerCleanupTimerTask.create;
import static sidplay.audio.Audio.FLV;
import static sidplay.audio.Audio.MP3;

@WebServlet(name = "ConvertServlet", displayName = "ConvertServlet", asyncSupported = true, urlPatterns = CONTEXT_ROOT_SERVLET
        + "/convert/*", description = "Stream e.g. SID as MP3 or D64 as MP3 or RTMP video stream")
@ServletSecurity(value = @HttpConstraint(rolesAllowed = { /* mobile Chrome ignores basic auth in audio src! */}))
public class ConvertServlet extends JSIDPlay2Servlet {

    @SuppressWarnings("unused")
    @Parameters(resourceBundle = "server.restful.servlets.ConvertServletParameters")
    public static class ConvertServletParameters extends FileRequestPathServletParameters {

        private String share;

        public String getShare() {
            return share;
        }

        @Parameter(names = "--share", descriptionKey = "SHARE", order = MIN_VALUE + 4)
        public void setShare(String share) {
            this.share = share;
        }

        @Override
        public File fetchFile(Configuration configuration, Properties directoryProperties, ServletParameterParser parser,
                              boolean hasAdminAccess) throws IOException, URISyntaxException {
            if (getHelp() || parser.hasException()) return null;
            if (getShare() == null) return super.fetchFile(configuration, directoryProperties, parser, hasAdminAccess);

            // Resolve shared content through the same file-loading entry point as ordinary requests.
            PlaybackService playback = new PlaybackService(configuration, directoryProperties, hasAdminAccess);
            try {
                return playback.fetch(playback.read(getShare()).primary);
            } catch (IOException | URISyntaxException | IllegalArgumentException e) {
                parser.setException(e);
                return null;
            }
        }

        private Boolean useDevTools = Boolean.FALSE;

        public Boolean getUseDevTools() {
            return useDevTools;
        }

        @Parameter(names = "--devtools", arity = 1, descriptionKey = "USE_DEV_TOOLS", hidden = true, order = MIN_VALUE + 5)
        public void setUseDevTools(Boolean useDevTools) {
            this.useDevTools = useDevTools;
        }

        private Integer startSong;

        public Integer getStartSong() {
            return startSong;
        }

        @Parameter(names = {"--startSong"}, descriptionKey = "START_SONG", order = MIN_VALUE + 6)
        public void setStartSong(Integer startSong) {
            this.startSong = startSong;
        }

        private Locale locale = Locale.ROOT;

        public Locale getLocale() {
            return locale;
        }

        @Parameter(names = "--locale", descriptionKey = "LOCALE", converter = LocaleConverter.class, order = MIN_VALUE + 7)
        public void setLocale(Locale locale) {
            this.locale = locale;
        }

        private TextToSpeechType textToSpeechType = TextToSpeechType.PICO2WAVE;

        public TextToSpeechType getTextToSpeechType() {
            return textToSpeechType;
        }

        @Parameter(names = "--textToSpeechType", arity = 1, descriptionKey = "TEXT_TO_SPEECH_TYPE", order = MIN_VALUE + 8)
        public void setTextToSpeechType(TextToSpeechType textToSpeechType) {
            this.textToSpeechType = textToSpeechType;
        }

        private Locale textToSpeechLocale;

        public Locale getTextToSpeechLocale() {
            return textToSpeechLocale;
        }

        @Parameter(names = "--textToSpeechLocale", descriptionKey = "TEXT_TO_SPEECH_LOCALE", converter = LocaleConverter.class, order = MIN_VALUE + 9)
        public void setTextToSpeechLocale(Locale textToSpeechLocale) {
            this.textToSpeechLocale = textToSpeechLocale;
        }

        private Boolean download = Boolean.FALSE;

        public Boolean getDownload() {
            return download;
        }

        @Parameter(names = "--download", arity = 1, descriptionKey = "DOWNLOAD", order = MIN_VALUE + 10)
        public void setDownload(Boolean download) {
            this.download = download;
        }

        private Integer reuSize = 0;

        public Integer getReuSize() {
            return reuSize;
        }

        @Parameter(names = {"--reuSize"}, descriptionKey = "REU_SIZE", order = MIN_VALUE + 11)
        public void setReuSize(Integer reuSize) {
            this.reuSize = reuSize;
        }

        private Boolean starTreuWorkaround = Boolean.FALSE;

        public Boolean getStarTreuWorkaround() {
            return starTreuWorkaround;
        }

        @Parameter(names = "--starTreuWorkaround", arity = 1, descriptionKey = "STARTREU_WORKAROUND", order = MIN_VALUE + 12)
        public void setStarTreuWorkaround(Boolean starTreuWorkaround) {
            this.starTreuWorkaround = starTreuWorkaround;
        }

        private Boolean sfxSoundExpander = Boolean.FALSE;

        public Boolean getSfxSoundExpander() {
            return sfxSoundExpander;
        }

        @Parameter(names = "--sfxSoundExpander", arity = 1, descriptionKey = "SFX_SOUND_EXPANDER", order = MIN_VALUE + 13)
        public void setSfxSoundExpander(Boolean sfxSoundExpander) {
            this.sfxSoundExpander = sfxSoundExpander;
        }

        private Integer sfxSoundExpanderType = 1;

        public Integer getSfxSoundExpanderType() {
            return sfxSoundExpanderType;
        }

        @Parameter(names = {"--sfxSoundExpanderType"}, descriptionKey = "SFX_SOUND_EXPANDER_TYPE", order = MIN_VALUE + 14)
        public void setSfxSoundExpanderType(Integer sfxSoundExpanderType) {
            this.sfxSoundExpanderType = sfxSoundExpanderType;
        }

        private Integer pressSpaceInterval = PRESS_SPACE_INTERVALL;

        public Integer getPressSpaceInterval() {
            return pressSpaceInterval;
        }

        @Parameter(names = {"--pressSpaceInterval"}, descriptionKey = "PRESS_SPACE_INTERVAL", order = MIN_VALUE + 15)
        public void setPressSpaceInterval(Integer pressSpaceInterval) {
            this.pressSpaceInterval = pressSpaceInterval;
        }

        private Boolean showStatus = Boolean.TRUE;

        public Boolean getShowStatus() {
            return showStatus;
        }

        @Parameter(names = "--status", arity = 1, descriptionKey = "STATUS", order = MIN_VALUE + 16)
        public void setShowStatus(Boolean showStatus) {
            this.showStatus = showStatus;
        }

        private final Boolean useHls = Boolean.TRUE;

        // RTMP is no more supported in favor of HLS
        public Boolean getUseHls() {
            return useHls;
        }

        private HlsType hlsType = HlsType.HLS_JS;

        public HlsType getHlsType() {
            return hlsType;
        }

        @Parameter(names = {"--hlsType"}, descriptionKey = "HLS_TYPE", order = MIN_VALUE + 17)
        public void setHlsType(HlsType hlsType) {
            this.hlsType = hlsType;
        }

        private Format sidRegFormat = Format.APP;

        public Format getSidRegFormat() {
            return sidRegFormat;
        }

        @Parameter(names = "--sidRegFormat", descriptionKey = "SID_REG_FORMAT", order = MIN_VALUE + 18)
        public void setSidRegFormat(Format sidRegFormat) {
            this.sidRegFormat = sidRegFormat;
        }

        private String autostart;

        public String getAutostart() {
            return autostart;
        }

        @Parameter(names = {"--autostart"}, descriptionKey = "AUTOSTART", order = MIN_VALUE + 19)
        public void setAutostart(String autostart) {
            this.autostart = autostart;
        }

        private Boolean videoTuneAsAudio = Boolean.FALSE;

        public Boolean getVideoTuneAsAudio() {
            return videoTuneAsAudio;
        }

        @Parameter(names = "--videoTuneAsAudio", arity = 1, descriptionKey = "VIDEO_TUNE_AS_AUDIO", order = MIN_VALUE + 20)
        public void setVideoTuneAsAudio(Boolean videoTuneAsAudio) {
            this.videoTuneAsAudio = videoTuneAsAudio;
        }

        private Boolean audioTuneAsVideo = Boolean.FALSE;

        public Boolean getAudioTuneAsVideo() {
            return audioTuneAsVideo;
        }

        @Parameter(names = "--audioTuneAsVideo", arity = 1, descriptionKey = "AUDIO_TUNE_AS_VIDEO", order = MIN_VALUE + 21)
        public void setAudioTuneAsVideo(Boolean audioTuneAsVideo) {
            this.audioTuneAsVideo = audioTuneAsVideo;
        }

        @ParametersDelegate
        private IniConfig config = new IniConfig();

        public IniConfig getConfig() {
            return config;
        }

        public void setConfig(IniConfig config) {
            this.config = config;
        }

    }

    private ExecutorService executorService;

    @Override
    public void init() {
        executorService = Executors.newFixedThreadPool(MAX_CONVERT_IN_PARALLEL, new DefaultThreadFactory("/convert"));
    }

    @Override
    public void destroy() {
        executorService.shutdown();
    }

    @Override
    public Map<Class<? extends HttpFilter>, Map<String, String>> getServletFiltersParameterMap() {
        Map<Class<? extends HttpFilter>, Map<String, String>> result = new HashMap<>();

        Map<String, String> headRequestFilterParameters = new HashMap<>();
        headRequestFilterParameters.put(FILTER_PARAMETER_CONTENT_TYPE, MIME_TYPE_MPEG.getMimeType());
        result.put(HeadRequestFilter.class, headRequestFilterParameters);

        Map<String, String> rtmpBasedRateLimiterFilterParameters = new HashMap<>();
        rtmpBasedRateLimiterFilterParameters.put(FILTER_PARAMETER_MAX_RTMP_PER_SERVLET,
                String.valueOf(MAX_CONVERT_RTMP_IN_PARALLEL));
        result.put(RTMPBasedRateLimiterFilter.class, rtmpBasedRateLimiterFilterParameters);

        return result;
    }

    /**
     * Stream e.g., SID as MP3 or D64 as RTMP video stream.
     *
     * <BR>
     * E.g. stream audio<BR> E.g.
     * {@code
     * http://haendel.ddns.net:8080/jsidplay2service/JSIDPlay2REST/convert/C64Music/MUSICIANS/D/DRAX/Worktunes/Outro.sid
     * } <BR> E.g. stream video<BR> E.g.
     * {@code
     * http://haendel.ddns.net:8080/jsidplay2service/JSIDPlay2REST/convert/C64Music/10_Years_HVSC_1.d64?enableSidDatabase=true&startTime=00:00&defaultLength=04:00&fadeIn=00:00&fadeOut=00:00&loop=false&single=true&frequency=MEDIUM&sampling=RESAMPLE&mainVolume=0&secondVolume=0&thirdVolume=0&mainBalance=0.3&secondBalance=0.7&thirdBalance=0.5&mainDelay=0&secondDelay=20&thirdDelay=0&bufferSize=65536&cbr=64&vbrQuality=5&vbr=false&acBitRate=64000&vcBitRate=480000&vcAudioDelay=0&delayBypass=true&reverbBypass=true&defaultEmulation=RESIDFP&defaultClock=PAL&defaultModel=MOS8580&sidToRead=FIRST_SID&digiBoosted8580=false&fakeStereo=false&muteVoice1=false&muteVoice2=false&muteVoice3=false&muteVoice4=false&muteStereoVoice1=false&muteStereoVoice2=false&muteStereoVoice3=false&muteStereoVoice4=false&muteThirdSidVoice1=false&muteThirdSidVoice2=false&muteThirdSidVoice3=false&muteThirdSidVoice4=false&filter6581=FilterAverage6581&stereoFilter6581=FilterAverage6581&thirdFilter6581=FilterAverage6581&filter8580=FilterAverage8580&stereoFilter8580=FilterAverage8580&thirdFilter8580=FilterAverage8580&reSIDfpFilter6581=FilterAlankila6581R4AR_3789&reSIDfpStereoFilter6581=FilterAlankila6581R4AR_3789&reSIDfpThirdFilter6581=FilterAlankila6581R4AR_3789&reSIDfpFilter8580=FilterTrurl8580R5_3691&reSIDfpStereoFilter8580=FilterTrurl8580R5_3691&reSIDfpThirdFilter8580=FilterTrurl8580R5_3691&detectPSID64ChipModel=true&hlsType=VIDEO_JS&pressSpaceInterval=90&status=true&jiffydos=true
     * }
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {

        AsyncContext asyncContext = request.startAsync(request, response);
        asyncContext.setTimeout(CONVERT_ASYNC_TIMEOUT);

        executorService.execute(new HttpAsyncContextRunnable(asyncContext, getServletContext()) {

            public void run(HttpServletRequest request, HttpServletResponse response) {
                try {
                    final ConvertServletParameters servletParameters = new ConvertServletParameters();

                    ServletParameterParser parser = new ServletParameterParser(request, response, servletParameters);

                    final File file = servletParameters.fetchFile(configuration, directoryProperties, parser,
                            hasAdminAccess(request));
                    if (file == null || servletParameters.getHelp() || parser.hasException()) {
                        parser.usage();
                        return;
                    }

                    final PlaybackService playback = new PlaybackService(configuration, directoryProperties, hasAdminAccess(request));
                    final PlaybackLaunch launch = servletParameters.getShare() == null ? null
                            : playback.read(servletParameters.getShare());
                    if (launch != null) {
                        PlaybackService.applySettings(launch, servletParameters,
                                servletParameters.getConfig().getSidplay2Section(), servletParameters.getConfig().getAudioSection(),
                                servletParameters.getConfig().getEmulationSection(), servletParameters.getConfig().getC1541Section());
                        if (launch.autostart != null) servletParameters.setAutostart(launch.autostart);
                        servletParameters.setItemId(launch.primary.itemId);
                        servletParameters.setCategoryId(launch.primary.categoryId);
                        servletParameters.setServerId(launch.primary.serverId);

                        // Explicit request options take precedence over saved launch defaults.
                        parser = new ServletParameterParser(request, response, servletParameters);
                        if (parser.hasException()) {
                            parser.usage();
                            return;
                        }
                        if (launch.companion(PlaybackService.CARTRIDGE) != null
                                && (servletParameters.getSfxSoundExpander() || servletParameters.getReuSize() > 0
                                || servletParameters.isREU())) {
                            throw new IllegalArgumentException("Cartridge companion conflicts with the selected expansion");
                        }
                    }
                    if ((AUDIO_TUNE_FILE_FILTER.accept(file)
                            || (servletParameters.getVideoTuneAsAudio() && VIDEO_TUNE_FILE_FILTER.accept(file)))
                            && !servletParameters.getAudioTuneAsVideo()) {

                        AudioDriver driver = getAudioDriverOfAudioFormat(response, servletParameters);

                        if (Boolean.TRUE.equals(servletParameters.getDownload())) {
                            response.addHeader(CONTENT_DISPOSITION, ATTACHMENT + "; filename="
                                    + URLEncoder.encode(getAttachmentFilename(file, driver), UTF_8));
                        }
                        response.setContentType(getMimeType(driver.getExtension()).toString());
                        convert2audio(file, driver, servletParameters, playback, launch);

                    } else if (VIDEO_TUNE_FILE_FILTER.accept(file) || DISK_FILE_FILTER.accept(file)
                            || TAPE_FILE_FILTER.accept(file) || CART_FILE_FILTER.accept(file)
                            || AUDIO_TUNE_FILE_FILTER.accept(file)) {

                        UUID uuid = UUID.randomUUID();

                        AudioDriver driver = getAudioDriverOfVideoFormat(uuid, servletParameters);

                        if (Boolean.FALSE.equals(servletParameters.getDownload())
                                && driver.lookup(FLVStreamDriver.class).isPresent()) {

                            Thread poolThread = Thread.currentThread();
                            new Thread(() -> {
                                try {
                                    convert2video(file, driver, servletParameters, playback, launch, uuid, parentThread, poolThread);
                                } catch (Exception e) {
                                    error(getServletContext(), e, parentThread);
                                }
                            }, "RTMP").start();
                            waitUntilVideoIsAvailable(uuid);

                            response.setHeader(HttpHeaders.CACHE_CONTROL, CACHE_CONTROL_RESPONSE_HEADER_UNCACHED);

                            try (InputStream is = new WebResourceConverter(SERVLET_PATH).convert("/convert.vue")) {
                                if (!isComplete()) {
                                    setOutput(MIME_TYPE_HTML, response, convertStreamToString(is, UTF_8,
                                            getReplacements(servletParameters, request, uuid)));
                                }
                            }
                        } else {

                            if (Boolean.TRUE.equals(servletParameters.getDownload())) {
                                response.addHeader(CONTENT_DISPOSITION, ATTACHMENT + "; filename="
                                        + URLEncoder.encode(getAttachmentFilename(file, driver), UTF_8));
                            }
                            File videoFile = convert2video(file, driver, servletParameters, playback, launch, null, parentThread);

                            ContentTypeAndFileExtensions mimeType = getMimeType(driver.getExtension());
                            if (!isComplete()) {
                                response.setContentLength((int) videoFile.length());
                                setOutput(mimeType, response, newFileInputStream(videoFile));
                            }
                            ioWrap(videoFile::delete);
                        }
                    } else {
                        if (!isComplete()) {
                            response.addHeader(CONTENT_DISPOSITION,
                                    ATTACHMENT + "; filename=" + URLEncoder.encode(file.getName(), UTF_8));
                            response.setContentLength((int) file.length());
                            setOutput(getMimeType(getFilenameSuffix(file.getName())), response,
                                    newFileInputStream(file));
                        }
                    }
                } catch (Throwable t) {
                    error(getServletContext(), t, parentThread);
                    if (!isComplete()) {
                        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                        setOutput(response, t);
                    }
                }
            }

            private String getAttachmentFilename(final File file, AudioDriver driver) {
                return getFilenameWithoutSuffix(file.getName()) + driver.getExtension();
            }

            private void convert2audio(File file, AudioDriver driver, ConvertServletParameters servletParameters,
                                       PlaybackService playback, PlaybackLaunch launch) throws Exception {
                info(getServletContext(), String.format("START file=%s", file.getAbsolutePath()), parentThread);

                ISidPlay2Section sidplay2Section = servletParameters.getConfig().getSidplay2Section();
                IEmulationSection emulationSection = servletParameters.getConfig().getEmulationSection();

                sidplay2Section.setHvsc(configuration.getSidplay2Section().getHvsc());
                emulationSection.setEngine(Engine.EMULATION);

                Player player = new Player(servletParameters.getConfig());
                player.getC64().getVIC().setPalEmulation(PALEmulation.NONE);
                player.getC64().setStarTreuWorkaround(Boolean.TRUE.equals(servletParameters.getStarTreuWorkaround()));
                player.setSidDatabase(sidDatabase);
                player.setSTIL(stil);
                if (Boolean.TRUE.equals(servletParameters.getDownload())) {
                    sidplay2Section
                            .setDefaultPlayLength(min(sidplay2Section.getDefaultPlayLength(), MAX_AUD_DOWNLOAD_LENGTH));
                }
                if (TEXT_TO_SPEECH && servletParameters.getTextToSpeechType() != TextToSpeechType.NONE) {
                    player.setMenuHook(new TextToSpeech(servletParameters.getTextToSpeechType(),
                            new TextToSpeechBean(file, player, getTextToSpeechLocale(servletParameters))));
                }

                Thread poolThread = Thread.currentThread();
                player.setAudioDriver(driver);
                player.setUncaughtExceptionHandler((thread, throwable) -> uncaughtExceptionHandler(getServletContext(),
                        throwable, thread, parentThread, poolThread));
                player.setCheckDefaultLengthInRecordMode(Boolean.TRUE.equals(servletParameters.getDownload()));
                player.setCheckLoopOffInRecordMode(Boolean.TRUE.equals(servletParameters.getDownload()));
                player.setForceCheckSongLength(Boolean.TRUE.equals(servletParameters.getDownload()));

                insertCartridge(servletParameters, player, playback, launch);

                SidTune tune = launch == null ? SidTune.load(file) : playback.tune(launch, file);
                tune.getInfo().setSelectedSong(servletParameters.getStartSong());

                player.play(tune);
                player.stopC64(false);

                info(getServletContext(), format("END file=%s", file.getAbsolutePath()), parentThread);
            }

            private File convert2video(File file, AudioDriver driver, ConvertServletParameters servletParameters,
                                       PlaybackService playback, PlaybackLaunch launch, UUID uuid, Thread... parentThreads) throws Exception {
                info(getServletContext(), format("START file=%s, uuid=%s", file.getAbsolutePath(), uuid),
                        parentThreads);

                File videoFile = null;
                ISidPlay2Section sidplay2Section = servletParameters.getConfig().getSidplay2Section();
                IEmulationSection emulationSection = servletParameters.getConfig().getEmulationSection();
                IC1541Section c1541Section = servletParameters.getConfig().getC1541Section();

                emulationSection.setEngine(Engine.EMULATION);
                if (TAPE_FILE_FILTER.accept(file)) {
                    c1541Section.setJiffyDosInstalled(false);
                }

                Player player = new Player(servletParameters.getConfig());
                player.getC64().setStarTreuWorkaround(Boolean.TRUE.equals(servletParameters.getStarTreuWorkaround()));
                if (Boolean.TRUE.equals(servletParameters.getDownload())) {
                    sidplay2Section
                            .setDefaultPlayLength(min(sidplay2Section.getDefaultPlayLength(), MAX_VID_DOWNLOAD_LENGTH));
                    videoFile = createVideoFile(player, driver);
                } else {
                    sidplay2Section.setDefaultPlayLength(RTMP_EXCEEDS_MAXIMUM_DURATION);
                }

                player.setAudioDriver(driver);
                player.setUncaughtExceptionHandler((thread, throwable) -> uncaughtExceptionHandler(getServletContext(),
                        throwable, thread, parentThreads));
                player.setCheckDefaultLengthInRecordMode(Boolean.TRUE.equals(servletParameters.getDownload()));
                player.setCheckLoopOffInRecordMode(Boolean.TRUE.equals(servletParameters.getDownload()));
                player.setForceCheckSongLength(Boolean.TRUE.equals(servletParameters.getDownload()));

                ConvenienceResult convenienceResult;
                boolean bundledReu = file.getName().toLowerCase(Locale.ROOT).endsWith(".crt")
                        && (servletParameters.isREU() || servletParameters.getReuSize() != null
                        && servletParameters.getReuSize() > 0);
                if (launch != null || bundledReu) {
                    // Explicit launches must not scan or replace the declared cartridge.
                    insertCartridge(servletParameters, player, playback, launch);
                    convenienceResult = new Convenience(player).autostart(file,
                            Convenience.LEXICALLY_FIRST_MEDIA, servletParameters.getAutostart(), false, true,
                            tuneFile -> {
                                SidTune tune = launch == null ? SidTune.load(tuneFile) : playback.tune(launch, tuneFile);
                                tune.getInfo().setSelectedSong(servletParameters.getStartSong());
                                return tune;
                            });
                } else {
                    convenienceResult = new Convenience(player).autostart(file,
                            Convenience.LEXICALLY_FIRST_MEDIA, servletParameters.getAutostart(), true);
                }

                if (launch == null && !player.getC64().isCartridge()) {
                    insertCartridge(servletParameters, player, playback, launch);
                }
                if (uuid != null) {
                    create(uuid, player, file, convenienceResult, servletParameters);
                }
                player.stopC64(false);

                info(getServletContext(), format("END file=%s, uuid=%s", file.getAbsolutePath(), uuid), parentThreads);
                return videoFile;
            }

            private Locale getTextToSpeechLocale(ConvertServletParameters servletParameters) {
                return servletParameters.getTextToSpeechLocale() != null ? servletParameters.getTextToSpeechLocale()
                        : servletParameters.getLocale();
            }

            private void insertCartridge(ConvertServletParameters servletParameters, Player player,
                                         PlaybackService playback, PlaybackLaunch launch) throws Exception {
                PlaybackLaunch.Resource cartridge = launch == null ? null : launch.companion(PlaybackService.CARTRIDGE);
                if (cartridge != null) {
                    player.insertCartridge(cartridge.path.toLowerCase(Locale.ROOT).endsWith(".reu")
                            ? CartridgeType.REU : CartridgeType.CRT, playback.fetch(cartridge));
                    if (cartridge.path.toLowerCase(Locale.ROOT).endsWith(".crt")
                            && servletParameters.getReuSize() != null && servletParameters.getReuSize() > 0) {
                        player.getC64().setREU(servletParameters.getReuSize());
                    }
                } else if (servletParameters.getSfxSoundExpander()) {
                    player.insertCartridge(CartridgeType.SOUNDEXPANDER, servletParameters.getSfxSoundExpanderType());
                } else if (servletParameters.isREU() || servletParameters.getReuSize() != null) {
                    if (servletParameters.isREU()) {
                        player.insertCartridge(CartridgeType.REU,
                                servletParameters.getReuSize() != null ? servletParameters.getReuSize() : 0 /* max. */);
                    } else //noinspection StatementWithEmptyBody
                        if (servletParameters.getReuSize() > 0) {
                            player.insertCartridge(CartridgeType.REU, servletParameters.getReuSize());
                        } else {
                            // servletParameters.getReuSize() == 0? -> no REU at all!
                        }
                }
            }

            private File createVideoFile(Player player, AudioDriver driver) throws IOException {
                ISidPlay2Section sidplay2Section = player.getConfig().getSidplay2Section();

                File tmpDir = new File(sidplay2Section.getTmpDir(), UUID.randomUUID().toString());
                ioWrap(tmpDir::mkdir);

                File videoFile = File.createTempFile("jsidplay2video", driver.getExtension(), tmpDir);
                player.setRecordingFilenameProvider(tune -> getFilenameWithoutSuffix(videoFile.getAbsolutePath()));
                return videoFile;
            }

            private Map<String, String> getReplacements(ConvertServletParameters servletParameters,
                                                        HttpServletRequest request, UUID uuid) throws IOException, URISyntaxException {
                URI videoURI = getVideoURI(Boolean.TRUE.equals(servletParameters.getUseHls()), uuid);
                String qrCodeImgTag = createQrCodeImgTag(createShareWithURL(request));

                Map<String, String> replacements = createReplacements(servletParameters.getUseDevTools());
                replacements.put("uuid", uuid.toString());
                replacements.put("qrCodeImgTag", qrCodeImgTag);
                replacements.put("videoUrl", videoURI.toString());
                replacements.put("hls", String.valueOf(Boolean.TRUE.equals(servletParameters.getUseHls())));
                replacements.put("hlsType", servletParameters.getHlsType().name());
                replacements.put("hlsScript", servletParameters.getHlsType().getScript());
                replacements.put("hlsStyle", servletParameters.getHlsType().getStyle());
                replacements.put("notYetPlayedTimeout", String.valueOf(RTMP_NOT_YET_PLAYED_TIMEOUT));
                replacements.put("notifyForHLS", String.valueOf(NOTIFY_FOR_HLS));
                return replacements;
            }

            private String createQrCodeImgTag(String data)
                    throws IOException {
                try {
                    ByteArrayOutputStream qrCodeImgData = new ByteArrayOutputStream();
                    ImageIO.write(createBarCodeImage(data, 320, 320), "png", qrCodeImgData);
                    return format("<img src='data:image/%s;base64,%s'>", "png",
                            printBase64Binary(qrCodeImgData.toByteArray()));
                } catch (WriterException e) {
                    return format("<img src='data:image/%s;base64,%s'>", "png", printBase64Binary(new byte[0]));
                }
            }

            private URI getVideoURI(boolean useHls, UUID uuid) throws URISyntaxException {
                if (useHls) {
                    // HLS protocol
                    return new URI(HLS_DOWNLOAD_URL + "/" + uuid + ".m3u8");
                } else {
                    // RTMP protocol
                    return new URI(RTMP_DOWNLOAD_URL + "/" + uuid);
                }
            }

            private String createShareWithURL(HttpServletRequest request) {
                StringBuilder result = new StringBuilder(request.getRequestURL());

                if (request.getQueryString() != null) {
                    result.append("?").append(request.getQueryString());
                }
                return result.toString();
            }

            private void waitUntilVideoIsAvailable(UUID uuid)
                    throws InterruptedException, URISyntaxException, IOException {
                URL url = getVideoURI(true, uuid).toURL();
                int retryCount = 0;
                while (retryCount++ < WAIT_FOR_VIDEO_AVAILABLE_RETRY_COUNT) {
                    try {
                        InternetUtil.openConnection(url, configuration.getSidplay2Section());
                        // Give video production a jump start
                        Thread.sleep(1000);
                        return;
                    } catch (InterruptedException | SocketTimeoutException e) {
                        throw e;
                    } catch (IOException e) {
                        // connection not yet established, retry!
                        Thread.sleep(500);
                    }
                }
                throw new IOException("Video is still not available, please retry later!");
            }

        });
    }

    // Each request owns its encoder and response stream, including during parallel conversions.
    static AudioDriver getAudioDriverOfAudioFormat(HttpServletResponse response,
                                                   ConvertServletParameters servletParameters) throws IOException {
        switch (Optional.ofNullable(servletParameters.getConfig().getAudioSection().getAudio()).orElse(MP3)) {
            case WAV:
                return wrapThrottlingDriver(new JWAVStreamDriver(response.getOutputStream()), servletParameters);
            case FLAC:
                return wrapThrottlingDriver(new FLACStreamDriver(response.getOutputStream()), servletParameters);
            case AAC:
                return wrapThrottlingDriver(new AACStreamDriver(response.getOutputStream()), servletParameters);
            case MP3:
            default:
                return wrapThrottlingDriver(new MP3StreamDriver(response.getOutputStream()), servletParameters);
            case SID_DUMP:
                return wrapThrottlingDriver(new SIDDumpStreamDriver(response.getOutputStream()), servletParameters);
            case SID_REG:
                return wrapThrottlingDriver(
                        new SIDRegStreamDriver(response.getOutputStream(), servletParameters.getSidRegFormat()),
                        servletParameters);
        }
    }

    static AudioDriver getAudioDriverOfVideoFormat(UUID uuid, ConvertServletParameters servletParameters) {
        switch (Optional.ofNullable(servletParameters.getConfig().getAudioSection().getAudio()).orElse(FLV)) {
            case FLV:
            default:
                if (Boolean.TRUE.equals(servletParameters.getDownload())) {
                    return new FLVFileDriver();
                } else {
                    return wrapThrottlingDriver(new FLVStreamDriver(RTMP_UPLOAD_URL + "/" + uuid),
                            servletParameters);
                }
            case AVI:
                return new AVIFileDriver();
            case MP4:
                return new MP4FileDriver();
        }
    }

    private static AudioDriver wrapThrottlingDriver(AudioDriver audioDriver,
                                                    ConvertServletParameters servletParameters) {
        if (Boolean.TRUE.equals(servletParameters.getDownload())) {
            return audioDriver;
        }
        return new ProxyDriver(new ThrottlingDriver(), audioDriver);
    }
}