bare-ffmpeg 1.0.0-1 → 1.0.0-11

package/index.js

@@ -1,7 +1,9 @@
+const ChannelLayout = require('./lib/channel-layout')
 const Codec = require('./lib/codec')
 const CodecContext = require('./lib/codec-context')
 const CodecParameters = require('./lib/codec-parameters')
 const Decoder = require('./lib/decoder')
+const Dictionary = require('./lib/dictionary')
 const Encoder = require('./lib/encoder')
 const {
   InputFormatContext,
@@ -13,15 +15,18 @@ const IOContext = require('./lib/io-context')
 const InputFormat = require('./lib/input-format')
 const OutputFormat = require('./lib/output-format')
 const Packet = require('./lib/packet')
+const Samples = require('./lib/samples')
 const Scaler = require('./lib/scaler')
 const Stream = require('./lib/stream')
 const Rational = require('./lib/rational')
-const Dictionary = require('./lib/dictionary')
+const Resampler = require('./lib/resampler')
 
+exports.ChannelLayout = ChannelLayout
 exports.Codec = Codec
 exports.CodecContext = CodecContext
 exports.CodecParameters = CodecParameters
 exports.Decoder = Decoder
+exports.Dictionary = Dictionary
 exports.Encoder = Encoder
 exports.Frame = Frame
 exports.IOContext = IOContext
@@ -31,9 +36,10 @@ exports.InputFormatContext = InputFormatContext
 exports.OutputFormat = OutputFormat
 exports.OutputFormatContext = OutputFormatContext
 exports.Packet = Packet
+exports.Samples = Samples
 exports.Scaler = Scaler
 exports.Stream = Stream
 exports.Rational = Rational
-exports.Dictionary = Dictionary
+exports.Resampler = Resampler
 
 exports.constants = require('./lib/constants')

package/lib/channel-layout.js

@@ -0,0 +1,33 @@
+const binding = require('../binding')
+const constants = require('./constants')
+
+module.exports = class FFmpegChannelLayout {
+  constructor(handle) {
+    this._handle = handle
+  }
+
+  get nbChannels() {
+    return binding.getChannelLayoutNbChannels(this._handle)
+  }
+
+  destroy() {
+    binding.destroyChannelLayout(this._handle)
+    this._handle = null
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+
+  static from(value) {
+    if (typeof value === 'string') value = constants.toChannelLayout(value)
+
+    if (typeof value === 'number') {
+      value = binding.channelLayoutFromMask(value)
+    } else if (typeof value === 'object' && value !== null) {
+      value = binding.copyChannelLayout(value._handle)
+    }
+
+    return new this(value)
+  }
+}

package/lib/codec-context.js

@@ -1,17 +1,15 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 const Rational = require('./rational')
+const ChannelLayout = require('./channel-layout')
 
-module.exports = class FFmpegCodecContext extends ReferenceCounted {
+module.exports = class FFmpegCodecContext {
   constructor(codec) {
-    super()
-
     this._codec = codec
     this._opened = false
     this._handle = binding.initCodecContext(codec._handle)
   }
 
-  _destroy() {
+  destroy() {
     binding.destroyCodecContext(this._handle)
     this._handle = null
   }
@@ -40,31 +38,73 @@ module.exports = class FFmpegCodecContext extends ReferenceCounted {
     binding.setCodecContextHeight(this._handle, value)
   }
 
+  get sampleFormat() {
+    return binding.getCodecContextSampleFormat(this._handle)
+  }
+
+  set sampleFormat(value) {
+    return binding.setCodecContextSampleFormat(this._handle, value)
+  }
+
+  get sampleRate() {
+    return binding.getCodecContextSampleRate(this._handle)
+  }
+
+  set sampleRate(value) {
+    binding.setCodecContextSampleRate(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)
+    binding.setCodecContextTimeBase(
+      this._handle,
+      value.numerator,
+      value.denominator
+    )
+  }
+
+  get channelLayout() {
+    return new ChannelLayout(binding.getCodecContextChannelLayout(this._handle))
   }
 
-  open() {
+  set channelLayout(value) {
+    using copy = ChannelLayout.from(value)
+
+    binding.setCodecContextChannelLayout(this._handle, copy._handle)
+  }
+
+  open(options) {
     if (this._opened) return
     this._opened = true
-    binding.openCodecContext(this._handle)
+    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
+    return binding.sendCodecContextPacket(this._handle, packet._handle)
+  }
+
+  receivePacket(packet) {
+    return binding.receiveCodecContextPacket(this._handle, packet._handle)
+  }
+
+  sendFrame(frame) {
+    return binding.sendCodecContextFrame(this._handle, frame._handle)
   }
 
   receiveFrame(frame) {
     return binding.receiveCodecContextFrame(this._handle, frame._handle)
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/codec-parameters.js

@@ -1,14 +1,12 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
+const ChannelLayout = require('./channel-layout')
 
-module.exports = class FFmpegCodecParameters extends ReferenceCounted {
+module.exports = class FFmpegCodecParameters {
   constructor(handle) {
-    super()
-
     this._handle = handle
   }
 
-  _destroy() {
+  destroy() {
     this._handle = null
   }
 
@@ -24,10 +22,28 @@ module.exports = class FFmpegCodecParameters extends ReferenceCounted {
     return binding.getCodecParametersBitsPerRawSample(this._handle)
   }
 
+  get format() {
+    return binding.getCodecParametersFormat(this._handle)
+  }
+
   get sampleRate() {
     return binding.getCodecParametersSampleRate(this._handle)
   }
 
+  get nbChannels() {
+    return binding.getCodecParametersNbChannels(this._handle)
+  }
+
+  get codecType() {
+    return binding.getCodecParametersCodecType(this._handle)
+  }
+
+  get channelLayout() {
+    return new ChannelLayout(
+      binding.getCodecParametersChannelLayout(this._handle)
+    )
+  }
+
   fromContext(context) {
     binding.codecParametersFromContext(this._handle, context._handle)
   }
@@ -35,4 +51,8 @@ module.exports = class FFmpegCodecParameters extends ReferenceCounted {
   toContext(context) {
     binding.codecParametersToContext(context._handle, this._handle)
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/codec.js

@@ -35,4 +35,8 @@ module.exports = class FFmpegCodec {
   }
 
   static MJPEG = this.for(constants.codecs.MJPEG)
+  static H264 = this.for(constants.codecs.H264)
+  static AAC = this.for(constants.codecs.AAC)
+  static OPUS = this.for(constants.codecs.OPUS)
+  static AV1 = this.for(constants.codecs.AV1)
 }

package/lib/constants.js

@@ -1,24 +1,108 @@
 const binding = require('../binding')
+const errors = require('./errors')
+const ChannelLayout = require('./channel-layout')
 
 module.exports = exports = {
   codecs: {
-    MJPEG: binding.AV_CODEC_ID_MJPEG
+    MJPEG: binding.AV_CODEC_ID_MJPEG,
+    H264: binding.AV_CODEC_ID_H264,
+    AAC: binding.AV_CODEC_ID_AAC,
+    OPUS: binding.AV_CODEC_ID_OPUS,
+    AV1: binding.AV_CODEC_ID_AV1
   },
   pixelFormats: {
     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
+  },
+  mediaTypes: {
+    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
+  },
+  sampleFormats: {
+    NONE: binding.AV_SAMPLE_FMT_NONE,
+    U8: binding.AV_SAMPLE_FMT_U8,
+    S16: binding.AV_SAMPLE_FMT_S16,
+    S32: binding.AV_SAMPLE_FMT_S32,
+    S64: binding.AV_SAMPLE_FMT_S64,
+    FLT: binding.AV_SAMPLE_FMT_FLT,
+    DBL: binding.AV_SAMPLE_FMT_DBL,
+    U8P: binding.AV_SAMPLE_FMT_U8P,
+    S16P: binding.AV_SAMPLE_FMT_S16P,
+    S32P: binding.AV_SAMPLE_FMT_S32P,
+    S64P: binding.AV_SAMPLE_FMT_S64P,
+    FLTP: binding.AV_SAMPLE_FMT_FLTP,
+    DBLP: binding.AV_SAMPLE_FMT_DBLP,
+    NB: binding.AV_SAMPLE_FMT_NB
+  },
+  channelLayouts: {
+    MONO: binding.AV_CH_LAYOUT_MONO,
+    STEREO: binding.AV_CH_LAYOUT_STEREO,
+    QUAD: binding.AV_CH_LAYOUT_QUAD,
+    SURROUND: binding.AV_CH_LAYOUT_SURROUND,
+    2_1: binding.AV_CH_LAYOUT_2POINT1,
+    5_0: binding.AV_CH_LAYOUT_5POINT0,
+    5_1: binding.AV_CH_LAYOUT_5POINT1,
+    7_1: binding.AV_CH_LAYOUT_7POINT1,
+    // Aliases
+    2.1: binding.AV_CH_LAYOUT_2POINT1,
+    '5.0': binding.AV_CH_LAYOUT_5POINT0,
+    5.1: binding.AV_CH_LAYOUT_5POINT1,
+    7.1: binding.AV_CH_LAYOUT_7POINT1
+  }
+}
+
+exports.toPixelFormat = function toPixelFormat(format) {
+  if (typeof format === 'number') return format
+
+  if (typeof format === 'string') {
+    if (format in exports.pixelFormats === false) {
+      throw errors.UNKNOWN_PIXEL_FORMAT(`Unknown pixel format '${format}'`)
+    }
+
+    return exports.pixelFormats[format]
   }
+
+  throw new TypeError(
+    `Pixel format must be a number or string. Received ${typeof format} (${format})`
+  )
 }
 
-exports.toPixelFormat = function toPixelFormat(pixelFormat) {
-  if (typeof pixelFormat === 'number') return pixelFormat
+exports.toSampleFormat = function toSampleFormat(format) {
+  if (typeof format === 'number') return format
 
-  if (typeof pixelFormat === 'string') {
-    if (pixelFormat in exports.pixelFormats === false) {
-      throw errors.UNKNOWN_PIXEL_FORMAT(`Unknown pixel format '${pixelFormat}'`)
+  if (typeof format === 'string') {
+    if (format in exports.sampleFormats === false) {
+      throw errors.UNKNOWN_SAMPLE_FORMAT(`Unknown sample format '${format}'`)
     }
 
-    return exports.pixelFormats[pixelFormat]
+    return exports.sampleFormats[format]
   }
+
+  throw new TypeError(
+    `Sample format must be a number or string. Received ${typeof format} (${format})`
+  )
+}
+
+exports.toChannelLayout = function toChannelLayout(layout) {
+  if (typeof layout === 'number') return layout
+
+  if (typeof layout === 'string') {
+    if (layout in exports.channelLayouts === false) {
+      throw errors.UNKNOWN_CHANNEL_LAYOUT(`Unknown channel layout '${layout}'`)
+    }
+
+    return exports.channelLayouts[layout]
+  }
+
+  throw new TypeError(
+    `Channel layout must be a number or string. Received ${typeof layout} (${layout})`
+  )
 }

package/lib/dictionary.js

@@ -1,33 +1,26 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
 
-module.exports = class FFmpegDictionary extends ReferenceCounted {
+module.exports = class FFmpegDictionary {
   constructor() {
-    super()
-
     this._handle = binding.initDictionary()
   }
 
-  _destroy() {
+  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)
+    const value = binding.getDictionaryEntry(this._handle, key)
+    if (value === undefined) return null
+    return value
   }
 
   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)
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/errors.js

@@ -0,0 +1,38 @@
+module.exports = class FFmpegError extends Error {
+  constructor(msg, code, fn = FFmpegError) {
+    super(`${code}: ${msg}`)
+    this.code = code
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, fn)
+    }
+  }
+
+  get name() {
+    return 'FFmpegError'
+  }
+
+  static UNKNOWN_PIXEL_FORMAT(msg) {
+    return new FFmpegError(
+      msg,
+      'UNKNOWN_PIXEL_FORMAT',
+      FFmpegError.UNKNOWN_PIXEL_FORMAT
+    )
+  }
+
+  static UNKNOWN_SAMPLE_FORMAT(msg) {
+    return new FFmpegError(
+      msg,
+      'UNKNOWN_SAMPLE_FORMAT',
+      FFmpegError.UNKNOWN_SAMPLE_FORMAT
+    )
+  }
+
+  static UNKNOWN_CHANNEL_LAYOUT(msg) {
+    return new FFmpegError(
+      msg,
+      'UNKNOWN_CHANNEL_LAYOUT',
+      FFmpegError.UNKNOWN_CHANNEL_LAYOUT
+    )
+  }
+}

package/lib/format-context.js

@@ -1,19 +1,21 @@
 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')
+const Dictionary = require('./dictionary')
 
-class FFmpegFormatContext extends ReferenceCounted {
+class FFmpegFormatContext {
   constructor(io) {
-    super()
-
-    this._io = io._ref()
+    this._io = io
     this._streams = []
   }
 
-  _destroy() {
-    this._io._unref()
-    this._io = null
+  destroy() {
+    if (this._io) {
+      this._io.destroy()
+      this._io = null
+    }
 
     for (const stream of this._streams) stream.destroy()
     this._streams = []
@@ -28,31 +30,90 @@ class FFmpegFormatContext extends ReferenceCounted {
   }
 
   readFrame(packet) {
-    if (packet._refs !== 0) {
-      throw new Error('Cannot read into packet with active references')
+    return binding.readFormatContextFrame(this._handle, packet._handle)
+  }
+
+  getBestStreamIndex(type) {
+    return binding.getFormatContextBestStreamIndex(this._handle, type)
+  }
+
+  getStream(index) {
+    if (index < 0 || index >= this._streams.length) {
+      return null
+    }
+
+    return this._streams[index]
+  }
+
+  getBestStream(type) {
+    if (this._streams.length == 0) {
+      return null
+    }
+
+    const bestIndex = binding.getFormatContextBestStreamIndex(
+      this._handle,
+      type
+    )
+
+    if (bestIndex < 0 || bestIndex >= this._streams.length) {
+      return null
     }
 
-    const result = binding.readFormatContextFrame(this._handle, packet._handle)
-    if (result) packet._ref()
-    return result
+    return this._streams[bestIndex]
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
   }
 }
 
+let defaultURL = null
+
+switch (Bare.platform) {
+  case 'darwin':
+  case 'ios':
+    defaultURL = '0:0'
+    break
+  case 'linux':
+    // TODO: test on real machine
+    // we might need separate contexts for linux
+    // video: V4L2 and audio: ALSA/PulseAudio
+    defaultURL = '/dev/video0'
+    break
+  case 'win32':
+    defaultURL = 'video=Integrated Camera'
+    break
+}
+
 exports.InputFormatContext = class FFmpegInputFormatContext extends (
   FFmpegFormatContext
 ) {
-  constructor(io) {
-    super(io)
+  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.openInputFormatContext(io._handle)
+      options = options || new Dictionary()
+
+      this._handle = binding.openInputFormatContextWithFormat(
+        io._handle,
+        options._handle,
+        url
+      )
+
+      options.destroy()
+    }
 
     for (const handle of binding.getFormatContextStreams(this._handle)) {
       this._streams.push(new Stream(handle))
     }
   }
 
-  _destroy() {
-    super._destroy()
+  destroy() {
+    super.destroy()
 
     binding.closeInputFormatContext(this._handle)
     this._handle = null
@@ -70,8 +131,8 @@ exports.OutputFormatContext = class FFmpegOutputFormatContext extends (
     this._handle = binding.openOutputFormatContext(format._handle, io._handle)
   }
 
-  _destroy() {
-    super._destroy()
+  destroy() {
+    super.destroy()
 
     binding.closeOutputFormatContext(this._handle)
     this._handle = null

package/lib/frame.js

@@ -1,51 +1,71 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
+const ChannelLayout = require('./channel-layout')
 
-module.exports = class FFmpegFrame extends ReferenceCounted {
+module.exports = class FFmpegFrame {
   constructor() {
-    super()
-
     this._handle = binding.initFrame()
   }
 
-  _destroy() {
+  destroy() {
     binding.destroyFrame(this._handle)
     this._handle = null
   }
 
-  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))
+  get width() {
+    return binding.getFrameWidth(this._handle)
   }
 
   set width(value) {
     binding.setFrameWidth(this._handle, value)
   }
 
-  get width() {
-    return binding.getFrameWidth(this._handle)
+  get height() {
+    return binding.getFrameHeight(this._handle)
   }
 
   set height(value) {
     binding.setFrameHeight(this._handle, value)
   }
 
-  get height() {
-    return binding.getFrameHeight(this._handle)
+  get pixelFormat() {
+    return binding.getFramePixelFormat(this._handle)
   }
 
   set pixelFormat(value) {
     binding.setFramePixelFormat(this._handle, value)
   }
 
-  get pixelFormat() {
-    return binding.getFramePixelFormat(this._handle)
+  get format() {
+    return binding.getFrameFormat(this._handle)
+  }
+
+  set format(value) {
+    binding.setFrameFormat(this._handle, value)
+  }
+
+  get channelLayout() {
+    return new ChannelLayout(binding.getFrameChannelLayout(this._handle))
+  }
+
+  set channelLayout(value) {
+    using copy = ChannelLayout.from(value)
+
+    binding.setFrameChannelLayout(this._handle, copy._handle)
+  }
+
+  get nbSamples() {
+    return binding.getFrameNbSamples(this._handle)
+  }
+
+  set nbSamples(value) {
+    binding.setFrameNbSamples(this._handle, value)
   }
 
   alloc() {
     binding.allocFrame(this._handle, 32)
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

package/lib/image.js

@@ -40,8 +40,18 @@ module.exports = class FFmpegImage {
       this._pixelFormat,
       this._width,
       this._height,
+      this._align,
       this._data.buffer,
+      this._data.byteOffset,
       frame._handle
     )
   }
+
+  lineSize(plane = 0) {
+    return binding.getImageLineSize(this._pixelFormat, this._width, plane)
+  }
+
+  static lineSize(pixelFormat, width, plane = 0) {
+    return binding.getImageLineSize(pixelFormat, width, plane)
+  }
 }