May 2018 - Wine-devel - list.winehq.org

[PATCH 1/3] mshtml.idl: Added IHTMLWindow7 declaration.
by Jacek Caban 17 May '18

17 May '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- include/mshtmdid.h | 71 ++++ include/mshtml.idl | 1170 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 1211 insertions(+), 30 deletions(-)

1 0

[PATCH 7/7] comctl32/taskdialog: Add support for TDF_RTL_LAYOUT.
by Zhiyi Zhang 17 May '18

17 May '18

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/taskdialog.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/comctl32/taskdialog.c b/dlls/comctl32/taskdialog.c index 7066b793c8..5cd1d05642 100644 --- a/dlls/comctl32/taskdialog.c +++ b/dlls/comctl32/taskdialog.c @@ -543,6 +543,7 @@ static DLGTEMPLATE *create_taskdialog_template(const TASKDIALOGCONFIG *taskconfi template->style = DS_MODALFRAME | DS_SETFONT | WS_CAPTION | WS_VISIBLE | WS_SYSMENU; if (taskconfig->dwFlags & TDF_CAN_BE_MINIMIZED) template->style |= WS_MINIMIZEBOX; if (!(taskconfig->dwFlags & TDF_NO_SET_FOREGROUND)) template->style |= DS_SETFOREGROUND; + if (taskconfig->dwFlags & TDF_RTL_LAYOUT) template->dwExtendedStyle = WS_EX_LAYOUTRTL | WS_EX_RIGHT | WS_EX_RTLREADING; template->cdit = desc.control_count; ptr = (char *)(template + 1); -- 2.17.0

2 3

[PATCH 6/7] comctl32/taskdialog: Add support for TDF_NO_SET_FOREGROUND.
by Zhiyi Zhang 17 May '18

17 May '18

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/taskdialog.c | 1 + 1 file changed, 1 insertion(+) diff --git a/dlls/comctl32/taskdialog.c b/dlls/comctl32/taskdialog.c index a0d38051b2..7066b793c8 100644 --- a/dlls/comctl32/taskdialog.c +++ b/dlls/comctl32/taskdialog.c @@ -542,6 +542,7 @@ static DLGTEMPLATE *create_taskdialog_template(const TASKDIALOGCONFIG *taskconfi template->style = DS_MODALFRAME | DS_SETFONT | WS_CAPTION | WS_VISIBLE | WS_SYSMENU; if (taskconfig->dwFlags & TDF_CAN_BE_MINIMIZED) template->style |= WS_MINIMIZEBOX; + if (!(taskconfig->dwFlags & TDF_NO_SET_FOREGROUND)) template->style |= DS_SETFOREGROUND; template->cdit = desc.control_count; ptr = (char *)(template + 1); -- 2.17.0

2 2

[PATCH] d3d11: Add support for DepthClipEnable in RSSetState.
by Zebediah Figura 17 May '18

17 May '18

From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/d3d10core/tests/device.c | 2 -- dlls/d3d11/device.c | 5 ++--- dlls/d3d11/tests/d3d11.c | 2 -- dlls/wined3d/directx.c | 1 + dlls/wined3d/state.c | 24 ++++++++++++++++++++++++ dlls/wined3d/stateblock.c | 2 ++ dlls/wined3d/utils.c | 1 + dlls/wined3d/wined3d_gl.h | 1 + include/wine/wined3d.h | 3 ++- 9 files changed, 33 insertions(+), 8 deletions(-) diff --git a/dlls/d3d10core/tests/device.c b/dlls/d3d10core/tests/device.c index 4b39c1b..50521bd 100644 --- a/dlls/d3d10core/tests/device.c +++ b/dlls/d3d10core/tests/device.c @@ -16894,12 +16894,10 @@ static void test_depth_clip(void) ID3D10Device_ClearDepthStencilView(device, dsv, D3D10_CLEAR_DEPTH, 1.0f, 0); set_viewport(device, vp.TopLeftX, vp.TopLeftY, vp.Width, vp.Height, 0.4f, 0.6f); draw_quad_z(&test_context, 2.0f); -todo_wine check_texture_float(texture, 0.6f, 1); draw_quad_z(&test_context, 0.5f); check_texture_float(texture, 0.5f, 1); draw_quad_z(&test_context, -1.0f); -todo_wine check_texture_float(texture, 0.4f, 1); ID3D10DepthStencilView_Release(dsv); diff --git a/dlls/d3d11/device.c b/dlls/d3d11/device.c index c930248..37ad327 100644 --- a/dlls/d3d11/device.c +++ b/dlls/d3d11/device.c @@ -932,6 +932,7 @@ static void STDMETHODCALLTYPE d3d11_immediate_context_RSSetState(ID3D11DeviceCon wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_CULLMODE, WINED3D_CULL_BACK); wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SLOPESCALEDEPTHBIAS, 0); wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DEPTHBIAS, 0); + wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DEPTHCLIP, TRUE); wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SCISSORTESTENABLE, FALSE); wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEANTIALIAS, FALSE); wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_ANTIALIASEDLINEENABLE, FALSE); @@ -948,9 +949,7 @@ static void STDMETHODCALLTYPE d3d11_immediate_context_RSSetState(ID3D11DeviceCon const_bias.f = desc->DepthBias; wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SLOPESCALEDEPTHBIAS, scale_bias.d); wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DEPTHBIAS, const_bias.d); - /* GL_DEPTH_CLAMP */ - if (!desc->DepthClipEnable) - FIXME("Ignoring DepthClipEnable %#x.\n", desc->DepthClipEnable); + wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_DEPTHCLIP, desc->DepthClipEnable); wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_SCISSORTESTENABLE, desc->ScissorEnable); wined3d_device_set_render_state(device->wined3d_device, WINED3D_RS_MULTISAMPLEANTIALIAS, desc->MultisampleEnable); wined3d_device_set_render_state(device->wined3d_device, diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 9e673ee..8269df4 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -26875,12 +26875,10 @@ static void test_depth_clip(void) ID3D11DeviceContext_ClearDepthStencilView(context, dsv, D3D11_CLEAR_DEPTH, 1.0f, 0); set_viewport(context, vp.TopLeftX, vp.TopLeftY, vp.Width, vp.Height, 0.4f, 0.6f); draw_quad_z(&test_context, 2.0f); -todo_wine check_texture_float(texture, 0.6f, 1); draw_quad_z(&test_context, 0.5f); check_texture_float(texture, 0.5f, 1); draw_quad_z(&test_context, -1.0f); -todo_wine check_texture_float(texture, 0.4f, 1); ID3D11DepthStencilView_Release(dsv); diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index e125c5f..0199b99 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -122,6 +122,7 @@ static const struct wined3d_extension_map gl_extension_map[] = {"GL_ARB_cull_distance", ARB_CULL_DISTANCE }, {"GL_ARB_debug_output", ARB_DEBUG_OUTPUT }, {"GL_ARB_depth_buffer_float", ARB_DEPTH_BUFFER_FLOAT }, + {"GL_ARB_depth_clamp", ARB_DEPTH_CLAMP }, {"GL_ARB_depth_texture", ARB_DEPTH_TEXTURE }, {"GL_ARB_derivative_control", ARB_DERIVATIVE_CONTROL }, {"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS }, diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c index 34e08e9..83903e2 100644 --- a/dlls/wined3d/state.c +++ b/dlls/wined3d/state.c @@ -1821,6 +1821,28 @@ static void state_depthbias(struct wined3d_context *context, const struct wined3 checkGLcall("depth bias"); } +static void state_depthclip(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id) +{ + const struct wined3d_gl_info *gl_info = context->gl_info; + + if (state->render_states[WINED3D_RS_DEPTHCLIP]) + { + gl_info->gl_ops.gl.p_glDisable(GL_DEPTH_CLAMP); + checkGLcall("glDisable(GL_DEPTH_CLAMP)"); + } + else + { + gl_info->gl_ops.gl.p_glEnable(GL_DEPTH_CLAMP); + checkGLcall("glEnable(GL_DEPTH_CLAMP)"); + } +} + +static void state_depthclip_w(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id) +{ + if (!state->render_states[WINED3D_RS_DEPTHCLIP]) + FIXME("Depth clamping not supported by GL.\n"); +} + static void state_zvisible(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id) { if (state->render_states[WINED3D_RS_ZVISIBLE]) @@ -4661,6 +4683,8 @@ const struct StateEntryTemplate misc_state_template[] = { STATE_RENDER(WINED3D_RS_BLENDFACTOR), { STATE_RENDER(WINED3D_RS_BLENDFACTOR), state_blendfactor_w }, WINED3D_GL_EXT_NONE }, { STATE_RENDER(WINED3D_RS_DEPTHBIAS), { STATE_RENDER(WINED3D_RS_DEPTHBIAS), state_depthbias }, WINED3D_GL_EXT_NONE }, { STATE_RENDER(WINED3D_RS_ZVISIBLE), { STATE_RENDER(WINED3D_RS_ZVISIBLE), state_zvisible }, WINED3D_GL_EXT_NONE }, + { STATE_RENDER(WINED3D_RS_DEPTHCLIP), { STATE_RENDER(WINED3D_RS_DEPTHCLIP), state_depthclip }, ARB_DEPTH_CLAMP }, + { STATE_RENDER(WINED3D_RS_DEPTHCLIP), { STATE_RENDER(WINED3D_RS_DEPTHCLIP), state_depthclip_w }, WINED3D_GL_EXT_NONE }, /* Samplers */ { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler }, WINED3D_GL_EXT_NONE }, { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler }, WINED3D_GL_EXT_NONE }, diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c index b4d1751..a60903d 100644 --- a/dlls/wined3d/stateblock.c +++ b/dlls/wined3d/stateblock.c @@ -90,6 +90,7 @@ static const DWORD pixel_states_render[] = WINED3D_RS_ZENABLE, WINED3D_RS_ZFUNC, WINED3D_RS_ZWRITEENABLE, + WINED3D_RS_DEPTHCLIP, }; static const DWORD pixel_states_texture[] = @@ -1257,6 +1258,7 @@ static void state_init_default(struct wined3d_state *state, const struct wined3d state->render_states[WINED3D_RS_BLENDFACTOR] = 0xffffffff; state->render_states[WINED3D_RS_SRGBWRITEENABLE] = 0; state->render_states[WINED3D_RS_DEPTHBIAS] = 0; + state->render_states[WINED3D_RS_DEPTHCLIP] = TRUE; state->render_states[WINED3D_RS_WRAP8] = 0; state->render_states[WINED3D_RS_WRAP9] = 0; state->render_states[WINED3D_RS_WRAP10] = 0; diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index 49b08bf..e25b95e 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -4434,6 +4434,7 @@ const char *debug_d3drenderstate(enum wined3d_render_state state) D3DSTATE_TO_STR(WINED3D_RS_SRCBLENDALPHA); D3DSTATE_TO_STR(WINED3D_RS_DESTBLENDALPHA); D3DSTATE_TO_STR(WINED3D_RS_BLENDOPALPHA); + D3DSTATE_TO_STR(WINED3D_RS_DEPTHCLIP); #undef D3DSTATE_TO_STR default: FIXME("Unrecognized %u render state!\n", state); diff --git a/dlls/wined3d/wined3d_gl.h b/dlls/wined3d/wined3d_gl.h index 3140526..525c298 100644 --- a/dlls/wined3d/wined3d_gl.h +++ b/dlls/wined3d/wined3d_gl.h @@ -55,6 +55,7 @@ enum wined3d_gl_extension ARB_CULL_DISTANCE, ARB_DEBUG_OUTPUT, ARB_DEPTH_BUFFER_FLOAT, + ARB_DEPTH_CLAMP, ARB_DEPTH_TEXTURE, ARB_DERIVATIVE_CONTROL, ARB_DRAW_BUFFERS, diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index 15e14e5..09e3a4e 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -386,8 +386,9 @@ enum wined3d_render_state WINED3D_RS_SRCBLENDALPHA = 207, WINED3D_RS_DESTBLENDALPHA = 208, WINED3D_RS_BLENDOPALPHA = 209, + WINED3D_RS_DEPTHCLIP = 210, }; -#define WINEHIGHEST_RENDER_STATE WINED3D_RS_BLENDOPALPHA +#define WINEHIGHEST_RENDER_STATE WINED3D_RS_DEPTHCLIP enum wined3d_blend { -- 2.7.4

3 2

[PATCH 1/3] gdi32: Add bounds checking for metafile records.
by Vincent Povirk 17 May '18

17 May '18

Signed-off-by: Vincent Povirk <vincent(a)codeweavers.com> --- dlls/gdi32/enhmetafile.c | 610 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 610 insertions(+) diff --git a/dlls/gdi32/enhmetafile.c b/dlls/gdi32/enhmetafile.c index 2d8a9b04fb2..d8f72c98718 100644 --- a/dlls/gdi32/enhmetafile.c +++ b/dlls/gdi32/enhmetafile.c @@ -743,6 +743,604 @@ static BOOL emr_produces_output(int type) } } +static BOOL emr_validate_size(const ENHMETARECORD *emr) +{ + switch(emr->iType) { + case EMR_HEADER: + if (emr->nSize < FIELD_OFFSET(ENHMETAHEADER, cbPixelFormat)) return FALSE; + break; + case EMR_EOF: + { + const EMREOF *lpEof = (const EMREOF *)emr; + if (emr->nSize < sizeof(EMREOF) || + (lpEof->nPalEntries * 4 / 4) != lpEof->nPalEntries || + lpEof->offPalEntries > lpEof->offPalEntries + lpEof->nPalEntries * 4 || + emr->nSize < lpEof->offPalEntries + lpEof->nPalEntries * 4) + return FALSE; + break; + } + case EMR_GDICOMMENT: + { + const EMRGDICOMMENT *lpGdiComment = (const EMRGDICOMMENT *)emr; + if (emr->nSize < FIELD_OFFSET(EMRGDICOMMENT, Data) || + lpGdiComment->cbData > lpGdiComment->cbData + FIELD_OFFSET(EMRGDICOMMENT, Data) || + emr->nSize < lpGdiComment->cbData + FIELD_OFFSET(EMRGDICOMMENT, Data)) + return FALSE; + break; + } + case EMR_SETMAPMODE: + if (emr->nSize < sizeof(EMRSETMAPMODE)) return FALSE; + break; + case EMR_SETBKMODE: + if (emr->nSize < sizeof(EMRSETBKMODE)) return FALSE; + break; + case EMR_SETBKCOLOR: + if (emr->nSize < sizeof(EMRSETBKCOLOR)) return FALSE; + break; + case EMR_SETPOLYFILLMODE: + if (emr->nSize < sizeof(EMRSETPOLYFILLMODE)) return FALSE; + break; + case EMR_SETROP2: + if (emr->nSize < sizeof(EMRSETROP2)) return FALSE; + break; + case EMR_SETTEXTALIGN: + if (emr->nSize < sizeof(EMRSETTEXTALIGN)) return FALSE; + break; + case EMR_SETTEXTCOLOR: + if (emr->nSize < sizeof(EMRSETTEXTCOLOR)) return FALSE; + break; + case EMR_SAVEDC: + if (emr->nSize < sizeof(EMRSAVEDC)) return FALSE; + break; + case EMR_RESTOREDC: + if (emr->nSize < sizeof(EMRRESTOREDC)) return FALSE; + break; + case EMR_INTERSECTCLIPRECT: + if (emr->nSize < sizeof(EMRINTERSECTCLIPRECT)) return FALSE; + break; + case EMR_SELECTOBJECT: + if (emr->nSize < sizeof(EMRSELECTOBJECT)) return FALSE; + break; + case EMR_DELETEOBJECT: + if (emr->nSize < sizeof(EMRDELETEOBJECT)) return FALSE; + break; + case EMR_SETWINDOWORGEX: + if (emr->nSize < sizeof(EMRSETWINDOWORGEX)) return FALSE; + break; + case EMR_SETWINDOWEXTEX: + if (emr->nSize < sizeof(EMRSETWINDOWEXTEX)) return FALSE; + break; + case EMR_SETVIEWPORTORGEX: + if (emr->nSize < sizeof(EMRSETVIEWPORTORGEX)) return FALSE; + break; + case EMR_SETVIEWPORTEXTEX: + if (emr->nSize < sizeof(EMRSETVIEWPORTEXTEX)) return FALSE; + break; + case EMR_CREATEPEN: + if (emr->nSize < sizeof(EMRCREATEPEN)) return FALSE; + break; + case EMR_EXTCREATEPEN: + { + const EMREXTCREATEPEN *pPen = (const EMREXTCREATEPEN *)emr; + if (emr->nSize < sizeof(EMREXTCREATEPEN) || + pPen->cbBmi > pPen->offBmi + pPen->cbBmi || + emr->nSize < pPen->offBmi + pPen->cbBmi || + pPen->cbBits > pPen->offBits + pPen->cbBits || + emr->nSize < pPen->offBits + pPen->cbBits || + (pPen->elp.elpNumEntries * 4 / 4) != pPen->elp.elpNumEntries || + pPen->elp.elpNumEntries * 4 > pPen->elp.elpNumEntries * 4 + FIELD_OFFSET(EMREXTCREATEPEN, elp.elpStyleEntry) || + emr->nSize < pPen->elp.elpNumEntries * 4 + FIELD_OFFSET(EMREXTCREATEPEN, elp.elpStyleEntry)) + return FALSE; + /* FIXME: validate DIB size */ + break; + } + case EMR_CREATEBRUSHINDIRECT: + if (emr->nSize < sizeof(EMRCREATEBRUSHINDIRECT)) return FALSE; + break; + case EMR_EXTCREATEFONTINDIRECTW: + if (emr->nSize < sizeof(EMREXTCREATEFONTINDIRECTW)) return FALSE; + break; + case EMR_MOVETOEX: + if (emr->nSize < sizeof(EMRMOVETOEX)) return FALSE; + break; + case EMR_LINETO: + if (emr->nSize < sizeof(EMRLINETO)) return FALSE; + break; + case EMR_RECTANGLE: + if (emr->nSize < sizeof(EMRRECTANGLE)) return FALSE; + break; + case EMR_ELLIPSE: + if (emr->nSize < sizeof(EMRELLIPSE)) return FALSE; + break; + case EMR_POLYGON16: + case EMR_POLYLINE16: + case EMR_POLYLINETO16: + case EMR_POLYBEZIER16: + case EMR_POLYBEZIERTO16: + { + const EMRPOLYGON16 *pPoly = (const EMRPOLYGON16 *)emr; + DWORD pts_ofs = FIELD_OFFSET(EMRPOLYGON16, apts); + if (emr->nSize < FIELD_OFFSET(EMRPOLYGON16, apts) || + (pPoly->cpts * 4 / 4) != pPoly->cpts || + pts_ofs > pts_ofs + pPoly->cpts * 4 || + emr->nSize < pts_ofs + pPoly->cpts * 4) + return FALSE; + break; + } + case EMR_POLYPOLYGON16: + case EMR_POLYPOLYLINE16: + { + const EMRPOLYPOLYGON16 *pPolyPoly = (const EMRPOLYPOLYGON16 *)emr; + DWORD counts_ofs = FIELD_OFFSET(EMRPOLYPOLYGON16, aPolyCounts); + DWORD points_ofs, total_points=0, i; + if (emr->nSize < FIELD_OFFSET(EMRPOLYPOLYGON16, aPolyCounts) || + (pPolyPoly->nPolys * 4 / 4) != pPolyPoly->nPolys || + counts_ofs > counts_ofs + pPolyPoly->nPolys * 4 || + emr->nSize < counts_ofs + pPolyPoly->nPolys * 4) + return FALSE; + points_ofs = counts_ofs + pPolyPoly->nPolys * 4; + if ((pPolyPoly->cpts * 4 / 4) != pPolyPoly->cpts || + points_ofs > points_ofs + pPolyPoly->cpts * 4 || + emr->nSize < points_ofs + pPolyPoly->cpts * 4) + return FALSE; + + for(i = 0; i < pPolyPoly->nPolys; i++) + { + if (total_points > total_points + pPolyPoly->aPolyCounts[i] || + pPolyPoly->cpts < total_points + pPolyPoly->aPolyCounts[i]) + return FALSE; + total_points += pPolyPoly->aPolyCounts[i]; + } + break; + } + case EMR_STRETCHDIBITS: + if (emr->nSize < sizeof(EMRSTRETCHDIBITS)) return FALSE; + /* FIXME: validate DIB size */ + break; + case EMR_EXTTEXTOUTA: + { + const EMREXTTEXTOUTA *pExtTextOutA = (const EMREXTTEXTOUTA *)emr; + DWORD string_ofs, dx_ofs; + if (emr->nSize < sizeof(EMREXTTEXTOUTA)) + return FALSE; + string_ofs = pExtTextOutA->emrtext.offString; + if (string_ofs > string_ofs + pExtTextOutA->emrtext.nChars || + emr->nSize < string_ofs + pExtTextOutA->emrtext.nChars) + return FALSE; + dx_ofs = pExtTextOutA->emrtext.offDx; + if (dx_ofs && ( + pExtTextOutA->emrtext.nChars * 4 / 4 != pExtTextOutA->emrtext.nChars || + dx_ofs > dx_ofs + pExtTextOutA->emrtext.nChars * 4 || + emr->nSize < dx_ofs + pExtTextOutA->emrtext.nChars * 4)) + return FALSE; + break; + } + + case EMR_EXTTEXTOUTW: + { + const EMREXTTEXTOUTW *pExtTextOutW = (const EMREXTTEXTOUTW *)emr; + DWORD string_ofs, dx_ofs; + if (emr->nSize < sizeof(EMREXTTEXTOUTW)) + return FALSE; + string_ofs = pExtTextOutW->emrtext.offString; + if (string_ofs > string_ofs + pExtTextOutW->emrtext.nChars || + pExtTextOutW->emrtext.nChars * 2 / 2 != pExtTextOutW->emrtext.nChars || + emr->nSize < string_ofs + pExtTextOutW->emrtext.nChars * 2) + return FALSE; + dx_ofs = pExtTextOutW->emrtext.offDx; + if (dx_ofs && ( + pExtTextOutW->emrtext.nChars * 4 / 4 != pExtTextOutW->emrtext.nChars || + dx_ofs > dx_ofs + pExtTextOutW->emrtext.nChars * 4 || + emr->nSize < dx_ofs + pExtTextOutW->emrtext.nChars * 4)) + return FALSE; + break; + } + + case EMR_CREATEPALETTE: + { + const EMRCREATEPALETTE *lpCreatePal = (const EMRCREATEPALETTE *)emr; + DWORD entries_ofs = FIELD_OFFSET(EMRCREATEPALETTE, lgpl.palPalEntry); + + if (emr->nSize < FIELD_OFFSET(EMRCREATEPALETTE, lgpl.palPalEntry) || + lpCreatePal->lgpl.palNumEntries * 4 / 4 != lpCreatePal->lgpl.palNumEntries || + entries_ofs > entries_ofs + lpCreatePal->lgpl.palNumEntries * 4 || + emr->nSize < entries_ofs + lpCreatePal->lgpl.palNumEntries * 4) + return FALSE; + + break; + } + + case EMR_SELECTPALETTE: + if (emr->nSize < sizeof(EMRSELECTPALETTE)) return FALSE; + break; + case EMR_REALIZEPALETTE: + if (emr->nSize < sizeof(EMRREALIZEPALETTE)) return FALSE; + break; + case EMR_EXTSELECTCLIPRGN: + { + const EMREXTSELECTCLIPRGN *lpRgn = (const EMREXTSELECTCLIPRGN *)emr; + DWORD data_ofs = FIELD_OFFSET(EMREXTSELECTCLIPRGN, RgnData); + + if (emr->nSize < FIELD_OFFSET(EMREXTSELECTCLIPRGN, RgnData) || + data_ofs > data_ofs + lpRgn->cbRgnData || + emr->nSize < data_ofs + lpRgn->cbRgnData) + return FALSE; + + break; + } + + case EMR_SETMETARGN: + if (emr->nSize < sizeof(EMRSETMETARGN)) return FALSE; + break; + case EMR_SETWORLDTRANSFORM: + if (emr->nSize < sizeof(EMRSETWORLDTRANSFORM)) return FALSE; + break; + case EMR_POLYBEZIER: + case EMR_POLYGON: + case EMR_POLYLINE: + case EMR_POLYBEZIERTO: + case EMR_POLYLINETO: + { + const EMRPOLYBEZIER *pPoly = (const EMRPOLYBEZIER *)emr; + DWORD pts_ofs = FIELD_OFFSET(EMRPOLYBEZIER, aptl); + if (emr->nSize < FIELD_OFFSET(EMRPOLYBEZIER, aptl) || + (pPoly->cptl * 8 / 8) != pPoly->cptl || + pts_ofs > pts_ofs + pPoly->cptl * 8 || + emr->nSize < pts_ofs + pPoly->cptl * 8) + return FALSE; + break; + } + case EMR_POLYPOLYLINE: + case EMR_POLYPOLYGON: + { + const EMRPOLYPOLYLINE *pPolyPoly = (const EMRPOLYPOLYLINE *)emr; + DWORD counts_ofs = FIELD_OFFSET(EMRPOLYPOLYLINE, aPolyCounts); + DWORD points_ofs, total_points=0, i; + if (emr->nSize < FIELD_OFFSET(EMRPOLYPOLYLINE, aPolyCounts) || + (pPolyPoly->nPolys * 4 / 4) != pPolyPoly->nPolys || + counts_ofs > counts_ofs + pPolyPoly->nPolys * 4 || + emr->nSize < counts_ofs + pPolyPoly->nPolys * 4) + return FALSE; + points_ofs = counts_ofs + pPolyPoly->nPolys * 4; + if ((pPolyPoly->cptl * 8 / 8) != pPolyPoly->cptl || + points_ofs > points_ofs + pPolyPoly->cptl * 8 || + emr->nSize < points_ofs + pPolyPoly->cptl * 8) + return FALSE; + + for(i = 0; i < pPolyPoly->nPolys; i++) + { + if (total_points > total_points + pPolyPoly->aPolyCounts[i] || + pPolyPoly->cptl < total_points + pPolyPoly->aPolyCounts[i]) + return FALSE; + total_points += pPolyPoly->aPolyCounts[i]; + } + break; + } + case EMR_SETBRUSHORGEX: + if (emr->nSize < sizeof(EMRSETBRUSHORGEX)) return FALSE; + break; + case EMR_SETPIXELV: + if (emr->nSize < sizeof(EMRSETPIXELV)) return FALSE; + break; + case EMR_SETMAPPERFLAGS: + if (emr->nSize < sizeof(EMRSETMAPPERFLAGS)) return FALSE; + break; + case EMR_SETCOLORADJUSTMENT: + if (emr->nSize < sizeof(EMRSETCOLORADJUSTMENT)) return FALSE; + break; + case EMR_OFFSETCLIPRGN: + if (emr->nSize < sizeof(EMROFFSETCLIPRGN)) return FALSE; + break; + case EMR_EXCLUDECLIPRECT: + if (emr->nSize < sizeof(EMREXCLUDECLIPRECT)) return FALSE; + break; + case EMR_SCALEVIEWPORTEXTEX: + if (emr->nSize < sizeof(EMRSCALEVIEWPORTEXTEX)) return FALSE; + break; + case EMR_SCALEWINDOWEXTEX: + if (emr->nSize < sizeof(EMRSCALEWINDOWEXTEX)) return FALSE; + break; + case EMR_MODIFYWORLDTRANSFORM: + if (emr->nSize < sizeof(EMRMODIFYWORLDTRANSFORM)) return FALSE; + break; + case EMR_ANGLEARC: + if (emr->nSize < sizeof(EMRANGLEARC)) return FALSE; + break; + case EMR_ROUNDRECT: + if (emr->nSize < sizeof(EMRROUNDRECT)) return FALSE; + break; + case EMR_ARC: + if (emr->nSize < sizeof(EMRARC)) return FALSE; + break; + case EMR_CHORD: + if (emr->nSize < sizeof(EMRCHORD)) return FALSE; + break; + case EMR_PIE: + if (emr->nSize < sizeof(EMRPIE)) return FALSE; + break; + case EMR_ARCTO: + if (emr->nSize < sizeof(EMRARCTO)) return FALSE; + break; + case EMR_EXTFLOODFILL: + if (emr->nSize < sizeof(EMREXTFLOODFILL)) return FALSE; + break; + case EMR_POLYDRAW: + { + const EMRPOLYDRAW *lpPolyDraw = (const EMRPOLYDRAW *)emr; + DWORD pts_ofs = FIELD_OFFSET(EMRPOLYDRAW, aptl); + if (emr->nSize < FIELD_OFFSET(EMRPOLYDRAW, aptl) || + (lpPolyDraw->cptl * 5 / 5) != lpPolyDraw->cptl || + pts_ofs > pts_ofs + lpPolyDraw->cptl * 5 || + emr->nSize < pts_ofs + lpPolyDraw->cptl * 5) + return FALSE; + break; + } + case EMR_SETARCDIRECTION: + if (emr->nSize < sizeof(EMRSETARCDIRECTION)) return FALSE; + break; + case EMR_SETMITERLIMIT: + if (emr->nSize < sizeof(EMRSETMITERLIMIT)) return FALSE; + break; + case EMR_BEGINPATH: + if (emr->nSize < sizeof(EMRBEGINPATH)) return FALSE; + break; + case EMR_ENDPATH: + if (emr->nSize < sizeof(EMRENDPATH)) return FALSE; + break; + case EMR_CLOSEFIGURE: + if (emr->nSize < sizeof(EMRCLOSEFIGURE)) return FALSE; + break; + case EMR_FILLPATH: + if (emr->nSize < sizeof(EMRFILLPATH)) return FALSE; + break; + case EMR_STROKEANDFILLPATH: + if (emr->nSize < sizeof(EMRSTROKEANDFILLPATH)) return FALSE; + break; + case EMR_STROKEPATH: + if (emr->nSize < sizeof(EMRSTROKEPATH)) return FALSE; + break; + case EMR_FLATTENPATH: + if (emr->nSize < sizeof(EMRFLATTENPATH)) return FALSE; + break; + case EMR_WIDENPATH: + if (emr->nSize < sizeof(EMRWIDENPATH)) return FALSE; + break; + case EMR_SELECTCLIPPATH: + if (emr->nSize < sizeof(EMRSELECTCLIPPATH)) return FALSE; + break; + case EMR_ABORTPATH: + if (emr->nSize < sizeof(EMRABORTPATH)) return FALSE; + break; + case EMR_CREATECOLORSPACE: + { + const EMRCREATECOLORSPACE *lpCreateColorSpace = (const EMRCREATECOLORSPACE*)emr; + DWORD i; + if (emr->nSize < FIELD_OFFSET(EMRCREATECOLORSPACE, lcs.lcsFilename)) return FALSE; + for (i=0; i<MAX_PATH; i++) + { + if (emr->nSize < FIELD_OFFSET(EMRCREATECOLORSPACE, lcs.lcsFilename[i+1])) return FALSE; + if (!lpCreateColorSpace->lcs.lcsFilename[i]) break; + } + if (i == MAX_PATH) return FALSE; + break; + } + + case EMR_SETCOLORSPACE: + if (emr->nSize < sizeof(EMRSETCOLORSPACE)) return FALSE; + break; + case EMR_DELETECOLORSPACE: + if (emr->nSize < sizeof(EMRDELETECOLORSPACE)) return FALSE; + break; + case EMR_SETICMMODE: + if (emr->nSize < sizeof(EMRSETICMMODE)) return FALSE; + break; + case EMR_PIXELFORMAT: + if (emr->nSize < sizeof(EMRPIXELFORMAT)) return FALSE; + break; + case EMR_SETPALETTEENTRIES: + { + const EMRSETPALETTEENTRIES *lpSetPaletteEntries = (const EMRSETPALETTEENTRIES *)emr; + DWORD entries_ofs = FIELD_OFFSET(EMRSETPALETTEENTRIES, aPalEntries); + + if (emr->nSize < FIELD_OFFSET(EMRSETPALETTEENTRIES, aPalEntries) || + (lpSetPaletteEntries->cEntries * 4 / 4) != lpSetPaletteEntries->cEntries || + entries_ofs > entries_ofs + lpSetPaletteEntries->cEntries * 4 || + emr->nSize < entries_ofs + lpSetPaletteEntries->cEntries * 4) + return FALSE; + + break; + } + case EMR_RESIZEPALETTE: + if (emr->nSize < sizeof(EMRRESIZEPALETTE)) return FALSE; + break; + case EMR_CREATEDIBPATTERNBRUSHPT: + if (emr->nSize < sizeof(EMRCREATEDIBPATTERNBRUSHPT)) return FALSE; + /* FIXME: validate dib size */ + break; + case EMR_CREATEMONOBRUSH: + if (emr->nSize < sizeof(EMRCREATEMONOBRUSH)) return FALSE; + /* FIXME: validate dib size */ + break; + case EMR_BITBLT: + if (emr->nSize < sizeof(EMRBITBLT)) return FALSE; + /* FIXME: validate dib size */ + break; + case EMR_STRETCHBLT: + if (emr->nSize < sizeof(EMRSTRETCHBLT)) return FALSE; + /* FIXME: validate dib size */ + break; + case EMR_ALPHABLEND: + if (emr->nSize < sizeof(EMRALPHABLEND)) return FALSE; + /* FIXME: validate dib size */ + break; + case EMR_MASKBLT: + if (emr->nSize < sizeof(EMRMASKBLT)) return FALSE; + /* FIXME: validate dib size */ + break; + case EMR_PLGBLT: + { + const EMRPLGBLT *pPlgBlt = (const EMRPLGBLT *)emr; + if (emr->nSize < sizeof(EMRPLGBLT) || + pPlgBlt->offBmiSrc > pPlgBlt->offBmiSrc + pPlgBlt->cbBmiSrc || + emr->nSize < pPlgBlt->offBmiSrc + pPlgBlt->cbBmiSrc || + pPlgBlt->offBitsSrc > pPlgBlt->offBitsSrc + pPlgBlt->cbBitsSrc || + emr->nSize < pPlgBlt->offBitsSrc + pPlgBlt->cbBitsSrc || + pPlgBlt->offBmiMask > pPlgBlt->offBmiMask + pPlgBlt->cbBmiMask || + emr->nSize < pPlgBlt->offBmiMask + pPlgBlt->cbBmiMask || + pPlgBlt->offBitsMask > pPlgBlt->offBitsMask + pPlgBlt->cbBitsMask || + emr->nSize < pPlgBlt->offBitsMask + pPlgBlt->cbBitsMask) + return FALSE; + /* FIXME: validate dib size */ + break; + } + + case EMR_SETDIBITSTODEVICE: + { + const EMRSETDIBITSTODEVICE *pSetDIBitsToDevice = (const EMRSETDIBITSTODEVICE *)emr; + if (emr->nSize < sizeof(EMRSETDIBITSTODEVICE) || + pSetDIBitsToDevice->offBmiSrc > pSetDIBitsToDevice->offBmiSrc + pSetDIBitsToDevice->cbBmiSrc || + emr->nSize < pSetDIBitsToDevice->offBmiSrc + pSetDIBitsToDevice->cbBmiSrc || + pSetDIBitsToDevice->offBitsSrc > pSetDIBitsToDevice->offBitsSrc + pSetDIBitsToDevice->cbBitsSrc || + emr->nSize < pSetDIBitsToDevice->offBitsSrc + pSetDIBitsToDevice->cbBitsSrc) + return FALSE; + break; + } + + case EMR_POLYTEXTOUTA: + { + const EMRPOLYTEXTOUTA *pPolyTextOutA = (const EMRPOLYTEXTOUTA *)emr; + int ofs_text = FIELD_OFFSET(EMRPOLYTEXTOUTA, aemrtext); + DWORD i; + if (emr->nSize < ofs_text || + pPolyTextOutA->cStrings * sizeof(EMRTEXT) / sizeof(EMRTEXT) != pPolyTextOutA->cStrings || + ofs_text < ofs_text + pPolyTextOutA->cStrings * sizeof(EMRTEXT) || + emr->nSize < ofs_text + pPolyTextOutA->cStrings * sizeof(EMRTEXT)) + return FALSE; + for (i=0; i < pPolyTextOutA->cStrings; i++) + { + const EMRTEXT *text = &pPolyTextOutA->aemrtext[i]; + DWORD string_ofs, dx_ofs; + string_ofs = text->offString; + if (string_ofs > string_ofs + text->nChars || + emr->nSize < string_ofs + text->nChars) + return FALSE; + dx_ofs = text->offDx; + if (dx_ofs && ( + text->nChars * 4 / 4 != text->nChars || + dx_ofs > dx_ofs + text->nChars * 4 || + emr->nSize < dx_ofs + text->nChars * 4)) + return FALSE; + } + break; + } + + case EMR_POLYTEXTOUTW: + { + const EMRPOLYTEXTOUTW *pPolyTextOutW = (const EMRPOLYTEXTOUTW *)emr; + DWORD ofs_text = FIELD_OFFSET(EMRPOLYTEXTOUTW, aemrtext); + DWORD i; + if (emr->nSize < ofs_text || + pPolyTextOutW->cStrings * sizeof(EMRTEXT) / sizeof(EMRTEXT) != pPolyTextOutW->cStrings || + ofs_text < ofs_text + pPolyTextOutW->cStrings * sizeof(EMRTEXT) || + emr->nSize < ofs_text + pPolyTextOutW->cStrings * sizeof(EMRTEXT)) + return FALSE; + for (i=0; i < pPolyTextOutW->cStrings; i++) + { + const EMRTEXT *text = &pPolyTextOutW->aemrtext[i]; + DWORD string_ofs, dx_ofs; + string_ofs = text->offString; + if (text->nChars * 2 / 2 != text->nChars || + string_ofs > string_ofs + text->nChars * 2 || + emr->nSize < string_ofs + text->nChars * 2) + return FALSE; + dx_ofs = text->offDx; + if (dx_ofs && ( + text->nChars * 4 / 4 != text->nChars || + dx_ofs > dx_ofs + text->nChars * 4 || + emr->nSize < dx_ofs + text->nChars * 4)) + return FALSE; + } + break; + } + + case EMR_FILLRGN: + { + const EMRFILLRGN *pFillRgn = (const EMRFILLRGN *)emr; + DWORD ofs_data = FIELD_OFFSET(EMRFILLRGN, RgnData); + if (emr->nSize < ofs_data || + ofs_data > ofs_data + pFillRgn->cbRgnData || + emr->nSize < ofs_data + pFillRgn->cbRgnData) + return FALSE; + break; + } + + case EMR_FRAMERGN: + { + const EMRFRAMERGN *pFrameRgn = (const EMRFRAMERGN *)emr; + DWORD ofs_data = FIELD_OFFSET(EMRFRAMERGN, RgnData); + if (emr->nSize < ofs_data || + ofs_data > ofs_data + pFrameRgn->cbRgnData || + emr->nSize < ofs_data + pFrameRgn->cbRgnData) + return FALSE; + break; + } + + case EMR_INVERTRGN: + case EMR_PAINTRGN: + { + const EMRINVERTRGN *pInvertRgn = (const EMRINVERTRGN *)emr; + DWORD ofs_data = FIELD_OFFSET(EMRINVERTRGN, RgnData); + if (emr->nSize < ofs_data || + ofs_data > ofs_data + pInvertRgn->cbRgnData || + emr->nSize < ofs_data + pInvertRgn->cbRgnData) + return FALSE; + break; + } + + case EMR_SETTEXTJUSTIFICATION: + { + if (emr->nSize < sizeof(EMRSETTEXTJUSTIFICATION)) return FALSE; + break; + } + + case EMR_SETLAYOUT: + { + if (emr->nSize < sizeof(EMRSETLAYOUT)) return FALSE; + break; + } + + case EMR_GRADIENTFILL: + { + EMRGRADIENTFILL *grad = (EMRGRADIENTFILL *)emr; + DWORD vertex_ofs, mesh_item_size, mesh_ofs; + vertex_ofs = FIELD_OFFSET(EMRGRADIENTFILL, Ver); + if (emr->nSize < vertex_ofs) return FALSE; + + mesh_ofs = vertex_ofs + grad->nVer * sizeof(TRIVERTEX); + if (grad->nVer * sizeof(TRIVERTEX) / sizeof(TRIVERTEX) != grad->nVer || + vertex_ofs > mesh_ofs || + emr->nSize < mesh_ofs) + return FALSE; + + if (grad->ulMode == GRADIENT_FILL_TRIANGLE) + mesh_item_size = sizeof(GRADIENT_TRIANGLE); + else + mesh_item_size = sizeof(GRADIENT_RECT); + + if (grad->nTri * mesh_item_size / mesh_item_size != grad->nTri || + mesh_ofs > mesh_ofs + grad->nTri * mesh_item_size || + emr->nSize < mesh_ofs + grad->nTri * mesh_item_size) + return FALSE; + + break; + } + + default: + break; + } + + return TRUE; +} /***************************************************************************** * PlayEnhMetaFileRecord (GDI32.@) @@ -774,6 +1372,12 @@ BOOL WINAPI PlayEnhMetaFileRecord( hdc, handletable, mr, handles); if (!mr) return FALSE; + if (!emr_validate_size(mr)) + { + ERR("record has insufficient size\n"); + return FALSE; + } + type = mr->iType; TRACE("record %s\n", get_emr_name(type)); @@ -2478,6 +3082,12 @@ BOOL WINAPI EnumEnhMetaFile( break; } + if (!emr_validate_size(emr)) + { + ERR("record has insufficient size\n"); + break; + } + /* In Win9x mode we update the xform if the record will produce output */ if (hdc && IS_WIN9X() && emr_produces_output(emr->iType)) EMF_Update_MF_Xform(hdc, info); -- 2.14.1

