feat(hw-frames-context): expose constraints (#192)

Signed-off-by: Tony Gorez <gorez.tony@gmail.com>

Author: tony-go

binding.cc

@@ -143,6 +143,10 @@ typedef struct {
   AVBufferRef *handle;
 } bare_ffmpeg_hw_frames_context_t;
 
+typedef struct {
+  AVHWFramesConstraints *handle;
+} bare_ffmpeg_hw_frames_constraints_t;
+
 static uv_once_t bare_ffmpeg__init_guard = UV_ONCE_INIT;
 
 static void
@@ -2718,6 +2722,113 @@ bare_ffmpeg_hw_frames_context_get_buffer(
   }
 }
 
+static js_arraybuffer_t
+bare_ffmpeg_hw_frames_context_get_constraints(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_hw_frames_context_t, 1> hw_frames_ctx
+) {
+  int err;
+
+  AVHWFramesContext *frames_ctx = reinterpret_cast<AVHWFramesContext *>(hw_frames_ctx->handle->data);
+
+  AVHWFramesConstraints *constraints = av_hwdevice_get_hwframe_constraints(frames_ctx->device_ref, NULL);
+  if (!constraints) {
+    err = js_throw_error(env, NULL, "Failed to get hardware frame constraints");
+    assert(err == 0);
+    throw js_pending_exception;
+  }
+
+  js_arraybuffer_t handle;
+  bare_ffmpeg_hw_frames_constraints_t *hw_frames_constraints;
+
+  err = js_create_arraybuffer(env, hw_frames_constraints, handle);
+  assert(err == 0);
+
+  hw_frames_constraints->handle = constraints;
+
+  return handle;
+}
+
+static void
+bare_ffmpeg_hw_frames_constraints_destroy(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_hw_frames_constraints_t, 1> hw_frames_constraints
+) {
+  av_hwframe_constraints_free(&hw_frames_constraints->handle);
+}
+
+static std::vector<int32_t>
+bare_ffmpeg_hw_frames_constraints_get_valid_sw_formats(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_hw_frames_constraints_t, 1> hw_frames_constraints
+) {
+  std::vector<int32_t> formats;
+
+  if (hw_frames_constraints->handle->valid_sw_formats) {
+    for (int i = 0; hw_frames_constraints->handle->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
+      formats.push_back(hw_frames_constraints->handle->valid_sw_formats[i]);
+    }
+  }
+
+  return formats;
+}
+
+static std::vector<int32_t>
+bare_ffmpeg_hw_frames_constraints_get_valid_hw_formats(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_hw_frames_constraints_t, 1> hw_frames_constraints
+) {
+  std::vector<int32_t> formats;
+
+  if (hw_frames_constraints->handle->valid_hw_formats) {
+    for (int i = 0; hw_frames_constraints->handle->valid_hw_formats[i] != AV_PIX_FMT_NONE; i++) {
+      formats.push_back(hw_frames_constraints->handle->valid_hw_formats[i]);
+    }
+  }
+
+  return formats;
+}
+
+static int32_t
+bare_ffmpeg_hw_frames_constraints_get_min_width(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_hw_frames_constraints_t, 1> hw_frames_constraints
+) {
+  return hw_frames_constraints->handle->min_width;
+}
+
+static int32_t
+bare_ffmpeg_hw_frames_constraints_get_max_width(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_hw_frames_constraints_t, 1> hw_frames_constraints
+) {
+  return hw_frames_constraints->handle->max_width;
+}
+
+static int32_t
+bare_ffmpeg_hw_frames_constraints_get_min_height(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_hw_frames_constraints_t, 1> hw_frames_constraints
+) {
+  return hw_frames_constraints->handle->min_height;
+}
+
+static int32_t
+bare_ffmpeg_hw_frames_constraints_get_max_height(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_hw_frames_constraints_t, 1> hw_frames_constraints
+) {
+  return hw_frames_constraints->handle->max_height;
+}
+
 static int32_t
 bare_ffmpeg_hw_frames_context_get_format(
   js_env_t *env,
@@ -2802,6 +2913,27 @@ bare_ffmpeg_hw_frames_context_set_height(
   ctx->height = height;
 }
 
+static int32_t
+bare_ffmpeg_hw_frames_context_get_initial_pool_size(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_hw_frames_context_t, 1> hw_frames_ctx
+) {
+  AVHWFramesContext *ctx = reinterpret_cast<AVHWFramesContext *>(hw_frames_ctx->handle->data);
+  return ctx->initial_pool_size;
+}
+
+static void
+bare_ffmpeg_hw_frames_context_set_initial_pool_size(
+  js_env_t *env,
+  js_receiver_t,
+  js_arraybuffer_span_of_t<bare_ffmpeg_hw_frames_context_t, 1> hw_frames_ctx,
+  int32_t initial_pool_size
+) {
+  AVHWFramesContext *ctx = reinterpret_cast<AVHWFramesContext *>(hw_frames_ctx->handle->data);
+  ctx->initial_pool_size = initial_pool_size;
+}
+
 static js_arraybuffer_t
 bare_ffmpeg_image_init(
   js_env_t *env,
@@ -4559,7 +4691,18 @@ bare_ffmpeg_exports(js_env_t *env, js_value_t *exports) {
   V("setHWFramesContextWidth", bare_ffmpeg_hw_frames_context_set_width)
   V("getHWFramesContextHeight", bare_ffmpeg_hw_frames_context_get_height)
   V("setHWFramesContextHeight", bare_ffmpeg_hw_frames_context_set_height)
+  V("getHWFramesContextInitialPoolSize", bare_ffmpeg_hw_frames_context_get_initial_pool_size)
+  V("setHWFramesContextInitialPoolSize", bare_ffmpeg_hw_frames_context_set_initial_pool_size)
   V("getHWFramesContextBuffer", bare_ffmpeg_hw_frames_context_get_buffer)
+  V("getHWFramesContextConstraints", bare_ffmpeg_hw_frames_context_get_constraints)
+
+  V("destroyHWFramesConstraints", bare_ffmpeg_hw_frames_constraints_destroy)
+  V("getHWFramesConstraintsValidSwFormats", bare_ffmpeg_hw_frames_constraints_get_valid_sw_formats)
+  V("getHWFramesConstraintsValidHwFormats", bare_ffmpeg_hw_frames_constraints_get_valid_hw_formats)
+  V("getHWFramesConstraintsMinWidth", bare_ffmpeg_hw_frames_constraints_get_min_width)
+  V("getHWFramesConstraintsMaxWidth", bare_ffmpeg_hw_frames_constraints_get_max_width)
+  V("getHWFramesConstraintsMinHeight", bare_ffmpeg_hw_frames_constraints_get_min_height)
+  V("getHWFramesConstraintsMaxHeight", bare_ffmpeg_hw_frames_constraints_get_max_height)
 
   V("initImage", bare_ffmpeg_image_init)
   V("fillImage", bare_ffmpeg_image_fill)

index.js

@@ -14,6 +14,7 @@ const FilterInOut = require('./lib/filter-inout')
 const Frame = require('./lib/frame')
 const HWDeviceContext = require('./lib/hw-device-context')
 const HWFramesContext = require('./lib/hw-frames-context')
+const HWFramesConstraints = require('./lib/hw-frames-constraints')
 const IOContext = require('./lib/io-context')
 const Image = require('./lib/image')
 const InputFormat = require('./lib/input-format')
@@ -41,6 +42,7 @@ exports.FilterInOut = FilterInOut
 exports.Frame = Frame
 exports.HWDeviceContext = HWDeviceContext
 exports.HWFramesContext = HWFramesContext
+exports.HWFramesConstraints = HWFramesConstraints
 exports.IOContext = IOContext
 exports.Image = Image
 exports.InputFormat = InputFormat

lib/hw-frames-constraints.js

@@ -0,0 +1,54 @@
+const binding = require('../binding')
+
+module.exports = class HWFramesConstraints {
+  constructor(handle) {
+    this._handle = handle
+  }
+
+  get validSwFormats() {
+    return binding.getHWFramesConstraintsValidSwFormats(this._handle)
+  }
+
+  get validHwFormats() {
+    return binding.getHWFramesConstraintsValidHwFormats(this._handle)
+  }
+
+  get minWidth() {
+    return binding.getHWFramesConstraintsMinWidth(this._handle)
+  }
+
+  get maxWidth() {
+    return binding.getHWFramesConstraintsMaxWidth(this._handle)
+  }
+
+  get minHeight() {
+    return binding.getHWFramesConstraintsMinHeight(this._handle)
+  }
+
+  get maxHeight() {
+    return binding.getHWFramesConstraintsMaxHeight(this._handle)
+  }
+
+  // Note: HWFramesConstraints is independently allocated by FFmpeg and must be
+  // explicitly freed. It is not owned by HWFramesContext.
+  destroy() {
+    binding.destroyHWFramesConstraints(this._handle)
+    this._handle = null
+  }
+
+  [Symbol.dispose]() {
+    this.destroy()
+  }
+
+  [Symbol.for('bare.inspect')]() {
+    return {
+      __proto__: { constructor: HWFramesConstraints },
+      validSwFormats: this.validSwFormats,
+      validHwFormats: this.validHwFormats,
+      minWidth: this.minWidth,
+      maxWidth: this.maxWidth,
+      minHeight: this.minHeight,
+      maxHeight: this.maxHeight
+    }
+  }
+}

lib/hw-frames-context.js

@@ -1,4 +1,5 @@
 const binding = require('../binding')
+const HWFramesConstraints = require('./hw-frames-constraints')
 
 module.exports = class HWFramesContext {
   constructor(hwDeviceContext, format, swFormat, width, height, handle = undefined) {
@@ -53,10 +54,23 @@ module.exports = class HWFramesContext {
     binding.setHWFramesContextHeight(this._handle, value)
   }
 
+  get initialPoolSize() {
+    return binding.getHWFramesContextInitialPoolSize(this._handle)
+  }
+
+  set initialPoolSize(value) {
+    binding.setHWFramesContextInitialPoolSize(this._handle, value)
+  }
+
   getBuffer(frame) {
     binding.getHWFramesContextBuffer(this._handle, frame._handle)
   }
 
+  getConstraints() {
+    const handle = binding.getHWFramesContextConstraints(this._handle)
+    return new HWFramesConstraints(handle)
+  }
+
   destroy() {
     binding.destroyHWFramesContext(this._handle)
     this._handle = null

test.js

@@ -14,6 +14,7 @@ require('./test/filter-inout')
 require('./test/frame')
 require('./test/hw-device-context')
 require('./test/hw-frames-context')
+require('./test/hw-frames-constraints')
 require('./test/image')
 require('./test/input-format')
 require('./test/packet')

test/hw-frames-constraints.js

@@ -0,0 +1,69 @@
+const test = require('brittle')
+const ffmpeg = require('..')
+const os = require('bare-os')
+
+const darwinFilter = os.platform() !== 'darwin'
+
+let hwDevice
+let hwFrames
+let constraints
+
+test.hook('setup', { skip: darwinFilter }, () => {
+  hwDevice = new ffmpeg.HWDeviceContext(ffmpeg.constants.hwDeviceTypes.VIDEOTOOLBOX)
+  hwFrames = new ffmpeg.HWFramesContext(
+    hwDevice,
+    ffmpeg.constants.pixelFormats.VIDEOTOOLBOX,
+    ffmpeg.constants.pixelFormats.NV12,
+    640,
+    480
+  )
+  constraints = hwFrames.getConstraints()
+})
+
+test(
+  'HWFramesConstraints should expose validSwFormats getter (darwin)',
+  { skip: darwinFilter },
+  (t) => {
+    t.ok(Array.isArray(constraints.validSwFormats))
+    t.ok(constraints.validSwFormats.length > 0)
+  }
+)
+
+test(
+  'HWFramesConstraints should expose validHwFormats getter (darwin)',
+  { skip: darwinFilter },
+  (t) => {
+    t.ok(Array.isArray(constraints.validHwFormats))
+    t.ok(constraints.validHwFormats.length > 0)
+  }
+)
+
+test('HWFramesConstraints should expose minWidth getter (darwin)', { skip: darwinFilter }, (t) => {
+  t.is(typeof constraints.minWidth, 'number')
+  t.ok(constraints.minWidth >= 0)
+})
+
+test('HWFramesConstraints should expose maxWidth getter (darwin)', { skip: darwinFilter }, (t) => {
+  t.is(typeof constraints.maxWidth, 'number')
+  t.ok(constraints.maxWidth >= 0)
+})
+
+test('HWFramesConstraints should expose minHeight getter (darwin)', { skip: darwinFilter }, (t) => {
+  t.is(typeof constraints.minHeight, 'number')
+  t.ok(constraints.minHeight >= 0)
+})
+
+test('HWFramesConstraints should expose maxHeight getter (darwin)', { skip: darwinFilter }, (t) => {
+  t.is(typeof constraints.maxHeight, 'number')
+  t.ok(constraints.maxHeight >= 0)
+})
+
+test('HWFramesConstraints should have destroy method (darwin)', { skip: darwinFilter }, (t) => {
+  t.ok(typeof constraints.destroy === 'function')
+})
+
+test.hook('teardown', { skip: darwinFilter }, () => {
+  constraints.destroy()
+  hwFrames.destroy()
+  hwDevice.destroy()
+})