davinci-resolve-mcp 2.57.4 → 2.58.0

package/resolve-advanced/vendor/drx-codec/__tests__/power-window-roundtrip.test.js

@@ -0,0 +1,230 @@
+/**
+ * P1.4 — extractPowerWindow tests.
+ *
+ * 2026-07-01: updated to the TRUE live-calibrated transform scales (multi-point
+ * fit 2026-06-22; see test/power-window-transform-calibration.test.mjs):
+ *   rotate = −UI°/180 · size = 1+(UI−50)×0.08 · aspect = (50−UI)/50 ·
+ *   pan/tilt = (UI−50)/50 × 4096 · soft = UI × 16 (gradient soft = UI × 100).
+ * The generator now writes these scales (registry window ranges were widened to
+ * the real DRX spans, removing the old [-1,1] clamp), so generate→parse→extract
+ * round-trips UI-exact AND matches what live Resolve stores.
+ *
+ * Synthesized-input tests exercise edge cases (Circle/Linear collision,
+ * SOFT_REF vs SOFT_1 reconciliation); real round-trips live at the bottom.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const drxParams = require('../../drx-parameters');
+const { extractPowerWindow, _internals } = require('../extract-power-window');
+const { generateDRX } = require('../drx-generator');
+const { parseDRXContent } = require('../drx-parser');
+
+const { POWER_WINDOWS, GRADIENT_WINDOW } = drxParams;
+const PW = POWER_WINDOWS;
+const GW = GRADIENT_WINDOW;
+
+// Mirrors buildWindowParams' TRUE scales. Builds the flattened param list
+// (ct4 transform + ct3 mask + ct65554 gradient) the extractor sees.
+function synthesize(w) {
+  const params = [];
+  const add = (id, value) => params.push({ id, value, name: 'pw' });
+  const isGradient = w.type === 5;
+  if (isGradient) {
+    add(GW.TYPE, { F2: 2 });
+    if (w.rotate !== undefined && w.rotate !== 0) add(GW.ROTATION, -w.rotate / 180);
+    if (w.pan !== undefined && w.pan !== 50) add(GW.HANDLE_1_POS, ((w.pan - 50) / 50) * 4096);
+    if (w.tilt !== undefined && w.tilt !== 50) add(GW.HANDLE_2_POS, ((w.tilt - 50) / 50) * 4096);
+    if (w.soft1 !== undefined && w.soft1 !== 0) add(GW.SOFTNESS, w.soft1 * 100);
+    return params;
+  }
+  if (w.type !== undefined) add(PW.WINDOW_TYPE, { F2: 2 }); // constant varint flag
+  if (w.rotate !== undefined && w.rotate !== 0) add(PW.ROTATE, -w.rotate / 180);
+  if (w.size !== undefined && w.size !== 50) add(PW.SIZE, 1 + (w.size - 50) * 0.08);
+  if (w.aspect !== undefined && w.aspect !== 50) add(PW.ASPECT, (50 - w.aspect) / 50);
+  if (w.pan !== undefined && w.pan !== 50) add(PW.PAN, ((w.pan - 50) / 50) * 4096);
+  if (w.tilt !== undefined && w.tilt !== 50) add(PW.TILT, ((w.tilt - 50) / 50) * 4096);
+  if (w.type === 2) {
+    if (w.soft1 !== undefined && w.soft1 !== 0) add(PW.SOFT_1, w.soft1 * 16);
+    if (w.soft2 !== undefined && w.soft2 !== 0) add(PW.SOFT_2, w.soft2 * 16);
+    if (w.soft3 !== undefined && w.soft3 !== 0) add(PW.SOFT_3, w.soft3 * 16);
+    if (w.soft4 !== undefined && w.soft4 !== 0) add(PW.SOFT_4, w.soft4 * 16);
+  } else if (w.soft1 !== undefined && w.soft1 !== 0) {
+    add(PW.SOFT_REF, w.soft1 * 16);
+  }
+  return params;
+}
+
+const TOL = 1e-3;
+function close(a, b) {
+  return Math.abs(a - b) < TOL;
+}
+
+test('extractPowerWindow: circle window — type round-trips', () => {
+  const out = extractPowerWindow(synthesize({ type: 1 }));
+  assert.ok(out);
+  assert.equal(out.type, 1, 'wire flag 2 with no linear mask → Circle');
+});
+
+test('extractPowerWindow: linear window — disambiguated by linear-only softness params', () => {
+  // The wire type flag is a constant 2 for BOTH circle and linear windows.
+  // Without sibling params, the decoder defaults to Circle. With SOFT_2-4 (only
+  // emitted by linear masks), Linear is recognized.
+  const minimal = extractPowerWindow(synthesize({ type: 2 }));
+  assert.equal(minimal.type, 1, 'pure flag alone is ambiguous; defaults to Circle');
+
+  const withSoftness = extractPowerWindow(synthesize({ type: 2, soft2: 8 }));
+  assert.equal(withSoftness.type, 2, 'SOFT_2 disambiguates → Linear');
+});
+
+test('extractPowerWindow: gradient window — type 5 via 0x08F0xxxx params', () => {
+  const out = extractPowerWindow(synthesize({ type: 5, soft1: 10 }));
+  assert.equal(out.type, 5);
+  // Gradient softness uses ×100 scale, not ×16.
+  assert.ok(close(out.soft1, 10), `expected soft1=10, got ${out.soft1}`);
+});
+
+test('extractPowerWindow: SIZE round-trips through 1+(UI−50)×0.08 encoding', () => {
+  const out = extractPowerWindow(synthesize({ type: 1, size: 75 }));
+  assert.ok(close(out.size, 75), `expected size=75, got ${out.size}`);
+});
+
+test('extractPowerWindow: ASPECT round-trips through (50−UI)/50 encoding', () => {
+  const out = extractPowerWindow(synthesize({ type: 1, aspect: 75 }));
+  assert.ok(close(out.aspect, 75), `expected aspect=75, got ${out.aspect}`);
+});
+
+test('extractPowerWindow: PAN/TILT round-trip through ±4096 pixel scaling', () => {
+  const out = extractPowerWindow(synthesize({ type: 1, pan: 60, tilt: 40 }));
+  assert.ok(close(out.pan, 60), `expected pan=60, got ${out.pan}`);
+  assert.ok(close(out.tilt, 40), `expected tilt=40, got ${out.tilt}`);
+});
+
+test('extractPowerWindow: ROTATE round-trips through −UI/180 encoding', () => {
+  const out = extractPowerWindow(synthesize({ type: 1, rotate: 45 }));
+  assert.ok(close(out.rotate, 45));
+});
+
+test('extractPowerWindow: linear with all 4 softness values', () => {
+  const input = { type: 2, soft1: 8, soft2: 12, soft3: 6, soft4: 4 };
+  const out = extractPowerWindow(synthesize(input));
+  assert.ok(close(out.soft1, 8), `soft1: got ${out.soft1}`);
+  assert.ok(close(out.soft2, 12), `soft2: got ${out.soft2}`);
+  assert.ok(close(out.soft3, 6), `soft3: got ${out.soft3}`);
+  assert.ok(close(out.soft4, 4), `soft4: got ${out.soft4}`);
+});
+
+test('extractPowerWindow: SOFT_REF and SOFT_1 reconcile — prefer SOFT_REF', () => {
+  const params = [
+    { id: PW.WINDOW_TYPE, value: { F2: 2 }, name: 'type' },
+    { id: PW.SOFT_REF, value: 16 * 10, name: 'softRef' },  // UI 10
+    { id: PW.SOFT_1, value: 16 * 99, name: 'soft1' },      // wrong value to detect override
+  ];
+  const out = extractPowerWindow(params);
+  assert.ok(close(out.soft1, 10), `SOFT_REF should win: got ${out.soft1}`);
+});
+
+test('extractPowerWindow: SOFT_1 alone (no SOFT_REF) surfaces', () => {
+  const params = [
+    { id: PW.WINDOW_TYPE, value: { F2: 2 }, name: 'type' },
+    { id: PW.SOFT_1, value: 16 * 7, name: 'soft1' },
+  ];
+  const out = extractPowerWindow(params);
+  assert.ok(close(out.soft1, 7));
+});
+
+test('extractPowerWindow: full linear spec round-trips', () => {
+  const input = {
+    type: 2,
+    rotate: 15,
+    size: 60,
+    aspect: 80,
+    pan: 55,
+    tilt: 45,
+    soft1: 10,
+    soft2: 5,
+    soft3: 3,
+    soft4: 2,
+  };
+  const out = extractPowerWindow(synthesize(input));
+  for (const [k, expected] of Object.entries(input)) {
+    assert.ok(close(out[k], expected), `${k}: got ${out[k]} expected ${expected}`);
+  }
+});
+
+test('extractPowerWindow: returns null on empty/non-window params', () => {
+  assert.equal(extractPowerWindow([
+    { id: 100663320, value: 0.5, name: 'lift.r' },
+  ]), null);
+});
+
+test('extractPowerWindow: handles malformed input', () => {
+  assert.equal(extractPowerWindow(null), null);
+  assert.equal(extractPowerWindow(undefined), null);
+  assert.equal(extractPowerWindow([]), null);
+});
+
+test('extractPowerWindow: handles BigInt varint type', () => {
+  const out = extractPowerWindow([
+    { id: PW.WINDOW_TYPE, value: 2n, name: 'type' },
+  ]);
+  assert.equal(out.type, 1, 'BigInt 2 → UI 1');
+});
+
+test('internals.drxToUiType: wire 2 → UI 1 (no linear softness) or UI 2 (with)', () => {
+  assert.equal(_internals.drxToUiType(2), 1, 'default → Circle');
+  assert.equal(_internals.drxToUiType(2, true), 2, 'with linear softness → Linear');
+  assert.equal(_internals.drxToUiType(3), 3);
+  assert.equal(_internals.drxToUiType(5), 5);
+  assert.equal(_internals.drxToUiType(2n), 1);
+});
+
+test('internals.drxToSize: round-trips around UI 50 (neutral stored 1.0)', () => {
+  assert.equal(_internals.drxToSize(1.0), 50);
+  assert.ok(close(_internals.drxToSize(3.0), 75));
+  assert.ok(close(_internals.drxToSize(-1.0), 25));
+});
+
+// ─── Real round-trip via generateDRX ─────────────────────────────────────
+
+async function roundTrip(window) {
+  const xml = await generateDRX({ window }, { label: 'win-rt' });
+  const parsed = await parseDRXContent(xml);
+  for (const node of parsed.nodes) {
+    // Flatten across corrector blocks: ct4 transform + ct3 mask + ct65554 gradient.
+    const params = (node.correctors || []).flatMap((c) => c.parameters || []);
+    const out = extractPowerWindow(params);
+    if (out) return out;
+  }
+  throw new Error('roundTrip: no window params found');
+}
+
+test('round-trip: circle window — full transform survives generate→parse→extract', async () => {
+  // Same UI values as the live power-window-transform fixture (Size 75 / Aspect 30 /
+  // Pan 35 / Tilt 88 / Rotate 49): the generator now stores the live-calibrated values.
+  const input = { type: 1, rotate: 49, size: 75, aspect: 30, pan: 35, tilt: 88, soft1: 10 };
+  const out = await roundTrip(input);
+  assert.equal(out.type, 1);
+  for (const k of ['rotate', 'size', 'aspect', 'pan', 'tilt', 'soft1']) {
+    assert.ok(close(out[k], input[k]), `${k}: got ${out[k]} expected ${input[k]}`);
+  }
+});
+
+test('round-trip: linear window — softness mask rides ct3', async () => {
+  const input = { type: 2, soft1: 4.5, soft2: 6.25, soft3: 8.75, soft4: 11 };
+  const out = await roundTrip(input);
+  assert.equal(out.type, 2);
+  for (const k of ['soft1', 'soft2', 'soft3', 'soft4']) {
+    assert.ok(close(out[k], input[k]), `${k}: got ${out[k]} expected ${input[k]}`);
+  }
+});
+
+test('round-trip: gradient window — ct65554 params', async () => {
+  const input = { type: 5, pan: 81, tilt: 82, rotate: 83, soft1: 85, opacity: 84 };
+  const out = await roundTrip(input);
+  assert.equal(out.type, 5);
+  for (const k of ['pan', 'tilt', 'rotate', 'soft1', 'opacity']) {
+    assert.ok(close(out[k], input[k]), `${k}: got ${out[k]} expected ${input[k]}`);
+  }
+});

package/resolve-advanced/vendor/drx-codec/__tests__/qualifier-roundtrip.test.js

@@ -0,0 +1,226 @@
+/**
+ * P1.3 — extractQualifier tests.
+ *
+ * Two test strategies coexist:
+ *
+ * 1. Synthesized inputs (tests 1-14 below): construct parameter lists
+ *    matching what buildQualifierParams WOULD emit and run
+ *    extractQualifier on them. Exercises edge cases the generator
+ *    doesn't expose (BigInt values, duplicate hue params, etc).
+ *
+ * 2. Real round-trip (tests at the bottom, "generate→parse→extract"):
+ *    SESSION 25 wired buildQualifierParams into createNode, so
+ *    generateDRX({qualifier:...}) now actually emits a Type 2
+ *    corrector. These tests round-trip through real generator + parser.
+ *
+ * Both strategies kept because synthesized is faster + covers BigInt
+ * paths the generator doesn't currently produce; round-trip is the
+ * ground-truth wire-format proof.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const drxParams = require('../../drx-parameters');
+const { extractQualifier, _internals } = require('../extract-qualifier');
+const { generateDRX } = require('../drx-generator');
+const { parseDRXContent } = require('../drx-parser');
+
+const { HSL_QUALIFIER } = drxParams;
+
+// Build the parameter list that buildQualifierParams WOULD emit for a
+// given UI input. Mirrors lines 2367-2395 of drx-generator.js exactly.
+function synthesizeQualifierParams(q) {
+  const params = [];
+  const add = (id, ui) => {
+    if (ui !== undefined) params.push({ id, value: ui / 100, name: 'q' });
+  };
+  add(HSL_QUALIFIER.HUE_CENTER, q.hueCenter);
+  add(HSL_QUALIFIER.HUE_WIDTH, q.hueWidth);
+  add(
+    HSL_QUALIFIER.HUE_SYM,
+    q.hueSymmetry !== undefined ? q.hueSymmetry : (q.hueCenter !== undefined ? 50 : undefined),
+  );
+  add(HSL_QUALIFIER.HUE_SOFT, q.hueSoft);
+  add(HSL_QUALIFIER.SAT_HIGH, q.satHigh);
+  add(HSL_QUALIFIER.SAT_LOW, q.satLow);
+  add(HSL_QUALIFIER.SAT_HIGH_SOFT, q.satHighSoft);
+  add(HSL_QUALIFIER.SAT_LOW_SOFT, q.satLowSoft);
+  add(HSL_QUALIFIER.LUM_HIGH, q.lumHigh);
+  add(HSL_QUALIFIER.LUM_LOW, q.lumLow);
+  add(HSL_QUALIFIER.LUM_HIGH_SOFT, q.lumHighSoft);
+  add(HSL_QUALIFIER.LUM_LOW_SOFT, q.lumLowSoft);
+  if (q.hueWidth !== undefined) add(HSL_QUALIFIER.HUE_WIDTH_DUP, q.hueWidth);
+  if (q.hueSoft !== undefined) add(HSL_QUALIFIER.HUE_SOFT_DUP, q.hueSoft);
+  if (params.length > 0) {
+    params.push({ id: HSL_QUALIFIER.MODE_FLAG, value: 4, name: 'modeFlag' });
+    params.push({ id: HSL_QUALIFIER.QUALIFIER_MODE, value: 0, name: 'qualifierMode' });
+  }
+  return params;
+}
+
+const TOL = 1e-4;
+
+function close(a, b) {
+  return Math.abs(a - b) < TOL;
+}
+
+test('extractQualifier: hue-only selection (8-config 1/8)', () => {
+  const input = { hueCenter: 30, hueWidth: 20 };
+  const params = synthesizeQualifierParams(input);
+  const out = extractQualifier(params);
+  assert.ok(out, 'should return non-null');
+  assert.ok(close(out.hueCenter, 30));
+  assert.ok(close(out.hueWidth, 20));
+  // Default hueSymmetry inserted by generator
+  assert.ok(close(out.hueSymmetry, 50));
+  // Mode flags surface
+  assert.equal(out.modeFlag, 4);
+  assert.equal(out.mode, 0);
+});
+
+test('extractQualifier: saturation-only selection (2/8)', () => {
+  const input = { satLow: 25, satHigh: 75 };
+  const out = extractQualifier(synthesizeQualifierParams(input));
+  assert.ok(close(out.satLow, 25));
+  assert.ok(close(out.satHigh, 75));
+  assert.equal(out.hueCenter, undefined);
+});
+
+test('extractQualifier: luminance-only selection (3/8)', () => {
+  const input = { lumLow: 30, lumHigh: 80 };
+  const out = extractQualifier(synthesizeQualifierParams(input));
+  assert.ok(close(out.lumLow, 30));
+  assert.ok(close(out.lumHigh, 80));
+});
+
+test('extractQualifier: all three axes bounded (4/8)', () => {
+  const input = {
+    hueCenter: 45, hueWidth: 30,
+    satLow: 20, satHigh: 80,
+    lumLow: 15, lumHigh: 85,
+  };
+  const out = extractQualifier(synthesizeQualifierParams(input));
+  for (const [k, expected] of Object.entries(input)) {
+    assert.ok(close(out[k], expected), `${k}: got ${out[k]}, expected ${expected}`);
+  }
+});
+
+test('extractQualifier: with softness on all axes (5/8)', () => {
+  const input = {
+    hueCenter: 30, hueWidth: 20, hueSoft: 10,
+    satLow: 25, satHigh: 75, satLowSoft: 5, satHighSoft: 5,
+    lumLow: 30, lumHigh: 70, lumLowSoft: 8, lumHighSoft: 8,
+  };
+  const out = extractQualifier(synthesizeQualifierParams(input));
+  for (const [k, expected] of Object.entries(input)) {
+    assert.ok(close(out[k], expected), `${k}: got ${out[k]}, expected ${expected}`);
+  }
+});
+
+test('extractQualifier: extreme hue near 0 (6/8)', () => {
+  const input = { hueCenter: 0, hueWidth: 10 };
+  const out = extractQualifier(synthesizeQualifierParams(input));
+  assert.ok(close(out.hueCenter, 0));
+  assert.ok(close(out.hueWidth, 10));
+});
+
+test('extractQualifier: extreme hue near 100 (7/8)', () => {
+  const input = { hueCenter: 100, hueWidth: 10 };
+  const out = extractQualifier(synthesizeQualifierParams(input));
+  assert.ok(close(out.hueCenter, 100));
+});
+
+test('extractQualifier: full-range cover-everything (8/8)', () => {
+  const input = {
+    hueCenter: 50, hueWidth: 100, hueSoft: 50, hueSymmetry: 50,
+    satLow: 0, satHigh: 100, satLowSoft: 0, satHighSoft: 0,
+    lumLow: 0, lumHigh: 100, lumLowSoft: 0, lumHighSoft: 0,
+  };
+  const out = extractQualifier(synthesizeQualifierParams(input));
+  for (const [k, expected] of Object.entries(input)) {
+    assert.ok(close(out[k], expected), `${k}: got ${out[k]}, expected ${expected}`);
+  }
+});
+
+test('extractQualifier: returns null when no qualifier params present', () => {
+  assert.equal(extractQualifier([
+    { id: 100663320, value: 0.5, name: 'lift.r' },
+  ]), null);
+});
+
+test('extractQualifier: handles malformed input', () => {
+  assert.equal(extractQualifier(null), null);
+  assert.equal(extractQualifier(undefined), null);
+  assert.equal(extractQualifier([]), null);
+});
+
+test('extractQualifier: handles BigInt varint values', () => {
+  // Parser surfaces varints as BigInt in some code paths.
+  const params = [
+    { id: HSL_QUALIFIER.MODE_FLAG, value: 4n, name: 'modeFlag' },
+    { id: HSL_QUALIFIER.QUALIFIER_MODE, value: 0n, name: 'qualifierMode' },
+  ];
+  const out = extractQualifier(params);
+  assert.equal(out.modeFlag, 4);
+  assert.equal(out.mode, 0);
+});
+
+test('extractQualifier: duplicate hue params do not override canonical', () => {
+  // HUE_WIDTH_DUP appears AFTER HUE_WIDTH in the generator's emission;
+  // canonical should win. Test with a deliberately wrong dup value.
+  const params = [
+    { id: HSL_QUALIFIER.HUE_WIDTH, value: 0.25, name: 'hueWidth' },          // 25
+    { id: HSL_QUALIFIER.HUE_WIDTH_DUP, value: 0.99, name: 'hueWidthDup' },   // wrong
+  ];
+  const out = extractQualifier(params);
+  assert.ok(close(out.hueWidth, 25), `hueWidth canonical should win: got ${out.hueWidth}`);
+});
+
+test('internals.drxToUi: BigInt input handled', () => {
+  assert.equal(_internals.drxToUi(0.5), 50);
+  assert.equal(_internals.drxToUi(0.25), 25);
+  // BigInt should be coerced
+  assert.equal(_internals.drxToUi(BigInt(0)), 0);
+});
+
+test('internals.varintToNumber: handles BigInt and number', () => {
+  assert.equal(_internals.varintToNumber(4n), 4);
+  assert.equal(_internals.varintToNumber(4), 4);
+  assert.equal(_internals.varintToNumber('foo'), 0);
+});
+
+// ─── Real round-trip via generateDRX (Session 25 wiring) ─────────────────
+
+async function roundTrip(qualifier) {
+  const xml = await generateDRX({ qualifier }, { label: 'qual-rt' });
+  const parsed = await parseDRXContent(xml);
+  for (const node of parsed.nodes) {
+    for (const corrector of node.correctors) {
+      if (corrector.type !== 2) continue;
+      const out = extractQualifier(corrector.parameters);
+      if (out) return out;
+    }
+  }
+  throw new Error('roundTrip: no Type 2 qualifier corrector found');
+}
+
+test('round-trip: hue + sat + lum bounded survives generate→parse→extract', async () => {
+  const input = { hueCenter: 30, hueWidth: 25, satLow: 20, satHigh: 80, lumLow: 10, lumHigh: 90 };
+  const out = await roundTrip(input);
+  for (const [k, v] of Object.entries(input)) {
+    assert.ok(close(out[k], v), `${k}: got ${out[k]}, expected ${v}`);
+  }
+});
+
+test('round-trip: full spec with softness on all axes', async () => {
+  const input = {
+    hueCenter: 45, hueWidth: 30, hueSoft: 15,
+    satLow: 25, satHigh: 75, satLowSoft: 8, satHighSoft: 8,
+    lumLow: 20, lumHigh: 80, lumLowSoft: 10, lumHighSoft: 10,
+  };
+  const out = await roundTrip(input);
+  for (const [k, v] of Object.entries(input)) {
+    assert.ok(close(out[k], v), `${k}: got ${out[k]}, expected ${v}`);
+  }
+});