2 1

[PATCH] version: Return ERROR_FILE_NOT_FOUND for Win 9X when a file was not found in GetFileVersionInfoSize.
by Alistair Leslie-Hughes 17 May '18

17 May '18

From: Michael Müller <michael(a)fds-team.de> Windows 9x doesnt have function GetFileVersionInfoSizeExA/W however is does have function GetFileVersionInfoSizeA/W. Since all the GetFileVersionInfoSize* functions go though GetFileVersionInfoSizeExW, this seems the best position for the code. Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/version/version.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/dlls/version/version.c b/dlls/version/version.c index 13436ca..f33361b 100644 --- a/dlls/version/version.c +++ b/dlls/version/version.c @@ -705,7 +705,12 @@ DWORD WINAPI GetFileVersionInfoSizeExW( DWORD flags, LPCWSTR filename, LPDWORD h return (len * 2) + 4; default: - SetLastError( lzfd == HFILE_ERROR ? ofs.nErrCode : ERROR_RESOURCE_DATA_NOT_FOUND ); + if (lzfd == HFILE_ERROR) + SetLastError(ofs.nErrCode); + else if (GetVersion() & 0x80000000) /* Windows 95/98 */ + SetLastError(ERROR_FILE_NOT_FOUND); + else + SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND); return 0; } } -- 1.9.1

