[PATCH v4 0/3] MR635: Draft: Implement transform graph. Partically implement effect drawing.

[Ziqing Hui (＠zhui)]

This MR has 2 purposes:
1. Get first 3 patches upstreamed.
2. Have the whole patch set to be reviewed to make sure I'm on the correct direction.

It means I'm just going to upstream first 3 patches. The remaining 2 patches are not going to be upstreamed for now. They are for reviewing purpose, to see if I am implementing them in a good way.

So, Nikolay, here are 2 questions:
1. Do first 3 patches (a test patch and 2 patches that implement transform graph) are good to be upstreamed?
2. Am I in a good way for implementing effect drawing?

Some notes:
d2d_transform_node struct is not implemented like d2d_brush, because there are user defined draw transforms. Users can have a custom struct, and implement ID2D1DrawTransform interface for that struct. So that in transform graph, we should rely on interface, not concrete struct implementation.

--
  v4:  
https://gitlab.winehq.org/wine/wine/-/merge_requests/635

[PATCH v4 1/3] d2d1/tests: Add more tests for ID2D1TransformGraph.

[Ziqing Hui]

From: Ziqing Hui

Signed-off-by: Ziqing Hui 
---
 dlls/d2d1/tests/d2d1.c | 55 +++++++++++++++++++++++++++++++++++++++---
 1 file changed, 51 insertions(+), 4 deletions(-)

diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c
index 665c3200e21..caedfdd552e 100644
--- a/dlls/d2d1/tests/d2d1.c
+++ b/dlls/d2d1/tests/d2d1.c
@@ -12024,6 +12024,7 @@ static void test_registered_effects(BOOL d3d11)

static void test_transform_graph(BOOL d3d11)
 {
+    UINT i, effect_input_count, transform_input_count;
     ID2D1OffsetTransform *offset_transform = NULL;
     ID2D1BlendTransform *blend_transform = NULL;
     D2D1_BLEND_DESCRIPTION blend_desc = {0};
@@ -12033,7 +12034,6 @@ static void test_transform_graph(BOOL d3d11)
     ID2D1Factory1 *factory;
     POINT point = {0 ,0};
     ID2D1Effect *effect;
-    UINT i, count;
     HRESULT hr;

const D2D1_PROPERTY_BINDING binding[] =
@@ -12090,6 +12090,15 @@ static void test_transform_graph(BOOL d3d11)
     hr = ID2D1TransformGraph_RemoveNode(graph, (ID2D1TransformNode *)blend_transform);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);

+    /* Clear nodes */
+    hr = ID2D1TransformGraph_AddNode(graph, (ID2D1TransformNode *)offset_transform);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1TransformGraph_AddNode(graph, (ID2D1TransformNode *)offset_transform);
+    ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
+    ID2D1TransformGraph_Clear(graph);
+    hr = ID2D1TransformGraph_AddNode(graph, (ID2D1TransformNode *)offset_transform);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
     /* Connect nodes which are both un-added */
     ID2D1TransformGraph_Clear(graph);
     hr = ID2D1TransformGraph_ConnectNode(graph,
@@ -12112,13 +12121,13 @@ static void test_transform_graph(BOOL d3d11)
     ok(hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND), "Got unexpected hr %#lx.\n", hr);

/* Connect nodes */
+    transform_input_count = ID2D1BlendTransform_GetInputCount(blend_transform);
     ID2D1TransformGraph_Clear(graph);
     hr = ID2D1TransformGraph_AddNode(graph, (ID2D1TransformNode *)offset_transform);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     hr = ID2D1TransformGraph_AddNode(graph, (ID2D1TransformNode *)blend_transform);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
