echogarden 0.12.2 → 1.0.0

package/dist/api/Synthesis.js

@@ -1,20 +1,22 @@
-import path from "node:path";
-import { deepClone, extendDeep } from "../utilities/ObjectUtilities.js";
-import * as FFMpegTranscoder from "../codecs/FFMpegTranscoder.js";
-import { clip, convertHtmlToText, sha256AsHex, simplifyPunctuationCharacters, stringifyAndFormatJson, logToStderr, yieldToEventLoop, runOperationWithRetries } from "../utilities/Utilities.js";
-import { concatAudioSegments, downmixToMono, encodeWaveBuffer, getAudioPeakDecibels, getEmptyRawAudio, getRawAudioDuration, normalizeAudioLevel, trimAudioEnd, trimAudioStart } from "../audio/AudioUtilities.js";
-import { Logger } from "../utilities/Logger.js";
-import { isWordOrSymbolWord, splitToParagraphs, splitToSentences } from "../nlp/Segmentation.js";
-import { loadLexiconsForLanguage } from "../nlp/Lexicon.js";
-import * as API from "./API.js";
-import { addTimeOffsetToTimeline, multiplyTimelineByFactor } from "../utilities/Timeline.js";
-import { getAppDataDir, ensureDir, existsSync, isFileIsUpToDate, readAndParseJsonFile, writeFileSafe } from "../utilities/FileSystem.js";
-import { formatLanguageCodeWithName, getShortLanguageCode, normalizeLanguageCode, defaultDialectForLanguageCode } from "../utilities/Locale.js";
-import { loadPackage } from "../utilities/PackageManager.js";
-import { appName } from "./Common.js";
-import { shouldCancelCurrentTask } from "../server/Worker.js";
-import chalk from "chalk";
-import { defaultSubtitlesBaseConfig } from "../subtitles/Subtitles.js";
+import path from 'node:path';
+import { deepClone, extendDeep } from '../utilities/ObjectUtilities.js';
+import * as FFMpegTranscoder from '../codecs/FFMpegTranscoder.js';
+import { clip, convertHtmlToText, sha256AsHex, simplifyPunctuationCharacters, stringifyAndFormatJson, logToStderr, yieldToEventLoop, runOperationWithRetries } from '../utilities/Utilities.js';
+import { attenuateIfClipping, concatAudioSegments, downmixToMono, encodeRawAudioToWave, getSamplePeakDecibels, getEmptyRawAudio, getRawAudioDuration, normalizeAudioLevel, trimAudioEnd, trimAudioStart } from '../audio/AudioUtilities.js';
+import { Logger } from '../utilities/Logger.js';
+import { isWordOrSymbolWord, splitToParagraphs, splitToSentences } from '../nlp/Segmentation.js';
+import { loadLexiconsForLanguage } from '../nlp/Lexicon.js';
+import * as API from './API.js';
+import { addTimeOffsetToTimeline, multiplyTimelineByFactor } from '../utilities/Timeline.js';
+import { getAppDataDir, ensureDir, existsSync, isFileIsUpToDate, readAndParseJsonFile, writeFileSafe } from '../utilities/FileSystem.js';
+import { formatLanguageCodeWithName, getShortLanguageCode, normalizeLanguageCode, defaultDialectForLanguageCode } from '../utilities/Locale.js';
+import { loadPackage } from '../utilities/PackageManager.js';
+import { appName } from './Common.js';
+import { shouldCancelCurrentTask } from '../server/Worker.js';
+import chalk from 'chalk';
+import { defaultSubtitlesBaseConfig } from '../subtitles/Subtitles.js';
+import { defaultOpenAICloudTTSOptions } from '../synthesis/OpenAICloudTTS.js';
+import { defaultElevenlabsTTSOptions } from '../synthesis/ElevenlabsTTS.js';
 const log = logToStderr;
 /////////////////////////////////////////////////////////////////////////////////////////////
 // Synthesis
