bare-ffmpeg 1.0.0-0 → 1.0.0-2

package/index.js

@@ -1,14 +1,39 @@
-exports.Codec = require('./lib/codec')
-exports.CodecContext = require('./lib/codec-context')
-exports.CodecParameters = require('./lib/codec-parameters')
-exports.Decoder = require('./lib/decoder')
-exports.Encoder = require('./lib/encoder')
-exports.FormatContext = require('./lib/format-context')
-exports.Frame = require('./lib/frame')
-exports.Image = require('./lib/image')
-exports.IOContext = require('./lib/io-context')
-exports.Packet = require('./lib/packet')
-exports.Scaler = require('./lib/scaler')
-exports.Stream = require('./lib/stream')
+const Codec = require('./lib/codec')
+const CodecContext = require('./lib/codec-context')
+const CodecParameters = require('./lib/codec-parameters')
+const Decoder = require('./lib/decoder')
+const Encoder = require('./lib/encoder')
+const {
+  InputFormatContext,
+  OutputFormatContext
+} = require('./lib/format-context')
+const Frame = require('./lib/frame')
+const Image = require('./lib/image')
+const IOContext = require('./lib/io-context')
+const InputFormat = require('./lib/input-format')
+const OutputFormat = require('./lib/output-format')
+const Packet = require('./lib/packet')
+const Scaler = require('./lib/scaler')
+const Stream = require('./lib/stream')
+const Rational = require('./lib/rational')
+const Dictionary = require('./lib/dictionary')
+
+exports.Codec = Codec
+exports.CodecContext = CodecContext
+exports.CodecParameters = CodecParameters
+exports.Decoder = Decoder
+exports.Encoder = Encoder
+exports.Frame = Frame
+exports.IOContext = IOContext
+exports.Image = Image
+exports.InputFormat = InputFormat
+exports.InputFormatContext = InputFormatContext
+exports.OutputFormat = OutputFormat
+exports.OutputFormatContext = OutputFormatContext
+exports.Packet = Packet
+exports.Scaler = Scaler
+exports.Stream = Stream
+exports.Rational = Rational
+exports.Dictionary = Dictionary
 
 exports.constants = require('./lib/constants')

package/lib/codec-context.js

@@ -1,38 +1,84 @@
 const binding = require('../binding')