-    count = ID2D1BlendTransform_GetInputCount(blend_transform);
-    for (i = 0; i < count; ++i)
+    for (i = 0; i < transform_input_count; ++i)
     {
         hr = ID2D1TransformGraph_ConnectNode(graph,
                 (ID2D1TransformNode *)offset_transform, (ID2D1TransformNode *)blend_transform, i);
@@ -12127,7 +12136,45 @@ static void test_transform_graph(BOOL d3d11)

/* Connect node to out-of-bounds index */
     hr = ID2D1TransformGraph_ConnectNode(graph,
-            (ID2D1TransformNode *)offset_transform, (ID2D1TransformNode *)blend_transform, count);
+            (ID2D1TransformNode *)offset_transform, (ID2D1TransformNode *)blend_transform, transform_input_count);
+    ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
+
+    /* Set output */
+    hr = ID2D1TransformGraph_SetOutputNode(graph, (ID2D1TransformNode *)blend_transform);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1TransformGraph_SetOutputNode(graph, (ID2D1TransformNode *)offset_transform);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+    /* Single node transform graph */
+    effect_input_count = ID2D1TransformGraph_GetInputCount(graph);
+
+    transform_input_count = ID2D1BlendTransform_GetInputCount(blend_transform);
+    ok(transform_input_count != effect_input_count, "Input count should not be equal.\n");
+    hr = ID2D1TransformGraph_SetSingleTransformNode(graph, (ID2D1TransformNode *)blend_transform);
+    ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1TransformGraph_RemoveNode(graph, (ID2D1TransformNode *)blend_transform);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1TransformGraph_RemoveNode(graph, (ID2D1TransformNode *)offset_transform);
+    ok(hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND), "Got unexpected hr %#lx.\n", hr);
+
+    transform_input_count = ID2D1OffsetTransform_GetInputCount(offset_transform);
+    ok(transform_input_count == effect_input_count, "Input count should be equal.\n");
+    hr = ID2D1TransformGraph_SetSingleTransformNode(graph, (ID2D1TransformNode *)offset_transform);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1TransformGraph_RemoveNode(graph, (ID2D1TransformNode *)offset_transform);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1TransformGraph_RemoveNode(graph, (ID2D1TransformNode *)blend_transform);
+    ok(hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND), "Got unexpected hr %#lx.\n", hr);
+
+    /* Connect effect inputs to node inputs */
+    transform_input_count = ID2D1BlendTransform_GetInputCount(blend_transform);
+    hr = ID2D1TransformGraph_AddNode(graph, (ID2D1TransformNode *)blend_transform);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1TransformGraph_ConnectToEffectInput(graph, 0, (ID2D1TransformNode *)blend_transform, 0);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1TransformGraph_ConnectToEffectInput(graph, 0, (ID2D1TransformNode *)blend_transform, transform_input_count);
+    ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1TransformGraph_ConnectToEffectInput(graph, effect_input_count, (ID2D1TransformNode *)blend_transform, 0);
     ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);

done:

[PATCH v4 2/3] d2d1: Implement nodes adding and removal for ID2D1TransformGraph.

[Ziqing Hui]

From: Ziqing Hui

Signed-off-by: Ziqing Hui 
---
 dlls/d2d1/d2d1_private.h |  7 +++++
 dlls/d2d1/effect.c       | 61 ++++++++++++++++++++++++++++++++++++----
 2 files changed, 63 insertions(+), 5 deletions(-)

