@lumen5/beamcoder 0.0.1

package/scratch/stream_avci.js

@@ -0,0 +1,127 @@
+/*
+  Aerostat Beam Coder - Node.js native bindings for FFmpeg.
+  Copyright (C) 2019  Streampunk Media Ltd.
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+  https://www.streampunk.media/ mailto:furnace@streampunk.media
+  14 Ormiscaig, Aultbea, Achnasheen, IV22 2JJ  U.K.
+*/
+
+const beamcoder = require('../index.js');
+const fs = require('fs');
+// const util = require('util');
+
+async function run() {
+  // let demuxer = await createDemuxer('../../media/dpp/AS11_DPP_HD_EXAMPLE_1.mxf');
+  let demuxerStream = beamcoder.demuxerStream({ highwaterMark: 65536 });
+  fs.createReadStream('../../media/dpp/AS11_DPP_HD_EXAMPLE_1.mxf').pipe(demuxerStream);
+  let demuxer = await demuxerStream.demuxer({});
+  // console.log(demuxer);
+
+  let decoder = await beamcoder.decoder({ name: 'h264' });
+  // console.log(decoder);
+
+  const vidStream = demuxer.streams[0];
+  let filterer = await beamcoder.filterer({
+    filterType: 'video',
+    inputParams: [
+      {
+        name: 'in0:v',
+        width: vidStream.codecpar.width,
+        height: vidStream.codecpar.height,
+        pixelFormat: vidStream.codecpar.format,
+        timeBase: vidStream.time_base,
+        pixelAspect: vidStream.sample_aspect_ratio
+      },
+      {
+        name: 'in1:v',
+        width: vidStream.codecpar.width,
+        height: vidStream.codecpar.height,
+        pixelFormat: vidStream.codecpar.format,
+        timeBase: vidStream.time_base,
+        pixelAspect: vidStream.sample_aspect_ratio
+      }
+    ],
+    outputParams: [
+      {
+        name: 'out0:v',
+        pixelFormat: 'yuv422p'
+      }
+    ],
+    filterSpec: '[in0:v] scale=1280:720 [left]; [in1:v] scale=640:360 [right]; [left][right] overlay=format=auto:x=640 [out0:v]'
+  });
+  // console.log(filterer.graph);
+  // console.log(util.inspect(filterer.graph, {depth: null}));
+  console.log(filterer.graph.dump());
+
+  // width = '1000';
+  // const scaleFilter = filterer.graph.filters.find(f => 'scale' === f.filter.name);
+  // scaleFilter.priv = { width: 1000 };
+  // console.log(util.inspect(scaleFilter, {depth: null}));
+
+  // const overlayFilter = filterer.graph.filters.find(f => 'overlay' === f.filter.name);
+  // overlayFilter.priv = { x: 100, y: 100 };
+  // console.log(util.inspect(overlayFilter, {depth: null}));
+
+  let encParams = {
+    name: 'libx264',
+    width: 1280,
+    height: 720,
+    // bit_rate: 10000000,
+    time_base: [1, 25],
+    framerate: [25, 1],
+    // gop_size: 50,
+    // max_b_frames: 1,
+    pix_fmt: 'yuv422p',
+    priv_data: {
+      crf: 23
+      // preset: 'slow',
+      // profile: 'high422',
+      // level: '4.2'
+    }
+  };
+
+  let encoder = beamcoder.encoder(encParams);
+  // console.log(encoder);
+
+  let outFile = fs.createWriteStream('wibble.h264');
+
+  // await demuxer.seek({ frame: 4200, stream_index: 0});
+
+  let packet = {};
+  for ( let x = 0 ; x < 10 && packet !== null; x++ ) {
+    packet = await demuxer.read();
+    if (packet.stream_index == 0) {
+      // console.log(packet);
+      let frames = await decoder.decode(packet);
+      // console.log(frames);
+      let filtFrames = await filterer.filter([
+        { name: 'in0:v', frames: frames.frames },
+        { name: 'in1:v', frames: frames.frames },
+      ]);
+      // console.log(filtFrames);
+
+      let packets = await encoder.encode(filtFrames[0].frames[0]);
+      // console.log(x, packets.totalTime);
+      packets.packets.forEach(x => outFile.write(x.data));
+    }
+  }
+  let frames = await decoder.flush();
+  console.log('flush', frames.total_time, frames.frames.length);
+
+  demuxerStream.destroy();
+}
+
+run().catch(console.error);

