nodejs - Node.js: conversión en tiempo real de imágenes jpeg a archivo de video

nodejs ubuntu

Question

Estoy usando node.js y a través de la biblioteca socket.io recibo fragmentos de datos que en realidad son imágenes jpeg. Estas imágenes son marcos de un video en tiempo real capturado desde una cámara web remota. Me veo obligado a transmitir el video como marcos jpeg. Estoy buscando una forma de convertir sobre la marcha estas imágenes jpeg en un archivo de video (archivo mpeg 4 o mjpeg). ¿El nodo tiene una biblioteca que puede hacer esto? Ya eché un vistazo a la biblioteca Nodo-fluente-FFMPEG , pero los únicos ejemplos que se dieron fueron conversiones de archivos jpeg a un video y no una conversión sobre la marcha de un flujo de imágenes jpeg. O, como alternativa, ¿ffmpeg para windows admite una secuencia de imágenes jpeg como entrada?

Answer 1

Usando require("child_process") puede usar ffmpeg, o probablemente haya módulos npm para ayudar con esto. ffmpeg le permitirá primero tomar una lista de archivos JPEG y convertirla en un video, segundo puede agregar una lista (o solo una) archivos JPEG al principio o al final de los videos.

Answer 2

Creo que deberías mirar el videofy

var exec = require("child_process").exec;
var escape = require("shell-escape");
var debug = require("debug")("videofy");
var mkdirp = require("mkdirp");
var uid = require("uid2");

/*
 *  Expose videofy
 */

module.exports = videofy;

/**
 * Convert `input` file to `output` video with the given `opts`:
 *
 *  - `rate` frame rate [10]
 *  - `encoders` the video codec format, default is libx264
 *
 * @param {String} input
 * @param {String} output
 * @return
 * @api public
 */
function videofy(input, output, opts, fn) {
    if (!input) throw new Error(''input filename required'');
    if (!output) throw new Error(''output filename required'');

    var FORMAT = ''-%05d'';

    // options
    if (''function'' == typeof opts) {
        fn = opts;
        opts = {};
    } else {
        opts = opts || {};
    }

    opts.rate = opts.rate || 10;
    opts.codec = opts.codec || ''libx264'';

    // tmpfile(s)
    var id = uid(10);
    var dir = ''tmp/'' + id;
    var tmp = dir + ''/tmp'' + FORMAT + ''.jpg'';


    function gc(err) {
        debug(''remove %s'', dir);
        exec(''rm -fr '' + dir);
        fn(err);
    }

    debug(''mkdirp -p %s'', dir);

    mkdirp(dir, function(error) {
        if (error) return fn(error);

        // convert gif to tmp jpg
        var cmd = [''convert'', input, tmp];
        cmd = escape(cmd);

        debug(''exec %s'', cmd);
        // covert jpg collection to video
        exec(cmd, function(err) {

            if (err) return gc(err);

            var cmd = [''ffmpeg''];

            cmd.push(''-f'', ''image2'');
            cmd.push(''-r'', String(opts.rate));
            cmd.push(''-i'', tmp);
            cmd.push(''-c:v'', String(opts.codec));
            cmd.push(output);

            cmd = escape(cmd);

            debug("exec %s", cmd);

            exec(cmd, gc);
        });
    });
}

Answer 3

FFMPEG admite flujos como entradas, como se indica en los documentos .

Puede agregar cualquier cantidad de entradas a un comando Ffmpeg. Una entrada puede ser una [...] secuencia legible

Entonces, por ejemplo, admite el uso

ffmpeg().input(fs.createReadStream(''/path/to/input3.avi''));

que crea una secuencia ''/path/to/input3.avi'' desde el archivo en ''/path/to/input3.avi'' .

No sé nada sobre FFMPEG, pero puede extraer sus mensajes de socket.io (los mensajes pueden ser un buffer ya) y envolverlo con su propia implementación de flujo legible .