| | <!DOCTYPE html> |
| | <html lang="en"> |
| | <head> |
| | <meta charset="utf-8"> |
| | <title>JSDoc: Source: utils.js</title> |
| |
|
| | <script src="scripts/prettify/prettify.js"> </script> |
| | <script src="scripts/prettify/lang-css.js"> </script> |
| | |
| | |
| | |
| | <link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css"> |
| | <link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css"> |
| | </head> |
| |
|
| | <body> |
| |
|
| | <div id="main"> |
| |
|
| | <h1 class="page-title">Source: utils.js</h1> |
| |
|
| | |
| |
|
| |
|
| | |
| | <section> |
| | <article> |
| | <pre class="prettyprint source linenums"><code>/*jshint node:true*/ |
| | 'use strict'; |
| |
|
| | var exec = require('child_process').exec; |
| | var isWindows = require('os').platform().match(/win(32|64)/); |
| | var which = require('which'); |
| |
|
| | var nlRegexp = /\r\n|\r|\n/g; |
| | var streamRegexp = /^\[?(.*?)\]?$/; |
| | var filterEscapeRegexp = /[,]/; |
| | var whichCache = {}; |
| |
|
| | /** |
| | * Parse progress line from ffmpeg stderr |
| | * |
| | * @param {String} line progress line |
| | * @return progress object |
| | * @private |
| | */ |
| | function parseProgressLine(line) { |
| | var progress = {}; |
| |
|
| | // Remove all spaces after = and trim |
| | line = line.replace(/=\s+/g, '=').trim(); |
| | var progressParts = line.split(' '); |
| |
|
| | // Split every progress part by "=" to get key and value |
| | for(var i = 0; i < progressParts.length; i++) { |
| | var progressSplit = progressParts[i].split('=', 2); |
| | var key = progressSplit[0]; |
| | var value = progressSplit[1]; |
| |
|
| | // This is not a progress line |
| | if(typeof value === 'undefined') |
| | return null; |
| |
|
| | progress[key] = value; |
| | } |
| |
|
| | return progress; |
| | } |
| |
|
| |
|
| | var utils = module.exports = { |
| | isWindows: isWindows, |
| | streamRegexp: streamRegexp, |
| |
|
| |
|
| | /** |
| | * Copy an object keys into another one |
| | * |
| | * @param {Object} source source object |
| | * @param {Object} dest destination object |
| | * @private |
| | */ |
| | copy: function(source, dest) { |
| | Object.keys(source).forEach(function(key) { |
| | dest[key] = source[key]; |
| | }); |
| | }, |
| |
|
| |
|
| | /** |
| | * Create an argument list |
| | * |
| | * Returns a function that adds new arguments to the list. |
| | * It also has the following methods: |
| | * - clear() empties the argument list |
| | * - get() returns the argument list |
| | * - find(arg, count) finds 'arg' in the list and return the following 'count' items, or undefined if not found |
| | * - remove(arg, count) remove 'arg' in the list as well as the following 'count' items |
| | * |
| | * @private |
| | */ |
| | args: function() { |
| | var list = []; |
| |
|
| | // Append argument(s) to the list |
| | var argfunc = function() { |
| | if (arguments.length === 1 && Array.isArray(arguments[0])) { |
| | list = list.concat(arguments[0]); |
| | } else { |
| | list = list.concat([].slice.call(arguments)); |
| | } |
| | }; |
| |
|
| | // Clear argument list |
| | argfunc.clear = function() { |
| | list = []; |
| | }; |
| |
|
| | // Return argument list |
| | argfunc.get = function() { |
| | return list; |
| | }; |
| |
|
| | // Find argument 'arg' in list, and if found, return an array of the 'count' items that follow it |
| | argfunc.find = function(arg, count) { |
| | var index = list.indexOf(arg); |
| | if (index !== -1) { |
| | return list.slice(index + 1, index + 1 + (count || 0)); |
| | } |
| | }; |
| |
|
| | // Find argument 'arg' in list, and if found, remove it as well as the 'count' items that follow it |
| | argfunc.remove = function(arg, count) { |
| | var index = list.indexOf(arg); |
| | if (index !== -1) { |
| | list.splice(index, (count || 0) + 1); |
| | } |
| | }; |
| |
|
| | // Clone argument list |
| | argfunc.clone = function() { |
| | var cloned = utils.args(); |
| | cloned(list); |
| | return cloned; |
| | }; |
| |
|
| | return argfunc; |
| | }, |
| |
|
| |
|
| | /** |
| | * Generate filter strings |
| | * |
| | * @param {String[]|Object[]} filters filter specifications. When using objects, |
| | * each must have the following properties: |
| | * @param {String} filters.filter filter name |
| | * @param {String|Array} [filters.inputs] (array of) input stream specifier(s) for the filter, |
| | * defaults to ffmpeg automatically choosing the first unused matching streams |
| | * @param {String|Array} [filters.outputs] (array of) output stream specifier(s) for the filter, |
| | * defaults to ffmpeg automatically assigning the output to the output file |
| | * @param {Object|String|Array} [filters.options] filter options, can be omitted to not set any options |
| | * @return String[] |
| | * @private |
| | */ |
| | makeFilterStrings: function(filters) { |
| | return filters.map(function(filterSpec) { |
| | if (typeof filterSpec === 'string') { |
| | return filterSpec; |
| | } |
| |
|
| | var filterString = ''; |
| |
|
| | // Filter string format is: |
| | // [input1][input2]...filter[output1][output2]... |
| | // The 'filter' part can optionaly have arguments: |
| | // filter=arg1:arg2:arg3 |
| | // filter=arg1=v1:arg2=v2:arg3=v3 |
| |
|
| | // Add inputs |
| | if (Array.isArray(filterSpec.inputs)) { |
| | filterString += filterSpec.inputs.map(function(streamSpec) { |
| | return streamSpec.replace(streamRegexp, '[$1]'); |
| | }).join(''); |
| | } else if (typeof filterSpec.inputs === 'string') { |
| | filterString += filterSpec.inputs.replace(streamRegexp, '[$1]'); |
| | } |
| |
|
| | // Add filter |
| | filterString += filterSpec.filter; |
| |
|
| | // Add options |
| | if (filterSpec.options) { |
| | if (typeof filterSpec.options === 'string' || typeof filterSpec.options === 'number') { |
| | // Option string |
| | filterString += '=' + filterSpec.options; |
| | } else if (Array.isArray(filterSpec.options)) { |
| | // Option array (unnamed options) |
| | filterString += '=' + filterSpec.options.map(function(option) { |
| | if (typeof option === 'string' && option.match(filterEscapeRegexp)) { |
| | return '\'' + option + '\''; |
| | } else { |
| | return option; |
| | } |
| | }).join(':'); |
| | } else if (Object.keys(filterSpec.options).length) { |
| | // Option object (named options) |
| | filterString += '=' + Object.keys(filterSpec.options).map(function(option) { |
| | var value = filterSpec.options[option]; |
| |
|
| | if (typeof value === 'string' && value.match(filterEscapeRegexp)) { |
| | value = '\'' + value + '\''; |
| | } |
| |
|
| | return option + '=' + value; |
| | }).join(':'); |
| | } |
| | } |
| |
|
| | // Add outputs |
| | if (Array.isArray(filterSpec.outputs)) { |
| | filterString += filterSpec.outputs.map(function(streamSpec) { |
| | return streamSpec.replace(streamRegexp, '[$1]'); |
| | }).join(''); |
| | } else if (typeof filterSpec.outputs === 'string') { |
| | filterString += filterSpec.outputs.replace(streamRegexp, '[$1]'); |
| | } |
| |
|
| | return filterString; |
| | }); |
| | }, |
| |
|
| |
|
| | /** |
| | * Search for an executable |
| | * |
| | * Uses 'which' or 'where' depending on platform |
| | * |
| | * @param {String} name executable name |
| | * @param {Function} callback callback with signature (err, path) |
| | * @private |
| | */ |
| | which: function(name, callback) { |
| | if (name in whichCache) { |
| | return callback(null, whichCache[name]); |
| | } |
| |
|
| | which(name, function(err, result){ |
| | if (err) { |
| | // Treat errors as not found |
| | return callback(null, whichCache[name] = ''); |
| | } |
| | callback(null, whichCache[name] = result); |
| | }); |
| | }, |
| |
|
| |
|
| | /** |
| | * Convert a [[hh:]mm:]ss[.xxx] timemark into seconds |
| | * |
| | * @param {String} timemark timemark string |
| | * @return Number |
| | * @private |
| | */ |
| | timemarkToSeconds: function(timemark) { |
| | if (typeof timemark === 'number') { |
| | return timemark; |
| | } |
| |
|
| | if (timemark.indexOf(':') === -1 && timemark.indexOf('.') >= 0) { |
| | return Number(timemark); |
| | } |
| |
|
| | var parts = timemark.split(':'); |
| |
|
| | // add seconds |
| | var secs = Number(parts.pop()); |
| |
|
| | if (parts.length) { |
| | // add minutes |
| | secs += Number(parts.pop()) * 60; |
| | } |
| |
|
| | if (parts.length) { |
| | // add hours |
| | secs += Number(parts.pop()) * 3600; |
| | } |
| |
|
| | return secs; |
| | }, |
| |
|
| |
|
| | /** |
| | * Extract codec data from ffmpeg stderr and emit 'codecData' event if appropriate |
| | * Call it with an initially empty codec object once with each line of stderr output until it returns true |
| | * |
| | * @param {FfmpegCommand} command event emitter |
| | * @param {String} stderrLine ffmpeg stderr output line |
| | * @param {Object} codecObject object used to accumulate codec data between calls |
| | * @return {Boolean} true if codec data is complete (and event was emitted), false otherwise |
| | * @private |
| | */ |
| | extractCodecData: function(command, stderrLine, codecsObject) { |
| | var inputPattern = /Input #[0-9]+, ([^ ]+),/; |
| | var durPattern = /Duration\: ([^,]+)/; |
| | var audioPattern = /Audio\: (.*)/; |
| | var videoPattern = /Video\: (.*)/; |
| |
|
| | if (!('inputStack' in codecsObject)) { |
| | codecsObject.inputStack = []; |
| | codecsObject.inputIndex = -1; |
| | codecsObject.inInput = false; |
| | } |
| |
|
| | var inputStack = codecsObject.inputStack; |
| | var inputIndex = codecsObject.inputIndex; |
| | var inInput = codecsObject.inInput; |
| |
|
| | var format, dur, audio, video; |
| |
|
| | if (format = stderrLine.match(inputPattern)) { |
| | inInput = codecsObject.inInput = true; |
| | inputIndex = codecsObject.inputIndex = codecsObject.inputIndex + 1; |
| |
|
| | inputStack[inputIndex] = { format: format[1], audio: '', video: '', duration: '' }; |
| | } else if (inInput && (dur = stderrLine.match(durPattern))) { |
| | inputStack[inputIndex].duration = dur[1]; |
| | } else if (inInput && (audio = stderrLine.match(audioPattern))) { |
| | audio = audio[1].split(', '); |
| | inputStack[inputIndex].audio = audio[0]; |
| | inputStack[inputIndex].audio_details = audio; |
| | } else if (inInput && (video = stderrLine.match(videoPattern))) { |
| | video = video[1].split(', '); |
| | inputStack[inputIndex].video = video[0]; |
| | inputStack[inputIndex].video_details = video; |
| | } else if (/Output #\d+/.test(stderrLine)) { |
| | inInput = codecsObject.inInput = false; |
| | } else if (/Stream mapping:|Press (\[q\]|ctrl-c) to stop/.test(stderrLine)) { |
| | command.emit.apply(command, ['codecData'].concat(inputStack)); |
| | return true; |
| | } |
| |
|
| | return false; |
| | }, |
| |
|
| |
|
| | /** |
| | * Extract progress data from ffmpeg stderr and emit 'progress' event if appropriate |
| | * |
| | * @param {FfmpegCommand} command event emitter |
| | * @param {String} stderrLine ffmpeg stderr data |
| | * @param {Number} [duration=0] expected output duration in seconds |
| | * @private |
| | */ |
| | extractProgress: function(command, stderrLine, duration) { |
| | var progress = parseProgressLine(stderrLine); |
| |
|
| | if (progress) { |
| | // build progress report object |
| | var ret = { |
| | frames: parseInt(progress.frame, 10), |
| | currentFps: parseInt(progress.fps, 10), |
| | currentKbps: progress.bitrate ? parseFloat(progress.bitrate.replace('kbits/s', '')) : 0, |
| | targetSize: parseInt(progress.size, 10), |
| | timemark: progress.time |
| | }; |
| |
|
| | // calculate percent progress using duration |
| | if (duration && duration > 0) { |
| | ret.percent = (utils.timemarkToSeconds(ret.timemark) / duration) * 100; |
| | } |
| |
|
| | command.emit('progress', ret); |
| | } |
| | }, |
| |
|
| |
|
| | /** |
| | * Extract error message(s) from ffmpeg stderr |
| | * |
| | * @param {String} stderr ffmpeg stderr data |
| | * @return {String} |
| | * @private |
| | */ |
| | extractError: function(stderr) { |
| | // Only return the last stderr lines that don't start with a space or a square bracket |
| | return stderr.split(nlRegexp).reduce(function(messages, message) { |
| | if (message.charAt(0) === ' ' || message.charAt(0) === '[') { |
| | return []; |
| | } else { |
| | messages.push(message); |
| | return messages; |
| | } |
| | }, []).join('\n'); |
| | }, |
| |
|
| |
|
| | /** |
| | * Creates a line ring buffer object with the following methods: |
| | * - append(str) : appends a string or buffer |
| | * - get() : returns the whole string |
| | * - close() : prevents further append() calls and does a last call to callbacks |
| | * - callback(cb) : calls cb for each line (incl. those already in the ring) |
| | * |
| | * @param {Numebr} maxLines maximum number of lines to store (<= 0 for unlimited) |
| | */ |
| | linesRing: function(maxLines) { |
| | var cbs = []; |
| | var lines = []; |
| | var current = null; |
| | var closed = false |
| | var max = maxLines - 1; |
| |
|
| | function emit(line) { |
| | cbs.forEach(function(cb) { cb(line); }); |
| | } |
| |
|
| | return { |
| | callback: function(cb) { |
| | lines.forEach(function(l) { cb(l); }); |
| | cbs.push(cb); |
| | }, |
| |
|
| | append: function(str) { |
| | if (closed) return; |
| | if (str instanceof Buffer) str = '' + str; |
| | if (!str || str.length === 0) return; |
| |
|
| | var newLines = str.split(nlRegexp); |
| |
|
| | if (newLines.length === 1) { |
| | if (current !== null) { |
| | current = current + newLines.shift(); |
| | } else { |
| | current = newLines.shift(); |
| | } |
| | } else { |
| | if (current !== null) { |
| | current = current + newLines.shift(); |
| | emit(current); |
| | lines.push(current); |
| | } |
| |
|
| | current = newLines.pop(); |
| |
|
| | newLines.forEach(function(l) { |
| | emit(l); |
| | lines.push(l); |
| | }); |
| |
|
| | if (max > -1 && lines.length > max) { |
| | lines.splice(0, lines.length - max); |
| | } |
| | } |
| | }, |
| |
|
| | get: function() { |
| | if (current !== null) { |
| | return lines.concat([current]).join('\n'); |
| | } else { |
| | return lines.join('\n'); |
| | } |
| | }, |
| |
|
| | close: function() { |
| | if (closed) return; |
| |
|
| | if (current !== null) { |
| | emit(current); |
| | lines.push(current); |
| |
|
| | if (max > -1 && lines.length > max) { |
| | lines.shift(); |
| | } |
| |
|
| | current = null; |
| | } |
| |
|
| | closed = true; |
| | } |
| | }; |
| | } |
| | }; |
| | </code></pre> |
| | </article> |
| | </section> |
| |
|
| |
|
| |
|
| |
|
| | </div> |
| |
|
| | <nav> |
| | <h2><a href="index.html">Index</a></h2><ul><li><a href="index.html#installation">Installation</a></li><ul></ul><li><a href="index.html#usage">Usage</a></li><ul><li><a href="index.html#prerequisites">Prerequisites</a></li><li><a href="index.html#creating-an-ffmpeg-command">Creating an FFmpeg command</a></li><li><a href="index.html#specifying-inputs">Specifying inputs</a></li><li><a href="index.html#input-options">Input options</a></li><li><a href="index.html#audio-options">Audio options</a></li><li><a href="index.html#video-options">Video options</a></li><li><a href="index.html#video-frame-size-options">Video frame size options</a></li><li><a href="index.html#specifying-multiple-outputs">Specifying multiple outputs</a></li><li><a href="index.html#output-options">Output options</a></li><li><a href="index.html#miscellaneous-options">Miscellaneous options</a></li><li><a href="index.html#setting-event-handlers">Setting event handlers</a></li><li><a href="index.html#starting-ffmpeg-processing">Starting FFmpeg processing</a></li><li><a href="index.html#controlling-the-ffmpeg-process">Controlling the FFmpeg process</a></li><li><a href="index.html#reading-video-metadata">Reading video metadata</a></li><li><a href="index.html#querying-ffmpeg-capabilities">Querying ffmpeg capabilities</a></li><li><a href="index.html#cloning-an-ffmpegcommand">Cloning an FfmpegCommand</a></li></ul><li><a href="index.html#contributing">Contributing</a></li><ul><li><a href="index.html#code-contributions">Code contributions</a></li><li><a href="index.html#documentation-contributions">Documentation contributions</a></li><li><a href="index.html#updating-the-documentation">Updating the documentation</a></li><li><a href="index.html#running-tests">Running tests</a></li></ul><li><a href="index.html#main-contributors">Main contributors</a></li><ul></ul><li><a href="index.html#license">License</a></li><ul></ul></ul><h3>Classes</h3><ul><li><a href="FfmpegCommand.html">FfmpegCommand</a></li><ul><li> <a href="FfmpegCommand.html#audio-methods">Audio methods</a></li><li> <a href="FfmpegCommand.html#capabilities-methods">Capabilities methods</a></li><li> <a href="FfmpegCommand.html#custom-options-methods">Custom options methods</a></li><li> <a href="FfmpegCommand.html#input-methods">Input methods</a></li><li> <a href="FfmpegCommand.html#metadata-methods">Metadata methods</a></li><li> <a href="FfmpegCommand.html#miscellaneous-methods">Miscellaneous methods</a></li><li> <a href="FfmpegCommand.html#other-methods">Other methods</a></li><li> <a href="FfmpegCommand.html#output-methods">Output methods</a></li><li> <a href="FfmpegCommand.html#processing-methods">Processing methods</a></li><li> <a href="FfmpegCommand.html#video-methods">Video methods</a></li><li> <a href="FfmpegCommand.html#video-size-methods">Video size methods</a></li></ul></ul> |
| | </nav> |
| |
|
| | <br clear="both"> |
| |
|
| | <footer> |
| | Documentation generated by <a href="https://github.com/jsdoc3/jsdoc">JSDoc 3.4.0</a> on Sun May 01 2016 12:10:37 GMT+0200 (CEST) |
| | </footer> |
| |
|
| | <script> prettyPrint(); </script> |
| | <script src="scripts/linenumber.js"> </script> |
| | </body> |
| | </html> |
| |
|
