bare-ffmpeg 1.0.0-0 → 1.0.0-1

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,70 @@
 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() {
+    if (this._opened) return
+    this._opened = true
+    binding.openCodecContext(this._handle)
+    return this
   }
 
   sendPacket(packet) {
     binding.sendCodecContextPacket(this._handle, packet._handle)
+    return this
   }
 
   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,6 @@ module.exports = class FFmpegCodec {
     }
     return codec
   }
+
+  static MJPEG = this.for(constants.codecs.MJPEG)
 }

package/lib/constants.js

@@ -1,8 +1,13 @@
 const binding = require('../binding')
 
 module.exports = exports = {
+  codecs: {
+    MJPEG: binding.AV_CODEC_ID_MJPEG
+  },
   pixelFormats: {
-    RGBA: binding.AV_PIX_FMT_RGBA
+    RGBA: binding.AV_PIX_FMT_RGBA,
+    YUVJ420P: binding.AV_PIX_FMT_YUVJ420P,
+    YUV420P: binding.AV_PIX_FMT_YUV420P
   }
 }
 

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,22 @@
 const binding = require('../binding')
 const Stream = require('./stream.js')
+const ReferenceCounted = require('./reference-counted')
+const OutputFormat = require('./output-format')
 
-module.exports = class FFmpegFormatContext {
+class FFmpegFormatContext extends ReferenceCounted {
   constructor(io) {
-    this._io = io
+    super()
+
+    this._io = io._ref()
     this._streams = []
-    this._handle = binding.initFormatContext(io._handle)
+  }
 
-    for (const handle of binding.getFormatContextStreams(this._handle)) {
-      this._streams.push(new Stream(handle))
-    }
+  _destroy() {
+    this._io._unref()
+    this._io = null
+
+    for (const stream of this._streams) stream.destroy()
+    this._streams = []
   }
 
   get io() {
@@ -20,18 +27,63 @@ 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
+  }
+}
+
+exports.InputFormatContext = class FFmpegInputFormatContext extends (
+  FFmpegFormatContext
+) {
+  constructor(io) {
+    super(io)
+
+    this._handle = binding.openInputFormatContext(io._handle)
+
+    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)
 
-  [Symbol.dispose]() {
-    this.destroy()
+    if (typeof format === 'string') format = new OutputFormat(format)
+
+    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,20 @@
 const binding = require('../binding')
+const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegPacket {
+module.exports = class FFmpegPacket extends ReferenceCounted {
   constructor() {
-    this._handle = binding.initPacket()
-  }
+    super()
 
-  unref() {
-    binding.unrefPacket(this._handle)
+    this._handle = binding.initPacket()
   }
 
-  destroy() {
-    if (this._handle === null) return
+  _destroy() {
     binding.destroyPacket(this._handle)
     this._handle = null
   }
 
-  [Symbol.dispose]() {
-    this.destroy()
+  unref() {
+    this._unref()
+    binding.unrefPacket(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

package/lib/stream.js

@@ -2,9 +2,12 @@ const binding = require('../binding')
 const Codec = require('./codec')
 const CodecContext = require('./codec-context')
 const CodecParameters = require('./codec-parameters')
+const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegStream {
+module.exports = class FFmpegStream extends ReferenceCounted {
   constructor(handle) {
+    super()
+
     this._handle = handle
 
     this._codec = Codec.for(binding.getStreamCodec(this._handle))
@@ -14,6 +17,11 @@ module.exports = class FFmpegStream {
     )
   }
 
+  _destroy() {
+    this._codecParameters.destroy()
+    this._codecParameters = null
+  }
+
   get codec() {
     return this._codec
   }
@@ -23,10 +31,14 @@ module.exports = class FFmpegStream {
   }
 
   decoder() {
-    return new CodecContext(this._codec.decoder, this._codecParameters)
+    const context = new CodecContext(this._codec.decoder)
+    this._codecParameters.toContext(context)
+    return context.open()
   }
 
   encoder() {
-    return new CodecContext(this._codec.encoder, this._codecParameters)
+    const context = new CodecContext(this._codec.encoder)
+    this._codecParameters.toContext(context)
+    return context.open()
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-ffmpeg",
-  "version": "1.0.0-0",
+  "version": "1.0.0-1",
   "description": "Low-level FFmpeg bindings for Bare",
   "exports": {
     ".": "./index.js",