bare-ffmpeg 1.0.0-15 → 1.0.0-16

package/index.d.ts

@@ -0,0 +1,46 @@
+import FFmpegAudioFIFO from './lib/audio-fifo'
+import FFmpegChannelLayout from './lib/channel-layout'
+import FFmpegCodec from './lib/codec'
+import FFmpegCodecContext from './lib/codec-context'
+import FFmpegCodecParameters from './lib/codec-parameters'
+import FFmpegDecoder from './lib/decoder'
+import FFmpegDictionary from './lib/dictionary'
+import FFmpegEncoder from './lib/encoder'
+import { InputFormatContext, OutputFormatContext } from './lib/format-context'
+import FFmpegFrame from './lib/frame'
+import FFmpegIOContext from './lib/io-context'
+import FFmpegImage from './lib/image'
+import FFmpegInputFormat from './lib/input-format'
+import FFmpegOutputFormat from './lib/output-format'
+import FFmpegPacket from './lib/packet'
+import FFmpegRational from './lib/rational'
+import FFmpegResampler from './lib/resampler'
+import FFmpegSamples from './lib/samples'
+import FFmpegScaler from './lib/scaler'
+import FFmpegStream from './lib/stream'
+import constants from './lib/constants'
+
+export {
+  FFmpegAudioFIFO as AudioFIFO,
+  FFmpegChannelLayout as ChannelLayout,
+  FFmpegCodec as Codec,
+  FFmpegCodecContext as CodecContext,
+  FFmpegCodecParameters as CodecParameters,
+  FFmpegDecoder as Decoder,
+  FFmpegDictionary as Dictionary,
+  FFmpegEncoder as Encoder,
+  FFmpegFrame as Frame,
+  FFmpegIOContext as IOContext,
+  FFmpegImage as Image,
+  FFmpegInputFormat as InputFormat,
+  FFmpegOutputFormat as OutputFormat,
+  FFmpegPacket as Packet,
+  FFmpegRational as Rational,
+  FFmpegResampler as Resampler,
+  FFmpegSamples as Samples,
+  FFmpegScaler as Scaler,
+  FFmpegStream as Stream,
+  InputFormatContext,
+  OutputFormatContext,
+  constants
+}

package/index.js

@@ -11,16 +11,17 @@ const {
   OutputFormatContext
 } = require('./lib/format-context')
 const Frame = require('./lib/frame')
-const Image = require('./lib/image')
 const IOContext = require('./lib/io-context')
+const Image = require('./lib/image')
 const InputFormat = require('./lib/input-format')
 const OutputFormat = require('./lib/output-format')
 const Packet = require('./lib/packet')
+const Rational = require('./lib/rational')
+const Resampler = require('./lib/resampler')
 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')
+const log = require('./lib/log')
 
 exports.AudioFIFO = AudioFIFO
 exports.ChannelLayout = ChannelLayout
@@ -43,5 +44,6 @@ exports.Scaler = Scaler
 exports.Stream = Stream
 exports.Rational = Rational
 exports.Resampler = Resampler
+exports.log = log
 
 exports.constants = require('./lib/constants')

package/lib/audio-fifo.d.ts

@@ -0,0 +1,20 @@
+import FFmpegFrame from './frame'
+
+declare class FFmpegAudioFIFO {
+  readonly size: number
+  readonly space: number
+
+  constructor(sampleFormat: number, channels: number, nbSamples: number)
+
+  write(frame: FFmpegFrame): number
+  read(frame: FFmpegFrame, nbSamples: number): number
+  peek(frame: FFmpegFrame, nbSamples: number): number
+  drain(nbSamples: number): number
+
+  reset(): void
+
+  destroy(): void
+  [Symbol.dispose](): void
+}
+
+export = FFmpegAudioFIFO

package/lib/channel-layout.d.ts

@@ -0,0 +1,9 @@
+declare class FFmpegChannelLayout {
+  readonly nbChannels: number
+
+  constructor(handle: ArrayBuffer)
+
+  static from(value: FFmpegChannelLayout | string | number): FFmpegChannelLayout
+}
+
+export = FFmpegChannelLayout

package/lib/channel-layout.js

@@ -10,6 +10,10 @@ module.exports = class FFmpegChannelLayout {
     return binding.getChannelLayoutNbChannels(this._handle)
   }
 
+  get mask() {
+    return binding.getChannelLayoutMask(this._handle)
+  }
+
   static from(value) {
     if (typeof value === 'string') value = constants.toChannelLayout(value)
 
@@ -21,4 +25,11 @@ module.exports = class FFmpegChannelLayout {
 
     return new this(value)
   }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegChannelLayout },
+      nbChannels: this.nbChannels
+    }
+  }
 }

package/lib/codec-context.d.ts

@@ -0,0 +1,34 @@
+import FFmpegChannelLayout from './channel-layout'
+import FFmpegDictionary from './dictionary'
+import FFmpegEncoder from './encoder'
+import FFmpegFrame from './frame'
+import FFmpegPacket from './packet'
+import FFmpegRational from './rational'
+
+declare class FFmpegCodecContext {
+  pixelFormat: number
+  width: number
+  height: number
+  sampleFormat: number
+  sampleRate: number
+  timeBase: FFmpegRational
+  gopSize: number
+
+  get channelLayout(): FFmpegChannelLayout
+  set channelLayout(value: FFmpegChannelLayout | string | number)
+
+  constructor(codec: FFmpegEncoder)
+
+  open(options?: FFmpegDictionary): this
+
+  sendPacket(packet: FFmpegPacket): boolean
+  receivePacket(packet: FFmpegPacket): boolean
+
+  sendFrame(frame: FFmpegFrame): boolean
+  receiveFrame(frame: FFmpegFrame): boolean
+
+  destroy(): void
+  [Symbol.dispose](): void
+}
+
+export = FFmpegCodecContext

package/lib/codec-context.js

@@ -67,6 +67,19 @@ module.exports = class FFmpegCodecContext {
     )
   }
 
+  get frameRate() {
+    const view = new Int32Array(binding.getCodecContextFramerate(this._handle))
+    return new Rational(view[0], view[1])
+  }
+
+  set frameRate(value) {
+    binding.setCodecContextFramerate(
+      this._handle,
+      value.numerator,
+      value.denominator
+    )
+  }
+
   get channelLayout() {
     return new ChannelLayout(binding.getCodecContextChannelLayout(this._handle))
   }
@@ -86,6 +99,14 @@ module.exports = class FFmpegCodecContext {
     binding.setCodecContextGOPSize(this._handle, value)
   }
 
+  get flags() {
+    return binding.getCodecContextFlags(this._handle)
+  }
+
+  set flags(value) {
+    binding.setCodecContextFlags(this._handle, value)
+  }
+
   open(options) {
     if (this._opened) return
     this._opened = true
@@ -106,7 +127,11 @@ module.exports = class FFmpegCodecContext {
   }
 
   sendFrame(frame) {
-    return binding.sendCodecContextFrame(this._handle, frame._handle)
+    let frameHandle = undefined
+
+    if (frame) frameHandle = frame._handle
+
+    return binding.sendCodecContextFrame(this._handle, frameHandle)
   }
 
   receiveFrame(frame) {
@@ -116,4 +141,21 @@ module.exports = class FFmpegCodecContext {
   [Symbol.dispose]() {
     this.destroy()
   }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegCodecContext },
+      _codec: this._codec,
+      _opened: this._opened,
+      flags: this.flags,
+      pixelFormat: this.pixelFormat,
+      width: this.width,
+      height: this.height,
+      sampleFormat: this.sampleFormat,
+      sampleRate: this.sampleRate,
+      timeBase: this.timeBase,
+      channelLayout: this.channelLayout,
+      gopSize: this.gopSize
+    }
+  }
 }

package/lib/codec-parameters.d.ts

@@ -0,0 +1,20 @@
+import FFmpegChannelLayout from './channel-layout'
+import FFmpegCodecContext from './codec-context'
+
+declare class FFmpegCodecParameters {
+  readonly bitRate: number
+  readonly bitsPerCodedSample: number
+  readonly bitsPerRawSample: number
+  readonly format: number
+  readonly sampleRate: number
+  readonly nbChannels: number
+  readonly codecType: number
+  readonly channelLayout: FFmpegChannelLayout
+
+  constructor(handle: ArrayBuffer)
+
+  fromContext(context: FFmpegCodecContext): void
+  toContext(context: FFmpegCodecContext): void
+}
+
+export = FFmpegCodecParameters

package/lib/codec-parameters.js

@@ -1,5 +1,6 @@
 const binding = require('../binding')
 const ChannelLayout = require('./channel-layout')