diff --git a/dlls/d2d1/d2d1_private.h b/dlls/d2d1/d2d1_private.h
index 085febe95e7..8de2f6de79f 100644
--- a/dlls/d2d1/d2d1_private.h
+++ b/dlls/d2d1/d2d1_private.h
@@ -674,10 +674,17 @@ struct d2d_effect_registration * d2d_factory_get_registered_effect(ID2D1Factory
 void d2d_factory_register_effect(struct d2d_factory *factory,
         struct d2d_effect_registration *effect) DECLSPEC_HIDDEN;

+struct d2d_transform_node
+{
+    ID2D1TransformNode *node;
+    struct list entry;
+};
+
 struct d2d_transform_graph
 {
     ID2D1TransformGraph ID2D1TransformGraph_iface;
     LONG refcount;
+    struct list nodes;
 };

struct d2d_effect
diff --git a/dlls/d2d1/effect.c b/dlls/d2d1/effect.c
index 7b086e20b9b..0ac2d4b3ade 100644
--- a/dlls/d2d1/effect.c
+++ b/dlls/d2d1/effect.c
@@ -20,6 +20,26 @@

WINE_DEFAULT_DEBUG_CHANNEL(d2d);

+static struct d2d_transform_node *d2d_transform_graph_find_node(const struct d2d_transform_graph *graph,
+        const ID2D1TransformNode *node)
+{
+    struct d2d_transform_node *entry;
+
+    LIST_FOR_EACH_ENTRY_REV(entry, &graph->nodes, struct d2d_transform_node, entry)
+    {
+        if (entry->node == node)
+            return entry;
+    }
+    return NULL;
+}
+
+static void d2d_transform_graph_remove_node(struct d2d_transform_graph *graph, struct d2d_transform_node *node)
+{
+    list_remove(&node->entry);
+    ID2D1TransformNode_Release(node->node);
+    free(node);
+}
+
 static inline struct d2d_transform_graph *impl_from_ID2D1TransformGraph(ID2D1TransformGraph *iface)
 {
     return CONTAINING_RECORD(iface, struct d2d_transform_graph, ID2D1TransformGraph_iface);
@@ -59,7 +79,10 @@ static ULONG STDMETHODCALLTYPE d2d_transform_graph_Release(ID2D1TransformGraph *
     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);

if (!refcount)
+    {
+        ID2D1TransformGraph_Clear(iface);
         free(graph);
+    }

return refcount;
 }
@@ -81,16 +104,35 @@ static HRESULT STDMETHODCALLTYPE d2d_transform_graph_SetSingleTransformNode(ID2D

static HRESULT STDMETHODCALLTYPE d2d_transform_graph_AddNode(ID2D1TransformGraph *iface, ID2D1TransformNode *node)
 {
-    FIXME("iface %p, node %p stub!\n", iface, node);
+    struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface);
+    struct d2d_transform_node *entry;

-    return E_NOTIMPL;
+    TRACE("iface %p, node %p.\n", iface, node);
+
+    if (d2d_transform_graph_find_node(graph, node))
+        return E_INVALIDARG;
+
+    if (!(entry = calloc(1, sizeof(*entry))))
+        return E_OUTOFMEMORY;
+
+    ID2D1TransformNode_AddRef(entry->node = node);
+    list_add_tail(&graph->nodes, &entry->entry);
+
+    return S_OK;
 }

static HRESULT STDMETHODCALLTYPE d2d_transform_graph_RemoveNode(ID2D1TransformGraph *iface, ID2D1TransformNode *node)
 {
-    FIXME("iface %p, node %p stub!\n", iface, node);
+    struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface);
+    struct d2d_transform_node *entry;

-    return E_NOTIMPL;
+    TRACE("iface %p, node %p.\n", iface, node);
+
+    if (!(entry = d2d_transform_graph_find_node(graph, node)))
+        return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
+
+    d2d_transform_graph_remove_node(graph, entry);
+    return S_OK;
 }

static HRESULT STDMETHODCALLTYPE d2d_transform_graph_SetOutputNode(ID2D1TransformGraph *iface, ID2D1TransformNode *node)
@@ -118,7 +160,15 @@ static HRESULT STDMETHODCALLTYPE d2d_transform_graph_ConnectToEffectInput(ID2D1T

static void STDMETHODCALLTYPE d2d_transform_graph_Clear(ID2D1TransformGraph *iface)
 {
-    FIXME("iface %p stub!\n", iface);
+    struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface);
+    struct d2d_transform_node *entry, *entry2;
+
+    TRACE("iface %p.\n", iface);
+
+    LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &graph->nodes, struct d2d_transform_node, entry)
+    {
+        d2d_transform_graph_remove_node(graph, entry);
+    }
 }