1 0

[PATCH] shell32: Create Microsoft\Windows\Themes directory during Wineprefix creation.
by Alistair Leslie-Hughes 17 May '18

17 May '18

From: Sebastian Lackner <sebastian(a)fds-team.de> Fixes: https://bugs.winehq.org/show_bug.cgi?id=34910 Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/shell32/shellpath.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/dlls/shell32/shellpath.c b/dlls/shell32/shellpath.c index e14f533..bd07574 100644 --- a/dlls/shell32/shellpath.c +++ b/dlls/shell32/shellpath.c @@ -857,6 +857,7 @@ static const WCHAR Microsoft_Windows_Start_Menu_Admin_ToolsW[] = {'M','i','c','r static const WCHAR Microsoft_Windows_Start_Menu_StartupW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','S','t','a','r','t',' ','M','e','n','u','\\','P','r','o','g','r','a','m','s','\\','S','t','a','r','t','U','p','\0'}; static const WCHAR Microsoft_Windows_TemplatesW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','T','e','m','p','l','a','t','e','s',0}; static const WCHAR Microsoft_Windows_Temporary_Internet_FilesW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','T','e','m','p','o','r','a','r','y',' ','I','n','t','e','r','n','e','t',' ','F','i','l','e','s',0}; +static const WCHAR Microsoft_Windows_ThemesW[] = {'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\','T','h','e','m','e','s',0}; static const WCHAR MoviesW[] = {'M','o','v','i','e','s','\0'}; static const WCHAR MusicW[] = {'M','u','s','i','c','\0'}; static const WCHAR MusicLibraryW[] = {'M','u','s','i','c','L','i','b','r','a','r','y',0}; @@ -4267,6 +4268,7 @@ static HRESULT _SHRegisterUserShellFolders(BOOL bDefault) }; WCHAR userShellFolderPath[MAX_PATH], shellFolderPath[MAX_PATH]; LPCWSTR pUserShellFolderPath, pShellFolderPath; + WCHAR path[MAX_PATH]; HRESULT hr = S_OK; HKEY hRootKey; HANDLE hToken; @@ -4295,6 +4297,13 @@ static HRESULT _SHRegisterUserShellFolders(BOOL bDefault) hr = _SHRegisterFolders(hRootKey, hToken, pUserShellFolderPath, pShellFolderPath, folders, ARRAY_SIZE(folders)); + + if (SUCCEEDED(hr)) + { + hr = SHGetFolderPathAndSubDirW(0, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, + SHGFP_TYPE_DEFAULT, Microsoft_Windows_ThemesW, path); + } + TRACE("returning 0x%08x\n", hr); return hr; } -- 1.9.1