+const Rational = require('./rational')
 
 module.exports = class FFmpegCodecParameters {
   constructor(handle) {
@@ -26,6 +27,13 @@ module.exports = class FFmpegCodecParameters {
     return binding.getCodecParametersSampleRate(this._handle)
   }
 
+  get frameRate() {
+    const view = new Int32Array(
+      binding.getCodecParametersFramerate(this._handle)
+    )
+    return new Rational(view[0], view[1])
+  }
+
   get nbChannels() {
     return binding.getCodecParametersNbChannels(this._handle)
   }
@@ -34,12 +42,24 @@ module.exports = class FFmpegCodecParameters {
     return binding.getCodecParametersCodecType(this._handle)
   }
 
+  get codecId() {
+    return binding.getCodecParametersCodecId(this._handle)
+  }
+
   get channelLayout() {
     return new ChannelLayout(
       binding.getCodecParametersChannelLayout(this._handle)
     )
   }
 
+  get width() {
+    return binding.getCodecParametersWidth(this._handle)
+  }
+
+  get height() {
+    return binding.getCodecParametersHeight(this._handle)
+  }
+
   fromContext(context) {
     binding.codecParametersFromContext(this._handle, context._handle)
   }
@@ -47,4 +67,22 @@ module.exports = class FFmpegCodecParameters {
   toContext(context) {
     binding.codecParametersToContext(context._handle, this._handle)
   }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: FFmpegCodecParameters },
+      codecType: this.codecType,
+      codecId: this.codecId,
+      width: this.width,
+      height: this.height,
+      bitRate: this.bitRate,
+      bitsPerCodedSample: this.bitsPerCodedSample,
+      bitsPerRawSample: this.bitsPerRawSample,
+      format: this.format,
+      sampleRate: this.sampleRate,
+      nbChannels: this.nbChannels,
+      channelLayout: this.channelLayout,
+      frameRate: this.frameRate
+    }
+  }
 }

package/lib/codec.d.ts

@@ -0,0 +1,20 @@
+import FFmpegDecoder from './decoder'
+import FFmpegEncoder from './encoder'
+
+declare class FFmpegCodec {
+  readonly id: number
+  readonly decoder: FFmpegDecoder
+  readonly encoder: FFmpegEncoder
+
+  constructor(id: number)
+
+  static for(id: number): FFmpegCodec
+
+  static MJPEG: FFmpegCodec
+  static H264: FFmpegCodec
+  static AAC: FFmpegCodec
+  static OPUS: FFmpegCodec
+  static AV1: FFmpegCodec
+}
+
+export = FFmpegCodec

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,19 @@ module.exports = class FFmpegCodec {
     return this._encoder
   }
 
