Node.js: konwersja czasu rzeczywistego z obrazów jpeg do pliku wideo

Question

Używam pliku node.js i za pośrednictwem biblioteki socket.io otrzymuję porcje danych, które są w rzeczywistości obrazami jpeg. Te obrazy są klatkami wideo w czasie rzeczywistym zrobionymi ze zdalnej kamery internetowej. Jestem zmuszony przesyłać strumieniowo wideo jako klatki JPEG. Szukam sposobu, aby przekonwertować w locie te pliki JPEG w pliku wideo (mpeg 4 lub plik mjpeg). Czy węzeł ma bibliotekę, która może to zrobić? Już zapoznałem się z biblioteką Node-fluent-FFMPEG, ale podano tylko przykłady konwersji plików jpeg na wideo, a nie konwersję w locie ze strumienia obrazów JPEG. Lub alternatywnie, czy ffmpeg dla Windows obsługuje strumień obrazów jpeg jako dane wejściowe?

Answer 1

Używając require("child_process") możesz użyć ffmpeg, lub są prawdopodobnie moduły npm, aby pomóc w tym. ffmpeg pozwoli ci najpierw zrobić listę plików jpeg i przekonwertować ją na wideo, po drugie możesz dodać listę (lub tylko jedną) jpegs na początku lub na końcu filmu.

Answer 2

myślę, że należy patrzeć na 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 obsługuje strumienie danych wejściowych, jak stwierdzono w docs.

Możesz dodać dowolną liczbę wejść do polecenia Ffmpeg. Wejście może być [...] czytelnym strumień

Tak na przykład wspiera użyciu

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

która tworzy Readable stream z pliku w '/path/to/input3.avi'.

Nie wiem nic na temat FFMPEG, ale możesz wyciągnąć wiadomości przychodzące z socket.io (wiadomości may be a Buffer) i owijać je własną implementacją Readable stream.