static HRESULT STDMETHODCALLTYPE d2d_transform_graph_SetPassthroughGraph(ID2D1TransformGraph *iface, UINT32 index)
@@ -148,6 +198,7 @@ static void d2d_transform_graph_init(struct d2d_transform_graph *graph)
 {
     graph->ID2D1TransformGraph_iface.lpVtbl = &d2d_transform_graph_vtbl;
     graph->refcount = 1;
+    list_init(&graph->nodes);
 }

static HRESULT STDMETHODCALLTYPE d2d_effect_impl_QueryInterface(ID2D1EffectImpl *iface, REFIID iid, void **out)

[PATCH v4 3/3] d2d1: Implement nodes connection for ID2D1TransformGraph.

[Ziqing Hui]

From: Ziqing Hui

Signed-off-by: Ziqing Hui 
---
 dlls/d2d1/d2d1_private.h |  14 ++++-
 dlls/d2d1/effect.c       | 133 ++++++++++++++++++++++++++++++++++-----
 2 files changed, 131 insertions(+), 16 deletions(-)

diff --git a/dlls/d2d1/d2d1_private.h b/dlls/d2d1/d2d1_private.h
index 8de2f6de79f..8970a4b7f28 100644
--- a/dlls/d2d1/d2d1_private.h
+++ b/dlls/d2d1/d2d1_private.h
@@ -676,7 +676,16 @@ void d2d_factory_register_effect(struct d2d_factory *factory,

struct d2d_transform_node
 {
-    ID2D1TransformNode *node;
+    BOOL effect_input;
+    union
+    {
+        ID2D1TransformNode *transform;
+        ID2D1Bitmap *bitmap;
+    } u;
+    struct d2d_transform_node **inputs;
+    UINT32 input_count;
+    struct d2d_transform_node *output;
+    UINT32 output_to_index;
     struct list entry;
 };

@@ -684,6 +693,9 @@ struct d2d_transform_graph
 {
     ID2D1TransformGraph ID2D1TransformGraph_iface;
     LONG refcount;
+    struct d2d_transform_node *input_nodes;
+    UINT32 input_count;
+    struct d2d_transform_node *output_node;
     struct list nodes;
 };

diff --git a/dlls/d2d1/effect.c b/dlls/d2d1/effect.c
index 0ac2d4b3ade..cdae0455755 100644
--- a/dlls/d2d1/effect.c
+++ b/dlls/d2d1/effect.c
@@ -27,7 +27,7 @@ static struct d2d_transform_node *d2d_transform_graph_find_node(const struct d2d

LIST_FOR_EACH_ENTRY_REV(entry, &graph->nodes, struct d2d_transform_node, entry)
     {
-        if (entry->node == node)
+        if (entry->u.transform == node)
             return entry;
     }
     return NULL;
@@ -35,8 +35,26 @@ static struct d2d_transform_node *d2d_transform_graph_find_node(const struct d2d

static void d2d_transform_graph_remove_node(struct d2d_transform_graph *graph, struct d2d_transform_node *node)
 {
+    UINT32 i;
+
+    for (i = 0; i < graph->input_count; ++i)
+    {
+        if (graph->input_nodes[i].output == node)
+            graph->input_nodes[i].output = NULL;
+    }
+    if (graph->output_node == node)
+        graph->output_node = NULL;
+    for (i = 0; i < node->input_count; ++i)
+    {
+        if (node->inputs[i])
+            node->inputs[i]->output = NULL;
+    }
+    if (node->output)
+        node->output->inputs[node->output_to_index] = NULL;
     list_remove(&node->entry);
-    ID2D1TransformNode_Release(node->node);
+
+    ID2D1TransformNode_Release(node->u.transform);
+    free(node->inputs);
     free(node);
 }

@@ -75,12 +93,19 @@ static ULONG STDMETHODCALLTYPE d2d_transform_graph_Release(ID2D1TransformGraph *
 {
     struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface);
     ULONG refcount = InterlockedDecrement(&graph->refcount);
+    UINT32 i;

TRACE("%p decreasing refcount to %lu.\n", iface, refcount);

if (!refcount)
     {
         ID2D1TransformGraph_Clear(iface);
+        for (i = 0; i < graph->input_count; ++i)
+        {
+            if (graph->input_nodes[i].u.bitmap)
+                ID2D1Bitmap_Release(graph->input_nodes[i].u.bitmap);
+        }
+        free(graph->input_nodes);
         free(graph);
     }

@@ -89,17 +114,39 @@ static ULONG STDMETHODCALLTYPE d2d_transform_graph_Release(ID2D1TransformGraph *

static UINT32 STDMETHODCALLTYPE d2d_transform_graph_GetInputCount(ID2D1TransformGraph *iface)
 {
-    FIXME("iface %p stub!\n", iface);
+    struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface);

-    return 0;
+    TRACE("iface %p\n", iface);
+
+    return graph->input_count;
 }

static HRESULT STDMETHODCALLTYPE d2d_transform_graph_SetSingleTransformNode(ID2D1TransformGraph *iface,
         ID2D1TransformNode *node)
 {
-    FIXME("iface %p, node %p stub!\n", iface, node);
+    struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface);
+    UINT32 input_count, i;
+    HRESULT hr;

-    return E_NOTIMPL;
+    TRACE("iface %p, node %p.\n", iface, node);
+
+    input_count = ID2D1TransformNode_GetInputCount(node);
+    if (input_count != graph->input_count)
+        return E_INVALIDARG;
+
+    ID2D1TransformGraph_Clear(iface);
+
+    if (FAILED(hr = ID2D1TransformGraph_AddNode(iface, node)))
+        return hr;
+    if (FAILED(hr = ID2D1TransformGraph_SetOutputNode(iface, node)))
+        return hr;
+    for (i = 0; i < input_count; ++i)
+    {
+        if (FAILED(hr = ID2D1TransformGraph_ConnectToEffectInput(iface, i, node, i)))
+            return hr;
+    }
+
+    return S_OK;
 }

static HRESULT STDMETHODCALLTYPE d2d_transform_graph_AddNode(ID2D1TransformGraph *iface, ID2D1TransformNode *node)
@@ -115,7 +162,13 @@ static HRESULT STDMETHODCALLTYPE d2d_transform_graph_AddNode(ID2D1TransformGraph
     if (!(entry = calloc(1, sizeof(*entry))))
         return E_OUTOFMEMORY;

-    ID2D1TransformNode_AddRef(entry->node = node);
+    entry->input_count = ID2D1TransformNode_GetInputCount(node);
+    if (!(entry->inputs = calloc(entry->input_count, sizeof(*entry->inputs))))
+    {
+        free(entry);
+        return E_OUTOFMEMORY;
+    }
+    ID2D1TransformNode_AddRef(entry->u.transform = node);
     list_add_tail(&graph->nodes, &entry->entry);

return S_OK;
@@ -137,25 +190,58 @@ static HRESULT STDMETHODCALLTYPE d2d_transform_graph_RemoveNode(ID2D1TransformGr

static HRESULT STDMETHODCALLTYPE d2d_transform_graph_SetOutputNode(ID2D1TransformGraph *iface, ID2D1TransformNode *node)
 {
-    FIXME("iface %p, node %p stub!\n", iface, node);
+    struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface);
+    struct d2d_transform_node *entry;

-    return E_NOTIMPL;
+    TRACE("iface %p, node %p.\n", iface, node);
+
+    if (!(entry = d2d_transform_graph_find_node(graph, node)))
+        return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
+
+    graph->output_node = entry;
+
+    return S_OK;
 }

static HRESULT STDMETHODCALLTYPE d2d_transform_graph_ConnectNode(ID2D1TransformGraph *iface,
         ID2D1TransformNode *from_node, ID2D1TransformNode *to_node, UINT32 index)
 {
-    FIXME("iface %p, from_node %p, to_node %p, index %u stub!\n", iface, from_node, to_node, index);
+    struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface);
+    struct d2d_transform_node *from, *to;

-    return E_NOTIMPL;
+    TRACE("iface %p, from_node %p, to_node %p, index %u.\n", iface, from_node, to_node, index);
+
+    if (!(from = d2d_transform_graph_find_node(graph, from_node))
+            || !(to = d2d_transform_graph_find_node(graph, to_node)))
+        return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
+    if (index >= to->input_count)
+        return E_INVALIDARG;
+
+    from->output = to;
+    from->output_to_index = index;
+    to->inputs[index] = from;
+
+    return S_OK;
 }

static HRESULT STDMETHODCALLTYPE d2d_transform_graph_ConnectToEffectInput(ID2D1TransformGraph *iface,
         UINT32 input_index, ID2D1TransformNode *node, UINT32 node_index)
 {
-    FIXME("iface %p, input_index %u, node %p, node_index %u stub!\n", iface, input_index, node, node_index);
+    struct d2d_transform_graph *graph = impl_from_ID2D1TransformGraph(iface);
+    struct d2d_transform_node *entry;

-    return E_NOTIMPL;
+    TRACE("iface %p, input_index %u, node %p, node_index %u.\n", iface, input_index, node, node_index);
+
+    if (!(entry = d2d_transform_graph_find_node(graph, node)))
+        return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
+    if (input_index >= graph->input_count || node_index >= entry->input_count)
+        return E_INVALIDARG;
+
+    graph->input_nodes[input_index].output = entry;
+    graph->input_nodes[input_index].output_to_index = node_index;
+    entry->inputs[node_index] = &graph->input_nodes[input_index];
+
+    return S_OK;
 }

static void STDMETHODCALLTYPE d2d_transform_graph_Clear(ID2D1TransformGraph *iface)
@@ -194,11 +280,23 @@ static const ID2D1TransformGraphVtbl d2d_transform_graph_vtbl =
     d2d_transform_graph_SetPassthroughGraph,
 };

-static void d2d_transform_graph_init(struct d2d_transform_graph *graph)
+static HRESULT d2d_transform_graph_init(struct d2d_transform_graph *graph, UINT32 input_count)
 {
+    UINT32 i;
+
     graph->ID2D1TransformGraph_iface.lpVtbl = &d2d_transform_graph_vtbl;
     graph->refcount = 1;
+
+    if (!(graph->input_nodes = calloc(input_count, sizeof(*graph->input_nodes))))
+        return E_OUTOFMEMORY;
+    for (i = 0; i < input_count; ++i)
+    {
+        graph->input_nodes[i].effect_input = TRUE;
+    }
+    graph->input_count = input_count;
+
     list_init(&graph->nodes);
+    return S_OK;
 }

static HRESULT STDMETHODCALLTYPE d2d_effect_impl_QueryInterface(ID2D1EffectImpl *iface, REFIID iid, void **out)
@@ -1639,7 +1737,12 @@ HRESULT d2d_effect_create(struct d2d_device_context *context, const CLSID *effec
         ID2D1EffectContext_Release(&effect_context->ID2D1EffectContext_iface);
         return E_OUTOFMEMORY;
     }
-    d2d_transform_graph_init(graph);
+    if (FAILED(hr = d2d_transform_graph_init(graph, reg->default_input_count)))
+    {
+        free(graph);
+        ID2D1EffectContext_Release(&effect_context->ID2D1EffectContext_iface);
+        return hr;
+    }

if (!(object = calloc(1, sizeof(*object))))
     {

[PATCH v4 0/3] MR635: Draft: Implement transform graph. Partically implement effect drawing. - closed

[Ziqing Hui (＠zhui)]

This merge request was closed by Ziqing Hui.