+  get name() {
+    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) {

package/lib/constants.d.ts

@@ -0,0 +1,74 @@
+declare const constants: {
+  codecs: {
+    MJPEG: number
+    H264: number
+    AAC: number
+    OPUS: number
+    AV1: number
+  }
+  pixelFormats: {
+    RGBA: number
+    RGB24: number
+    YUVJ420P: number
+    UYVY422: number
+    YUV420P: number
+  }
+  mediaTypes: {
+    UNKNOWN: number
+    VIDEO: number
+    AUDIO: number
+    DATA: number
+    SUBTITLE: number
+    ATTACHEMENT: number
+    NB: number
+  }
+  sampleFormats: {
+    NONE: number
+    U8: number
+    S16: number
+    S32: number
+    S64: number
+    FLT: number
+    DBL: number
+    U8P: number
+    S16P: number
+    S32P: number
+    S64P: number
+    FLTP: number
+    DBLP: number
+    NB: number
+  }
+  channelLayouts: {
+    MONO: number
+    STEREO: number
+    QUAD: number
+    SURROUND: number
+    2_1: number
+    5_0: number
+    5_1: number
+    7_1: number
+    // Aliases
+    2.1: number
+    '5.0': number
+    5.1: number
+    7.1: number
+  }
+  pictureTypes: {
+    NONE: number
+    I: number
+    P: number
+    B: number
+    S: number
+    SI: number
+    SP: number
+    BI: number
+  }
+}
+
+export function toPixelFormat(format: string | number): number
+
+export function toSampleFormat(format: string | number): number
+
+export function toChannelLayout(layout: string | number): number
+
+export default constants

package/lib/constants.js

@@ -1,6 +1,5 @@
 const binding = require('../binding')
 const errors = require('./errors')
-const ChannelLayout = require('./channel-layout')
 
 module.exports = exports = {
   codecs: {
@@ -8,7 +7,9 @@ module.exports = exports = {
     H264: binding.AV_CODEC_ID_H264,
     AAC: binding.AV_CODEC_ID_AAC,
     OPUS: binding.AV_CODEC_ID_OPUS,
-    AV1: binding.AV_CODEC_ID_AV1
+    AV1: binding.AV_CODEC_ID_AV1,
+    FLAC: binding.AV_CODEC_ID_FLAC,
+    MP3: binding.AV_CODEC_ID_MP3
   },
   pixelFormats: {
     RGBA: binding.AV_PIX_FMT_RGBA,
@@ -57,7 +58,7 @@ module.exports = exports = {
     5.1: binding.AV_CH_LAYOUT_5POINT1,
     7.1: binding.AV_CH_LAYOUT_7POINT1
   },
-  pictureType: {
+  pictureTypes: {
     NONE: binding.AV_PICTURE_TYPE_NONE,
     I: binding.AV_PICTURE_TYPE_I,
     P: binding.AV_PICTURE_TYPE_P,
@@ -66,6 +67,51 @@ module.exports = exports = {
     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
   }
 }
 

package/lib/decoder.d.ts

@@ -0,0 +1,7 @@
+import FFmpegCodec from './codec'
+
+declare class FFmpegDecoder {
+  constructor(codec: FFmpegCodec)
+}
+
+export = FFmpegDecoder

package/lib/dictionary.d.ts

@@ -0,0 +1,11 @@
+declare class FFmpegDictionary {
+  constructor()
+
+  get(key: string): string
+  set(key: string, value: string): void
+
+  destroy(): void
+  [Symbol.dispose](): void
+}
+
+export = FFmpegDictionary

package/lib/dictionary.js

@@ -17,6 +17,8 @@ module.exports = class FFmpegDictionary {
   }
 
   set(key, value) {
+    if (typeof value !== 'string') value = String(value)
+
     binding.setDictionaryEntry(this._handle, key, value)
   }
 

package/lib/encoder.d.ts

@@ -0,0 +1,7 @@
+import FFmpegCodec from './codec'
+
+declare class FFmpegEncoder {
+  constructor(codec: FFmpegCodec)
+}
+
+export = FFmpegEncoder

package/lib/format-context.d.ts

@@ -0,0 +1,43 @@
+import FFmpegIOContext from './io-context'
+import FFmpegStream from './stream'
+import FFmpegPacket from './packet'
+import FFmpegCodec from './codec'
+import FFmpegOutputFormat from './output-format'
+import FFmpegInputFormat from './input-format'
+import FFmpegDictionary from './dictionary'
+
+declare class FFmpegFormatContext {
+  readonly io: FFmpegIOContext
+  readonly streams: FFmpegStream[]
+
+  constructor(io: FFmpegIOContext)
+
+  readFrame(packet: FFmpegPacket): boolean
+
+  getBestStreamIndex(type: number): number
+  getStream(index: number): FFmpegStream
+  getBestStream(type: number): FFmpegStream | null
+
+  destroy(): void
+  [Symbol.dispose](): void
+}
+
+declare class FFmpegInputFormatContext extends FFmpegFormatContext {
+  constructor(io: FFmpegIOContext)
+  constructor(input: FFmpegInputFormat, option?: FFmpegDictionary, url?: string)
+
+  destroy(): void
+}
+
+declare class FFmpegOutputFormatContext extends FFmpegFormatContext {
+  constructor(format: FFmpegOutputFormat | string, io: FFmpegIOContext)
+
+  createStream(codec: FFmpegCodec): FFmpegStream
+
+  destroy(): void
+}
+
+export {
+  FFmpegInputFormatContext as InputFormatContext,
+  FFmpegOutputFormatContext as OutputFormatContext
+}

package/lib/format-context.js

@@ -4,6 +4,7 @@ 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 {
   constructor(io) {
@@ -42,8 +43,9 @@ class FFmpegFormatContext {
     return this._streams[index]
   }
 
+  /** @returns {Stream|null} */
   getBestStream(type) {
-    if (this._streams.length == 0) {
+    if (this._streams.length === 0) {
       return null
     }
 
@@ -109,6 +111,10 @@ exports.InputFormatContext = class FFmpegInputFormatContext extends (
     }
   }
 
+  dump(printIdx = 0, printUrl = '') {
+    binding.dumpFormatContext(this._handle, false, printIdx, printUrl)
+  }
+
   destroy() {
     super.destroy()
 
@@ -126,6 +132,7 @@ 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() {
@@ -135,13 +142,29 @@ exports.OutputFormatContext = class FFmpegOutputFormatContext extends (
     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)
+  }
 }