package/scratch/stream_mp4.js

@@ -0,0 +1,78 @@
+/*
+  Aerostat Beam Coder - Node.js native bindings for FFmpeg.
+  Copyright (C) 2019  Streampunk Media Ltd.
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+  https://www.streampunk.media/ mailto:furnace@streampunk.media
+  14 Ormiscaig, Aultbea, Achnasheen, IV22 2JJ  U.K.
+*/
+
+const beamcoder = require('../index.js');
+
+async function run() {
+  const urls = [ 'file:../../Media/big_buck_bunny_1080p_h264.mov' ];
+  const spec = { start: 0, end: 24 };
+
+  const params = {
+    video: [
+      {
+        sources: [
+          { url: urls[0], ms: spec, streamIndex: 0 }
+        ],
+        filterSpec: '[in0:v] scale=1280:720, colorspace=all=bt709 [out0:v]',
+        streams: [
+          { name: 'h264', time_base: [1, 90000],
+            codecpar: {
+              width: 1280, height: 720, format: 'yuv422p', color_space: 'bt709',
+              sample_aspect_ratio: [1, 1]
+            }
+          }
+        ]
+      }
+    ],
+    audio: [
+      {
+        sources: [
+          { url: urls[0], ms: spec, streamIndex: 2 }
+        ],
+        filterSpec: '[in0:a] aformat=sample_fmts=fltp:channel_layouts=mono [out0:a]',
+        streams: [
+          { name: 'aac', time_base: [1, 90000],
+            codecpar: {
+              sample_rate: 48000, format: 'fltp', frame_size: 1024,
+              channels: 1, channel_layout: 'mono'
+            }
+          }
+        ]
+      },
+    ],
+    out: {
+      formatName: 'mp4',
+      url: 'file:temp.mp4'
+    }
+  };
+
+  await beamcoder.makeSources(params);
+  const beamStreams = await beamcoder.makeStreams(params);
+
+  await beamStreams.run();
+}
+
+console.log('Running mp4 maker');
+let start = Date.now();
+run()
+  .then(() => console.log(`Finished ${Date.now() - start}ms`))
+  .catch(console.error);
+

package/scratch/stream_mux.js

@@ -0,0 +1,47 @@
+/*
+  Aerostat Beam Coder - Node.js native bindings for FFmpeg.
+  Copyright (C) 2019  Streampunk Media Ltd.
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+  https://www.streampunk.media/ mailto:furnace@streampunk.media
+  14 Ormiscaig, Aultbea, Achnasheen, IV22 2JJ  U.K.
+*/
+
+const beamcoder = require('../index.js');
+const fs = require('fs');
+
+async function run() {
+  let demuxer = await beamcoder.demuxer('../../media/sound/BBCNewsCountdown.wav');
+
+  let muxerStream = beamcoder.muxerStream({ highwaterMark: 65536 });
+  muxerStream.pipe(fs.createWriteStream('test.wav'));
+
+  let muxer = muxerStream.muxer({ format_name: 'wav' });
+  let stream = muxer.newStream(demuxer.streams[0]); // eslint-disable-line
+  // stream.time_base = demuxer.streams[0].time_base;
+  // stream.codecpar = demuxer.streams[0].codecpar;
+  await muxer.openIO();
+
+  await muxer.writeHeader();
+  let packet = {};
+  for ( let x = 0 ; x < 10000 && packet !== null ; x++ ) {
+    packet = await demuxer.read();
+    if (packet)
+      await muxer.writeFrame(packet);
+  }
+  await muxer.writeTrailer();
+}
+
+run();

