mcopy/src/filmout/index.ts

494 lines
12 KiB
TypeScript
Raw Normal View History

'use strict';
import { default as animated } from 'animated-gif-detector';
import { extname, join } from 'path';
import { readFile, lstat, readdir } from 'fs-extra';
2019-06-15 15:06:57 +00:00
import { delay } from 'delay';
import { createHash } from 'crypto';
import Jimp from 'jimp';
import Frame from 'frame';
2019-08-25 18:59:39 +00:00
/**
* @module FilmOut
**/
class FilmOut {
private id : string = 'filmout';
private videoExtensions : string[] = ['.mpg', '.mpeg', '.mov', '.mkv', '.avi', '.mp4'];
private stillExtensions : string[] = ['.tif', '.tiff', '.png', '.jpg', '.jpeg', '.bmp'];
private sequenceExtensions : string[] = ['.png', '.jpg', '.jpeg'];
private gifExtension : string = '.gif';
public state : any = {
frame : 0,
frames : 0,
still : false,
path : null,
fileName : null,
directory : false,
info : {},
dir : true,
enabled : false,
files : []
};
private display : any;
private ffmpeg : any;
private ffprobe : any;
private light : any;
private ipc : any;
private ui : any;
private log : any;
/**
2019-08-25 18:59:39 +00:00
* @constructor
* Builds FilmOut class with display, ffmpeg, ffprobe, ui and light as internal properties.
*
2019-08-25 18:59:39 +00:00
* @param {object} display Display object for showing frames
* @param {object} ffmpeg FFMPEG wrapper
* @param {object} ffprobe FFPROBE wrapper for file info
* @param {object} ui Electron ui object
* @param {object} light Light device object
**/
constructor (display : any, ffmpeg : any, ffprobe : any, ui : any, light : any) {
this.display = display;
this.ffmpeg = ffmpeg;
this.ffprobe = ffprobe;
this.ui = ui;
this.light = light;
this.init();
}
/**
2019-08-25 18:59:39 +00:00
* Async function for requiring log, ipcMain and bind events.
**/
private async init () {
2019-06-15 15:06:57 +00:00
const Log = require('log');
this.log = await Log({ label : this.id });
this.ipc = require('electron').ipcMain;
this.listen();
}
/**
2019-08-25 18:59:39 +00:00
*
**/
private listen () {
this.ipc.on(this.id, this.onConnect.bind(this));
this.ipc.on('focus', this.focus.bind(this));
this.ipc.on('field', this.field.bind(this));
this.ipc.on('meter', this.meter.bind(this));
this.ipc.on('filmout_close', this.close.bind(this));
this.ipc.on('preview', this.preview.bind(this));
this.ipc.on('preview_frame', this.previewFrame.bind(this));
this.ipc.on('display', this.onDisplay.bind(this));
this.ipc.on('pre_export', this.onPreExport.bind(this));
this.ffmpeg.onProgress = (obj : any) => {
this.ui.send('pre_export_progress', { progress: obj });
}
}
/**
* Create a hash of a string.
*
* @param {string} data Data to produce hash of
*/
private hash (data : string) {
return createHash('sha1').update(data).digest('hex');
}
/**
2019-08-25 18:59:39 +00:00
* Sets filmout direction.
*
2019-08-25 18:59:39 +00:00
* @param {boolean} dir Direction of filmout
**/
public set (dir : boolean) {
this.state.dir = dir;
}
/**
2019-08-25 18:59:39 +00:00
* Moves filmout a frame at a time.
**/
public async move () {
let start : number = +new Date();
if (this.state.still) {
return false;
}
if (this.state.dir) {
this.state.frame++;
} else {
this.state.frame--;
}
if (this.state.frame < 1) {
this.state.frame = 1;
}
return (+new Date()) - start;
}
/**
2019-08-25 18:59:39 +00:00
* Begin the process of exporting single frames from the video for display.
**/
async start () {
let path;
try {
path = await this.ffmpeg.frame(this.state, this.light.state);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
throw err;
}
await this.display.show(path);
await delay(20);
}
/**
2019-08-25 18:59:39 +00:00
* Ends the filmout process and closes the display.
**/
private async end () {
await delay(20);
this.display.hide();
}
/**
* Use a video file as a film out source on "projector"
*
2019-08-25 18:59:39 +00:00
* @param {object} evt Original connect event
* @param {object} arg Arguments from ipc message
**/
async onConnect (evt : any, arg : any) {
let frames : number = 0;
let isAnimated : boolean = false;
let info : any;
let ext : string;
let stats : any;
let frameList : string[];
try {
stats = await lstat(arg.path);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
return false;
}
ext = extname(arg.fileName.toLowerCase());
if (stats.isDirectory()) {
this.state.directory = true;
this.state.still = false;
} else if (ext === this.gifExtension) {
try {
isAnimated = await this.isGifAnimated(arg.path);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
await this.ui.send(this.id, { valid : false });
return false;
}
this.state.still = !isAnimated;
} else if (this.stillExtensions.indexOf(ext) !== -1) {
this.state.still = true;
this.state.directory = false;
} else if (this.videoExtensions.indexOf(ext) !== -1) {
this.state.still = false;
this.state.directory = false;
} else {
this.log.error(`File is not of a valid file type`, 'FILMOUT', true, true);
return false;
}
try {
await this.ffmpeg.clearAll();
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
throw err;
}
if (this.state.directory) {
try {
frameList = await this.dirList(arg.path);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
this.state.enabled = false;
await this.ui.send(this.id, { valid : false });
return false;
}
try {
info = await this.dirInfo(frameList);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
this.state.enabled = false;
await this.ui.send(this.id, { valid : false });
return false;
}
frames = frameList.length;
this.state.files = frameList;
} else if (this.state.still) {
try {
info = await this.stillInfo(arg.path);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
this.state.enabled = false;
await this.ui.send(this.id, { valid : false });
return false;
}
frames = 1;
} else {
try {
info = await this.ffprobe.info(arg.path);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
this.state.enabled = false;
await this.ui.send(this.id, { valid : false });
return false;
}
try {
frames = await this.ffprobe.frames(arg.path);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
this.state.enabled = false;
await this.ui.send(this.id, { valid : false });
return false;
}
}
console.dir(info);
this.state.frame = 0;
this.state.path = arg.path;
this.state.fileName = arg.fileName;
this.state.frames = frames;
this.state.info = info;
this.state.hash = this.hash(arg.path);
if (info.fps) {
this.state.fps = info.fps;
} else {
this.state.fps = 24; //default
}
if (info.seconds) {
this.state.seconds = info.seconds;
} else if (info.fps && frames) {
this.state.seconds = frames / info.fps;
} else if (this.state.directory) {
this.state.seconds = frames / 24;
}
this.log.info(`Opened ${this.state.fileName}`, 'FILMOUT', true, true);
this.log.info(`Frames : ${frames}`, 'FILMOUT', true, true);
this.state.enabled = true;
return await this.ui.send(this.id, { valid : true, state : JSON.stringify(this.state) });
}
2020-01-20 06:15:20 +00:00
/**
* Pre-export all frames from video for display.
*
* @param {object} evt IPC event
* @param {object} arg IPC args
*/
async onPreExport (evt : Event, arg : any) {
if (!this.state.path) {
return await this.ui.send('pre_export', { complete : false, err : 'No file to pre export.' });
}
try {
await this.ffmpeg.frames(this.state);
} catch (err) {
return await this.ui.send('pre_export', { complete : false, err });
}
return await this.ui.send('pre_export', { complete : true });
}
/**
* Return true if gif is animated, false if it is a still
2019-08-25 18:59:39 +00:00
*
* @param {string} pathStr Path to gif to check
*
* @returns {boolean} Whether or not gif is animated
**/
async isGifAnimated (pathStr : string) {
let gifBuffer : Buffer;
try {
gifBuffer = await readFile(pathStr);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
return false;
}
return animated(gifBuffer);
}
/**
* Return information on a still image using the Jimp module
2019-08-25 18:59:39 +00:00
*
* @param {string} pathStr Path to gif to check
*
* @returns {object} Info about still from sharp
**/
async stillInfo (pathStr : string) {
let info : any;
try {
info = await Frame.info(pathStr);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
return info;
}
/**
* Return information on the first still image found in a
* directory using the Jimp module.
*
* @param {array} images List of image paths
*
* @returns {object} Info about first image
**/
async dirInfo (images : string[]) {
let info : any;
try {
info = await this.stillInfo(images[0]);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
return info;
}
/**
* Returns a list of images within a directory, filtered
* for supported types and sorted.
*
* @param {string} pathStr Path to directory
*
* @returns {array} Array of image paths
**/
async dirList (pathStr : string) {
let frameList : string[] = [];
try {
frameList = await readdir(pathStr)
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
frameList = frameList.filter((fileName : string) => {
let ext : string = extname(fileName);
if (this.sequenceExtensions.indexOf(ext) !== -1) {
return true;
}
return false;
});
frameList.sort();
frameList = frameList.map((fileName : string) => {
return join(pathStr, fileName);
});
return frameList;
}
/**
2019-08-25 18:59:39 +00:00
* Preview a frame from the selected video.
*
2019-08-25 18:59:39 +00:00
* @param {object} evt Original event
* @param {object} arg Arguments from message
**/
async previewFrame (evt : any, arg : any) {
const state : any = JSON.parse(JSON.stringify(this.state));
let path : string;
state.frame = arg.frame;
try {
path = await this.ffmpeg.frame(state, { color : [255, 255, 255] });
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
throw err;
}
this.ui.send('preview_frame', { path, frame : arg.frame })
}
/**
* Open a single frame in a display window to preview filmout.
*
2019-08-25 18:59:39 +00:00
* @param {object} evt Original event
* @param {object} arg Arguments from message
**/
async preview (evt : any, arg : any) {
const state : any = JSON.parse(JSON.stringify(this.state));
let path : string;
state.frame = arg.frame;
this.log.info(`Previewing frame ${state.frame} of ${state.fileName}`);
try {
path = await this.ffmpeg.frame(state, { color : [255, 255, 255] });
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
throw err;
}
try {
await this.display.open();
await this.display.show(path);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
}
/**
*
**/
async focus (evt : any, arg : any) {
this.log.info(`Showing focus screen`);
try {
await this.display.open();
await this.display.focus();
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
}
/**
*
**/
async field (evt : any, arg : any) {
const ratio : number = arg.ratio;
this.log.info(`Showing field guide screen`);
try {
await this.display.open();
await this.display.field(ratio);
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
}
/**
*
**/
async meter (evt : any, arg : any) {
this.log.info(`Showing meter screen`);
try {
await this.display.open();
await this.display.meter();
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
}
/**
*
**/
async close (evt : any, arg : any) {
try {
await this.display.hide();
await this.display.close();
} catch (err) {
this.log.error(err, 'FILMOUT', true, true);
}
}
/**
*
**/
onDisplay (evt : any, arg : any) {
this.display.change(arg.display);
this.log.info(`Changing the display to ${arg.display}`);
}
}
module.exports = (display : any, ffmpeg : any, ffprobe : any, ui : any, light : any) => {
return new FilmOut(display, ffmpeg, ffprobe, ui, light);
}