1 0

[PATCH] d2d1: Add d2d1_1.idl for drawing ID2D1Bitmap1
by Alistair Leslie-Hughes 17 May '18

17 May '18

From: Lucian Poston <lucian.poston(a)gmail.com> https://bugs.winehq.org/show_bug.cgi?id=44052 Signed-off-by: Lucian Poston <lucian.poston(a)gmail.com> Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- include/d2d1_1.idl | 523 ++++++++++++++++++++++++++++++++++++++++++++++++++++ include/dcommon.idl | 15 ++ 2 files changed, 538 insertions(+) diff --git a/include/d2d1_1.idl b/include/d2d1_1.idl index 1fbbb30..254b73e 100644 --- a/include/d2d1_1.idl +++ b/include/d2d1_1.idl @@ -17,7 +17,17 @@ */ import "d2d1.idl"; +import "dxgi.idl"; +interface IWICImagingFactory; +interface IWICColorContext; +interface IPrintDocumentPackageTarget; +interface ID2D1PrintControl; +interface ID2D1ColorContext; +interface ID2D1Bitmap1; +interface ID2D1CommandSink; +interface ID2D1Effect; +interface ID2D1ImageBrush; interface ID2D1Device; interface ID2D1StrokeStyle1; interface ID2D1PathGeometry1; @@ -50,6 +60,105 @@ typedef enum D2D1_UNIT_MODE D2D1_UNIT_MODE_FORCE_DWORD = 0xffffffff, } D2D1_UNIT_MODE; +typedef enum D2D1_DEVICE_CONTEXT_OPTIONS +{ + D2D1_DEVICE_CONTEXT_OPTIONS_NONE = 0, + D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTITHREADED_OPTIMIZATIONS = 1, + D2D1_DEVICE_CONTEXT_OPTIONS_FORCE_DWORD = 0xffffffff, +} D2D1_DEVICE_CONTEXT_OPTIONS; + +typedef enum D2D1_PRINT_FONT_SUBSET_MODE +{ + D2D1_PRINT_FONT_SUBSET_DEFAULT = 0, + D2D1_PRINT_FONT_SUBSET_EACHPAGE = 1, + D2D1_PRINT_FONT_SUBSET_NONE = 2, + D2D1_PRINT_FONT_SUBSET_FORCE_DWORD = 0xffffffff, +} D2D1_PRINT_FONT_SUBSET_MODE; + +typedef enum D2D1_COLOR_SPACE +{ + D2D1_COLOR_SPACE_CUSTOM = 0, + D2D1_COLOR_SPACE_SRGB = 1, + D2D1_COLOR_SPACE_SCRGB = 2, + D2D1_COLOR_SPACE_FORCE_DWORD = 0xffffffff, +} D2D1_COLOR_SPACE; + +typedef enum D2D1_BITMAP_OPTIONS +{ + D2D1_BITMAP_OPTIONS_NONE = 0, + D2D1_BITMAP_OPTIONS_TARGET = 1, + D2D1_BITMAP_OPTIONS_CANNOT_DRAW = 2, + D2D1_BITMAP_OPTIONS_CPU_READ = 4, + D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE = 8, + D2D1_BITMAP_OPTIONS_FORCE_DWORD = 0xffffffff, +} D2D1_BITMAP_OPTIONS; + +typedef enum D2D1_INTERPOLATION_MODE +{ + D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR = D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR, + D2D1_INTERPOLATION_MODE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR, + D2D1_INTERPOLATION_MODE_CUBIC = D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC, + D2D1_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR, + D2D1_INTERPOLATION_MODE_ANISOTROPIC = D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC, + D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC, + D2D1_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_INTERPOLATION_MODE; + +typedef enum D2D1_BUFFER_PRECISION +{ + D2D1_BUFFER_PRECISION_UNKNOWN = 0, + D2D1_BUFFER_PRECISION_8BPC_UNORM = 1, + D2D1_BUFFER_PRECISION_8BPC_UNORM_SRGB = 2, + D2D1_BUFFER_PRECISION_16BPC_UNORM = 3, + D2D1_BUFFER_PRECISION_16BPC_FLOAT = 4, + D2D1_BUFFER_PRECISION_32BPC_FLOAT = 5, + D2D1_BUFFER_PRECISION_FORCE_DWORD = 0xffffffff, +} D2D1_BUFFER_PRECISION; + +typedef enum D2D1_COLOR_INTERPOLATION_MODE +{ + D2D1_COLOR_INTERPOLATION_MODE_STRAIGHT = 0, + D2D1_COLOR_INTERPOLATION_MODE_PREMULTIPLIED = 1, + D2D1_COLOR_INTERPOLATION_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_COLOR_INTERPOLATION_MODE; + +typedef enum D2D1_COMPOSITE_MODE +{ + D2D1_COMPOSITE_MODE_SOURCE_OVER = 0, + D2D1_COMPOSITE_MODE_DESTINATION_OVER = 1, + D2D1_COMPOSITE_MODE_SOURCE_IN = 2, + D2D1_COMPOSITE_MODE_DESTINATION_IN = 3, + D2D1_COMPOSITE_MODE_SOURCE_OUT = 4, + D2D1_COMPOSITE_MODE_DESTINATION_OUT = 5, + D2D1_COMPOSITE_MODE_SOURCE_ATOP = 6, + D2D1_COMPOSITE_MODE_DESTINATION_ATOP = 7, + D2D1_COMPOSITE_MODE_XOR = 8, + D2D1_COMPOSITE_MODE_PLUS = 9, + D2D1_COMPOSITE_MODE_SOURCE_COPY = 10, + D2D1_COMPOSITE_MODE_BOUNDED_SOURCE_COPY = 11, + D2D1_COMPOSITE_MODE_MASK_INVERT = 12, + D2D1_COMPOSITE_MODE_FORCE_DWORD = 0xffffffff, +} D2D1_COMPOSITE_MODE; + +typedef enum D2D1_LAYER_OPTIONS1 +{ + D2D1_LAYER_OPTIONS1_NONE = 0, + D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND = 1, + D2D1_LAYER_OPTIONS1_IGNORE_ALPHA = 2, + D2D1_LAYER_OPTIONS1_FORCE_DWORD = 0xffffffff, +} D2D1_LAYER_OPTIONS1; + +typedef enum D2D1_MAP_OPTIONS +{ + D2D1_MAP_OPTIONS_NONE = 0, + D2D1_MAP_OPTIONS_READ = 1, + D2D1_MAP_OPTIONS_WRITE = 2, + D2D1_MAP_OPTIONS_DISCARD = 4, + D2D1_MAP_OPTIONS_FORCE_DWORD = 0xffffffff, +} D2D1_MAP_OPTIONS; + +typedef D2D_MATRIX_4X4_F D2D1_MATRIX_4X4_F; +typedef struct DWRITE_GLYPH_RUN_DESCRIPTION DWRITE_GLYPH_RUN_DESCRIPTION; typedef struct D2D1_PROPERTY_BINDING D2D1_PROPERTY_BINDING; typedef struct D2D1_STROKE_STYLE_PROPERTIES1 @@ -75,6 +184,76 @@ typedef struct D2D1_DRAWING_STATE_DESCRIPTION1 D2D1_UNIT_MODE unitMode; } D2D1_DRAWING_STATE_DESCRIPTION1; +typedef struct D2D1_MAPPED_RECT +{ + UINT32 pitch; + BYTE *bits; +} D2D1_MAPPED_RECT; + +typedef struct D2D1_LAYER_PARAMETERS1 +{ + D2D1_RECT_F contentBounds; + ID2D1Geometry *geometricMask; + D2D1_ANTIALIAS_MODE maskAntialiasMode; + D2D1_MATRIX_3X2_F maskTransform; + float opacity; + ID2D1Brush *opacityBrush; + D2D1_LAYER_OPTIONS1 layerOptions; +} D2D1_LAYER_PARAMETERS1; + +typedef struct D2D1_RENDERING_CONTROLS +{ + D2D1_BUFFER_PRECISION bufferPrecision; + D2D1_SIZE_U tileSize; +} D2D1_RENDERING_CONTROLS; + +typedef struct D2D1_EFFECT_INPUT_DESCRIPTION +{ + ID2D1Effect *effect; + UINT32 inputIndex; + D2D1_RECT_F inputRectangle; +} D2D1_EFFECT_INPUT_DESCRIPTION; + +typedef struct D2D1_IMAGE_BRUSH_PROPERTIES +{ + D2D1_RECT_F sourceRectangle; + D2D1_EXTEND_MODE extendModeX; + D2D1_EXTEND_MODE extendModeY; + D2D1_INTERPOLATION_MODE interpolationMode; +} D2D1_IMAGE_BRUSH_PROPERTIES; + +typedef struct D2D1_BITMAP_BRUSH_PROPERTIES1 +{ + D2D1_EXTEND_MODE extendModeX; + D2D1_EXTEND_MODE extendModeY; + D2D1_INTERPOLATION_MODE interpolationMode; +} D2D1_BITMAP_BRUSH_PROPERTIES1; + +typedef struct D2D1_BITMAP_PROPERTIES1 +{ + D2D1_PIXEL_FORMAT pixelFormat; + float dpiX; + float dpiY; + D2D1_BITMAP_OPTIONS bitmapOptions; + ID2D1ColorContext *colorContext; +} D2D1_BITMAP_PROPERTIES1; + +typedef struct D2D1_PRINT_CONTROL_PROPERTIES +{ + D2D1_PRINT_FONT_SUBSET_MODE fontSubset; + float rasterDPI; + D2D1_COLOR_SPACE colorSpace; +} D2D1_PRINT_CONTROL_PROPERTIES; + +typedef struct D2D1_POINT_DESCRIPTION +{ + D2D1_POINT_2F point; + D2D1_POINT_2F unitTangentVector; + UINT32 endSegment; + UINT32 endFigure; + float lengthToEndSegment; +} D2D1_POINT_DESCRIPTION; + typedef HRESULT (__stdcall *PD2D1_EFFECT_FACTORY)(IUnknown **effect); [ @@ -134,3 +313,347 @@ interface ID2D1Factory1 : ID2D1Factory [out] ID2D1Properties **props ); } + +[ + local, + object, + uuid(a898a84c-3873-4588-b08b-ebbf978df041) +] +interface ID2D1Bitmap1 : ID2D1Bitmap +{ + void GetColorContext( + [out] ID2D1ColorContext **color_context + ); + D2D1_BITMAP_OPTIONS GetOptions(); + HRESULT GetSurface( + [out] IDXGISurface **surface + ); + HRESULT Map( + [in] D2D1_MAP_OPTIONS options, + [out] D2D1_MAPPED_RECT *mapped_rect + ); + HRESULT Unmap(); +} + +[ + local, + object, + uuid(ae1572f4-5dd0-4777-998b-9279472ae63b) +] +interface ID2D1GradientStopCollection1 : ID2D1GradientStopCollection +{ + void GetGradientStops1( + [out] D2D1_GRADIENT_STOP *stops, + [in] UINT32 stop_count + ); + D2D1_COLOR_SPACE GetPreInterpolationSpace(); + D2D1_COLOR_SPACE GetPostInterpolationSpace(); + D2D1_BUFFER_PRECISION GetBufferPrecision(); + D2D1_COLOR_INTERPOLATION_MODE GetColorInterpolationMode(); +} + +[ + local, + object, + uuid(b4f34a19-2383-4d76-94f6-ec343657c3dc) +] +interface ID2D1CommandList : ID2D1Image +{ + HRESULT Stream( + [in] ID2D1CommandSink *sink + ); + HRESULT Close(); +} + +[ + local, + object, + uuid(41343a53-e41a-49a2-91cd-21793bbb62e5) +] +interface ID2D1BitmapBrush1 : ID2D1BitmapBrush +{ + void SetInterpolationMode1( + [in] D2D1_INTERPOLATION_MODE interpolation_mode + ); + D2D1_INTERPOLATION_MODE GetInterpolationMode1(); +} + +[ + local, + object, + uuid(1c4820bb-5771-4518-a581-2fe4dd0ec657) +] +interface ID2D1ColorContext : ID2D1Resource +{ + D2D1_COLOR_SPACE GetColorSpace(); + UINT32 GetProfileSize(); + HRESULT GetProfile( + [out] BYTE *profile, + [in] UINT32 size + ); +} + +[ + local, + object, + uuid(82237326-8111-4f7c-bcf4-b5c1175564fe) +] +interface ID2D1GdiMetafileSink : ID2D1Resource +{ + BOOL ProcessRecord( + [in] DWORD record_type, + [out] const void *data, + [in] DWORD data_size + ); +} + +[ + local, + object, + uuid(2f543dc3-cfc1-4211-864f-cfd91c6f3395) +] +interface ID2D1GdiMetafile : ID2D1Resource +{ + HRESULT Stream( + [in] ID2D1GdiMetafileSink *sink + ); + HRESULT GetBounds( + [out] D2D1_RECT_F *bounds + ); +} + +[ + local, + object, + uuid(10a72a66-e91c-43f4-993f-ddf4b82b0b4a) +] +interface ID2D1StrokeStyle1 : ID2D1StrokeStyle +{ + D2D1_STROKE_TRANSFORM_TYPE GetStrokeTransformType(); +} + +[ + local, + object, + uuid(62baa2d2-ab54-41b7-b872-787e0106a421) +] +interface ID2D1PathGeometry1 : ID2D1PathGeometry +{ + HRESULT ComputePointAndSegmentAtLength( + [in] float length, + [in] UINT32 start_segment, + [in] const D2D1_MATRIX_3X2_F *world_transform, + [in] float tolerance, + [out] D2D1_POINT_DESCRIPTION *desc + ); +} + +[ + local, + object, + uuid(689f1f85-c72e-4e33-8f19-85754efd5ace) +] +interface ID2D1DrawingStateBlock1 : ID2D1DrawingStateBlock +{ + void GetDescription( + [out] D2D1_DRAWING_STATE_DESCRIPTION1 *desc + ); + void SetDescription( + [in] const D2D1_DRAWING_STATE_DESCRIPTION1 *desc + ); +} + +[ + local, + object, + uuid(e8f7fe7a-191c-466d-ad95-975678bda998) +] +interface ID2D1DeviceContext : ID2D1RenderTarget +{ + HRESULT CreateBitmap( + [in] D2D1_SIZE_U size, + [in] const void *src_data, + [in] UINT32 pitch, + [in] const D2D1_BITMAP_PROPERTIES1 *desc, + [out] ID2D1Bitmap1 **bitmap + ); + HRESULT CreateBitmapFromWicBitmap( + [in] IWICBitmapSource *bitmap_source, + [in] const D2D1_BITMAP_PROPERTIES1 *desc, + [out] ID2D1Bitmap1 **bitmap + ); + HRESULT CreateColorContext( + [in] D2D1_COLOR_SPACE space, + [in] const BYTE *profile, + [in] UINT32 profile_size, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateColorContextFromFilename( + [in] const WCHAR *filename, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateColorContextFromWicColorContext( + [in] IWICColorContext *wic_color_context, + [out] ID2D1ColorContext **color_context + ); + HRESULT CreateBitmapFromDxgiSurface( + [in] IDXGISurface *surface, + [in] const D2D1_BITMAP_PROPERTIES1 *desc, + [out] ID2D1Bitmap1 **bitmap + ); + HRESULT CreateEffect( + [in] REFCLSID effect_id, + [out] ID2D1Effect **effect + ); + HRESULT CreateGradientStopCollection( + [in] const D2D1_GRADIENT_STOP *stops, + [in] UINT32 stop_count, + [in] D2D1_COLOR_SPACE preinterpolation_space, + [in] D2D1_COLOR_SPACE postinterpolation_space, + [in] D2D1_BUFFER_PRECISION buffer_precision, + [in] D2D1_EXTEND_MODE extend_mode, + [in] D2D1_COLOR_INTERPOLATION_MODE color_interpolation_mode, + [out] ID2D1GradientStopCollection1 **gradient + ); + HRESULT CreateImageBrush( + [in] ID2D1Image *image, + [in] const D2D1_IMAGE_BRUSH_PROPERTIES *image_brush_desc, + [in] const D2D1_BRUSH_PROPERTIES *brush_desc, + [out] ID2D1ImageBrush **brush + ); + HRESULT CreateBitmapBrush( + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_BITMAP_BRUSH_PROPERTIES1 *bitmap_brush_desc, + [in] const D2D1_BRUSH_PROPERTIES *brush_desc, + [out] ID2D1BitmapBrush1 **bitmap_brush + ); + HRESULT CreateCommandList( + [out] ID2D1CommandList **command_list + ); + BOOL IsDxgiFormatSupported( + [in] DXGI_FORMAT format + ); + BOOL IsBufferPrecisionSupported( + [in] D2D1_BUFFER_PRECISION buffer_precision + ); + void GetImageLocalBounds( + [in] ID2D1Image *image, + [out] D2D1_RECT_F *local_bounds + ); + HRESULT GetImageWorldBounds( + [in] ID2D1Image *image, + [out] D2D1_RECT_F *world_bounds + ); + HRESULT GetGlyphRunWorldBounds( + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in] DWRITE_MEASURING_MODE measuring_mode, + [out] D2D1_RECT_F *bounds + ); + void GetDevice( + [out] ID2D1Device **device + ); + void SetTarget( + [in] ID2D1Image *target + ); + void GetTarget( + [out] ID2D1Image **target + ); + void SetRenderingControls( + [in] const D2D1_RENDERING_CONTROLS *rendering_controls + ); + void GetRenderingControls( + [out] D2D1_RENDERING_CONTROLS *rendering_controls + ); + void SetPrimitiveBlend( + [in] D2D1_PRIMITIVE_BLEND primitive_blend + ); + D2D1_PRIMITIVE_BLEND GetPrimitiveBlend(); + void SetUnitMode( + [in] D2D1_UNIT_MODE unit_mode + ); + D2D1_UNIT_MODE GetUnitMode(); + void DrawGlyphRun( + [in] D2D1_POINT_2F baseline_origin, + [in] const DWRITE_GLYPH_RUN *glyph_run, + [in] const DWRITE_GLYPH_RUN_DESCRIPTION *glyph_run_desc, + [in] ID2D1Brush *brush, + [in] DWRITE_MEASURING_MODE measuring_mode + ); + void DrawImage( + [in] ID2D1Image *image, + [in] const D2D1_POINT_2F *target_offset, + [in] const D2D1_RECT_F *image_rect, + [in] D2D1_INTERPOLATION_MODE interpolation_mode, + [in] D2D1_COMPOSITE_MODE composite_mode + ); + void DrawGdiMetafile( + [in] ID2D1GdiMetafile *metafile, + [in] const D2D1_POINT_2F *target_offset + ); + void DrawBitmap( + [in] ID2D1Bitmap *bitmap, + [in] const D2D1_RECT_F *dst_rect, + [in] float opacity, + [in] D2D1_INTERPOLATION_MODE interpolation_mode, + [in] const D2D1_RECT_F *src_rect, + [in] const D2D1_MATRIX_4X4_F *perspective_transform + ); + void PushLayer( + [in] const D2D1_LAYER_PARAMETERS1 *layer_parameters, + [in] ID2D1Layer *layer + ); + HRESULT InvalidateEffectInputRectangle( + [in] ID2D1Effect *effect, + [in] UINT32 input, + [in] const D2D1_RECT_F *input_rect + ); + HRESULT GetEffectInvalidRectangleCount( + [in] ID2D1Effect *effect, + [out] UINT32 *rect_count + ); + HRESULT GetEffectInvalidRectangles( + [in] ID2D1Effect *effect, + [out] D2D1_RECT_F *rectangles, + [in] UINT32 rect_count + ); + HRESULT GetEffectRequiredInputRectangles( + [in] ID2D1Effect *effect, + [in] const D2D1_RECT_F *image_rect, + [in] const D2D1_EFFECT_INPUT_DESCRIPTION *desc, + [out] D2D1_RECT_F *input_rect, + [in] UINT32 input_count + ); + void FillOpacityMask( + [in] ID2D1Bitmap *mask, + [in] ID2D1Brush *brush, + [in] const D2D1_RECT_F *dst_rect, + [in] const D2D1_RECT_F *src_rect + ); +} + +[ + local, + object, + uuid(47dd575d-ac05-4cdd-8049-9b02cd16f44c) +] +interface ID2D1Device : ID2D1Resource +{ + HRESULT CreateDeviceContext( + [in] D2D1_DEVICE_CONTEXT_OPTIONS options, + [out] ID2D1DeviceContext **context + ); + HRESULT CreatePrintControl( + [in] IWICImagingFactory *wic_factory, + [in] IPrintDocumentPackageTarget *document_target, + [in] const D2D1_PRINT_CONTROL_PROPERTIES *desc, + [out] ID2D1PrintControl **print_control + ); + void SetMaximumTextureMemory( + [in] UINT64 max_texture_memory + ); + UINT64 GetMaximumTextureMemory(); + HRESULT ClearResources( + [in, defaultvalue(0)] UINT msec_since_use + ); +} diff --git a/include/dcommon.idl b/include/dcommon.idl index db5055d..18f2fbe 100644 --- a/include/dcommon.idl +++ b/include/dcommon.idl @@ -61,3 +61,18 @@ typedef struct D2D_SIZE_U UINT32 width; UINT32 height; } D2D_SIZE_U, D2D1_SIZE_U; + +typedef struct D2D_MATRIX_4X4_F +{ + union + { + struct + { + float _11, _12, _13, _14; + float _21, _22, _23, _24; + float _31, _32, _33, _34; + float _41, _42, _43, _44; + }; + float m[4][4]; + }; +} D2D_MATRIX_4X4_F; -- 1.9.1