package/scratch/stream_pcm.js

@@ -0,0 +1,82 @@
+/*
+  Aerostat Beam Coder - Node.js native bindings for FFmpeg.
+  Copyright (C) 2019  Streampunk Media Ltd.
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+  https://www.streampunk.media/ mailto:furnace@streampunk.media
+  14 Ormiscaig, Aultbea, Achnasheen, IV22 2JJ  U.K.
+*/
+
+const beamcoder = require('../index.js');
+const fs = require('fs');
+const util = require('util'); // eslint-disable-line
+
+async function run() {
+  let demuxerStream = beamcoder.demuxerStream({ highwaterMark: 65536 });
+  // fs.createReadStream('../../media/dpp/AS11_DPP_HD_EXAMPLE_1.mxf').pipe(demuxerStream);
+  fs.createReadStream('../../media/sound/BBCNewsCountdown.wav').pipe(demuxerStream);
+
+  let demuxer = await demuxerStream.demuxer();
+  console.log(demuxer.streams);
+
+  let decoder = await beamcoder.decoder({ demuxer: demuxer, stream_index : 0 });
+  // console.log(decoder);
+
+  const audStream = demuxer.streams[0];
+  let filterer = await beamcoder.filterer({
+    filterType: 'audio',
+    inputParams: [
+      {
+        name: '0:a',
+        sampleRate: audStream.codecpar.sample_rate,
+        sampleFormat: audStream.codecpar.format,
+        channelLayout: 'stereo', //audStream.codecpar.channel_layout,
+        timeBase: audStream.time_base
+      }
+    ],
+    outputParams: [
+      {
+        name: 'out0:a',
+        sampleRate: 8000,
+        sampleFormat: 's16',
+        channelLayout: 'stereo'
+      }
+    ],
+    filterSpec: '[0:a] aresample=8000, aformat=sample_fmts=s16:channel_layouts=stereo [out0:a]'
+  });
+  // console.log(filterer.graph);
+  // console.log(util.inspect(filterer.graph.filters[2], {depth: null}));
+  console.log(filterer.graph.dump());
+
+  // const abuffersink = filterer.graph.filters.find(f => 'abuffersink' === f.filter.name);
+  // console.log(util.inspect(abuffersink, {depth: null}));
+
+  let packet = {};
+  for ( let x = 0 ; x < 10000 && packet !== null ; x++ ) {
+    packet = await demuxer.read();
+    if (packet && packet.stream_index == 0) {
+      // console.log(packet);
+      let frames = await decoder.decode(packet);
+      // console.log(frames);
+
+      let filtFrames = await filterer.filter([ // eslint-disable-line
+        { name: '0:a', frames: frames.frames }
+      ]);
+      // console.log(filtFrames);
+    }
+  }
+}
+
+run().catch(console.error);

package/scratch/stream_wav.js

@@ -0,0 +1,62 @@
+/*
+  Aerostat Beam Coder - Node.js native bindings for FFmpeg.
+  Copyright (C) 2019  Streampunk Media Ltd.
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+  https://www.streampunk.media/ mailto:furnace@streampunk.media
+  14 Ormiscaig, Aultbea, Achnasheen, IV22 2JJ  U.K.
+*/
+
+const beamcoder = require('../index.js');
+
+async function run() {
+  const urls = [ 'file:../Media/sound/Countdown.wav' ];
+  const spec = { start: 50, end: 58 };
+  const params = {
+    video: [],
+    audio: [
+      {
+        sources: [
+          { url: urls[0], ms: spec, streamIndex: 0 }
+        ],
+        filterSpec: '[in0:a] \
+                     volume=precision=float:volume=0.8 \
+                     [out0:a]',
+        streams: [
+          { name: 'aac', time_base: [1, 90000],
+            codecpar: {
+              sample_rate: 48000, format: 'fltp', channel_layout: 'stereo'
+            }
+          }
+        ]
+      },
+    ],
+    out: {
+      formatName: 'mp4',
+      url: 'file:temp.mp4'
+    }
+  };
+
+  await beamcoder.makeSources(params);
+  const beamStreams = await beamcoder.makeStreams(params);
+  await beamStreams.run();
+}
+
+console.log('Running wav maker');
+let start = Date.now();
+run()
+  .then(() => console.log(`Finished ${Date.now() - start}ms`))
+  .catch(console.error);
+