+const ReferenceCounted = require('./reference-counted')
+const Rational = require('./rational')
+
+module.exports = class FFmpegCodecContext extends ReferenceCounted {
+  constructor(codec) {
+    super()
 
-module.exports = class FFmpegCodecContext {
-  constructor(codec, parameters) {
     this._codec = codec
-    this._handle = binding.initCodecContext(codec._handle, parameters._handle)
+    this._opened = false
+    this._handle = binding.initCodecContext(codec._handle)
+  }
+
+  _destroy() {
+    binding.destroyCodecContext(this._handle)
+    this._handle = null
   }
 
   get pixelFormat() {
     return binding.getCodecContextPixelFormat(this._handle)
   }
 
+  set pixelFormat(value) {
+    binding.setCodecContextPixelFormat(this._handle, value)
+  }
+
   get width() {
     return binding.getCodecContextWidth(this._handle)
   }
 
+  set width(value) {
+    binding.setCodecContextWidth(this._handle, value)
+  }
+
   get height() {
     return binding.getCodecContextHeight(this._handle)
   }
 
-  destroy() {
-    if (this._handle === null) return
-    binding.destroyCodecContext(this._handle)
-    this._handle = null
+  set height(value) {
+    binding.setCodecContextHeight(this._handle, value)
+  }
+
+  get timeBase() {
+    const view = new Int32Array(binding.getCodecContextTimeBase(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set timeBase(value) {
+    const view = new Int32Array(2)
+    view[0] = value.numerator
+    view[1] = value.denominator
+    binding.setCodecContextTimeBase(this._handle, view.buffer)
   }
 
-  [Symbol.dispose]() {
-    this.destroy()
+  open(options) {
+    if (this._opened) return
+    this._opened = true
+    if (options) {
+      binding.openCodecContextWithOptions(this._handle, options._handle)
+    } else {
+      binding.openCodecContext(this._handle)
+    }
+    return this
   }
 
   sendPacket(packet) {
     binding.sendCodecContextPacket(this._handle, packet._handle)
+    return this
+  }
+
+  receivePacket(packet) {
+    const res = binding.receiveCodecContextPacket(this._handle, packet._handle)
+    if (res) packet._ref()
+    return res
+  }
+
+  sendFrame(frame) {
+    return binding.sendCodecContextFrame(this._handle, frame._handle)
   }
 
   receiveFrame(frame) {
-    binding.receiveCodecContextFrame(this._handle, frame._handle)
+    return binding.receiveCodecContextFrame(this._handle, frame._handle)
   }
 }

package/lib/codec-parameters.js

@@ -1,5 +1,38 @@
-module.exports = class FFmpegCodecParameters {
+const binding = require('../binding')
+const ReferenceCounted = require('./reference-counted')
+
+module.exports = class FFmpegCodecParameters extends ReferenceCounted {
   constructor(handle) {
+    super()
+
     this._handle = handle
   }
+
+  _destroy() {
+    this._handle = null
+  }
+
+  get bitRate() {
+    return binding.getCodecParametersBitRate(this._handle)
+  }
+
+  get bitsPerCodedSample() {
+    return binding.getCodecParametersBitsPerCodedSample(this._handle)
+  }
+
+  get bitsPerRawSample() {
+    return binding.getCodecParametersBitsPerRawSample(this._handle)
+  }
+
+  get sampleRate() {
+    return binding.getCodecParametersSampleRate(this._handle)
+  }
+
+  fromContext(context) {
+    binding.codecParametersFromContext(this._handle, context._handle)
+  }
+
+  toContext(context) {
+    binding.codecParametersToContext(context._handle, this._handle)
+  }
 }

package/lib/codec.js

@@ -1,5 +1,6 @@
 const Decoder = require('./decoder')
 const Encoder = require('./encoder')
+const constants = require('./constants')
 
 const codecs = new Map()
 
@@ -32,4 +33,7 @@ module.exports = class FFmpegCodec {
     }
     return codec
   }
+
+  static MJPEG = this.for(constants.codecs.MJPEG)
+  static H264 = this.for(constants.codecs.H264)
 }

package/lib/constants.js

@@ -1,8 +1,25 @@
 const binding = require('../binding')
 
 module.exports = exports = {
+  codecs: {
+    MJPEG: binding.AV_CODEC_ID_MJPEG,
+    H264: binding.AV_CODEC_ID_H264
+  },
   pixelFormats: {
-    RGBA: binding.AV_PIX_FMT_RGBA
+    RGBA: binding.AV_PIX_FMT_RGBA,
+    RGB24: binding.AV_PIX_FMT_RGB24,
+    YUVJ420P: binding.AV_PIX_FMT_YUVJ420P,
+    UYVY422: binding.AV_PIX_FMT_UYVY422,
+    YUV420P: binding.AV_PIX_FMT_YUV420P
+  },
+  mediaType: {
+    UNKNOWN: binding.AVMEDIA_TYPE_UNKNOWN,
+    VIDEO: binding.AVMEDIA_TYPE_VIDEO,
+    AUDIO: binding.AVMEDIA_TYPE_AUDIO,
+    DATA: binding.AVMEDIA_TYPE_DATA,
+    SUBTITLE: binding.AVMEDIA_TYPE_SUBTITLE,
+    ATTACHEMENT: binding.AVMEDIA_TYPE_ATTACHMENT,
+    NB: binding.AVMEDIA_TYPE_NB
   }
 }
 

package/lib/dictionary.js

@@ -0,0 +1,33 @@
+const binding = require('../binding')
+const ReferenceCounted = require('./reference-counted')
+
+module.exports = class FFmpegDictionary extends ReferenceCounted {
+  constructor() {
+    super()
+
+    this._handle = binding.initDictionary()
+  }
+
+  _destroy() {
+    binding.destroyDictionary(this._handle)
+    this._handle = null
+  }
+
+  get(key) {
+    if (typeof key !== 'string' || key.length < 1) {
+      throw new TypeError(`Key should be a non empty string`)
+    }
+    return binding.getDictionaryEntry(this._handle, key)
+  }
+
+  set(key, value) {
+    if (typeof key !== 'string' || key.length < 1) {
+      throw new TypeError(`Key should be a non empty string`)
+    }
+
+    if (typeof value !== 'string' || value.length < 1) {
+      throw new TypeError(`Value should be a non empty string`)
+    }
+    binding.setDictionaryEntry(this._handle, key, value)
+  }
+}

package/lib/format-context.js

@@ -1,15 +1,26 @@
 const binding = require('../binding')
 const Stream = require('./stream.js')
+const ReferenceCounted = require('./reference-counted')
+const OutputFormat = require('./output-format')
+const IOContext = require('./io-context')
+const InputFormat = require('./input-format')
 
-module.exports = class FFmpegFormatContext {
+class FFmpegFormatContext extends ReferenceCounted {
   constructor(io) {
-    this._io = io
+    super()
+
+    this._io = io ? io._ref() : null
     this._streams = []
-    this._handle = binding.initFormatContext(io._handle)
+  }
 
-    for (const handle of binding.getFormatContextStreams(this._handle)) {
-      this._streams.push(new Stream(handle))
+  _destroy() {
+    if (this._io) {
+      this._io._unref()
+      this._io = null
     }
+
+    for (const stream of this._streams) stream.destroy()
+    this._streams = []
   }
 
   get io() {
@@ -20,18 +31,109 @@ module.exports = class FFmpegFormatContext {
     return this._streams
   }
 
-  destroy() {
-    if (this._handle === null) return
-    binding.destroyFormatContext(this._handle)
-    this._io = null
+  readFrame(packet) {
+    if (packet._refs !== 0) {
+      throw new Error('Cannot read into packet with active references')
+    }
+
+    const result = binding.readFormatContextFrame(this._handle, packet._handle)
+    if (result) packet._ref()
+    return result
+  }
+
+  getBestStream(type) {
+    if (typeof type !== 'number') {
+      throw new TypeError(
+        `Type parameter should be of type number but got: ${typeof type}`
+      )
+    }
+
+    if (this._streams.length == 0) {
+      return null
+    }
+
+    const bestIndex = binding.getFormatContextBestStreamIndex(
+      this._handle,
+      type
+    )
+
+    if (bestIndex < 0 || bestIndex >= this._streams.length) {
+      return null
+    }
+
+    return this._streams[bestIndex]
+  }
+}
+
+let defaultURL = null
+
+switch (Bare.platform) {
+  case 'darwin':
+    defaultURL = '0'
+    break
+  case 'linux':
+    // TODO: test on real machine
+    defaultURL = '/dev/video0'
+    break
+  case 'win32':
+    defaultURL = 'video=Integrated Camera'
+    break
+}
+
+exports.InputFormatContext = class FFmpegInputFormatContext extends (
+  FFmpegFormatContext
+) {
+  constructor(io, options, url = defaultURL) {
+    if (io instanceof IOContext) {
+      super(io)
+      this._handle = binding.openInputFormatContextWithIO(io._handle)
+    } else if (io instanceof InputFormat) {
+      super()
+      this._handle = binding.openInputFormatContextWithFormat(
+        io._handle,
+        options._handle,
+        url
+      )
+    }
+
+    for (const handle of binding.getFormatContextStreams(this._handle)) {
+      this._streams.push(new Stream(handle))
+    }
+  }
+
+  _destroy() {
+    super._destroy()
+
+    binding.closeInputFormatContext(this._handle)
     this._handle = null
   }
+}
+
+exports.OutputFormatContext = class FFmpegOutputFormatContext extends (
+  FFmpegFormatContext
+) {
+  constructor(format, io) {
+    super(io)
+
+    if (typeof format === 'string') format = new OutputFormat(format)
 
-  [Symbol.dispose]() {
-    this.destroy()
+    this._handle = binding.openOutputFormatContext(format._handle, io._handle)
   }
 
-  readFrame(packet) {
-    binding.readFormatContextFrame(this._handle, packet._handle)
+  _destroy() {
+    super._destroy()
+
+    binding.closeOutputFormatContext(this._handle)
+    this._handle = null
+  }
+
+  createStream(codec) {
+    const stream = new Stream(
+      binding.createFormatContextStream(this._handle, codec._handle)
+    )
+
+    this._streams.push(stream)
+
+    return stream
   }
 }

package/lib/frame.js

@@ -1,17 +1,51 @@
 const binding = require('../binding')
+const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegFrame {
+module.exports = class FFmpegFrame extends ReferenceCounted {
   constructor() {
+    super()
+
     this._handle = binding.initFrame()
   }
 
-  destroy() {
-    if (this._handle === null) return
+  _destroy() {
     binding.destroyFrame(this._handle)
     this._handle = null
   }
 
-  [Symbol.dispose]() {
-    this.destroy()
+  channel(i) {
+    if (i < 0 || i > 7) {
+      throw new RangeError(`Channel index must be between 0 and 7`)
+    }
+
+    return Buffer.from(binding.getFrameChannel(this._handle, i))
+  }
+
+  set width(value) {
+    binding.setFrameWidth(this._handle, value)
+  }
+
+  get width() {
+    return binding.getFrameWidth(this._handle)
+  }
+
+  set height(value) {
+    binding.setFrameHeight(this._handle, value)
+  }
+
+  get height() {
+    return binding.getFrameHeight(this._handle)
+  }
+
+  set pixelFormat(value) {
+    binding.setFramePixelFormat(this._handle, value)
+  }
+
+  get pixelFormat() {
+    return binding.getFramePixelFormat(this._handle)
+  }
+
+  alloc() {
+    binding.allocFrame(this._handle, 32)
   }
 }

package/lib/input-format.js

@@ -0,0 +1,24 @@
+const binding = require('../binding')
+
+let defaultName = null
+
+switch (Bare.platform) {
+  case 'darwin':
+    defaultName = 'avfoundation'
+    break
+  case 'linux':
+    defaultName = 'v4l2'
+    break
+  case 'win32':
+    defaultName = 'dshow'
+    break
+}
+
+module.exports = class FFmpegInputFormat {
+  constructor(name = defaultName) {
+    if (typeof name !== 'string' || name.length < 1) {
+      throw new TypeError('Input format name should be a non empty string')
+    }
+    this._handle = binding.initInputFormat(name)
+  }
+}

package/lib/io-context.js

@@ -1,17 +1,15 @@
 const binding = require('../binding')
+const ReferenceCounted = require('./reference-counted')
+
+module.exports = class FFmpegIOContext extends ReferenceCounted {
+  constructor(buffer = Buffer.alloc(0)) {
+    super()
 
-module.exports = class FFmpegIOContext {
-  constructor(buffer) {
     this._handle = binding.initIOContext(buffer)
   }
 
-  destroy() {
-    if (this._handle === null) return
+  _destroy() {
     binding.destroyIOContext(this._handle)
     this._handle = null
   }
-
-  [Symbol.dispose]() {
-    this.destroy()
-  }
 }

package/lib/output-format.js

@@ -0,0 +1,7 @@
+const binding = require('../binding')
+
+module.exports = class FFmpegOutputFormat {
+  constructor(name) {
+    this._handle = binding.initOutputFormat(name)
+  }
+}

package/lib/packet.js

@@ -1,21 +1,42 @@
 const binding = require('../binding')
+const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegPacket {
-  constructor() {
-    this._handle = binding.initPacket()
+module.exports = class FFmpegPacket extends ReferenceCounted {
+  constructor(buffer) {
+    super()
+
+    if (buffer) {
+      if (!Buffer.isBuffer(buffer)) {
+        throw TypeError(
+          `Buffer parameter should be of type Buffer but got: ${typeof buffer}`
+        )
+      }
+
+      this._handle = binding.initPacketFromBuffer(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength
+      )
+    } else {
+      this._handle = binding.initPacket()
+    }
+  }
+
+  _destroy() {
+    binding.destroyPacket(this._handle)
+    this._handle = null
   }
 
   unref() {
+    this._unref()
     binding.unrefPacket(this._handle)
   }
 
-  destroy() {
-    if (this._handle === null) return
-    binding.destroyPacket(this._handle)
-    this._handle = null
+  get streamIndex() {
+    return binding.getPacketStreamIndex(this._handle)
   }
 
-  [Symbol.dispose]() {
-    this.destroy()
+  get data() {
+    return Buffer.from(binding.getPacketData(this._handle))
   }
 }

package/lib/rational.js

@@ -0,0 +1,6 @@
+module.exports = class FFmpegRational {
+  constructor(numerator, denominator) {
+    this.numerator = numerator
+    this.denominator = denominator
+  }
+}

package/lib/reference-counted.js

@@ -0,0 +1,39 @@
+module.exports = class FFmpegReferenceCounted {
+  constructor() {
+    this._refs = 0
+    this._destroyed = false
+  }
+
+  _ref() {
+    if (this._destroyed === false) this._refs++
+    return this
+  }
+
+  _unref() {
+    if (this._refs === 0) {
+      throw new Error('Cannot unreference object with no active references')
+    }
+
+    if (--this._refs === 0 && this._destroyed === true) this._destroy()
+    return this
+  }
+
+  _destroy() {}
+
+  destroy() {
+    if (this._refs !== 0) {
+      throw new Error('Cannot destroy object with active references')
+    }
+
+    if (this._destroyed === true) {
+      throw new Error('Object has already been destroyed')
+    }
+
+    this._destroyed = true
+    this._destroy()
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+}

package/lib/scaler.js

@@ -1,7 +1,8 @@
 const binding = require('../binding')
 const constants = require('./constants')
+const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegScaler {
+module.exports = class FFmpegScaler extends ReferenceCounted {
   constructor(
     sourcePixelFormat,
     sourceWidth,
@@ -10,6 +11,8 @@ module.exports = class FFmpegScaler {
     targetWidth,
     targetHeight
   ) {
+    super()
+
     sourcePixelFormat = constants.toPixelFormat(sourcePixelFormat)
     targetPixelFormat = constants.toPixelFormat(targetPixelFormat)
 
@@ -30,16 +33,11 @@ module.exports = class FFmpegScaler {
     )
   }
 
-  destroy() {
-    if (this._handle === null) return
+  _destroy() {
     binding.destroyScaler(this._handle)
     this._handle = null
   }
 
-  [Symbol.dispose]() {
-    this.destroy()
-  }
-
   scale(source, y, height, target) {
     if (typeof y !== 'number') {
       target = y