badger-am/lib/audio.js

// requirements
const fs = require('fs');
const path = require('path');
const async = require('async');
const metadata = require('musicmetadata');
const ffmpeg = require('fluent-ffmpeg');
const fse = require('fs-extra');
const util = require('./util');
const cli = require('./cli');

// convert all files in input directory
function batchConvert(config, callback) {
    async.waterfall([
        // get files
        function (waterfallCallback) {
            util.readDirRecursive(config.input, config.format, waterfallCallback);
        },
        // display info, prompt user and create progressbar
        function (files, waterfallCallback) {
            cli.askForConfirmation(files.length + ' files found.\nstart conversion now?', ['yes', 'y'], function (err) {
                if (err) {
                    return waterfallCallback(err);
                }
                waterfallCallback(null, files, cli.createProgressBar(files.length));
            });
        },
        // process each file
        function (files, bar, waterfallCallback) {
            async.eachLimit(files, config.concurrency, function (file, eachCallback) {
                convert(file, config, function (err) {
                    bar.tick();
                    if (err) {
                        return eachCallback(err);
                    }
                    eachCallback();
                });
            }, waterfallCallback);
        }
    ], callback);
}

// convert file to mp3 at specified bitrate
function convert(source, config, callback) {
    async.waterfall([
        // get metadata
        function (waterfallCallback) {
            extractMetadata(source, waterfallCallback);
        },
        // create path from metadata
        function (metadata, waterfallCallback) {
            util.getPathByMetadata(source, config.output, metadata, waterfallCallback);
        },
        // create target directory
        function (target, waterfallCallback) {
            target = path.join(path.dirname(target), path.basename(target, path.extname(target)) + '.mp3');
            fse.mkdirs(path.dirname(target), function (err) {
                if (err) {
                    return waterfallCallback(err);
                }
                waterfallCallback(null, target, config);
            });
        },
        // convert file to mp3
        function (target, config, waterfallCallback) {
            ffmpeg(path.normalize(source)).audioCodec('libmp3lame').audioBitrate(config.bitrate).save(target)
                .on('error', function (err) {
                    return waterfallCallback(err);
                })
                .on('end', function () {
                    waterfallCallback();
                });
        }
    ], callback);
}

//
function batchArtwork(config, callback) {
    async.waterfall([
        // get files
        function (waterfallCallback) {
            util.readDirRecursive(config.input, config.format, waterfallCallback);
        },
        // display info, prompt user and create progressbar
        function (files, waterfallCallback) {
            cli.askForConfirmation(files.length + ' files found.\nstart artwork extraction now?', ['yes', 'y'], function (err) {
                if (err) {
                    return waterfallCallback(err);
                }
                waterfallCallback(null, files, cli.createProgressBar(files.length));
            });
        },
        // process each file
        function (files, bar, waterfallCallback) {
            async.eachLimit(files, config.concurrency, function (file, eachCallback) {
                extractArtwork(file, function (err) {
                    bar.tick();
                    if (err) {
                        return eachCallback(err);
                    }
                    eachCallback();
                });
            }, waterfallCallback);
        }
    ], callback);
}

// extract cover artwork
function extractArtwork(source, callback) {
    async.waterfall([
        // get metadata
        function (waterfallCallback) {
            extractMetadata(source, waterfallCallback);
        },
        // write image to disk
        function (metadata, waterfallCallback) {
            if (!metadata.picture) {
                waterfallCallback();
            }
            for (let counter = 0, length = metadata.picture.length; counter < length; counter++) {
                const stream = fs.createWriteStream(path.join(path.dirname(source), path.basename(source, path.extname(source)) + '.' + metadata.picture[counter].format));
                stream.write(metadata.picture[counter].data);
                stream.end();
            }
            waterfallCallback();
        }
    ], callback);
}

// extract metadata for further processing
function extractMetadata(sourceFile, callback) {
    const stream = fs.createReadStream(sourceFile);
    metadata(stream, function (err, metadata) {
        if (err) {
            return callback(err);
        }
        stream.close();
        callback(null, metadata);
    });
}

// api
exports.batchConvert = batchConvert;
exports.convert = convert;
exports.batchArtwork = batchArtwork;
exports.extractArtwork = extractArtwork;
exports.extractMetadata = extractMetadata;