bare-ffmpeg 1.0.0-17 → 1.0.0-19

package/README.md

@@ -315,6 +315,24 @@ const params = stream.codecParameters // Get from stream
 
 #### Properties
 
+##### `CodecParameters.codecType`
+
+General type of the encoded data.
+
+**Returns**: `number`
+
+##### `CodecParameters.codecId`
+
+Specific type of the encoded data (the codec used).
+
+**Returns**: `number`
+
+##### `CodecParameters.codecTag`
+
+Additional information about the codec (corresponds to the AVI FOURCC).
+
+**Returns**: `number`
+
 ##### `CodecParameters.bitRate`
 
 Gets the bit rate.
@@ -339,6 +357,31 @@ Gets the sample rate for audio codecs.
 
 **Returns**: `number`
 
+##### `CodecParameters.extraData`
+
+Out-of-band global headers that may be used by some codecs.
+
+**Returns**: `Buffer`
+
+##### `CodecParameters.codecProfile`
+
+Codec-specific bitstream restrictions that the stream conforms to.
+
+**Returns**: `number`
+
+##### `CodecParameters.codecLevel`
+
+Codec-specific bitstream restrictions that the stream conforms to.
+
+**Returns**: `number`
+
+##### `CodecParameters.codecFormat`
+
+Video: the pixel format, the value corresponds to AVPixelFormat.
+Audio: the sample format, the value corresponds to AVSampleFormat.
+
+**Returns**: `number`
+
 #### Methods
 
 ##### `CodecParameters.fromContext(context)`
@@ -636,6 +679,36 @@ Gets the denominator.
 
 **Returns**: `number`
 
+##### `Rational.valid`
+
+Returns if true if rational describes a non-zero & non-negative quantity.
+
+**Returns**: `number`
+
+##### `Rational.uninitialized`
+
+Returns if true when is not set.
+
+**Returns**: `number`
+
+##### `Rational.toNumber()`
+
+see `av_q2d()`
+
+**Returns**: `number`
+
+##### `static Rational.from(number)`
+
+see `av_d2q()`
+
+**Returns**: `Rational`
+
+##### `Rational.rescaleQ(number, timebaseA, timebaseB)`
+
+see `av_rescale_q()`
+
+**Returns**: `number`
+
 ### `Stream`
 
 The `Stream` API provides functionality to access media stream information and create decoders/encoders.

package/binding.cc

@@ -1271,6 +1271,35 @@ bare_ffmpeg_codec_parameters_get_codec_type(
   return parameters->handle->codec_type;
 }
 
