davinci-resolve-mcp 2.57.4 → 2.58.0

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

@@ -0,0 +1,167 @@
+/**
+ * P1.5 — extractMatteFinesse tests.
+ *
+ * No generator emits MATTE_FINESSE params today, so synthesize the
+ * parameter list the registry says Resolve emits. All scale: DRX = UI / 100
+ * (TRAINED 2026-03-16, corrected 2026-03-22).
+ *
+ * External matte refs (file path / media pool ID / channel / invert /
+ * expand) are a separate encoding not yet reverse-engineered.
+ * Queued as deferred Resolve-fixture work — see
+ * knowledge/resolve-verifications.md.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const drxParams = require('../../drx-parameters');
+const { extractMatteFinesse, _internals } = require('../extract-matte-finesse');
+
+const { MATTE_FINESSE } = drxParams;
+const MF = MATTE_FINESSE;
+
+function synthesize(spec) {
+  const params = [];
+  const add = (id, ui) => params.push({ id, value: ui / 100, name: 'mf' });
+  if (spec.denoise !== undefined) add(MF.DENOISE, spec.denoise);
+  if (spec.blackClip !== undefined) add(MF.BLACK_CLIP, spec.blackClip);
+  if (spec.whiteClip !== undefined) add(MF.WHITE_CLIP, spec.whiteClip);
+  if (spec.inOutRatio !== undefined) add(MF.IN_OUT_RATIO, spec.inOutRatio);
+  if (spec.cleanBlack !== undefined) add(MF.CLEAN_BLACK, spec.cleanBlack);
+  if (spec.cleanWhite !== undefined) add(MF.CLEAN_WHITE, spec.cleanWhite);
+  if (spec.morphRadius !== undefined) add(MF.MORPH_RADIUS, spec.morphRadius);
+  if (spec.preFilter !== undefined) add(MF.PRE_FILTER, spec.preFilter);
+  if (spec.postFilter !== undefined) add(MF.POST_FILTER, spec.postFilter);
+  if (spec.shadow !== undefined) add(MF.SHADOW, spec.shadow);
+  if (spec.midtone !== undefined) add(MF.MIDTONE, spec.midtone);
+  if (spec.highlight !== undefined) add(MF.HIGHLIGHT, spec.highlight);
+  return params;
+}
+
+const TOL = 1e-3;
+function close(a, b) {
+  return Math.abs(a - b) < TOL;
+}
+
+test('extractMatteFinesse: denoise-only (training canary: 15 → 0.15)', () => {
+  const out = extractMatteFinesse(synthesize({ denoise: 15 }));
+  assert.ok(out);
+  assert.ok(close(out.denoise, 15));
+});
+
+test('extractMatteFinesse: cleanBlack-only (training canary: 30 → 0.30)', () => {
+  const out = extractMatteFinesse(synthesize({ cleanBlack: 30 }));
+  assert.ok(close(out.cleanBlack, 30));
+});
+
+test('extractMatteFinesse: black/white clip pair', () => {
+  const out = extractMatteFinesse(synthesize({ blackClip: 10, whiteClip: 90 }));
+  assert.ok(close(out.blackClip, 10));
+  assert.ok(close(out.whiteClip, 90));
+});
+
+test('extractMatteFinesse: zone-based fine tuning (shadow/mid/highlight)', () => {
+  const out = extractMatteFinesse(synthesize({
+    shadow: 20, midtone: 50, highlight: 80,
+  }));
+  assert.ok(close(out.shadow, 20));
+  assert.ok(close(out.midtone, 50));
+  assert.ok(close(out.highlight, 80));
+});
+
+test('extractMatteFinesse: filter chain (pre + morph + post)', () => {
+  const out = extractMatteFinesse(synthesize({
+    preFilter: 5, morphRadius: 3, postFilter: 7,
+  }));
+  assert.ok(close(out.preFilter, 5));
+  assert.ok(close(out.morphRadius, 3));
+  assert.ok(close(out.postFilter, 7));
+});
+
+test('extractMatteFinesse: full spec round-trips all 12 params', () => {
+  const input = {
+    denoise: 12, blackClip: 8, whiteClip: 92, inOutRatio: 50,
+    cleanBlack: 25, cleanWhite: 35, morphRadius: 4,
+    preFilter: 6, postFilter: 10,
+    shadow: 22, midtone: 48, highlight: 78,
+  };
+  const out = extractMatteFinesse(synthesize(input));
+  for (const [k, expected] of Object.entries(input)) {
+    assert.ok(close(out[k], expected), `${k}: got ${out[k]}, expected ${expected}`);
+  }
+});
+
+test('extractMatteFinesse: returns null when no matte params present', () => {
+  assert.equal(extractMatteFinesse([
+    { id: 100663320, value: 0.5, name: 'lift.r' },
+  ]), null);
+});
+
+test('extractMatteFinesse: handles malformed input', () => {
+  assert.equal(extractMatteFinesse(null), null);
+  assert.equal(extractMatteFinesse(undefined), null);
+  assert.equal(extractMatteFinesse([]), null);
+});
+
+test('extractMatteFinesse: handles BigInt values gracefully', () => {
+  const out = extractMatteFinesse([
+    // BigInt 0 maps to 0 — graceful, not crash.
+    { id: MF.DENOISE, value: 0n, name: 'denoise' },
+  ]);
+  assert.equal(out.denoise, 0);
+});
+
+test('extractMatteFinesse: filters non-matte param IDs', () => {
+  // 100663320 is LIFT.R, not in MATTE_FINESSE — must be ignored
+  const out = extractMatteFinesse([
+    { id: MF.DENOISE, value: 0.20, name: 'denoise' },
+    { id: 100663320, value: 0.5, name: 'lift.r' },
+  ]);
+  assert.equal(Object.keys(out).length, 1);
+  assert.ok(close(out.denoise, 20));
+});
+
+test('internals.drxToUi: round-trips and clamps non-finite', () => {
+  assert.equal(_internals.drxToUi(0.15), 15);
+  assert.equal(_internals.drxToUi(0.3), 30);
+  assert.equal(_internals.drxToUi(NaN), 0);
+  assert.equal(_internals.drxToUi(Infinity), 0);
+});
+
+// ─── Real round-trip via generateDRX (Session 25 wiring) ─────────────────
+
+const { generateDRX } = require('../drx-generator');
+const { parseDRXContent } = require('../drx-parser');
+
+async function roundTrip(matteFinesse) {
+  const xml = await generateDRX({ matteFinesse }, { label: 'matte-rt' });
+  const parsed = await parseDRXContent(xml);
+  for (const node of parsed.nodes) {
+    for (const corrector of node.correctors) {
+      if (corrector.type !== 9) continue;
+      const out = extractMatteFinesse(corrector.parameters);
+      if (out) return out;
+    }
+  }
+  throw new Error('roundTrip: no Type 9 matte corrector found');
+}
+
+test('round-trip: denoise + cleanBlack via real generator', async () => {
+  const input = { denoise: 15, cleanBlack: 30 };
+  const out = await roundTrip(input);
+  assert.ok(close(out.denoise, 15), `denoise: ${out.denoise}`);
+  assert.ok(close(out.cleanBlack, 30), `cleanBlack: ${out.cleanBlack}`);
+});
+
+test('round-trip: all 12 matte params via real generator', async () => {
+  const input = {
+    denoise: 12, blackClip: 8, whiteClip: 92, inOutRatio: 50,
+    cleanBlack: 25, cleanWhite: 35, morphRadius: 4,
+    preFilter: 6, postFilter: 10,
+    shadow: 22, midtone: 48, highlight: 78,
+  };
+  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}`);
+  }
+});

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

@@ -0,0 +1,215 @@
+/**
+ * P1.6 — extractOFXParams tests.
+ *
+ * Round-trips the F7.F10 OFX tool-list encoding from the generator's
+ * buildOFXToolEntry through extractOFXParams / extractOFXTools.
+ *
+ * Strategy: drive the encoder helpers directly (protoBytes / protoVarint
+ * / protoFloat64), assemble the wire bytes the way buildOFXToolEntry
+ * does, then verify the decoder recovers pluginId, instanceId, enabled,
+ * and each named param.
+ *
+ * Film Grain coverage at minimum per ledger; other plugins land when
+ * P2.1 expands the tool registry.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { extractOFXParams, extractOFXTools, _internals } = require('../extract-ofx-params');
+
+// ─── Mini protobuf encoder helpers (mirror drx-generator.js) ─────────────
+
+function encVarint(value) {
+  let n = BigInt(value);
+  const bytes = [];
+  while (n > 0x7fn) {
+    bytes.push(Number((n & 0x7fn) | 0x80n));
+    n >>= 7n;
+  }
+  bytes.push(Number(n & 0x7fn));
+  return Buffer.from(bytes);
+}
+
+function protoVarint(fieldNum, value) {
+  const tag = (fieldNum << 3) | 0;
+  return Buffer.concat([encVarint(tag), encVarint(value)]);
+}
+
+function protoFloat64(fieldNum, value) {
+  const tag = (fieldNum << 3) | 1;
+  const buf = Buffer.alloc(8);
+  buf.writeDoubleLE(value, 0);
+  return Buffer.concat([encVarint(tag), buf]);
+}
+
+function protoBytes(fieldNum, data) {
+  const tag = (fieldNum << 3) | 2;
+  return Buffer.concat([encVarint(tag), encVarint(data.length), data]);
+}
+
+// Encode one OFX tool's F7.F10 entry (the F1-wrapped form), matching
+// the generator's buildOFXToolEntry F2.F21 container.
+function encodeOFXEntry(pluginId, params, opts = {}) {
+  const instanceId = opts.instanceId || 'OfxImageEffectContext_test_abc';
+  const enabled = opts.enabled === undefined ? 1 : (opts.enabled ? 1 : 0);
+
+  const paramEntries = [];
+  for (const [name, value] of Object.entries(params)) {
+    const nameBuf = Buffer.from(name, 'utf-8');
+    let valueBuf;
+    if (typeof value === 'string') {
+      valueBuf = protoBytes(5, Buffer.from(value, 'utf-8'));
+    } else {
+      valueBuf = protoFloat64(2, value);
+    }
+    paramEntries.push(protoBytes(5, Buffer.concat([
+      protoBytes(1, nameBuf),
+      protoBytes(2, valueBuf),
+    ])));
+  }
+
+  const ofxContainer = protoBytes(21, Buffer.concat([
+    protoVarint(1, 0x4F4659),
+    protoBytes(2, Buffer.from(pluginId, 'utf-8')),
+    protoBytes(3, Buffer.from(instanceId, 'utf-8')),
+    protoVarint(4, enabled),
+    ...paramEntries,
+  ]));
+
+  // Each F10 entry is wrapped in F1 (the F1=2 marker is a separate entry).
+  return protoBytes(1, Buffer.concat([
+    protoBytes(2, ofxContainer),
+  ]));
+}
+
+function encodeToolList(entries) {
+  return Buffer.concat(entries);
+}
+
+// Standard node marker — not an OFX tool, should be ignored by extractor.
+const NODE_MARKER = protoBytes(1, Buffer.concat([
+  protoVarint(1, 0xC0000001),
+  protoBytes(2, protoVarint(2, 2)),
+]));
+
+test('extractOFXParams: Film Grain plugin round-trips', () => {
+  const input = {
+    pluginId: 'com.blackmagicdesign.resolvefx.filmgrain',
+    params: {
+      inMean: 0.5,
+      inSize: 1.0,
+      inResponse: 'linear',
+    },
+  };
+  const toolList = encodeToolList([
+    NODE_MARKER,
+    encodeOFXEntry(input.pluginId, input.params),
+  ]);
+  const out = extractOFXParams(toolList);
+  assert.ok(out);
+  assert.equal(out.pluginId, input.pluginId);
+  assert.ok(out.enabled);
+  assert.equal(out.params.inMean, 0.5);
+  assert.equal(out.params.inSize, 1.0);
+  assert.equal(out.params.inResponse, 'linear');
+});
+
+test('extractOFXTools: returns all tools (node marker filtered out)', () => {
+  const list = encodeToolList([
+    NODE_MARKER,
+    encodeOFXEntry('com.blackmagicdesign.resolvefx.filmgrain', { inMean: 0.5 }),
+    encodeOFXEntry('com.blackmagicdesign.resolvefx.beauty', { intensity: 0.3 }),
+  ]);
+  const tools = extractOFXTools(list);
+  assert.equal(tools.length, 2);
+  assert.equal(tools[0].pluginId, 'com.blackmagicdesign.resolvefx.filmgrain');
+  assert.equal(tools[1].pluginId, 'com.blackmagicdesign.resolvefx.beauty');
+});
+
+test('extractOFXParams: enabled=false flag round-trips', () => {
+  const list = encodeToolList([
+    encodeOFXEntry('com.blackmagicdesign.resolvefx.filmgrain', { inMean: 0.5 }, { enabled: false }),
+  ]);
+  const out = extractOFXParams(list);
+  assert.equal(out.enabled, false);
+});
+
+test('extractOFXParams: instanceId round-trips', () => {
+  const customId = 'OfxImageEffectContext_2026_xyz';
+  const list = encodeToolList([
+    encodeOFXEntry('com.blackmagicdesign.resolvefx.filmgrain', {},
+      { instanceId: customId }),
+  ]);
+  const out = extractOFXParams(list);
+  assert.equal(out.instanceId, customId);
+});
+
+test('extractOFXParams: float64 + string params coexist', () => {
+  const params = {
+    inMean: 0.42,
+    inResponse: 'sRGB',
+    inSize: 1.5,
+    inLayer: 'green',
+  };
+  const list = encodeToolList([
+    encodeOFXEntry('com.blackmagicdesign.resolvefx.filmgrain', params),
+  ]);
+  const out = extractOFXParams(list);
+  for (const [k, v] of Object.entries(params)) {
+    assert.equal(out.params[k], v, `${k}: got ${out.params[k]}`);
+  }
+});
+
+test('extractOFXParams: returns null on empty tool list', () => {
+  assert.equal(extractOFXParams(Buffer.alloc(0)), null);
+});
+
+test('extractOFXParams: returns null on tool list with only node marker', () => {
+  const list = encodeToolList([NODE_MARKER]);
+  assert.equal(extractOFXParams(list), null);
+});
+
+test('extractOFXParams: rejects buffers without OFY marker', () => {
+  const noMarker = protoBytes(1, Buffer.concat([
+    protoBytes(2, protoBytes(21, Buffer.concat([
+      protoBytes(2, Buffer.from('com.fake', 'utf-8')),
+    ]))),
+  ]));
+  const list = encodeToolList([noMarker]);
+  assert.equal(extractOFXParams(list), null);
+});
+
+test('extractOFXParams: handles malformed input gracefully', () => {
+  assert.equal(extractOFXParams(null), null);
+  assert.equal(extractOFXParams(undefined), null);
+  assert.equal(extractOFXParams('not a buffer'), null);
+  assert.equal(extractOFXParams(42), null);
+});
+
+test('extractOFXTools: empty tool list returns []', () => {
+  assert.deepEqual(extractOFXTools(Buffer.alloc(0)), []);
+  assert.deepEqual(extractOFXTools(null), []);
+});
+
+test('internals.OFY_MARKER: matches the registry constant', () => {
+  assert.equal(_internals.OFY_MARKER, 0x4F4659);
+});
+
+test('internals.decodeParamEntry: float64 + string round-trip', () => {
+  const entry = Buffer.concat([
+    protoBytes(1, Buffer.from('inMean', 'utf-8')),
+    protoBytes(2, protoFloat64(2, 0.5)),
+  ]);
+  const { name, value } = _internals.decodeParamEntry(entry);
+  assert.equal(name, 'inMean');
+  assert.equal(value, 0.5);
+
+  const strEntry = Buffer.concat([
+    protoBytes(1, Buffer.from('inResponse', 'utf-8')),
+    protoBytes(2, protoBytes(5, Buffer.from('sRGB', 'utf-8'))),
+  ]);
+  const { name: n2, value: v2 } = _internals.decodeParamEntry(strEntry);
+  assert.equal(n2, 'inResponse');
+  assert.equal(v2, 'sRGB');
+});

package/resolve-advanced/vendor/drx-codec/__tests__/ofx-slugs-discovery.test.js

@@ -0,0 +1,149 @@
+/**
+ * P2.1 + P2.2 — OFX plugin slug discovery against captured fixtures.
+ *
+ * Each fixture is a Resolve-exported DRX gallery still with one
+ * ResolveFX plugin applied. The test parses the DRX body, locates
+ * the F7.F10 tool list, runs extractOFXTools, and asserts the
+ * pluginId (slug) matches what RESOLVEFX.SLUGS exposes.
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const zlib = require('node:zlib');
+
+const drxParams = require('../../drx-parameters');
+const { extractOFXTools } = require('../extract-ofx-params');
+
+const FIXTURES = path.join(__dirname, 'fixtures');
+
+// Tiny inline proto walker — locates F1.F7.F10 buffer in the body so
+// extractOFXTools has its expected input shape.
+function readVarint(buf, off) {
+  let v = 0n, shift = 0n, b;
+  do {
+    if (off >= buf.length) throw new Error('truncated varint');
+    b = buf[off++];
+    v |= BigInt(b & 0x7f) << shift;
+    shift += 7n;
+  } while (b & 0x80);
+  return [v, off];
+}
+
+function readFields(buf) {
+  const out = [];
+  let off = 0;
+  while (off < buf.length) {
+    let tag;
+    try { [tag, off] = readVarint(buf, off); }
+    catch (e) { break; }
+    const fieldNum = Number(tag >> 3n);
+    const wireType = Number(tag & 7n);
+    if (wireType === 0) {
+      const [v, o2] = readVarint(buf, off);
+      out.push({ fieldNum, wireType, value: v });
+      off = o2;
+    } else if (wireType === 2) {
+      const [len, o2] = readVarint(buf, off);
+      const L = Number(len);
+      out.push({ fieldNum, wireType, value: buf.slice(o2, o2 + L) });
+      off = o2 + L;
+    } else if (wireType === 1) {
+      out.push({ fieldNum, wireType, value: buf.slice(off, off + 8) });
+      off += 8;
+    } else if (wireType === 5) {
+      out.push({ fieldNum, wireType, value: buf.slice(off, off + 4) });
+      off += 4;
+    } else { break; }
+  }
+  return out;
+}
+
+function findF10Buffer(decompressedBody) {
+  const root = readFields(decompressedBody);
+  for (const rootField of root) {
+    if (rootField.fieldNum !== 1 || rootField.wireType !== 2) continue;
+    const nodeBlock = readFields(rootField.value);
+    for (const nodeField of nodeBlock) {
+      if (nodeField.fieldNum !== 7 || nodeField.wireType !== 2) continue;
+      const toolList = readFields(nodeField.value);
+      for (const tf of toolList) {
+        if (tf.fieldNum === 10 && tf.wireType === 2) return tf.value;
+      }
+    }
+  }
+  return null;
+}
+
+async function loadOfx(fixtureName) {
+  const xml = fs.readFileSync(path.join(FIXTURES, fixtureName), 'utf8');
+  const m = xml.match(/<Body>([0-9a-f]+)<\/Body>/);
+  if (!m) throw new Error('no Body in fixture');
+  const raw = Buffer.from(m[1], 'hex');
+  const zstdPayload = raw[0] === 0x81 ? raw.slice(1) : raw;
+  // Node 18+ has zstdDecompressSync via node:zlib.
+  const decompressed = typeof zlib.zstdDecompressSync === 'function'
+    ? zlib.zstdDecompressSync(zstdPayload)
+    : await zstdDecompressViaCodec(zstdPayload);
+  const f10 = findF10Buffer(decompressed);
+  if (!f10) throw new Error('no F7.F10 buffer found');
+  return extractOFXTools(f10);
+}
+
+async function zstdDecompressViaCodec(payload) {
+  const { ZstdCodec } = require('zstd-codec');
+  return new Promise((res) => {
+    ZstdCodec.run((zstd) => {
+      const simple = new zstd.Simple();
+      res(Buffer.from(simple.decompress(payload)));
+    });
+  });
+}
+
+// ─── Slug discovery tests ────────────────────────────────────────────────
+
+const SLUG_FIXTURES = [
+  { fixture: 'p2-1-filmgrain.drx',       expectedSlug: drxParams.RESOLVEFX.SLUGS.FILM_GRAIN },
+  { fixture: 'p2-1-face-refinement.drx', expectedSlug: drxParams.RESOLVEFX.SLUGS.FACE_REFINEMENT2 },
+  { fixture: 'p2-1-lens-flare.drx',      expectedSlug: drxParams.RESOLVEFX.SLUGS.LENS_FLARE_V2 },
+  { fixture: 'p2-1-glow.drx',            expectedSlug: drxParams.RESOLVEFX.SLUGS.GLOW },
+  { fixture: 'p2-3-beauty-25.drx',       expectedSlug: drxParams.RESOLVEFX.SLUGS.BEAUTY },
+  { fixture: 'p2-3-beauty-75.drx',       expectedSlug: drxParams.RESOLVEFX.SLUGS.BEAUTY },
+];
+
+for (const { fixture, expectedSlug } of SLUG_FIXTURES) {
+  test(`slug discovery: ${fixture} → ${expectedSlug}`, async () => {
+    const tools = await loadOfx(fixture);
+    assert.equal(tools.length, 1, 'one OFX tool per fixture');
+    assert.equal(tools[0].pluginId, expectedSlug);
+    assert.equal(tools[0].enabled, true);
+    assert.equal(tools[0].marker, 0x4F4659, 'OFY marker present');
+  });
+}
+
+// ─── Known-params smoke (P2.2 partial coverage) ─────────────────────────
+
+test('KNOWN_PARAMS: each slug entry maps to a parameter list', () => {
+  for (const slug of Object.values(drxParams.RESOLVEFX.SLUGS)) {
+    const params = drxParams.RESOLVEFX.KNOWN_PARAMS[slug];
+    assert.ok(Array.isArray(params), `slug "${slug}" has KNOWN_PARAMS`);
+    assert.ok(params.length >= 1, `slug "${slug}" has at least one param`);
+    assert.ok(params.includes('resolvefxVersion'),
+      `slug "${slug}" should include the resolvefxVersion canary param`);
+  }
+});
+
+// ─── Beauty round-trip canary (P2.3 — proves the encoding side) ─────────
+
+test('beauty round-trip: 25 and 75 produce same slug + same param set', async () => {
+  const tools25 = await loadOfx('p2-3-beauty-25.drx');
+  const tools75 = await loadOfx('p2-3-beauty-75.drx');
+  assert.equal(tools25[0].pluginId, tools75[0].pluginId);
+  assert.equal(tools25[0].marker, tools75[0].marker);
+  // The params keys should match exactly (only values should differ).
+  const keys25 = Object.keys(tools25[0].params).sort();
+  const keys75 = Object.keys(tools75[0].params).sort();
+  assert.deepEqual(keys25, keys75,
+    'same plugin with different param values yields same key set');
+});