@@ -38,7 +40,7 @@ async function synthesizeSegments(segments, options, onSegment, onSentence) {
     const logger = new Logger();
     options = extendDeep(defaultSynthesisOptions, options);
     if (!options.language && !options.voice) {
-        logger.start("No language or voice specified. Detecting language");
+        logger.start('No language or voice specified. Detecting language');
         let segmentsPlainText = segments;
         if (options.ssml) {
             segmentsPlainText = [];
@@ -46,7 +48,7 @@ async function synthesizeSegments(segments, options, onSegment, onSentence) {
                 segmentsPlainText.push(await convertHtmlToText(segment));
             }
         }
-        const { detectedLanguage } = await API.detectTextLanguage(segmentsPlainText.join("\n\n"), options.languageDetection || {});
+        const { detectedLanguage } = await API.detectTextLanguage(segmentsPlainText.join('\n\n'), options.languageDetection || {});
         options.language = detectedLanguage;
         logger.end();
         logger.logTitledMessage('Language detected', formatLanguageCodeWithName(detectedLanguage));
@@ -61,7 +63,7 @@ async function synthesizeSegments(segments, options, onSegment, onSentence) {
     logger.start(`Get voice list for ${options.engine}`);
     const { bestMatchingVoice } = await requestVoiceList(options);
     if (!bestMatchingVoice) {
-        throw new Error("No matching voice found");
+        throw new Error('No matching voice found');
     }
     options.voice = bestMatchingVoice.name;
     if (!options.language) {
@@ -76,21 +78,21 @@ async function synthesizeSegments(segments, options, onSegment, onSentence) {
     let timeOffset = 0;
     for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
         const segmentText = segments[segmentIndex].trim();
-        logger.log(`\n${chalk.magentaBright(`Synthesizing segment ${segmentIndex + 1}/${segments.length}`)}: "${segmentText}"`);
+        logger.log(`\n${chalk.magentaBright(`Synthesizing segment ${segmentIndex + 1}/${segments.length}`)}: '${segmentText}'`);
         const segmentStartTime = timeOffset;
         const segmentEntry = {
-            type: "segment",
+            type: 'segment',
             text: segmentText,
             startTime: timeOffset,
             endTime: -1,
             timeline: []
         };
         let sentences;
-        if ((options.splitToSentences || options.engine == "vits") && !options.ssml) {
+        if ((options.splitToSentences || options.engine == 'vits') && !options.ssml) {
             sentences = splitToSentences(segmentText, options.language);
-            sentences = sentences.filter(sentence => sentence.trim() != "");
+            sentences = sentences.filter(sentence => sentence.trim() != '');
             if (sentences.length == 0) {
-                sentences = [""];
+                sentences = [''];
             }
         }
         else {
@@ -101,8 +103,8 @@ async function synthesizeSegments(segments, options, onSegment, onSentence) {
         for (let sentenceIndex = 0; sentenceIndex < sentences.length; sentenceIndex++) {
             await yieldToEventLoop();
             if (shouldCancelCurrentTask()) {
-                //log("\n\n\n\n\nCANCELED\n\n\n\n")
-                throw new Error("Canceled");
+                //log('\n\n\n\n\nCANCELED\n\n\n\n')
+                throw new Error('Canceled');
             }
             const sentenceText = sentences[sentenceIndex].trim();
             logger.log(`\n${chalk.magentaBright(`Synthesizing sentence ${sentenceIndex + 1}/${sentences.length}`)}: "${sentenceText}"`);
@@ -121,13 +123,13 @@ async function synthesizeSegments(segments, options, onSegment, onSentence) {
             const sentenceTimelineWithOffset = addTimeOffsetToTimeline(sentenceTimeline, sentenceStartTime);
             const sentenceEndTime = timeOffset - endPause;
             segmentEntry.timeline.push({
-                type: "sentence",
+                type: 'sentence',
                 text: sentenceText,
                 startTime: sentenceStartTime,
                 endTime: sentenceEndTime,
                 timeline: sentenceTimelineWithOffset
             });
-            peakDecibelsSoFar = Math.max(peakDecibelsSoFar, getAudioPeakDecibels(sentenceRawAudio.audioChannels));
+            peakDecibelsSoFar = Math.max(peakDecibelsSoFar, getSamplePeakDecibels(sentenceRawAudio.audioChannels));
             const sentenceAudio = await convertToTargetCodecIfNeeded(sentenceRawAudio);
             if (onSentence) {
                 await onSentence({
@@ -176,7 +178,10 @@ async function synthesizeSegments(segments, options, onSegment, onSentence) {
         const joinedAudioBuffers = concatAudioSegments(segmentsRawAudio.map(part => part.audioChannels));
         resultRawAudio = { audioChannels: joinedAudioBuffers, sampleRate: segmentsRawAudio[0].sampleRate };
         if (options.postProcessing.normalizeAudio) {
-            resultRawAudio = normalizeAudioLevel(resultRawAudio, options.postProcessing.targetPeakDb, options.postProcessing.maxIncreaseDb);
+            resultRawAudio = normalizeAudioLevel(resultRawAudio, options.postProcessing.targetPeak, options.postProcessing.maxGainIncrease);
+        }
+        else {
+            resultRawAudio = attenuateIfClipping(resultRawAudio);
         }
     }
     else {
@@ -187,8 +192,8 @@ async function synthesizeSegments(segments, options, onSegment, onSentence) {
         let output;
         if (targetCodec) {
             logger.start(`Convert to ${targetCodec} codec`);
-            if (targetCodec == "wav") {
-                output = encodeWaveBuffer(rawAudio);
+            if (targetCodec == 'wav') {
+                output = encodeRawAudioToWave(rawAudio);
             }
             else {
                 const ffmpegOptions = FFMpegTranscoder.getDefaultFFMpegOptionsForSpeech(targetCodec, options.outputAudioFormat?.bitrate);
@@ -212,13 +217,13 @@ async function synthesizeSegments(segments, options, onSegment, onSentence) {
 async function synthesizeSegment(text, options) {
     const logger = new Logger();
     const startTimestamp = logger.getTimestamp();
-    logger.start("Prepare for synthesis");
+    logger.start('Prepare for synthesis');
     const simplifiedText = simplifyPunctuationCharacters(text);
     const engine = options.engine;
     logger.start(`Get voice list for ${engine}`);
     const { bestMatchingVoice } = await requestVoiceList(options);
     if (!bestMatchingVoice) {
-        throw new Error("No matching voice found");
+        throw new Error('No matching voice found');
     }
     const selectedVoice = bestMatchingVoice;
     let voicePackagePath;
@@ -238,22 +243,22 @@ async function synthesizeSegment(text, options) {
     let shouldPostprocessSpeed = false;
     let shouldPostprocessPitch = false;
     switch (engine) {
-        case "vits": {
+        case 'vits': {
             if (inputIsSSML) {
                 throw new Error(`The VITS engine doesn't currently support SSML inputs`);
             }
             let vitsLanguage = language;
-            if (vitsLanguage == "en") {
-                vitsLanguage = "en-us";
+            if (vitsLanguage == 'en') {
+                vitsLanguage = 'en-us';
             }
-            const vitsTTS = await import("../synthesis/VitsTTS.js");
+            const vitsTTS = await import('../synthesis/VitsTTS.js');
             const lengthScale = 1 / speed;
             const engineOptions = options.vits;
             const speakerId = engineOptions.speakerId;
             if (speakerId != undefined) {
                 if (selectedVoice.speakerCount == undefined) {
                     if (speakerId != 0) {
-                        throw new Error("Selected VITS model has only one speaker. Speaker ID must be 0 if specified.");
+                        throw new Error('Selected VITS model has only one speaker. Speaker ID must be 0 if specified.');
                     }
                 }
                 else if (speakerId < 0 || speakerId >= selectedVoice.speakerCount) {
@@ -270,15 +275,15 @@ async function synthesizeSegment(text, options) {
             logger.end();
             break;
         }
-        case "pico": {
+        case 'pico': {
             if (inputIsSSML) {
                 throw new Error(`The SVOX Pico engine doesn't currently support SSML inputs`);
             }
-            const SvoxPicoTTS = await import("../synthesis/SvoxPicoTTS.js");
+            const SvoxPicoTTS = await import('../synthesis/SvoxPicoTTS.js');
             const picoSpeed = Math.round(speed * 1.0 * 100);
             const picoPitch = Math.round(pitch * 1.0 * 100);
             const picoVolume = 35.0;
-            const preparedText = `<speed level="${picoSpeed}"><pitch level="${picoPitch}"><volume level="${picoVolume}">${simplifiedText}</volume></pitch></speed>`;
+            const preparedText = `<speed level='${picoSpeed}'><pitch level='${picoPitch}'><volume level='${picoVolume}'>${simplifiedText}</volume></pitch></speed>`;
             logger.end();
             const { textAnalysisFilename, signalGenerationFilename } = SvoxPicoTTS.getResourceFilenamesForLanguage(language);
             const resourceFilePath = path.resolve(voicePackagePath, textAnalysisFilename);
@@ -287,19 +292,19 @@ async function synthesizeSegment(text, options) {
             synthesizedAudio = rawAudio;
             break;
         }
-        case "flite": {
+        case 'flite': {
             if (inputIsSSML) {
                 throw new Error(`The Flite engine doesn't currently support SSML inputs`);
             }
-            const FliteTTS = await import("../synthesis/FliteTTS.js");
+            const FliteTTS = await import('../synthesis/FliteTTS.js');
             logger.end();
             const { rawAudio, events } = await FliteTTS.synthesize(simplifiedText, voice, voicePackagePath, speed);
             synthesizedAudio = rawAudio;
             shouldPostprocessPitch = true;
             break;
         }
-        case "espeak": {
-            const EspeakTTS = await import("../synthesis/EspeakTTS.js");
+        case 'espeak': {
+            const EspeakTTS = await import('../synthesis/EspeakTTS.js');
             const engineOptions = options.espeak;
             const espeakVoice = voice;
             const espeakLanguage = selectedVoice.languages[0];
@@ -307,13 +312,15 @@ async function synthesizeSegment(text, options) {
             const espeakPitch = engineOptions.pitch || options.pitch * 50;
             const espeakPitchRange = engineOptions.pitchRange || options.pitchVariation * 50;
             const espeakUseKlatt = engineOptions.useKlatt || false;
+            const espeakInsertSeparators = engineOptions.insertSeparators || false;
             const espeakOptions = {
                 voice: espeakVoice,
                 ssml: inputIsSSML,
                 rate: espeakRate,
                 pitch: espeakPitch,
                 pitchRange: espeakPitchRange,
-                useKlatt: espeakUseKlatt
+                useKlatt: espeakUseKlatt,
+                insertSeparators: espeakInsertSeparators,
             };
             if (inputIsSSML) {
                 logger.end();
@@ -329,11 +336,11 @@ async function synthesizeSegment(text, options) {
             }
             break;
         }
-        case "sam": {
+        case 'sam': {
             if (inputIsSSML) {
                 throw new Error(`The SAM engine doesn't support SSML inputs`);
             }
-            const SamTTS = await import("../synthesis/SamTTS.js");
+            const SamTTS = await import('../synthesis/SamTTS.js');
             const engineOptions = options.sam;
             const samPitch = clip(engineOptions.pitch || Math.round((1 / pitch) * 64), 0, 255);
             const samSpeed = clip(engineOptions.speed || Math.round((1 / speed) * 72), 0, 255);
@@ -344,11 +351,11 @@ async function synthesizeSegment(text, options) {
             synthesizedAudio = rawAudio;
             break;
         }
-        case "sapi": {
+        case 'sapi': {
             if (inputIsSSML) {
                 throw new Error(`The SAPI engine doesn't currently support SSML inputs`);
             }
-            const SapiTTS = await import("../synthesis/SapiTTS.js");
+            const SapiTTS = await import('../synthesis/SapiTTS.js');
             await SapiTTS.AssertSAPIAvailable(false);
             const engineOptions = options.sapi;
             const sapiRate = engineOptions.rate || 0;
@@ -360,11 +367,11 @@ async function synthesizeSegment(text, options) {
             shouldPostprocessPitch = true;
             break;
         }
-        case "msspeech": {
+        case 'msspeech': {
             if (inputIsSSML) {
                 throw new Error(`The MSSpeech engine doesn't currently support SSML inputs`);
             }
-            const SapiTTS = await import("../synthesis/SapiTTS.js");
+            const SapiTTS = await import('../synthesis/SapiTTS.js');
             await SapiTTS.AssertSAPIAvailable(true);
             const engineOptions = options.msspeech;
             const sapiRate = engineOptions.rate || 0;
@@ -376,11 +383,11 @@ async function synthesizeSegment(text, options) {
             shouldPostprocessPitch = true;
             break;
         }
-        case "coqui-server": {
+        case 'coqui-server': {
             if (inputIsSSML) {
                 throw new Error(`The Coqui Server engine doesn't support SSML inputs`);
             }
-            const CoquiServerTTS = await import("../synthesis/CoquiServerTTS.js");
+            const CoquiServerTTS = await import('../synthesis/CoquiServerTTS.js');
             const engineOptions = options.coquiServer;
             const speakerId = engineOptions.speakerId;
             const serverUrl = engineOptions.serverUrl;
@@ -394,12 +401,12 @@ async function synthesizeSegment(text, options) {
             shouldPostprocessPitch = true;
             break;
         }
-        case "google-cloud": {
-            const GoogleCloudTTS = await import("../synthesis/GoogleCloudTTS.js");
+        case 'google-cloud': {
+            const GoogleCloudTTS = await import('../synthesis/GoogleCloudTTS.js');
             const engineOptions = options.googleCloud;
             const apiKey = engineOptions.apiKey;
             if (!apiKey) {
-                throw new Error(`No API key given`);
+                throw new Error(`No Google Cloud API key provided`);
             }
             let pitchDeltaSemitones;
             // 1 semitone up = multiply by 1.05946
@@ -419,16 +426,16 @@ async function synthesizeSegment(text, options) {
             synthesizedAudio = rawAudio;
             break;
         }
-        case "microsoft-azure": {
-            const AzureCognitiveServicesTTS = await import("../synthesis/AzureCognitiveServicesTTS.js");
+        case 'microsoft-azure': {
+            const AzureCognitiveServicesTTS = await import('../synthesis/AzureCognitiveServicesTTS.js');
             const engineOptions = options.microsoftAzure;
             const subscriptionKey = engineOptions.subscriptionKey;
             if (!subscriptionKey) {
-                throw new Error(`No subscription key given`);
+                throw new Error(`No Microsoft Azure subscription key provided`);
             }
             const serviceRegion = engineOptions.serviceRegion;
             if (!serviceRegion) {
-                throw new Error(`No service region given`);
+                throw new Error(`No Microsoft Azure service region provided`);
             }
             let ssmlPitch;
             if (engineOptions.pitchDeltaHz != undefined) {
@@ -449,20 +456,20 @@ async function synthesizeSegment(text, options) {
             timeline = outTimeline;
             break;
         }
-        case "amazon-polly": {
-            const AwsPollyTTS = await import("../synthesis/AwsPollyTTS.js");
+        case 'amazon-polly': {
+            const AwsPollyTTS = await import('../synthesis/AwsPollyTTS.js');
             const engineOptions = options.amazonPolly;
             const region = engineOptions.region;
             if (!region) {
-                throw new Error(`No region given`);
+                throw new Error(`No Amazon Polly region provided`);
             }
             const accessKeyId = engineOptions.accessKeyId;
             if (!accessKeyId) {
-                throw new Error(`No access key id given`);
+                throw new Error(`No Amazon Polly access key id provided`);
             }
             const secretAccessKey = engineOptions.secretAccessKey;
             if (!secretAccessKey) {
-                throw new Error(`No secret access key given`);
+                throw new Error(`No Amazon Polly secret access key provided`);
             }
             const pollyEngine = engineOptions.pollyEngine;
             const lexiconNames = engineOptions.lexiconNames;
@@ -473,32 +480,41 @@ async function synthesizeSegment(text, options) {
             shouldPostprocessPitch = true;
             break;
         }
-        case "elevenlabs": {
+        case 'openai-cloud': {
+            const OpenAICloudTTS = await import('../synthesis/OpenAICloudTTS.js');
+            const openAICloudTTSOptions = options.openAICloud;
+            if (!openAICloudTTSOptions.apiKey) {
+                throw new Error(`No API key given`);
+            }
+            logger.end();
+            synthesizedAudio = await OpenAICloudTTS.synthesize(text, voice, speed, openAICloudTTSOptions);
+            shouldPostprocessSpeed = false;
+            shouldPostprocessPitch = true;
+            break;
+        }
+        case 'elevenlabs': {
             if (inputIsSSML) {
                 throw new Error(`The Elevenlabs engine doesn't support SSML inputs`);
             }
-            const ElevenLabsTTS = await import("../synthesis/ElevenLabsTTS.js");
+            const ElevenLabsTTS = await import('../synthesis/ElevenlabsTTS.js');
             const engineOptions = options.elevenlabs;
-            const apiKey = engineOptions.apiKey;
-            if (!apiKey) {
-                throw new Error(`No ElevenLabs API key given`);
+            if (!engineOptions.apiKey) {
+                throw new Error(`No ElevenLabs API key provided`);
             }
-            const voiceId = selectedVoice["elevenLabsVoiceId"];
-            const modelId = selectedVoice["elevenLabsModelId"];
-            const stability = engineOptions.stability;
-            const similarityBoost = engineOptions.similarityBoost;
+            const voiceId = selectedVoice['elevenLabsVoiceId'];
+            const modelId = selectedVoice['elevenLabsModelId'];
             logger.end();
-            const { rawAudio } = await ElevenLabsTTS.synthesize(text, voiceId, apiKey, modelId, stability, similarityBoost);
+            const { rawAudio } = await ElevenLabsTTS.synthesize(text, voiceId, modelId, engineOptions);
             synthesizedAudio = rawAudio;
             shouldPostprocessSpeed = true;
             shouldPostprocessPitch = true;
             break;
         }
-        case "google-translate": {
+        case 'google-translate': {
             if (inputIsSSML) {
                 throw new Error(`The Google Translate engine doesn't support SSML inputs`);
             }
-            const GoogleTranslateTTS = await import("../synthesis/GoogleTranslateTTS.js");
+            const GoogleTranslateTTS = await import('../synthesis/GoogleTranslateTTS.js');
             logger.end();
             const { rawAudio, timeline: segmentTimeline } = await runOperationWithRetries(() => GoogleTranslateTTS.synthesizeLongText(text, language, options.googleTranslate?.tld, options.sentenceEndPause, options.segmentEndPause), logger);
             synthesizedAudio = rawAudio;
@@ -509,18 +525,18 @@ async function synthesizeSegment(text, options) {
             shouldPostprocessPitch = true;
             break;
         }
-        case "microsoft-edge": {
+        case 'microsoft-edge': {
             if (inputIsSSML) {
                 throw new Error(`The Microsoft Edge engine doesn't support SSML inputs`);
             }
-            const MicrosoftEdgeTTS = await import("../synthesis/MicrosoftEdgeTTS.js");
+            const MicrosoftEdgeTTS = await import('../synthesis/MicrosoftEdgeTTS.js');
             const engineOptions = options.microsoftEdge;
             const trustedClientToken = engineOptions.trustedClientToken;
             if (!trustedClientToken) {
-                throw new Error("No trusted client token provided.");
+                throw new Error('No Microsoft Edge trusted client token provided');
             }
-            if (await sha256AsHex(trustedClientToken) != "558d7c6a7f7db444895946fe23a54ad172fd6d159f46cb34dd4db21bb27c07d7") {
-                throw new Error("Trusted client token is incorrect.");
+            if (await sha256AsHex(trustedClientToken) != '558d7c6a7f7db444895946fe23a54ad172fd6d159f46cb34dd4db21bb27c07d7') {
+                throw new Error('Trusted client token is incorrect.');
             }
             let ssmlPitch;
             if (engineOptions.pitchDeltaHz != undefined) {
@@ -541,11 +557,11 @@ async function synthesizeSegment(text, options) {
             timeline = edgeTimeline;
             break;
         }
-        case "streamlabs-polly": {
+        case 'streamlabs-polly': {
             if (inputIsSSML) {
                 throw new Error(`The Streamlabs Polly Engine engine doesn't support SSML inputs`);
             }
-            const StreamlabsPollyTTS = await import("../synthesis/StreamlabsPollyTTS.js");
+            const StreamlabsPollyTTS = await import('../synthesis/StreamlabsPollyTTS.js');
             logger.end();
             const { rawAudio, timeline: segmentTimeline } = await StreamlabsPollyTTS.synthesizeLongText(text, voice, language, options.sentenceEndPause, options.segmentEndPause);
             synthesizedAudio = rawAudio;
@@ -560,10 +576,13 @@ async function synthesizeSegment(text, options) {
             throw new Error(`Engine '${options.engine}' is not supported`);
         }
     }
-    logger.start("Postprocess synthesized audio");
+    logger.start('Postprocess synthesized audio');
     synthesizedAudio = downmixToMono(synthesizedAudio);
     if (options.postProcessing.normalizeAudio) {
-        synthesizedAudio = normalizeAudioLevel(synthesizedAudio, options.postProcessing.targetPeakDb, options.postProcessing.maxIncreaseDb);
+        synthesizedAudio = normalizeAudioLevel(synthesizedAudio, options.postProcessing.targetPeak, options.postProcessing.maxGainIncrease);
+    }
+    else {
+        synthesizedAudio = attenuateIfClipping(synthesizedAudio);
     }
     const preTrimSampleCount = synthesizedAudio.audioChannels[0].length;
     synthesizedAudio.audioChannels[0] = trimAudioStart(synthesizedAudio.audioChannels[0]);
@@ -573,7 +592,7 @@ async function synthesizeSegment(text, options) {
         timeline = addTimeOffsetToTimeline(timeline, newDuration - oldDuration);
     }
     if (!timeline) {
-        logger.start("Align synthesized audio with text");
+        logger.start('Align synthesized audio with text');
         let plainText = text;
         if (inputIsSSML) {
             plainText = await convertHtmlToText(text);
@@ -600,15 +619,15 @@ async function synthesizeSegment(text, options) {
         pitchShiftFactor = pitch;
     }
     if ((timeStretchFactor != undefined && timeStretchFactor != 1.0) || (pitchShiftFactor != undefined && pitchShiftFactor != 1.0)) {
-        logger.start("Apply time and pitch shifting");
+        logger.start('Apply time and pitch shifting');
         timeStretchFactor = timeStretchFactor || 1.0;
         pitchShiftFactor = pitchShiftFactor || 1.0;
         const timePitchShiftingMethod = postProcessingOptions.timePitchShiftingMethod;
-        if (timePitchShiftingMethod == "sonic") {
+        if (timePitchShiftingMethod == 'sonic') {
             const sonic = await import('../dsp/Sonic.js');
             synthesizedAudio = await sonic.stretchTimePitch(synthesizedAudio, timeStretchFactor, pitchShiftFactor);
         }
-        else if (timePitchShiftingMethod == "rubberband") {
+        else if (timePitchShiftingMethod == 'rubberband') {
             const rubberband = await import('../dsp/Rubberband.js');
             const rubberbandOptions = extendDeep(rubberband.defaultRubberbandOptions, postProcessingOptions.rubberband || {});
             synthesizedAudio = await rubberband.stretchTimePitch(synthesizedAudio, timeStretchFactor, pitchShiftFactor, rubberbandOptions);
@@ -639,11 +658,11 @@ function convertSpeedScaleToSSMLValueString(rate) {
 }
 function convertPitchScaleToSSMLValueString(pitch, voiceGender) {
     let fundementalFrequency;
-    if (voiceGender == "male") {
+    if (voiceGender == 'male') {
         // Use an estimate of the average male voice fundemental frequency
         fundementalFrequency = 120;
     }
-    else if (voiceGender == "female") {
+    else if (voiceGender == 'female') {
         // Use an estimate of the average female voice fundemental frequency
         fundementalFrequency = 210;
     }
@@ -679,18 +698,18 @@ export const defaultSynthesisOptions = {
         whitespace: 'collapse'
     },
     alignment: {
-        engine: "dtw",
+        engine: 'dtw',
         dtw: {
             granularity: 'high'
         }
     },
     postProcessing: {
         normalizeAudio: true,
-        targetPeakDb: -3,
-        maxIncreaseDb: 30,
+        targetPeak: -3,
+        maxGainIncrease: 30,
         speed: undefined,
         pitch: undefined,
-        timePitchShiftingMethod: "sonic",
+        timePitchShiftingMethod: 'sonic',
         rubberband: {}
     },
     outputAudioFormat: undefined,
@@ -720,7 +739,7 @@ export const defaultSynthesisOptions = {
         rate: 0,
     },
     coquiServer: {
-        serverUrl: "http://[::1]:5002",
+        serverUrl: 'http://[::1]:5002',
         speakerId: null
     },
     googleCloud: {
@@ -740,13 +759,10 @@ export const defaultSynthesisOptions = {
         pollyEngine: undefined,
         lexiconNames: undefined,
     },
-    elevenlabs: {
-        apiKey: undefined,
-        stability: 0.5,
-        similarityBoost: 0.5,
-    },
+    openAICloud: defaultOpenAICloudTTSOptions,
+    elevenlabs: defaultElevenlabsTTSOptions,
     googleTranslate: {
-        tld: "us"
+        tld: 'us'
     },
     microsoftEdge: {
         trustedClientToken: undefined,
@@ -771,8 +787,8 @@ export async function requestVoiceList(options) {
     async function loadVoiceList() {
         let voiceList = [];
         switch (options.engine) {
-            case "espeak": {
-                const EspeakTTS = await import("../synthesis/EspeakTTS.js");
+            case 'espeak': {
+                const EspeakTTS = await import('../synthesis/EspeakTTS.js');
                 const voices = await EspeakTTS.listVoices();
                 voiceList = voices.map(voice => {
                     const languages = voice.languages.map(lang => normalizeLanguageCode(lang.name));
@@ -785,61 +801,61 @@ export async function requestVoiceList(options) {
                     return {
                         name: voice.identifier,
                         languages,
-                        gender: "male"
+                        gender: 'male'
                     };
                 });
                 break;
             }
-            case "flite": {
-                const FliteTTS = await import("../synthesis/FliteTTS.js");
+            case 'flite': {
+                const FliteTTS = await import('../synthesis/FliteTTS.js');
                 voiceList = deepClone(FliteTTS.voiceList);
                 break;
             }
-            case "pico": {
-                const SvoxPicoTTS = await import("../synthesis/SvoxPicoTTS.js");
+            case 'pico': {
+                const SvoxPicoTTS = await import('../synthesis/SvoxPicoTTS.js');
                 voiceList = SvoxPicoTTS.voiceList;
                 break;
             }
-            case "sam": {
+            case 'sam': {
                 voiceList.push({
-                    name: "sam",
-                    languages: ["en-US", "en"],
-                    gender: "male"
+                    name: 'sam',
+                    languages: ['en-US', 'en'],
+                    gender: 'male'
                 });
                 break;
             }
-            case "vits": {
-                const VitsTTS = await import("../synthesis/VitsTTS.js");
+            case 'vits': {
+                const VitsTTS = await import('../synthesis/VitsTTS.js');
                 voiceList = VitsTTS.voiceList.map(entry => {
                     return { ...entry, packageName: `vits-${entry.name}` };
                 });
                 break;
             }
-            case "sapi": {
-                const SapiTTS = await import("../synthesis/SapiTTS.js");
+            case 'sapi': {
+                const SapiTTS = await import('../synthesis/SapiTTS.js');
                 await SapiTTS.AssertSAPIAvailable(false);
                 voiceList = await SapiTTS.getVoiceList(false);
                 break;
             }
-            case "msspeech": {
-                const SapiTTS = await import("../synthesis/SapiTTS.js");
+            case 'msspeech': {
+                const SapiTTS = await import('../synthesis/SapiTTS.js');
                 await SapiTTS.AssertSAPIAvailable(true);
                 voiceList = await SapiTTS.getVoiceList(true);
                 break;
             }
-            case "coqui-server": {
+            case 'coqui-server': {
                 voiceList = [{
-                        name: "coqui",
-                        languages: ["en-US"],
-                        gender: "unknown"
+                        name: 'coqui',
+                        languages: ['en-US'],
+                        gender: 'unknown'
                     }];
                 break;
             }
-            case "google-cloud": {
-                const GoogleCloudTTS = await import("../synthesis/GoogleCloudTTS.js");
+            case 'google-cloud': {
+                const GoogleCloudTTS = await import('../synthesis/GoogleCloudTTS.js');
                 const apiKey = options.googleCloud.apiKey;
                 if (!apiKey) {
-                    throw new Error(`No API key given`);
+                    throw new Error(`No Google Cloud API key provided`);
                 }
                 const voices = await GoogleCloudTTS.getVoiceList(apiKey);
                 voiceList = voices.map(voice => ({
@@ -849,39 +865,39 @@ export async function requestVoiceList(options) {
                 }));
                 break;
             }
-            case "microsoft-azure": {
-                const AzureCognitiveServicesTTS = await import("../synthesis/AzureCognitiveServicesTTS.js");
+            case 'microsoft-azure': {
+                const AzureCognitiveServicesTTS = await import('../synthesis/AzureCognitiveServicesTTS.js');
                 const subscriptionKey = options.microsoftAzure.subscriptionKey;
                 if (!subscriptionKey) {
-                    throw new Error(`No subscription key given`);
+                    throw new Error(`No Microsoft Azure subscription key provided`);
                 }
                 const serviceRegion = options.microsoftAzure.serviceRegion;
                 if (!serviceRegion) {
-                    throw new Error(`No service region given`);
+                    throw new Error(`No Microsoft Azure service region provided`);
                 }
                 const voices = await AzureCognitiveServicesTTS.getVoiceList(subscriptionKey, serviceRegion);
                 for (const voice of voices) {
                     voiceList.push({
                         name: voice.name,
                         languages: [normalizeLanguageCode(voice.locale), getShortLanguageCode(voice.locale)],
-                        gender: voice.gender == 1 ? "female" : "male"
+                        gender: voice.gender == 1 ? 'female' : 'male'
                     });
                 }
                 break;
             }
-            case "amazon-polly": {
-                const AwsPollyTTS = await import("../synthesis/AwsPollyTTS.js");
+            case 'amazon-polly': {
+                const AwsPollyTTS = await import('../synthesis/AwsPollyTTS.js');
                 const region = options.amazonPolly.region;
                 if (!region) {
-                    throw new Error(`No region given`);
+                    throw new Error(`No Amazon Polly region provided`);
                 }
                 const accessKeyId = options.amazonPolly.accessKeyId;
                 if (!accessKeyId) {
-                    throw new Error(`No access key id given`);
+                    throw new Error(`No Amazon Polly access key id provided`);
                 }
                 const secretAccessKey = options.amazonPolly.secretAccessKey;
                 if (!secretAccessKey) {
-                    throw new Error(`No secret access key given`);
+                    throw new Error(`No Amazon Polly secret access key provided`);
                 }
                 const voices = await AwsPollyTTS.getVoiceList(region, accessKeyId, secretAccessKey);
                 for (const voice of voices) {
@@ -900,44 +916,49 @@ export async function requestVoiceList(options) {
                 }
                 break;
             }
-            case "elevenlabs": {
-                const ElevenLabsTTS = await import("../synthesis/ElevenLabsTTS.js");
+            case 'openai-cloud': {
+                const OpenAICloudTTS = await import('../synthesis/OpenAICloudTTS.js');
+                voiceList = OpenAICloudTTS.voiceList;
+                break;
+            }
+            case 'elevenlabs': {
+                const ElevenLabsTTS = await import('../synthesis/ElevenlabsTTS.js');
                 const engineOptions = options.elevenlabs;
                 const apiKey = engineOptions.apiKey;
                 if (!apiKey) {
-                    throw new Error(`No Elevenlabs API key given`);
+                    throw new Error(`No Elevenlabs API key provided`);
                 }
                 voiceList = await ElevenLabsTTS.getVoiceList(apiKey);
                 break;
             }
-            case "google-translate": {
-                const GoogleTranslateTTS = await import("../synthesis/GoogleTranslateTTS.js");
+            case 'google-translate': {
+                const GoogleTranslateTTS = await import('../synthesis/GoogleTranslateTTS.js');
                 const langLookup = GoogleTranslateTTS.supportedLanguageLookup;
                 for (const langCode in langLookup) {
                     voiceList.push({
                         name: langLookup[langCode],
-                        languages: langCode.includes("-") ? [normalizeLanguageCode(langCode), getShortLanguageCode(langCode)] : [normalizeLanguageCode(langCode)],
-                        gender: "unknown"
+                        languages: langCode.includes('-') ? [normalizeLanguageCode(langCode), getShortLanguageCode(langCode)] : [normalizeLanguageCode(langCode)],
+                        gender: 'unknown'
                     });
                 }
                 break;
             }
-            case "microsoft-edge": {
-                const MicrosoftEdgeTTS = await import("../synthesis/MicrosoftEdgeTTS.js");
+            case 'microsoft-edge': {
+                const MicrosoftEdgeTTS = await import('../synthesis/MicrosoftEdgeTTS.js');
                 const trustedClientToken = options.microsoftEdge?.trustedClientToken;
                 if (!trustedClientToken) {
-                    throw new Error("No trusted client token provided");
+                    throw new Error('No Microsoft Edge trusted client token provided');
                 }
                 const voices = await runOperationWithRetries(() => MicrosoftEdgeTTS.getVoiceList(trustedClientToken), logger);
                 voiceList = voices.map((voice) => ({
                     name: voice.Name,
                     languages: [normalizeLanguageCode(voice.Locale), getShortLanguageCode(voice.Locale)],
-                    gender: voice.Gender == "Male" ? "male" : "female",
+                    gender: voice.Gender == 'Male' ? 'male' : 'female',
                 }));
                 break;
             }
-            case "streamlabs-polly": {
-                const StreamlabsPollyTTS = await import("../synthesis/StreamlabsPollyTTS.js");
+            case 'streamlabs-polly': {
+                const StreamlabsPollyTTS = await import('../synthesis/StreamlabsPollyTTS.js');
                 voiceList = StreamlabsPollyTTS.voiceList;
                 break;
             }
@@ -954,10 +975,10 @@ export async function requestVoiceList(options) {
     else {
         voiceList = await loadVoiceList();
     }
-    const languageCode = normalizeLanguageCode(options.language || "");
+    const languageCode = normalizeLanguageCode(options.language || '');
     if (languageCode) {
         let filteredVoiceList = voiceList.filter(voice => voice.languages.includes(languageCode));
-        if (filteredVoiceList.length == 0 && languageCode.includes("-")) {
+        if (filteredVoiceList.length == 0 && languageCode.includes('-')) {
             const shortLanguageCode = getShortLanguageCode(languageCode);
             filteredVoiceList = voiceList.filter(voice => voice.languages.includes(shortLanguageCode));
         }
@@ -965,7 +986,7 @@ export async function requestVoiceList(options) {
     }
     if (options.voiceGender) {
         const genderLowercase = options.voiceGender.toLowerCase();
-        voiceList = voiceList.filter(voice => voice.gender == genderLowercase || voice.gender == "unknown");
+        voiceList = voiceList.filter(voice => voice.gender == genderLowercase || voice.gender == 'unknown');
     }
     if (options.voice) {
         const namePatternLowerCase = options.voice.toLocaleLowerCase();
@@ -1000,22 +1021,22 @@ export async function requestVoiceList(options) {
 }
 export async function selectBestOfflineEngineForLanguage(language) {
     language = normalizeLanguageCode(language);
-    const VitsTTS = await import("../synthesis/VitsTTS.js");
+    const VitsTTS = await import('../synthesis/VitsTTS.js');
     const vitsLanguages = getAllLangCodesFromVoiceList(VitsTTS.voiceList);
     if (vitsLanguages.includes(language)) {
-        return "vits";
+        return 'vits';
     }
-    const FliteTTS = await import("../synthesis/FliteTTS.js");
+    const FliteTTS = await import('../synthesis/FliteTTS.js');
     const fliteLanguages = getAllLangCodesFromVoiceList(FliteTTS.voiceList);
     if (fliteLanguages.includes(language)) {
-        return "flite";
+        return 'flite';
     }
-    const SvoxPicoTTS = await import("../synthesis/SvoxPicoTTS.js");
+    const SvoxPicoTTS = await import('../synthesis/SvoxPicoTTS.js');
     const picoLanguages = getAllLangCodesFromVoiceList(SvoxPicoTTS.voiceList);
     if (picoLanguages.includes(language)) {
-        return "pico";
+        return 'pico';
     }
-    return "espeak";
+    return 'espeak';
 }
 export function getAllLangCodesFromVoiceList(voiceList) {
     const languageCodes = new Set();
@@ -1060,13 +1081,13 @@ export const synthesisEngines = [
     {
         id: 'espeak',
         name: 'eSpeak NG',
-        description: 'A lightweight "robot" sounding formant-based synthesizer.',
+        description: `A lightweight 'robot' sounding formant-based synthesizer.`,
         type: 'local'
     },
     {
         id: 'sam',
         name: 'SAM (Software Automatic Mouth)',
-        description: 'A classic "robot" speech synthesizer from 1982.',
+        description: `A classic 'robot' speech synthesizer from 1982.`,
         type: 'local'
     },
     {
@@ -1105,6 +1126,12 @@ export const synthesisEngines = [
         description: 'Amazon Polly (also: AWS Polly) cloud text-to-speech.',
         type: 'cloud'
     },
+    {
+        id: 'openai-cloud',
+        name: 'OpenAI Cloud',
+        description: 'OpenAI cloud text-to-speech.',
+        type: 'cloud'
+    },
     {
         id: 'elevenlabs',
         name: 'Elevenlabs',