@makefully/dutifully 1.10.1

package/src/formats/LRC.js

@@ -0,0 +1,38 @@
+const
+    fs = require('fs').promises,
+    os = require('os'),
+    File = require("./File"),
+    getSeparater = (str) => str.indexOf(os.EOL) >= 0 ? os.EOL : '\n';
+
+module.exports = class LRC extends File {
+    async load (path) {
+        await super.load(path);
+        this.data = await fs.readFile(path, 'utf8');
+        return this.data;
+    }
+
+    addHash (hash) {
+        this.data = this.data.replace(/^\[hash:[a-f0-9]+\]\n?/im, '');
+
+        const
+            sep = getSeparater(this.data),
+            insertAfter = this.data.match(/^\[generator:[^\]]*\]/im);
+
+        if (insertAfter) {
+            this.data = this.data.replace(insertAfter[0], `${insertAfter[0]}${sep}[hash:${hash}]`);
+        } else {
+            this.data = `[hash:${hash}]${sep}${this.data}`;
+        }
+    }
+
+    getHash () {
+        const
+            match = this.data.match(/^\[hash:([a-f0-9]+)\]/im);
+
+        return match ? match[1] : null;
+    }
+
+    toString () {
+        return this.data.split(getSeparater(this.data)).filter((line) => line.length > 0 && line.indexOf('[') === 0 && line.indexOf(']') === 9).map((text) => text.substring(10)).join(' ');
+    }
+}

package/src/formats/MP3.js

