echogarden 0.9.2 → 0.10.0

package/dist/cli/CLI.js

@@ -1,6 +1,6 @@
 import * as API from '../api/API.js';
 import { parseCLIArguments } from './CLIParser.js';
-import { convertHtmlToText, formatIntegerWithLeadingZeros, formatListWithQuotedElements, getWithDefault, logToStderr, setupUnhandledExceptionListeners, splitFilenameOnExtendedExtension, stringifyAndFormatJson } from "../utilities/Utilities.js";
+import { convertHtmlToText, formatIntegerWithLeadingZeros, formatListWithQuotedElements, getWithDefault, setupUnhandledExceptionListeners, splitFilenameOnExtendedExtension, stringifyAndFormatJson } from "../utilities/Utilities.js";
 import { getOptionTypeFromSchema } from "./CLIOptionsSchema.js";
 import { parseConfigFile, parseJSONConfigFile } from "./CLIConfigFile.js";
 import chalk from 'chalk';
@@ -8,12 +8,12 @@ import { applyGainDecibels, encodeWaveBuffer, getEmptyRawAudio, normalizeAudioLe
 import { subtitlesToText, subtitlesToTimeline, timelineToSubtitles } from "../subtitles/Subtitles.js";
 import { Logger } from "../utilities/Logger.js";
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { encodeFromChannels } from "../codecs/FFMpegTranscoder.js";
+import { encodeFromChannels, getDefaultFFMpegOptionsForSpeech } from "../codecs/FFMpegTranscoder.js";
 import path, { parse as parsePath } from "node:path";
 import { splitToParagraphs, splitToWords, wordCharacterPattern } from "../nlp/Segmentation.js";
 import { playAudioSamples, playAudioWithWordTimeline } from "../audio/AudioPlayer.js";
 import { extendDeep } from "../utilities/ObjectUtilities.js";
-import { addTimeOffsetToTimeline, addWordTextOffsetsToTimeline, roundTimelineProperties, wordTimelineToSegmentSentenceTimeline } from "../utilities/Timeline.js";
+import { addTimeOffsetToTimeline, addWordTextOffsetsToTimeline, roundTimelineProperties } from "../utilities/Timeline.js";
 import { ensureDir, existsSync, getLowercaseFileExtension, readAndParseJsonFile, readFile, readdir, resolveToModuleRootDir, writeFileSafe } from '../utilities/FileSystem.js';
 import { formatLanguageCodeWithName, getShortLanguageCode } from '../utilities/Locale.js';
 import { ensureAndGetPackagesDir, getVersionTagFromPackageName, loadPackage, resolveVersionTagForUnversionedPackageName } from '../utilities/PackageManager.js';
@@ -21,7 +21,7 @@ import { removePackage } from '../utilities/PackageManager.js';
 import { appName } from '../api/Common.js';
 import { startWebSocketServer } from '../server/Server.js';
 import { OpenPromise } from '../utilities/OpenPromise.js';
-const log = logToStderr;
+//const log = logToStderr
 async function startIfInWorkerThread() {
     if (isMainThread || !parentPort) {
         return;
@@ -43,17 +43,18 @@ async function startIfInWorkerThread() {
     start(process.argv.slice(2));
 }
 export async function start(processArgs) {
+    const logger = new Logger();
     let args;
     try {
         const packageData = await readAndParseJsonFile(resolveToModuleRootDir("package.json"));
-        log(chalk.magentaBright(`Echogarden v${packageData.version}\n`));
+        logger.log(chalk.magentaBright(`Echogarden v${packageData.version}\n`));
         const command = processArgs[0];
         if (!command || command == "help") {
-            log(`Supported operations:\n\n${commandHelp.join("\n")}`);
+            logger.log(`Supported operations:\n\n${commandHelp.join("\n")}`);
             process.exit(0);
         }
         if (command == "--help") {
-            log(`There's no command called '--help'. Did you mean to run 'echogarden help'?`);
+            logger.log(`There's no command called '--help'. Did you mean to run 'echogarden help'?`);
             process.exit(0);
         }
         args = parseCLIArguments(command, processArgs.slice(1));
@@ -92,7 +93,7 @@ export async function start(processArgs) {
         }
     }
     catch (e) {
-        log(`Error: ${e.message}`);
+        logger.logTitledMessage(`Error`, e.message, chalk.redBright);
         process.exit(1);
     }
     let debugMode = false;
@@ -105,10 +106,10 @@ export async function start(processArgs) {
     }
     catch (e) {
         if (debugMode) {
-            log(e);
+            logger.log(e);
         }
         else {
-            log(`Error: ${e.message}`);
+            logger.logTitledMessage(`Error`, e.message, chalk.redBright);
         }
         process.exit(1);
     }
@@ -148,8 +149,11 @@ const commandHelp = [
     `    Uninstall one or more Echogarden packages\n`,
     `${executableName} ${chalk.magentaBright('list-packages')} [options...]`,
     `    List installed Echogarden packages\n`,
+    `${executableName} ${chalk.magentaBright('serve')} [options...]`,
+    `    Start a server\n`,
 ];
 async function startWithArgs(parsedArgs) {
+    const logger = new Logger();
     switch (parsedArgs.command) {
         case 'speak':
         case 'speak-file':
@@ -215,13 +219,13 @@ async function startWithArgs(parsedArgs) {
             break;
         }
         default: {
-            log(`Unknown command: ${parsedArgs.command}`);
+            logger.logTitledMessage(`Unknown command`, parsedArgs.command, chalk.redBright);
             process.exit(1);
         }
     }
 }
 async function speak(command, commandArgs, cliOptions) {
-    const progressLogger = new Logger();
+    const logger = new Logger();
     const mainArg = commandArgs[0];
     const outputFilenames = commandArgs.slice(1);
     if (mainArg == undefined) {
@@ -318,10 +322,10 @@ async function speak(command, commandArgs, cliOptions) {
     }
     async function onSegment(segmentData) {
         if (includesPartPattern) {
-            progressLogger.start("Writing output files for segment");
+            logger.start("Writing output files for segment");
         }
         await writeOutputFilesForSegment(outputFilenames, segmentData.index, segmentData.total, segmentData.audio, segmentData.timeline, segmentData.transcript, segmentData.language, allowOverwrite);
-        progressLogger.end();
+        logger.end();
         if (options.play) {
             let gainAmount = -3 - segmentData.peakDecibelsSoFar;
             //gainAmount = Math.min(gainAmount, 0)
@@ -330,12 +334,15 @@ async function speak(command, commandArgs, cliOptions) {
             await playAudioWithWordTimeline(audioWithAddedGain, segmentWordTimeline, segmentData.transcript);
         }
     }
-    const { synthesizedAudio, timeline } = await API.synthesizeSegments(textSegments, options, onSegment, undefined);
+    if (options.outputAudioFormat?.codec) {
+        options.outputAudioFormat.codec = undefined;
+    }
+    const { audio: synthesizedAudio, timeline } = await API.synthesize(textSegments, options, onSegment, undefined);
     if (plainText) {
         addWordTextOffsetsToTimeline(timeline, plainText);
     }
     if (outputFilenames.length > 0) {
-        progressLogger.start("\nWriting output files");
+        logger.start("\nWriting output files");
     }
     for (const outputFile of outputFilenames) {
         const partPatternMatch = outputFile.match(segmentFilenamePattern);
@@ -345,10 +352,10 @@ async function speak(command, commandArgs, cliOptions) {
         const fileSaver = getFileSaver(outputFile, allowOverwrite);
         await fileSaver(synthesizedAudio, timeline, textSegments.join("\n\n"), options.subtitles);
     }
-    progressLogger.end();
+    logger.end();
 }
 async function transcribe(commandArgs, cliOptions) {
-    const progressLogger = new Logger();
+    const logger = new Logger();
     const sourceFilename = commandArgs[0];
     const outputFilenames = commandArgs.slice(1);
     if (sourceFilename == undefined) {
@@ -366,11 +373,9 @@ async function transcribe(commandArgs, cliOptions) {
     const options = await cliOptionsMapToOptionsObject(cliOptions, "RecognitionOptions", additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
     const { includesPartPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
-    const { transcript, timeline: wordTimeline, rawAudio, language } = await API.recognizeFile(sourceFilename, options);
-    const { segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(wordTimeline, transcript, language, 'single', 'preserve');
-    addWordTextOffsetsToTimeline(segmentTimeline, transcript);
+    const { transcript, timeline, wordTimeline, inputRawAudio, language } = await API.recognize(sourceFilename, options);
     if (outputFilenames.length > 0) {
-        progressLogger.start("\nWriting output files");
+        logger.start("\nWriting output files");
     }
     for (const outputFile of outputFilenames) {
         const partPatternMatch = outputFile.match(segmentFilenamePattern);
@@ -378,16 +383,16 @@ async function transcribe(commandArgs, cliOptions) {
             continue;
         }
         const fileSaver = getFileSaver(outputFile, allowOverwrite);
-        await fileSaver(rawAudio, segmentTimeline, transcript, options.subtitles);
+        await fileSaver(inputRawAudio, timeline, transcript, options.subtitles);
     }
-    progressLogger.end();
+    logger.end();
     if (options.play) {
-        const normalizedAudio = normalizeAudioLevel(rawAudio);
+        const normalizedAudio = normalizeAudioLevel(inputRawAudio);
         await playAudioWithWordTimeline(normalizedAudio, wordTimeline, transcript);
     }
 }
 async function align(commandArgs, cliOptions) {
-    const progressLogger = new Logger();
+    const logger = new Logger();
     const audioFilename = commandArgs[0];
     const outputFilenames = commandArgs.slice(2);
     if (audioFilename == undefined) {
@@ -427,18 +432,16 @@ async function align(commandArgs, cliOptions) {
     const options = await cliOptionsMapToOptionsObject(cliOptions, "AlignmentOptions", additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
     const { includesPartPattern } = await checkOutputFilenames(outputFilenames, true, true, true);
-    const { wordTimeline, rawAudio, transcript, language } = await API.alignFile(audioFilename, text, options);
-    const { segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(wordTimeline, transcript, language, options.plainText?.paragraphBreaks, options.plainText?.whitespace);
-    addWordTextOffsetsToTimeline(segmentTimeline, transcript);
+    const { timeline, wordTimeline, transcript, language, inputRawAudio } = await API.align(audioFilename, text, options);
     if (outputFilenames.length > 0) {
-        progressLogger.start("\nWriting output files");
+        logger.start("\nWriting output files");
     }
     if (includesPartPattern) {
-        for (let segmentIndex = 0; segmentIndex < segmentTimeline.length; segmentIndex++) {
-            const segmentEntry = segmentTimeline[segmentIndex];
-            const segmentAudio = sliceRawAudioByTime(rawAudio, segmentEntry.startTime, segmentEntry.endTime);
+        for (let segmentIndex = 0; segmentIndex < timeline.length; segmentIndex++) {
+            const segmentEntry = timeline[segmentIndex];
+            const segmentAudio = sliceRawAudioByTime(inputRawAudio, segmentEntry.startTime, segmentEntry.endTime);
             const sentenceTimeline = addTimeOffsetToTimeline(segmentEntry.timeline, -segmentEntry.startTime);
-            await writeOutputFilesForSegment(outputFilenames, segmentIndex, segmentTimeline.length, segmentAudio, sentenceTimeline, segmentEntry.text, language, allowOverwrite);
+            await writeOutputFilesForSegment(outputFilenames, segmentIndex, timeline.length, segmentAudio, sentenceTimeline, segmentEntry.text, language, allowOverwrite);
         }
     }
     for (const outputFile of outputFilenames) {
@@ -447,17 +450,16 @@ async function align(commandArgs, cliOptions) {
             continue;
         }
         const fileSaver = getFileSaver(outputFile, allowOverwrite);
-        await fileSaver(rawAudio, segmentTimeline, transcript, options.subtitles);
+        await fileSaver(inputRawAudio, timeline, transcript, options.subtitles);
     }
-    progressLogger.end();
+    logger.end();
     if (options.play) {
-        const normalizedAudio = normalizeAudioLevel(rawAudio);
-        const wordTimeline = segmentTimeline.flatMap(segmentEntry => segmentEntry.timeline).flatMap(sentenceEntry => sentenceEntry.timeline);
+        const normalizedAudio = normalizeAudioLevel(inputRawAudio);
         await playAudioWithWordTimeline(normalizedAudio, wordTimeline, transcript);
     }
 }
 async function translateSpeech(commandArgs, cliOptions) {
-    const progressLogger = new Logger();
+    const logger = new Logger();
     const inputFilename = commandArgs[0];
     const outputFilenames = commandArgs.slice(1);
     if (inputFilename == undefined) {
@@ -475,11 +477,9 @@ async function translateSpeech(commandArgs, cliOptions) {
     const options = await cliOptionsMapToOptionsObject(cliOptions, "SpeechTranslationOptions", additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, true, true, true);
-    const { transcript, timeline: wordTimeline, rawAudio, targetLanguage } = await API.translateSpeechFile(inputFilename, options);
-    const { segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(wordTimeline, transcript, targetLanguage, 'single', 'preserve');
-    addWordTextOffsetsToTimeline(segmentTimeline, transcript);
+    const { transcript, timeline, wordTimeline, sourceLanguage, targetLanguage, inputRawAudio } = await API.translateSpeech(inputFilename, options);
     if (outputFilenames.length > 0) {
-        progressLogger.start("\nWriting output files");
+        logger.start("\nWriting output files");
     }
     for (const outputFile of outputFilenames) {
         const partPatternMatch = outputFile.match(segmentFilenamePattern);
@@ -487,16 +487,16 @@ async function translateSpeech(commandArgs, cliOptions) {
             continue;
         }
         const fileSaver = getFileSaver(outputFile, allowOverwrite);
-        await fileSaver(rawAudio, segmentTimeline, transcript, options.subtitles);
+        await fileSaver(inputRawAudio, timeline, transcript, options.subtitles);
     }
-    progressLogger.end();
+    logger.end();
     if (options.play) {
-        const normalizedAudio = normalizeAudioLevel(rawAudio);
+        const normalizedAudio = normalizeAudioLevel(inputRawAudio);
         await playAudioWithWordTimeline(normalizedAudio, wordTimeline, transcript);
     }
 }
 async function detectLanguage(commandArgs, cliOptions, mode) {
-    const progressLogger = new Logger();
+    const logger = new Logger();
     const inputFilePath = commandArgs[0];
     const outputFilenames = commandArgs.slice(1);
     if (!existsSync(inputFilePath)) {
@@ -532,11 +532,11 @@ async function detectLanguage(commandArgs, cliOptions, mode) {
         const options = await cliOptionsMapToOptionsObject(cliOptions, "SpeechLanguageDetectionOptions", additionalOptionsSchema);
         allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
         await checkOutputFilenames(outputFilenames, false, true, false);
-        const { detectedLanguage, detectedLanguageProbabilities } = await API.detectSpeechFileLanguage(inputFilePath, options);
+        const { detectedLanguage, detectedLanguageProbabilities } = await API.detectSpeechLanguage(inputFilePath, options);
         results = detectedLanguageProbabilities;
     }
     if (outputFilenames.length > 0) {
-        progressLogger.start("\nWriting output files");
+        logger.start("\nWriting output files");
         const resultsAsText = results.map(result => `${formatLanguageCodeWithName(result.language)}: ${result.probability.toFixed(5)}`).join("\n");
         for (const outputFile of outputFilenames) {
             const fileSaver = getFileSaver(outputFile, allowOverwrite);
@@ -545,13 +545,13 @@ async function detectLanguage(commandArgs, cliOptions, mode) {
     }
     else {
         const resultsAsText = results.slice(0, 10).map(result => `${formatLanguageCodeWithName(result.language)}: ${result.probability.toFixed(5)}`).join("\n");
-        log("");
-        log(resultsAsText);
+        logger.log("");
+        logger.log(resultsAsText);
     }
-    progressLogger.end();
+    logger.end();
 }
 async function detectVoiceActivity(commandArgs, cliOptions) {
-    const progressLogger = new Logger();
+    const logger = new Logger();
     const audioFilename = commandArgs[0];
     const outputFilenames = commandArgs.slice(1);
     if (audioFilename == undefined) {
@@ -569,9 +569,9 @@ async function detectVoiceActivity(commandArgs, cliOptions) {
     const options = await cliOptionsMapToOptionsObject(cliOptions, "VADOptions", additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, true, true, false);
-    const { timeline, rawAudio } = await API.detectFileVoiceActivity(audioFilename, options);
+    const { timeline, inputRawAudio } = await API.detectVoiceActivity(audioFilename, options);
     if (outputFilenames.length > 0) {
-        progressLogger.start("\nWriting output files");
+        logger.start("\nWriting output files");
     }
     for (const outputFile of outputFilenames) {
         const partPatternMatch = outputFile.match(segmentFilenamePattern);
@@ -579,16 +579,19 @@ async function detectVoiceActivity(commandArgs, cliOptions) {
             continue;
         }
         const fileSaver = getFileSaver(outputFile, allowOverwrite);
-        await fileSaver(rawAudio, timeline, "");
+        await fileSaver(inputRawAudio, timeline, "");
     }
-    progressLogger.end();
+    logger.end();
     if (options.play) {
-        const normalizedAudio = normalizeAudioLevel(rawAudio);
-        await playAudioWithWordTimeline(normalizedAudio, timeline);
+        const normalizedAudio = normalizeAudioLevel(inputRawAudio);
+        const timelineToPlay = timeline.map(entry => {
+            return { ...entry, type: "word" };
+        });
+        await playAudioWithWordTimeline(normalizedAudio, timelineToPlay);
     }
 }
 async function denoise(commandArgs, cliOptions) {
-    const progressLogger = new Logger();
+    const logger = new Logger();
     const audioFilename = commandArgs[0];
     const outputFilenames = commandArgs.slice(1);
     if (audioFilename == undefined) {
@@ -606,17 +609,17 @@ async function denoise(commandArgs, cliOptions) {
     const options = await cliOptionsMapToOptionsObject(cliOptions, "DenoisingOptions", additionalOptionsSchema);
     const allowOverwrite = getWithDefault(options.overwrite, overwriteByDefault);
     await checkOutputFilenames(outputFilenames, true, false, false);
-    const outputAudio = await API.denoiseFile(audioFilename, options);
+    const { denoisedAudio } = await API.denoise(audioFilename, options);
     if (outputFilenames.length > 0) {
-        progressLogger.start("\nWriting output files");
+        logger.start("\nWriting output files");
     }
     for (const filename of outputFilenames) {
         const fileSaver = getFileSaver(filename, allowOverwrite);
-        await fileSaver(outputAudio, [], "");
+        await fileSaver(denoisedAudio, [], "");
     }
-    progressLogger.end();
+    logger.end();
     if (options.play) {
-        await playAudioSamples(outputAudio);
+        await playAudioSamples(denoisedAudio);
     }
 }
 async function listEngines(commandArgs, cliOptions) {
@@ -686,12 +689,12 @@ async function listEngines(commandArgs, cliOptions) {
         logger.logTitledMessage('Description', engine.description);
         logger.logTitledMessage('Type', engine.type);
         if (index < engines.length - 1) {
-            log("");
+            logger.log("");
         }
     }
 }
 async function listTTSVoices(commandArgs, cliOptions) {
-    const progressLogger = new Logger();
+    const logger = new Logger();
     const targetEngine = commandArgs[0];
     const outputFilenames = commandArgs.slice(1);
     if (!targetEngine) {
@@ -718,7 +721,7 @@ async function listTTSVoices(commandArgs, cliOptions) {
         return entryText;
     }).join("\n\n");
     if (outputFilenames.length > 0) {
-        progressLogger.start("\nWriting output files");
+        logger.start("\nWriting output files");
         for (const filename of outputFilenames) {
             const fileSaver = getFileSaver(filename, allowOverwrite);
             const { default: stripAnsi } = await import('strip-ansi');
@@ -727,11 +730,12 @@ async function listTTSVoices(commandArgs, cliOptions) {
         }
     }
     else {
-        log(voiceListText);
+        logger.log(voiceListText);
     }
-    progressLogger.end();
+    logger.end();
 }
 async function installPackages(commandArgs, cliOptions) {
+    const logger = new Logger();
     if (commandArgs.length == 0) {
         throw new Error("No package names specified");
     }
@@ -741,20 +745,21 @@ async function installPackages(commandArgs, cliOptions) {
             await loadPackage(packageName);
         }
         catch (e) {
-            log(`Failed installing package ${packageName}: ${e}`);
+            logger.log(`Failed installing package ${packageName}: ${e}`);
             failedPackageNames.push(packageName);
         }
     }
     if (failedPackageNames.length > 0) {
         if (failedPackageNames.length == 1) {
-            log(`The package ${failedPackageNames[0]} failed to install`);
+            logger.log(`The package ${failedPackageNames[0]} failed to install`);
         }
         else {
-            log(`The packages ${failedPackageNames.join(', ')} failed to install`);
+            logger.log(`The packages ${failedPackageNames.join(', ')} failed to install`);
         }
     }
 }
 async function uninstallPackages(commandArgs, cliOptions) {
+    const logger = new Logger();
     if (commandArgs.length == 0) {
         throw new Error("No package names specified");
     }
@@ -764,15 +769,16 @@ async function uninstallPackages(commandArgs, cliOptions) {
             await removePackage(packageName);
         }
         catch (e) {
-            log(`Failed uninstalling package ${packageName}: ${e}`);
+            logger.log(`Failed uninstalling package ${packageName}: ${e}`);
             failedPackageNames.push(packageName);
         }
     }
     if (failedPackageNames.length > 0) {
-        log(`The packages ${failedPackageNames.join(', ')} failed to uninstall`);
+        logger.log(`The packages ${failedPackageNames.join(', ')} failed to uninstall`);
     }
 }
 async function listPackages(commandArgs, cliOptions) {
+    const logger = new Logger();
     const packagesDir = await ensureAndGetPackagesDir();
     const installedPackageNames = await readdir(packagesDir);
     const installedPackageNamesFormatted = installedPackageNames.map(packageName => {
@@ -790,8 +796,8 @@ async function listPackages(commandArgs, cliOptions) {
         }
     });
     installedPackageNamesFormatted.sort();
-    log(`Total of ${installedPackageNamesFormatted.length} packages installed in '${packagesDir}'\n`);
-    log(installedPackageNamesFormatted.join("\n"));
+    logger.log(`Total of ${installedPackageNamesFormatted.length} packages installed in '${packagesDir}'\n`);
+    logger.log(installedPackageNamesFormatted.join("\n"));
 }
 async function startServer(commandArgs, cliOptions) {
     const options = await cliOptionsMapToOptionsObject(cliOptions, "ServerOptions");
@@ -1003,49 +1009,7 @@ function getFileSaver(outputFilePath, allowOverwrite) {
     }
     else if (supportedOutputMediaFileExtensions.includes(fileExtension)) {
         fileSaver = async (audio) => {
-            let ffmpegOptions;
-            if (fileExtension == "mp3") {
-                ffmpegOptions = {
-                    format: "mp3",
-                    codec: "libmp3lame",
-                    bitrate: 64,
-                    customOptions: []
-                };
-            }
-            else if (fileExtension == "opus") {
-                ffmpegOptions = {
-                    codec: "libopus",
-                    bitrate: 48,
-                    customOptions: []
-                };
-            }
-            else if (fileExtension == "m4a") {
-                ffmpegOptions = {
-                    format: "mp4",
-                    codec: "aac",
-                    bitrate: 48,
-                    customOptions: ["-profile:a", "aac_low", "-movflags", "frag_keyframe+empty_moov"]
-                };
-            }
-            else if (fileExtension == "ogg") {
-                ffmpegOptions = {
-                    codec: "libvorbis",
-                    bitrate: 48,
-                    customOptions: []
-                };
-            }
-            else if (fileExtension == "flac") {
-                ffmpegOptions = {
-                    format: "flac",
-                    customOptions: ["-compression_level", "6"]
-                };
-            }
-            else {
-                ffmpegOptions = {
-                    format: fileExtension,
-                    customOptions: []
-                };
-            }
+            const ffmpegOptions = getDefaultFFMpegOptionsForSpeech(fileExtension);
             ffmpegOptions.filename = outputFilePath;
             await ensureDir(fileDir);
             await encodeFromChannels(audio, ffmpegOptions);