v2f/v2f.js

/*jshint strict: true, esversion:6, node: true, asi: true*/

'use strict'
const cmd = require('commander')
const async = require('async')
const exec = require('child_process').exec
const fs = require('fs')
const path = require('path')

const TMP = '/tmp/v2f/'

class Dimensions{
	constructor (filmStr, dpi) {
		const IN = dpi / 25.4
		const film = this._gauge(filmStr)

		this.h = Math.round(film.h * IN) //frame height
		this.w = Math.round(film.w * IN) //frame width
		this.o = Math.round(film.o * IN) //space between columns
		this.dpi = dpi
		this.film = film
	}

	_gauge (film) {
		if (film === '16mm') {
			return {
				h: 7.62,
				w : 10.5,
				o : 16
			}
		} else if (film === 'super16'){
			return {
				h: 7.62,
				w : 12.75,
				o : 16
			}
		} else if (film === '35mm') {
			return {
				h : 19.05,
				w : 22,
				o : 35
			}
		} else {
			error('Film type not found, see --help for more info')
		}
	}
}

/**
 * 
 *
 * @function
 * @param {Object} Commander object
 */
function initialize (command) {
	const dpi = command.dpi || 300
	const film = command.film || '16mm'
	const input = command.input || command.args[0] || error('No input file, see --help for more info')
	const output = command.output || command.args[1] || error('No ouput directory, see --help for more info')
	const dim = new Dimensions(film, dpi)

	if (!fs.existsSync(input)) error(`Video "${input}" cannot be found`)

	async.series([
		next => {
			convert(input, dim, next)
		},
		next => {
			stitch(output, dim, next)
		},
		cleanup
	], () => {
		console.log(`Finished creating pages`)
	})
}

/** *
 * Create image sequence from source video, using
 * 
 * @function
 * @param {String} 		input  	file path (absolute)
 * @param {Integer} 	dpi 	target printing dpi
 * @param {Integer} 	length 	strip length in frames
 * 
*/
function convert (input, dim, next) {
	const file = input.split('/').pop()
	const execStr = `avconv -i "${input}" -s ${dim.w}x${dim.h} -qscale 1 "${TMP}v2f_sequence_%04d.jpg"`

	console.log(`Converting  ${file}...`)
	console.log(`Exporting all frames with aspect ratio:  ${dim.w / dim.h}...`)

	if (!fs.existsSync(TMP)) fs.mkdirSync(TMP)

	exec(execStr, (ste, std) => {
		if (ste) {
			return error(ste)
		}
		console.log('Frames exported successfully!')
		next()
	})
}

/** *
 * Stitch rendered frames into strips

 * @function
 * @param {String}	 	output   	Path of folder containing frames
 * @param {Object}	  	dim   		Dimensions object
 * @param {Function}	next		Async lib callback function
 * 
*/
function stitch (output, dim, next) {
	const length = Math.floor((11 * dim.dpi) / dim.h) - 1
	const width = Math.floor((8.5 * dim.dpi / dim.o)) - 1
	const loc = TMP.substring(0, TMP.length - 1)
	const diff = Math.round((dim.o - dim.w) / 2)
	let page = 0
	let pageCount = 0
	let cmd = `find "${loc}" -type f -name "v2f_sequence_*.jpg"`

	console.log('Stitching frames into sheets...')
	console.log(`Sheets will contain ${width}x${length} frames...`)

	exec(cmd, (ste, std) => {
		if (ste) {
			return error(ste)
		}
		let jobs = []
		let cmds = []
		let frames = std.split('\n')
		let execStr = 'montage '
		let pagePath = ``
		let i = 0

		frames = frames.filter(elem => {
			if (elem.indexOf('find: ') === -1) {
				return elem
			}
		})
		frames.sort()
		for (let frame of frames) {
			execStr += `${frame} `
			if ((i + 1) % (width * length) === 0 || i === frames.length - 1) {
				pagePath = path.join(output, `./page_${pad(page)}.jpg`)
				execStr += `\ -tile 1x${length} -geometry ${dim.w}x${dim.h}+${diff}+0 miff:- |\  \nmontage - -geometry +0+0 -tile ${width}x1 -density ${dim.dpi} "${pagePath}"`
				console.log(execStr)
				process.exit()
				cmds.push(execStr)
				execStr = 'montage '
				page++
			}
			i++
		}
		jobs = cmds.map(cmd => {
			return cb => {
				exec(cmd, (err, std, ste) => {
					if (err) {
						return error(err)
					}
					console.log(`Created page of ${width}x${length} frames!`)
					cb()
				})
			}
		})
		async.series(jobs, next)
	})
}

function cleanup (next) {
	console.log('Cleaning up...');
	exec(`rm -r "${TMP}"`,  (err) => {
		if (err) console.error(err)
		if (next) next()
	})
}

function pad (n) {
	return ('00000' + n).slice(-5)
}

var error = function (err) {
	if (process.argv.indexOf('-v') !== -1 || process.argv.indexOf('--verbose') !== -1){
		console.error(err)
	} else {
		console.error('Error running program. Run in verbose mode for more info (-v,--verbose)')
	}
	process.exit(1)
}

process.on('uncaughtException', err => {
	error(err)
})

//convert(process.argv[2], process.argv[3])

//fix for nexe
let args = [].concat(process.argv)
if (args[1].indexOf('v2f.js') === -1) {
	args.reverse()
	args.push('node')
	args.reverse()
}

cmd.arguments('<input> <output>')
	.version('1.1.0')
	.option('-i, --input <path>', 'Video source to print to film strip, anything that avconv can read')
	.option('-o, --output <path>', 'Output directory, will print images on A4 standard paper file')
	.option('-d, --dpi <dpi>', 'DPI output pages')
	.option('-f, --film <gauge>', 'Choose film gauge: 16mm, super16, 35mm')
	.option('-v, --verbose', 'Run in verbose mode')
	.parse(args)

initialize(cmd)