package/scripts/install_beamcoder_dependencies.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+ARCH=$(uname -m)
+
+if [[ "$ARCH" == "x86_64" ]]; then
+    echo "Detected 64 bit intel"
+    BINARIES_URL="https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n5.1-latest-linux64-gpl-shared-5.1.tar.xz"
+elif [[ "$ARCH" == "aarch64" ]]; then
+    # ARM linux setup
+    echo "Detected ARM"
+    BINARIES_URL="https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n5.1-latest-linuxarm64-gpl-shared-5.1.tar.xz"
+else
+    echo "\n\n\UNSUPPORTED ARCH $ARCH\n\n\n"
+    exit 1
+fi
+
+rm -rf ./.ffmpeg
+mkdir ./.ffmpeg
+cd ./.ffmpeg
+wget $BINARIES_URL -O ffmpeg.tar.xz
+tar -xf ffmpeg.tar.xz
+rm ffmpeg.tar.xz
+mv $(ls -1) ffmpeg
+
+ldconfig $(realpath .)/ffmpeg/lib/

package/src/adaptor.h

@@ -0,0 +1,202 @@
+/*
+  Aerostat Beam Coder - Node.js native bindings for FFmpeg.
+  Copyright (C) 2019  Streampunk Media Ltd.
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+  https://www.streampunk.media/ mailto:furnace@streampunk.media
+  14 Ormiscaig, Aultbea, Achnasheen, IV22 2JJ  U.K.
+*/
+
+#ifndef ADAPTOR_H
+#define ADAPTOR_H
+
+#include "node_api.h"
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+
+template <class T>
+class Queue {
+public:
+  Queue(uint32_t maxQueue) : mActive(true), mMaxQueue(maxQueue), qu(), m(), cv() {}
+  ~Queue() {}
+
+  void enqueue(T t) {
+    std::unique_lock<std::mutex> lk(m);
+    while(mActive && (qu.size() >= mMaxQueue)) {
+      cv.wait(lk);
+    }
+    qu.push(t);
+    cv.notify_one();
+  }
+
+  T dequeue() {
+    std::unique_lock<std::mutex> lk(m);
+    while(mActive && qu.empty()) {
+      cv.wait(lk);
+    }
+    T val = 0;
+    if (!qu.empty()) {
+      val = qu.front();
+      qu.pop();
+      cv.notify_one();
+    }
+    return val;
+  }
+
+  size_t size() const {
+    std::lock_guard<std::mutex> lk(m);
+    return qu.size();
+  }
+
+  void quit() {
+    std::lock_guard<std::mutex> lk(m);
+    mActive = false;
+    if ((0 == qu.size()) || (qu.size() >= mMaxQueue)) {
+      // ensure release of any blocked thread
+      cv.notify_all();
+    }
+  }
+
+private:
+  bool mActive;
+  uint32_t mMaxQueue;
+  std::queue<T> qu;
+  mutable std::mutex m;
+  std::condition_variable cv;
+};
+
+class Chunk {
+public:
+  Chunk(napi_ref bufRef, void *buf, size_t bufLen)
+    : mBufRef(bufRef), mBuf(buf), mLen(bufLen), mLocalAlloc(nullptr == bufRef) {}
+  ~Chunk() { if (mLocalAlloc) free(mBuf); }
+
+  napi_ref buf_ref() const  { return mBufRef; }
+  const void *buf() const  { return mBuf; }
+  size_t len() const  { return mLen; }
+
+private:
+  const napi_ref mBufRef;
+  void *mBuf;
+  const size_t mLen;
+  const bool mLocalAlloc;
+};
+
+class Adaptor {
+public:
+  Adaptor(uint32_t queueLen)
+    : mQueue(new Queue<Chunk *>(queueLen)), mCurChunk(nullptr), mChunkPos(0), m(), mBuf(1024) {}
+  ~Adaptor() {
+    delete mQueue;
+    std::unique_lock<std::mutex> lk(m);
+    while (mDone.size()) {
+      Chunk *chunk = mDone.back();
+      mDone.pop_back();
+      delete chunk;
+    }
+    mDone.clear();
+  }
+
+  int write(const uint8_t *buf, int bufSize) {
+    uint8_t *qBuf = (uint8_t *)malloc(bufSize);
+    memcpy(qBuf, buf, bufSize);
+    mQueue->enqueue(new Chunk(nullptr, qBuf, bufSize));
+    return bufSize;
+  }
+
+  void *read(size_t numBytes, size_t *bytesRead) {
+    uint8_t *buf = (uint8_t *)malloc(numBytes);
+    *bytesRead = fillBuf(buf, numBytes);
+    if (numBytes != *bytesRead) {
+      if (0 == *bytesRead) {
+        free(buf);
+        buf = nullptr;
+      }
+      else
+        buf = (uint8_t *)realloc(buf, *bytesRead);
+    }
+    return buf;
+  }
+
+  void write(napi_ref bufRef, void *buf, size_t bufLen) {
+    mQueue->enqueue(new Chunk(bufRef, buf, bufLen));
+  }
+
+  int read(uint8_t *buf, int bufSize) {
+    return fillBuf(buf, bufSize);
+  }
+
+  void finish()  { mQueue->quit(); }
+
+  napi_status finaliseBufs(napi_env env) {
+    napi_status status = napi_ok;
+    std::unique_lock<std::mutex> lk(m);
+    while (mDone.size()) {
+      Chunk *chunk = mDone.back();
+      mDone.pop_back();
+      if (chunk->buf_ref())
+        status = napi_delete_reference(env, chunk->buf_ref());
+      delete chunk;
+      if (napi_ok != status) break;
+    }
+    return status;
+  }
+
+  // convenience buffer for avio_alloc_context
+  //  - it shouldn't be needed but avformat_write_header crashes if no buffer is provided
+  unsigned char *buf()  { return &mBuf[0]; }
+  int bufLen() const  { return (int)mBuf.size(); }
+
+private:
+  Queue<Chunk *> *mQueue;
+  std::vector<Chunk *> mDone;
+  Chunk *mCurChunk;
+  size_t mChunkPos;
+  mutable std::mutex m;
+  std::vector<unsigned char> mBuf;
+
+  int fillBuf(uint8_t *buf, size_t numBytes) {
+    int bufOff = 0;
+    while (numBytes) {
+      if (!mCurChunk || (mCurChunk && mCurChunk->len() == mChunkPos))
+        if (!nextChunk())
+          break;
+
+      int curSize = FFMIN(numBytes, mCurChunk->len() - mChunkPos);
+      void *srcBuf = (uint8_t *)mCurChunk->buf() + mChunkPos;
+      memcpy(buf + bufOff, srcBuf, curSize);
+
+      bufOff += curSize;
+      mChunkPos += curSize;
+      numBytes -= curSize;
+    }
+
+    return bufOff;
+  }
+
+  bool nextChunk() {
+    if (mCurChunk) {
+      std::unique_lock<std::mutex> lk(m);
+      mDone.push_back(mCurChunk);
+    }
+
+    mCurChunk = mQueue->dequeue();
+    mChunkPos = 0;
+    return nullptr != mCurChunk;
+  }
+};
+
+#endif