bare-ffmpeg 1.0.0-2 → 1.0.0-21

package/lib/codec.js

@@ -1,6 +1,7 @@
 const Decoder = require('./decoder')
 const Encoder = require('./encoder')
 const constants = require('./constants')
+const binding = require('../binding')
 
 const codecs = new Map()
 
@@ -25,6 +26,21 @@ module.exports = class FFmpegCodec {
     return this._encoder
   }
 
+  get name() {
+    if (Number.isInteger(this._id)) {
+      return binding.getCodecNameByID(this._id)
+    }
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegCodec },
+      id: this.id,
+      name: this.name
+    }
+  }
+
+  /** @return {FFmpegCodec} */
   static for(id) {
     let codec = codecs.get(id)
     if (codec === undefined) {
@@ -36,4 +52,7 @@ 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,9 +1,42 @@
 const binding = require('../binding')
+const errors = require('./errors')
+
+// Helpers
+function makeTag(a, b, c, d) {
+  return (
+    a.charCodeAt(0) |
+    (b.charCodeAt(0) << 8) |
+    (c.charCodeAt(0) << 16) |
+    (d.charCodeAt(0) << 24)
+  )
+}
 
 module.exports = exports = {
   codecs: {
     MJPEG: binding.AV_CODEC_ID_MJPEG,
-    H264: binding.AV_CODEC_ID_H264
+    H264: binding.AV_CODEC_ID_H264,
+    AAC: binding.AV_CODEC_ID_AAC,
+    OPUS: binding.AV_CODEC_ID_OPUS,
+    AV1: binding.AV_CODEC_ID_AV1,
+    FLAC: binding.AV_CODEC_ID_FLAC,
+    MP3: binding.AV_CODEC_ID_MP3
+  },
+  tags: {
+    // Source Ref:
+    // https://github.com/FFmpeg/FFmpeg/blob/master/libavformat/riff.c#L36
+    // https://github.com/FFmpeg/FFmpeg/blob/master/libavformat/riff.c#L530
+    MJPEG: makeTag('M', 'J', 'P', 'G'),
+    H264: makeTag('H', '2', '6', '4'),
+    AV1: makeTag('A', 'V', '0', '1'),
+    AAC: 0x00ff,
+    FLAC: 0xf1ac,
+    MP3: 0x0055
+  },
+  profiles: {
+    H264_MAIN: binding.AV_PROFILE_H264_MAIN
+  },
+  levels: {
+    UNKNOWN: binding.AV_LEVEL_UNKNOWN
   },
   pixelFormats: {
     RGBA: binding.AV_PIX_FMT_RGBA,
@@ -12,7 +45,7 @@ module.exports = exports = {
     UYVY422: binding.AV_PIX_FMT_UYVY422,
     YUV420P: binding.AV_PIX_FMT_YUV420P
   },
-  mediaType: {
+  mediaTypes: {
     UNKNOWN: binding.AVMEDIA_TYPE_UNKNOWN,
     VIDEO: binding.AVMEDIA_TYPE_VIDEO,
     AUDIO: binding.AVMEDIA_TYPE_AUDIO,
@@ -20,17 +53,139 @@ module.exports = exports = {
     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
+  },
+  pictureTypes: {
+    NONE: binding.AV_PICTURE_TYPE_NONE,
+    I: binding.AV_PICTURE_TYPE_I,
+    P: binding.AV_PICTURE_TYPE_P,
+    B: binding.AV_PICTURE_TYPE_B,
+    S: binding.AV_PICTURE_TYPE_S,
+    SI: binding.AV_PICTURE_TYPE_SI,
+    SP: binding.AV_PICTURE_TYPE_SP,
+    BI: binding.AV_PICTURE_TYPE_BI
+  },
+  logLevels: {
+    QUIET: binding.AV_LOG_QUIET,
+    PANIC: binding.AV_LOG_PANIC,
+    FATAL: binding.AV_LOG_FATAL,
+    ERROR: binding.AV_LOG_ERROR,
+    WARNING: binding.AV_LOG_WARNING,
+    INFO: binding.AV_LOG_INFO,
+    VERBOSE: binding.AV_LOG_VERBOSE,
+    DEBUG: binding.AV_LOG_DEBUG,
+    TRACE: binding.AV_LOG_TRACE
+  },
+  codecFlags: {
+    COPY_OPAQUE: binding.AV_CODEC_FLAG_COPY_OPAQUE,
+    FRAME_DURATION: binding.AV_CODEC_FLAG_FRAME_DURATION,
+    PASS1: binding.AV_CODEC_FLAG_PASS1,
+    PASS2: binding.AV_CODEC_FLAG_PASS2,
+    LOOP_FILTER: binding.AV_CODEC_FLAG_LOOP_FILTER,
+    GRAY: binding.AV_CODEC_FLAG_GRAY,
+    PSNR: binding.AV_CODEC_FLAG_PSNR,
+    INTERLACED_DCT: binding.AV_CODEC_FLAG_INTERLACED_DCT,
+    LOW_DELAY: binding.AV_CODEC_FLAG_LOW_DELAY,
+    GLOBAL_HEADER: binding.AV_CODEC_FLAG_GLOBAL_HEADER,
+    BITEXACT: binding.AV_CODEC_FLAG_BITEXACT,
+    AC_PRED: binding.AV_CODEC_FLAG_AC_PRED,
+    INTERLACED_ME: binding.AV_CODEC_FLAG_INTERLACED_ME,
+    CLOSED_GOP: binding.AV_CODEC_FLAG_CLOSED_GOP
+  },
+  formatFlags: {
+    SHOW_IDS: binding.AVFMT_SHOW_IDS,
+    GENERIC_INDEX: binding.AVFMT_GENERIC_INDEX,
+    TS_DISCONT: binding.AVFMT_TS_DISCONT,
+    NOBINSEARCH: binding.AVFMT_NOBINSEARCH,
+    NOGENSEARCH: binding.AVFMT_NOGENSEARCH,
+    NO_BYTE_SEEK: binding.AVFMT_NO_BYTE_SEEK,
+    SEEK_TO_PTS: binding.AVFMT_SEEK_TO_PTS,
+    GLOBALHEADER: binding.AVFMT_GLOBALHEADER,
+    VARIABLE_FPS: binding.AVFMT_VARIABLE_FPS,
+    NODIMENSIONS: binding.AVFMT_NODIMENSIONS,
+    NOSTREAMS: binding.AVFMT_NOSTREAMS,
+    TS_NONSTRICT: binding.AVFMT_TS_NONSTRICT,
+    TS_NEGATIVE: binding.AVFMT_TS_NEGATIVE,
+    NOFILE: binding.AVFMT_NOFILE,
+    NEEDNUMBER: binding.AVFMT_NEEDNUMBER,
+    NOTIMESTAMPS: binding.AVFMT_NOTIMESTAMPS
+  }
+}
+
+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,36 @@
 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 = String(value)
 
-    if (typeof value !== 'string' || value.length < 1) {
-      throw new TypeError(`Value should be a non empty string`)
-    }
     binding.setDictionaryEntry(this._handle, key, value)
   }
+
+  entries() {
+    return binding.getDictionaryEntries(this._handle)
+  }
+
+  *[Symbol.iterator]() {
+    yield* this.entries()
+  }
+
+  [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,26 +1,22 @@
 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')
+/** @typedef {import('./packet')} Packet */
 
-class FFmpegFormatContext extends ReferenceCounted {
+class FFmpegFormatContext {
   constructor(io) {
-    super()
-
-    this._io = io ? io._ref() : null
+    this._io = io
     this._streams = []
   }
 
-  _destroy() {
+  destroy() {
     if (this._io) {
-      this._io._unref()
+      this._io.destroy()
       this._io = null
     }
-
-    for (const stream of this._streams) stream.destroy()
-    this._streams = []
   }
 
   get io() {
@@ -32,23 +28,24 @@ 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)
+  }
 
-    const result = binding.readFormatContextFrame(this._handle, packet._handle)
-    if (result) packet._ref()
-    return result
+  getBestStreamIndex(type) {
+    return binding.getFormatContextBestStreamIndex(this._handle, type)
   }
 
-  getBestStream(type) {
-    if (typeof type !== 'number') {
-      throw new TypeError(
-        `Type parameter should be of type number but got: ${typeof type}`
-      )
+  getStream(index) {
+    if (index < 0 || index >= this._streams.length) {
+      return null
     }
 
-    if (this._streams.length == 0) {
+    return this._streams[index]
+  }
+
+  /** @returns {Stream|null} */
+  getBestStream(type) {
+    if (this._streams.length === 0) {
       return null
     }
 
@@ -63,16 +60,23 @@ class FFmpegFormatContext extends ReferenceCounted {
 
     return this._streams[bestIndex]
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
 }
 
 let defaultURL = null
 
 switch (Bare.platform) {
   case 'darwin':
-    defaultURL = '0'
+  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':
@@ -86,14 +90,20 @@ exports.InputFormatContext = class FFmpegInputFormatContext extends (
   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)) {
@@ -101,8 +111,12 @@ exports.InputFormatContext = class FFmpegInputFormatContext extends (
     }
   }
 
-  _destroy() {
-    super._destroy()
+  dump(printIdx = 0, printUrl = '') {
+    binding.dumpFormatContext(this._handle, false, printIdx, printUrl)
+  }
+
+  destroy() {
+    super.destroy()
 
     binding.closeInputFormatContext(this._handle)
     this._handle = null
@@ -118,22 +132,39 @@ exports.OutputFormatContext = class FFmpegOutputFormatContext extends (
     if (typeof format === 'string') format = new OutputFormat(format)
 
     this._handle = binding.openOutputFormatContext(format._handle, io._handle)
+    this._isOutput = true
   }
 
-  _destroy() {
-    super._destroy()
+  destroy() {
+    super.destroy()
 
     binding.closeOutputFormatContext(this._handle)
     this._handle = null
   }
 
-  createStream(codec) {
-    const stream = new Stream(
-      binding.createFormatContextStream(this._handle, codec._handle)
-    )
+  createStream() {
+    const stream = new Stream(binding.createFormatContextStream(this._handle))
 
     this._streams.push(stream)
 
     return stream
   }
+
+  /** @param {Dictionary} [options] format options */
+  writeHeader(options) {
+    binding.writeFormatContextHeader(this._handle, options?._handle)
+  }
+
+  /** @param {Packet} packet */
+  writeFrame(packet) {
+    binding.writeFormatContextFrame(this._handle, packet._handle)
+  }
+
+  writeTrailer() {
+    binding.writeFormatContextTrailer(this._handle)
+  }
+
+  dump(printIdx = 0, printUrl = '') {
+    binding.dumpFormatContext(this._handle, true, printIdx, printUrl)
+  }
 }

package/lib/frame.js

@@ -1,51 +1,122 @@
 const binding = require('../binding')
-const ReferenceCounted = require('./reference-counted')
+const ChannelLayout = require('./channel-layout')
+const Rational = require('./rational')
 
-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`)
-    }
+  unref() {
+    binding.unrefFrame(this._handle)
+  }
 
-    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) {
+    binding.setFrameChannelLayout(
+      this._handle,
+      ChannelLayout.from(value)._handle
+    )
+  }
+
+  get nbSamples() {
+    return binding.getFrameNbSamples(this._handle)
+  }
+
+  set nbSamples(value) {
+    binding.setFrameNbSamples(this._handle, value)
+  }
+
+  get pictType() {
+    return binding.getFramePictType(this._handle)
+  }
+
+  get pts() {
+    return binding.getFramePTS(this._handle)
+  }
+
+  set pts(value) {
+    return binding.setFramePTS(this._handle, value)
+  }
+
+  get packetDTS() {
+    return binding.getFramePacketDTS(this._handle)
+  }
+
+  set packetDTS(value) {
+    return binding.setFramePacketDTS(this._handle, value)
+  }
+
+  get timeBase() {
+    const view = new Int32Array(binding.getFrameTimeBase(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set timeBase(value) {
+    binding.setFrameTimeBase(this._handle, value.numerator, value.denominator)
   }
 
   alloc() {
     binding.allocFrame(this._handle, 32)
   }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegFrame },
+      width: this.width,
+      height: this.height,
+      pixelFormat: this.pixelFormat,
+      format: this.format,
+      channelLayout: this.channelLayout,
+      nbSamples: this.nbSamples,
+      pictType: this.pictType,
+      pts: this.pts,
+      packetDTS: this.packetDTS,
+      timeBase: this.timeBase
+    }
+  }
 }

package/lib/image.js

@@ -40,8 +40,30 @@ module.exports = class FFmpegImage {
       this._pixelFormat,
       this._width,
       this._height,
+      this._align,
       this._data.buffer,
+      this._data.byteOffset,
       frame._handle
     )
   }
+
+  read(frame) {
+    binding.readImage(
+      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)
+  }
 }

package/lib/input-format.js

@@ -3,7 +3,11 @@ const binding = require('../binding')
 let defaultName = null
 
 switch (Bare.platform) {
+  case 'android':
+    defaultName = 'android_camera'
+    break
   case 'darwin':
+  case 'ios':
     defaultName = 'avfoundation'
     break
   case 'linux':
@@ -16,9 +20,10 @@ switch (Bare.platform) {
 
 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)
   }
+
+  get flags() {
+    return binding.getInputFormatFlags(this._handle)
+  }
 }