bare-ffmpeg 1.0.0-0 → 1.0.0-10

package/index.js

@@ -1,14 +1,45 @@
-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 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,
+  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 Samples = require('./lib/samples')
+const Scaler = require('./lib/scaler')
+const Stream = require('./lib/stream')
+const Rational = require('./lib/rational')
+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
+exports.Image = Image
+exports.InputFormat = InputFormat
+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.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,38 +1,91 @@
 const binding = require('../binding')
+const Rational = require('./rational')
 
 module.exports = class FFmpegCodecContext {
-  constructor(codec, parameters) {
+  constructor(codec) {
     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)
   }
 
-  [Symbol.dispose]() {
-    this.destroy()
+  get sampleFormat() {
+    return binding.getCodecContextSampleFormat(this._handle)
+  }
+
+  set sampleFormat(value) {
+    return binding.setCodecContextSampleFormat(this._handle, value)
+  }
+
+  get timeBase() {
+    const view = new Int32Array(binding.getCodecContextTimeBase(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set timeBase(value) {
+    binding.setCodecContextTimeBase(
+      this._handle,
+      value.numerator,
+      value.denominator
+    )
+  }
+
+  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 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) {
-    binding.receiveCodecContextFrame(this._handle, frame._handle)
+    return binding.receiveCodecContextFrame(this._handle, frame._handle)
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
   }
 }

package/lib/codec-parameters.js

@@ -1,5 +1,58 @@
+const binding = require('../binding')
+const ChannelLayout = require('./channel-layout')
+
 module.exports = class FFmpegCodecParameters {
   constructor(handle) {
     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 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)
+  }
+
+  toContext(context) {
+    binding.codecParametersToContext(context._handle, this._handle)
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }

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,10 @@ module.exports = class FFmpegCodec {
     }
     return codec
   }
+
+  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,19 +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,
+    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
+    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(pixelFormat) {
-  if (typeof pixelFormat === 'number') return pixelFormat
+exports.toPixelFormat = function toPixelFormat(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.pixelFormats === false) {
+      throw errors.UNKNOWN_PIXEL_FORMAT(`Unknown pixel format '${format}'`)
     }
 
-    return exports.pixelFormats[pixelFormat]
+    return exports.pixelFormats[format]
   }
+
+  throw new TypeError(
+    `Pixel format must be a number or string. Received ${typeof format} (${format})`
+  )
+}
+
+exports.toSampleFormat = function toSampleFormat(format) {
+  if (typeof format === 'number') return format
+
+  if (typeof format === 'string') {
+    if (format in exports.sampleFormats === false) {
+      throw errors.UNKNOWN_SAMPLE_FORMAT(`Unknown sample format '${format}'`)
+    }
+
+    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

@@ -0,0 +1,26 @@
+const binding = require('../binding')
+
+module.exports = class FFmpegDictionary {
+  constructor() {
+    this._handle = binding.initDictionary()
+  }
+
+  destroy() {
+    binding.destroyDictionary(this._handle)
+    this._handle = null
+  }
+
+  get(key) {
+    const value = binding.getDictionaryEntry(this._handle, key)
+    if (value === undefined) return null
+    return value
+  }
+
+  set(key, value) {
+    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,15 +1,24 @@
 const binding = require('../binding')
 const Stream = require('./stream.js')
+const OutputFormat = require('./output-format')
+const IOContext = require('./io-context')
+const InputFormat = require('./input-format')
+const Dictionary = require('./dictionary')
 
-module.exports = class FFmpegFormatContext {
+class FFmpegFormatContext {
   constructor(io) {
     this._io = io
     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.destroy()
+      this._io = null
     }
+
+    for (const stream of this._streams) stream.destroy()
+    this._streams = []
   }
 
   get io() {
@@ -20,18 +29,122 @@ module.exports = class FFmpegFormatContext {
     return this._streams
   }
 
-  destroy() {
-    if (this._handle === null) return
-    binding.destroyFormatContext(this._handle)
-    this._io = null
-    this._handle = null
+  readFrame(packet) {
+    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
+    }
+
+    return this._streams[bestIndex]
   }
 
   [Symbol.dispose]() {
     this.destroy()
   }
+}
 
-  readFrame(packet) {
-    binding.readFormatContextFrame(this._handle, packet._handle)
+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, options, url = defaultURL) {
+    if (io instanceof IOContext) {
+      super(io)
+
+      this._handle = binding.openInputFormatContextWithIO(io._handle)
+    } else if (io instanceof InputFormat) {
+      super()
+
+      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()
+
+    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)
+
+    this._handle = binding.openOutputFormatContext(format._handle, io._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,4 +1,5 @@
 const binding = require('../binding')
+const ChannelLayout = require('./channel-layout')
 
 module.exports = class FFmpegFrame {
   constructor() {
@@ -6,11 +7,64 @@ module.exports = class FFmpegFrame {
   }
 
   destroy() {
-    if (this._handle === null) return
     binding.destroyFrame(this._handle)
     this._handle = null
   }
 
+  get width() {
+    return binding.getFrameWidth(this._handle)
+  }
+
+  set width(value) {
+    binding.setFrameWidth(this._handle, value)
+  }
+
+  get height() {
+    return binding.getFrameHeight(this._handle)
+  }
+
+  set height(value) {
+    binding.setFrameHeight(this._handle, value)
+  }
+
+  get pixelFormat() {
+    return binding.getFramePixelFormat(this._handle)
+  }
+
+  set pixelFormat(value) {
+    binding.setFramePixelFormat(this._handle, value)
+  }
+
+  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)
+  }
 }