@@ -0,0 +1,60 @@
+const
+    id3 = require('node-id3').Promise,
+    File = require("./File");
+
+module.exports = class MP3 extends File {
+    async load (path) {
+        await super.load(path);
+        this.data = await id3.read(path);
+        return this.data;
+    }
+
+    addHash (hash, {hashKey = 'CaptionHash'} = {}) {
+        const
+            existing = (this.data.userDefinedText ?? []).filter(({description}) => description !== hashKey);
+
+        this.data.userDefinedText = [...existing, {description: hashKey, value: hash}];
+    }
+
+    getHash ({hashKey = 'CaptionHash'} = {}) {
+        const
+            {userDefinedText} = this.data;
+
+        if (userDefinedText) {
+            for (let i = 0; i < userDefinedText.length; i++) {
+                if (userDefinedText[i].description === hashKey) {
+                    return userDefinedText[i].value;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    save () { // return a promise
+        return id3.write(this.data, this.path);
+    }
+
+    toString () {
+        const
+            {synchronisedLyrics, unsynchronisedLyrics} = this.data;
+
+        if (unsynchronisedLyrics?.text) {
+            return unsynchronisedLyrics.text;
+        }
+
+        if (synchronisedLyrics) {
+            const
+                index = synchronisedLyrics.map(({shortText}) => shortText).indexOf('captions');
+
+            if (index >= 0) {
+                const
+                    {synchronisedText} = synchronisedLyrics[index];
+
+                return synchronisedText.map(({text}) => text).join(' ');
+            }
+        }
+
+        return '';
+    }
+}

package/src/formats/SAMI.js

@@ -0,0 +1,59 @@
+const
+    fs = require('fs').promises,
+    File = require("./File"),
+    removeComments = (html) => html.replace(/<!--[\s\S]*?-->/g, ''),
+    cleanHTML = (html) => html
+        .replace(/<[^>]+>/g, '')   // remove HTML tags
+        .replace(/&nbsp;/gi, ' ')  // decode common HTML entities
+        .replace(/&amp;/gi, '&')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&quot;/gi, '"')
+        .trim();
+
+module.exports = class SAMI extends File {
+    async load (path) {
+        await super.load(path);
+        this.data = await fs.readFile(path, 'utf8');
+        return this.data;
+    }
+
+    addHash (hash) {
+        this.data = this.data.replace(/<META[\s]+Hash="[a-f0-9]+"[\s]*\/>\n?/i, '');
+
+        const
+            insertAfter = this.data.match(/<META[\s]+Generator="[^"]*"[\s]*\/>/i);
+
+        if (insertAfter) {
+            this.data = this.data.replace(insertAfter[0], `${insertAfter[0]}\n    <META Hash="${hash}"/>`);
+        } else {
+            this.data = this.data.replace(/<HEAD>/i, `<HEAD>\n    <META Hash="${hash}"/>`);
+        }
+    }
+    
+    getHash () {
+        const
+            match = this.data.match(/<META[\s]+Hash="([a-f0-9]+)"/i);
+
+        return match ? match[1] : null;
+    }
+
+    toString () {
+        const
+            sami = removeComments(this.data),
+            regex = /<P[^>]*>([\s\S]*?)<\/P>/gi,
+            matches = [];
+        let match;
+
+        while ((match = regex.exec(sami)) !== null) {
+            const
+                innerText = cleanHTML(match[1]);
+                
+            if (innerText) {
+                matches.push(innerText);
+            }
+        }
+                
+        return matches.join(' ');
+    }
+}

package/src/formats/SRT.js

@@ -0,0 +1,40 @@
+const
+    fs = require('fs').promises,
+    os = require('os'),
+    File = require("./File"),
+    getSeparater = (str) => str.indexOf(os.EOL) >= 0 ? os.EOL : '\n';
+
+module.exports = class SRT extends File {
+    async load (path) {
+        await super.load(path);
+        this.data = await fs.readFile(path, 'utf8');
+        return this.data;
+    }
+
+    addHash (hash) {
+        this.data = this.data.replace(/<u[\s]+hash="[a-f0-9]+"[\s]*(?:\/>|><\/u>)\n?/im, '');
+
+        const
+            insertAfter = this.data.match(/<u[\s]+generator="[^"]*"[\s]*(?:\/>|><\/u>)/im);
+
+        if (insertAfter) {
+            this.data = this.data.replace(insertAfter[0], `${insertAfter[0]}${getSeparater(this.data)}<u hash="${hash}"></u>`);
+        } else {
+            const
+                sep = getSeparater(this.data);
+
+            this.data = `1${sep}00:00:00,000 --> 00:00:00,001${sep}<u hash="${hash}"></u>${sep}${sep}${this.data}`;
+        }
+    }
+
+    getHash () {
+        const
+            match = this.data.match(/<u[\s]+hash="([a-f0-9]+)"[\s]*(?:\/>|><\/u>)/im);
+
+        return match ? match[1] : null;
+    }
+
+    toString () {
+        return this.data.split(getSeparater(this.data)).filter((line) => line.length > 0 && line.indexOf(' --> ') === -1 && parseInt(line) != line).join(' ');
+    }
+}

package/src/formats/VTT.js

@@ -0,0 +1,38 @@
+const
+    fs = require('fs').promises,
+    os = require('os'),
+    File = require("./File"),
+    getSeparater = (str) => str.indexOf(os.EOL) >= 0 ? os.EOL : '\n';
+
+module.exports = class VTT extends File {
+    async load (path) {
+        await super.load(path);
+        this.data = await fs.readFile(path, 'utf8');
+        return this.data;
+    }
+
+    addHash (hash) {
+        this.data = this.data.replace(/^NOTE[\s]+Hash:[\s]+[a-f0-9]+\n?/im, '');
+
+        const
+            sep = getSeparater(this.data),
+            insertAfter = this.data.match(/^NOTE[\s]+Generator:[^\n]*/im);
+
+        if (insertAfter) {
+            this.data = this.data.replace(insertAfter[0], `${insertAfter[0]}${sep}NOTE Hash: ${hash}`);
+        } else {
+            this.data = this.data.replace('WEBVTT', `WEBVTT${sep}${sep}NOTE Hash: ${hash}`);
+        }
+    }
+    
+    getHash () {
+        const
+            match = this.data.match(/^NOTE[\s]+Hash:[\s]+([a-f0-9]+)/im);
+
+        return match ? match[1] : null;
+    }
+
+    toString () {
+        return this.data.split(getSeparater(this.data)).filter((line) => line.length > 0 && line.indexOf(' --> ') === -1 && parseInt(line) != line).join(' ');
+    }
+}

package/src/helpers/getCaptions.js

@@ -0,0 +1,44 @@
+const
+    fs = require('fs').promises,
+    getFileData = require("./getFileData"),
+    filter = (fileType, file) => (file.indexOf('.') !== 0) && (file.slice(-(fileType.length + 1)) === `.${fileType}`);
+
+module.exports = async (path, fileType) => {
+
+    // "captions.json" is a proprietary format that includes all captions.
+    if (fileType.toLowerCase() === 'json') {
+        const
+            file = await getFileData(`${path}captions.json`, 'json'),
+            {data: json} = file;
+
+        return {
+            captions: Object.keys(json).reduce((obj, key) => {
+                obj[key] = json[key].map(({content}) => content).join(' ');
+                return obj;
+            }, {}),
+            file,
+            files: null
+        };
+    } else { // Otherwise we pull all the files and construct a key/value object.
+        const
+            files = (await fs.readdir(path)).filter(filter.bind(null, fileType)),
+            captions = {},
+            fileMap = {};
+            
+        for (let i = 0; i < files.length; i++) {
+            const
+                filename = files[i],
+                file = await getFileData(`${path}${filename}`, fileType),
+                key = filename.substring(0, filename.length - fileType.length - 1);
+                
+            captions[key] = file.toString();
+            fileMap[key] = file;
+        }
+
+        return {
+            captions,
+            file: null,
+            files: fileMap
+        };
+    }
+};

package/src/helpers/getFileData.js

@@ -0,0 +1,33 @@
+const
+    JSONFile = require("../formats/JSONFile"),
+    LRC = require("../formats/LRC"),
+    MP3 = require("../formats/MP3"),
+    SAMI = require("../formats/SAMI"),
+    SRT = require("../formats/SRT"),
+    VTT = require("../formats/VTT"),
+    formats = {
+        json: JSONFile,
+        lrc: LRC,
+        mp3: MP3,
+        sami: SAMI,
+        smi: SAMI,
+        srt: SRT,
+        vtt: VTT
+    };
+
+module.exports = async (path, fileType) => {
+    const
+        lcFormat = fileType.toLowerCase(),
+        File = formats[lcFormat] ?? formats.JSONFile;
+
+    // Find file type and throw if that doesn't work.
+    if (File) {
+        const
+            file = new File({fileType: lcFormat});
+
+        await file.load(path);
+        return file;
+    } else {
+        throw `"${fileType}" not supported.`;
+    }
+};

package/src/helpers/getJSON.js

@@ -0,0 +1,33 @@
+const
+    fs = require('fs'),
+    getJSON = (path) => new Promise ((resolve, reject) => {
+        fs.readFile(path, (err, data) => {
+            if (err) {
+                reject(err);
+            } else {
+                let json = null;
+                
+                try {
+                    json = JSON.parse(data);
+                } catch (e) {
+                    reject(e);
+                }
+        
+                if (json) {
+                    resolve(json);
+                }
+            }
+        });
+    });
+
+module.exports = async (path) => {
+    let json = null;
+    
+    try {
+        json = await getJSON(path);
+    } catch (e) {
+        console.warn(e);
+    }
+
+    return json;
+};

package/src/index.js

@@ -0,0 +1,58 @@
+/* eslint-disable no-sync */
+/* global console, process, require */
+const
+    LipSync = require('./classes/LipSync'),
+    parsers = {
+        allosaurus: LipSync,
+        elevenlabs: require('./classes/ElevenLabs'),
+        ffmpeg: require('./classes/FFMPEG'),
+        polly: require('./classes/Polly'),
+        rasterize: require('./classes/Rasterize'),
+        rhubarb: LipSync,
+        transcription: require('./classes/Transcription')
+    },
+    getJSON = require('./helpers/getJSON'),
+    send = function (contents) {
+        const
+            {id, service} = contents,
+            configs = Array.isArray(contents[service]) ? contents[service] : [contents[service]];
+
+        configs.forEach(async (config, index, {length}) => {
+            if (!config) {
+                console.warn(`Empty configuration for "${service}" service.`);
+            } else {
+                const
+                    serviceHandler = new parsers[service]({config, contents});
+                    
+                try {
+                    await serviceHandler.prepare({...contents, ...config});
+                } catch (e) {
+                    console.warn(e.message);
+                    return;
+                }
+
+                await serviceHandler.send({
+                    instanceId: `${id}-${service}${length > 1 ? `-${index}` : ''}`
+                });
+            }
+        });
+    };
+
+const cheer = async (cmdArgs) => {
+    const
+        package = await getJSON('./package.json') ?? {},
+        config = await getJSON('./cheerfully.json') ?? {},
+        env = await getJSON('./env-cheerfully.json') ?? {};
+
+    send({
+        id: `${package.name}-${package.version}`,
+        package,
+        ...config,
+        ...env,
+        ...cmdArgs
+    });
+};
+
+cheer.say = require('./say');
+
+module.exports = cheer;

package/src/say.js

@@ -0,0 +1,141 @@
+/* eslint-disable no-sync */
+/* global console, process, require */
+const
+    fs = require('fs'),
+    fsp = require('fs').promises,
+    path = require('path'),
+    {createHash} = require('crypto'),
+    {AudioContext} = require('node-web-audio-api'),
+    ElevenLabs = require('./classes/ElevenLabs'),
+    getJSON = require('./helpers/getJSON'),
+    CACHE_DIR = '.cache/tts',
+    resolveVoiceId = (voice) => {
+        if (!voice) {
+            return null;
+        }
+
+        if (typeof voice === 'string') {
+            return voice;
+        }
+
+        return voice.default ?? Object.values(voice)[0] ?? null;
+    },
+    cacheKey = ({voice, text}) => createHash('sha256')
+        .update(JSON.stringify({
+            version: 1,
+            voice,
+            text
+        }))
+        .digest('hex'),
+    playMp3 = async (file) => {
+        const
+            audioContext = new AudioContext(),
+            data = await fsp.readFile(file),
+            arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength),
+            buffer = await audioContext.decodeAudioData(arrayBuffer),
+            source = audioContext.createBufferSource();
+
+        source.buffer = buffer;
+        source.connect(audioContext.destination);
+
+        await new Promise((resolve, reject) => {
+            source.onended = resolve;
+            try {
+                source.start();
+            } catch (e) {
+                reject(e);
+            }
+        });
+
+        await audioContext.close();
+    },
+    generate = async ({text, voice, key, contents, elevenlabsConfig}) => {
+        const
+            output = `${CACHE_DIR}/`,
+            config = {
+                ...elevenlabsConfig,
+                files: {
+                    [key]: text
+                },
+                path: '',
+                voice,
+                output
+            },
+            handler = new ElevenLabs({
+                config,
+                contents: {
+                    ...contents,
+                    service: 'elevenlabs'
+                }
+            });
+
+        delete config.script;
+
+        await handler.prepare({
+            difference: false,
+            extract: true
+        });
+        await handler.send({
+            instanceId: `${contents.id}-say`
+        });
+
+        return path.join(CACHE_DIR, `${key}.mp3`);
+    };
+
+module.exports = async (textOrArgs = {}) => {
+    const
+        isString = typeof textOrArgs === 'string',
+        cmdArgs = isString ? {} : (textOrArgs ?? {}),
+        text = (isString ? textOrArgs : (cmdArgs.text ?? '')).trim();
+
+    if (!text) {
+        throw new Error('Usage: say "Hello world"');
+    }
+
+    const
+        packageJson = await getJSON('./package.json') ?? {},
+        cheerfully = await getJSON('./cheerfully.json') ?? {},
+        env = await getJSON('./env-cheerfully.json') ?? {},
+        contents = {
+            id: `${packageJson.name ?? 'cheerfully'}-${packageJson.version ?? '0'}`,
+            package: packageJson,
+            ...cheerfully,
+            ...env,
+            ...cmdArgs
+        },
+        elevenlabsConfig = Array.isArray(contents.elevenlabs)
+            ? (contents.elevenlabs[0] ?? {})
+            : (contents.elevenlabs ?? {}),
+        voice = elevenlabsConfig.voice,
+        voiceId = resolveVoiceId(voice);
+
+    if (!voiceId) {
+        throw new Error('No ElevenLabs voice configured. Set elevenlabs[0].voice in cheerfully.json.');
+    }
+
+    if (!contents.server || !contents.accessToken) {
+        throw new Error('Missing server/accessToken. Set them in env-cheerfully.json.');
+    }
+
+    await fsp.mkdir(CACHE_DIR, {recursive: true});
+
+    const
+        key = cacheKey({
+            voice: voiceId,
+            text
+        }),
+        mp3File = path.join(CACHE_DIR, `${key}.mp3`);
+
+    if (!fs.existsSync(mp3File)) {
+        console.log('Generating speech...');
+        await generate({
+            text,
+            voice,
+            key,
+            contents,
+            elevenlabsConfig
+        });
+    }
+
+    await playMp3(mp3File);
+};