1 0

[resend PATCH 1/3] comctl32/taskdialog: Return TRUE when message is handled.
by Nikolay Sivov 16 May '18

16 May '18

From: Zhiyi Zhang <yi.gd.cn(a)gmail.com> Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/comctl32/taskdialog.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/dlls/comctl32/taskdialog.c b/dlls/comctl32/taskdialog.c index 1ab9e133da..4db487957c 100644 --- a/dlls/comctl32/taskdialog.c +++ b/dlls/comctl32/taskdialog.c @@ -558,15 +558,17 @@ static INT_PTR CALLBACK taskdialog_proc(HWND hwnd, UINT msg, WPARAM wParam, LPAR if (HIWORD(wParam) == BN_CLICKED) { taskdialog_on_button_click(dialog_info, LOWORD(wParam)); - return TRUE; + break; } - break; + return FALSE; case WM_DESTROY: taskdialog_notify(dialog_info, TDN_DESTROYED, 0, 0); RemovePropW(hwnd, taskdialog_info_propnameW); break; + default: + return FALSE; } - return FALSE; + return TRUE; } /*********************************************************************** -- 2.17.0

1 2

[PATCH] mp3dmod: Register DMO.
by Zebediah Figura 16 May '18

16 May '18

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/mp3dmod/mp3dmod.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/dlls/mp3dmod/mp3dmod.c b/dlls/mp3dmod/mp3dmod.c index fa1cce5..4949780 100644 --- a/dlls/mp3dmod/mp3dmod.c +++ b/dlls/mp3dmod/mp3dmod.c @@ -33,6 +33,11 @@ #include "wine/debug.h" #include "wine/heap.h" +#include "initguid.h" +DEFINE_GUID(WMMEDIATYPE_Audio, 0x73647561,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71); +DEFINE_GUID(WMMEDIASUBTYPE_MP3,0x00000055,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71); +DEFINE_GUID(WMMEDIASUBTYPE_PCM,0x00000001,0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71); + WINE_DEFAULT_DEBUG_CHANNEL(mp3dmod); static HINSTANCE mp3dmod_instance; @@ -526,6 +531,18 @@ HRESULT WINAPI DllCanUnloadNow(void) */ HRESULT WINAPI DllRegisterServer(void) { + static const WCHAR nameW[] = {'M','P','3',' ','D','e','c','o','d','e','r',' ','D','M','O',0}; + DMO_PARTIAL_MEDIATYPE in, out; + HRESULT hr; + + in.type = WMMEDIATYPE_Audio; + in.subtype = WMMEDIASUBTYPE_MP3; + out.type = WMMEDIATYPE_Audio; + out.subtype = WMMEDIASUBTYPE_PCM; + hr = DMORegister(nameW, &CLSID_CMP3DecMediaObject, &DMOCATEGORY_AUDIO_DECODER, + 0, 1, &in, 1, &out); + if (FAILED(hr)) return hr; + return __wine_register_resources( mp3dmod_instance ); } @@ -534,5 +551,10 @@ HRESULT WINAPI DllRegisterServer(void) */ HRESULT WINAPI DllUnregisterServer(void) { + HRESULT hr; + + hr = DMOUnregister(&CLSID_CMP3DecMediaObject, &DMOCATEGORY_AUDIO_DECODER); + if (FAILED(hr)) return hr; + return __wine_unregister_resources( mp3dmod_instance ); } -- 2.7.4

1 0