+static void
+bare_ffmpeg_codec_parameters_set_codec_type(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int type
+) {
+  parameters->handle->codec_type = static_cast<AVMediaType>(type);
+}
+
+static uint32_t
+bare_ffmpeg_codec_parameters_get_codec_tag(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  return parameters->handle->codec_tag;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_codec_tag(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  uint32_t codec_tag
+) {
+  parameters->handle->codec_tag = codec_tag;
+}
+
 static int32_t
 bare_ffmpeg_codec_parameters_get_codec_id(
   js_env_t *env,
@@ -1280,6 +1309,73 @@ bare_ffmpeg_codec_parameters_get_codec_id(
   return parameters->handle->codec_id;
 }
 
+static void
+bare_ffmpeg_codec_parameters_set_codec_id(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  uint32_t codec_id
+) {
+  parameters->handle->codec_id = static_cast<AVCodecID>(codec_id);
+}
+
+static int
+bare_ffmpeg_codec_parameters_get_codec_level(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  return parameters->handle->level;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_codec_level(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int level
+) {
+  parameters->handle->level = level;
+}
+
+static int
+bare_ffmpeg_codec_parameters_get_codec_profile(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  return parameters->handle->profile;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_codec_profile(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int profile
+) {
+  parameters->handle->profile = profile;
+}
+
+static int
+bare_ffmpeg_codec_parameters_get_codec_format(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  return parameters->handle->format;
+}
+
+static void
+bare_ffmpeg_codec_parameters_set_codec_format(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  int format
+) {
+  parameters->handle->format = format;
+}
+
 static js_arraybuffer_t
 bare_ffmpeg_codec_parameters_get_channel_layout(
   js_env_t *env,
@@ -1338,6 +1434,62 @@ bare_ffmpeg_codec_parameters_get_framerate(
   return result;
 }
 
+static js_arraybuffer_t
+bare_ffmpeg_codec_parameters_get_extra_data(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters
+) {
+  int err;
+
+  js_arraybuffer_t buffer;
+
+  assert(parameters->handle->extradata_size >= 0);
+
+  err = js_create_arraybuffer(
+    env,
+    parameters->handle->extradata,
+    static_cast<size_t>(parameters->handle->extradata_size),
+    buffer
+  );
+  assert(err == 0);
+
+  return buffer;
+}
+
+void
+bare_ffmpeg_codec_parameters_set_extra_data(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_codec_parameters_t, 1> parameters,
+  js_arraybuffer_t buffer,
+  uint32_t offset,
+  uint32_t len
+) {
+  int err;
+
+  std::span<uint8_t> view;
+
+  err = js_get_arraybuffer_info(env, buffer, view);
+  assert(err == 0);
+
+  if (parameters->handle->extradata_size) {
+    assert(parameters->handle->extradata_size > 0);
+    assert(parameters->handle->extradata);
+
+    av_free(parameters->handle->extradata);
+  }
+
+  size_t min_size = len + AV_INPUT_BUFFER_PADDING_SIZE;
+
+  parameters->handle->extradata = reinterpret_cast<uint8_t *>(av_malloc(min_size));
+  memset(&parameters->handle->extradata[len], 0, AV_INPUT_BUFFER_PADDING_SIZE);
+
+  memcpy(parameters->handle->extradata, &view[offset], len);
+
+  parameters->handle->extradata_size = static_cast<int>(len);
+}
+
 static js_arraybuffer_t
 bare_ffmpeg_frame_init(js_env_t *env, js_receiver_t) {
   int err;
@@ -2568,11 +2720,23 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("getCodecParametersSampleRate", bare_ffmpeg_codec_parameters_get_sample_rate)
   V("getCodecParametersNbChannels", bare_ffmpeg_codec_parameters_get_nb_channels)
   V("getCodecParametersCodecType", bare_ffmpeg_codec_parameters_get_codec_type)
+  V("setCodecParametersCodecType", bare_ffmpeg_codec_parameters_set_codec_type)
+  V("getCodecParametersCodecTag", bare_ffmpeg_codec_parameters_get_codec_tag)
+  V("setCodecParametersCodecTag", bare_ffmpeg_codec_parameters_set_codec_tag)
   V("getCodecParametersCodecId", bare_ffmpeg_codec_parameters_get_codec_id)
+  V("setCodecParametersCodecId", bare_ffmpeg_codec_parameters_set_codec_id)
+  V("getCodecParametersCodecLevel", bare_ffmpeg_codec_parameters_get_codec_level)
+  V("setCodecParametersCodecLevel", bare_ffmpeg_codec_parameters_set_codec_level)
+  V("getCodecParametersCodecProfile", bare_ffmpeg_codec_parameters_get_codec_profile)
+  V("setCodecParametersCodecProfile", bare_ffmpeg_codec_parameters_set_codec_profile)
+  V("getCodecParametersCodecFormat", bare_ffmpeg_codec_parameters_get_codec_format)
+  V("setCodecParametersCodecFormat", bare_ffmpeg_codec_parameters_set_codec_format)
   V("getCodecParametersChannelLayout", bare_ffmpeg_codec_parameters_get_channel_layout)
   V("getCodecParametersWidth", bare_ffmpeg_codec_parameters_get_width)
   V("getCodecParametersHeight", bare_ffmpeg_codec_parameters_get_height)
   V("getCodecParametersFramerate", bare_ffmpeg_codec_parameters_get_framerate)
+  V("getCodecParametersExtraData", bare_ffmpeg_codec_parameters_get_extra_data)
+  V("setCodecParametersExtraData", bare_ffmpeg_codec_parameters_set_extra_data)
 
   V("initFrame", bare_ffmpeg_frame_init)
   V("destroyFrame", bare_ffmpeg_frame_destroy)
@@ -2770,6 +2934,120 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V(AVFMT_NEEDNUMBER)
   V(AVFMT_NOTIMESTAMPS)
 
+  // Profile
+  V(AV_PROFILE_UNKNOWN)
+  V(AV_PROFILE_RESERVED)
+  V(AV_PROFILE_AAC_MAIN)
+  V(AV_PROFILE_AAC_LOW)
+  V(AV_PROFILE_AAC_SSR)
+  V(AV_PROFILE_AAC_LTP)
+  V(AV_PROFILE_AAC_HE)
+  V(AV_PROFILE_AAC_HE_V2)
+  V(AV_PROFILE_AAC_LD)
+  V(AV_PROFILE_AAC_ELD)
+  V(AV_PROFILE_AAC_USAC)
+  V(AV_PROFILE_MPEG2_AAC_LOW)
+  V(AV_PROFILE_MPEG2_AAC_HE)
+  V(AV_PROFILE_DNXHD)
+  V(AV_PROFILE_DNXHR_LB)
+  V(AV_PROFILE_DNXHR_SQ)
+  V(AV_PROFILE_DNXHR_HQ)
+  V(AV_PROFILE_DNXHR_HQX)
+  V(AV_PROFILE_DNXHR_444)
+  V(AV_PROFILE_DTS)
+  V(AV_PROFILE_DTS_ES)
+  V(AV_PROFILE_DTS_96_24)
+  V(AV_PROFILE_DTS_HD_HRA)
+  V(AV_PROFILE_DTS_HD_MA)
+  V(AV_PROFILE_DTS_EXPRESS)
+  V(AV_PROFILE_DTS_HD_MA_X)
+  V(AV_PROFILE_DTS_HD_MA_X_IMAX)
+  V(AV_PROFILE_EAC3_DDP_ATMOS)
+  V(AV_PROFILE_TRUEHD_ATMOS)
+  V(AV_PROFILE_MPEG2_422)
+  V(AV_PROFILE_MPEG2_HIGH)
+  V(AV_PROFILE_MPEG2_SS)
+  V(AV_PROFILE_MPEG2_SNR_SCALABLE)
+  V(AV_PROFILE_MPEG2_MAIN)
+  V(AV_PROFILE_MPEG2_SIMPLE)
+  V(AV_PROFILE_H264_CONSTRAINED)
+  V(AV_PROFILE_H264_INTRA)
+  V(AV_PROFILE_H264_BASELINE)
+  V(AV_PROFILE_H264_CONSTRAINED_BASELINE)
+  V(AV_PROFILE_H264_MAIN)
+  V(AV_PROFILE_H264_EXTENDED)
+  V(AV_PROFILE_H264_HIGH)
+  V(AV_PROFILE_H264_HIGH_10)
+  V(AV_PROFILE_H264_HIGH_10_INTRA)
+  V(AV_PROFILE_H264_MULTIVIEW_HIGH)
+  V(AV_PROFILE_H264_HIGH_422)
+  V(AV_PROFILE_H264_HIGH_422_INTRA)
+  V(AV_PROFILE_H264_STEREO_HIGH)
+  V(AV_PROFILE_H264_HIGH_444)
+  V(AV_PROFILE_H264_HIGH_444_PREDICTIVE)
+  V(AV_PROFILE_H264_HIGH_444_INTRA)
+  V(AV_PROFILE_H264_CAVLC_444)
+  V(AV_PROFILE_VC1_SIMPLE)
+  V(AV_PROFILE_VC1_MAIN)
+  V(AV_PROFILE_VC1_COMPLEX)
+  V(AV_PROFILE_VC1_ADVANCED)
+  V(AV_PROFILE_MPEG4_SIMPLE)
+  V(AV_PROFILE_MPEG4_SIMPLE_SCALABLE)
+  V(AV_PROFILE_MPEG4_CORE)
+  V(AV_PROFILE_MPEG4_MAIN)
+  V(AV_PROFILE_MPEG4_N_BIT)
+  V(AV_PROFILE_MPEG4_SCALABLE_TEXTURE)
+  V(AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION)
+  V(AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE)
+  V(AV_PROFILE_MPEG4_HYBRID)
+  V(AV_PROFILE_MPEG4_ADVANCED_REAL_TIME)
+  V(AV_PROFILE_MPEG4_CORE_SCALABLE)
+  V(AV_PROFILE_MPEG4_ADVANCED_CODING)
+  V(AV_PROFILE_MPEG4_ADVANCED_CORE)
+  V(AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE)
+  V(AV_PROFILE_MPEG4_SIMPLE_STUDIO)
+  V(AV_PROFILE_MPEG4_ADVANCED_SIMPLE)
+  V(AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0)
+  V(AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1)
+  V(AV_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION)
+  V(AV_PROFILE_JPEG2000_DCINEMA_2K)
+  V(AV_PROFILE_JPEG2000_DCINEMA_4K)
+  V(AV_PROFILE_VP9_0)
+  V(AV_PROFILE_VP9_1)
+  V(AV_PROFILE_VP9_2)
+  V(AV_PROFILE_VP9_3)
+  V(AV_PROFILE_HEVC_MAIN)
+  V(AV_PROFILE_HEVC_MAIN_10)
+  V(AV_PROFILE_HEVC_MAIN_STILL_PICTURE)
+  V(AV_PROFILE_HEVC_REXT)
+  V(AV_PROFILE_HEVC_MULTIVIEW_MAIN)
+  V(AV_PROFILE_HEVC_SCC)
+  V(AV_PROFILE_VVC_MAIN_10)
+  V(AV_PROFILE_VVC_MAIN_10_444)
+  V(AV_PROFILE_AV1_MAIN)
+  V(AV_PROFILE_AV1_HIGH)
+  V(AV_PROFILE_AV1_PROFESSIONAL)
+  V(AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT)
+  V(AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT)
+  V(AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT)
+  V(AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS)
+  V(AV_PROFILE_MJPEG_JPEG_LS)
+  V(AV_PROFILE_SBC_MSBC)
+  V(AV_PROFILE_PRORES_PROXY)
+  V(AV_PROFILE_PRORES_LT)
+  V(AV_PROFILE_PRORES_STANDARD)
+  V(AV_PROFILE_PRORES_HQ)
+  V(AV_PROFILE_PRORES_4444)
+  V(AV_PROFILE_PRORES_XQ)
+  V(AV_PROFILE_ARIB_PROFILE_A)
+  V(AV_PROFILE_ARIB_PROFILE_C)
+  V(AV_PROFILE_KLVA_SYNC)
+  V(AV_PROFILE_KLVA_ASYNC)
+  V(AV_PROFILE_EVC_BASELINE)
+  V(AV_PROFILE_EVC_MAIN)
+
+  // Levels
+  V(AV_LEVEL_UNKNOWN)
 #undef V
 
   return exports;

package/lib/codec-parameters.d.ts

@@ -8,8 +8,14 @@ declare class FFmpegCodecParameters {
   readonly format: number
   readonly sampleRate: number
   readonly nbChannels: number
-  readonly codecType: number
+  codecType: number
+  codecTag: number
+  codecId: number
+  codecProfile: number
+  codecLevel: number
+  codecFormat: number
   readonly channelLayout: FFmpegChannelLayout
+  extraData: Buffer
 
   constructor(handle: ArrayBuffer)
 

package/lib/codec-parameters.js

@@ -42,10 +42,50 @@ module.exports = class FFmpegCodecParameters {
     return binding.getCodecParametersCodecType(this._handle)
   }
 
+  set codecType(type) {
+    return binding.setCodecParametersCodecType(this._handle, type)
+  }
+
+  get codecTag() {
+    return binding.getCodecParametersCodecTag(this._handle)
+  }
+
+  set codecTag(tag) {
+    return binding.setCodecParametersCodecTag(this._handle, tag)
+  }
+
   get codecId() {
     return binding.getCodecParametersCodecId(this._handle)
   }
 
+  set codecId(id) {
+    return binding.setCodecParametersCodecId(this._handle, id)
+  }
+
+  get codecLevel() {
+    return binding.getCodecParametersCodecLevel(this._handle)
+  }
+
+  set codecLevel(level) {
+    return binding.setCodecParametersCodecLevel(this._handle, level)
+  }
+
+  get codecProfile() {
+    return binding.getCodecParametersCodecProfile(this._handle)
+  }
+
+  set codecProfile(profile) {
+    return binding.setCodecParametersCodecProfile(this._handle, profile)
+  }
+
+  get codecFormat() {
+    return binding.getCodecParametersCodecFormat(this._handle)
+  }
+
+  set codecFormat(format) {
+    return binding.setCodecParametersCodecFormat(this._handle, format)
+  }
+
   get channelLayout() {
     return new ChannelLayout(
       binding.getCodecParametersChannelLayout(this._handle)
@@ -60,6 +100,19 @@ module.exports = class FFmpegCodecParameters {
     return binding.getCodecParametersHeight(this._handle)
   }
 
+  get extraData() {
+    return Buffer.from(binding.getCodecParametersExtraData(this._handle))
+  }
+
+  set extraData(value) {
+    binding.setCodecParametersExtraData(
+      this._handle,
+      value.buffer,
+      value.byteOffset,
+      value.byteLength
+    )
+  }
+
   fromContext(context) {
     binding.codecParametersFromContext(this._handle, context._handle)
   }
@@ -82,7 +135,8 @@ module.exports = class FFmpegCodecParameters {
       sampleRate: this.sampleRate,
       nbChannels: this.nbChannels,
       channelLayout: this.channelLayout,
-      frameRate: this.frameRate
+      frameRate: this.frameRate,
+      extraData: this.extraData
     }
   }
 }

package/lib/constants.d.ts

@@ -6,6 +6,15 @@ declare const constants: {
     OPUS: number
     AV1: number
   }
+  tags: {
+    H264: number
+  }
+  profiles: {
+    H264_MAIN: number
+  }
+  levels: {
+    UNKNOWN: number
+  }
   pixelFormats: {
     RGBA: number
     RGB24: number

package/lib/constants.js

@@ -1,6 +1,16 @@
 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,
@@ -11,6 +21,23 @@ module.exports = exports = {
     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,
     RGB24: binding.AV_PIX_FMT_RGB24,

package/lib/rational.d.ts

@@ -1,8 +1,14 @@
 declare class FFmpegRational {
   numerator: number
   denominator: number
+  valid: boolean
+  unintialized: boolean
 
   constructor(numerator: number, denominator: number)
+
+  toNumber(): number
+  static from(number: number): Rational
+  static rescaleQ(n: Number, a: Rational, b: Rational)
 }
 
 export = FFmpegRational

package/lib/rational.js

@@ -7,21 +7,22 @@ module.exports = class FFmpegRational {
   }
 
   get valid() {
-    // don't support negative denominators unless
-    // required by codec or format
-    if (this.denominator < 1) return false
+    // don't support negative denominators for now
+    if (this.denominator < 0) return false
 
-    // common initial value for AVRational(0, 1)
-    if (this.q2d === 0) return false
+    const n = this.toNumber()
+
+    if (Number.isNaN(n) || n === 0) return false
 
     return true
   }
 
   get uninitialized() {
+    // common initial value for AVRational(0, 1)
     return this.numerator === 0 && this.denominator === 1
   }
 
-  get q2d() {
+  toNumber() {
     return this.numerator / this.denominator
   }
 
@@ -29,4 +30,11 @@ module.exports = class FFmpegRational {
     const view = new Int32Array(binding.rationalD2Q(num))
     return new FFmpegRational(view[0], view[1])
   }
+
+  static rescaleQ(n, src, dst) {
+    return (
+      (n * (src.numerator / src.denominator)) /
+      (dst.numerator / dst.denominator)
+    )
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-ffmpeg",
-  "version": "1.0.0-17",
+  "version": "1.0.0-19",
   "description": "Low-level FFmpeg bindings for Bare",
   "exports": {
     ".": {