- wine-devel - winehq.org

[PATCH resend 1/4] iphlpapi: Implement asynchronous events for IcmpSendEcho2(Ex).
by Gabriel Ivăncescu 15 Jun '21

15 Jun '21

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/iphlpapi/icmp.c | 108 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 100 insertions(+), 8 deletions(-) diff --git a/dlls/iphlpapi/icmp.c b/dlls/iphlpapi/icmp.c index 8ef0321..ceeab69 100644 --- a/dlls/iphlpapi/icmp.c +++ b/dlls/iphlpapi/icmp.c @@ -106,9 +106,42 @@ WINE_DECLARE_DEBUG_CHANNEL(winediag); typedef struct { int sid; + LONG lock_count; + HANDLE lock_event; IP_OPTION_INFORMATION default_opts; } icmp_t; +static void icmp_lock(icmp_t *icp) +{ + InterlockedIncrement(&icp->lock_count); +} + +static void icmp_unlock(icmp_t *icp) +{ + if (InterlockedDecrement(&icp->lock_count) == 0x80000000) + { + if (icp->lock_event) + SetEvent(icp->lock_event); + } +} + +static void icmp_wait_for_released_locks(icmp_t *icp) +{ + HANDLE event = CreateEventW(NULL, TRUE, FALSE, NULL); + + icp->lock_event = event; + if (InterlockedExchangeAdd(&icp->lock_count, 0x80000000) != 0) + { + do + { + if (event) WaitForSingleObjectEx(event, INFINITE, TRUE); + else SleepEx(1, TRUE); + } + while (icp->lock_count != 0x80000000); + } + if (event) CloseHandle(event); +} + #define IP_OPTS_UNKNOWN 0 #define IP_OPTS_DEFAULT 1 #define IP_OPTS_CUSTOM 2 @@ -347,6 +380,30 @@ done: return res; } +struct icmp_get_reply_async_ctx +{ + icmp_t *icp; + HANDLE event; + unsigned char *buffer; + void *reply_buf; + DWORD reply_size; + DWORD send_time; + DWORD timeout; +}; + +static DWORD WINAPI icmp_get_reply_async_func(VOID *parameter) +{ + struct icmp_get_reply_async_ctx *ctx = parameter; + + icmp_get_reply(ctx->icp->sid, ctx->buffer, ctx->send_time, ctx->reply_buf, ctx->reply_size, ctx->timeout); + + SetEvent(ctx->event); + + icmp_unlock(ctx->icp); + HeapFree(GetProcessHeap(), 0, ctx); + return 0; +} + /* @@ -381,6 +438,7 @@ HANDLE WINAPI Icmp6CreateFile(VOID) } icp->sid=sid; icp->default_opts.OptionsSize=IP_OPTS_UNKNOWN; + icp->lock_count=0; return (HANDLE)icp; } @@ -439,6 +497,7 @@ HANDLE WINAPI IcmpCreateFile(VOID) } icp->sid=sid; icp->default_opts.OptionsSize=IP_OPTS_UNKNOWN; + icp->lock_count=0; return (HANDLE)icp; } @@ -455,6 +514,9 @@ BOOL WINAPI IcmpCloseHandle(HANDLE IcmpHandle) return FALSE; } + /* Windows waits until all outstanding async requests are complete or timed out */ + icmp_wait_for_released_locks(icp); + close( icp->sid ); HeapFree(GetProcessHeap (), 0, icp); return TRUE; @@ -526,6 +588,7 @@ DWORD WINAPI IcmpSendEcho2Ex( unsigned char *buffer; int reqsize, repsize; DWORD send_time; + DWORD res = 0; TRACE("(%p, %p, %p, %p, %08x, %08x, %p, %d, %p, %p, %d, %d)\n", IcmpHandle, Event, ApcRoutine, ApcContext, SourceAddress, DestinationAddress, RequestData, @@ -553,11 +616,6 @@ DWORD WINAPI IcmpSendEcho2Ex( return 0; } - if (Event) - { - FIXME("unsupported for events\n"); - return 0; - } if (ApcRoutine) { FIXME("unsupported for APCs\n"); @@ -569,6 +627,8 @@ DWORD WINAPI IcmpSendEcho2Ex( return 0; } + icmp_lock(icp); + /* Prepare the request */ id=getpid() & 0xFFFF; seq=InterlockedIncrement(&icmp_sequence) & 0xFFFF; @@ -580,7 +640,7 @@ DWORD WINAPI IcmpSendEcho2Ex( buffer = HeapAlloc(GetProcessHeap(), 0, max( repsize, reqsize )); if (buffer == NULL) { SetLastError(ERROR_OUTOFMEMORY); - return 0; + goto done; } icmp_header=(struct icmp*)buffer; @@ -661,10 +721,42 @@ DWORD WINAPI IcmpSendEcho2Ex( } } HeapFree(GetProcessHeap(), 0, buffer); - return 0; + goto done; } - return icmp_get_reply(icp->sid, buffer, send_time, ReplyBuffer, ReplySize, Timeout); + if (Event) + { + struct icmp_get_reply_async_ctx *ctx = HeapAlloc(GetProcessHeap(), 0, sizeof(*ctx)); + + if (ctx) + { + ctx->icp = icp; + ctx->event = Event; + ctx->buffer = buffer; + ctx->reply_buf = ReplyBuffer; + ctx->reply_size = ReplySize; + ctx->send_time = send_time; + ctx->timeout = Timeout; + if (QueueUserWorkItem(icmp_get_reply_async_func, ctx, WT_EXECUTEDEFAULT | WT_EXECUTELONGFUNCTION)) + { + SetLastError(ERROR_IO_PENDING); + return 0; + } + + HeapFree(GetProcessHeap(), 0, ctx); + } + else + SetLastError(ERROR_OUTOFMEMORY); + + HeapFree(GetProcessHeap(), 0, buffer); + goto done; + } + + res = icmp_get_reply(icp->sid, buffer, send_time, ReplyBuffer, ReplySize, Timeout); + +done: + icmp_unlock(icp); + return res; } /* -- 2.31.1

1 3

[PATCH] win32u: Add stub DLL.
by Jacek Caban 15 Jun '21

15 Jun '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/win32u/Makefile.in | 1 + dlls/win32u/win32u.spec | 1317 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 1318 insertions(+) create mode 100644 dlls/win32u/Makefile.in create mode 100644 dlls/win32u/win32u.spec

1 0

[PATCH 1/4] jscript: Parse 'let' and 'const' variable declarations.
by Paul Gofman 15 Jun '21

15 Jun '21

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- dlls/jscript/compile.c | 5 +++++ dlls/jscript/lex.c | 2 ++ dlls/jscript/parser.h | 1 + dlls/jscript/parser.y | 29 ++++++++++++++++++++++++----- dlls/jscript/tests/lang.js | 25 +++++++++++++++++++++++++ dlls/mshtml/tests/es5.js | 17 +++++++++++++++++ 6 files changed, 74 insertions(+), 5 deletions(-) diff --git a/dlls/jscript/compile.c b/dlls/jscript/compile.c index 9bb9ff13d14..2a17639641f 100644 --- a/dlls/jscript/compile.c +++ b/dlls/jscript/compile.c @@ -1138,6 +1138,11 @@ static HRESULT compile_variable_list(compiler_ctx_t *ctx, variable_declaration_t if(!iter->expr) continue; + if (iter->block_scope) + FIXME("Block scope variables are not supported.\n"); + if (iter->constant) + FIXME("Constant variables are not supported.\n"); + hres = emit_identifier_ref(ctx, iter->identifier, 0); if(FAILED(hres)) return hres; diff --git a/dlls/jscript/lex.c b/dlls/jscript/lex.c index efed1038a95..3dd609885e6 100644 --- a/dlls/jscript/lex.c +++ b/dlls/jscript/lex.c @@ -41,6 +41,7 @@ static const struct { {L"break", kBREAK, TRUE}, {L"case", kCASE}, {L"catch", kCATCH}, + {L"const", kCONST, FALSE}, {L"continue", kCONTINUE, TRUE}, {L"default", kDEFAULT}, {L"delete", kDELETE}, @@ -54,6 +55,7 @@ static const struct { {L"if", kIF}, {L"in", kIN}, {L"instanceof", kINSTANCEOF}, + {L"let", kLET, FALSE, SCRIPTLANGUAGEVERSION_ES5}, {L"new", kNEW}, {L"null", kNULL}, {L"return", kRETURN, TRUE}, diff --git a/dlls/jscript/parser.h b/dlls/jscript/parser.h index b88a52af242..c4dd0752ee9 100644 --- a/dlls/jscript/parser.h +++ b/dlls/jscript/parser.h @@ -95,6 +95,7 @@ literal_t *new_boolean_literal(parser_ctx_t*,BOOL) DECLSPEC_HIDDEN; typedef struct _variable_declaration_t { const WCHAR *identifier; + BOOL block_scope, constant; expression_t *expr; struct _variable_declaration_t *next; diff --git a/dlls/jscript/parser.y b/dlls/jscript/parser.y index f11119143b8..7d0630582e0 100644 --- a/dlls/jscript/parser.y +++ b/dlls/jscript/parser.y @@ -87,7 +87,7 @@ static variable_list_t *variable_list_add(parser_ctx_t*,variable_list_t*,variabl static void *new_statement(parser_ctx_t*,statement_type_t,size_t,unsigned); static statement_t *new_block_statement(parser_ctx_t*,unsigned,statement_list_t*); -static statement_t *new_var_statement(parser_ctx_t*,unsigned,variable_list_t*); +static statement_t *new_var_statement(parser_ctx_t*,BOOL,BOOL,unsigned,variable_list_t*); static statement_t *new_expression_statement(parser_ctx_t*,unsigned,expression_t*); static statement_t *new_if_statement(parser_ctx_t*,unsigned,expression_t*,statement_t*,statement_t*); static statement_t *new_while_statement(parser_ctx_t*,unsigned,BOOL,expression_t*,statement_t*); @@ -168,8 +168,9 @@ static source_elements_t *source_elements_add_statement(source_elements_t*,state } /* keywords */ -%token <identifier> kBREAK kCASE kCATCH kCONTINUE kDEFAULT kDELETE kDO kELSE kFUNCTION kIF kFINALLY kFOR kGET kIN kSET -%token <identifier> kINSTANCEOF kNEW kNULL kRETURN kSWITCH kTHIS kTHROW kTRUE kFALSE kTRY kTYPEOF kVAR kVOID kWHILE kWITH +%token <identifier> kBREAK kCASE kCATCH kCONST kCONTINUE kDEFAULT kDELETE kDO kELSE kFUNCTION kIF kFINALLY kFOR +%token <identifier> kGET kIN kLET kSET kINSTANCEOF kNEW kNULL kRETURN kSWITCH kTHIS kTHROW kTRUE kFALSE +%token <identifier> kTRY kTYPEOF kVAR kVOID kWHILE kWITH %token tANDAND tOROR tINC tDEC tHTMLCOMMENT kDIVEQ kDCOL /* tokens */ @@ -182,6 +183,7 @@ static source_elements_t *source_elements_add_statement(source_elements_t*,state %type <source_elements> FunctionBody %type <statement> Statement %type <statement> Block +%type <statement> LexicalDeclaration %type <statement> VariableStatement %type <statement> EmptyStatement %type <statement> ExpressionStatement @@ -291,6 +293,7 @@ FormalParameterList_opt /* ECMA-262 3rd Edition 12 */ Statement : Block { $$ = $1; } + | LexicalDeclaration { $$ = $1; } | VariableStatement { $$ = $1; } | EmptyStatement { $$ = $1; } | FunctionExpression { $$ = new_expression_statement(ctx, @$, $1); } @@ -322,10 +325,17 @@ Block : '{' StatementList '}' { $$ = new_block_statement(ctx, @2, $2); } | '{' '}' { $$ = new_block_statement(ctx, @$, NULL); } +/* ECMA-262 10th Edition 13.3.1, TODO: BindingList*/ +LexicalDeclaration + : kLET VariableDeclarationList semicolon_opt + { $$ = new_var_statement(ctx, TRUE, FALSE, @$, $2); } + | kCONST VariableDeclarationList semicolon_opt + { $$ = new_var_statement(ctx, TRUE, TRUE, @$, $2); } + /* ECMA-262 3rd Edition 12.2 */ VariableStatement : kVAR VariableDeclarationList semicolon_opt - { $$ = new_var_statement(ctx, @$, $2); } + { $$ = new_var_statement(ctx, FALSE, FALSE, @$, $2); } /* ECMA-262 3rd Edition 12.2 */ VariableDeclarationList @@ -834,6 +844,7 @@ ReservedAsIdentifier : kBREAK { $$ = $1; } | kCASE { $$ = $1; } | kCATCH { $$ = $1; } + | kCONST { $$ = $1; } | kCONTINUE { $$ = $1; } | kDEFAULT { $$ = $1; } | kDELETE { $$ = $1; } @@ -847,6 +858,7 @@ ReservedAsIdentifier | kIF { $$ = $1; } | kIN { $$ = $1; } | kINSTANCEOF { $$ = $1; } + | kLET { $$ = $1; } | kNEW { $$ = $1; } | kNULL { $$ = $1; } | kRETURN { $$ = $1; } @@ -1144,8 +1156,10 @@ static variable_list_t *variable_list_add(parser_ctx_t *ctx, variable_list_t *li return list; } -static statement_t *new_var_statement(parser_ctx_t *ctx, unsigned loc, variable_list_t *variable_list) +static statement_t *new_var_statement(parser_ctx_t *ctx, BOOL block_scope, BOOL constant, unsigned loc, + variable_list_t *variable_list) { + variable_declaration_t *var; var_statement_t *ret; ret = new_statement(ctx, STAT_VAR, sizeof(*ret), loc); @@ -1153,6 +1167,11 @@ static statement_t *new_var_statement(parser_ctx_t *ctx, unsigned loc, variable_ return NULL; ret->variable_list = variable_list->head; + for (var = ret->variable_list; var; var = var->next) + { + var->block_scope = block_scope; + var->constant = constant; + } return &ret->stat; } diff --git a/dlls/jscript/tests/lang.js b/dlls/jscript/tests/lang.js index 9e6e6ad239f..2028d233ccf 100644 --- a/dlls/jscript/tests/lang.js +++ b/dlls/jscript/tests/lang.js @@ -2030,3 +2030,28 @@ Math = 6; ok(Math === 6, "NaN !== 6"); reportSuccess(); + +function test_es5_keywords() { + var let = 1 + var tmp + ok(let == 1, "let != 1"); + + tmp = false + try { + eval('var var = 1;'); + } + catch(e) { + tmp = true + } + ok(tmp === true, "Expected exception for 'var var = 1;'"); + + tmp = false + try { + eval('var const = 1;'); + } + catch(e) { + tmp = true + } + ok(tmp === true, "Expected exception for 'var const = 1;'"); +} +test_es5_keywords(); diff --git a/dlls/mshtml/tests/es5.js b/dlls/mshtml/tests/es5.js index 7e46848d40e..24906de5231 100644 --- a/dlls/mshtml/tests/es5.js +++ b/dlls/mshtml/tests/es5.js @@ -1207,3 +1207,20 @@ sync_test("head_setter", function() { document.head = ""; ok(typeof(document.head) === "object", "typeof(document.head) = " + typeof(document.head)); }); + + +sync_test("declaration_let", function() { + ok(a === undefined, "a is not undefined"); + var a = 3; + + { + let a = 2; + + ok(a == 2, "a != 2"); + + a = 4; + ok(a == 4, "a != 4"); + } + + todo_wine.ok(a == 3, "a != 3"); +}); -- 2.31.1

3 11

[PATCH 1/4] mf: Move presentation clock implementation to a separate file.
by Nikolay Sivov 15 Jun '21

15 Jun '21

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mf/Makefile.in | 1 + dlls/mf/clock.c | 1162 +++++++++++++++++++++++++++++++++++++++++++ dlls/mf/session.c | 1135 ------------------------------------------ 3 files changed, 1163 insertions(+), 1135 deletions(-) create mode 100644 dlls/mf/clock.c diff --git a/dlls/mf/Makefile.in b/dlls/mf/Makefile.in index e56d4c04a84..e80883fb642 100644 --- a/dlls/mf/Makefile.in +++ b/dlls/mf/Makefile.in @@ -6,6 +6,7 @@ DELAYIMPORTS = evr user32 EXTRADLLFLAGS = -mno-cygwin -Wb,--prefer-native C_SRCS = \ + clock.c \ copier.c \ evr.c \ main.c \ diff --git a/dlls/mf/clock.c b/dlls/mf/clock.c new file mode 100644 index 00000000000..a9ca9b4528b --- /dev/null +++ b/dlls/mf/clock.c @@ -0,0 +1,1162 @@ +/* + * Copyright 2017 Nikolay Sivov + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#define COBJMACROS + +#include "wine/debug.h" +#include "wine/heap.h" +#include "wine/list.h" + +#include "mf_private.h" + +WINE_DEFAULT_DEBUG_CHANNEL(mfplat); + +struct clock_sink +{ + struct list entry; + IMFClockStateSink *state_sink; +}; + +enum clock_command +{ + CLOCK_CMD_START = 0, + CLOCK_CMD_STOP, + CLOCK_CMD_PAUSE, + CLOCK_CMD_SET_RATE, + CLOCK_CMD_MAX, +}; + +enum clock_notification +{ + CLOCK_NOTIFY_START, + CLOCK_NOTIFY_STOP, + CLOCK_NOTIFY_PAUSE, + CLOCK_NOTIFY_RESTART, + CLOCK_NOTIFY_SET_RATE, +}; + +struct clock_state_change_param +{ + union + { + LONGLONG offset; + float rate; + } u; +}; + +struct sink_notification +{ + IUnknown IUnknown_iface; + LONG refcount; + MFTIME system_time; + struct clock_state_change_param param; + enum clock_notification notification; + IMFClockStateSink *sink; +}; + +struct clock_timer +{ + IUnknown IUnknown_iface; + LONG refcount; + IMFAsyncResult *result; + IMFAsyncCallback *callback; + MFWORKITEM_KEY key; + struct list entry; +}; + +struct presentation_clock +{ + IMFPresentationClock IMFPresentationClock_iface; + IMFRateControl IMFRateControl_iface; + IMFTimer IMFTimer_iface; + IMFShutdown IMFShutdown_iface; + IMFAsyncCallback sink_callback; + IMFAsyncCallback timer_callback; + LONG refcount; + IMFPresentationTimeSource *time_source; + IMFClockStateSink *time_source_sink; + MFCLOCK_STATE state; + LONGLONG start_offset; + struct list sinks; + struct list timers; + float rate; + LONGLONG frequency; + CRITICAL_SECTION cs; + BOOL is_shut_down; +}; + +static struct presentation_clock *impl_from_IMFPresentationClock(IMFPresentationClock *iface) +{ + return CONTAINING_RECORD(iface, struct presentation_clock, IMFPresentationClock_iface); +} + +static struct presentation_clock *impl_from_IMFRateControl(IMFRateControl *iface) +{ + return CONTAINING_RECORD(iface, struct presentation_clock, IMFRateControl_iface); +} + +static struct presentation_clock *impl_from_IMFTimer(IMFTimer *iface) +{ + return CONTAINING_RECORD(iface, struct presentation_clock, IMFTimer_iface); +} + +static struct presentation_clock *impl_from_IMFShutdown(IMFShutdown *iface) +{ + return CONTAINING_RECORD(iface, struct presentation_clock, IMFShutdown_iface); +} + +static struct presentation_clock *impl_from_sink_callback_IMFAsyncCallback(IMFAsyncCallback *iface) +{ + return CONTAINING_RECORD(iface, struct presentation_clock, sink_callback); +} + +static struct presentation_clock *impl_from_timer_callback_IMFAsyncCallback(IMFAsyncCallback *iface) +{ + return CONTAINING_RECORD(iface, struct presentation_clock, timer_callback); +} + +static struct clock_timer *impl_clock_timer_from_IUnknown(IUnknown *iface) +{ + return CONTAINING_RECORD(iface, struct clock_timer, IUnknown_iface); +} + +static struct sink_notification *impl_sink_notification_from_IUnknown(IUnknown *iface) +{ + return CONTAINING_RECORD(iface, struct sink_notification, IUnknown_iface); +} + +static HRESULT WINAPI sink_notification_QueryInterface(IUnknown *iface, REFIID riid, void **out) +{ + if (IsEqualIID(riid, &IID_IUnknown)) + { + *out = iface; + IUnknown_AddRef(iface); + return S_OK; + } + + WARN("Unsupported %s.\n", debugstr_guid(riid)); + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI sink_notification_AddRef(IUnknown *iface) +{ + struct sink_notification *notification = impl_sink_notification_from_IUnknown(iface); + ULONG refcount = InterlockedIncrement(&notification->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI sink_notification_Release(IUnknown *iface) +{ + struct sink_notification *notification = impl_sink_notification_from_IUnknown(iface); + ULONG refcount = InterlockedDecrement(&notification->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + if (!refcount) + { + IMFClockStateSink_Release(notification->sink); + heap_free(notification); + } + + return refcount; +} + +static const IUnknownVtbl sinknotificationvtbl = +{ + sink_notification_QueryInterface, + sink_notification_AddRef, + sink_notification_Release, +}; + +static void clock_notify_async_sink(struct presentation_clock *clock, MFTIME system_time, + struct clock_state_change_param param, enum clock_notification notification, IMFClockStateSink *sink) +{ + struct sink_notification *object; + IMFAsyncResult *result; + HRESULT hr; + + object = heap_alloc(sizeof(*object)); + if (!object) + return; + + object->IUnknown_iface.lpVtbl = &sinknotificationvtbl; + object->refcount = 1; + object->system_time = system_time; + object->param = param; + object->notification = notification; + object->sink = sink; + IMFClockStateSink_AddRef(object->sink); + + hr = MFCreateAsyncResult(&object->IUnknown_iface, &clock->sink_callback, NULL, &result); + IUnknown_Release(&object->IUnknown_iface); + if (SUCCEEDED(hr)) + { + MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_STANDARD, result); + IMFAsyncResult_Release(result); + } +} + +static HRESULT WINAPI present_clock_QueryInterface(IMFPresentationClock *iface, REFIID riid, void **out) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + + TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out); + + if (IsEqualIID(riid, &IID_IMFPresentationClock) || + IsEqualIID(riid, &IID_IMFClock) || + IsEqualIID(riid, &IID_IUnknown)) + { + *out = &clock->IMFPresentationClock_iface; + } + else if (IsEqualIID(riid, &IID_IMFRateControl)) + { + *out = &clock->IMFRateControl_iface; + } + else if (IsEqualIID(riid, &IID_IMFTimer)) + { + *out = &clock->IMFTimer_iface; + } + else if (IsEqualIID(riid, &IID_IMFShutdown)) + { + *out = &clock->IMFShutdown_iface; + } + else + { + WARN("Unsupported %s.\n", debugstr_guid(riid)); + *out = NULL; + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown *)*out); + return S_OK; +} + +static ULONG WINAPI present_clock_AddRef(IMFPresentationClock *iface) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + ULONG refcount = InterlockedIncrement(&clock->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI present_clock_Release(IMFPresentationClock *iface) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + ULONG refcount = InterlockedDecrement(&clock->refcount); + struct clock_timer *timer, *timer2; + struct clock_sink *sink, *sink2; + + TRACE("%p, refcount %u.\n", iface, refcount); + + if (!refcount) + { + if (clock->time_source) + IMFPresentationTimeSource_Release(clock->time_source); + if (clock->time_source_sink) + IMFClockStateSink_Release(clock->time_source_sink); + LIST_FOR_EACH_ENTRY_SAFE(sink, sink2, &clock->sinks, struct clock_sink, entry) + { + list_remove(&sink->entry); + IMFClockStateSink_Release(sink->state_sink); + heap_free(sink); + } + LIST_FOR_EACH_ENTRY_SAFE(timer, timer2, &clock->timers, struct clock_timer, entry) + { + list_remove(&timer->entry); + IUnknown_Release(&timer->IUnknown_iface); + } + DeleteCriticalSection(&clock->cs); + heap_free(clock); + } + + return refcount; +} + +static HRESULT WINAPI present_clock_GetClockCharacteristics(IMFPresentationClock *iface, DWORD *flags) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE; + + TRACE("%p, %p.\n", iface, flags); + + EnterCriticalSection(&clock->cs); + if (clock->time_source) + hr = IMFPresentationTimeSource_GetClockCharacteristics(clock->time_source, flags); + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static HRESULT WINAPI present_clock_GetCorrelatedTime(IMFPresentationClock *iface, DWORD reserved, + LONGLONG *clock_time, MFTIME *system_time) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE; + + TRACE("%p, %#x, %p, %p.\n", iface, reserved, clock_time, system_time); + + EnterCriticalSection(&clock->cs); + if (clock->time_source) + hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, reserved, clock_time, system_time); + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static HRESULT WINAPI present_clock_GetContinuityKey(IMFPresentationClock *iface, DWORD *key) +{ + TRACE("%p, %p.\n", iface, key); + + *key = 0; + + return S_OK; +} + +static HRESULT WINAPI present_clock_GetState(IMFPresentationClock *iface, DWORD reserved, MFCLOCK_STATE *state) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + + TRACE("%p, %#x, %p.\n", iface, reserved, state); + + EnterCriticalSection(&clock->cs); + *state = clock->state; + LeaveCriticalSection(&clock->cs); + + return S_OK; +} + +static HRESULT WINAPI present_clock_GetProperties(IMFPresentationClock *iface, MFCLOCK_PROPERTIES *props) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE; + + TRACE("%p, %p.\n", iface, props); + + EnterCriticalSection(&clock->cs); + if (clock->time_source) + hr = IMFPresentationTimeSource_GetProperties(clock->time_source, props); + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static HRESULT WINAPI present_clock_SetTimeSource(IMFPresentationClock *iface, + IMFPresentationTimeSource *time_source) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + MFCLOCK_PROPERTIES props; + IMFClock *source_clock; + HRESULT hr; + + TRACE("%p, %p.\n", iface, time_source); + + EnterCriticalSection(&clock->cs); + + if (clock->time_source) + IMFPresentationTimeSource_Release(clock->time_source); + if (clock->time_source_sink) + IMFClockStateSink_Release(clock->time_source_sink); + clock->time_source = NULL; + clock->time_source_sink = NULL; + + hr = IMFPresentationTimeSource_QueryInterface(time_source, &IID_IMFClockStateSink, (void **)&clock->time_source_sink); + if (SUCCEEDED(hr)) + { + clock->time_source = time_source; + IMFPresentationTimeSource_AddRef(clock->time_source); + } + + if (SUCCEEDED(IMFPresentationTimeSource_GetUnderlyingClock(time_source, &source_clock))) + { + if (SUCCEEDED(IMFClock_GetProperties(source_clock, &props))) + clock->frequency = props.qwClockFrequency; + IMFClock_Release(source_clock); + } + + if (!clock->frequency) + clock->frequency = MFCLOCK_FREQUENCY_HNS; + + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static HRESULT WINAPI present_clock_GetTimeSource(IMFPresentationClock *iface, + IMFPresentationTimeSource **time_source) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + HRESULT hr = S_OK; + + TRACE("%p, %p.\n", iface, time_source); + + if (!time_source) + return E_INVALIDARG; + + EnterCriticalSection(&clock->cs); + if (clock->time_source) + { + *time_source = clock->time_source; + IMFPresentationTimeSource_AddRef(*time_source); + } + else + hr = MF_E_CLOCK_NO_TIME_SOURCE; + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static HRESULT WINAPI present_clock_GetTime(IMFPresentationClock *iface, MFTIME *time) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE; + MFTIME systime; + + TRACE("%p, %p.\n", iface, time); + + if (!time) + return E_POINTER; + + EnterCriticalSection(&clock->cs); + if (clock->time_source) + hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, 0, time, &systime); + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static HRESULT WINAPI present_clock_AddClockStateSink(IMFPresentationClock *iface, IMFClockStateSink *state_sink) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + struct clock_sink *sink, *cur; + HRESULT hr = S_OK; + + TRACE("%p, %p.\n", iface, state_sink); + + if (!state_sink) + return E_INVALIDARG; + + sink = heap_alloc(sizeof(*sink)); + if (!sink) + return E_OUTOFMEMORY; + + sink->state_sink = state_sink; + IMFClockStateSink_AddRef(sink->state_sink); + + EnterCriticalSection(&clock->cs); + LIST_FOR_EACH_ENTRY(cur, &clock->sinks, struct clock_sink, entry) + { + if (cur->state_sink == state_sink) + { + hr = E_INVALIDARG; + break; + } + } + if (SUCCEEDED(hr)) + { + static const enum clock_notification notifications[MFCLOCK_STATE_PAUSED + 1] = + { + /* MFCLOCK_STATE_INVALID */ 0, /* Does not apply */ + /* MFCLOCK_STATE_RUNNING */ CLOCK_NOTIFY_START, + /* MFCLOCK_STATE_STOPPED */ CLOCK_NOTIFY_STOP, + /* MFCLOCK_STATE_PAUSED */ CLOCK_NOTIFY_PAUSE, + }; + struct clock_state_change_param param; + + if (!clock->is_shut_down && clock->state != MFCLOCK_STATE_INVALID) + { + param.u.offset = clock->start_offset; + clock_notify_async_sink(clock, MFGetSystemTime(), param, notifications[clock->state], sink->state_sink); + } + + list_add_tail(&clock->sinks, &sink->entry); + } + LeaveCriticalSection(&clock->cs); + + if (FAILED(hr)) + { + IMFClockStateSink_Release(sink->state_sink); + heap_free(sink); + } + + return hr; +} + +static HRESULT WINAPI present_clock_RemoveClockStateSink(IMFPresentationClock *iface, + IMFClockStateSink *state_sink) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + struct clock_sink *sink; + + TRACE("%p, %p.\n", iface, state_sink); + + if (!state_sink) + return E_INVALIDARG; + + EnterCriticalSection(&clock->cs); + LIST_FOR_EACH_ENTRY(sink, &clock->sinks, struct clock_sink, entry) + { + if (sink->state_sink == state_sink) + { + IMFClockStateSink_Release(sink->state_sink); + list_remove(&sink->entry); + heap_free(sink); + break; + } + } + LeaveCriticalSection(&clock->cs); + + return S_OK; +} + +static HRESULT clock_call_state_change(MFTIME system_time, struct clock_state_change_param param, + enum clock_notification notification, IMFClockStateSink *sink) +{ + HRESULT hr = S_OK; + + switch (notification) + { + case CLOCK_NOTIFY_START: + hr = IMFClockStateSink_OnClockStart(sink, system_time, param.u.offset); + break; + case CLOCK_NOTIFY_STOP: + hr = IMFClockStateSink_OnClockStop(sink, system_time); + break; + case CLOCK_NOTIFY_PAUSE: + hr = IMFClockStateSink_OnClockPause(sink, system_time); + break; + case CLOCK_NOTIFY_RESTART: + hr = IMFClockStateSink_OnClockRestart(sink, system_time); + break; + case CLOCK_NOTIFY_SET_RATE: + /* System time source does not allow 0.0 rate, presentation clock allows it without raising errors. */ + IMFClockStateSink_OnClockSetRate(sink, system_time, param.u.rate); + break; + default: + ; + } + + return hr; +} + +static HRESULT clock_change_state(struct presentation_clock *clock, enum clock_command command, + struct clock_state_change_param param) +{ + static const BYTE state_change_is_allowed[MFCLOCK_STATE_PAUSED+1][CLOCK_CMD_MAX] = + { /* S S* P, R */ + /* INVALID */ { 1, 1, 1, 1 }, + /* RUNNING */ { 1, 1, 1, 1 }, + /* STOPPED */ { 1, 1, 0, 1 }, + /* PAUSED */ { 1, 1, 0, 1 }, + }; + static const MFCLOCK_STATE states[CLOCK_CMD_MAX] = + { + /* CLOCK_CMD_START */ MFCLOCK_STATE_RUNNING, + /* CLOCK_CMD_STOP */ MFCLOCK_STATE_STOPPED, + /* CLOCK_CMD_PAUSE */ MFCLOCK_STATE_PAUSED, + /* CLOCK_CMD_SET_RATE */ 0, /* Unused */ + }; + static const enum clock_notification notifications[CLOCK_CMD_MAX] = + { + /* CLOCK_CMD_START */ CLOCK_NOTIFY_START, + /* CLOCK_CMD_STOP */ CLOCK_NOTIFY_STOP, + /* CLOCK_CMD_PAUSE */ CLOCK_NOTIFY_PAUSE, + /* CLOCK_CMD_SET_RATE */ CLOCK_NOTIFY_SET_RATE, + }; + enum clock_notification notification; + struct clock_sink *sink; + MFCLOCK_STATE old_state; + IMFAsyncResult *result; + MFTIME system_time; + HRESULT hr; + + if (!clock->time_source) + return MF_E_CLOCK_NO_TIME_SOURCE; + + if (command != CLOCK_CMD_SET_RATE && clock->state == states[command] && clock->state != MFCLOCK_STATE_RUNNING) + return MF_E_CLOCK_STATE_ALREADY_SET; + + if (!state_change_is_allowed[clock->state][command]) + return MF_E_INVALIDREQUEST; + + system_time = MFGetSystemTime(); + + if (command == CLOCK_CMD_START && clock->state == MFCLOCK_STATE_PAUSED && + param.u.offset == PRESENTATION_CURRENT_POSITION) + { + notification = CLOCK_NOTIFY_RESTART; + } + else + notification = notifications[command]; + + if (FAILED(hr = clock_call_state_change(system_time, param, notification, clock->time_source_sink))) + return hr; + + old_state = clock->state; + if (command != CLOCK_CMD_SET_RATE) + clock->state = states[command]; + + /* Dump all pending timer requests immediately on start; otherwise try to cancel scheduled items when + transitioning from running state. */ + if ((clock->state == MFCLOCK_STATE_RUNNING) ^ (old_state == MFCLOCK_STATE_RUNNING)) + { + struct clock_timer *timer, *timer2; + + if (clock->state == MFCLOCK_STATE_RUNNING) + { + LIST_FOR_EACH_ENTRY_SAFE(timer, timer2, &clock->timers, struct clock_timer, entry) + { + list_remove(&timer->entry); + hr = MFCreateAsyncResult(&timer->IUnknown_iface, &clock->timer_callback, NULL, &result); + IUnknown_Release(&timer->IUnknown_iface); + if (SUCCEEDED(hr)) + { + MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_TIMER, result); + IMFAsyncResult_Release(result); + } + } + } + else + { + LIST_FOR_EACH_ENTRY(timer, &clock->timers, struct clock_timer, entry) + { + if (timer->key) + { + MFCancelWorkItem(timer->key); + timer->key = 0; + } + } + } + } + + LIST_FOR_EACH_ENTRY(sink, &clock->sinks, struct clock_sink, entry) + { + clock_notify_async_sink(clock, system_time, param, notification, sink->state_sink); + } + + return S_OK; +} + +static HRESULT WINAPI present_clock_Start(IMFPresentationClock *iface, LONGLONG start_offset) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + struct clock_state_change_param param = {{0}}; + HRESULT hr; + + TRACE("%p, %s.\n", iface, debugstr_time(start_offset)); + + EnterCriticalSection(&clock->cs); + clock->start_offset = param.u.offset = start_offset; + hr = clock_change_state(clock, CLOCK_CMD_START, param); + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static HRESULT WINAPI present_clock_Stop(IMFPresentationClock *iface) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + struct clock_state_change_param param = {{0}}; + HRESULT hr; + + TRACE("%p.\n", iface); + + EnterCriticalSection(&clock->cs); + hr = clock_change_state(clock, CLOCK_CMD_STOP, param); + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static HRESULT WINAPI present_clock_Pause(IMFPresentationClock *iface) +{ + struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); + struct clock_state_change_param param = {{0}}; + HRESULT hr; + + TRACE("%p.\n", iface); + + EnterCriticalSection(&clock->cs); + hr = clock_change_state(clock, CLOCK_CMD_PAUSE, param); + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static const IMFPresentationClockVtbl presentationclockvtbl = +{ + present_clock_QueryInterface, + present_clock_AddRef, + present_clock_Release, + present_clock_GetClockCharacteristics, + present_clock_GetCorrelatedTime, + present_clock_GetContinuityKey, + present_clock_GetState, + present_clock_GetProperties, + present_clock_SetTimeSource, + present_clock_GetTimeSource, + present_clock_GetTime, + present_clock_AddClockStateSink, + present_clock_RemoveClockStateSink, + present_clock_Start, + present_clock_Stop, + present_clock_Pause, +}; + +static HRESULT WINAPI present_clock_rate_control_QueryInterface(IMFRateControl *iface, REFIID riid, void **out) +{ + struct presentation_clock *clock = impl_from_IMFRateControl(iface); + return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out); +} + +static ULONG WINAPI present_clock_rate_control_AddRef(IMFRateControl *iface) +{ + struct presentation_clock *clock = impl_from_IMFRateControl(iface); + return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface); +} + +static ULONG WINAPI present_clock_rate_control_Release(IMFRateControl *iface) +{ + struct presentation_clock *clock = impl_from_IMFRateControl(iface); + return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface); +} + +static HRESULT WINAPI present_clock_rate_SetRate(IMFRateControl *iface, BOOL thin, float rate) +{ + struct presentation_clock *clock = impl_from_IMFRateControl(iface); + struct clock_state_change_param param; + HRESULT hr; + + TRACE("%p, %d, %f.\n", iface, thin, rate); + + if (thin) + return MF_E_THINNING_UNSUPPORTED; + + EnterCriticalSection(&clock->cs); + param.u.rate = rate; + if (SUCCEEDED(hr = clock_change_state(clock, CLOCK_CMD_SET_RATE, param))) + clock->rate = rate; + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static HRESULT WINAPI present_clock_rate_GetRate(IMFRateControl *iface, BOOL *thin, float *rate) +{ + struct presentation_clock *clock = impl_from_IMFRateControl(iface); + + TRACE("%p, %p, %p.\n", iface, thin, rate); + + if (!rate) + return E_INVALIDARG; + + if (thin) + *thin = FALSE; + + EnterCriticalSection(&clock->cs); + *rate = clock->rate; + LeaveCriticalSection(&clock->cs); + + return S_OK; +} + +static const IMFRateControlVtbl presentclockratecontrolvtbl = +{ + present_clock_rate_control_QueryInterface, + present_clock_rate_control_AddRef, + present_clock_rate_control_Release, + present_clock_rate_SetRate, + present_clock_rate_GetRate, +}; + +static HRESULT WINAPI present_clock_timer_QueryInterface(IMFTimer *iface, REFIID riid, void **out) +{ + struct presentation_clock *clock = impl_from_IMFTimer(iface); + return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out); +} + +static ULONG WINAPI present_clock_timer_AddRef(IMFTimer *iface) +{ + struct presentation_clock *clock = impl_from_IMFTimer(iface); + return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface); +} + +static ULONG WINAPI present_clock_timer_Release(IMFTimer *iface) +{ + struct presentation_clock *clock = impl_from_IMFTimer(iface); + return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface); +} + +static HRESULT present_clock_schedule_timer(struct presentation_clock *clock, DWORD flags, LONGLONG time, + struct clock_timer *timer) +{ + IMFAsyncResult *result; + MFTIME systime, clocktime; + LONGLONG frequency; + HRESULT hr; + + if (!(flags & MFTIMER_RELATIVE)) + { + if (FAILED(hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, 0, &clocktime, &systime))) + { + WARN("Failed to get clock time, hr %#x.\n", hr); + return hr; + } + time -= clocktime; + } + + frequency = clock->frequency / 1000; + time /= frequency; + + /* Scheduled item is using clock instance callback, with timer instance as an object. Clock callback will + call user callback and cleanup timer list. */ + + if (FAILED(hr = MFCreateAsyncResult(&timer->IUnknown_iface, &clock->timer_callback, NULL, &result))) + return hr; + + hr = MFScheduleWorkItemEx(result, -time, &timer->key); + IMFAsyncResult_Release(result); + + return hr; +} + +static HRESULT WINAPI clock_timer_QueryInterface(IUnknown *iface, REFIID riid, void **obj) +{ + if (IsEqualIID(riid, &IID_IUnknown)) + { + *obj = iface; + IUnknown_AddRef(iface); + return S_OK; + } + + *obj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI clock_timer_AddRef(IUnknown *iface) +{ + struct clock_timer *timer = impl_clock_timer_from_IUnknown(iface); + return InterlockedIncrement(&timer->refcount); +} + +static ULONG WINAPI clock_timer_Release(IUnknown *iface) +{ + struct clock_timer *timer = impl_clock_timer_from_IUnknown(iface); + ULONG refcount = InterlockedDecrement(&timer->refcount); + + if (!refcount) + { + IMFAsyncResult_Release(timer->result); + IMFAsyncCallback_Release(timer->callback); + heap_free(timer); + } + + return refcount; +} + +static const IUnknownVtbl clock_timer_vtbl = +{ + clock_timer_QueryInterface, + clock_timer_AddRef, + clock_timer_Release, +}; + +static HRESULT WINAPI present_clock_timer_SetTimer(IMFTimer *iface, DWORD flags, LONGLONG time, + IMFAsyncCallback *callback, IUnknown *state, IUnknown **cancel_key) +{ + struct presentation_clock *clock = impl_from_IMFTimer(iface); + struct clock_timer *clock_timer; + HRESULT hr; + + TRACE("%p, %#x, %s, %p, %p, %p.\n", iface, flags, debugstr_time(time), callback, state, cancel_key); + + if (!(clock_timer = heap_alloc_zero(sizeof(*clock_timer)))) + return E_OUTOFMEMORY; + + if (FAILED(hr = MFCreateAsyncResult(NULL, NULL, state, &clock_timer->result))) + { + heap_free(clock_timer); + return hr; + } + + clock_timer->IUnknown_iface.lpVtbl = &clock_timer_vtbl; + clock_timer->refcount = 1; + clock_timer->callback = callback; + IMFAsyncCallback_AddRef(clock_timer->callback); + + EnterCriticalSection(&clock->cs); + + if (clock->state == MFCLOCK_STATE_RUNNING) + hr = present_clock_schedule_timer(clock, flags, time, clock_timer); + else if (clock->state == MFCLOCK_STATE_STOPPED) + hr = MF_S_CLOCK_STOPPED; + + if (SUCCEEDED(hr)) + { + list_add_tail(&clock->timers, &clock_timer->entry); + if (cancel_key) + { + *cancel_key = &clock_timer->IUnknown_iface; + IUnknown_AddRef(*cancel_key); + } + } + + LeaveCriticalSection(&clock->cs); + + if (FAILED(hr)) + IUnknown_Release(&clock_timer->IUnknown_iface); + + return hr; +} + +static HRESULT WINAPI present_clock_timer_CancelTimer(IMFTimer *iface, IUnknown *cancel_key) +{ + struct presentation_clock *clock = impl_from_IMFTimer(iface); + struct clock_timer *timer; + + TRACE("%p, %p.\n", iface, cancel_key); + + EnterCriticalSection(&clock->cs); + + LIST_FOR_EACH_ENTRY(timer, &clock->timers, struct clock_timer, entry) + { + if (&timer->IUnknown_iface == cancel_key) + { + list_remove(&timer->entry); + if (timer->key) + { + MFCancelWorkItem(timer->key); + timer->key = 0; + } + IUnknown_Release(&timer->IUnknown_iface); + break; + } + } + + LeaveCriticalSection(&clock->cs); + + return S_OK; +} + +static const IMFTimerVtbl presentclocktimervtbl = +{ + present_clock_timer_QueryInterface, + present_clock_timer_AddRef, + present_clock_timer_Release, + present_clock_timer_SetTimer, + present_clock_timer_CancelTimer, +}; + +static HRESULT WINAPI present_clock_shutdown_QueryInterface(IMFShutdown *iface, REFIID riid, void **out) +{ + struct presentation_clock *clock = impl_from_IMFShutdown(iface); + return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out); +} + +static ULONG WINAPI present_clock_shutdown_AddRef(IMFShutdown *iface) +{ + struct presentation_clock *clock = impl_from_IMFShutdown(iface); + return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface); +} + +static ULONG WINAPI present_clock_shutdown_Release(IMFShutdown *iface) +{ + struct presentation_clock *clock = impl_from_IMFShutdown(iface); + return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface); +} + +static HRESULT WINAPI present_clock_shutdown_Shutdown(IMFShutdown *iface) +{ + struct presentation_clock *clock = impl_from_IMFShutdown(iface); + + TRACE("%p.\n", iface); + + EnterCriticalSection(&clock->cs); + clock->is_shut_down = TRUE; + LeaveCriticalSection(&clock->cs); + + return S_OK; +} + +static HRESULT WINAPI present_clock_shutdown_GetShutdownStatus(IMFShutdown *iface, MFSHUTDOWN_STATUS *status) +{ + struct presentation_clock *clock = impl_from_IMFShutdown(iface); + HRESULT hr = S_OK; + + TRACE("%p, %p.\n", iface, status); + + if (!status) + return E_INVALIDARG; + + EnterCriticalSection(&clock->cs); + if (clock->is_shut_down) + *status = MFSHUTDOWN_COMPLETED; + else + hr = MF_E_INVALIDREQUEST; + LeaveCriticalSection(&clock->cs); + + return hr; +} + +static const IMFShutdownVtbl presentclockshutdownvtbl = +{ + present_clock_shutdown_QueryInterface, + present_clock_shutdown_AddRef, + present_clock_shutdown_Release, + present_clock_shutdown_Shutdown, + present_clock_shutdown_GetShutdownStatus, +}; + +static HRESULT WINAPI present_clock_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **out) +{ + if (IsEqualIID(riid, &IID_IMFAsyncCallback) || + IsEqualIID(riid, &IID_IUnknown)) + { + *out = iface; + IMFAsyncCallback_AddRef(iface); + return S_OK; + } + + WARN("Unsupported %s.\n", wine_dbgstr_guid(riid)); + *out = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI present_clock_sink_callback_AddRef(IMFAsyncCallback *iface) +{ + struct presentation_clock *clock = impl_from_sink_callback_IMFAsyncCallback(iface); + return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface); +} + +static ULONG WINAPI present_clock_sink_callback_Release(IMFAsyncCallback *iface) +{ + struct presentation_clock *clock = impl_from_sink_callback_IMFAsyncCallback(iface); + return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface); +} + +static HRESULT WINAPI present_clock_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI present_clock_sink_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result) +{ + struct sink_notification *data; + IUnknown *object; + HRESULT hr; + + if (FAILED(hr = IMFAsyncResult_GetObject(result, &object))) + return hr; + + data = impl_sink_notification_from_IUnknown(object); + + clock_call_state_change(data->system_time, data->param, data->notification, data->sink); + + IUnknown_Release(object); + + return S_OK; +} + +static const IMFAsyncCallbackVtbl presentclocksinkcallbackvtbl = +{ + present_clock_callback_QueryInterface, + present_clock_sink_callback_AddRef, + present_clock_sink_callback_Release, + present_clock_callback_GetParameters, + present_clock_sink_callback_Invoke, +}; + +static ULONG WINAPI present_clock_timer_callback_AddRef(IMFAsyncCallback *iface) +{ + struct presentation_clock *clock = impl_from_timer_callback_IMFAsyncCallback(iface); + return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface); +} + +static ULONG WINAPI present_clock_timer_callback_Release(IMFAsyncCallback *iface) +{ + struct presentation_clock *clock = impl_from_timer_callback_IMFAsyncCallback(iface); + return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface); +} + +static HRESULT WINAPI present_clock_timer_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result) +{ + struct presentation_clock *clock = impl_from_timer_callback_IMFAsyncCallback(iface); + struct clock_timer *timer; + IUnknown *object; + HRESULT hr; + + if (FAILED(hr = IMFAsyncResult_GetObject(result, &object))) + return hr; + + timer = impl_clock_timer_from_IUnknown(object); + + EnterCriticalSection(&clock->cs); + list_remove(&timer->entry); + IUnknown_Release(&timer->IUnknown_iface); + LeaveCriticalSection(&clock->cs); + + IMFAsyncCallback_Invoke(timer->callback, timer->result); + + IUnknown_Release(object); + + return S_OK; +} + +static const IMFAsyncCallbackVtbl presentclocktimercallbackvtbl = +{ + present_clock_callback_QueryInterface, + present_clock_timer_callback_AddRef, + present_clock_timer_callback_Release, + present_clock_callback_GetParameters, + present_clock_timer_callback_Invoke, +}; + +/*********************************************************************** + * MFCreatePresentationClock (mf.@) + */ +HRESULT WINAPI MFCreatePresentationClock(IMFPresentationClock **clock) +{ + struct presentation_clock *object; + + TRACE("%p.\n", clock); + + object = heap_alloc_zero(sizeof(*object)); + if (!object) + return E_OUTOFMEMORY; + + object->IMFPresentationClock_iface.lpVtbl = &presentationclockvtbl; + object->IMFRateControl_iface.lpVtbl = &presentclockratecontrolvtbl; + object->IMFTimer_iface.lpVtbl = &presentclocktimervtbl; + object->IMFShutdown_iface.lpVtbl = &presentclockshutdownvtbl; + object->sink_callback.lpVtbl = &presentclocksinkcallbackvtbl; + object->timer_callback.lpVtbl = &presentclocktimercallbackvtbl; + object->refcount = 1; + list_init(&object->sinks); + list_init(&object->timers); + object->rate = 1.0f; + InitializeCriticalSection(&object->cs); + + *clock = &object->IMFPresentationClock_iface; + + return S_OK; +} diff --git a/dlls/mf/session.c b/dlls/mf/session.c index 9f233295773..a7f81e694c2 100644 --- a/dlls/mf/session.c +++ b/dlls/mf/session.c @@ -247,80 +247,6 @@ struct media_session CRITICAL_SECTION cs; }; -struct clock_sink -{ - struct list entry; - IMFClockStateSink *state_sink; -}; - -enum clock_command -{ - CLOCK_CMD_START = 0, - CLOCK_CMD_STOP, - CLOCK_CMD_PAUSE, - CLOCK_CMD_SET_RATE, - CLOCK_CMD_MAX, -}; - -enum clock_notification -{ - CLOCK_NOTIFY_START, - CLOCK_NOTIFY_STOP, - CLOCK_NOTIFY_PAUSE, - CLOCK_NOTIFY_RESTART, - CLOCK_NOTIFY_SET_RATE, -}; - -struct clock_state_change_param -{ - union - { - LONGLONG offset; - float rate; - } u; -}; - -struct sink_notification -{ - IUnknown IUnknown_iface; - LONG refcount; - MFTIME system_time; - struct clock_state_change_param param; - enum clock_notification notification; - IMFClockStateSink *sink; -}; - -struct clock_timer -{ - IUnknown IUnknown_iface; - LONG refcount; - IMFAsyncResult *result; - IMFAsyncCallback *callback; - MFWORKITEM_KEY key; - struct list entry; -}; - -struct presentation_clock -{ - IMFPresentationClock IMFPresentationClock_iface; - IMFRateControl IMFRateControl_iface; - IMFTimer IMFTimer_iface; - IMFShutdown IMFShutdown_iface; - IMFAsyncCallback sink_callback; - IMFAsyncCallback timer_callback; - LONG refcount; - IMFPresentationTimeSource *time_source; - IMFClockStateSink *time_source_sink; - MFCLOCK_STATE state; - LONGLONG start_offset; - struct list sinks; - struct list timers; - float rate; - LONGLONG frequency; - CRITICAL_SECTION cs; - BOOL is_shut_down; -}; - enum quality_manager_state { QUALITY_MANAGER_READY = 0, @@ -384,46 +310,6 @@ static struct session_op *impl_op_from_IUnknown(IUnknown *iface) return CONTAINING_RECORD(iface, struct session_op, IUnknown_iface); } -static struct presentation_clock *impl_from_IMFPresentationClock(IMFPresentationClock *iface) -{ - return CONTAINING_RECORD(iface, struct presentation_clock, IMFPresentationClock_iface); -} - -static struct presentation_clock *impl_from_IMFRateControl(IMFRateControl *iface) -{ - return CONTAINING_RECORD(iface, struct presentation_clock, IMFRateControl_iface); -} - -static struct presentation_clock *impl_from_IMFTimer(IMFTimer *iface) -{ - return CONTAINING_RECORD(iface, struct presentation_clock, IMFTimer_iface); -} - -static struct presentation_clock *impl_from_IMFShutdown(IMFShutdown *iface) -{ - return CONTAINING_RECORD(iface, struct presentation_clock, IMFShutdown_iface); -} - -static struct presentation_clock *impl_from_sink_callback_IMFAsyncCallback(IMFAsyncCallback *iface) -{ - return CONTAINING_RECORD(iface, struct presentation_clock, sink_callback); -} - -static struct presentation_clock *impl_from_timer_callback_IMFAsyncCallback(IMFAsyncCallback *iface) -{ - return CONTAINING_RECORD(iface, struct presentation_clock, timer_callback); -} - -static struct clock_timer *impl_clock_timer_from_IUnknown(IUnknown *iface) -{ - return CONTAINING_RECORD(iface, struct clock_timer, IUnknown_iface); -} - -static struct sink_notification *impl_sink_notification_from_IUnknown(IUnknown *iface) -{ - return CONTAINING_RECORD(iface, struct sink_notification, IUnknown_iface); -} - static struct quality_manager *impl_from_IMFQualityManager(IMFQualityManager *iface) { return CONTAINING_RECORD(iface, struct quality_manager, IMFQualityManager_iface); @@ -3795,1027 +3681,6 @@ failed: return hr; } -static HRESULT WINAPI sink_notification_QueryInterface(IUnknown *iface, REFIID riid, void **out) -{ - if (IsEqualIID(riid, &IID_IUnknown)) - { - *out = iface; - IUnknown_AddRef(iface); - return S_OK; - } - - WARN("Unsupported %s.\n", debugstr_guid(riid)); - *out = NULL; - return E_NOINTERFACE; -} - -static ULONG WINAPI sink_notification_AddRef(IUnknown *iface) -{ - struct sink_notification *notification = impl_sink_notification_from_IUnknown(iface); - ULONG refcount = InterlockedIncrement(&notification->refcount); - - TRACE("%p, refcount %u.\n", iface, refcount); - - return refcount; -} - -static ULONG WINAPI sink_notification_Release(IUnknown *iface) -{ - struct sink_notification *notification = impl_sink_notification_from_IUnknown(iface); - ULONG refcount = InterlockedDecrement(&notification->refcount); - - TRACE("%p, refcount %u.\n", iface, refcount); - - if (!refcount) - { - IMFClockStateSink_Release(notification->sink); - heap_free(notification); - } - - return refcount; -} - -static const IUnknownVtbl sinknotificationvtbl = -{ - sink_notification_QueryInterface, - sink_notification_AddRef, - sink_notification_Release, -}; - -static void clock_notify_async_sink(struct presentation_clock *clock, MFTIME system_time, - struct clock_state_change_param param, enum clock_notification notification, IMFClockStateSink *sink) -{ - struct sink_notification *object; - IMFAsyncResult *result; - HRESULT hr; - - object = heap_alloc(sizeof(*object)); - if (!object) - return; - - object->IUnknown_iface.lpVtbl = &sinknotificationvtbl; - object->refcount = 1; - object->system_time = system_time; - object->param = param; - object->notification = notification; - object->sink = sink; - IMFClockStateSink_AddRef(object->sink); - - hr = MFCreateAsyncResult(&object->IUnknown_iface, &clock->sink_callback, NULL, &result); - IUnknown_Release(&object->IUnknown_iface); - if (SUCCEEDED(hr)) - { - MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_STANDARD, result); - IMFAsyncResult_Release(result); - } -} - -static HRESULT WINAPI present_clock_QueryInterface(IMFPresentationClock *iface, REFIID riid, void **out) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - - TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out); - - if (IsEqualIID(riid, &IID_IMFPresentationClock) || - IsEqualIID(riid, &IID_IMFClock) || - IsEqualIID(riid, &IID_IUnknown)) - { - *out = &clock->IMFPresentationClock_iface; - } - else if (IsEqualIID(riid, &IID_IMFRateControl)) - { - *out = &clock->IMFRateControl_iface; - } - else if (IsEqualIID(riid, &IID_IMFTimer)) - { - *out = &clock->IMFTimer_iface; - } - else if (IsEqualIID(riid, &IID_IMFShutdown)) - { - *out = &clock->IMFShutdown_iface; - } - else - { - WARN("Unsupported %s.\n", debugstr_guid(riid)); - *out = NULL; - return E_NOINTERFACE; - } - - IUnknown_AddRef((IUnknown *)*out); - return S_OK; -} - -static ULONG WINAPI present_clock_AddRef(IMFPresentationClock *iface) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - ULONG refcount = InterlockedIncrement(&clock->refcount); - - TRACE("%p, refcount %u.\n", iface, refcount); - - return refcount; -} - -static ULONG WINAPI present_clock_Release(IMFPresentationClock *iface) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - ULONG refcount = InterlockedDecrement(&clock->refcount); - struct clock_timer *timer, *timer2; - struct clock_sink *sink, *sink2; - - TRACE("%p, refcount %u.\n", iface, refcount); - - if (!refcount) - { - if (clock->time_source) - IMFPresentationTimeSource_Release(clock->time_source); - if (clock->time_source_sink) - IMFClockStateSink_Release(clock->time_source_sink); - LIST_FOR_EACH_ENTRY_SAFE(sink, sink2, &clock->sinks, struct clock_sink, entry) - { - list_remove(&sink->entry); - IMFClockStateSink_Release(sink->state_sink); - heap_free(sink); - } - LIST_FOR_EACH_ENTRY_SAFE(timer, timer2, &clock->timers, struct clock_timer, entry) - { - list_remove(&timer->entry); - IUnknown_Release(&timer->IUnknown_iface); - } - DeleteCriticalSection(&clock->cs); - heap_free(clock); - } - - return refcount; -} - -static HRESULT WINAPI present_clock_GetClockCharacteristics(IMFPresentationClock *iface, DWORD *flags) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE; - - TRACE("%p, %p.\n", iface, flags); - - EnterCriticalSection(&clock->cs); - if (clock->time_source) - hr = IMFPresentationTimeSource_GetClockCharacteristics(clock->time_source, flags); - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static HRESULT WINAPI present_clock_GetCorrelatedTime(IMFPresentationClock *iface, DWORD reserved, - LONGLONG *clock_time, MFTIME *system_time) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE; - - TRACE("%p, %#x, %p, %p.\n", iface, reserved, clock_time, system_time); - - EnterCriticalSection(&clock->cs); - if (clock->time_source) - hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, reserved, clock_time, system_time); - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static HRESULT WINAPI present_clock_GetContinuityKey(IMFPresentationClock *iface, DWORD *key) -{ - TRACE("%p, %p.\n", iface, key); - - *key = 0; - - return S_OK; -} - -static HRESULT WINAPI present_clock_GetState(IMFPresentationClock *iface, DWORD reserved, MFCLOCK_STATE *state) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - - TRACE("%p, %#x, %p.\n", iface, reserved, state); - - EnterCriticalSection(&clock->cs); - *state = clock->state; - LeaveCriticalSection(&clock->cs); - - return S_OK; -} - -static HRESULT WINAPI present_clock_GetProperties(IMFPresentationClock *iface, MFCLOCK_PROPERTIES *props) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE; - - TRACE("%p, %p.\n", iface, props); - - EnterCriticalSection(&clock->cs); - if (clock->time_source) - hr = IMFPresentationTimeSource_GetProperties(clock->time_source, props); - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static HRESULT WINAPI present_clock_SetTimeSource(IMFPresentationClock *iface, - IMFPresentationTimeSource *time_source) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - MFCLOCK_PROPERTIES props; - IMFClock *source_clock; - HRESULT hr; - - TRACE("%p, %p.\n", iface, time_source); - - EnterCriticalSection(&clock->cs); - - if (clock->time_source) - IMFPresentationTimeSource_Release(clock->time_source); - if (clock->time_source_sink) - IMFClockStateSink_Release(clock->time_source_sink); - clock->time_source = NULL; - clock->time_source_sink = NULL; - - hr = IMFPresentationTimeSource_QueryInterface(time_source, &IID_IMFClockStateSink, (void **)&clock->time_source_sink); - if (SUCCEEDED(hr)) - { - clock->time_source = time_source; - IMFPresentationTimeSource_AddRef(clock->time_source); - } - - if (SUCCEEDED(IMFPresentationTimeSource_GetUnderlyingClock(time_source, &source_clock))) - { - if (SUCCEEDED(IMFClock_GetProperties(source_clock, &props))) - clock->frequency = props.qwClockFrequency; - IMFClock_Release(source_clock); - } - - if (!clock->frequency) - clock->frequency = MFCLOCK_FREQUENCY_HNS; - - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static HRESULT WINAPI present_clock_GetTimeSource(IMFPresentationClock *iface, - IMFPresentationTimeSource **time_source) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - HRESULT hr = S_OK; - - TRACE("%p, %p.\n", iface, time_source); - - if (!time_source) - return E_INVALIDARG; - - EnterCriticalSection(&clock->cs); - if (clock->time_source) - { - *time_source = clock->time_source; - IMFPresentationTimeSource_AddRef(*time_source); - } - else - hr = MF_E_CLOCK_NO_TIME_SOURCE; - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static HRESULT WINAPI present_clock_GetTime(IMFPresentationClock *iface, MFTIME *time) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - HRESULT hr = MF_E_CLOCK_NO_TIME_SOURCE; - MFTIME systime; - - TRACE("%p, %p.\n", iface, time); - - if (!time) - return E_POINTER; - - EnterCriticalSection(&clock->cs); - if (clock->time_source) - hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, 0, time, &systime); - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static HRESULT WINAPI present_clock_AddClockStateSink(IMFPresentationClock *iface, IMFClockStateSink *state_sink) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - struct clock_sink *sink, *cur; - HRESULT hr = S_OK; - - TRACE("%p, %p.\n", iface, state_sink); - - if (!state_sink) - return E_INVALIDARG; - - sink = heap_alloc(sizeof(*sink)); - if (!sink) - return E_OUTOFMEMORY; - - sink->state_sink = state_sink; - IMFClockStateSink_AddRef(sink->state_sink); - - EnterCriticalSection(&clock->cs); - LIST_FOR_EACH_ENTRY(cur, &clock->sinks, struct clock_sink, entry) - { - if (cur->state_sink == state_sink) - { - hr = E_INVALIDARG; - break; - } - } - if (SUCCEEDED(hr)) - { - static const enum clock_notification notifications[MFCLOCK_STATE_PAUSED + 1] = - { - /* MFCLOCK_STATE_INVALID */ 0, /* Does not apply */ - /* MFCLOCK_STATE_RUNNING */ CLOCK_NOTIFY_START, - /* MFCLOCK_STATE_STOPPED */ CLOCK_NOTIFY_STOP, - /* MFCLOCK_STATE_PAUSED */ CLOCK_NOTIFY_PAUSE, - }; - struct clock_state_change_param param; - - if (!clock->is_shut_down && clock->state != MFCLOCK_STATE_INVALID) - { - param.u.offset = clock->start_offset; - clock_notify_async_sink(clock, MFGetSystemTime(), param, notifications[clock->state], sink->state_sink); - } - - list_add_tail(&clock->sinks, &sink->entry); - } - LeaveCriticalSection(&clock->cs); - - if (FAILED(hr)) - { - IMFClockStateSink_Release(sink->state_sink); - heap_free(sink); - } - - return hr; -} - -static HRESULT WINAPI present_clock_RemoveClockStateSink(IMFPresentationClock *iface, - IMFClockStateSink *state_sink) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - struct clock_sink *sink; - - TRACE("%p, %p.\n", iface, state_sink); - - if (!state_sink) - return E_INVALIDARG; - - EnterCriticalSection(&clock->cs); - LIST_FOR_EACH_ENTRY(sink, &clock->sinks, struct clock_sink, entry) - { - if (sink->state_sink == state_sink) - { - IMFClockStateSink_Release(sink->state_sink); - list_remove(&sink->entry); - heap_free(sink); - break; - } - } - LeaveCriticalSection(&clock->cs); - - return S_OK; -} - -static HRESULT clock_call_state_change(MFTIME system_time, struct clock_state_change_param param, - enum clock_notification notification, IMFClockStateSink *sink) -{ - HRESULT hr = S_OK; - - switch (notification) - { - case CLOCK_NOTIFY_START: - hr = IMFClockStateSink_OnClockStart(sink, system_time, param.u.offset); - break; - case CLOCK_NOTIFY_STOP: - hr = IMFClockStateSink_OnClockStop(sink, system_time); - break; - case CLOCK_NOTIFY_PAUSE: - hr = IMFClockStateSink_OnClockPause(sink, system_time); - break; - case CLOCK_NOTIFY_RESTART: - hr = IMFClockStateSink_OnClockRestart(sink, system_time); - break; - case CLOCK_NOTIFY_SET_RATE: - /* System time source does not allow 0.0 rate, presentation clock allows it without raising errors. */ - IMFClockStateSink_OnClockSetRate(sink, system_time, param.u.rate); - break; - default: - ; - } - - return hr; -} - -static HRESULT clock_change_state(struct presentation_clock *clock, enum clock_command command, - struct clock_state_change_param param) -{ - static const BYTE state_change_is_allowed[MFCLOCK_STATE_PAUSED+1][CLOCK_CMD_MAX] = - { /* S S* P, R */ - /* INVALID */ { 1, 1, 1, 1 }, - /* RUNNING */ { 1, 1, 1, 1 }, - /* STOPPED */ { 1, 1, 0, 1 }, - /* PAUSED */ { 1, 1, 0, 1 }, - }; - static const MFCLOCK_STATE states[CLOCK_CMD_MAX] = - { - /* CLOCK_CMD_START */ MFCLOCK_STATE_RUNNING, - /* CLOCK_CMD_STOP */ MFCLOCK_STATE_STOPPED, - /* CLOCK_CMD_PAUSE */ MFCLOCK_STATE_PAUSED, - /* CLOCK_CMD_SET_RATE */ 0, /* Unused */ - }; - static const enum clock_notification notifications[CLOCK_CMD_MAX] = - { - /* CLOCK_CMD_START */ CLOCK_NOTIFY_START, - /* CLOCK_CMD_STOP */ CLOCK_NOTIFY_STOP, - /* CLOCK_CMD_PAUSE */ CLOCK_NOTIFY_PAUSE, - /* CLOCK_CMD_SET_RATE */ CLOCK_NOTIFY_SET_RATE, - }; - enum clock_notification notification; - struct clock_sink *sink; - MFCLOCK_STATE old_state; - IMFAsyncResult *result; - MFTIME system_time; - HRESULT hr; - - if (!clock->time_source) - return MF_E_CLOCK_NO_TIME_SOURCE; - - if (command != CLOCK_CMD_SET_RATE && clock->state == states[command] && clock->state != MFCLOCK_STATE_RUNNING) - return MF_E_CLOCK_STATE_ALREADY_SET; - - if (!state_change_is_allowed[clock->state][command]) - return MF_E_INVALIDREQUEST; - - system_time = MFGetSystemTime(); - - if (command == CLOCK_CMD_START && clock->state == MFCLOCK_STATE_PAUSED && - param.u.offset == PRESENTATION_CURRENT_POSITION) - { - notification = CLOCK_NOTIFY_RESTART; - } - else - notification = notifications[command]; - - if (FAILED(hr = clock_call_state_change(system_time, param, notification, clock->time_source_sink))) - return hr; - - old_state = clock->state; - if (command != CLOCK_CMD_SET_RATE) - clock->state = states[command]; - - /* Dump all pending timer requests immediately on start; otherwise try to cancel scheduled items when - transitioning from running state. */ - if ((clock->state == MFCLOCK_STATE_RUNNING) ^ (old_state == MFCLOCK_STATE_RUNNING)) - { - struct clock_timer *timer, *timer2; - - if (clock->state == MFCLOCK_STATE_RUNNING) - { - LIST_FOR_EACH_ENTRY_SAFE(timer, timer2, &clock->timers, struct clock_timer, entry) - { - list_remove(&timer->entry); - hr = MFCreateAsyncResult(&timer->IUnknown_iface, &clock->timer_callback, NULL, &result); - IUnknown_Release(&timer->IUnknown_iface); - if (SUCCEEDED(hr)) - { - MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_TIMER, result); - IMFAsyncResult_Release(result); - } - } - } - else - { - LIST_FOR_EACH_ENTRY(timer, &clock->timers, struct clock_timer, entry) - { - if (timer->key) - { - MFCancelWorkItem(timer->key); - timer->key = 0; - } - } - } - } - - LIST_FOR_EACH_ENTRY(sink, &clock->sinks, struct clock_sink, entry) - { - clock_notify_async_sink(clock, system_time, param, notification, sink->state_sink); - } - - return S_OK; -} - -static HRESULT WINAPI present_clock_Start(IMFPresentationClock *iface, LONGLONG start_offset) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - struct clock_state_change_param param = {{0}}; - HRESULT hr; - - TRACE("%p, %s.\n", iface, debugstr_time(start_offset)); - - EnterCriticalSection(&clock->cs); - clock->start_offset = param.u.offset = start_offset; - hr = clock_change_state(clock, CLOCK_CMD_START, param); - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static HRESULT WINAPI present_clock_Stop(IMFPresentationClock *iface) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - struct clock_state_change_param param = {{0}}; - HRESULT hr; - - TRACE("%p.\n", iface); - - EnterCriticalSection(&clock->cs); - hr = clock_change_state(clock, CLOCK_CMD_STOP, param); - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static HRESULT WINAPI present_clock_Pause(IMFPresentationClock *iface) -{ - struct presentation_clock *clock = impl_from_IMFPresentationClock(iface); - struct clock_state_change_param param = {{0}}; - HRESULT hr; - - TRACE("%p.\n", iface); - - EnterCriticalSection(&clock->cs); - hr = clock_change_state(clock, CLOCK_CMD_PAUSE, param); - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static const IMFPresentationClockVtbl presentationclockvtbl = -{ - present_clock_QueryInterface, - present_clock_AddRef, - present_clock_Release, - present_clock_GetClockCharacteristics, - present_clock_GetCorrelatedTime, - present_clock_GetContinuityKey, - present_clock_GetState, - present_clock_GetProperties, - present_clock_SetTimeSource, - present_clock_GetTimeSource, - present_clock_GetTime, - present_clock_AddClockStateSink, - present_clock_RemoveClockStateSink, - present_clock_Start, - present_clock_Stop, - present_clock_Pause, -}; - -static HRESULT WINAPI present_clock_rate_control_QueryInterface(IMFRateControl *iface, REFIID riid, void **out) -{ - struct presentation_clock *clock = impl_from_IMFRateControl(iface); - return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out); -} - -static ULONG WINAPI present_clock_rate_control_AddRef(IMFRateControl *iface) -{ - struct presentation_clock *clock = impl_from_IMFRateControl(iface); - return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface); -} - -static ULONG WINAPI present_clock_rate_control_Release(IMFRateControl *iface) -{ - struct presentation_clock *clock = impl_from_IMFRateControl(iface); - return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface); -} - -static HRESULT WINAPI present_clock_rate_SetRate(IMFRateControl *iface, BOOL thin, float rate) -{ - struct presentation_clock *clock = impl_from_IMFRateControl(iface); - struct clock_state_change_param param; - HRESULT hr; - - TRACE("%p, %d, %f.\n", iface, thin, rate); - - if (thin) - return MF_E_THINNING_UNSUPPORTED; - - EnterCriticalSection(&clock->cs); - param.u.rate = rate; - if (SUCCEEDED(hr = clock_change_state(clock, CLOCK_CMD_SET_RATE, param))) - clock->rate = rate; - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static HRESULT WINAPI present_clock_rate_GetRate(IMFRateControl *iface, BOOL *thin, float *rate) -{ - struct presentation_clock *clock = impl_from_IMFRateControl(iface); - - TRACE("%p, %p, %p.\n", iface, thin, rate); - - if (!rate) - return E_INVALIDARG; - - if (thin) - *thin = FALSE; - - EnterCriticalSection(&clock->cs); - *rate = clock->rate; - LeaveCriticalSection(&clock->cs); - - return S_OK; -} - -static const IMFRateControlVtbl presentclockratecontrolvtbl = -{ - present_clock_rate_control_QueryInterface, - present_clock_rate_control_AddRef, - present_clock_rate_control_Release, - present_clock_rate_SetRate, - present_clock_rate_GetRate, -}; - -static HRESULT WINAPI present_clock_timer_QueryInterface(IMFTimer *iface, REFIID riid, void **out) -{ - struct presentation_clock *clock = impl_from_IMFTimer(iface); - return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out); -} - -static ULONG WINAPI present_clock_timer_AddRef(IMFTimer *iface) -{ - struct presentation_clock *clock = impl_from_IMFTimer(iface); - return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface); -} - -static ULONG WINAPI present_clock_timer_Release(IMFTimer *iface) -{ - struct presentation_clock *clock = impl_from_IMFTimer(iface); - return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface); -} - -static HRESULT present_clock_schedule_timer(struct presentation_clock *clock, DWORD flags, LONGLONG time, - struct clock_timer *timer) -{ - IMFAsyncResult *result; - MFTIME systime, clocktime; - LONGLONG frequency; - HRESULT hr; - - if (!(flags & MFTIMER_RELATIVE)) - { - if (FAILED(hr = IMFPresentationTimeSource_GetCorrelatedTime(clock->time_source, 0, &clocktime, &systime))) - { - WARN("Failed to get clock time, hr %#x.\n", hr); - return hr; - } - time -= clocktime; - } - - frequency = clock->frequency / 1000; - time /= frequency; - - /* Scheduled item is using clock instance callback, with timer instance as an object. Clock callback will - call user callback and cleanup timer list. */ - - if (FAILED(hr = MFCreateAsyncResult(&timer->IUnknown_iface, &clock->timer_callback, NULL, &result))) - return hr; - - hr = MFScheduleWorkItemEx(result, -time, &timer->key); - IMFAsyncResult_Release(result); - - return hr; -} - -static HRESULT WINAPI clock_timer_QueryInterface(IUnknown *iface, REFIID riid, void **obj) -{ - if (IsEqualIID(riid, &IID_IUnknown)) - { - *obj = iface; - IUnknown_AddRef(iface); - return S_OK; - } - - *obj = NULL; - return E_NOINTERFACE; -} - -static ULONG WINAPI clock_timer_AddRef(IUnknown *iface) -{ - struct clock_timer *timer = impl_clock_timer_from_IUnknown(iface); - return InterlockedIncrement(&timer->refcount); -} - -static ULONG WINAPI clock_timer_Release(IUnknown *iface) -{ - struct clock_timer *timer = impl_clock_timer_from_IUnknown(iface); - ULONG refcount = InterlockedDecrement(&timer->refcount); - - if (!refcount) - { - IMFAsyncResult_Release(timer->result); - IMFAsyncCallback_Release(timer->callback); - heap_free(timer); - } - - return refcount; -} - -static const IUnknownVtbl clock_timer_vtbl = -{ - clock_timer_QueryInterface, - clock_timer_AddRef, - clock_timer_Release, -}; - -static HRESULT WINAPI present_clock_timer_SetTimer(IMFTimer *iface, DWORD flags, LONGLONG time, - IMFAsyncCallback *callback, IUnknown *state, IUnknown **cancel_key) -{ - struct presentation_clock *clock = impl_from_IMFTimer(iface); - struct clock_timer *clock_timer; - HRESULT hr; - - TRACE("%p, %#x, %s, %p, %p, %p.\n", iface, flags, debugstr_time(time), callback, state, cancel_key); - - if (!(clock_timer = heap_alloc_zero(sizeof(*clock_timer)))) - return E_OUTOFMEMORY; - - if (FAILED(hr = MFCreateAsyncResult(NULL, NULL, state, &clock_timer->result))) - { - heap_free(clock_timer); - return hr; - } - - clock_timer->IUnknown_iface.lpVtbl = &clock_timer_vtbl; - clock_timer->refcount = 1; - clock_timer->callback = callback; - IMFAsyncCallback_AddRef(clock_timer->callback); - - EnterCriticalSection(&clock->cs); - - if (clock->state == MFCLOCK_STATE_RUNNING) - hr = present_clock_schedule_timer(clock, flags, time, clock_timer); - else if (clock->state == MFCLOCK_STATE_STOPPED) - hr = MF_S_CLOCK_STOPPED; - - if (SUCCEEDED(hr)) - { - list_add_tail(&clock->timers, &clock_timer->entry); - if (cancel_key) - { - *cancel_key = &clock_timer->IUnknown_iface; - IUnknown_AddRef(*cancel_key); - } - } - - LeaveCriticalSection(&clock->cs); - - if (FAILED(hr)) - IUnknown_Release(&clock_timer->IUnknown_iface); - - return hr; -} - -static HRESULT WINAPI present_clock_timer_CancelTimer(IMFTimer *iface, IUnknown *cancel_key) -{ - struct presentation_clock *clock = impl_from_IMFTimer(iface); - struct clock_timer *timer; - - TRACE("%p, %p.\n", iface, cancel_key); - - EnterCriticalSection(&clock->cs); - - LIST_FOR_EACH_ENTRY(timer, &clock->timers, struct clock_timer, entry) - { - if (&timer->IUnknown_iface == cancel_key) - { - list_remove(&timer->entry); - if (timer->key) - { - MFCancelWorkItem(timer->key); - timer->key = 0; - } - IUnknown_Release(&timer->IUnknown_iface); - break; - } - } - - LeaveCriticalSection(&clock->cs); - - return S_OK; -} - -static const IMFTimerVtbl presentclocktimervtbl = -{ - present_clock_timer_QueryInterface, - present_clock_timer_AddRef, - present_clock_timer_Release, - present_clock_timer_SetTimer, - present_clock_timer_CancelTimer, -}; - -static HRESULT WINAPI present_clock_shutdown_QueryInterface(IMFShutdown *iface, REFIID riid, void **out) -{ - struct presentation_clock *clock = impl_from_IMFShutdown(iface); - return IMFPresentationClock_QueryInterface(&clock->IMFPresentationClock_iface, riid, out); -} - -static ULONG WINAPI present_clock_shutdown_AddRef(IMFShutdown *iface) -{ - struct presentation_clock *clock = impl_from_IMFShutdown(iface); - return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface); -} - -static ULONG WINAPI present_clock_shutdown_Release(IMFShutdown *iface) -{ - struct presentation_clock *clock = impl_from_IMFShutdown(iface); - return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface); -} - -static HRESULT WINAPI present_clock_shutdown_Shutdown(IMFShutdown *iface) -{ - struct presentation_clock *clock = impl_from_IMFShutdown(iface); - - TRACE("%p.\n", iface); - - EnterCriticalSection(&clock->cs); - clock->is_shut_down = TRUE; - LeaveCriticalSection(&clock->cs); - - return S_OK; -} - -static HRESULT WINAPI present_clock_shutdown_GetShutdownStatus(IMFShutdown *iface, MFSHUTDOWN_STATUS *status) -{ - struct presentation_clock *clock = impl_from_IMFShutdown(iface); - HRESULT hr = S_OK; - - TRACE("%p, %p.\n", iface, status); - - if (!status) - return E_INVALIDARG; - - EnterCriticalSection(&clock->cs); - if (clock->is_shut_down) - *status = MFSHUTDOWN_COMPLETED; - else - hr = MF_E_INVALIDREQUEST; - LeaveCriticalSection(&clock->cs); - - return hr; -} - -static const IMFShutdownVtbl presentclockshutdownvtbl = -{ - present_clock_shutdown_QueryInterface, - present_clock_shutdown_AddRef, - present_clock_shutdown_Release, - present_clock_shutdown_Shutdown, - present_clock_shutdown_GetShutdownStatus, -}; - -static HRESULT WINAPI present_clock_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **out) -{ - if (IsEqualIID(riid, &IID_IMFAsyncCallback) || - IsEqualIID(riid, &IID_IUnknown)) - { - *out = iface; - IMFAsyncCallback_AddRef(iface); - return S_OK; - } - - WARN("Unsupported %s.\n", wine_dbgstr_guid(riid)); - *out = NULL; - return E_NOINTERFACE; -} - -static ULONG WINAPI present_clock_sink_callback_AddRef(IMFAsyncCallback *iface) -{ - struct presentation_clock *clock = impl_from_sink_callback_IMFAsyncCallback(iface); - return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface); -} - -static ULONG WINAPI present_clock_sink_callback_Release(IMFAsyncCallback *iface) -{ - struct presentation_clock *clock = impl_from_sink_callback_IMFAsyncCallback(iface); - return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface); -} - -static HRESULT WINAPI present_clock_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue) -{ - return E_NOTIMPL; -} - -static HRESULT WINAPI present_clock_sink_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result) -{ - struct sink_notification *data; - IUnknown *object; - HRESULT hr; - - if (FAILED(hr = IMFAsyncResult_GetObject(result, &object))) - return hr; - - data = impl_sink_notification_from_IUnknown(object); - - clock_call_state_change(data->system_time, data->param, data->notification, data->sink); - - IUnknown_Release(object); - - return S_OK; -} - -static const IMFAsyncCallbackVtbl presentclocksinkcallbackvtbl = -{ - present_clock_callback_QueryInterface, - present_clock_sink_callback_AddRef, - present_clock_sink_callback_Release, - present_clock_callback_GetParameters, - present_clock_sink_callback_Invoke, -}; - -static ULONG WINAPI present_clock_timer_callback_AddRef(IMFAsyncCallback *iface) -{ - struct presentation_clock *clock = impl_from_timer_callback_IMFAsyncCallback(iface); - return IMFPresentationClock_AddRef(&clock->IMFPresentationClock_iface); -} - -static ULONG WINAPI present_clock_timer_callback_Release(IMFAsyncCallback *iface) -{ - struct presentation_clock *clock = impl_from_timer_callback_IMFAsyncCallback(iface); - return IMFPresentationClock_Release(&clock->IMFPresentationClock_iface); -} - -static HRESULT WINAPI present_clock_timer_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result) -{ - struct presentation_clock *clock = impl_from_timer_callback_IMFAsyncCallback(iface); - struct clock_timer *timer; - IUnknown *object; - HRESULT hr; - - if (FAILED(hr = IMFAsyncResult_GetObject(result, &object))) - return hr; - - timer = impl_clock_timer_from_IUnknown(object); - - EnterCriticalSection(&clock->cs); - list_remove(&timer->entry); - IUnknown_Release(&timer->IUnknown_iface); - LeaveCriticalSection(&clock->cs); - - IMFAsyncCallback_Invoke(timer->callback, timer->result); - - IUnknown_Release(object); - - return S_OK; -} - -static const IMFAsyncCallbackVtbl presentclocktimercallbackvtbl = -{ - present_clock_callback_QueryInterface, - present_clock_timer_callback_AddRef, - present_clock_timer_callback_Release, - present_clock_callback_GetParameters, - present_clock_timer_callback_Invoke, -}; - -/*********************************************************************** - * MFCreatePresentationClock (mf.@) - */ -HRESULT WINAPI MFCreatePresentationClock(IMFPresentationClock **clock) -{ - struct presentation_clock *object; - - TRACE("%p.\n", clock); - - object = heap_alloc_zero(sizeof(*object)); - if (!object) - return E_OUTOFMEMORY; - - object->IMFPresentationClock_iface.lpVtbl = &presentationclockvtbl; - object->IMFRateControl_iface.lpVtbl = &presentclockratecontrolvtbl; - object->IMFTimer_iface.lpVtbl = &presentclocktimervtbl; - object->IMFShutdown_iface.lpVtbl = &presentclockshutdownvtbl; - object->sink_callback.lpVtbl = &presentclocksinkcallbackvtbl; - object->timer_callback.lpVtbl = &presentclocktimercallbackvtbl; - object->refcount = 1; - list_init(&object->sinks); - list_init(&object->timers); - object->rate = 1.0f; - InitializeCriticalSection(&object->cs); - - *clock = &object->IMFPresentationClock_iface; - - return S_OK; -} - static HRESULT WINAPI standard_quality_manager_QueryInterface(IMFQualityManager *iface, REFIID riid, void **out) { struct quality_manager *manager = impl_from_IMFQualityManager(iface); -- 2.30.2

1 3

[PATCH v3 2/2] d3dx10/tests: Test subresource data for created texture.
by Ziqing Hui 15 Jun '21

15 Jun '21

Signed-off-by: Ziqing Hui <zhui(a)codeweavers.com> --- v2: * Merge 2 patches. * Get rid of shift operation. * Replace copy_texture with get_texuture_readback. * Use winetest_push_context rather than "Test %u:". * Release created texture. * Only use D3D10_CPU_ACCESS_READ for readback. v3: Fix test crash. dlls/d3dx10_43/tests/d3dx10.c | 458 +++++++++++++++++++++++++++++----- 1 file changed, 394 insertions(+), 64 deletions(-)

2 1

[PATCH v3 1/2] d3dx10/tests: Use winetest_push_context.
by Ziqing Hui 15 Jun '21

15 Jun '21

Signed-off-by: Ziqing Hui <zhui(a)codeweavers.com> --- v2: This is a new patch in patch set. v3: No changes. dlls/d3dx10_43/tests/d3dx10.c | 205 ++++++++++++++++++---------------- 1 file changed, 108 insertions(+), 97 deletions(-)

2 1

[PATCH] winegstreamer: Let async command handle request token.
by Nikolay Sivov 15 Jun '21

15 Jun '21

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/winegstreamer/media_source.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/dlls/winegstreamer/media_source.c b/dlls/winegstreamer/media_source.c index 3c87bbb2146..9c554c7c415 100644 --- a/dlls/winegstreamer/media_source.c +++ b/dlls/winegstreamer/media_source.c @@ -170,6 +170,11 @@ static ULONG WINAPI source_async_command_Release(IUnknown *iface) { if (command->op == SOURCE_ASYNC_START) PropVariantClear(&command->u.start.position); + else if (command->op == SOURCE_ASYNC_REQUEST_SAMPLE) + { + if (command->u.request_sample.token) + IUnknown_Release(command->u.request_sample.token); + } free(command); } @@ -467,8 +472,6 @@ static void wait_on_sample(struct media_stream *stream, IUnknown *token) case WG_PARSER_EVENT_EOS: stream->eos = TRUE; - if (token) - IUnknown_Release(token); IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEEndOfStream, &GUID_NULL, S_OK, &empty_var); dispatch_end_of_presentation(stream->parent_source); return; -- 2.30.2

1 0

[PATCH v4] iphlpapi: Fix the field 'AdapterName' of IP_ADAPTER_INFO returned by GetAdaptersInfo.
by Yeshun Ye 15 Jun '21

15 Jun '21

Signed-off-by: Yeshun Ye <yeyeshun(a)uniontech.com> --- dlls/iphlpapi/iphlpapi_main.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/dlls/iphlpapi/iphlpapi_main.c b/dlls/iphlpapi/iphlpapi_main.c index 09414d26dde..21edd9ee128 100644 --- a/dlls/iphlpapi/iphlpapi_main.c +++ b/dlls/iphlpapi/iphlpapi_main.c @@ -706,9 +706,16 @@ DWORD WINAPI GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen) DWORD i; PIP_ADDR_STRING currentIPAddr = &ptr->IpAddressList; BOOL firstIPAddr = TRUE; + NET_LUID luid; + GUID guid; /* on Win98 this is left empty, but whatever */ - getInterfaceNameByIndex(table->indexes[ndx], ptr->AdapterName); + ConvertInterfaceIndexToLuid(table->indexes[ndx], &luid); + ConvertInterfaceLuidToGuid(&luid, &guid); + sprintf(ptr->AdapterName, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", + guid.Data1, guid.Data2, guid.Data3, guid.Data4[0], guid.Data4[1], + guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5], + guid.Data4[6], guid.Data4[7]); getInterfaceNameByIndex(table->indexes[ndx], ptr->Description); ptr->AddressLength = sizeof(ptr->Address); getInterfacePhysicalByIndex(table->indexes[ndx], -- 2.20.1

2 1

[PATCH 1/7] server: Implement IOCTL_AFD_GET_EVENTS.
by Zebediah Figura 15 Jun '21

15 Jun '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/ntdll/unix/socket.c | 6 ++++++ include/wine/afd.h | 7 +++++++ server/sock.c | 22 ++++++++++++++++++++++ 3 files changed, 35 insertions(+) diff --git a/dlls/ntdll/unix/socket.c b/dlls/ntdll/unix/socket.c index 088f29f85ff..3b8206474f0 100644 --- a/dlls/ntdll/unix/socket.c +++ b/dlls/ntdll/unix/socket.c @@ -1181,6 +1181,12 @@ NTSTATUS sock_ioctl( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc break; } + case IOCTL_AFD_GET_EVENTS: + if (in_size) FIXME( "unexpected input size %u\n", in_size ); + + status = STATUS_BAD_DEVICE_TYPE; + break; + case IOCTL_AFD_RECV: { const struct afd_recv_params *params = in_buffer; diff --git a/include/wine/afd.h b/include/wine/afd.h index 2eb3e6f12a9..46d242c7582 100644 --- a/include/wine/afd.h +++ b/include/wine/afd.h @@ -36,6 +36,7 @@ #define IOCTL_AFD_RECV CTL_CODE(FILE_DEVICE_BEEP, 0x805, METHOD_NEITHER, FILE_ANY_ACCESS) #define IOCTL_AFD_POLL CTL_CODE(FILE_DEVICE_BEEP, 0x809, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_AFD_EVENT_SELECT CTL_CODE(FILE_DEVICE_BEEP, 0x821, METHOD_NEITHER, FILE_ANY_ACCESS) +#define IOCTL_AFD_GET_EVENTS CTL_CODE(FILE_DEVICE_BEEP, 0x822, METHOD_NEITHER, FILE_ANY_ACCESS) enum afd_poll_bit { @@ -125,6 +126,12 @@ struct afd_event_select_params_32 int mask; }; +struct afd_get_events_params +{ + int flags; + NTSTATUS status[13]; +}; + #define IOCTL_AFD_WINE_CREATE CTL_CODE(FILE_DEVICE_NETWORK, 200, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_AFD_WINE_ACCEPT CTL_CODE(FILE_DEVICE_NETWORK, 201, METHOD_BUFFERED, FILE_ANY_ACCESS) #define IOCTL_AFD_WINE_ACCEPT_INTO CTL_CODE(FILE_DEVICE_NETWORK, 202, METHOD_BUFFERED, FILE_ANY_ACCESS) diff --git a/server/sock.c b/server/sock.c index 3556ee21aa3..1d992d8f9e4 100644 --- a/server/sock.c +++ b/server/sock.c @@ -2011,6 +2011,28 @@ static int sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async ) } return 1; + case IOCTL_AFD_GET_EVENTS: + { + struct afd_get_events_params params = {0}; + unsigned int i; + + if (get_reply_max_size() < sizeof(params)) + { + set_error( STATUS_INVALID_PARAMETER ); + return 0; + } + + params.flags = sock->pending_events & sock->mask; + for (i = 0; i < ARRAY_SIZE( params.status ); ++i) + params.status[i] = sock_get_ntstatus( sock->errors[i] ); + + sock->pending_events = 0; + sock_reselect( sock ); + + set_reply_data( &params, sizeof(params) ); + return 0; + } + case IOCTL_AFD_EVENT_SELECT: { struct event *event = NULL; -- 2.30.2

2 7

[PATCH v3] gdi32: Partially implement HALFTONE stretch mode.
by Zhiyi Zhang 15 Jun '21

15 Jun '21

COLORONCOLOR(STRETCH_DELETESCANS) was used in place of HALFTONE. COLORONCOLOR mode may delete rows of pixels without trying to preserve information so it will cause Wine to render poorly when the destination rectangle is small. According to tests, HALFTONE mode uses box filter when doing integer downscaling and nearest neighbor interpolation when doing upscaling in both horizontally and vertically. In other cases, HALFTONE mode uses a lanczos3 like algorithm to interpolate pixels. There are also other heuristics involved. For example, shrinking a 2x2 image to 1x1 may not use box filter depending on image data. Since this algorithm is undocumented, it's difficult to reverse engineer the original algorithm and produce identical results. Instead, this patch uses a naive implementation of bilinear interpolation to implement HALFTONE mode and it produces good quality images. For 8-bit and lower color depth images, nulldrv_StretchBlt should resize the images first and then converts color depth. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=46375 Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- v3: Supersede 206858. Mark some user32 cursoricon tests as todo because they end up using HALFTONE mode and compare the exact data values. As said in the commit message, this patch doesn't produce identical results. Previously the cursoricon tests can succeed are coincidences. They will fail if source image changes. dlls/gdi32/dibdrv/bitblt.c | 7 + dlls/gdi32/dibdrv/dibdrv.h | 2 + dlls/gdi32/dibdrv/primitives.c | 629 ++++++++++++++++++++++++++++++++- dlls/user32/tests/cursoricon.c | 18 +- 4 files changed, 640 insertions(+), 16 deletions(-) diff --git a/dlls/gdi32/dibdrv/bitblt.c b/dlls/gdi32/dibdrv/bitblt.c index d2f59965b02..9b46ad2916f 100644 --- a/dlls/gdi32/dibdrv/bitblt.c +++ b/dlls/gdi32/dibdrv/bitblt.c @@ -1216,6 +1216,12 @@ DWORD stretch_bitmapinfo( const BITMAPINFO *src_info, void *src_bits, struct bit init_dib_info_from_bitmapinfo( &src_dib, src_info, src_bits ); init_dib_info_from_bitmapinfo( &dst_dib, dst_info, dst_bits ); + if (mode == HALFTONE) + { + dst_dib.funcs->halftone( &dst_dib, dst, &src_dib, src ); + goto done; + } + /* v */ ret = calc_1d_stretch_params( dst->y, dst->height, dst->visrect.top, dst->visrect.bottom, src->y, src->height, src->visrect.top, src->visrect.bottom, @@ -1300,6 +1306,7 @@ DWORD stretch_bitmapinfo( const BITMAPINFO *src_info, void *src_bits, struct bit } } +done: /* update coordinates, the destination rectangle is always stored at 0,0 */ *src = *dst; src->x -= src->visrect.left; diff --git a/dlls/gdi32/dibdrv/dibdrv.h b/dlls/gdi32/dibdrv/dibdrv.h index d3a35b96c75..0492c0bd51e 100644 --- a/dlls/gdi32/dibdrv/dibdrv.h +++ b/dlls/gdi32/dibdrv/dibdrv.h @@ -211,6 +211,8 @@ typedef struct primitive_funcs void (* shrink_row)(const dib_info *dst_dib, const POINT *dst_start, const dib_info *src_dib, const POINT *src_start, const struct stretch_params *params, int mode, BOOL keep_dst); + void (* halftone)(const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src); } primitive_funcs; extern const primitive_funcs funcs_8888 DECLSPEC_HIDDEN; diff --git a/dlls/gdi32/dibdrv/primitives.c b/dlls/gdi32/dibdrv/primitives.c index e4b18a6656d..5eca124b918 100644 --- a/dlls/gdi32/dibdrv/primitives.c +++ b/dlls/gdi32/dibdrv/primitives.c @@ -7430,6 +7430,608 @@ static void shrink_row_null(const dib_info *dst_dib, const POINT *dst_start, return; } +static float clampf( float value, float min, float max ) +{ + return max( min, min( value, max ) ); +} + +static int clamp( int value, int min, int max ) +{ + return max( min, min( value, max ) ); +} + +static BYTE linear_interpolate( BYTE start, BYTE end, float delta ) +{ + return start + (end - start) * delta + 0.5f; +} + +static BYTE bilinear_interpolate( BYTE c00, BYTE c01, BYTE c10, BYTE c11, float dx, float dy ) +{ + return linear_interpolate( linear_interpolate( c00, c01, dx ), + linear_interpolate( c10, c11, dx ), dy ); +} + +static void calc_halftone_params( const struct bitblt_coords *dst, const struct bitblt_coords *src, + RECT *dst_rect, RECT *src_rect, int *src_start_x, + int *src_start_y, float *src_inc_x, float *src_inc_y ) +{ + int src_width, src_height, dst_width, dst_height; + BOOL mirrored_x, mirrored_y; + + get_bounding_rect( src_rect, src->x, src->y, src->width, src->height ); + get_bounding_rect( dst_rect, dst->x, dst->y, dst->width, dst->height ); + intersect_rect( src_rect, &src->visrect, src_rect ); + intersect_rect( dst_rect, &dst->visrect, dst_rect ); + offset_rect( dst_rect, -dst_rect->left, -dst_rect->top ); + + src_width = src_rect->right - src_rect->left; + src_height = src_rect->bottom - src_rect->top; + dst_width = dst_rect->right - dst_rect->left; + dst_height = dst_rect->bottom - dst_rect->top; + + mirrored_x = (dst->width < 0) != (src->width < 0); + mirrored_y = (dst->height < 0) != (src->height < 0); + *src_start_x = mirrored_x ? src_rect->right - 1 : src_rect->left; + *src_start_y = mirrored_y ? src_rect->bottom - 1 : src_rect->top; + *src_inc_x = mirrored_x ? -(float)src_width / dst_width : (float)src_width / dst_width; + *src_inc_y = mirrored_y ? -(float)src_height / dst_height : (float)src_height / dst_height; +} + +static void halftone_888( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + DWORD *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE c00_r, c01_r, c10_r, c11_r; + BYTE c00_g, c01_g, c10_g, c11_g; + BYTE c00_b, c01_b, c10_b, c11_b; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + dst_ptr = get_pixel_ptr_32( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_32( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride / 4; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0; + c01_ptr = src_ptr + x1; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00_r = (*c00_ptr >> 16) & 0xff; + c01_r = (*c01_ptr >> 16) & 0xff; + c10_r = (*c10_ptr >> 16) & 0xff; + c11_r = (*c11_ptr >> 16) & 0xff; + c00_g = (*c00_ptr >> 8) & 0xff; + c01_g = (*c01_ptr >> 8) & 0xff; + c10_g = (*c10_ptr >> 8) & 0xff; + c11_g = (*c11_ptr >> 8) & 0xff; + c00_b = *c00_ptr & 0xff; + c01_b = *c01_ptr & 0xff; + c10_b = *c10_ptr & 0xff; + c11_b = *c11_ptr & 0xff; + r = bilinear_interpolate( c00_r, c01_r, c10_r, c11_r, dx, dy ); + g = bilinear_interpolate( c00_g, c01_g, c10_g, c11_g, dx, dy ); + b = bilinear_interpolate( c00_b, c01_b, c10_b, c11_b, dx, dy ); + dst_ptr[dst_x] = ((r << 16) & 0xff0000) | ((g << 8) & 0x00ff00) | (b & 0x0000ff); + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride / 4; + float_y += src_inc_y; + } +} + +static void halftone_32( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + DWORD *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE c00_r, c01_r, c10_r, c11_r; + BYTE c00_g, c01_g, c10_g, c11_g; + BYTE c00_b, c01_b, c10_b, c11_b; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + dst_ptr = get_pixel_ptr_32( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_32( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride / 4; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0; + c01_ptr = src_ptr + x1; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00_r = get_field( *c00_ptr, src_dib->red_shift, src_dib->red_len ); + c01_r = get_field( *c01_ptr, src_dib->red_shift, src_dib->red_len ); + c10_r = get_field( *c10_ptr, src_dib->red_shift, src_dib->red_len ); + c11_r = get_field( *c11_ptr, src_dib->red_shift, src_dib->red_len ); + c00_g = get_field( *c00_ptr, src_dib->green_shift, src_dib->green_len ); + c01_g = get_field( *c01_ptr, src_dib->green_shift, src_dib->green_len ); + c10_g = get_field( *c10_ptr, src_dib->green_shift, src_dib->green_len ); + c11_g = get_field( *c11_ptr, src_dib->green_shift, src_dib->green_len ); + c00_b = get_field( *c00_ptr, src_dib->blue_shift, src_dib->blue_len ); + c01_b = get_field( *c01_ptr, src_dib->blue_shift, src_dib->blue_len ); + c10_b = get_field( *c10_ptr, src_dib->blue_shift, src_dib->blue_len ); + c11_b = get_field( *c11_ptr, src_dib->blue_shift, src_dib->blue_len ); + r = bilinear_interpolate( c00_r, c01_r, c10_r, c11_r, dx, dy ); + g = bilinear_interpolate( c00_g, c01_g, c10_g, c11_g, dx, dy ); + b = bilinear_interpolate( c00_b, c01_b, c10_b, c11_b, dx, dy ); + dst_ptr[dst_x] = rgb_to_pixel_masks( dst_dib, r, g, b ); + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride / 4; + float_y += src_inc_y; + } +} + +static void halftone_24( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + BYTE *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE c00_r, c01_r, c10_r, c11_r; + BYTE c00_g, c01_g, c10_g, c11_g; + BYTE c00_b, c01_b, c10_b, c11_b; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + dst_ptr = get_pixel_ptr_24( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_24( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0 * 3; + c01_ptr = src_ptr + x1 * 3; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00_b = c00_ptr[0]; + c01_b = c01_ptr[0]; + c10_b = c10_ptr[0]; + c11_b = c11_ptr[0]; + c00_g = c00_ptr[1]; + c01_g = c01_ptr[1]; + c10_g = c10_ptr[1]; + c11_g = c11_ptr[1]; + c00_r = c00_ptr[2]; + c01_r = c01_ptr[2]; + c10_r = c10_ptr[2]; + c11_r = c11_ptr[2]; + r = bilinear_interpolate( c00_r, c01_r, c10_r, c11_r, dx, dy ); + g = bilinear_interpolate( c00_g, c01_g, c10_g, c11_g, dx, dy ); + b = bilinear_interpolate( c00_b, c01_b, c10_b, c11_b, dx, dy ); + dst_ptr[dst_x * 3] = b; + dst_ptr[dst_x * 3 + 1] = g; + dst_ptr[dst_x * 3 + 2] = r; + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride; + float_y += src_inc_y; + } +} + +static void halftone_555( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + WORD *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE c00_r, c01_r, c10_r, c11_r; + BYTE c00_g, c01_g, c10_g, c11_g; + BYTE c00_b, c01_b, c10_b, c11_b; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + dst_ptr = get_pixel_ptr_16( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_16( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride / 2; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0; + c01_ptr = src_ptr + x1; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00_r = ((*c00_ptr >> 7) & 0xf8) | ((*c00_ptr >> 12) & 0x07); + c01_r = ((*c01_ptr >> 7) & 0xf8) | ((*c01_ptr >> 12) & 0x07); + c10_r = ((*c10_ptr >> 7) & 0xf8) | ((*c10_ptr >> 12) & 0x07); + c11_r = ((*c11_ptr >> 7) & 0xf8) | ((*c11_ptr >> 12) & 0x07); + c00_g = ((*c00_ptr >> 2) & 0xf8) | ((*c00_ptr >> 7) & 0x07); + c01_g = ((*c01_ptr >> 2) & 0xf8) | ((*c01_ptr >> 7) & 0x07); + c10_g = ((*c10_ptr >> 2) & 0xf8) | ((*c10_ptr >> 7) & 0x07); + c11_g = ((*c11_ptr >> 2) & 0xf8) | ((*c11_ptr >> 7) & 0x07); + c00_b = ((*c00_ptr << 3) & 0xf8) | ((*c00_ptr >> 2) & 0x07); + c01_b = ((*c01_ptr << 3) & 0xf8) | ((*c01_ptr >> 2) & 0x07); + c10_b = ((*c10_ptr << 3) & 0xf8) | ((*c10_ptr >> 2) & 0x07); + c11_b = ((*c11_ptr << 3) & 0xf8) | ((*c11_ptr >> 2) & 0x07); + r = bilinear_interpolate( c00_r, c01_r, c10_r, c11_r, dx, dy ); + g = bilinear_interpolate( c00_g, c01_g, c10_g, c11_g, dx, dy ); + b = bilinear_interpolate( c00_b, c01_b, c10_b, c11_b, dx, dy ); + dst_ptr[dst_x] = ((r << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((b >> 3) & 0x001f); + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride / 2; + float_y += src_inc_y; + } +} + +static void halftone_16( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + WORD *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE c00_r, c01_r, c10_r, c11_r; + BYTE c00_g, c01_g, c10_g, c11_g; + BYTE c00_b, c01_b, c10_b, c11_b; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + dst_ptr = get_pixel_ptr_16( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_16( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride / 2; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0; + c01_ptr = src_ptr + x1; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00_r = get_field( *c00_ptr, src_dib->red_shift, src_dib->red_len ); + c01_r = get_field( *c01_ptr, src_dib->red_shift, src_dib->red_len ); + c10_r = get_field( *c10_ptr, src_dib->red_shift, src_dib->red_len ); + c11_r = get_field( *c11_ptr, src_dib->red_shift, src_dib->red_len ); + c00_g = get_field( *c00_ptr, src_dib->green_shift, src_dib->green_len ); + c01_g = get_field( *c01_ptr, src_dib->green_shift, src_dib->green_len ); + c10_g = get_field( *c10_ptr, src_dib->green_shift, src_dib->green_len ); + c11_g = get_field( *c11_ptr, src_dib->green_shift, src_dib->green_len ); + c00_b = get_field( *c00_ptr, src_dib->blue_shift, src_dib->blue_len ); + c01_b = get_field( *c01_ptr, src_dib->blue_shift, src_dib->blue_len ); + c10_b = get_field( *c10_ptr, src_dib->blue_shift, src_dib->blue_len ); + c11_b = get_field( *c11_ptr, src_dib->blue_shift, src_dib->blue_len ); + r = bilinear_interpolate( c00_r, c01_r, c10_r, c11_r, dx, dy ); + g = bilinear_interpolate( c00_g, c01_g, c10_g, c11_g, dx, dy ); + b = bilinear_interpolate( c00_b, c01_b, c10_b, c11_b, dx, dy ); + dst_ptr[dst_x] = rgb_to_pixel_masks( dst_dib, r, g, b ); + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride / 2; + float_y += src_inc_y; + } +} + +static void halftone_8( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + BYTE *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + RGBQUAD c00_rgb, c01_rgb, c10_rgb, c11_rgb, zero_rgb = {0}; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + const RGBQUAD *src_clr_table; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + src_clr_table = get_dib_color_table( src_dib ); + dst_ptr = get_pixel_ptr_8( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_8( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0; + c01_ptr = src_ptr + x1; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + if (src_clr_table) + { + c00_rgb = *c00_ptr < src_dib->color_table_size ? src_clr_table[*c00_ptr] : zero_rgb; + c01_rgb = *c01_ptr < src_dib->color_table_size ? src_clr_table[*c01_ptr] : zero_rgb; + c10_rgb = *c10_ptr < src_dib->color_table_size ? src_clr_table[*c10_ptr] : zero_rgb; + c11_rgb = *c11_ptr < src_dib->color_table_size ? src_clr_table[*c11_ptr] : zero_rgb; + r = bilinear_interpolate( c00_rgb.rgbRed, c01_rgb.rgbRed, c10_rgb.rgbRed, c11_rgb.rgbRed, dx, dy ); + g = bilinear_interpolate( c00_rgb.rgbGreen, c01_rgb.rgbGreen, c10_rgb.rgbGreen, c11_rgb.rgbGreen, dx, dy ); + b = bilinear_interpolate( c00_rgb.rgbBlue, c01_rgb.rgbBlue, c10_rgb.rgbBlue, c11_rgb.rgbBlue, dx, dy ); + } + else + { + r = 0; + g = 0; + b = 0; + } + dst_ptr[dst_x] = rgb_to_pixel_colortable( dst_dib, r, g, b ); + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride; + float_y += src_inc_y; + } +} + +static void halftone_4( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + BYTE *dst_col_ptr, *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + RGBQUAD c00_rgb, c01_rgb, c10_rgb, c11_rgb, zero_rgb = {0}; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE r, g, b, val, c00, c01, c10, c11; + const RGBQUAD *src_clr_table; + RECT dst_rect, src_rect; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + src_clr_table = get_dib_color_table( src_dib ); + dst_col_ptr = (BYTE *)dst_dib->bits.ptr + (dst_dib->rect.top + dst_rect.top) * dst_dib->stride; + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = (BYTE *)src_dib->bits.ptr + (src_dib->rect.top + y0) * src_dib->stride; + src_ptr_dy = (y1 - y0) * src_dib->stride; + for (dst_x = dst_rect.left; dst_x < dst_rect.right; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + (src_dib->rect.left + x0) / 2; + c01_ptr = src_ptr + (src_dib->rect.left + x1) / 2; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + if ((src_dib->rect.left + x0) & 1) + { + c00 = *c00_ptr & 0x0f; + c10 = *c10_ptr & 0x0f; + } + else + { + c00 = (*c00_ptr >> 4) & 0x0f; + c10 = (*c10_ptr >> 4) & 0x0f; + } + if ((src_dib->rect.left + x1) & 1) + { + c01 = *c01_ptr & 0x0f; + c11 = *c11_ptr & 0x0f; + } + else + { + c01 = (*c01_ptr >> 4) & 0x0f; + c11 = (*c11_ptr >> 4) & 0x0f; + } + + if (src_clr_table) + { + c00_rgb = c00 < src_dib->color_table_size ? src_clr_table[c00] : zero_rgb; + c01_rgb = c01 < src_dib->color_table_size ? src_clr_table[c01] : zero_rgb; + c10_rgb = c10 < src_dib->color_table_size ? src_clr_table[c10] : zero_rgb; + c11_rgb = c11 < src_dib->color_table_size ? src_clr_table[c11] : zero_rgb; + r = bilinear_interpolate( c00_rgb.rgbRed, c01_rgb.rgbRed, c10_rgb.rgbRed, c11_rgb.rgbRed, dx, dy ); + g = bilinear_interpolate( c00_rgb.rgbGreen, c01_rgb.rgbGreen, c10_rgb.rgbGreen, c11_rgb.rgbGreen, dx, dy ); + b = bilinear_interpolate( c00_rgb.rgbBlue, c01_rgb.rgbBlue, c10_rgb.rgbBlue, c11_rgb.rgbBlue, dx, dy ); + } + else + { + r = 0; + g = 0; + b = 0; + } + + dst_ptr = dst_col_ptr + (dst_dib->rect.left + dst_x) / 2; + val = rgb_to_pixel_colortable( dst_dib, r, g, b ); + if ((dst_x + dst_dib->rect.left) & 1) + *dst_ptr = (val & 0x0f) | (*dst_ptr & 0xf0); + else + *dst_ptr = (val << 4) & 0xf0; + + float_x += src_inc_x; + } + + dst_col_ptr += dst_dib->stride; + float_y += src_inc_y; + } +} + +static void halftone_1( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1, bit_pos; + BYTE *dst_col_ptr, *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + RGBQUAD c00_rgb, c01_rgb, c10_rgb, c11_rgb, zero_rgb = {0}; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE r, g, b, val, c00, c01, c10, c11; + const RGBQUAD *src_clr_table; + RECT dst_rect, src_rect; + RGBQUAD bg_entry; + DWORD bg_pixel; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + bg_entry = *get_dib_color_table( dst_dib ); + src_clr_table = get_dib_color_table( src_dib ); + dst_col_ptr = (BYTE *)dst_dib->bits.ptr + (dst_dib->rect.top + dst_rect.top) * dst_dib->stride; + for (dst_y = dst_rect.top; dst_y < dst_rect.bottom; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = (BYTE *)src_dib->bits.ptr + (src_dib->rect.top + y0) * src_dib->stride; + src_ptr_dy = (y1 - y0) * src_dib->stride; + for (dst_x = dst_rect.left; dst_x < dst_rect.right; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + (src_dib->rect.left + x0) / 8; + c01_ptr = src_ptr + (src_dib->rect.left + x1) / 8; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00 = (*c00_ptr & pixel_masks_1[(src_dib->rect.left + x0) & 7]) ? 1 : 0; + c01 = (*c01_ptr & pixel_masks_1[(src_dib->rect.left + x1) & 7]) ? 1 : 0; + c10 = (*c10_ptr & pixel_masks_1[(src_dib->rect.left + x0) & 7]) ? 1 : 0; + c11 = (*c11_ptr & pixel_masks_1[(src_dib->rect.left + x1) & 7]) ? 1 : 0; + + if (src_clr_table) + { + c00_rgb = c00 < src_dib->color_table_size ? src_clr_table[c00] : zero_rgb; + c01_rgb = c01 < src_dib->color_table_size ? src_clr_table[c01] : zero_rgb; + c10_rgb = c10 < src_dib->color_table_size ? src_clr_table[c10] : zero_rgb; + c11_rgb = c11 < src_dib->color_table_size ? src_clr_table[c11] : zero_rgb; + r = bilinear_interpolate( c00_rgb.rgbRed, c01_rgb.rgbRed, c10_rgb.rgbRed, c11_rgb.rgbRed, dx, dy ); + g = bilinear_interpolate( c00_rgb.rgbGreen, c01_rgb.rgbGreen, c10_rgb.rgbGreen, c11_rgb.rgbGreen, dx, dy ); + b = bilinear_interpolate( c00_rgb.rgbBlue, c01_rgb.rgbBlue, c10_rgb.rgbBlue, c11_rgb.rgbBlue, dx, dy ); + } + else + { + r = 0; + g = 0; + b = 0; + } + + dst_ptr = dst_col_ptr + (dst_dib->rect.left + dst_x) / 8; + bit_pos = (dst_x + dst_dib->rect.left) & 7; + bg_pixel = FILTER_DIBINDEX(bg_entry, RGB(bg_entry.rgbRed, bg_entry.rgbGreen, bg_entry.rgbBlue)); + val = rgb_to_pixel_mono( dst_dib, FALSE, dst_x, dst_y, RGB(r, g, b), bg_pixel, r, g, b ); + if (bit_pos == 0) + *dst_ptr = 0; + *dst_ptr = (*dst_ptr & ~pixel_masks_1[bit_pos]) | (val & pixel_masks_1[bit_pos]); + + float_x += src_inc_x; + } + + dst_col_ptr += dst_dib->stride; + float_y += src_inc_y; + } +} + +static void halftone_null( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{} + const primitive_funcs funcs_8888 = { solid_rects_32, @@ -7448,7 +8050,8 @@ const primitive_funcs funcs_8888 = create_rop_masks_32, create_dither_masks_null, stretch_row_32, - shrink_row_32 + shrink_row_32, + halftone_888 }; const primitive_funcs funcs_32 = @@ -7469,7 +8072,8 @@ const primitive_funcs funcs_32 = create_rop_masks_32, create_dither_masks_null, stretch_row_32, - shrink_row_32 + shrink_row_32, + halftone_32 }; const primitive_funcs funcs_24 = @@ -7490,7 +8094,8 @@ const primitive_funcs funcs_24 = create_rop_masks_24, create_dither_masks_null, stretch_row_24, - shrink_row_24 + shrink_row_24, + halftone_24 }; const primitive_funcs funcs_555 = @@ -7511,7 +8116,8 @@ const primitive_funcs funcs_555 = create_rop_masks_16, create_dither_masks_null, stretch_row_16, - shrink_row_16 + shrink_row_16, + halftone_555 }; const primitive_funcs funcs_16 = @@ -7532,7 +8138,8 @@ const primitive_funcs funcs_16 = create_rop_masks_16, create_dither_masks_null, stretch_row_16, - shrink_row_16 + shrink_row_16, + halftone_16 }; const primitive_funcs funcs_8 = @@ -7553,7 +8160,8 @@ const primitive_funcs funcs_8 = create_rop_masks_8, create_dither_masks_8, stretch_row_8, - shrink_row_8 + shrink_row_8, + halftone_8 }; const primitive_funcs funcs_4 = @@ -7574,7 +8182,8 @@ const primitive_funcs funcs_4 = create_rop_masks_4, create_dither_masks_4, stretch_row_4, - shrink_row_4 + shrink_row_4, + halftone_4 }; const primitive_funcs funcs_1 = @@ -7595,7 +8204,8 @@ const primitive_funcs funcs_1 = create_rop_masks_1, create_dither_masks_1, stretch_row_1, - shrink_row_1 + shrink_row_1, + halftone_1 }; const primitive_funcs funcs_null = @@ -7616,5 +8226,6 @@ const primitive_funcs funcs_null = create_rop_masks_null, create_dither_masks_null, stretch_row_null, - shrink_row_null + shrink_row_null, + halftone_null }; diff --git a/dlls/user32/tests/cursoricon.c b/dlls/user32/tests/cursoricon.c index 39ffe9d88e6..f84312f3ea2 100644 --- a/dlls/user32/tests/cursoricon.c +++ b/dlls/user32/tests/cursoricon.c @@ -2897,10 +2897,10 @@ static COLORREF get_color_from_bits(const unsigned char *bits, const BITMAPINFO return RGB(color.rgbRed, color.rgbGreen, color.rgbBlue); } -#define compare_bitmap_bits(a, b, c, d, e, f, g) compare_bitmap_bits_(__LINE__, a, b, c, d, e, f, g) +#define compare_bitmap_bits(a, b, c, d, e, f, g, h) compare_bitmap_bits_(__LINE__, a, b, c, d, e, f, g, h) static void compare_bitmap_bits_(unsigned int line, HDC hdc, HBITMAP bitmap, BITMAPINFO *bmi, size_t result_bits_size, const unsigned char *expected_bits, unsigned int test_index, - const unsigned char *expected_broken_bits) + BOOL allow_todo, const unsigned char *expected_broken_bits) { unsigned char *result_bits; unsigned int row, column; @@ -2919,6 +2919,7 @@ static void compare_bitmap_bits_(unsigned int line, HDC hdc, HBITMAP bitmap, BIT result = get_color_from_bits(result_bits, bmi, row, column); expected = get_color_from_bits(expected_bits, bmi, row, column); + todo_wine_if(allow_todo && result != expected) ok_(__FILE__, line)(result == expected || broken(expected_broken_bits && result == get_color_from_bits(expected_broken_bits, bmi, row, column)), "Colors do not match, got 0x%06x, expected 0x%06x, test_index %u, row %u, column %u.\n", @@ -2999,21 +3000,22 @@ static void test_Image_StretchMode(void) size_t test_bits_size, result_bits_size; const RGBQUAD *bmi_colors; size_t bmi_colors_size; + BOOL allow_todo; const unsigned char *expected_broken_bits; } tests[] = { {4, 4, 2, 2, 24, test_bits_24, expected_bits_24, - sizeof(test_bits_24), sizeof(expected_bits_24), NULL, 0, + sizeof(test_bits_24), sizeof(expected_bits_24), NULL, 0, TRUE, /* Broken on Windows before Win10 1607+ */ expected_broken_bits_24}, {4, 4, 2, 2, 1, test_bits_1, expected_bits_1, sizeof(test_bits_1), sizeof(expected_bits_1), colors_bits_1, sizeof(colors_bits_1)}, {4, 4, 2, 2, 8, test_bits_8, expected_bits_8, sizeof(test_bits_8), sizeof(expected_bits_8), colors_bits_8, - sizeof(colors_bits_8)}, + sizeof(colors_bits_8), TRUE}, {4, 4, 2, 2, 16, (const unsigned char *)test_bits_16, (const unsigned char *)expected_bits_16, - sizeof(test_bits_16), sizeof(expected_bits_16), NULL, 0}, + sizeof(test_bits_16), sizeof(expected_bits_16), NULL, 0, TRUE}, }; static const char filename[] = "test.bmp"; BITMAPINFO *bmi, *bmi_output; @@ -3059,7 +3061,8 @@ static void test_Image_StretchMode(void) ok(!!bitmap_copy, "CopyImage() failed, result %u.\n", GetLastError()); compare_bitmap_bits(hdc, bitmap_copy, bmi_output, tests[test_index].result_bits_size, - tests[test_index].expected_bits, test_index, tests[test_index].expected_broken_bits); + tests[test_index].expected_bits, test_index, tests[test_index].allow_todo, + tests[test_index].expected_broken_bits); DeleteObject(bitmap); DeleteObject(bitmap_copy); @@ -3069,7 +3072,8 @@ static void test_Image_StretchMode(void) ok(!!bitmap, "LoadImageA() failed, result %u.\n", GetLastError()); DeleteFileA(filename); compare_bitmap_bits(hdc, bitmap, bmi_output, tests[test_index].result_bits_size, - tests[test_index].expected_bits, test_index, tests[test_index].expected_broken_bits); + tests[test_index].expected_bits, test_index, tests[test_index].allow_todo, + tests[test_index].expected_broken_bits); DeleteObject(bitmap); } ReleaseDC(0, hdc); -- 2.30.2

2 1

[PATCH 1/3] qcap/tests: Add some tests for filter state on the video capture filter.
by Zebediah Figura 15 Jun '21

15 Jun '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/qcap/tests/videocapture.c | 57 ++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/dlls/qcap/tests/videocapture.c b/dlls/qcap/tests/videocapture.c index fafd18009f4..7733dfdc8ed 100644 --- a/dlls/qcap/tests/videocapture.c +++ b/dlls/qcap/tests/videocapture.c @@ -360,12 +360,65 @@ static void testfilter_init(struct testfilter *filter) strmbase_sink_init(&filter->sink, &filter->filter, L"sink", &testsink_ops, NULL); } +static void test_filter_state(IMediaControl *control) +{ + OAFilterState state; + HRESULT hr; + + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(state == State_Stopped, "Got state %u.\n", state); + + hr = IMediaControl_Pause(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == VFW_S_CANT_CUE, "Got hr %#x.\n", hr); + ok(state == State_Paused, "Got state %u.\n", state); + + hr = IMediaControl_Run(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(state == State_Running, "Got state %u.\n", state); + + hr = IMediaControl_Pause(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == VFW_S_CANT_CUE, "Got hr %#x.\n", hr); + ok(state == State_Paused, "Got state %u.\n", state); + + hr = IMediaControl_Stop(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(state == State_Stopped, "Got state %u.\n", state); + + hr = IMediaControl_Run(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(state == State_Running, "Got state %u.\n", state); + + hr = IMediaControl_Stop(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(state == State_Stopped, "Got state %u.\n", state); +} + static void test_connect_pin(IBaseFilter *filter, IPin *source) { AM_MEDIA_TYPE req_mt, default_mt, mt, *mts[2]; IAMStreamConfig *stream_config; struct testfilter testsink; IEnumMediaTypes *enummt; + IMediaControl *control; IFilterGraph2 *graph; ULONG count, ref; HRESULT hr; @@ -373,6 +426,7 @@ static void test_connect_pin(IBaseFilter *filter, IPin *source) CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterGraph2, (void **)&graph); + IFilterGraph2_QueryInterface(graph, &IID_IMediaControl, (void **)&control); testfilter_init(&testsink); IFilterGraph2_AddFilter(graph, &testsink.filter.IBaseFilter_iface, L"sink"); IFilterGraph2_AddFilter(graph, filter, L"source"); @@ -406,6 +460,8 @@ static void test_connect_pin(IBaseFilter *filter, IPin *source) hr = IFilterGraph2_ConnectDirect(graph, source, &testsink.sink.pin.IPin_iface, &req_mt); ok(hr == S_OK, "Got hr %#x.\n", hr); + test_filter_state(control); + hr = IPin_ConnectedTo(source, &peer); ok(hr == S_OK, "Got hr %#x.\n", hr); ok(peer == &testsink.sink.pin.IPin_iface, "Got peer %p.\n", peer); @@ -445,6 +501,7 @@ static void test_connect_pin(IBaseFilter *filter, IPin *source) FreeMediaType(&req_mt); FreeMediaType(&default_mt); IAMStreamConfig_Release(stream_config); + IMediaControl_Release(control); ref = IFilterGraph2_Release(graph); ok(!ref, "Got outstanding refcount %d.\n", ref); ref = IBaseFilter_Release(&testsink.filter.IBaseFilter_iface); -- 2.30.2

1 2

[PATCH v2 5/6] gdi32: Partially implement HALFTONE stretch mode.
by Zhiyi Zhang 14 Jun '21

14 Jun '21

COLORONCOLOR(STRETCH_DELETESCANS) was used in place of HALFTONE. COLORONCOLOR mode may delete rows of pixels without trying to preserve information so it will cause Wine to render poorly when the destination rectangle is small. According to tests, HALFTONE mode uses box filter when doing integer downscaling and nearest neighbor interpolation when doing upscaling in both horizontally and vertically. In other cases, HALFTONE mode uses a lanczos3 like algorithm to interpolate pixels. There are also other heuristics involved. For example, shrinking a 2x2 image to 1x1 may not use box filter depending on image data. Since this algorithm is undocumented, it's difficult to reverse engineer the original algorithm and produce identical results. Instead, this patch uses a naive implementation of bilinear interpolation to implement HALFTONE mode and it produces good quality images. For 8-bit and lower color depth images, nulldrv_StretchBlt should resize the images first and then converts color depth. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=46375 Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/gdi32/dibdrv/bitblt.c | 7 + dlls/gdi32/dibdrv/dibdrv.h | 2 + dlls/gdi32/dibdrv/primitives.c | 629 ++++++++++++++++++++++++++++++++- 3 files changed, 629 insertions(+), 9 deletions(-) diff --git a/dlls/gdi32/dibdrv/bitblt.c b/dlls/gdi32/dibdrv/bitblt.c index d2f59965b02..9b46ad2916f 100644 --- a/dlls/gdi32/dibdrv/bitblt.c +++ b/dlls/gdi32/dibdrv/bitblt.c @@ -1216,6 +1216,12 @@ DWORD stretch_bitmapinfo( const BITMAPINFO *src_info, void *src_bits, struct bit init_dib_info_from_bitmapinfo( &src_dib, src_info, src_bits ); init_dib_info_from_bitmapinfo( &dst_dib, dst_info, dst_bits ); + if (mode == HALFTONE) + { + dst_dib.funcs->halftone( &dst_dib, dst, &src_dib, src ); + goto done; + } + /* v */ ret = calc_1d_stretch_params( dst->y, dst->height, dst->visrect.top, dst->visrect.bottom, src->y, src->height, src->visrect.top, src->visrect.bottom, @@ -1300,6 +1306,7 @@ DWORD stretch_bitmapinfo( const BITMAPINFO *src_info, void *src_bits, struct bit } } +done: /* update coordinates, the destination rectangle is always stored at 0,0 */ *src = *dst; src->x -= src->visrect.left; diff --git a/dlls/gdi32/dibdrv/dibdrv.h b/dlls/gdi32/dibdrv/dibdrv.h index d3a35b96c75..0492c0bd51e 100644 --- a/dlls/gdi32/dibdrv/dibdrv.h +++ b/dlls/gdi32/dibdrv/dibdrv.h @@ -211,6 +211,8 @@ typedef struct primitive_funcs void (* shrink_row)(const dib_info *dst_dib, const POINT *dst_start, const dib_info *src_dib, const POINT *src_start, const struct stretch_params *params, int mode, BOOL keep_dst); + void (* halftone)(const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src); } primitive_funcs; extern const primitive_funcs funcs_8888 DECLSPEC_HIDDEN; diff --git a/dlls/gdi32/dibdrv/primitives.c b/dlls/gdi32/dibdrv/primitives.c index e4b18a6656d..5eca124b918 100644 --- a/dlls/gdi32/dibdrv/primitives.c +++ b/dlls/gdi32/dibdrv/primitives.c @@ -7430,6 +7430,608 @@ static void shrink_row_null(const dib_info *dst_dib, const POINT *dst_start, return; } +static float clampf( float value, float min, float max ) +{ + return max( min, min( value, max ) ); +} + +static int clamp( int value, int min, int max ) +{ + return max( min, min( value, max ) ); +} + +static BYTE linear_interpolate( BYTE start, BYTE end, float delta ) +{ + return start + (end - start) * delta + 0.5f; +} + +static BYTE bilinear_interpolate( BYTE c00, BYTE c01, BYTE c10, BYTE c11, float dx, float dy ) +{ + return linear_interpolate( linear_interpolate( c00, c01, dx ), + linear_interpolate( c10, c11, dx ), dy ); +} + +static void calc_halftone_params( const struct bitblt_coords *dst, const struct bitblt_coords *src, + RECT *dst_rect, RECT *src_rect, int *src_start_x, + int *src_start_y, float *src_inc_x, float *src_inc_y ) +{ + int src_width, src_height, dst_width, dst_height; + BOOL mirrored_x, mirrored_y; + + get_bounding_rect( src_rect, src->x, src->y, src->width, src->height ); + get_bounding_rect( dst_rect, dst->x, dst->y, dst->width, dst->height ); + intersect_rect( src_rect, &src->visrect, src_rect ); + intersect_rect( dst_rect, &dst->visrect, dst_rect ); + offset_rect( dst_rect, -dst_rect->left, -dst_rect->top ); + + src_width = src_rect->right - src_rect->left; + src_height = src_rect->bottom - src_rect->top; + dst_width = dst_rect->right - dst_rect->left; + dst_height = dst_rect->bottom - dst_rect->top; + + mirrored_x = (dst->width < 0) != (src->width < 0); + mirrored_y = (dst->height < 0) != (src->height < 0); + *src_start_x = mirrored_x ? src_rect->right - 1 : src_rect->left; + *src_start_y = mirrored_y ? src_rect->bottom - 1 : src_rect->top; + *src_inc_x = mirrored_x ? -(float)src_width / dst_width : (float)src_width / dst_width; + *src_inc_y = mirrored_y ? -(float)src_height / dst_height : (float)src_height / dst_height; +} + +static void halftone_888( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + DWORD *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE c00_r, c01_r, c10_r, c11_r; + BYTE c00_g, c01_g, c10_g, c11_g; + BYTE c00_b, c01_b, c10_b, c11_b; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + dst_ptr = get_pixel_ptr_32( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_32( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride / 4; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0; + c01_ptr = src_ptr + x1; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00_r = (*c00_ptr >> 16) & 0xff; + c01_r = (*c01_ptr >> 16) & 0xff; + c10_r = (*c10_ptr >> 16) & 0xff; + c11_r = (*c11_ptr >> 16) & 0xff; + c00_g = (*c00_ptr >> 8) & 0xff; + c01_g = (*c01_ptr >> 8) & 0xff; + c10_g = (*c10_ptr >> 8) & 0xff; + c11_g = (*c11_ptr >> 8) & 0xff; + c00_b = *c00_ptr & 0xff; + c01_b = *c01_ptr & 0xff; + c10_b = *c10_ptr & 0xff; + c11_b = *c11_ptr & 0xff; + r = bilinear_interpolate( c00_r, c01_r, c10_r, c11_r, dx, dy ); + g = bilinear_interpolate( c00_g, c01_g, c10_g, c11_g, dx, dy ); + b = bilinear_interpolate( c00_b, c01_b, c10_b, c11_b, dx, dy ); + dst_ptr[dst_x] = ((r << 16) & 0xff0000) | ((g << 8) & 0x00ff00) | (b & 0x0000ff); + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride / 4; + float_y += src_inc_y; + } +} + +static void halftone_32( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + DWORD *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE c00_r, c01_r, c10_r, c11_r; + BYTE c00_g, c01_g, c10_g, c11_g; + BYTE c00_b, c01_b, c10_b, c11_b; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + dst_ptr = get_pixel_ptr_32( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_32( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride / 4; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0; + c01_ptr = src_ptr + x1; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00_r = get_field( *c00_ptr, src_dib->red_shift, src_dib->red_len ); + c01_r = get_field( *c01_ptr, src_dib->red_shift, src_dib->red_len ); + c10_r = get_field( *c10_ptr, src_dib->red_shift, src_dib->red_len ); + c11_r = get_field( *c11_ptr, src_dib->red_shift, src_dib->red_len ); + c00_g = get_field( *c00_ptr, src_dib->green_shift, src_dib->green_len ); + c01_g = get_field( *c01_ptr, src_dib->green_shift, src_dib->green_len ); + c10_g = get_field( *c10_ptr, src_dib->green_shift, src_dib->green_len ); + c11_g = get_field( *c11_ptr, src_dib->green_shift, src_dib->green_len ); + c00_b = get_field( *c00_ptr, src_dib->blue_shift, src_dib->blue_len ); + c01_b = get_field( *c01_ptr, src_dib->blue_shift, src_dib->blue_len ); + c10_b = get_field( *c10_ptr, src_dib->blue_shift, src_dib->blue_len ); + c11_b = get_field( *c11_ptr, src_dib->blue_shift, src_dib->blue_len ); + r = bilinear_interpolate( c00_r, c01_r, c10_r, c11_r, dx, dy ); + g = bilinear_interpolate( c00_g, c01_g, c10_g, c11_g, dx, dy ); + b = bilinear_interpolate( c00_b, c01_b, c10_b, c11_b, dx, dy ); + dst_ptr[dst_x] = rgb_to_pixel_masks( dst_dib, r, g, b ); + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride / 4; + float_y += src_inc_y; + } +} + +static void halftone_24( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + BYTE *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE c00_r, c01_r, c10_r, c11_r; + BYTE c00_g, c01_g, c10_g, c11_g; + BYTE c00_b, c01_b, c10_b, c11_b; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + dst_ptr = get_pixel_ptr_24( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_24( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0 * 3; + c01_ptr = src_ptr + x1 * 3; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00_b = c00_ptr[0]; + c01_b = c01_ptr[0]; + c10_b = c10_ptr[0]; + c11_b = c11_ptr[0]; + c00_g = c00_ptr[1]; + c01_g = c01_ptr[1]; + c10_g = c10_ptr[1]; + c11_g = c11_ptr[1]; + c00_r = c00_ptr[2]; + c01_r = c01_ptr[2]; + c10_r = c10_ptr[2]; + c11_r = c11_ptr[2]; + r = bilinear_interpolate( c00_r, c01_r, c10_r, c11_r, dx, dy ); + g = bilinear_interpolate( c00_g, c01_g, c10_g, c11_g, dx, dy ); + b = bilinear_interpolate( c00_b, c01_b, c10_b, c11_b, dx, dy ); + dst_ptr[dst_x * 3] = b; + dst_ptr[dst_x * 3 + 1] = g; + dst_ptr[dst_x * 3 + 2] = r; + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride; + float_y += src_inc_y; + } +} + +static void halftone_555( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + WORD *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE c00_r, c01_r, c10_r, c11_r; + BYTE c00_g, c01_g, c10_g, c11_g; + BYTE c00_b, c01_b, c10_b, c11_b; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + dst_ptr = get_pixel_ptr_16( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_16( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride / 2; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0; + c01_ptr = src_ptr + x1; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00_r = ((*c00_ptr >> 7) & 0xf8) | ((*c00_ptr >> 12) & 0x07); + c01_r = ((*c01_ptr >> 7) & 0xf8) | ((*c01_ptr >> 12) & 0x07); + c10_r = ((*c10_ptr >> 7) & 0xf8) | ((*c10_ptr >> 12) & 0x07); + c11_r = ((*c11_ptr >> 7) & 0xf8) | ((*c11_ptr >> 12) & 0x07); + c00_g = ((*c00_ptr >> 2) & 0xf8) | ((*c00_ptr >> 7) & 0x07); + c01_g = ((*c01_ptr >> 2) & 0xf8) | ((*c01_ptr >> 7) & 0x07); + c10_g = ((*c10_ptr >> 2) & 0xf8) | ((*c10_ptr >> 7) & 0x07); + c11_g = ((*c11_ptr >> 2) & 0xf8) | ((*c11_ptr >> 7) & 0x07); + c00_b = ((*c00_ptr << 3) & 0xf8) | ((*c00_ptr >> 2) & 0x07); + c01_b = ((*c01_ptr << 3) & 0xf8) | ((*c01_ptr >> 2) & 0x07); + c10_b = ((*c10_ptr << 3) & 0xf8) | ((*c10_ptr >> 2) & 0x07); + c11_b = ((*c11_ptr << 3) & 0xf8) | ((*c11_ptr >> 2) & 0x07); + r = bilinear_interpolate( c00_r, c01_r, c10_r, c11_r, dx, dy ); + g = bilinear_interpolate( c00_g, c01_g, c10_g, c11_g, dx, dy ); + b = bilinear_interpolate( c00_b, c01_b, c10_b, c11_b, dx, dy ); + dst_ptr[dst_x] = ((r << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((b >> 3) & 0x001f); + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride / 2; + float_y += src_inc_y; + } +} + +static void halftone_16( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + WORD *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE c00_r, c01_r, c10_r, c11_r; + BYTE c00_g, c01_g, c10_g, c11_g; + BYTE c00_b, c01_b, c10_b, c11_b; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + dst_ptr = get_pixel_ptr_16( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_16( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride / 2; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0; + c01_ptr = src_ptr + x1; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00_r = get_field( *c00_ptr, src_dib->red_shift, src_dib->red_len ); + c01_r = get_field( *c01_ptr, src_dib->red_shift, src_dib->red_len ); + c10_r = get_field( *c10_ptr, src_dib->red_shift, src_dib->red_len ); + c11_r = get_field( *c11_ptr, src_dib->red_shift, src_dib->red_len ); + c00_g = get_field( *c00_ptr, src_dib->green_shift, src_dib->green_len ); + c01_g = get_field( *c01_ptr, src_dib->green_shift, src_dib->green_len ); + c10_g = get_field( *c10_ptr, src_dib->green_shift, src_dib->green_len ); + c11_g = get_field( *c11_ptr, src_dib->green_shift, src_dib->green_len ); + c00_b = get_field( *c00_ptr, src_dib->blue_shift, src_dib->blue_len ); + c01_b = get_field( *c01_ptr, src_dib->blue_shift, src_dib->blue_len ); + c10_b = get_field( *c10_ptr, src_dib->blue_shift, src_dib->blue_len ); + c11_b = get_field( *c11_ptr, src_dib->blue_shift, src_dib->blue_len ); + r = bilinear_interpolate( c00_r, c01_r, c10_r, c11_r, dx, dy ); + g = bilinear_interpolate( c00_g, c01_g, c10_g, c11_g, dx, dy ); + b = bilinear_interpolate( c00_b, c01_b, c10_b, c11_b, dx, dy ); + dst_ptr[dst_x] = rgb_to_pixel_masks( dst_dib, r, g, b ); + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride / 2; + float_y += src_inc_y; + } +} + +static void halftone_8( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + BYTE *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + RGBQUAD c00_rgb, c01_rgb, c10_rgb, c11_rgb, zero_rgb = {0}; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + const RGBQUAD *src_clr_table; + RECT dst_rect, src_rect; + BYTE r, g, b; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + src_clr_table = get_dib_color_table( src_dib ); + dst_ptr = get_pixel_ptr_8( dst_dib, dst_rect.left, dst_rect.top ); + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = get_pixel_ptr_8( src_dib, 0, y0 ); + src_ptr_dy = (y1 - y0) * src_dib->stride; + for (dst_x = 0; dst_x < dst_rect.right - dst_rect.left; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + x0; + c01_ptr = src_ptr + x1; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + if (src_clr_table) + { + c00_rgb = *c00_ptr < src_dib->color_table_size ? src_clr_table[*c00_ptr] : zero_rgb; + c01_rgb = *c01_ptr < src_dib->color_table_size ? src_clr_table[*c01_ptr] : zero_rgb; + c10_rgb = *c10_ptr < src_dib->color_table_size ? src_clr_table[*c10_ptr] : zero_rgb; + c11_rgb = *c11_ptr < src_dib->color_table_size ? src_clr_table[*c11_ptr] : zero_rgb; + r = bilinear_interpolate( c00_rgb.rgbRed, c01_rgb.rgbRed, c10_rgb.rgbRed, c11_rgb.rgbRed, dx, dy ); + g = bilinear_interpolate( c00_rgb.rgbGreen, c01_rgb.rgbGreen, c10_rgb.rgbGreen, c11_rgb.rgbGreen, dx, dy ); + b = bilinear_interpolate( c00_rgb.rgbBlue, c01_rgb.rgbBlue, c10_rgb.rgbBlue, c11_rgb.rgbBlue, dx, dy ); + } + else + { + r = 0; + g = 0; + b = 0; + } + dst_ptr[dst_x] = rgb_to_pixel_colortable( dst_dib, r, g, b ); + + float_x += src_inc_x; + } + + dst_ptr += dst_dib->stride; + float_y += src_inc_y; + } +} + +static void halftone_4( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + BYTE *dst_col_ptr, *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1; + RGBQUAD c00_rgb, c01_rgb, c10_rgb, c11_rgb, zero_rgb = {0}; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE r, g, b, val, c00, c01, c10, c11; + const RGBQUAD *src_clr_table; + RECT dst_rect, src_rect; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + src_clr_table = get_dib_color_table( src_dib ); + dst_col_ptr = (BYTE *)dst_dib->bits.ptr + (dst_dib->rect.top + dst_rect.top) * dst_dib->stride; + for (dst_y = 0; dst_y < dst_rect.bottom - dst_rect.top; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = (BYTE *)src_dib->bits.ptr + (src_dib->rect.top + y0) * src_dib->stride; + src_ptr_dy = (y1 - y0) * src_dib->stride; + for (dst_x = dst_rect.left; dst_x < dst_rect.right; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + (src_dib->rect.left + x0) / 2; + c01_ptr = src_ptr + (src_dib->rect.left + x1) / 2; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + if ((src_dib->rect.left + x0) & 1) + { + c00 = *c00_ptr & 0x0f; + c10 = *c10_ptr & 0x0f; + } + else + { + c00 = (*c00_ptr >> 4) & 0x0f; + c10 = (*c10_ptr >> 4) & 0x0f; + } + if ((src_dib->rect.left + x1) & 1) + { + c01 = *c01_ptr & 0x0f; + c11 = *c11_ptr & 0x0f; + } + else + { + c01 = (*c01_ptr >> 4) & 0x0f; + c11 = (*c11_ptr >> 4) & 0x0f; + } + + if (src_clr_table) + { + c00_rgb = c00 < src_dib->color_table_size ? src_clr_table[c00] : zero_rgb; + c01_rgb = c01 < src_dib->color_table_size ? src_clr_table[c01] : zero_rgb; + c10_rgb = c10 < src_dib->color_table_size ? src_clr_table[c10] : zero_rgb; + c11_rgb = c11 < src_dib->color_table_size ? src_clr_table[c11] : zero_rgb; + r = bilinear_interpolate( c00_rgb.rgbRed, c01_rgb.rgbRed, c10_rgb.rgbRed, c11_rgb.rgbRed, dx, dy ); + g = bilinear_interpolate( c00_rgb.rgbGreen, c01_rgb.rgbGreen, c10_rgb.rgbGreen, c11_rgb.rgbGreen, dx, dy ); + b = bilinear_interpolate( c00_rgb.rgbBlue, c01_rgb.rgbBlue, c10_rgb.rgbBlue, c11_rgb.rgbBlue, dx, dy ); + } + else + { + r = 0; + g = 0; + b = 0; + } + + dst_ptr = dst_col_ptr + (dst_dib->rect.left + dst_x) / 2; + val = rgb_to_pixel_colortable( dst_dib, r, g, b ); + if ((dst_x + dst_dib->rect.left) & 1) + *dst_ptr = (val & 0x0f) | (*dst_ptr & 0xf0); + else + *dst_ptr = (val << 4) & 0xf0; + + float_x += src_inc_x; + } + + dst_col_ptr += dst_dib->stride; + float_y += src_inc_y; + } +} + +static void halftone_1( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{ + int src_start_x, src_start_y, src_ptr_dy, dst_x, dst_y, x0, x1, y0, y1, bit_pos; + BYTE *dst_col_ptr, *dst_ptr, *src_ptr, *c00_ptr, *c01_ptr, *c10_ptr, *c11_ptr; + RGBQUAD c00_rgb, c01_rgb, c10_rgb, c11_rgb, zero_rgb = {0}; + float src_inc_x, src_inc_y, float_x, float_y, dx, dy; + BYTE r, g, b, val, c00, c01, c10, c11; + const RGBQUAD *src_clr_table; + RECT dst_rect, src_rect; + RGBQUAD bg_entry; + DWORD bg_pixel; + + calc_halftone_params( dst, src, &dst_rect, &src_rect, &src_start_x, &src_start_y, &src_inc_x, + &src_inc_y ); + + float_y = src_start_y; + bg_entry = *get_dib_color_table( dst_dib ); + src_clr_table = get_dib_color_table( src_dib ); + dst_col_ptr = (BYTE *)dst_dib->bits.ptr + (dst_dib->rect.top + dst_rect.top) * dst_dib->stride; + for (dst_y = dst_rect.top; dst_y < dst_rect.bottom; ++dst_y) + { + float_y = clampf( float_y, src_rect.top, src_rect.bottom - 1 ); + y0 = float_y; + y1 = clamp( y0 + 1, src_rect.top, src_rect.bottom - 1 ); + dy = float_y - y0; + + float_x = src_start_x; + src_ptr = (BYTE *)src_dib->bits.ptr + (src_dib->rect.top + y0) * src_dib->stride; + src_ptr_dy = (y1 - y0) * src_dib->stride; + for (dst_x = dst_rect.left; dst_x < dst_rect.right; ++dst_x) + { + float_x = clampf( float_x, src_rect.left, src_rect.right - 1 ); + x0 = float_x; + x1 = clamp( x0 + 1, src_rect.left, src_rect.right - 1 ); + dx = float_x - x0; + + c00_ptr = src_ptr + (src_dib->rect.left + x0) / 8; + c01_ptr = src_ptr + (src_dib->rect.left + x1) / 8; + c10_ptr = c00_ptr + src_ptr_dy; + c11_ptr = c01_ptr + src_ptr_dy; + c00 = (*c00_ptr & pixel_masks_1[(src_dib->rect.left + x0) & 7]) ? 1 : 0; + c01 = (*c01_ptr & pixel_masks_1[(src_dib->rect.left + x1) & 7]) ? 1 : 0; + c10 = (*c10_ptr & pixel_masks_1[(src_dib->rect.left + x0) & 7]) ? 1 : 0; + c11 = (*c11_ptr & pixel_masks_1[(src_dib->rect.left + x1) & 7]) ? 1 : 0; + + if (src_clr_table) + { + c00_rgb = c00 < src_dib->color_table_size ? src_clr_table[c00] : zero_rgb; + c01_rgb = c01 < src_dib->color_table_size ? src_clr_table[c01] : zero_rgb; + c10_rgb = c10 < src_dib->color_table_size ? src_clr_table[c10] : zero_rgb; + c11_rgb = c11 < src_dib->color_table_size ? src_clr_table[c11] : zero_rgb; + r = bilinear_interpolate( c00_rgb.rgbRed, c01_rgb.rgbRed, c10_rgb.rgbRed, c11_rgb.rgbRed, dx, dy ); + g = bilinear_interpolate( c00_rgb.rgbGreen, c01_rgb.rgbGreen, c10_rgb.rgbGreen, c11_rgb.rgbGreen, dx, dy ); + b = bilinear_interpolate( c00_rgb.rgbBlue, c01_rgb.rgbBlue, c10_rgb.rgbBlue, c11_rgb.rgbBlue, dx, dy ); + } + else + { + r = 0; + g = 0; + b = 0; + } + + dst_ptr = dst_col_ptr + (dst_dib->rect.left + dst_x) / 8; + bit_pos = (dst_x + dst_dib->rect.left) & 7; + bg_pixel = FILTER_DIBINDEX(bg_entry, RGB(bg_entry.rgbRed, bg_entry.rgbGreen, bg_entry.rgbBlue)); + val = rgb_to_pixel_mono( dst_dib, FALSE, dst_x, dst_y, RGB(r, g, b), bg_pixel, r, g, b ); + if (bit_pos == 0) + *dst_ptr = 0; + *dst_ptr = (*dst_ptr & ~pixel_masks_1[bit_pos]) | (val & pixel_masks_1[bit_pos]); + + float_x += src_inc_x; + } + + dst_col_ptr += dst_dib->stride; + float_y += src_inc_y; + } +} + +static void halftone_null( const dib_info *dst_dib, const struct bitblt_coords *dst, + const dib_info *src_dib, const struct bitblt_coords *src ) +{} + const primitive_funcs funcs_8888 = { solid_rects_32, @@ -7448,7 +8050,8 @@ const primitive_funcs funcs_8888 = create_rop_masks_32, create_dither_masks_null, stretch_row_32, - shrink_row_32 + shrink_row_32, + halftone_888 }; const primitive_funcs funcs_32 = @@ -7469,7 +8072,8 @@ const primitive_funcs funcs_32 = create_rop_masks_32, create_dither_masks_null, stretch_row_32, - shrink_row_32 + shrink_row_32, + halftone_32 }; const primitive_funcs funcs_24 = @@ -7490,7 +8094,8 @@ const primitive_funcs funcs_24 = create_rop_masks_24, create_dither_masks_null, stretch_row_24, - shrink_row_24 + shrink_row_24, + halftone_24 }; const primitive_funcs funcs_555 = @@ -7511,7 +8116,8 @@ const primitive_funcs funcs_555 = create_rop_masks_16, create_dither_masks_null, stretch_row_16, - shrink_row_16 + shrink_row_16, + halftone_555 }; const primitive_funcs funcs_16 = @@ -7532,7 +8138,8 @@ const primitive_funcs funcs_16 = create_rop_masks_16, create_dither_masks_null, stretch_row_16, - shrink_row_16 + shrink_row_16, + halftone_16 }; const primitive_funcs funcs_8 = @@ -7553,7 +8160,8 @@ const primitive_funcs funcs_8 = create_rop_masks_8, create_dither_masks_8, stretch_row_8, - shrink_row_8 + shrink_row_8, + halftone_8 }; const primitive_funcs funcs_4 = @@ -7574,7 +8182,8 @@ const primitive_funcs funcs_4 = create_rop_masks_4, create_dither_masks_4, stretch_row_4, - shrink_row_4 + shrink_row_4, + halftone_4 }; const primitive_funcs funcs_1 = @@ -7595,7 +8204,8 @@ const primitive_funcs funcs_1 = create_rop_masks_1, create_dither_masks_1, stretch_row_1, - shrink_row_1 + shrink_row_1, + halftone_1 }; const primitive_funcs funcs_null = @@ -7616,5 +8226,6 @@ const primitive_funcs funcs_null = create_rop_masks_null, create_dither_masks_null, stretch_row_null, - shrink_row_null + shrink_row_null, + halftone_null }; -- 2.30.2

3 2

[PATCH] wined3d: Don't pass a 3D texture view's depth range as layer range to Vulkan.
by Jan Sikorski 14 Jun '21

14 Jun '21

Layer index and count fields in struct wined3d_view_desc double as the depth range of a 3D texture view. Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> --- dlls/wined3d/view.c | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index 91d26c05fae..7900df3c246 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -773,8 +773,19 @@ static VkImageView wined3d_view_vk_create_vk_image_view(struct wined3d_context_v } create_info.subresourceRange.baseMipLevel = desc->u.texture.level_idx; create_info.subresourceRange.levelCount = desc->u.texture.level_count; - create_info.subresourceRange.baseArrayLayer = desc->u.texture.layer_idx; - create_info.subresourceRange.layerCount = desc->u.texture.layer_count; + if (create_info.viewType == VK_IMAGE_VIEW_TYPE_3D) + { + if (desc->u.texture.layer_idx || (desc->u.texture.layer_count != texture_vk->t.resource.depth + && desc->u.texture.layer_count != ~0u)) + WARN("Partial 3D texture views are not supported.\n"); + create_info.subresourceRange.baseArrayLayer = 0; + create_info.subresourceRange.layerCount = 1; + } + else + { + create_info.subresourceRange.baseArrayLayer = desc->u.texture.layer_idx; + create_info.subresourceRange.layerCount = desc->u.texture.layer_count; + } if ((vr = VK_CALL(vkCreateImageView(device_vk->vk_device, &create_info, NULL, &vk_image_view))) < 0) { ERR("Failed to create Vulkan image view, vr %s.\n", wined3d_debug_vkresult(vr)); -- 2.30.2

2 1

[PATCH 2/2] msvcrt: Import pow implementation from musl.
by Piotr Caban 14 Jun '21

14 Jun '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/crtdll/Makefile.in | 1 - dlls/msvcr100/Makefile.in | 1 - dlls/msvcr110/Makefile.in | 1 - dlls/msvcr120/Makefile.in | 1 - dlls/msvcr70/Makefile.in | 1 - dlls/msvcr71/Makefile.in | 1 - dlls/msvcr80/Makefile.in | 1 - dlls/msvcr90/Makefile.in | 1 - dlls/msvcrt/Makefile.in | 1 - dlls/msvcrt/math.c | 423 +++++++++++++++++++++++++++++++++++++- dlls/msvcrt/unixlib.c | 64 ------ dlls/msvcrt/unixlib.h | 29 --- dlls/msvcrtd/Makefile.in | 1 - dlls/ucrtbase/Makefile.in | 1 - 14 files changed, 412 insertions(+), 115 deletions(-) delete mode 100644 dlls/msvcrt/unixlib.c delete mode 100644 dlls/msvcrt/unixlib.h

1 0

[PATCH 1/2] msvcrt: Fix math error arguments in powf.
by Piotr Caban 14 Jun '21

14 Jun '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/math.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)

1 0

[PATCH v3 1/3] hid: Use HID_VALUE_CAPS Reserved2 to store start bit.
by Rémi Bernon 14 Jun '21

14 Jun '21

It's only going to be used for internal HID preparsed data, to save a custom struct. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- v3: Should really be no-op, add a BitCount in the Reserved2 fields for now, but we'll drop it later. Supersedes: 207499-207501 dlls/hid/hidp.c | 20 ++++++++++---------- dlls/hidclass.sys/descriptor.c | 17 ++++++++--------- include/ddk/hidpi.h | 5 +++++ include/wine/hid.h | 1 - 4 files changed, 23 insertions(+), 20 deletions(-) diff --git a/dlls/hid/hidp.c b/dlls/hid/hidp.c index 2933c2ff7ef..4532f656008 100644 --- a/dlls/hid/hidp.c +++ b/dlls/hid/hidp.c @@ -277,7 +277,7 @@ static NTSTATUS find_usage(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT if (value->IsRange && value->Range.UsageMin <= Usage && Usage <= value->Range.UsageMax) { *element = elems[report->elementIdx + i]; - element->valueStartBit += value->BitSize * (Usage - value->Range.UsageMin); + element->caps.StartBit += value->BitSize * (Usage - value->Range.UsageMin); element->bitCount = elems[report->elementIdx + i].caps.BitSize; return HIDP_STATUS_SUCCESS; } @@ -332,7 +332,7 @@ NTSTATUS WINAPI HidP_GetScaledUsageValue(HIDP_REPORT_TYPE ReportType, USAGE Usag { ULONG rawValue; rc = get_report_data((BYTE*)Report, ReportLength, - element.valueStartBit, element.bitCount, &rawValue); + element.caps.StartBit, element.bitCount, &rawValue); if (rc != HIDP_STATUS_SUCCESS) return rc; *UsageValue = logical_to_physical(sign_extend(rawValue, &element), &element); @@ -357,7 +357,7 @@ NTSTATUS WINAPI HidP_GetUsageValue(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, if (rc == HIDP_STATUS_SUCCESS) { return get_report_data((BYTE*)Report, ReportLength, - element.valueStartBit, element.bitCount, UsageValue); + element.caps.StartBit, element.bitCount, UsageValue); } return rc; @@ -381,7 +381,7 @@ NTSTATUS WINAPI HidP_GetUsageValueArray(HIDP_REPORT_TYPE ReportType, USAGE Usage if (element.caps.IsRange || element.caps.ReportCount <= 1 || !element.bitCount) return HIDP_STATUS_NOT_VALUE_ARRAY; - return get_report_data_array((BYTE*)Report, ReportLength, element.valueStartBit, element.bitCount, + return get_report_data_array((BYTE*)Report, ReportLength, element.caps.StartBit, element.bitCount, element.caps.ReportCount, UsageValue, UsageValueByteLength); } @@ -444,7 +444,7 @@ NTSTATUS WINAPI HidP_GetUsages(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USH { UINT v = 0; NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength, - element->valueStartBit + k, 1, &v); + element->caps.StartBit + k, 1, &v); if (rc != HIDP_STATUS_SUCCESS) return rc; found = TRUE; @@ -636,7 +636,7 @@ NTSTATUS WINAPI HidP_SetUsageValue(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, if (rc == HIDP_STATUS_SUCCESS) { return set_report_data((BYTE*)Report, ReportLength, - element.valueStartBit, element.bitCount, UsageValue); + element.caps.StartBit, element.bitCount, UsageValue); } return rc; @@ -661,7 +661,7 @@ NTSTATUS WINAPI HidP_SetUsages(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USH if (rc == HIDP_STATUS_SUCCESS) { rc = set_report_data((BYTE*)Report, ReportLength, - element.valueStartBit, element.bitCount, -1); + element.caps.StartBit, element.bitCount, -1); } if (rc != HIDP_STATUS_SUCCESS) @@ -869,7 +869,7 @@ NTSTATUS WINAPI HidP_GetUsagesEx(HIDP_REPORT_TYPE ReportType, USHORT LinkCollect { UINT v = 0; NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength, - element->valueStartBit + k, 1, &v); + element->caps.StartBit + k, 1, &v); if (rc != HIDP_STATUS_SUCCESS) return rc; if (v) @@ -952,7 +952,7 @@ NTSTATUS WINAPI HidP_GetData(HIDP_REPORT_TYPE ReportType, HIDP_DATA *DataList, U { UINT v = 0; NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength, - element->valueStartBit + k, 1, &v); + element->caps.StartBit + k, 1, &v); if (rc != HIDP_STATUS_SUCCESS) return rc; if (v) @@ -972,7 +972,7 @@ NTSTATUS WINAPI HidP_GetData(HIDP_REPORT_TYPE ReportType, HIDP_DATA *DataList, U { UINT v; NTSTATUS rc = get_report_data((BYTE*)Report, ReportLength, - element->valueStartBit, element->bitCount, &v); + element->caps.StartBit, element->bitCount, &v); if (rc != HIDP_STATUS_SUCCESS) return rc; DataList[uCount].DataIndex = element->caps.NotRange.DataIndex; diff --git a/dlls/hidclass.sys/descriptor.c b/dlls/hidclass.sys/descriptor.c index 65c2f9aadae..9cf6f311fca 100644 --- a/dlls/hidclass.sys/descriptor.c +++ b/dlls/hidclass.sys/descriptor.c @@ -137,12 +137,12 @@ static inline const char *debugstr_hidp_value_caps( HIDP_VALUE_CAPS *caps ) { if (!caps) return "(null)"; return wine_dbg_sprintf( "RId %d, Usg %02x:%02x-%02x Dat %02x-%02x (%d), Str %d-%d (%d), Des %d-%d (%d), " - "Bits %02x, Als %d, Abs %d, Nul %d, LCol %d LUsg %02x:%02x, BitSz %d, RCnt %d, " + "Bits %02x, Als %d, Abs %d, Nul %d, LCol %d LUsg %02x:%02x, BitStrt %d, BitSz %d, RCnt %d, " "Unit %x E%+d, Log %+d-%+d, Phy %+d-%+d", caps->ReportID, caps->UsagePage, caps->Range.UsageMin, caps->Range.UsageMax, caps->Range.DataIndexMin, caps->Range.DataIndexMax, caps->IsRange, caps->Range.StringMin, caps->Range.StringMax, caps->IsStringRange, caps->Range.DesignatorMin, caps->Range.DesignatorMax, caps->IsDesignatorRange, - caps->BitField, caps->IsAlias, caps->IsAbsolute, caps->HasNull, caps->LinkCollection, caps->LinkUsagePage, caps->LinkUsage, caps->BitSize, caps->ReportCount, - caps->Units, caps->UnitsExp, caps->LogicalMin, caps->LogicalMax, caps->PhysicalMin, caps->PhysicalMax ); + caps->BitField, caps->IsAlias, caps->IsAbsolute, caps->HasNull, caps->LinkCollection, caps->LinkUsagePage, caps->LinkUsage, caps->StartBit, + caps->BitSize, caps->ReportCount, caps->Units, caps->UnitsExp, caps->LogicalMin, caps->LogicalMax, caps->PhysicalMin, caps->PhysicalMax ); } static void debug_feature(struct feature *feature) @@ -196,7 +196,7 @@ static void debug_print_report(const char* type, WINE_HIDP_PREPARSED_DATA *data, for (i = 0; i < report->elementCount; i++) { WINE_HID_ELEMENT *elem = elems + report->elementIdx + i; - TRACE("%s: %s, StartBit %d, BitCount %d\n", type, debugstr_hidp_value_caps(&elem->caps), elem->valueStartBit, elem->bitCount); + TRACE("%s: %s, BitCount %d\n", type, debugstr_hidp_value_caps(&elem->caps), elem->bitCount); } TRACE(">>> END Report %i\n",report->reportID); } @@ -589,11 +589,6 @@ static void build_elements(WINE_HID_REPORT *wine_report, WINE_HID_ELEMENT *elems return; } - wine_element->valueStartBit = wine_report->bitSize; - - wine_element->bitCount = (feature->caps.BitSize * feature->caps.ReportCount); - wine_report->bitSize += wine_element->bitCount; - wine_element->caps = feature->caps; wine_element->caps.BitField = feature->BitField; wine_element->caps.LinkCollection = feature->collection->index; @@ -601,6 +596,10 @@ static void build_elements(WINE_HID_REPORT *wine_report, WINE_HID_ELEMENT *elems wine_element->caps.LinkUsagePage = feature->collection->caps.UsagePage; wine_element->caps.IsAbsolute = feature->IsAbsolute; wine_element->caps.HasNull = feature->HasNull; + wine_element->caps.StartBit = wine_report->bitSize; + + wine_element->bitCount = (wine_element->caps.BitSize * wine_element->caps.ReportCount); + wine_report->bitSize += wine_element->bitCount; if (wine_element->caps.IsRange) { diff --git a/include/ddk/hidpi.h b/include/ddk/hidpi.h index fb497f3282f..9da84f38531 100644 --- a/include/ddk/hidpi.h +++ b/include/ddk/hidpi.h @@ -83,7 +83,12 @@ typedef struct _HIDP_VALUE_CAPS UCHAR Reserved; USHORT BitSize; USHORT ReportCount; +#ifdef __WINESRC__ + USHORT Reserved2[3]; + ULONG StartBit; +#else USHORT Reserved2[5]; +#endif ULONG UnitsExp; ULONG Units; LONG LogicalMin; diff --git a/include/wine/hid.h b/include/wine/hid.h index cfb4f389eb9..0c0d3fdca99 100644 --- a/include/wine/hid.h +++ b/include/wine/hid.h @@ -33,7 +33,6 @@ typedef struct __WINE_ELEMENT { - UINT valueStartBit; UINT bitCount; HIDP_VALUE_CAPS caps; } WINE_HID_ELEMENT; -- 2.31.0

1 3

[PATCH v2 6/6] gdi32/tests: Add StretchBlt HALFTONE mode tests.
by Zhiyi Zhang 14 Jun '21

14 Jun '21

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- I'm not sure the tests should be in tests/dib.c. The framework in dib.c hashes results and compares them. I don't think that's going to help us figuring out the exact HALFTONE algorithm details with the results being hashes. Also, the tests that succeed have all input pixels has the same value. So if I only add the tests that succeed, it provides little value. The tests here are mostly for helping figuring out the algorithm in the future. Since the actual Wine implementation in the previous patch uses a different approach. It doesn't reproduce identical results. So if you feel that such tests are not necessary, you can drop this. dlls/gdi32/tests/bitmap.c | 1136 +++++++++++++++++++++++++++++++++++++ 1 file changed, 1136 insertions(+) diff --git a/dlls/gdi32/tests/bitmap.c b/dlls/gdi32/tests/bitmap.c index fe3482671b2..c28dde8159b 100644 --- a/dlls/gdi32/tests/bitmap.c +++ b/dlls/gdi32/tests/bitmap.c @@ -57,6 +57,29 @@ static inline int get_dib_image_size( const BITMAPINFO *info ) * abs( info->bmiHeader.biHeight ); } +static void dump_bits(int bpp, int width, const BYTE *expected, const BYTE *result, int size, + const char *comment) +{ + int i, stride; + + stride = get_dib_stride(width, bpp); + printf("%s expected:\n", comment); + for (i = 0; i < size; i++) + { + printf("%02x ", expected[i]); + if ((i + 1) % stride == 0) + printf("\n"); + } + printf("\n%s got:\n", comment); + for (i = 0; i < size; i++) + { + printf("%02x ", result[i]); + if ((i + 1) % stride == 0) + printf("\n"); + } + printf("\n"); +} + static void test_bitmap_info(HBITMAP hbm, INT expected_depth, const BITMAPINFOHEADER *bmih) { BITMAP bm; @@ -3426,6 +3449,1118 @@ static void test_StretchBlt(void) DeleteDC(hdcScreen); } +static void test_StretchBlt_HALFTONE(void) +{ +#define PAD_ZERO 0x00, + + /* Same dimension */ + /* 1x1 -> 1x1 */ + static const unsigned char test_bits_0[] = + { + 0xff, 0x7f, 0x00, + }; + static const unsigned char expected_bits_0[] = + { + 0xff, 0x7f, 0x00, + }; + + /* Shrink horizontally */ + /* 2x1 -> 1x1 */ + /* 0xff / 2 = 0x7f.8, (0xff + 1) / 2 = 0x80 */ + static const unsigned char test_bits_1[] = + { + 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, + }; + static const unsigned char expected_bits_1[] = + { + 0x7f, 0x80, 0x7f, + }; + static const unsigned char test_bits_2[] = + { + 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_2[] = + { + 0x7f, 0x80, 0x7f, + }; + + /* 3x1 -> 1x1 */ + /* 0xff / 3 = 0x55 */ + static const unsigned char test_bits_3[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + }; + static const unsigned char expected_bits_3[] = + { + 0x54, 0x54, 0x54, + }; + static const unsigned char test_bits_4[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + }; + static const unsigned char expected_bits_4[] = + { + 0x55, 0x55, 0x55, + }; + static const unsigned char test_bits_5[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_5[] = + { + 0x55, 0x55, 0x55, + }; + /* 0xff * 2 / 3 = 0xaa */ + static const unsigned char test_bits_6[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + }; + static const unsigned char expected_bits_6[] = + { + 0xa9, 0xa9, 0xa9, + }; + static const unsigned char test_bits_7[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_7[] = + { + 0xa9, 0xa9, 0xa9, + }; + static const unsigned char test_bits_8[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_8[] = + { + 0xaa, 0xaa, 0xaa, + }; + static const unsigned char test_bits_9[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_9[] = + { + 0xff, 0xff, 0xff, + }; + + /* 4x1 -> 1x1 */ + /* 0xff * 3 / 4 = 0xbf.4 */ + static const unsigned char test_bits_10[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_10[] = + { + 0xbf, 0xbf, 0xbf, + }; + + /* 5x1 -> 1x1 */ + /* 0xff * 4 / 5 = 0xcc */ + static const unsigned char test_bits_11[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_11[] = + { + 0xcc, 0xcc, 0xcc, + }; + + /* Shrink horizontally with non-integer ratio */ + /* 3x1 -> 2x1 */ + static const unsigned char test_bits_12[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + }; + static const unsigned char expected_bits_12[] = + { + 0xd4, 0xd4, 0xd4, 0x00, 0x00, 0x00, + }; + static const unsigned char test_bits_13[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + }; + static const unsigned char expected_bits_13[] = + { + 0x55, 0x55, 0x55, 0x54, 0x54, 0x54, + }; + static const unsigned char test_bits_14[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_14[] = + { + 0x00, 0x00, 0x00, 0xd4, 0xd4, 0xd4, + }; + static const unsigned char test_bits_15[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + }; + static const unsigned char expected_bits_15[] = + { + 0xff, 0xff, 0xff, 0x2a, 0x2a, 0x2a, + }; + static const unsigned char test_bits_16[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_16[] = + { + 0xa9, 0xa9, 0xa9, 0xaa, 0xaa, 0xaa, + }; + static const unsigned char test_bits_17[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_17[] = + { + 0x2a, 0x2a, 0x2a, 0xff, 0xff, 0xff, + }; + static const unsigned char test_bits_18[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_18[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + + /* 4x1 -> 3x1 */ + static const unsigned char test_bits_19[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_19[] = + { + 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char test_bits_20[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + }; + static const unsigned char expected_bits_20[] = + { + 0xcf, 0xcf, 0xcf, 0x7f, 0x7f, 0x7f, 0x2f, 0x2f, 0x2f, + }; + static const unsigned char test_bits_21[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_21[] = + { + 0x2f, 0x2f, 0x2f, 0x7f, 0x7f, 0x7f, 0xcf, 0xcf, 0xcf, + }; + static const unsigned char test_bits_22[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff + }; + static const unsigned char expected_bits_22[] = + { + 0xef, 0xef, 0xef, 0x00, 0x00, 0x00, 0xef, 0xef, 0xef, + }; + static const unsigned char test_bits_23[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + }; + static const unsigned char expected_bits_23[] = + { + 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, + }; + + /* 5x1 -> 3x1 */ + static const unsigned char test_bits_24[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_24[] = + { + 0x3f, 0x3f, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char test_bits_25[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + }; + static const unsigned char expected_bits_25[] = + { + 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x65, 0x65, 0x65, + }; + static const unsigned char test_bits_26[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_26[] = + { + 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x99, 0x99, 0x99, + }; + + /* Shrink vertically */ + /* 1x2 -> 1x1 */ + /* 0xff / 2 = 0x7f.8, (0xff + 1) / 2 = 0x80 */ + static const unsigned char test_bits_27[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x01, 0x00, PAD_ZERO + }; + static const unsigned char expected_bits_27[] = + { + 0x7f, 0x80, 0x7f + }; + static const unsigned char test_bits_28[] = + { + 0x00, 0x01, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_28[] = + { + 0x7f, 0x80, 0x7f + }; + + /* 1x3 -> 1x1 */ + /* 0xff / 3 = 0x55 */ + static const unsigned char test_bits_29[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char expected_bits_29[] = + { + 0x55, 0x55, 0x55, + }; + static const unsigned char test_bits_30[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char expected_bits_30[] = + { + 0x55, 0x55, 0x55, + }; + static const unsigned char test_bits_31[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_31[] = + { + 0x54, 0x54, 0x54, + }; + /* 0xff * 2 / 3 = 0xaa */ + static const unsigned char test_bits_32[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char expected_bits_32[] = + { + 0xaa, 0xaa, 0xaa, + }; + static const unsigned char test_bits_33[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_33[] = + { + 0xa9, 0xa9, 0xa9, + }; + static const unsigned char test_bits_34[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_34[] = + { + 0xa9, 0xa9, 0xa9, + }; + static const unsigned char test_bits_35[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_35[] = + { + 0xff, 0xff, 0xff, + }; + + /* 1x4 -> 1x1 */ + /* 0xff * 3 / 4 = 0xbf.4 */ + static const unsigned char test_bits_36[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_36[] = + { + 0xbf, 0xbf, 0xbf, + }; + + /* 1x5 -> 1x1 */ + /* 0xff * 4 / 5 = 0xcc */ + static const unsigned char test_bits_37[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_37[] = + { + 0xcb, 0xcb, 0xcb, + }; + + /* Shrink vertically with a non-integer ratio */ + /* 3x1 -> 2x1 */ + static const unsigned char test_bits_38[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char expected_bits_38[] = + { + 0xd4, 0xd4, 0xd4, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char test_bits_39[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char expected_bits_39[] = + { + 0x54, 0x54, 0x54, PAD_ZERO + 0x55, 0x55, 0x55, PAD_ZERO + }; + static const unsigned char test_bits_40[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_40[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xd4, 0xd4, 0xd4, PAD_ZERO + }; + static const unsigned char test_bits_41[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char expected_bits_41[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0x2a, 0x2a, 0x2a, PAD_ZERO + }; + static const unsigned char test_bits_42[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_42[] = + { + 0xaa, 0xaa, 0xaa, PAD_ZERO + 0xa9, 0xa9, 0xa9, PAD_ZERO + }; + static const unsigned char test_bits_43[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_43[] = + { + 0x2a, 0x2a, 0x2a, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char test_bits_44[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_44[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + + /* 4x1 -> 3x1 */ + static const unsigned char test_bits_45[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_45[] = + { + 0x0f, 0x0f, 0x0f, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char test_bits_46[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char expected_bits_46[] = + { + 0xcf, 0xcf, 0xcf, PAD_ZERO + 0x7f, 0x7f, 0x7f, PAD_ZERO + 0x2f, 0x2f, 0x2f, PAD_ZERO + }; + static const unsigned char test_bits_47[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_47[] = + { + 0x2f, 0x2f, 0x2f, PAD_ZERO + 0x7f, 0x7f, 0x7f, PAD_ZERO + 0xcf, 0xcf, 0xcf, PAD_ZERO + }; + static const unsigned char test_bits_48[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_48[] = + { + 0xef, 0xef, 0xef, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xef, 0xef, 0xef, PAD_ZERO + }; + static const unsigned char test_bits_49[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char expected_bits_49[] = + { + 0x0f, 0x0f, 0x0f, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x0f, 0x0f, 0x0f, PAD_ZERO + }; + + /* 5x1 -> 3x1 */ + static const unsigned char test_bits_50[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_50[] = + { + 0x3f, 0x3f, 0x3f, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char test_bits_51[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char expected_bits_51[] = + { + 0x65, 0x65, 0x65, PAD_ZERO + 0x66, 0x66, 0x66, PAD_ZERO + 0x66, 0x66, 0x66, PAD_ZERO + }; + static const unsigned char test_bits_52[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_52[] = + { + 0x99, 0x99, 0x99, PAD_ZERO + 0x98, 0x98, 0x98, PAD_ZERO + 0x98, 0x98, 0x98, PAD_ZERO + }; + + /* Stretch horizontally */ + /* 1x1 -> 2x1 */ + static const unsigned char test_bits_53[] = + { + 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_53[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + /* 2x1 -> 3x1 */ + static const unsigned char test_bits_54[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_54[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + }; + /* 3x1 -> 4x1 */ + static const unsigned char test_bits_55[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_55[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + /* 4x1 -> 5x1 */ + static const unsigned char test_bits_56[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_56[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + + /* Stretch vertically */ + /* 1x1 -> 1x2 */ + static const unsigned char test_bits_57[] = + { + 0xff, 0xff, 0xff, + }; + static const unsigned char expected_bits_57[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + /* 1x2 -> 1x3 */ + static const unsigned char test_bits_58[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_58[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + /* 1x3 -> 1x4 */ + static const unsigned char test_bits_59[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_59[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + /* 1x4 -> 1x5 */ + static const unsigned char test_bits_60[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char expected_bits_60[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + + /* Shrink both horizontally and vertically*/ + /* 2x2 -> 1x1 */ + /* 0xff / 4 = 0x3f.c */ + static const unsigned char test_bits_61[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_61[] = + { + 0x40, 0x40, 0x40, + }; + static const unsigned char test_bits_62[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_62[] = + { + 0x40, 0x40, 0x40, + }; + static const unsigned char test_bits_63[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_63[] = + { + 0x40, 0x40, 0x40, + }; + static const unsigned char test_bits_64[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_64[] = + { + 0x40, 0x40, 0x40, + }; + /* 0xff * 2 / 4 = 0x7f.8 */ + static const unsigned char test_bits_65[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_65[] = + { + 0x80, 0x80, 0x80, + }; + static const unsigned char test_bits_66[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_66[] = + { + 0x80, 0x80, 0x80, + }; + static const unsigned char test_bits_67[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_67[] = + { + 0xff, 0xff, 0xff, + }; + + /* Stretch horizontally and shrink vertically */ + /* 2x2 -> 1x4 */ + static const unsigned char test_bits_68[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_68[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + }; + static const unsigned char test_bits_69[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_69[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff + }; + static const unsigned char test_bits_70[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_70[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + }; + static const unsigned char test_bits_71[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_71[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + static const unsigned char test_bits_72[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_72[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + }; + static const unsigned char test_bits_73[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_73[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + }; + /* 0xff * 2 / 4 = 0x7f.8 */ + static const unsigned char test_bits_74[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_74[] = + { + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 + }; + static const unsigned char test_bits_75[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_75[] = + { + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 + }; + static const unsigned char test_bits_76[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_76[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff + }; + /* 0xfe * 2 / 4 = 0x7f */ + static const unsigned char test_bits_77[] = + { + 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xfe, PAD_ZERO PAD_ZERO + 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_77[] = + { + 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f + }; + + /* Stretch vertically and shrink horizontally */ + /* 2x2 -> 4x1 */ + static const unsigned char test_bits_78[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_78[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char test_bits_79[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_79[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char test_bits_80[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_80[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char test_bits_81[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_81[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + static const unsigned char test_bits_82[] = + { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_82[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + static const unsigned char test_bits_83[] = + { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_83[] = + { + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + }; + /* 0xff * 2 / 4 = 0x7f.8 */ + static const unsigned char test_bits_84[] = + { + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_84[] = + { + 0x80, 0x80, 0x80, PAD_ZERO + 0x80, 0x80, 0x80, PAD_ZERO + 0x80, 0x80, 0x80, PAD_ZERO + 0x80, 0x80, 0x80, PAD_ZERO + }; + static const unsigned char test_bits_85[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_85[] = + { + 0x80, 0x80, 0x80, PAD_ZERO + 0x80, 0x80, 0x80, PAD_ZERO + 0x80, 0x80, 0x80, PAD_ZERO + 0x80, 0x80, 0x80, PAD_ZERO + }; + static const unsigned char test_bits_86[] = + { + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, PAD_ZERO PAD_ZERO + 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_86[] = + { + 0xff, 0xff, 0xff, PAD_ZERO + 0xff, 0xff, 0xff, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + 0x00, 0x00, 0x00, PAD_ZERO + }; + /* 0xfe * 2 / 4 = 0x7f */ + static const unsigned char test_bits_87[] = + { + 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xfe, PAD_ZERO PAD_ZERO + 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, PAD_ZERO PAD_ZERO + }; + static const unsigned char expected_bits_87[] = + { + 0x7f, 0x7f, 0x7f, PAD_ZERO + 0x7f, 0x7f, 0x7f, PAD_ZERO + 0x7f, 0x7f, 0x7f, PAD_ZERO + 0x7f, 0x7f, 0x7f, PAD_ZERO + }; + +#undef PAD_ZERO + + static const struct + { + const unsigned char *src_bits; + size_t src_bits_size; + const unsigned char *dst_bits; + size_t dst_bits_size; + int bpp; + int src_width; + int src_height; + int dst_width; + int dst_height; + BOOL todo; + } + tests[] = + { +#define BITS(x) test_bits_##x, sizeof(test_bits_##x), expected_bits_##x, sizeof(expected_bits_##x) + + {BITS(0), 24, 1, 1, 1, 1}, + {BITS(1), 24, 2, 1, 1, 1, TRUE}, + {BITS(2), 24, 2, 1, 1, 1, TRUE}, + {BITS(3), 24, 3, 1, 1, 1, TRUE}, + {BITS(4), 24, 3, 1, 1, 1, TRUE}, + {BITS(5), 24, 3, 1, 1, 1, TRUE}, + {BITS(6), 24, 3, 1, 1, 1, TRUE}, + {BITS(7), 24, 3, 1, 1, 1, TRUE}, + {BITS(8), 24, 3, 1, 1, 1, TRUE}, + {BITS(9), 24, 3, 1, 1, 1}, + {BITS(10), 24, 4, 1, 1, 1, TRUE}, + {BITS(11), 24, 5, 1, 1, 1, TRUE}, + {BITS(12), 24, 3, 1, 2, 1, TRUE}, + {BITS(13), 24, 3, 1, 2, 1, TRUE}, + {BITS(14), 24, 3, 1, 2, 1, TRUE}, + {BITS(15), 24, 3, 1, 2, 1, TRUE}, + {BITS(16), 24, 3, 1, 2, 1, TRUE}, + {BITS(17), 24, 3, 1, 2, 1, TRUE}, + {BITS(18), 24, 3, 1, 2, 1}, + {BITS(19), 24, 4, 1, 3, 1, TRUE}, + {BITS(20), 24, 4, 1, 3, 1, TRUE}, + {BITS(21), 24, 4, 1, 3, 1, TRUE}, + {BITS(22), 24, 4, 1, 3, 1, TRUE}, + {BITS(23), 24, 4, 1, 3, 1, TRUE}, + {BITS(24), 24, 5, 1, 3, 1, TRUE}, + {BITS(25), 24, 5, 1, 3, 1, TRUE}, + {BITS(26), 24, 5, 1, 3, 1, TRUE}, + {BITS(27), 24, 1, 2, 1, 1, TRUE}, + {BITS(28), 24, 1, 2, 1, 1, TRUE}, + {BITS(29), 24, 1, 3, 1, 1, TRUE}, + {BITS(30), 24, 1, 3, 1, 1, TRUE}, + {BITS(31), 24, 1, 3, 1, 1, TRUE}, + {BITS(32), 24, 1, 3, 1, 1, TRUE}, + {BITS(33), 24, 1, 3, 1, 1, TRUE}, + {BITS(34), 24, 1, 3, 1, 1, TRUE}, + {BITS(35), 24, 1, 3, 1, 1}, + {BITS(36), 24, 1, 4, 1, 1, TRUE}, + {BITS(37), 24, 1, 5, 1, 1, TRUE}, + {BITS(38), 24, 1, 3, 1, 2, TRUE}, + {BITS(39), 24, 1, 3, 1, 2, TRUE}, + {BITS(40), 24, 1, 3, 1, 2, TRUE}, + {BITS(41), 24, 1, 3, 1, 2, TRUE}, + {BITS(42), 24, 1, 3, 1, 2, TRUE}, + {BITS(43), 24, 1, 3, 1, 2, TRUE}, + {BITS(44), 24, 1, 3, 1, 2}, + {BITS(45), 24, 1, 4, 1, 3, TRUE}, + {BITS(46), 24, 1, 4, 1, 3, TRUE}, + {BITS(47), 24, 1, 4, 1, 3, TRUE}, + {BITS(48), 24, 1, 4, 1, 3, TRUE}, + {BITS(49), 24, 1, 4, 1, 3, TRUE}, + {BITS(50), 24, 1, 5, 1, 3, TRUE}, + {BITS(51), 24, 1, 5, 1, 3, TRUE}, + {BITS(52), 24, 1, 5, 1, 3, TRUE}, + {BITS(53), 24, 1, 1, 2, 1}, + {BITS(54), 24, 2, 1, 3, 1, TRUE}, + {BITS(55), 24, 3, 1, 4, 1, TRUE}, + {BITS(56), 24, 4, 1, 5, 1, TRUE}, + {BITS(57), 24, 1, 1, 1, 2}, + {BITS(58), 24, 1, 2, 1, 3, TRUE}, + {BITS(59), 24, 1, 3, 1, 4, TRUE}, + {BITS(60), 24, 1, 4, 1, 5, TRUE}, + {BITS(61), 24, 2, 2, 1, 1, TRUE}, + {BITS(62), 24, 2, 2, 1, 1, TRUE}, + {BITS(63), 24, 2, 2, 1, 1, TRUE}, + {BITS(64), 24, 2, 2, 1, 1, TRUE}, + {BITS(65), 24, 2, 2, 1, 1, TRUE}, + {BITS(66), 24, 2, 2, 1, 1, TRUE}, + {BITS(67), 24, 2, 2, 1, 1}, + {BITS(68), 24, 2, 2, 4, 1, TRUE}, + {BITS(69), 24, 2, 2, 4, 1, TRUE}, + {BITS(70), 24, 2, 2, 4, 1, TRUE}, + {BITS(71), 24, 2, 2, 4, 1, TRUE}, + {BITS(72), 24, 2, 2, 4, 1, TRUE}, + {BITS(73), 24, 2, 2, 4, 1, TRUE}, + {BITS(74), 24, 2, 2, 4, 1, TRUE}, + {BITS(75), 24, 2, 2, 4, 1, TRUE}, + {BITS(76), 24, 2, 2, 4, 1, TRUE}, + {BITS(77), 24, 2, 2, 4, 1, TRUE}, + {BITS(78), 24, 2, 2, 1, 4, TRUE}, + {BITS(79), 24, 2, 2, 1, 4, TRUE}, + {BITS(80), 24, 2, 2, 1, 4, TRUE}, + {BITS(81), 24, 2, 2, 1, 4, TRUE}, + {BITS(82), 24, 2, 2, 1, 4, TRUE}, + {BITS(83), 24, 2, 2, 1, 4, TRUE}, + {BITS(84), 24, 2, 2, 1, 4, TRUE}, + {BITS(85), 24, 2, 2, 1, 4, TRUE}, + {BITS(86), 24, 2, 2, 1, 4, TRUE}, + {BITS(87), 24, 2, 2, 1, 4, TRUE}, + +#undef BITS + }; + + unsigned char bmi_buffer[FIELD_OFFSET(BITMAPINFO, bmiColors[256])]; + HBITMAP src_bmp, dst_bmp, old_src_bmp, old_dst_bmp; + BITMAPINFO *bmi = (BITMAPINFO *)bmi_buffer; + unsigned char *src_bits, *dst_bits; + HDC dc, src_dc, dst_dc; + int i, ret; + + dc = GetDC(0); + + memset(&bmi_buffer, 0, sizeof(bmi_buffer)); + bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + bmi->bmiHeader.biPlanes = 1; + bmi->bmiHeader.biCompression = BI_RGB; + + for (i = 0; i < ARRAY_SIZE(tests); ++i) + { + winetest_push_context("Test %d", i); + + bmi->bmiHeader.biBitCount = tests[i].bpp; + bmi->bmiHeader.biWidth = tests[i].src_width; + bmi->bmiHeader.biHeight = tests[i].src_height; + src_dc = CreateCompatibleDC(dc); + src_bmp = CreateDIBSection(src_dc, bmi, DIB_RGB_COLORS, (void **)&src_bits, NULL, 0); + ok(src_bmp && src_bits, "CreateDIBSection failed, error %u.\n", GetLastError()); + memcpy(src_bits, tests[i].src_bits, tests[i].src_bits_size); + old_src_bmp = SelectObject(src_dc, src_bmp); + + bmi->bmiHeader.biWidth = tests[i].dst_width; + bmi->bmiHeader.biHeight = tests[i].dst_height; + dst_dc = CreateCompatibleDC(dc); + dst_bmp = CreateDIBSection(dst_dc, bmi, DIB_RGB_COLORS, (void **)&dst_bits, NULL, 0); + ok(dst_bmp && dst_bits, "CreateDIBSection failed, error %u.\n", GetLastError()); + old_dst_bmp = SelectObject(dst_dc, dst_bmp); + + SetStretchBltMode(dst_dc, HALFTONE); + ret = GetStretchBltMode(dst_dc); + ok(ret == HALFTONE, "Expected mode %#x, got %#x\n", HALFTONE, ret); + ret = StretchBlt(dst_dc, 0, 0, tests[i].dst_width, tests[i].dst_height, src_dc, 0, 0, + tests[i].src_width, tests[i].src_height, SRCCOPY); + ok(ret, "StretchBlt failed, error %u.\n", GetLastError()); + + ret = memcmp(dst_bits, tests[i].dst_bits, tests[i].dst_bits_size); + todo_wine_if(tests[i].todo) + ok(!ret, "Bits mismatch.\n"); + if (ret) + dump_bits(tests[i].bpp, tests[i].dst_width, tests[i].dst_bits, dst_bits, + tests[i].dst_bits_size, "StretchBlt_HALFTONE"); + + SelectObject(dst_dc, old_dst_bmp); + SelectObject(src_dc, old_src_bmp); + DeleteObject(dst_bmp); + DeleteObject(src_bmp); + DeleteDC(dst_dc); + DeleteDC(src_dc); + + winetest_pop_context(); + } + + ReleaseDC(0, dc); +} + static void check_StretchDIBits_pixel(HDC hdcDst, UINT32 *dstBuffer, UINT32 *srcBuffer, DWORD dwRop, UINT32 expected, int line) { @@ -5963,6 +7098,7 @@ START_TEST(bitmap) test_CreateBitmap(); test_BitBlt(); test_StretchBlt(); + test_StretchBlt_HALFTONE(); test_StretchDIBits(); test_GdiAlphaBlend(); test_GdiGradientFill(); -- 2.30.2

2 1

[PATCH v4 1/2] riched20: Allow to insert OLE object at specified offset.
by Jactry Zeng 14 Jun '21

14 Jun '21

Signed-off-by: Jactry Zeng <jzeng(a)codeweavers.com> --- Superseded patch 206830. v4: - Discard nCursor parameter in ME_InsertOLEFromCursor(). - Rename ME_InsertOLEFromCursor() to editor_insert_oleobj(). --- dlls/riched20/caret.c | 16 ++++++++++++---- dlls/riched20/editor.c | 2 +- dlls/riched20/editor.h | 2 +- dlls/riched20/richole.c | 2 +- dlls/riched20/tests/richole.c | 18 +++++++++--------- 5 files changed, 24 insertions(+), 16 deletions(-) diff --git a/dlls/riched20/caret.c b/dlls/riched20/caret.c index 1f4c3903a38..beac8af50a1 100644 --- a/dlls/riched20/caret.c +++ b/dlls/riched20/caret.c @@ -455,15 +455,23 @@ static struct re_object* create_re_object(const REOBJECT *reo) return reobj; } -void ME_InsertOLEFromCursor(ME_TextEditor *editor, const REOBJECT* reo, int nCursor) +void editor_insert_oleobj(ME_TextEditor *editor, const REOBJECT *reo) { ME_Run *run, *prev; const WCHAR space = ' '; struct re_object *reobj_prev = NULL; - ME_Cursor *cursor = editor->pCursors + nCursor; - ME_Style *style = style_get_insert_style( editor, cursor ); + ME_Cursor *cursor, cursor_from_ofs; + ME_Style *style; + + if (reo->cp == REO_CP_SELECTION) + cursor = editor->pCursors; + else + { + cursor_from_char_ofs( editor, reo->cp, &cursor_from_ofs ); + cursor = &cursor_from_ofs; + } + style = style_get_insert_style( editor, cursor ); - /* FIXME no no no */ if (ME_IsSelection(editor)) ME_DeleteSelection(editor); diff --git a/dlls/riched20/editor.c b/dlls/riched20/editor.c index d4aadc325f9..cc02604767e 100644 --- a/dlls/riched20/editor.c +++ b/dlls/riched20/editor.c @@ -1172,7 +1172,7 @@ static HRESULT insert_static_object(ME_TextEditor *editor, HENHMETAFILE hemf, HB reobject.dwFlags = 0; /* FIXME */ reobject.dwUser = 0; - ME_InsertOLEFromCursor(editor, &reobject, 0); + editor_insert_oleobj(editor, &reobject); hr = S_OK; } diff --git a/dlls/riched20/editor.h b/dlls/riched20/editor.h index 141e9034a6a..fdf3e068fe9 100644 --- a/dlls/riched20/editor.h +++ b/dlls/riched20/editor.h @@ -188,7 +188,7 @@ int ME_GetSelection(ME_TextEditor *editor, ME_Cursor **from, ME_Cursor **to) DEC BOOL ME_IsSelection(ME_TextEditor *editor) DECLSPEC_HIDDEN; void ME_DeleteSelection(ME_TextEditor *editor) DECLSPEC_HIDDEN; void ME_SendSelChange(ME_TextEditor *editor) DECLSPEC_HIDDEN; -void ME_InsertOLEFromCursor(ME_TextEditor *editor, const REOBJECT* reo, int nCursor) DECLSPEC_HIDDEN; +void editor_insert_oleobj( ME_TextEditor *editor, const REOBJECT *reo ) DECLSPEC_HIDDEN; BOOL ME_InternalDeleteText(ME_TextEditor *editor, ME_Cursor *start, int nChars, BOOL bForce) DECLSPEC_HIDDEN; int ME_GetTextLength(ME_TextEditor *editor) DECLSPEC_HIDDEN; int ME_GetTextLengthEx(ME_TextEditor *editor, const GETTEXTLENGTHEX *how) DECLSPEC_HIDDEN; diff --git a/dlls/riched20/richole.c b/dlls/riched20/richole.c index 72840a4cafa..03572511ff7 100644 --- a/dlls/riched20/richole.c +++ b/dlls/riched20/richole.c @@ -1367,7 +1367,7 @@ IRichEditOle_fnInsertObject(IRichEditOle *iface, REOBJECT *reo) if (reo->cbStruct < sizeof(*reo)) return STG_E_INVALIDPARAMETER; - ME_InsertOLEFromCursor(services->editor, reo, 0); + editor_insert_oleobj(services->editor, reo); ME_CommitUndo(services->editor); ME_UpdateRepaint(services->editor, FALSE); return S_OK; diff --git a/dlls/riched20/tests/richole.c b/dlls/riched20/tests/richole.c index a76f9fdaf2e..a8c48994613 100644 --- a/dlls/riched20/tests/richole.c +++ b/dlls/riched20/tests/richole.c @@ -3377,15 +3377,15 @@ static void test_InsertObject(void) SendMessageW(hwnd, EM_SETSEL, 3, 4); result = SendMessageW(hwnd, EM_SELECTIONTYPE, 0, 0); - todo_wine ok(result == SEL_OBJECT, "Got selection type: %x.\n", result); - todo_wine CHECK_REOBJECT_STRUCT(reole, REO_IOB_SELECTION, REO_GETOBJ_ALL_INTERFACES, 1, NULL, NULL, reo1.polesite, 1); + ok(result == SEL_OBJECT, "Got selection type: %x.\n", result); + CHECK_REOBJECT_STRUCT(reole, REO_IOB_SELECTION, REO_GETOBJ_ALL_INTERFACES, 1, NULL, NULL, reo1.polesite, 1); SendMessageW(hwnd, EM_SETSEL, 2, 4); result = SendMessageW(hwnd, EM_SELECTIONTYPE, 0, 0); - todo_wine ok(result == (SEL_TEXT | SEL_OBJECT), "Got selection type: %x.\n", result); + ok(result == (SEL_TEXT | SEL_OBJECT), "Got selection type: %x.\n", result); SendMessageW(hwnd, EM_SETSEL, 5, 6); - todo_wine CHECK_REOBJECT_STRUCT(reole, REO_IOB_SELECTION, REO_GETOBJ_ALL_INTERFACES, 1, NULL, NULL, reo2.polesite, 2); + CHECK_REOBJECT_STRUCT(reole, REO_IOB_SELECTION, REO_GETOBJ_ALL_INTERFACES, 1, NULL, NULL, reo2.polesite, 2); expected_string = L"abc\xfffc""d\xfffc""efg"; gettextex.cb = sizeof(buffer); @@ -3408,7 +3408,7 @@ static void test_InsertObject(void) SendMessageA(hwnd, EM_SETSEL, 0, -1); result = SendMessageA(hwnd, EM_GETSELTEXT, (WPARAM)sizeof(bufferA), (LPARAM)bufferA); ok(result == strlen(expected_stringA), "Got wrong length: %d.\n", result); - todo_wine ok(!strcmp(bufferA, expected_stringA), "Got wrong content: %s.\n", bufferA); + ok(!strcmp(bufferA, expected_stringA), "Got wrong content: %s.\n", bufferA); memset(bufferA, 0, sizeof(bufferA)); textrange.lpstrText = bufferA; @@ -3416,7 +3416,7 @@ static void test_InsertObject(void) textrange.chrg.cpMax = 11; result = SendMessageA(hwnd, EM_GETTEXTRANGE, 0, (LPARAM)&textrange); ok(result == strlen(expected_stringA), "Got wrong length: %d.\n", result); - todo_wine ok(!strcmp(bufferA, expected_stringA), "Got wrong content: %s.\n", bufferA); + ok(!strcmp(bufferA, expected_stringA), "Got wrong content: %s.\n", bufferA); expected_string = L"abc\xfffc""d\xfffc""efg\r"; hr = ITextDocument_Range(doc, 0, 11, &range); @@ -3467,7 +3467,7 @@ static void test_InsertObject(void) ok(hr == S_OK, "Got hr %#x.\n", hr); string = GlobalLock(stgmedium.hGlobal); ok(lstrlenW(string) == lstrlenW(expected_string), "Got wrong length: %d.\n", lstrlenW(string)); - todo_wine ok(!lstrcmpW(string, expected_string), "Got wrong content: %s.\n", debugstr_w(string)); + ok(!lstrcmpW(string, expected_string), "Got wrong content: %s.\n", debugstr_w(string)); GlobalUnlock(stgmedium.hGlobal); expected_string = L"abc\xfffc""d\xfffc""efg"; @@ -3491,7 +3491,7 @@ static void test_InsertObject(void) SendMessageA(hwnd, EM_SETSEL, 0, -1); result = SendMessageA(hwnd, EM_GETSELTEXT, (WPARAM)sizeof(bufferA), (LPARAM)bufferA); ok(result == strlen(expected_stringA), "Got wrong length: %d.\n", result); - todo_wine ok(!strcmp(bufferA, expected_stringA), "Got wrong content: %s.\n", bufferA); + ok(!strcmp(bufferA, expected_stringA), "Got wrong content: %s.\n", bufferA); memset(bufferA, 0, sizeof(bufferA)); textrange.lpstrText = bufferA; @@ -3499,7 +3499,7 @@ static void test_InsertObject(void) textrange.chrg.cpMax = 11; result = SendMessageA(hwnd, EM_GETTEXTRANGE, 0, (LPARAM)&textrange); ok(result == strlen(expected_stringA), "Got wrong length: %d.\n", result); - todo_wine ok(!strcmp(bufferA, expected_stringA), "Got wrong content: %s.\n", bufferA); + ok(!strcmp(bufferA, expected_stringA), "Got wrong content: %s.\n", bufferA); expected_string = L"abc\xfffc""d\xfffc""efg"; hr = ITextDocument_Range(doc, 0, 11, &range); -- 2.30.2

2 3

[PATCH] gdi32: Fix SetPixel error return value.
by Jacek Caban 14 Jun '21

14 Jun '21

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/gdi32/painting.c | 2 +- dlls/gdi32/tests/dc.c | 10 ++++++++++ 2 files changed, 11 insertions(+), 1 deletion(-)

2 1

[PATCH 1/5] server: Use AFD_POLL_* flags internally.
by Zebediah Figura 14 Jun '21

14 Jun '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- include/wine/afd.h | 19 ++++++ server/sock.c | 166 +++++++++++++++++++++++++++++---------------- 2 files changed, 128 insertions(+), 57 deletions(-) diff --git a/include/wine/afd.h b/include/wine/afd.h index 595fc572a1c..c4a15d6688c 100644 --- a/include/wine/afd.h +++ b/include/wine/afd.h @@ -36,6 +36,25 @@ #define IOCTL_AFD_RECV CTL_CODE(FILE_DEVICE_BEEP, 0x805, METHOD_NEITHER, FILE_ANY_ACCESS) #define IOCTL_AFD_POLL CTL_CODE(FILE_DEVICE_BEEP, 0x809, METHOD_BUFFERED, FILE_ANY_ACCESS) +enum afd_poll_bit +{ + AFD_POLL_BIT_READ = 0, + AFD_POLL_BIT_OOB = 1, + AFD_POLL_BIT_WRITE = 2, + AFD_POLL_BIT_HUP = 3, + AFD_POLL_BIT_RESET = 4, + AFD_POLL_BIT_CLOSE = 5, + AFD_POLL_BIT_CONNECT = 6, + AFD_POLL_BIT_ACCEPT = 7, + AFD_POLL_BIT_CONNECT_ERR = 8, + /* IOCTL_AFD_GET_EVENTS has space for 13 events. */ + AFD_POLL_BIT_UNK1 = 9, + AFD_POLL_BIT_UNK2 = 10, + AFD_POLL_BIT_UNK3 = 11, + AFD_POLL_BIT_UNK4 = 12, + AFD_POLL_BIT_COUNT = 13, +}; + #define AFD_POLL_READ 0x0001 #define AFD_POLL_OOB 0x0002 #define AFD_POLL_WRITE 0x0004 diff --git a/server/sock.c b/server/sock.c index 66440a540dc..2a22bb2340b 100644 --- a/server/sock.c +++ b/server/sock.c @@ -146,14 +146,14 @@ struct sock struct fd *fd; /* socket file descriptor */ enum connection_state state; /* connection state */ unsigned int mask; /* event mask */ - /* pending FD_* events which have not yet been reported to the application */ + /* pending AFD_POLL_* events which have not yet been reported to the application */ unsigned int pending_events; - /* FD_* events which have already been reported and should not be selected - * for again until reset by a relevant call. + /* AFD_POLL_* events which have already been reported and should not be + * selected for again until reset by a relevant call. * - * For example, if FD_READ is set here and not in pending_events, it has - * already been reported and consumed, and we should not report it again, - * even if POLLIN is signaled, until it is reset by e.g recv(). + * For example, if AFD_POLL_READ is set here and not in pending_events, it + * has already been reported and consumed, and we should not report it + * again, even if POLLIN is signaled, until it is reset by e.g recv(). * * If an event has been signaled and not consumed yet, it will be set in * both pending_events and reported_events (as we should only ever report @@ -167,7 +167,7 @@ struct sock user_handle_t window; /* window to send the message to */ unsigned int message; /* message to send */ obj_handle_t wparam; /* message wparam (socket handle) */ - unsigned int errors[FD_MAX_EVENTS]; /* event errors */ + unsigned int errors[AFD_POLL_BIT_COUNT]; /* event errors */ timeout_t connect_time;/* time the socket was connected */ struct sock *deferred; /* socket that waits for a deferred accept */ struct async_queue read_q; /* queue for asynchronous reads */ @@ -338,27 +338,21 @@ static int sockaddr_from_unix( const union unix_sockaddr *uaddr, struct WS_socka } } -/* Permutation of 0..FD_MAX_EVENTS - 1 representing the order in which - * we post messages if there are multiple events. Used to send - * messages. The problem is if there is both a FD_CONNECT event and, - * say, an FD_READ event available on the same socket, we want to - * notify the app of the connect event first. Otherwise it may - * discard the read event because it thinks it hasn't connected yet. - */ -static const int event_bitorder[FD_MAX_EVENTS] = +/* some events are generated at the same time but must be sent in a particular + * order (e.g. CONNECT must be sent before READ) */ +static const enum afd_poll_bit event_bitorder[] = { - FD_CONNECT_BIT, - FD_ACCEPT_BIT, - FD_OOB_BIT, - FD_WRITE_BIT, - FD_READ_BIT, - FD_CLOSE_BIT, - 6, 7, 8, 9 /* leftovers */ + AFD_POLL_BIT_CONNECT, + AFD_POLL_BIT_CONNECT_ERR, + AFD_POLL_BIT_ACCEPT, + AFD_POLL_BIT_OOB, + AFD_POLL_BIT_WRITE, + AFD_POLL_BIT_READ, + AFD_POLL_BIT_RESET, + AFD_POLL_BIT_HUP, + AFD_POLL_BIT_CLOSE, }; -/* Flags that make sense only for SOCK_STREAM sockets */ -#define STREAM_FLAG_MASK ((unsigned int) (FD_CONNECT | FD_ACCEPT | FD_WINE_LISTENING | FD_WINE_CONNECTED)) - typedef enum { SOCK_SHUTDOWN_ERROR = -1, SOCK_SHUTDOWN_EOF = 0, @@ -425,6 +419,53 @@ static int sock_reselect( struct sock *sock ) return ev; } +static unsigned int afd_poll_flag_to_win32( unsigned int flags ) +{ + static const unsigned int map[] = + { + FD_READ, /* READ */ + FD_OOB, /* OOB */ + FD_WRITE, /* WRITE */ + FD_CLOSE, /* HUP */ + FD_CLOSE, /* RESET */ + 0, /* CLOSE */ + FD_CONNECT, /* CONNECT */ + FD_ACCEPT, /* ACCEPT */ + FD_CONNECT, /* CONNECT_ERR */ + }; + + unsigned int i, ret = 0; + + for (i = 0; i < ARRAY_SIZE(map); ++i) + { + if (flags & (1 << i)) ret |= map[i]; + } + + return ret; +} + +static unsigned int afd_poll_flag_from_win32( unsigned int flags ) +{ + static const unsigned int map[] = + { + AFD_POLL_READ, + AFD_POLL_WRITE, + AFD_POLL_OOB, + AFD_POLL_ACCEPT, + AFD_POLL_CONNECT | AFD_POLL_CONNECT_ERR, + AFD_POLL_RESET | AFD_POLL_HUP, + }; + + unsigned int i, ret = 0; + + for (i = 0; i < ARRAY_SIZE(map); ++i) + { + if (flags & (1 << i)) ret |= map[i]; + } + + return ret; +} + /* wake anybody waiting on the socket event or send the associated message */ static void sock_wake_up( struct sock *sock ) { @@ -440,12 +481,12 @@ static void sock_wake_up( struct sock *sock ) if (sock->window) { if (debug_level) fprintf(stderr, "signalling events %x win %08x\n", events, sock->window ); - for (i = 0; i < FD_MAX_EVENTS; i++) + for (i = 0; i < ARRAY_SIZE(event_bitorder); i++) { - int event = event_bitorder[i]; + enum afd_poll_bit event = event_bitorder[i]; if (events & (1 << event)) { - lparam_t lparam = (1 << event) | (sock->errors[event] << 16); + lparam_t lparam = afd_poll_flag_to_win32(1 << event) | (sock->errors[event] << 16); post_message( sock->window, sock->message, sock->wparam, lparam ); } } @@ -810,7 +851,7 @@ static int sock_dispatch_asyncs( struct sock *sock, int event, int error ) return event; } -static void post_socket_event( struct sock *sock, unsigned int event_bit, unsigned int error ) +static void post_socket_event( struct sock *sock, enum afd_poll_bit event_bit, unsigned int error ) { unsigned int event = (1 << event_bit); @@ -830,28 +871,30 @@ static void sock_dispatch_events( struct sock *sock, enum connection_state prevs break; case SOCK_CONNECTING: - if (event & (POLLOUT | POLLERR | POLLHUP)) - post_socket_event( sock, FD_CONNECT_BIT, sock_get_error( error ) ); + if (event & POLLOUT) + post_socket_event( sock, AFD_POLL_BIT_CONNECT, 0 ); + if (event & (POLLERR | POLLHUP)) + post_socket_event( sock, AFD_POLL_BIT_CONNECT_ERR, sock_get_error( error ) ); break; case SOCK_LISTENING: if (event & (POLLIN | POLLERR | POLLHUP)) - post_socket_event( sock, FD_ACCEPT_BIT, sock_get_error( error ) ); + post_socket_event( sock, AFD_POLL_BIT_ACCEPT, sock_get_error( error ) ); break; case SOCK_CONNECTED: case SOCK_CONNECTIONLESS: if (event & POLLIN) - post_socket_event( sock, FD_READ_BIT, 0 ); + post_socket_event( sock, AFD_POLL_BIT_READ, 0 ); if (event & POLLOUT) - post_socket_event( sock, FD_WRITE_BIT, 0 ); + post_socket_event( sock, AFD_POLL_BIT_WRITE, 0 ); if (event & POLLPRI) - post_socket_event( sock, FD_OOB_BIT, 0 ); + post_socket_event( sock, AFD_POLL_BIT_OOB, 0 ); if (event & (POLLERR | POLLHUP)) - post_socket_event( sock, FD_CLOSE_BIT, sock_get_error( error ) ); + post_socket_event( sock, AFD_POLL_BIT_HUP, sock_get_error( error ) ); break; } @@ -1006,7 +1049,7 @@ static int sock_get_poll_events( struct fd *fd ) return POLLOUT; case SOCK_LISTENING: - if (!list_empty( &sock->accept_list ) || (mask & FD_ACCEPT)) + if (!list_empty( &sock->accept_list ) || (mask & AFD_POLL_ACCEPT)) ev |= POLLIN; break; @@ -1020,17 +1063,17 @@ static int sock_get_poll_events( struct fd *fd ) { if (async_waiting( &sock->read_q )) ev |= POLLIN | POLLPRI; } - else if (!sock->rd_shutdown && (mask & FD_READ)) + else if (!sock->rd_shutdown && (mask & AFD_POLL_READ)) ev |= POLLIN | POLLPRI; - /* We use POLLIN with 0 bytes recv() as FD_CLOSE indication for stream sockets. */ - else if (sock->state == SOCK_CONNECTED && (mask & FD_CLOSE) && !(sock->reported_events & FD_READ)) + /* We use POLLIN with 0 bytes recv() as hangup indication for stream sockets. */ + else if (sock->state == SOCK_CONNECTED && (mask & AFD_POLL_HUP) && !(sock->reported_events & AFD_POLL_READ)) ev |= POLLIN; if (async_queued( &sock->write_q )) { if (async_waiting( &sock->write_q )) ev |= POLLOUT; } - else if (!sock->wr_shutdown && (mask & FD_WRITE)) + else if (!sock->wr_shutdown && (mask & AFD_POLL_WRITE)) { ev |= POLLOUT; } @@ -1465,8 +1508,8 @@ static struct sock *accept_socket( struct sock *sock ) } } clear_error(); - sock->pending_events &= ~FD_ACCEPT; - sock->reported_events &= ~FD_ACCEPT; + sock->pending_events &= ~AFD_POLL_ACCEPT; + sock->reported_events &= ~AFD_POLL_ACCEPT; sock_reselect( sock ); return acceptsock; } @@ -1514,8 +1557,8 @@ static int accept_into_socket( struct sock *sock, struct sock *acceptsock ) acceptsock->fd = newfd; clear_error(); - sock->pending_events &= ~FD_ACCEPT; - sock->reported_events &= ~FD_ACCEPT; + sock->pending_events &= ~AFD_POLL_ACCEPT; + sock->reported_events &= ~AFD_POLL_ACCEPT; sock_reselect( sock ); return TRUE; @@ -1791,7 +1834,7 @@ static int sock_ioctl( struct fd *fd, ioctl_code_t code, struct async *async ) /* a listening socket can no longer be accepted into */ allow_fd_caching( sock->fd ); - /* we may already be selecting for FD_ACCEPT */ + /* we may already be selecting for AFD_POLL_ACCEPT */ sock_reselect( sock ); return 0; } @@ -2374,11 +2417,11 @@ DECL_HANDLER(set_socket_event) FILE_WRITE_ATTRIBUTES, &sock_ops))) return; if (get_unix_fd( sock->fd ) == -1) return; old_event = sock->event; - sock->mask = req->mask; + sock->mask = afd_poll_flag_from_win32( req->mask ); if (req->window) { - sock->pending_events &= ~req->mask; - sock->reported_events &= ~req->mask; + sock->pending_events &= ~sock->mask; + sock->reported_events &= ~sock->mask; } sock->event = NULL; sock->window = req->window; @@ -2393,7 +2436,7 @@ DECL_HANDLER(set_socket_event) sock->nonblocking = 1; /* if a network event is pending, signal the event object - it is possible that FD_CONNECT or FD_ACCEPT network events has happened + it is possible that CONNECT or ACCEPT network events has happened before a WSAEventSelect() was done on it. (when dealing with Asynchronous socket) */ sock_wake_up( sock ); @@ -2405,14 +2448,23 @@ DECL_HANDLER(set_socket_event) /* get socket event parameters */ DECL_HANDLER(get_socket_event) { + unsigned int errors[FD_MAX_EVENTS] = {0}; struct sock *sock; if (!(sock = (struct sock *)get_handle_obj( current->process, req->handle, FILE_READ_ATTRIBUTES, &sock_ops ))) return; if (get_unix_fd( sock->fd ) == -1) return; - reply->mask = sock->mask; - reply->pmask = sock->pending_events; - set_reply_data( sock->errors, min( get_reply_max_size(), sizeof(sock->errors) )); + reply->mask = afd_poll_flag_to_win32( sock->mask ); + reply->pmask = afd_poll_flag_to_win32( sock->pending_events ); + + errors[FD_READ_BIT] = sock->errors[AFD_POLL_BIT_READ]; + errors[FD_WRITE_BIT] = sock->errors[AFD_POLL_BIT_WRITE]; + errors[FD_OOB_BIT] = sock->errors[AFD_POLL_BIT_OOB]; + errors[FD_ACCEPT_BIT] = sock->errors[AFD_POLL_BIT_ACCEPT]; + errors[FD_CONNECT_BIT] = sock->errors[AFD_POLL_BIT_CONNECT_ERR]; + if (!(errors[FD_CLOSE_BIT] = sock->errors[AFD_POLL_BIT_HUP])) + errors[FD_CLOSE_BIT] = sock->errors[AFD_POLL_BIT_RESET]; + set_reply_data( errors, min( get_reply_max_size(), sizeof(errors) )); if (req->service) { @@ -2499,8 +2551,8 @@ DECL_HANDLER(recv_socket) if (status == STATUS_PENDING && sock->rd_shutdown) status = STATUS_PIPE_DISCONNECTED; - sock->pending_events &= ~(req->oob ? FD_OOB : FD_READ); - sock->reported_events &= ~(req->oob ? FD_OOB : FD_READ); + sock->pending_events &= ~(req->oob ? AFD_POLL_OOB : AFD_POLL_READ); + sock->reported_events &= ~(req->oob ? AFD_POLL_OOB : AFD_POLL_READ); if ((async = create_request_async( fd, get_fd_comp_flags( fd ), &req->async ))) { @@ -2570,8 +2622,8 @@ DECL_HANDLER(send_socket) if (status != STATUS_SUCCESS) { /* send() calls only clear and reselect events if unsuccessful. */ - sock->pending_events &= ~FD_WRITE; - sock->reported_events &= ~FD_WRITE; + sock->pending_events &= ~AFD_POLL_WRITE; + sock->reported_events &= ~AFD_POLL_WRITE; } /* If we had a short write and the socket is nonblocking (and the client is -- 2.30.2

1 4

[tools] testbot/WineTest: Don't run the tests for test=build missions.
by Francois Gouget 13 Jun '21

13 Jun '21

Signed-off-by: Francois Gouget <fgouget(a)codeweavers.com> --- testbot/bin/build/WineTest.pl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testbot/bin/build/WineTest.pl b/testbot/bin/build/WineTest.pl index ffd665faa..73cd660c6 100755 --- a/testbot/bin/build/WineTest.pl +++ b/testbot/bin/build/WineTest.pl @@ -116,7 +116,7 @@ sub TestPatch($$) { push @TestList, "-m", "do.not.submit"; } - else + elsif ($Mission->{test} ne "build") { foreach my $ModuleName (sort keys %{$Impacts->{Modules}}) { -- 2.20.1

1 0

[PATCH] ntdll: Export ZwFilterToken().
by Kalen Alwardt 13 Jun '21

13 Jun '21

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=39142 Signed-off-by: Kalen Alwardt <kalenalwardt(a)gmail.com> --- dlls/ntdll/ntdll.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 6bd6579d432..8cba4fa164a 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -1224,7 +1224,7 @@ # @ stub ZwEnumerateSystemEnvironmentValuesEx @ stdcall -private -syscall ZwEnumerateValueKey(long long long ptr long ptr) NtEnumerateValueKey @ stub ZwExtendSection -# @ stub ZwFilterToken +@ stdcall -private -syscall ZwFilterToken(long long ptr ptr ptr ptr) NtFilterToken @ stdcall -private -syscall ZwFindAtom(ptr long ptr) NtFindAtom @ stdcall -private -syscall ZwFlushBuffersFile(long ptr) NtFlushBuffersFile @ stdcall -private -syscall ZwFlushInstructionCache(long ptr long) NtFlushInstructionCache -- 2.18.0.windows.1

2 1

[PATCH] server: Free the old process image name if a second process image is mapped (Valgrind).
by Zebediah Figura 12 Jun '21

12 Jun '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- server/mapping.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/server/mapping.c b/server/mapping.c index 9cb24a4213f..cd918224caa 100644 --- a/server/mapping.c +++ b/server/mapping.c @@ -376,6 +376,9 @@ static void add_process_view( struct thread *thread, struct memory_view *view ) /* main exe */ set_process_machine( process, view ); list_add_head( &process->views, &view->entry ); + + free( process->image ); + process->image = NULL; if (get_view_nt_name( view, &name ) && (process->image = memdup( name.str, name.len ))) process->imagelen = name.len; return; -- 2.30.2

1 0

[PATCH] ntdll: Reserve space for the whole 64-bit YMM context in struct x86_thread_data.
by Zebediah Figura 12 Jun '21

12 Jun '21

Fixes a regression introduced by 308a5e7c4d01525184b057058949c68c0ee77dba. This was previously broken, but happened to work until the aforementioned commit put the YMM state right at the end of a page. Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- I don't know how accurate "some" is; both of my development machines suffer from this. It manifests as a stack overflow trying to execute any 32-bit program. The processors in question are AMD cores manufactured in 2012 and 2018. dlls/ntdll/unix/signal_i386.c | 53 +++++++++++------------------------ 1 file changed, 16 insertions(+), 37 deletions(-) diff --git a/dlls/ntdll/unix/signal_i386.c b/dlls/ntdll/unix/signal_i386.c index 0b2b269505f..446fed25eb8 100644 --- a/dlls/ntdll/unix/signal_i386.c +++ b/dlls/ntdll/unix/signal_i386.c @@ -461,24 +461,6 @@ enum i386_trap_code #endif }; -struct syscall_xsave -{ - union - { - XSAVE_FORMAT xsave; - FLOATING_SAVE_AREA fsave; - } u; - struct - { - ULONG64 mask; - ULONG64 compaction_mask; - ULONG64 reserved[6]; - M128A ymm_high[8]; - } xstate; -}; - -C_ASSERT( sizeof(struct syscall_xsave) == 0x2c0 ); - struct syscall_frame { DWORD restore_flags; /* 000 */ @@ -504,16 +486,13 @@ struct syscall_frame XSAVE_FORMAT xsave; FLOATING_SAVE_AREA fsave; } u; - struct /* 240 */ - { - ULONG64 mask; - ULONG64 compaction_mask; - ULONG64 reserved[6]; - M128A ymm_high[8]; - } xstate; + /* Leave space for the whole set of YMM registers. They're not used in + * 32-bit mode, but some processors fault if they're not in writable memory. + */ + XSTATE xstate; /* 240 */ }; -C_ASSERT( sizeof(struct syscall_frame) == 0x300 ); +C_ASSERT( sizeof(struct syscall_frame) == 0x380 ); struct x86_thread_data { @@ -1011,7 +990,7 @@ NTSTATUS WINAPI NtSetContextThread( HANDLE handle, const CONTEXT *context ) memcpy( &frame->u.xsave, context->ExtendedRegisters, sizeof(frame->u.xsave) ); /* reset the current interrupt status */ frame->u.xsave.StatusWord &= frame->u.xsave.ControlWord | 0xff80; - frame->xstate.mask |= XSTATE_MASK_LEGACY; + frame->xstate.Mask |= XSTATE_MASK_LEGACY; } else if (flags & CONTEXT_FLOATING_POINT) { @@ -1023,7 +1002,7 @@ NTSTATUS WINAPI NtSetContextThread( HANDLE handle, const CONTEXT *context ) { frame->u.fsave = context->FloatSave; } - frame->xstate.mask |= XSTATE_MASK_LEGACY_FLOATING_POINT; + frame->xstate.Mask |= XSTATE_MASK_LEGACY_FLOATING_POINT; } if (flags & CONTEXT_XSTATE) { @@ -1032,10 +1011,10 @@ NTSTATUS WINAPI NtSetContextThread( HANDLE handle, const CONTEXT *context ) if (xs->Mask & XSTATE_MASK_GSSE) { - frame->xstate.mask |= XSTATE_MASK_GSSE; - memcpy( &frame->xstate.ymm_high, &xs->YmmContext, sizeof(frame->xstate.ymm_high) ); + frame->xstate.Mask |= XSTATE_MASK_GSSE; + frame->xstate.YmmContext = xs->YmmContext; } - else frame->xstate.mask &= ~XSTATE_MASK_GSSE; + else frame->xstate.Mask &= ~XSTATE_MASK_GSSE; } frame->restore_flags |= flags & ~CONTEXT_INTEGER; @@ -1104,7 +1083,7 @@ NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context ) context->FloatSave = frame->u.fsave; } else if (!xstate_compaction_enabled || - (frame->xstate.mask & XSTATE_MASK_LEGACY_FLOATING_POINT)) + (frame->xstate.Mask & XSTATE_MASK_LEGACY_FLOATING_POINT)) { fpux_to_fpu( &context->FloatSave, &frame->u.xsave ); } @@ -1120,7 +1099,7 @@ NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context ) XSAVE_FORMAT *xs = (XSAVE_FORMAT *)context->ExtendedRegisters; if (!xstate_compaction_enabled || - (frame->xstate.mask & XSTATE_MASK_LEGACY_FLOATING_POINT)) + (frame->xstate.Mask & XSTATE_MASK_LEGACY_FLOATING_POINT)) { memcpy( xs, &frame->u.xsave, FIELD_OFFSET( XSAVE_FORMAT, MxCsr )); memcpy( xs->FloatRegisters, frame->u.xsave.FloatRegisters, @@ -1133,7 +1112,7 @@ NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context ) xs->ControlWord = 0x37f; } - if (!xstate_compaction_enabled || (frame->xstate.mask & XSTATE_MASK_LEGACY_SSE)) + if (!xstate_compaction_enabled || (frame->xstate.Mask & XSTATE_MASK_LEGACY_SSE)) { memcpy( xs->XmmRegisters, frame->u.xsave.XmmRegisters, sizeof( xs->XmmRegisters )); xs->MxCsr = frame->u.xsave.MxCsr; @@ -1168,7 +1147,7 @@ NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context ) return STATUS_INVALID_PARAMETER; mask = (xstate_compaction_enabled ? xstate->CompactionMask : xstate->Mask) & XSTATE_MASK_GSSE; - xstate->Mask = frame->xstate.mask & mask; + xstate->Mask = frame->xstate.Mask & mask; xstate->CompactionMask = xstate_compaction_enabled ? (0x8000000000000000 | mask) : 0; memset( xstate->Reserved, 0, sizeof(xstate->Reserved) ); if (xstate->Mask) @@ -1176,7 +1155,7 @@ NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context ) if (context_ex->XState.Length < sizeof(XSTATE)) return STATUS_BUFFER_OVERFLOW; - memcpy( &xstate->YmmContext, frame->xstate.ymm_high, sizeof(frame->xstate.ymm_high) ); + xstate->YmmContext = frame->xstate.YmmContext; } } } @@ -2401,7 +2380,7 @@ __ASM_GLOBAL_FUNC( signal_start_thread, /* set syscall frame */ "cmpl $0,%fs:0x1f8\n\t" /* x86_thread_data()->syscall_frame */ "jnz 1f\n\t" - "leal -0x300(%esp),%eax\n\t" /* sizeof(struct syscall_frame) */ + "leal -0x380(%esp),%eax\n\t" /* sizeof(struct syscall_frame) */ "andl $~63,%eax\n\t" "movl %eax,%fs:0x1f8\n" /* x86_thread_data()->syscall_frame */ /* switch to thread stack */ -- 2.30.2

3 2

[PATCH v2 2/2] dpnhupnp: Stub DirectPlayNATHelpCreate and DllGetClassObject
by Alistair Leslie-Hughes 11 Jun '21

11 Jun '21

Stop crash in "STAR WARS Galactic Battlegrounds Saga" Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/dpnhupnp/Makefile.in | 2 ++ dlls/dpnhupnp/dpnhupnp.spec | 4 ++-- dlls/dpnhupnp/main.c | 39 +++++++++++++++++++++++++++++++++++++ 3 files changed, 43 insertions(+), 2 deletions(-) create mode 100644 dlls/dpnhupnp/main.c diff --git a/dlls/dpnhupnp/Makefile.in b/dlls/dpnhupnp/Makefile.in index 566ce038f82..6aa9ef1dd80 100644 --- a/dlls/dpnhupnp/Makefile.in +++ b/dlls/dpnhupnp/Makefile.in @@ -2,5 +2,7 @@ MODULE = dpnhupnp.dll EXTRADLLFLAGS = -Wb,--prefer-native +C_SRCS = \ + main.c RC_SRCS = version.rc diff --git a/dlls/dpnhupnp/dpnhupnp.spec b/dlls/dpnhupnp/dpnhupnp.spec index 2a750e53675..9145823b92a 100644 --- a/dlls/dpnhupnp/dpnhupnp.spec +++ b/dlls/dpnhupnp/dpnhupnp.spec @@ -1,6 +1,6 @@ -@ stub DirectPlayNATHelpCreate +@ stdcall DirectPlayNATHelpCreate(ptr ptr) @ stdcall -private DllCanUnloadNow() -@ stub DllGetClassObject +@ stdcall -private DllGetClassObject() @ stdcall -private DllRegisterServer() @ stdcall -private DllUnregisterServer() diff --git a/dlls/dpnhupnp/main.c b/dlls/dpnhupnp/main.c new file mode 100644 index 00000000000..10bca6e7c23 --- /dev/null +++ b/dlls/dpnhupnp/main.c @@ -0,0 +1,39 @@ +/* + * + * Copyright (C) 2021 Alistair Leslie-Hughes + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <stdarg.h> + +#include "windef.h" +#include "winbase.h" +#include "objbase.h" +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dpnhupnp); + +HRESULT WINAPI DirectPlayNATHelpCreate(LPCGUID pIID, void **ppv) +{ + FIXME("(%p, %p) stub\n", pIID, ppv); + return E_NOTIMPL; +} + +HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv) +{ + FIXME("(%s, %s, %p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv); + return E_FAIL; +} -- 2.30.2

1 0

[PATCH v2 1/2] dpnhupnp: add stub dll
by Alistair Leslie-Hughes 11 Jun '21

11 Jun '21

From: Austin English <austinenglish(a)gmail.com> Signed-off-by: Austin English <austinenglish(a)gmail.com> Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- configure.ac | 1 + dlls/dpnhupnp/Makefile.in | 6 ++++++ dlls/dpnhupnp/dpnhupnp.spec | 6 ++++++ dlls/dpnhupnp/version.rc | 26 ++++++++++++++++++++++++++ 4 files changed, 39 insertions(+) create mode 100644 dlls/dpnhupnp/Makefile.in create mode 100644 dlls/dpnhupnp/dpnhupnp.spec create mode 100644 dlls/dpnhupnp/version.rc diff --git a/configure.ac b/configure.ac index 8c74532dabc..e7475de1f7d 100644 --- a/configure.ac +++ b/configure.ac @@ -3171,6 +3171,7 @@ WINE_CONFIG_MAKEFILE(dlls/dplay) WINE_CONFIG_MAKEFILE(dlls/dplayx) WINE_CONFIG_MAKEFILE(dlls/dplayx/tests) WINE_CONFIG_MAKEFILE(dlls/dpnaddr) +WINE_CONFIG_MAKEFILE(dlls/dpnhupnp) WINE_CONFIG_MAKEFILE(dlls/dpnet) WINE_CONFIG_MAKEFILE(dlls/dpnet/tests) WINE_CONFIG_MAKEFILE(dlls/dpnhpast) diff --git a/dlls/dpnhupnp/Makefile.in b/dlls/dpnhupnp/Makefile.in new file mode 100644 index 00000000000..566ce038f82 --- /dev/null +++ b/dlls/dpnhupnp/Makefile.in @@ -0,0 +1,6 @@ +MODULE = dpnhupnp.dll + +EXTRADLLFLAGS = -Wb,--prefer-native + + +RC_SRCS = version.rc diff --git a/dlls/dpnhupnp/dpnhupnp.spec b/dlls/dpnhupnp/dpnhupnp.spec new file mode 100644 index 00000000000..2a750e53675 --- /dev/null +++ b/dlls/dpnhupnp/dpnhupnp.spec @@ -0,0 +1,6 @@ +@ stub DirectPlayNATHelpCreate + +@ stdcall -private DllCanUnloadNow() +@ stub DllGetClassObject +@ stdcall -private DllRegisterServer() +@ stdcall -private DllUnregisterServer() diff --git a/dlls/dpnhupnp/version.rc b/dlls/dpnhupnp/version.rc new file mode 100644 index 00000000000..21633a49815 --- /dev/null +++ b/dlls/dpnhupnp/version.rc @@ -0,0 +1,26 @@ +/* + * Copyright 2020 Austin English + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#define WINE_FILEDESCRIPTION_STR "Wine dpnhupnp" +#define WINE_FILENAME_STR "dpnhupnp.dll" +#define WINE_FILEVERSION 5,3,2600,5512 +#define WINE_FILEVERSION_STR "5.3.2600.5512" +#define WINE_PRODUCTVERSION 5,3,2600,5512 +#define WINE_PRODUCTVERSION_STR "5.3.2600.5512" + +#include "wine/wine_common_ver.rc" -- 2.30.2

1 0

[PATCH 1/2] dpnhupnp: add stub dll
by Alistair Leslie-Hughes 11 Jun '21

11 Jun '21

From: Austin English <austinenglish(a)gmail.com> Signed-off-by: Austin English <austinenglish(a)gmail.com> Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- configure.ac | 1 + dlls/dpnhupnp/Makefile.in | 6 ++++++ dlls/dpnhupnp/dpnhupnp.spec | 6 ++++++ dlls/dpnhupnp/version.rc | 26 ++++++++++++++++++++++++++ 4 files changed, 39 insertions(+) create mode 100644 dlls/dpnhupnp/Makefile.in create mode 100644 dlls/dpnhupnp/dpnhupnp.spec create mode 100644 dlls/dpnhupnp/version.rc diff --git a/configure.ac b/configure.ac index 431f4acef28..c07ad8114fc 100644 --- a/configure.ac +++ b/configure.ac @@ -3230,6 +3230,7 @@ WINE_CONFIG_MAKEFILE(dlls/dplay) WINE_CONFIG_MAKEFILE(dlls/dplayx) WINE_CONFIG_MAKEFILE(dlls/dplayx/tests) WINE_CONFIG_MAKEFILE(dlls/dpnaddr) +WINE_CONFIG_MAKEFILE(dlls/dpnhupnp) WINE_CONFIG_MAKEFILE(dlls/dpnet) WINE_CONFIG_MAKEFILE(dlls/dpnet/tests) WINE_CONFIG_MAKEFILE(dlls/dpnhpast) diff --git a/dlls/dpnhupnp/Makefile.in b/dlls/dpnhupnp/Makefile.in new file mode 100644 index 00000000000..566ce038f82 --- /dev/null +++ b/dlls/dpnhupnp/Makefile.in @@ -0,0 +1,6 @@ +MODULE = dpnhupnp.dll + +EXTRADLLFLAGS = -Wb,--prefer-native + + +RC_SRCS = version.rc diff --git a/dlls/dpnhupnp/dpnhupnp.spec b/dlls/dpnhupnp/dpnhupnp.spec new file mode 100644 index 00000000000..2a750e53675 --- /dev/null +++ b/dlls/dpnhupnp/dpnhupnp.spec @@ -0,0 +1,6 @@ +@ stub DirectPlayNATHelpCreate + +@ stdcall -private DllCanUnloadNow() +@ stub DllGetClassObject +@ stdcall -private DllRegisterServer() +@ stdcall -private DllUnregisterServer() diff --git a/dlls/dpnhupnp/version.rc b/dlls/dpnhupnp/version.rc new file mode 100644 index 00000000000..21633a49815 --- /dev/null +++ b/dlls/dpnhupnp/version.rc @@ -0,0 +1,26 @@ +/* + * Copyright 2020 Austin English + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#define WINE_FILEDESCRIPTION_STR "Wine dpnhupnp" +#define WINE_FILENAME_STR "dpnhupnp.dll" +#define WINE_FILEVERSION 5,3,2600,5512 +#define WINE_FILEVERSION_STR "5.3.2600.5512" +#define WINE_PRODUCTVERSION 5,3,2600,5512 +#define WINE_PRODUCTVERSION_STR "5.3.2600.5512" + +#include "wine/wine_common_ver.rc" -- 2.30.2

2 2

[PATCH resend] ntdll: Export ZwFilterToken().
by Kalen Alwardt 11 Jun '21

11 Jun '21

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=39142 Signed-off-by: Kalen Alwardt <kalenalwardt(a)gmail.com> --- dlls/ntdll/ntdll.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 6bd6579d432..8cba4fa164a 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -1224,7 +1224,7 @@ # @ stub ZwEnumerateSystemEnvironmentValuesEx @ stdcall -private -syscall ZwEnumerateValueKey(long long long ptr long ptr) NtEnumerateValueKey @ stub ZwExtendSection -# @ stub ZwFilterToken +@ stdcall -private -syscall ZwFilterToken(long long ptr ptr ptr ptr) NtFilterToken @ stdcall -private -syscall ZwFindAtom(ptr long ptr) NtFindAtom @ stdcall -private -syscall ZwFlushBuffersFile(long ptr) NtFlushBuffersFile @ stdcall -private -syscall ZwFlushInstructionCache(long ptr long) NtFlushInstructionCache -- 2.18.0.windows.1

2 1

[PATCH 1/2] wined3d: Implement wined3d_deferred_context_update_sub_resource().
by Zebediah Figura 11 Jun '21

11 Jun '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/wined3d/cs.c | 37 +++++++++++++++++++++++++++++++++---- 1 file changed, 33 insertions(+), 4 deletions(-) diff --git a/dlls/wined3d/cs.c b/dlls/wined3d/cs.c index 50a08334dab..e6f84134795 100644 --- a/dlls/wined3d/cs.c +++ b/dlls/wined3d/cs.c @@ -490,6 +490,7 @@ struct wined3d_cs_update_sub_resource unsigned int sub_resource_idx; struct wined3d_box box; struct wined3d_sub_resource_data data; + /* If data.data is NULL, the structure is followed by the data in memory. */ }; struct wined3d_cs_add_dirty_texture_region @@ -2597,6 +2598,7 @@ void wined3d_device_context_emit_blt_sub_resource(struct wined3d_device_context static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs *cs, const void *data) { const struct wined3d_cs_update_sub_resource *op = data; + const void *src_data = op->data.data ? op->data.data : (const BYTE *)(op + 1); struct wined3d_resource *resource = op->resource; const struct wined3d_box *box = &op->box; unsigned int width, height, depth, level; @@ -2617,7 +2619,7 @@ static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs *cs, const voi goto done; } - wined3d_buffer_upload_data(buffer, context, box, op->data.data); + wined3d_buffer_upload_data(buffer, context, box, src_data); wined3d_buffer_invalidate_location(buffer, ~WINED3D_LOCATION_BUFFER); goto done; } @@ -2630,7 +2632,7 @@ static void wined3d_cs_exec_update_sub_resource(struct wined3d_cs *cs, const voi depth = wined3d_texture_get_level_depth(texture, level); addr.buffer_object = 0; - addr.addr = op->data.data; + addr.addr = src_data; /* Only load the sub-resource for partial updates. */ if (!box->left && !box->top && !box->front @@ -3375,8 +3377,35 @@ static void wined3d_deferred_context_update_sub_resource(struct wined3d_device_c struct wined3d_resource *resource, unsigned int sub_resource_idx, const struct wined3d_box *box, const void *data, unsigned int row_pitch, unsigned int slice_pitch) { - FIXME("context %p, resource %p, sub_resource_idx %u, box %s, data %p, row_pitch %u, slice_pitch %u, stub!\n", - context, resource, sub_resource_idx, debug_box(box), data, row_pitch, slice_pitch); + struct wined3d_cs_update_sub_resource *op; + size_t data_size; + + if (resource->type == WINED3D_RTYPE_BUFFER) + { + data_size = box->right - box->left; + } + else + { + const struct wined3d_format *format = resource->format; + + data_size = (box->back - box->front - 1) * slice_pitch + + ((box->bottom - box->top - 1) / format->block_height) * row_pitch + + ((box->right - box->left + format->block_width - 1) / format->block_width) * format->block_byte_count; + } + + op = wined3d_device_context_require_space(context, sizeof(*op) + data_size, WINED3D_CS_QUEUE_DEFAULT); + op->opcode = WINED3D_CS_OP_UPDATE_SUB_RESOURCE; + op->resource = resource; + op->sub_resource_idx = sub_resource_idx; + op->box = *box; + op->data.row_pitch = row_pitch; + op->data.slice_pitch = slice_pitch; + op->data.data = NULL; + memcpy(op + 1, data, data_size); + + wined3d_device_context_acquire_resource(context, resource); + + wined3d_device_context_submit(context, WINED3D_CS_QUEUE_DEFAULT); } static void wined3d_deferred_context_issue_query(struct wined3d_device_context *context, -- 2.30.2

5 14

[PATCH 1/2] sechost: Reject string SIDs with too many characters.
by Esme Povirk 11 Jun '21

11 Jun '21

Signed-off-by: Esme Povirk <esme(a)codeweavers.com> --- dlls/advapi32/tests/security.c | 17 +++++++++- dlls/sechost/security.c | 58 ++++++++++++++++++++-------------- 2 files changed, 51 insertions(+), 24 deletions(-) diff --git a/dlls/advapi32/tests/security.c b/dlls/advapi32/tests/security.c index 3f1fffda273..9231c0243bf 100644 --- a/dlls/advapi32/tests/security.c +++ b/dlls/advapi32/tests/security.c @@ -338,6 +338,20 @@ static void test_ConvertStringSidToSid(void) "expected GetLastError() is ERROR_INVALID_SID, got %d\n", GetLastError() ); + r = ConvertStringSidToSidA( "WDandmorecharacters", &psid ); + ok( !r, + "expected failure with too many characters\n" ); + ok( GetLastError() == ERROR_INVALID_SID, + "expected GetLastError() is ERROR_INVALID_SID, got %d\n", + GetLastError() ); + + r = ConvertStringSidToSidA( "WD)", &psid ); + ok( !r, + "expected failure with too many characters\n" ); + ok( GetLastError() == ERROR_INVALID_SID, + "expected GetLastError() is ERROR_INVALID_SID, got %d\n", + GetLastError() ); + ok(ConvertStringSidToSidA("S-1-5-21-93476-23408-4576", &psid), "ConvertStringSidToSidA failed\n"); pisid = psid; ok(pisid->SubAuthorityCount == 4, "Invalid sub authority count - expected 4, got %d\n", pisid->SubAuthorityCount); @@ -4237,7 +4251,8 @@ static void test_ConvertStringSecurityDescriptor(void) { "", SDDL_REVISION_1, TRUE }, /* test ACE string SID */ { "D:(D;;GA;;;S-1-0-0)", SDDL_REVISION_1, TRUE }, - { "D:(D;;GA;;;Nonexistent account)", SDDL_REVISION_1, FALSE, ERROR_INVALID_ACL, ERROR_INVALID_SID } /* W2K */ + { "D:(D;;GA;;;WDANDSUCH)", SDDL_REVISION_1, FALSE, ERROR_INVALID_ACL }, + { "D:(D;;GA;;;Nonexistent account)", SDDL_REVISION_1, FALSE, ERROR_INVALID_ACL, ERROR_INVALID_SID }, /* W2K */ }; for (i = 0; i < ARRAY_SIZE(cssd); i++) diff --git a/dlls/sechost/security.c b/dlls/sechost/security.c index b6731b1fe1c..940561cce79 100644 --- a/dlls/sechost/security.c +++ b/dlls/sechost/security.c @@ -18,6 +18,7 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include <assert.h> #include <stdarg.h> #include "windef.h" #include "winbase.h" @@ -593,18 +594,22 @@ static BOOL get_computer_sid( PSID sid ) return TRUE; } -static DWORD get_sid_size( const WCHAR *string ) +static DWORD get_sid_size( const WCHAR *string, const WCHAR **end ) { if (string[0] == 'S' && string[1] == '-') /* S-R-I(-S)+ */ { int token_count = 0; - while (*string) + string++; + while (*string == '-' || iswdigit(*string)) { if (*string == '-') token_count++; string++; } + if (end) + *end = string; + if (token_count >= 3) return GetSidLengthRequired( token_count - 2 ); } @@ -612,6 +617,9 @@ static DWORD get_sid_size( const WCHAR *string ) { unsigned int i; + if (end) + *end = string + 2; + for (i = 0; i < ARRAY_SIZE(well_known_sids); i++) { if (!wcsncmp( well_known_sids[i].str, string, 2 )) @@ -632,12 +640,12 @@ static DWORD get_sid_size( const WCHAR *string ) return GetSidLengthRequired( 0 ); } -static BOOL parse_sid( const WCHAR *string, SID *pisid, DWORD *size ) +static BOOL parse_sid( const WCHAR *string, const WCHAR **end, SID *pisid, DWORD *size ) { while (*string == ' ') string++; - *size = get_sid_size( string ); + *size = get_sid_size( string, end ); if (!pisid) /* Simply compute the size */ return TRUE; @@ -647,7 +655,7 @@ static BOOL parse_sid( const WCHAR *string, SID *pisid, DWORD *size ) DWORD csubauth = ((*size - GetSidLengthRequired(0)) / sizeof(DWORD)); string += 2; /* Advance to Revision */ - pisid->Revision = wcstoul( string, NULL, 10 ); + pisid->Revision = wcstoul( string, (WCHAR**)&string, 10 ); if (pisid->Revision != SDDL_REVISION) { @@ -665,8 +673,6 @@ static BOOL parse_sid( const WCHAR *string, SID *pisid, DWORD *size ) pisid->SubAuthorityCount = csubauth; /* Advance to identifier authority */ - while (*string && *string != '-') - string++; if (*string == '-') string++; @@ -675,24 +681,20 @@ static BOOL parse_sid( const WCHAR *string, SID *pisid, DWORD *size ) */ pisid->IdentifierAuthority.Value[0] = 0; pisid->IdentifierAuthority.Value[1] = 0; - identAuth = wcstoul( string, NULL, 10 ); + identAuth = wcstoul( string, (WCHAR**)&string, 10 ); pisid->IdentifierAuthority.Value[5] = identAuth & 0xff; pisid->IdentifierAuthority.Value[4] = (identAuth & 0xff00) >> 8; pisid->IdentifierAuthority.Value[3] = (identAuth & 0xff0000) >> 16; pisid->IdentifierAuthority.Value[2] = (identAuth & 0xff000000) >> 24; /* Advance to first sub authority */ - while (*string && *string != '-') - string++; if (*string == '-') string++; - while (*string) + while (iswdigit(*string) || *string == '-') { - pisid->SubAuthority[i++] = wcstoul( string, NULL, 10 ); + pisid->SubAuthority[i++] = wcstoul( string, (WCHAR**)&string, 10 ); - while (*string && *string != '-') - string++; if (*string == '-') string++; } @@ -703,6 +705,9 @@ static BOOL parse_sid( const WCHAR *string, SID *pisid, DWORD *size ) return FALSE; } + if (end) + assert(*end == string); + return TRUE; } else /* String constant format - Only available in winxp and above */ @@ -746,6 +751,7 @@ static BOOL parse_sid( const WCHAR *string, SID *pisid, DWORD *size ) BOOL WINAPI DECLSPEC_HOTPATCH ConvertStringSidToSidW( const WCHAR *string, PSID *sid ) { DWORD size; + const WCHAR *string_end; TRACE("%s, %p\n", debugstr_w(string), sid); @@ -761,12 +767,18 @@ BOOL WINAPI DECLSPEC_HOTPATCH ConvertStringSidToSidW( const WCHAR *string, PSID return FALSE; } - if (!parse_sid( string, NULL, &size )) + if (!parse_sid( string, &string_end, NULL, &size )) return FALSE; + if (*string_end) + { + SetLastError(ERROR_INVALID_SID); + return FALSE; + } + *sid = LocalAlloc( 0, size ); - if (!parse_sid( string, *sid, &size )) + if (!parse_sid( string, NULL, *sid, &size )) { LocalFree( *sid ); return FALSE; @@ -996,11 +1008,11 @@ static BOOL parse_acl( const WCHAR *string, DWORD *flags, ACL *acl, DWORD *ret_s string++; /* Parse ACE account sid */ - if (parse_sid( string, ace ? (SID *)&ace->SidStart : NULL, &sidlen )) - { - while (*string && *string != ')') - string++; - } + if (!parse_sid( string, &string, ace ? (SID *)&ace->SidStart : NULL, &sidlen )) + goto err; + + while (*string == ' ') + string++; if (*string != ')') goto err; @@ -1095,7 +1107,7 @@ static BOOL parse_sd( const WCHAR *string, SECURITY_DESCRIPTOR_RELATIVE *sd, DWO { DWORD bytes; - if (!parse_sid( tok, (SID *)next, &bytes )) + if (!parse_sid( tok, NULL, (SID *)next, &bytes )) goto out; if (sd) @@ -1113,7 +1125,7 @@ static BOOL parse_sd( const WCHAR *string, SECURITY_DESCRIPTOR_RELATIVE *sd, DWO { DWORD bytes; - if (!parse_sid( tok, (SID *)next, &bytes )) + if (!parse_sid( tok, NULL, (SID *)next, &bytes )) goto out; if (sd) -- 2.25.1

1 1

[PATCH 1/7] hid: Implement HidP_SetUsageValueArray stub.
by Rémi Bernon 11 Jun '21

11 Jun '21

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/hid/hid.spec | 2 +- dlls/hid/hidp.c | 9 +++++++++ include/ddk/hidpi.h | 3 +++ 3 files changed, 13 insertions(+), 1 deletion(-) diff --git a/dlls/hid/hid.spec b/dlls/hid/hid.spec index 98508a456ce..edfdb004fd0 100644 --- a/dlls/hid/hid.spec +++ b/dlls/hid/hid.spec @@ -37,7 +37,7 @@ @ stub HidP_SetData @ stub HidP_SetScaledUsageValue @ stdcall HidP_SetUsageValue(long long long long long ptr ptr long) -@ stub HidP_SetUsageValueArray +@ stdcall HidP_SetUsageValueArray(long long long long ptr long ptr ptr long) @ stdcall HidP_SetUsages(long long long ptr ptr ptr ptr long) @ stdcall HidP_TranslateUsagesToI8042ScanCodes(ptr long long ptr ptr ptr) @ stub HidP_UnsetUsages diff --git a/dlls/hid/hidp.c b/dlls/hid/hidp.c index 2933c2ff7ef..e56731d599e 100644 --- a/dlls/hid/hidp.c +++ b/dlls/hid/hidp.c @@ -388,6 +388,15 @@ NTSTATUS WINAPI HidP_GetUsageValueArray(HIDP_REPORT_TYPE ReportType, USAGE Usage return rc; } +NTSTATUS WINAPI HidP_SetUsageValueArray( HIDP_REPORT_TYPE report_type, USAGE usage_page, USHORT collection, USAGE usage, char *value_buf, USHORT value_len, + PHIDP_PREPARSED_DATA preparsed_data, char *report_buf, ULONG report_len ) + +{ + FIXME( "report_type %d, usage_page %x, collection %d, usage %x, value_buf %p, value_len %u, preparsed_data %p, report_buf %p, report_len %u stub!\n", + report_type, usage_page, collection, usage, value_buf, value_len, preparsed_data, report_buf, report_len ); + + return HIDP_STATUS_NOT_IMPLEMENTED; +} NTSTATUS WINAPI HidP_GetUsages(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, PUSAGE UsageList, PULONG UsageLength, PHIDP_PREPARSED_DATA PreparsedData, diff --git a/include/ddk/hidpi.h b/include/ddk/hidpi.h index fb497f3282f..8c970673ec1 100644 --- a/include/ddk/hidpi.h +++ b/include/ddk/hidpi.h @@ -201,6 +201,9 @@ NTSTATUS WINAPI HidP_InitializeReportForID(HIDP_REPORT_TYPE ReportType, UCHAR Re ULONG WINAPI HidP_MaxUsageListLength(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, PHIDP_PREPARSED_DATA PreparsedData); NTSTATUS WINAPI HidP_GetScaledUsageValue(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, USAGE Usage, PLONG UsageValue, PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, ULONG ReportLength); NTSTATUS WINAPI HidP_SetUsageValue(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, USAGE Usage, ULONG UsageValue, PHIDP_PREPARSED_DATA PreparsedData, CHAR *Report, ULONG ReportLength); +NTSTATUS WINAPI HidP_SetUsageValueArray( HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, + USAGE Usage, PCHAR UsageValue, USHORT UsageValueByteLength, + PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, ULONG ReportLength ); NTSTATUS WINAPI HidP_SetUsages(HIDP_REPORT_TYPE ReportType, USAGE UsagePage, USHORT LinkCollection, PUSAGE UsageList, PULONG UsageLength, PHIDP_PREPARSED_DATA PreparsedData, PCHAR Report, ULONG ReportLength); -- 2.31.0

3 15

[PATCH 2/2] msvcrt: Import exp implementation from musl.
by Piotr Caban 11 Jun '21

11 Jun '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/math.c | 156 ++++++++++++++++++++++++++++++++++-------- dlls/msvcrt/unixlib.c | 9 --- dlls/msvcrt/unixlib.h | 1 - 3 files changed, 128 insertions(+), 38 deletions(-)

1 0

[PATCH 1/2] msvcrt: Import exp2 implementation from musl.
by Piotr Caban 11 Jun '21

11 Jun '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- configure.ac | 3 - dlls/msvcrt/math.c | 245 +++++++++++++++++++++++++++++++++++++++++- dlls/msvcrt/unixlib.c | 13 --- dlls/msvcrt/unixlib.h | 1 - 4 files changed, 242 insertions(+), 20 deletions(-)

1 0

[PATCH] wined3d: Fix typo in wined3d_texture_vk_prepare_texture().
by Jan Sikorski 11 Jun '21

11 Jun '21

Signed-off-by: Jan Sikorski <jsikorski(a)codeweavers.com> --- dlls/wined3d/texture.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index c77de1796c4..165d83eb035 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -5139,7 +5139,7 @@ BOOL wined3d_texture_vk_prepare_texture(struct wined3d_texture_vk *texture_vk, vk_usage |= VK_IMAGE_USAGE_STORAGE_BIT; texture_vk->layout = VK_IMAGE_LAYOUT_GENERAL; - if (wined3d_popcount(resource->bind_flags == 1)) + if (wined3d_popcount(resource->bind_flags) == 1) { switch (resource->bind_flags) { -- 2.29.2

2 1

[PATCH] d2d1: Reuse VS constant buffer object.
by Nikolay Sivov 11 Jun '21

11 Jun '21

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/d2d1_private.h | 22 ++- dlls/d2d1/device.c | 286 +++++++++++++++++---------------------- 2 files changed, 141 insertions(+), 167 deletions(-) diff --git a/dlls/d2d1/d2d1_private.h b/dlls/d2d1/d2d1_private.h index 779e6a0c359..81a46c8a7ce 100644 --- a/dlls/d2d1/d2d1_private.h +++ b/dlls/d2d1/d2d1_private.h @@ -121,6 +121,22 @@ struct d2d_ps_cb struct d2d_brush_cb opacity_brush; }; +struct d2d_vec4 +{ + float x, y, z, w; +}; + +struct d2d_vs_cb +{ + struct + { + float _11, _21, _31, pad0; + float _12, _22, _32, stroke_width; + } transform_geometry; + struct d2d_vec4 transform_rtx; + struct d2d_vec4 transform_rty; +}; + struct d2d_device_context_ops { HRESULT (*device_context_present)(IUnknown *outer_unknown); @@ -149,6 +165,7 @@ struct d2d_device_context struct d2d_bitmap *target; ID3D10StateBlock *stateblock; struct d2d_shape_resources shape_resources[D2D_SHAPE_TYPE_COUNT]; + ID3D10Buffer *vs_cb; ID3D10PixelShader *ps; ID3D10Buffer *ps_cb; ID3D10Buffer *ib; @@ -415,11 +432,6 @@ struct d2d_face UINT16 v[3]; }; -struct d2d_vec4 -{ - float x, y, z, w; -}; - struct d2d_outline_vertex { D2D1_POINT_2F position; diff --git a/dlls/d2d1/device.c b/dlls/d2d1/device.c index e3f01e7e7f1..2a0c094fb74 100644 --- a/dlls/d2d1/device.c +++ b/dlls/d2d1/device.c @@ -119,7 +119,7 @@ static void d2d_clip_stack_pop(struct d2d_clip_stack *stack) static void d2d_device_context_draw(struct d2d_device_context *render_target, enum d2d_shape_type shape_type, ID3D10Buffer *ib, unsigned int index_count, ID3D10Buffer *vb, unsigned int vb_stride, - ID3D10Buffer *vs_cb, struct d2d_brush *brush, struct d2d_brush *opacity_brush) + struct d2d_brush *brush, struct d2d_brush *opacity_brush) { struct d2d_shape_resources *shape_resources = &render_target->shape_resources[shape_type]; ID3D10Device *device = render_target->d3d_device; @@ -148,7 +148,7 @@ static void d2d_device_context_draw(struct d2d_device_context *render_target, en ID3D10Device_IASetIndexBuffer(device, ib, DXGI_FORMAT_R16_UINT, 0); offset = 0; ID3D10Device_IASetVertexBuffers(device, 0, 1, &vb, &vb_stride, &offset); - ID3D10Device_VSSetConstantBuffers(device, 0, 1, &vs_cb); + ID3D10Device_VSSetConstantBuffers(device, 0, 1, &render_target->vs_cb); ID3D10Device_VSSetShader(device, shape_resources->vs); ID3D10Device_PSSetConstantBuffers(device, 0, 1, &render_target->ps_cb); ID3D10Device_PSSetShader(device, render_target->ps); @@ -267,6 +267,7 @@ static ULONG STDMETHODCALLTYPE d2d_device_context_inner_Release(IUnknown *iface) ID3D10Buffer_Release(context->ib); ID3D10Buffer_Release(context->ps_cb); ID3D10PixelShader_Release(context->ps); + ID3D10Buffer_Release(context->vs_cb); for (i = 0; i < D2D_SHAPE_TYPE_COUNT; ++i) { ID3D10VertexShader_Release(context->shape_resources[i].vs); @@ -733,72 +734,75 @@ static HRESULT d2d_device_context_update_ps_cb(struct d2d_device_context *contex return hr; } -static void d2d_device_context_draw_geometry(struct d2d_device_context *render_target, - const struct d2d_geometry *geometry, struct d2d_brush *brush, float stroke_width) +static HRESULT d2d_device_context_update_vs_cb(struct d2d_device_context *context, + const D2D_MATRIX_3X2_F *geometry_transform, float stroke_width) { - D3D10_SUBRESOURCE_DATA buffer_data; - D3D10_BUFFER_DESC buffer_desc; - ID3D10Buffer *ib, *vb, *vs_cb; const D2D1_MATRIX_3X2_F *w; + struct d2d_vs_cb *cb_data; float tmp_x, tmp_y; HRESULT hr; - struct + + if (FAILED(hr = ID3D10Buffer_Map(context->vs_cb, D3D10_MAP_WRITE_DISCARD, 0, (void **)&cb_data))) { - struct - { - float _11, _21, _31, pad0; - float _12, _22, _32, stroke_width; - } transform_geometry; - struct d2d_vec4 transform_rtx; - struct d2d_vec4 transform_rty; - } vs_cb_data; - - vs_cb_data.transform_geometry._11 = geometry->transform._11; - vs_cb_data.transform_geometry._21 = geometry->transform._21; - vs_cb_data.transform_geometry._31 = geometry->transform._31; - vs_cb_data.transform_geometry.pad0 = 0.0f; - vs_cb_data.transform_geometry._12 = geometry->transform._12; - vs_cb_data.transform_geometry._22 = geometry->transform._22; - vs_cb_data.transform_geometry._32 = geometry->transform._32; - vs_cb_data.transform_geometry.stroke_width = stroke_width; - - w = &render_target->drawing_state.transform; - - tmp_x = render_target->desc.dpiX / 96.0f; - vs_cb_data.transform_rtx.x = w->_11 * tmp_x; - vs_cb_data.transform_rtx.y = w->_21 * tmp_x; - vs_cb_data.transform_rtx.z = w->_31 * tmp_x; - vs_cb_data.transform_rtx.w = 2.0f / render_target->pixel_size.width; - - tmp_y = render_target->desc.dpiY / 96.0f; - vs_cb_data.transform_rty.x = w->_12 * tmp_y; - vs_cb_data.transform_rty.y = w->_22 * tmp_y; - vs_cb_data.transform_rty.z = w->_32 * tmp_y; - vs_cb_data.transform_rty.w = -2.0f / render_target->pixel_size.height; - - buffer_desc.ByteWidth = sizeof(vs_cb_data); - buffer_desc.Usage = D3D10_USAGE_DEFAULT; - buffer_desc.BindFlags = D3D10_BIND_CONSTANT_BUFFER; - buffer_desc.CPUAccessFlags = 0; - buffer_desc.MiscFlags = 0; + WARN("Failed to map constant buffer, hr %#x.\n", hr); + return hr; + } - buffer_data.pSysMem = &vs_cb_data; - buffer_data.SysMemPitch = 0; - buffer_data.SysMemSlicePitch = 0; + cb_data->transform_geometry._11 = geometry_transform->_11; + cb_data->transform_geometry._21 = geometry_transform->_21; + cb_data->transform_geometry._31 = geometry_transform->_31; + cb_data->transform_geometry.pad0 = 0.0f; + cb_data->transform_geometry._12 = geometry_transform->_12; + cb_data->transform_geometry._22 = geometry_transform->_22; + cb_data->transform_geometry._32 = geometry_transform->_32; + cb_data->transform_geometry.stroke_width = stroke_width; + + w = &context->drawing_state.transform; + + tmp_x = context->desc.dpiX / 96.0f; + cb_data->transform_rtx.x = w->_11 * tmp_x; + cb_data->transform_rtx.y = w->_21 * tmp_x; + cb_data->transform_rtx.z = w->_31 * tmp_x; + cb_data->transform_rtx.w = 2.0f / context->pixel_size.width; + + tmp_y = context->desc.dpiY / 96.0f; + cb_data->transform_rty.x = w->_12 * tmp_y; + cb_data->transform_rty.y = w->_22 * tmp_y; + cb_data->transform_rty.z = w->_32 * tmp_y; + cb_data->transform_rty.w = -2.0f / context->pixel_size.height; + + ID3D10Buffer_Unmap(context->vs_cb); + + return S_OK; +} + +static void d2d_device_context_draw_geometry(struct d2d_device_context *render_target, + const struct d2d_geometry *geometry, struct d2d_brush *brush, float stroke_width) +{ + D3D10_SUBRESOURCE_DATA buffer_data; + D3D10_BUFFER_DESC buffer_desc; + ID3D10Buffer *ib, *vb; + HRESULT hr; - if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vs_cb))) + if (FAILED(hr = d2d_device_context_update_vs_cb(render_target, &geometry->transform, stroke_width))) { - WARN("Failed to create constant buffer, hr %#x.\n", hr); + WARN("Failed to update vs constant buffer, hr %#x.\n", hr); return; } if (FAILED(hr = d2d_device_context_update_ps_cb(render_target, brush, NULL, TRUE, FALSE))) { - WARN("Failed to update constant buffer, hr %#x.\n", hr); - ID3D10Buffer_Release(vs_cb); + WARN("Failed to update ps constant buffer, hr %#x.\n", hr); return; } + buffer_desc.Usage = D3D10_USAGE_DEFAULT; + buffer_desc.CPUAccessFlags = 0; + buffer_desc.MiscFlags = 0; + + buffer_data.SysMemPitch = 0; + buffer_data.SysMemSlicePitch = 0; + if (geometry->outline.face_count) { buffer_desc.ByteWidth = geometry->outline.face_count * sizeof(*geometry->outline.faces); @@ -808,7 +812,7 @@ static void d2d_device_context_draw_geometry(struct d2d_device_context *render_t if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib))) { WARN("Failed to create index buffer, hr %#x.\n", hr); - goto done; + return; } buffer_desc.ByteWidth = geometry->outline.vertex_count * sizeof(*geometry->outline.vertices); @@ -819,11 +823,11 @@ static void d2d_device_context_draw_geometry(struct d2d_device_context *render_t { ERR("Failed to create vertex buffer, hr %#x.\n", hr); ID3D10Buffer_Release(ib); - goto done; + return; } d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_OUTLINE, ib, 3 * geometry->outline.face_count, vb, - sizeof(*geometry->outline.vertices), vs_cb, brush, NULL); + sizeof(*geometry->outline.vertices), brush, NULL); ID3D10Buffer_Release(vb); ID3D10Buffer_Release(ib); @@ -838,7 +842,7 @@ static void d2d_device_context_draw_geometry(struct d2d_device_context *render_t if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib))) { WARN("Failed to create beziers index buffer, hr %#x.\n", hr); - goto done; + return; } buffer_desc.ByteWidth = geometry->outline.bezier_count * sizeof(*geometry->outline.beziers); @@ -849,12 +853,12 @@ static void d2d_device_context_draw_geometry(struct d2d_device_context *render_t { ERR("Failed to create beziers vertex buffer, hr %#x.\n", hr); ID3D10Buffer_Release(ib); - goto done; + return; } d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_BEZIER_OUTLINE, ib, 3 * geometry->outline.bezier_face_count, vb, - sizeof(*geometry->outline.beziers), vs_cb, brush, NULL); + sizeof(*geometry->outline.beziers), brush, NULL); ID3D10Buffer_Release(vb); ID3D10Buffer_Release(ib); @@ -869,7 +873,7 @@ static void d2d_device_context_draw_geometry(struct d2d_device_context *render_t if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib))) { WARN("Failed to create arcs index buffer, hr %#x.\n", hr); - goto done; + return; } buffer_desc.ByteWidth = geometry->outline.arc_count * sizeof(*geometry->outline.arcs); @@ -880,20 +884,17 @@ static void d2d_device_context_draw_geometry(struct d2d_device_context *render_t { ERR("Failed to create arcs vertex buffer, hr %#x.\n", hr); ID3D10Buffer_Release(ib); - goto done; + return; } if (SUCCEEDED(d2d_device_context_update_ps_cb(render_target, brush, NULL, TRUE, TRUE))) d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_ARC_OUTLINE, ib, 3 * geometry->outline.arc_face_count, vb, - sizeof(*geometry->outline.arcs), vs_cb, brush, NULL); + sizeof(*geometry->outline.arcs), brush, NULL); ID3D10Buffer_Release(vb); ID3D10Buffer_Release(ib); } - -done: - ID3D10Buffer_Release(vs_cb); } static void STDMETHODCALLTYPE d2d_device_context_DrawGeometry(ID2D1DeviceContext *iface, @@ -917,64 +918,25 @@ static void d2d_device_context_fill_geometry(struct d2d_device_context *render_t { D3D10_SUBRESOURCE_DATA buffer_data; D3D10_BUFFER_DESC buffer_desc; - ID3D10Buffer *ib, *vb, *vs_cb; - D2D1_MATRIX_3X2_F *w; - float tmp_x, tmp_y; + ID3D10Buffer *ib, *vb; HRESULT hr; - struct - { - struct - { - float _11, _21, _31, pad0; - float _12, _22, _32, pad1; - } transform_geometry; - struct d2d_vec4 transform_rtx; - struct d2d_vec4 transform_rty; - } vs_cb_data; - - vs_cb_data.transform_geometry._11 = geometry->transform._11; - vs_cb_data.transform_geometry._21 = geometry->transform._21; - vs_cb_data.transform_geometry._31 = geometry->transform._31; - vs_cb_data.transform_geometry.pad0 = 0.0f; - vs_cb_data.transform_geometry._12 = geometry->transform._12; - vs_cb_data.transform_geometry._22 = geometry->transform._22; - vs_cb_data.transform_geometry._32 = geometry->transform._32; - vs_cb_data.transform_geometry.pad1 = 0.0f; - - w = &render_target->drawing_state.transform; - - tmp_x = render_target->desc.dpiX / 96.0f; - vs_cb_data.transform_rtx.x = w->_11 * tmp_x; - vs_cb_data.transform_rtx.y = w->_21 * tmp_x; - vs_cb_data.transform_rtx.z = w->_31 * tmp_x; - vs_cb_data.transform_rtx.w = 2.0f / render_target->pixel_size.width; - - tmp_y = render_target->desc.dpiY / 96.0f; - vs_cb_data.transform_rty.x = w->_12 * tmp_y; - vs_cb_data.transform_rty.y = w->_22 * tmp_y; - vs_cb_data.transform_rty.z = w->_32 * tmp_y; - vs_cb_data.transform_rty.w = -2.0f / render_target->pixel_size.height; - - buffer_desc.ByteWidth = sizeof(vs_cb_data); + buffer_desc.Usage = D3D10_USAGE_DEFAULT; - buffer_desc.BindFlags = D3D10_BIND_CONSTANT_BUFFER; buffer_desc.CPUAccessFlags = 0; buffer_desc.MiscFlags = 0; - buffer_data.pSysMem = &vs_cb_data; buffer_data.SysMemPitch = 0; buffer_data.SysMemSlicePitch = 0; - if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vs_cb))) + if (FAILED(hr = d2d_device_context_update_vs_cb(render_target, &geometry->transform, 0.0f))) { - WARN("Failed to create constant buffer, hr %#x.\n", hr); + WARN("Failed to update vs constant buffer, hr %#x.\n", hr); return; } if (FAILED(hr = d2d_device_context_update_ps_cb(render_target, brush, opacity_brush, FALSE, FALSE))) { WARN("Failed to update ps constant buffer, hr %#x.\n", hr); - ID3D10Buffer_Release(vs_cb); return; } @@ -987,7 +949,7 @@ static void d2d_device_context_fill_geometry(struct d2d_device_context *render_t if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &ib))) { WARN("Failed to create index buffer, hr %#x.\n", hr); - goto done; + return; } buffer_desc.ByteWidth = geometry->fill.vertex_count * sizeof(*geometry->fill.vertices); @@ -998,11 +960,11 @@ static void d2d_device_context_fill_geometry(struct d2d_device_context *render_t { ERR("Failed to create vertex buffer, hr %#x.\n", hr); ID3D10Buffer_Release(ib); - goto done; + return; } d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_TRIANGLE, ib, 3 * geometry->fill.face_count, vb, - sizeof(*geometry->fill.vertices), vs_cb, brush, opacity_brush); + sizeof(*geometry->fill.vertices), brush, opacity_brush); ID3D10Buffer_Release(vb); ID3D10Buffer_Release(ib); @@ -1017,11 +979,11 @@ static void d2d_device_context_fill_geometry(struct d2d_device_context *render_t if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb))) { ERR("Failed to create beziers vertex buffer, hr %#x.\n", hr); - goto done; + return; } d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_CURVE, NULL, geometry->fill.bezier_vertex_count, vb, - sizeof(*geometry->fill.bezier_vertices), vs_cb, brush, opacity_brush); + sizeof(*geometry->fill.bezier_vertices), brush, opacity_brush); ID3D10Buffer_Release(vb); } @@ -1035,18 +997,15 @@ static void d2d_device_context_fill_geometry(struct d2d_device_context *render_t if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vb))) { ERR("Failed to create arc vertex buffer, hr %#x.\n", hr); - goto done; + return; } if (SUCCEEDED(d2d_device_context_update_ps_cb(render_target, brush, opacity_brush, FALSE, TRUE))) d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_CURVE, NULL, geometry->fill.arc_vertex_count, vb, - sizeof(*geometry->fill.arc_vertices), vs_cb, brush, opacity_brush); + sizeof(*geometry->fill.arc_vertices), brush, opacity_brush); ID3D10Buffer_Release(vb); } - -done: - ID3D10Buffer_Release(vs_cb); } static void STDMETHODCALLTYPE d2d_device_context_FillGeometry(ID2D1DeviceContext *iface, @@ -1642,61 +1601,51 @@ static void STDMETHODCALLTYPE d2d_device_context_PopAxisAlignedClip(ID2D1DeviceC static void STDMETHODCALLTYPE d2d_device_context_Clear(ID2D1DeviceContext *iface, const D2D1_COLOR_F *colour) { struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); - D3D10_SUBRESOURCE_DATA buffer_data; - D3D10_BUFFER_DESC buffer_desc; - ID3D10Buffer *vs_cb; + struct d2d_ps_cb *ps_cb_data; + struct d2d_vs_cb *vs_cb_data; D2D1_COLOR_F *c; HRESULT hr; - static const struct - { - struct - { - float _11, _21, _31, pad0; - float _12, _22, _32, pad1; - } transform_geometry; - struct d2d_vec4 transform_rtx; - struct d2d_vec4 transform_rty; - } - vs_cb_data = - { - {1.0f, 0.0f, 0.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 0.0f}, - {1.0f, 0.0f, 1.0f, 1.0f}, - {0.0f, 1.0f, 1.0f, -1.0f}, - }; - struct d2d_ps_cb *cb_data; - TRACE("iface %p, colour %p.\n", iface, colour); - buffer_desc.ByteWidth = sizeof(vs_cb_data); - buffer_desc.Usage = D3D10_USAGE_DEFAULT; - buffer_desc.BindFlags = D3D10_BIND_CONSTANT_BUFFER; - buffer_desc.CPUAccessFlags = 0; - buffer_desc.MiscFlags = 0; - - buffer_data.pSysMem = &vs_cb_data; - buffer_data.SysMemPitch = 0; - buffer_data.SysMemSlicePitch = 0; - - if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->d3d_device, &buffer_desc, &buffer_data, &vs_cb))) + if (FAILED(hr = ID3D10Buffer_Map(render_target->vs_cb, D3D10_MAP_WRITE_DISCARD, + 0, (void **)&vs_cb_data))) { - WARN("Failed to create constant buffer, hr %#x.\n", hr); + WARN("Failed to map vs constant buffer, hr %#x.\n", hr); return; } - if (FAILED(hr = ID3D10Buffer_Map(render_target->ps_cb, D3D10_MAP_WRITE_DISCARD, 0, (void **)&cb_data))) + vs_cb_data->transform_geometry._11 = 1.0f; + vs_cb_data->transform_geometry._21 = 0.0f; + vs_cb_data->transform_geometry._31 = 0.0f; + vs_cb_data->transform_geometry.pad0 = 0.0f; + vs_cb_data->transform_geometry._12 = 0.0f; + vs_cb_data->transform_geometry._22 = 1.0f; + vs_cb_data->transform_geometry._32 = 0.0f; + vs_cb_data->transform_geometry.stroke_width = 0.0f; + vs_cb_data->transform_rtx.x = 1.0f; + vs_cb_data->transform_rtx.y = 0.0f; + vs_cb_data->transform_rtx.z = 1.0f; + vs_cb_data->transform_rtx.w = 1.0f; + vs_cb_data->transform_rty.x = 0.0f; + vs_cb_data->transform_rty.y = 1.0f; + vs_cb_data->transform_rty.z = 1.0f; + vs_cb_data->transform_rty.w = -1.0f; + + ID3D10Buffer_Unmap(render_target->vs_cb); + + if (FAILED(hr = ID3D10Buffer_Map(render_target->ps_cb, D3D10_MAP_WRITE_DISCARD, + 0, (void **)&ps_cb_data))) { - WARN("Failed to map constant buffer, hr %#x.\n", hr); - ID3D10Buffer_Release(vs_cb); + WARN("Failed to map ps constant buffer, hr %#x.\n", hr); return; } - memset(cb_data, 0, sizeof(*cb_data)); - cb_data->colour_brush.type = D2D_BRUSH_TYPE_SOLID; - cb_data->colour_brush.opacity = 1.0f; - cb_data->opacity_brush.type = D2D_BRUSH_TYPE_COUNT; - c = &cb_data->colour_brush.u.solid.colour; + memset(ps_cb_data, 0, sizeof(*ps_cb_data)); + ps_cb_data->colour_brush.type = D2D_BRUSH_TYPE_SOLID; + ps_cb_data->colour_brush.opacity = 1.0f; + ps_cb_data->opacity_brush.type = D2D_BRUSH_TYPE_COUNT; + c = &ps_cb_data->colour_brush.u.solid.colour; if (colour) *c = *colour; if (render_target->desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_IGNORE) @@ -1708,9 +1657,7 @@ static void STDMETHODCALLTYPE d2d_device_context_Clear(ID2D1DeviceContext *iface ID3D10Buffer_Unmap(render_target->ps_cb); d2d_device_context_draw(render_target, D2D_SHAPE_TYPE_TRIANGLE, render_target->ib, 6, - render_target->vb, render_target->vb_stride, vs_cb, NULL, NULL); - - ID3D10Buffer_Release(vs_cb); + render_target->vb, render_target->vb_stride, NULL, NULL); } static void STDMETHODCALLTYPE d2d_device_context_BeginDraw(ID2D1DeviceContext *iface) @@ -3935,6 +3882,19 @@ static HRESULT d2d_device_context_init(struct d2d_device_context *render_target, } + buffer_desc.ByteWidth = sizeof(struct d2d_vs_cb); + buffer_desc.Usage = D3D10_USAGE_DYNAMIC; + buffer_desc.BindFlags = D3D10_BIND_CONSTANT_BUFFER; + buffer_desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE; + buffer_desc.MiscFlags = 0; + + if (FAILED(hr = ID3D10Device_CreateBuffer(render_target->d3d_device, &buffer_desc, NULL, + &render_target->vs_cb))) + { + WARN("Failed to create constant buffer, hr %#x.\n", hr); + goto err; + } + if (FAILED(hr = ID3D10Device_CreatePixelShader(render_target->d3d_device, ps_code, sizeof(ps_code), &render_target->ps))) { @@ -4042,6 +4002,8 @@ err: ID3D10Buffer_Release(render_target->ps_cb); if (render_target->ps) ID3D10PixelShader_Release(render_target->ps); + if (render_target->vs_cb) + ID3D10Buffer_Release(render_target->vs_cb); for (i = 0; i < D2D_SHAPE_TYPE_COUNT; ++i) { if (render_target->shape_resources[i].vs) -- 2.30.2

2 1

[PATCH 1/2] winegstreamer: Implement pausing the media source.
by Giovanni Mascellani 11 Jun '21

11 Jun '21

Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> --- dlls/winegstreamer/media_source.c | 95 +++++++++++++++++++++++++++---- 1 file changed, 85 insertions(+), 10 deletions(-) diff --git a/dlls/winegstreamer/media_source.c b/dlls/winegstreamer/media_source.c index 3c87bbb2146..496aab545e7 100644 --- a/dlls/winegstreamer/media_source.c +++ b/dlls/winegstreamer/media_source.c @@ -27,6 +27,12 @@ WINE_DEFAULT_DEBUG_CHANNEL(mfplat); +struct pending_sample +{ + struct list entry; + IMFSample *sample; +}; + struct media_stream { IMFMediaStream IMFMediaStream_iface; @@ -34,6 +40,7 @@ struct media_stream struct media_source *parent_source; IMFMediaEventQueue *event_queue; IMFStreamDescriptor *descriptor; + struct list pending_samples; struct wg_parser_stream *wg_stream; @@ -50,6 +57,7 @@ struct media_stream enum source_async_op { SOURCE_ASYNC_START, + SOURCE_ASYNC_PAUSE, SOURCE_ASYNC_STOP, SOURCE_ASYNC_REQUEST_SAMPLE, }; @@ -96,6 +104,7 @@ struct media_source { SOURCE_OPENING, SOURCE_STOPPED, + SOURCE_PAUSED, SOURCE_RUNNING, SOURCE_SHUTDOWN, } state; @@ -257,6 +266,23 @@ static IMFStreamDescriptor *stream_descriptor_from_id(IMFPresentationDescriptor return NULL; } +static void flush_pending_queue(struct media_stream *stream, BOOL send_events) +{ + struct pending_sample *pending, *pending2; + + LIST_FOR_EACH_ENTRY_SAFE(pending, pending2, &stream->pending_samples, struct pending_sample, entry) + { + if (send_events) + { + IMFMediaEventQueue_QueueEventParamUnk(stream->event_queue, MEMediaSample, + &GUID_NULL, S_OK, (IUnknown *)pending->sample); + } + IMFSample_Release(pending->sample); + list_remove(&pending->entry); + free(pending); + } +} + static void start_pipeline(struct media_source *source, struct source_async_command *command) { PROPVARIANT *position = &command->u.start.position; @@ -269,7 +295,8 @@ static void start_pipeline(struct media_source *source, struct source_async_comm position->vt = VT_I8; position->hVal.QuadPart = 0; } - source->start_time = position->hVal.QuadPart; + if (position->vt != VT_EMPTY) + source->start_time = position->hVal.QuadPart; for (i = 0; i < source->stream_count; i++) { @@ -318,6 +345,8 @@ static void start_pipeline(struct media_source *source, struct source_async_comm IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, seek_message ? MEStreamSeeked : MEStreamStarted, &GUID_NULL, S_OK, position); + + flush_pending_queue(stream, TRUE); } } @@ -327,11 +356,30 @@ static void start_pipeline(struct media_source *source, struct source_async_comm source->state = SOURCE_RUNNING; - unix_funcs->wg_parser_stream_seek(source->streams[0]->wg_stream, 1.0, - position->hVal.QuadPart, 0, AM_SEEKING_AbsolutePositioning, AM_SEEKING_NoPositioning); + if (position->vt != VT_EMPTY) + unix_funcs->wg_parser_stream_seek(source->streams[0]->wg_stream, 1.0, + position->hVal.QuadPart, 0, AM_SEEKING_AbsolutePositioning, AM_SEEKING_NoPositioning); unix_funcs->wg_parser_end_flush(source->wg_parser); } +static void pause_pipeline(struct media_source *source) +{ + unsigned int i; + + for (i = 0; i < source->stream_count; i++) + { + struct media_stream *stream = source->streams[i]; + if (stream->state != STREAM_INACTIVE) + { + IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamPaused, &GUID_NULL, S_OK, NULL); + } + } + + IMFMediaEventQueue_QueueEventParamVar(source->event_queue, MESourcePaused, &GUID_NULL, S_OK, NULL); + + source->state = SOURCE_PAUSED; +} + static void stop_pipeline(struct media_source *source) { unsigned int i; @@ -343,6 +391,7 @@ static void stop_pipeline(struct media_source *source) struct media_stream *stream = source->streams[i]; if (stream->state != STREAM_INACTIVE) { + flush_pending_queue(stream, FALSE); IMFMediaEventQueue_QueueEventParamVar(stream->event_queue, MEStreamStopped, &GUID_NULL, S_OK, NULL); unix_funcs->wg_parser_stream_disable(stream->wg_stream); } @@ -437,12 +486,26 @@ static void send_buffer(struct media_stream *stream, const struct wg_parser_even if (token) IMFSample_SetUnknown(sample, &MFSampleExtension_Token, token); - IMFMediaEventQueue_QueueEventParamUnk(stream->event_queue, MEMediaSample, - &GUID_NULL, S_OK, (IUnknown *)sample); + if (stream->parent_source->state == SOURCE_PAUSED) + { + struct pending_sample *pending = malloc(sizeof(*pending)); + if (!pending) + { + ERR("Cannot allocate pending sample\n"); + goto out; + } + pending->sample = sample; + sample = NULL; + list_add_tail(&stream->pending_samples, &pending->entry); + } + else + IMFMediaEventQueue_QueueEventParamUnk(stream->event_queue, MEMediaSample, + &GUID_NULL, S_OK, (IUnknown *)sample); out: IMFMediaBuffer_Release(buffer); - IMFSample_Release(sample); + if (sample) + IMFSample_Release(sample); } static void wait_on_sample(struct media_stream *stream, IUnknown *token) @@ -501,6 +564,9 @@ static HRESULT WINAPI source_async_commands_Invoke(IMFAsyncCallback *iface, IMFA case SOURCE_ASYNC_START: start_pipeline(source, command); break; + case SOURCE_ASYNC_PAUSE: + pause_pipeline(source); + break; case SOURCE_ASYNC_STOP: stop_pipeline(source); break; @@ -597,6 +663,7 @@ static ULONG WINAPI media_stream_Release(IMFMediaStream *iface) { if (stream->event_queue) IMFMediaEventQueue_Release(stream->event_queue); + flush_pending_queue(stream, FALSE); free(stream); } @@ -699,7 +766,6 @@ static HRESULT WINAPI media_stream_RequestSample(IMFMediaStream *iface, IUnknown IUnknown_AddRef(token); command->u.request_sample.token = token; - /* Once pause support is added, this will need to put into a stream queue, and synchronization will need to be added*/ hr = MFPutWorkItem(stream->parent_source->async_commands_queue, &stream->parent_source->async_commands_callback, &command->IUnknown_iface); } @@ -738,6 +804,7 @@ static HRESULT new_media_stream(struct media_source *source, object->state = STREAM_INACTIVE; object->eos = FALSE; object->wg_stream = wg_stream; + list_init(&object->pending_samples); if (FAILED(hr = MFCreateEventQueue(&object->event_queue))) goto fail; @@ -1123,7 +1190,7 @@ static HRESULT WINAPI media_source_GetCharacteristics(IMFMediaSource *iface, DWO if (source->state == SOURCE_SHUTDOWN) return MF_E_SHUTDOWN; - *characteristics = MFMEDIASOURCE_CAN_SEEK; + *characteristics = MFMEDIASOURCE_CAN_SEEK | MFMEDIASOURCE_CAN_PAUSE; return S_OK; } @@ -1187,13 +1254,21 @@ static HRESULT WINAPI media_source_Stop(IMFMediaSource *iface) static HRESULT WINAPI media_source_Pause(IMFMediaSource *iface) { struct media_source *source = impl_from_IMFMediaSource(iface); + struct source_async_command *command; + HRESULT hr; - FIXME("(%p): stub\n", source); + TRACE("(%p)\n", source); if (source->state == SOURCE_SHUTDOWN) return MF_E_SHUTDOWN; - return E_NOTIMPL; + if (source->state != SOURCE_RUNNING) + return MF_E_INVALID_STATE_TRANSITION; + + if (SUCCEEDED(hr = source_create_async_op(SOURCE_ASYNC_PAUSE, &command))) + hr = MFPutWorkItem(source->async_commands_queue, &source->async_commands_callback, &command->IUnknown_iface); + + return hr; } static HRESULT WINAPI media_source_Shutdown(IMFMediaSource *iface) -- 2.32.0

4 17

[PATCH] secur32: Translate errors from push/pull callbacks.
by Hans Leidekker 11 Jun '21

11 Jun '21

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51192 Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/secur32/schannel.c | 12 +++++------- dlls/secur32/schannel_gnutls.c | 19 +++++++++++++++---- dlls/secur32/schannel_macosx.c | 4 ++-- 3 files changed, 22 insertions(+), 13 deletions(-) diff --git a/dlls/secur32/schannel.c b/dlls/secur32/schannel.c index 50a1c848c0e..9c7e98b32a4 100644 --- a/dlls/secur32/schannel.c +++ b/dlls/secur32/schannel.c @@ -759,9 +759,8 @@ static char * CDECL schan_get_buffer(const struct schan_transport *t, struct sch * *buff_len > 0 indicates that some data was read. May be less than * what was requested, in which case the caller should call again if/ * when they want more. - * EAGAIN when no data could be read without blocking + * -1 when no data could be read without blocking * another errno-style error value on failure - * */ static int CDECL schan_pull(struct schan_transport *t, void *buff, size_t *buff_len) { @@ -774,7 +773,7 @@ static int CDECL schan_pull(struct schan_transport *t, void *buff, size_t *buff_ b = schan_get_buffer(t, &t->in, &local_len); if (!b) - return EAGAIN; + return -1; memcpy(buff, b, local_len); t->in.offset += local_len; @@ -797,10 +796,9 @@ static int CDECL schan_pull(struct schan_transport *t, void *buff, size_t *buff_ * 0 on success * *buff_len will be > 0 indicating how much data was written. May be less * than what was requested, in which case the caller should call again - if/when they want to write more. - * EAGAIN when no data could be written without blocking + * if/when they want to write more. + * -1 when no data could be written without blocking * another errno-style error value on failure - * */ static int CDECL schan_push(struct schan_transport *t, const void *buff, size_t *buff_len) { @@ -813,7 +811,7 @@ static int CDECL schan_push(struct schan_transport *t, const void *buff, size_t b = schan_get_buffer(t, &t->out, &local_len); if (!b) - return EAGAIN; + return -1; memcpy(b, buff, local_len); t->out.offset += local_len; diff --git a/dlls/secur32/schannel_gnutls.c b/dlls/secur32/schannel_gnutls.c index 76ab230137d..93868d10b3b 100644 --- a/dlls/secur32/schannel_gnutls.c +++ b/dlls/secur32/schannel_gnutls.c @@ -28,6 +28,7 @@ #include <stdarg.h> #include <stdio.h> +#include <errno.h> #ifdef SONAME_LIBGNUTLS #include <gnutls/gnutls.h> #include <gnutls/crypto.h> @@ -204,9 +205,14 @@ static ssize_t pull_adapter(gnutls_transport_ptr_t transport, void *buff, size_t gnutls_session_t s = (gnutls_session_t)callbacks->get_session_for_transport(t); int ret = callbacks->pull(transport, buff, &buff_len); - if (ret) + if (ret == -1) { - pgnutls_transport_set_errno(s, ret); + pgnutls_transport_set_errno(s, EAGAIN); + return -1; + } + if (ret < 0) + { + FIXME("unhandled error from pull callback %d\n", ret); return -1; } @@ -219,9 +225,14 @@ static ssize_t push_adapter(gnutls_transport_ptr_t transport, const void *buff, gnutls_session_t s = (gnutls_session_t)callbacks->get_session_for_transport(t); int ret = callbacks->push(transport, buff, &buff_len); - if (ret) + if (ret == -1) + { + pgnutls_transport_set_errno(s, EAGAIN); + return -1; + } + if (ret < 0) { - pgnutls_transport_set_errno(s, ret); + FIXME("unhandled error from push callback %d\n", ret); return -1; } diff --git a/dlls/secur32/schannel_macosx.c b/dlls/secur32/schannel_macosx.c index daf9d835835..f4f84557dfe 100644 --- a/dlls/secur32/schannel_macosx.c +++ b/dlls/secur32/schannel_macosx.c @@ -672,7 +672,7 @@ static OSStatus pull_adapter(SSLConnectionRef transport, void *buff, SIZE_T *buf ret = noErr; } } - else if (status == EAGAIN) + else if (status == -1) { TRACE("Would block before being able to pull anything\n"); ret = errSSLWouldBlock; @@ -723,7 +723,7 @@ static OSStatus push_adapter(SSLConnectionRef transport, const void *buff, SIZE_ TRACE("Pushed %lu bytes\n", *buff_len); ret = noErr; } - else if (status == EAGAIN) + else if (status == -1) { TRACE("Would block before being able to push anything\n"); ret = errSSLWouldBlock; -- 2.30.2

1 0

[PATCH v2 2/2] d3dx10/tests: Test subresource data for created texture.
by Ziqing Hui 11 Jun '21

11 Jun '21

Signed-off-by: Ziqing Hui <zhui(a)codeweavers.com> --- v2: * Merge 2 patches. * Get rid of shift operation. * Replace copy_texture with get_texuture_readback. * Use winetest_push_context rather than "Test %u:". * Release created texture. * Only use D3D10_CPU_ACCESS_READ for readback. dlls/d3dx10_43/tests/d3dx10.c | 458 +++++++++++++++++++++++++++++----- 1 file changed, 394 insertions(+), 64 deletions(-)

2 1

[PATCH 2/2] dpnhupnp: Stub DirectPlayNATHelpCreate and DllGetClassObject
by Alistair Leslie-Hughes 11 Jun '21

11 Jun '21

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/dpnhupnp/Makefile.in | 2 ++ dlls/dpnhupnp/dpnhupnp.spec | 4 ++-- dlls/dpnhupnp/main.c | 39 +++++++++++++++++++++++++++++++++++++ 3 files changed, 43 insertions(+), 2 deletions(-) create mode 100644 dlls/dpnhupnp/main.c diff --git a/dlls/dpnhupnp/Makefile.in b/dlls/dpnhupnp/Makefile.in index 566ce038f82..6aa9ef1dd80 100644 --- a/dlls/dpnhupnp/Makefile.in +++ b/dlls/dpnhupnp/Makefile.in @@ -2,5 +2,7 @@ MODULE = dpnhupnp.dll EXTRADLLFLAGS = -Wb,--prefer-native +C_SRCS = \ + main.c RC_SRCS = version.rc diff --git a/dlls/dpnhupnp/dpnhupnp.spec b/dlls/dpnhupnp/dpnhupnp.spec index 2a750e53675..9145823b92a 100644 --- a/dlls/dpnhupnp/dpnhupnp.spec +++ b/dlls/dpnhupnp/dpnhupnp.spec @@ -1,6 +1,6 @@ -@ stub DirectPlayNATHelpCreate +@ stdcall DirectPlayNATHelpCreate(ptr ptr) @ stdcall -private DllCanUnloadNow() -@ stub DllGetClassObject +@ stdcall -private DllGetClassObject() @ stdcall -private DllRegisterServer() @ stdcall -private DllUnregisterServer() diff --git a/dlls/dpnhupnp/main.c b/dlls/dpnhupnp/main.c new file mode 100644 index 00000000000..38d46fcbe3e --- /dev/null +++ b/dlls/dpnhupnp/main.c @@ -0,0 +1,39 @@ +/* + * + * Copyright (C) 2021 Alistair Leslie-Hughes + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <stdarg.h> + +#include "windef.h" +#include "winbase.h" +#include "objbase.h" +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dpnhupnp); + +HRESULT WINAPI DirectPlayNATHelpCreate(LPCGUID pIID, void **ppv) +{ + TRACE("(%p, %p) stub\n", pIID, ppv); + return E_NOTIMPL; +} + +HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv) +{ + FIXME("(%s, %s, %p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv); + return E_FAIL; +} -- 2.30.2

1 0

[PATCH v2 1/2] d3dx10/tests: Use winetest_push_context.
by Ziqing Hui 11 Jun '21

11 Jun '21

Signed-off-by: Ziqing Hui <zhui(a)codeweavers.com> --- v2: This is a new patch in patch set. dlls/d3dx10_43/tests/d3dx10.c | 205 ++++++++++++++++++---------------- 1 file changed, 108 insertions(+), 97 deletions(-)

1 0

[PATCH vkd3d 1/5] vkd3d-shader: Introduce HLSL allocation helpers.
by Zebediah Figura 11 Jun '21

11 Jun '21

To automatically put the compilation context in a failed state. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/hlsl.c | 102 ++++++++++----------- libs/vkd3d-shader/hlsl.h | 57 +++++++++--- libs/vkd3d-shader/hlsl.l | 5 +- libs/vkd3d-shader/hlsl.y | 137 ++++++++++++++-------------- libs/vkd3d-shader/hlsl_codegen.c | 147 +++++++++++-------------------- 5 files changed, 216 insertions(+), 232 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index e81efa2d..86ef1247 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -103,7 +103,7 @@ struct hlsl_type *hlsl_new_type(struct hlsl_ctx *ctx, const char *name, enum hls { struct hlsl_type *type; - if (!(type = vkd3d_calloc(1, sizeof(*type)))) + if (!(type = hlsl_alloc(ctx, sizeof(*type)))) return NULL; type->name = name; type->type = type_class; @@ -149,7 +149,7 @@ struct hlsl_type *hlsl_new_struct_type(struct hlsl_ctx *ctx, const char *name, s unsigned int reg_size = 0; struct hlsl_type *type; - if (!(type = vkd3d_calloc(1, sizeof(*type)))) + if (!(type = hlsl_alloc(ctx, sizeof(*type)))) return NULL; type->type = HLSL_CLASS_STRUCT; type->base_type = HLSL_TYPE_VOID; @@ -281,12 +281,12 @@ struct hlsl_type *hlsl_type_clone(struct hlsl_ctx *ctx, struct hlsl_type *old, u struct hlsl_struct_field *old_field, *field; struct hlsl_type *type; - if (!(type = vkd3d_calloc(1, sizeof(*type)))) + if (!(type = hlsl_alloc(ctx, sizeof(*type)))) return NULL; if (old->name) { - type->name = vkd3d_strdup(old->name); + type->name = hlsl_strdup(ctx, old->name); if (!type->name) { vkd3d_free(type); @@ -313,7 +313,7 @@ struct hlsl_type *hlsl_type_clone(struct hlsl_ctx *ctx, struct hlsl_type *old, u { unsigned int reg_size = 0; - if (!(type->e.elements = vkd3d_malloc(sizeof(*type->e.elements)))) + if (!(type->e.elements = hlsl_alloc(ctx, sizeof(*type->e.elements)))) { vkd3d_free((void *)type->name); vkd3d_free(type); @@ -322,7 +322,7 @@ struct hlsl_type *hlsl_type_clone(struct hlsl_ctx *ctx, struct hlsl_type *old, u list_init(type->e.elements); LIST_FOR_EACH_ENTRY(old_field, old->e.elements, struct hlsl_struct_field, entry) { - if (!(field = vkd3d_calloc(1, sizeof(*field)))) + if (!(field = hlsl_alloc(ctx, sizeof(*field)))) { LIST_FOR_EACH_ENTRY_SAFE(field, old_field, type->e.elements, struct hlsl_struct_field, entry) { @@ -337,10 +337,10 @@ struct hlsl_type *hlsl_type_clone(struct hlsl_ctx *ctx, struct hlsl_type *old, u } field->loc = old_field->loc; field->type = hlsl_type_clone(ctx, old_field->type, default_majority); - field->name = vkd3d_strdup(old_field->name); + field->name = hlsl_strdup(ctx, old_field->name); if (old_field->semantic.name) { - field->semantic.name = vkd3d_strdup(old_field->semantic.name); + field->semantic.name = hlsl_strdup(ctx, old_field->semantic.name); field->semantic.index = old_field->semantic.index; } field->reg_offset = reg_size; @@ -373,30 +373,30 @@ bool hlsl_scope_add_type(struct hlsl_scope *scope, struct hlsl_type *type) return true; } -struct hlsl_ir_expr *hlsl_new_cast(struct hlsl_ir_node *node, struct hlsl_type *type, +struct hlsl_ir_expr *hlsl_new_cast(struct hlsl_ctx *ctx, struct hlsl_ir_node *node, struct hlsl_type *type, struct vkd3d_shader_location *loc) { struct hlsl_ir_node *cast; - cast = hlsl_new_unary_expr(HLSL_IR_UNOP_CAST, node, *loc); + cast = hlsl_new_unary_expr(ctx, HLSL_IR_UNOP_CAST, node, *loc); if (cast) cast->data_type = type; return hlsl_ir_expr(cast); } -struct hlsl_ir_expr *hlsl_new_copy(struct hlsl_ir_node *node) +struct hlsl_ir_expr *hlsl_new_copy(struct hlsl_ctx *ctx, struct hlsl_ir_node *node) { /* Use a cast to the same type as a makeshift identity expression. */ - return hlsl_new_cast(node, node->data_type, &node->loc); + return hlsl_new_cast(ctx, node, node->data_type, &node->loc); } -struct hlsl_ir_var *hlsl_new_var(const char *name, struct hlsl_type *type, +struct hlsl_ir_var *hlsl_new_var(struct hlsl_ctx *ctx, const char *name, struct hlsl_type *type, const struct vkd3d_shader_location loc, const struct hlsl_semantic *semantic, unsigned int modifiers, const struct hlsl_reg_reservation *reg_reservation) { struct hlsl_ir_var *var; - if (!(var = vkd3d_calloc(1, sizeof(*var)))) + if (!(var = hlsl_alloc(ctx, sizeof(*var)))) return NULL; var->name = name; @@ -412,7 +412,7 @@ struct hlsl_ir_var *hlsl_new_var(const char *name, struct hlsl_type *type, struct hlsl_ir_var *hlsl_new_synthetic_var(struct hlsl_ctx *ctx, const char *name, struct hlsl_type *type, const struct vkd3d_shader_location loc) { - struct hlsl_ir_var *var = hlsl_new_var(vkd3d_strdup(name), type, loc, NULL, 0, NULL); + struct hlsl_ir_var *var = hlsl_new_var(ctx, hlsl_strdup(ctx, name), type, loc, NULL, 0, NULL); if (var) list_add_tail(&ctx->globals->vars, &var->scope_entry); @@ -424,7 +424,7 @@ static bool type_is_single_reg(const struct hlsl_type *type) return type->type == HLSL_CLASS_SCALAR || type->type == HLSL_CLASS_VECTOR; } -struct hlsl_ir_store *hlsl_new_store(struct hlsl_ir_var *var, struct hlsl_ir_node *offset, +struct hlsl_ir_store *hlsl_new_store(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, struct hlsl_ir_node *offset, struct hlsl_ir_node *rhs, unsigned int writemask, struct vkd3d_shader_location loc) { struct hlsl_ir_store *store; @@ -432,7 +432,7 @@ struct hlsl_ir_store *hlsl_new_store(struct hlsl_ir_var *var, struct hlsl_ir_nod if (!writemask && type_is_single_reg(rhs->data_type)) writemask = (1 << rhs->data_type->dimx) - 1; - if (!(store = vkd3d_malloc(sizeof(*store)))) + if (!(store = hlsl_alloc(ctx, sizeof(*store)))) return NULL; init_node(&store->node, HLSL_IR_STORE, NULL, loc); @@ -443,9 +443,9 @@ struct hlsl_ir_store *hlsl_new_store(struct hlsl_ir_var *var, struct hlsl_ir_nod return store; } -struct hlsl_ir_store *hlsl_new_simple_store(struct hlsl_ir_var *lhs, struct hlsl_ir_node *rhs) +struct hlsl_ir_store *hlsl_new_simple_store(struct hlsl_ctx *ctx, struct hlsl_ir_var *lhs, struct hlsl_ir_node *rhs) { - return hlsl_new_store(lhs, NULL, rhs, 0, rhs->loc); + return hlsl_new_store(ctx, lhs, NULL, rhs, 0, rhs->loc); } struct hlsl_ir_constant *hlsl_new_uint_constant(struct hlsl_ctx *ctx, unsigned int n, @@ -453,19 +453,19 @@ struct hlsl_ir_constant *hlsl_new_uint_constant(struct hlsl_ctx *ctx, unsigned i { struct hlsl_ir_constant *c; - if (!(c = vkd3d_malloc(sizeof(*c)))) + if (!(c = hlsl_alloc(ctx, sizeof(*c)))) return NULL; init_node(&c->node, HLSL_IR_CONSTANT, ctx->builtin_types.scalar[HLSL_TYPE_UINT], loc); c->value.u[0] = n; return c; } -struct hlsl_ir_node *hlsl_new_unary_expr(enum hlsl_ir_expr_op op, +struct hlsl_ir_node *hlsl_new_unary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg, struct vkd3d_shader_location loc) { struct hlsl_ir_expr *expr; - if (!(expr = vkd3d_calloc(1, sizeof(*expr)))) + if (!(expr = hlsl_alloc(ctx, sizeof(*expr)))) return NULL; init_node(&expr->node, HLSL_IR_EXPR, arg->data_type, loc); expr->op = op; @@ -473,13 +473,14 @@ struct hlsl_ir_node *hlsl_new_unary_expr(enum hlsl_ir_expr_op op, return &expr->node; } -struct hlsl_ir_node *hlsl_new_binary_expr(enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2) +struct hlsl_ir_node *hlsl_new_binary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op, + struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2) { struct hlsl_ir_expr *expr; assert(hlsl_types_are_equal(arg1->data_type, arg2->data_type)); - if (!(expr = vkd3d_calloc(1, sizeof(*expr)))) + if (!(expr = hlsl_alloc(ctx, sizeof(*expr)))) return NULL; init_node(&expr->node, HLSL_IR_EXPR, arg1->data_type, arg1->loc); expr->op = op; @@ -488,11 +489,11 @@ struct hlsl_ir_node *hlsl_new_binary_expr(enum hlsl_ir_expr_op op, struct hlsl_i return &expr->node; } -struct hlsl_ir_if *hlsl_new_if(struct hlsl_ir_node *condition, struct vkd3d_shader_location loc) +struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition, struct vkd3d_shader_location loc) { struct hlsl_ir_if *iff; - if (!(iff = vkd3d_malloc(sizeof(*iff)))) + if (!(iff = hlsl_alloc(ctx, sizeof(*iff)))) return NULL; init_node(&iff->node, HLSL_IR_IF, NULL, loc); hlsl_src_from_node(&iff->condition, condition); @@ -501,12 +502,12 @@ struct hlsl_ir_if *hlsl_new_if(struct hlsl_ir_node *condition, struct vkd3d_shad return iff; } -struct hlsl_ir_load *hlsl_new_load(struct hlsl_ir_var *var, struct hlsl_ir_node *offset, +struct hlsl_ir_load *hlsl_new_load(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, struct hlsl_ir_node *offset, struct hlsl_type *type, const struct vkd3d_shader_location loc) { struct hlsl_ir_load *load; - if (!(load = vkd3d_calloc(1, sizeof(*load)))) + if (!(load = hlsl_alloc(ctx, sizeof(*load)))) return NULL; init_node(&load->node, HLSL_IR_LOAD, type, loc); load->src.var = var; @@ -514,9 +515,10 @@ struct hlsl_ir_load *hlsl_new_load(struct hlsl_ir_var *var, struct hlsl_ir_node return load; } -struct hlsl_ir_load *hlsl_new_var_load(struct hlsl_ir_var *var, const struct vkd3d_shader_location loc) +struct hlsl_ir_load *hlsl_new_var_load(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, + const struct vkd3d_shader_location loc) { - return hlsl_new_load(var, NULL, var->data_type, loc); + return hlsl_new_load(ctx, var, NULL, var->data_type, loc); } struct hlsl_ir_swizzle *hlsl_new_swizzle(struct hlsl_ctx *ctx, DWORD s, unsigned int components, @@ -524,7 +526,7 @@ struct hlsl_ir_swizzle *hlsl_new_swizzle(struct hlsl_ctx *ctx, DWORD s, unsigned { struct hlsl_ir_swizzle *swizzle; - if (!(swizzle = vkd3d_malloc(sizeof(*swizzle)))) + if (!(swizzle = hlsl_alloc(ctx, sizeof(*swizzle)))) return NULL; init_node(&swizzle->node, HLSL_IR_SWIZZLE, hlsl_new_type(ctx, NULL, HLSL_CLASS_VECTOR, val->data_type->base_type, components, 1), *loc); @@ -533,22 +535,22 @@ struct hlsl_ir_swizzle *hlsl_new_swizzle(struct hlsl_ctx *ctx, DWORD s, unsigned return swizzle; } -struct hlsl_ir_jump *hlsl_new_jump(enum hlsl_ir_jump_type type, struct vkd3d_shader_location loc) +struct hlsl_ir_jump *hlsl_new_jump(struct hlsl_ctx *ctx, enum hlsl_ir_jump_type type, struct vkd3d_shader_location loc) { struct hlsl_ir_jump *jump; - if (!(jump = vkd3d_malloc(sizeof(*jump)))) + if (!(jump = hlsl_alloc(ctx, sizeof(*jump)))) return NULL; init_node(&jump->node, HLSL_IR_JUMP, NULL, loc); jump->type = type; return jump; } -struct hlsl_ir_loop *hlsl_new_loop(struct vkd3d_shader_location loc) +struct hlsl_ir_loop *hlsl_new_loop(struct hlsl_ctx *ctx, struct vkd3d_shader_location loc) { struct hlsl_ir_loop *loop; - if (!(loop = vkd3d_calloc(1, sizeof(*loop)))) + if (!(loop = hlsl_alloc(ctx, sizeof(*loop)))) return NULL; init_node(&loop->node, HLSL_IR_LOOP, NULL, loc); list_init(&loop->body); @@ -565,7 +567,7 @@ struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx, struct hl { struct hlsl_ir_function_decl *decl; - if (!(decl = vkd3d_calloc(1, sizeof(*decl)))) + if (!(decl = hlsl_alloc(ctx, sizeof(*decl)))) return NULL; decl->return_type = return_type; decl->parameters = parameters; @@ -577,7 +579,7 @@ struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx, struct hl char name[28]; sprintf(name, "<retval-%p>", decl); - if (!(return_var = hlsl_new_var(vkd3d_strdup(name), return_type, loc, semantic, 0, NULL))) + if (!(return_var = hlsl_new_var(ctx, hlsl_strdup(ctx, name), return_type, loc, semantic, 0, NULL))) { vkd3d_free(decl); return NULL; @@ -609,7 +611,7 @@ void hlsl_push_scope(struct hlsl_ctx *ctx) { struct hlsl_scope *new_scope; - if (!(new_scope = vkd3d_malloc(sizeof(*new_scope)))) + if (!(new_scope = hlsl_alloc(ctx, sizeof(*new_scope)))) return; TRACE("Pushing a new scope.\n"); list_init(&new_scope->vars); @@ -1333,12 +1335,12 @@ static void free_function_rb(struct rb_entry *entry, void *context) free_function(RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry)); } -void hlsl_add_function(struct rb_tree *funcs, char *name, struct hlsl_ir_function_decl *decl, bool intrinsic) +void hlsl_add_function(struct hlsl_ctx *ctx, char *name, struct hlsl_ir_function_decl *decl, bool intrinsic) { struct hlsl_ir_function *func; struct rb_entry *func_entry, *old_entry; - func_entry = rb_get(funcs, name); + func_entry = rb_get(&ctx->functions, name); if (func_entry) { func = RB_ENTRY_VALUE(func_entry, struct hlsl_ir_function, entry); @@ -1372,13 +1374,13 @@ void hlsl_add_function(struct rb_tree *funcs, char *name, struct hlsl_ir_functio vkd3d_free(name); return; } - func = vkd3d_malloc(sizeof(*func)); + func = hlsl_alloc(ctx, sizeof(*func)); func->name = name; rb_init(&func->overloads, compare_function_decl_rb); decl->func = func; rb_put(&func->overloads, decl->parameters, &decl->entry); func->intrinsic = intrinsic; - rb_put(funcs, func->name, &func->entry); + rb_put(&ctx->functions, func->name, &func->entry); } static const struct hlsl_profile_info *get_target_info(const char *target) @@ -1517,20 +1519,20 @@ static void declare_predefined_types(struct hlsl_ctx *ctx) for (x = 1; x <= 4; ++x) { sprintf(name, "%s%ux%u", names[bt], y, x); - type = hlsl_new_type(ctx, vkd3d_strdup(name), HLSL_CLASS_MATRIX, bt, x, y); + type = hlsl_new_type(ctx, hlsl_strdup(ctx, name), HLSL_CLASS_MATRIX, bt, x, y); hlsl_scope_add_type(ctx->globals, type); if (y == 1) { sprintf(name, "%s%u", names[bt], x); - type = hlsl_new_type(ctx, vkd3d_strdup(name), HLSL_CLASS_VECTOR, bt, x, y); + type = hlsl_new_type(ctx, hlsl_strdup(ctx, name), HLSL_CLASS_VECTOR, bt, x, y); hlsl_scope_add_type(ctx->globals, type); ctx->builtin_types.vector[bt][x - 1] = type; if (x == 1) { sprintf(name, "%s", names[bt]); - type = hlsl_new_type(ctx, vkd3d_strdup(name), HLSL_CLASS_SCALAR, bt, x, y); + type = hlsl_new_type(ctx, hlsl_strdup(ctx, name), HLSL_CLASS_SCALAR, bt, x, y); hlsl_scope_add_type(ctx->globals, type); ctx->builtin_types.scalar[bt] = type; } @@ -1541,16 +1543,16 @@ static void declare_predefined_types(struct hlsl_ctx *ctx) for (bt = 0; bt <= HLSL_SAMPLER_DIM_MAX; ++bt) { - type = hlsl_new_type(ctx, vkd3d_strdup(sampler_names[bt]), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1); + type = hlsl_new_type(ctx, hlsl_strdup(ctx, sampler_names[bt]), HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1); type->sampler_dim = bt; ctx->builtin_types.sampler[bt] = type; } - ctx->builtin_types.Void = hlsl_new_type(ctx, vkd3d_strdup("void"), HLSL_CLASS_OBJECT, HLSL_TYPE_VOID, 1, 1); + ctx->builtin_types.Void = hlsl_new_type(ctx, hlsl_strdup(ctx, "void"), HLSL_CLASS_OBJECT, HLSL_TYPE_VOID, 1, 1); for (i = 0; i < ARRAY_SIZE(effect_types); ++i) { - type = hlsl_new_type(ctx, vkd3d_strdup(effect_types[i].name), effect_types[i].class, + type = hlsl_new_type(ctx, hlsl_strdup(ctx, effect_types[i].name), effect_types[i].class, effect_types[i].base_type, effect_types[i].dimx, effect_types[i].dimy); hlsl_scope_add_type(ctx->globals, type); } @@ -1565,9 +1567,9 @@ static bool hlsl_ctx_init(struct hlsl_ctx *ctx, const struct hlsl_profile_info * ctx->message_context = message_context; - if (!(ctx->source_files = vkd3d_malloc(sizeof(*ctx->source_files)))) + if (!(ctx->source_files = hlsl_alloc(ctx, sizeof(*ctx->source_files)))) return false; - if (!(ctx->source_files[0] = vkd3d_strdup(""))) + if (!(ctx->source_files[0] = hlsl_strdup(ctx, ""))) { vkd3d_free(ctx->source_files); return false; diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 9081ef37..3e7d2445 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -539,6 +539,34 @@ static inline void hlsl_src_remove(struct hlsl_src *src) src->node = NULL; } +static inline void *hlsl_alloc(struct hlsl_ctx *ctx, size_t size) +{ + void *ptr = vkd3d_calloc(1, size); + + if (!ptr) + ctx->failed = true; + return ptr; +} + +static inline char *hlsl_strdup(struct hlsl_ctx *ctx, const char *string) +{ + char *ptr = vkd3d_strdup(string); + + if (!ptr) + ctx->failed = true; + return ptr; +} + +static inline bool hlsl_array_reserve(struct hlsl_ctx *ctx, void **elements, + size_t *capacity, size_t element_count, size_t element_size) +{ + bool ret = vkd3d_array_reserve(elements, capacity, element_count, element_size); + + if (!ret) + ctx->failed = true; + return ret; +} + const char *debug_hlsl_type(const struct hlsl_type *type) DECLSPEC_HIDDEN; const char *debug_hlsl_writemask(unsigned int writemask) DECLSPEC_HIDDEN; @@ -548,7 +576,7 @@ struct vkd3d_string_buffer *hlsl_modifiers_to_string(struct vkd3d_string_buffer_ unsigned int modifiers) DECLSPEC_HIDDEN; const char *hlsl_node_type_to_string(enum hlsl_ir_node_type type) DECLSPEC_HIDDEN; -void hlsl_add_function(struct rb_tree *funcs, char *name, struct hlsl_ir_function_decl *decl, +void hlsl_add_function(struct hlsl_ctx *ctx, char *name, struct hlsl_ir_function_decl *decl, bool intrinsic) DECLSPEC_HIDDEN; bool hlsl_add_var(struct hlsl_ctx *ctx, struct hlsl_ir_var *decl, bool local_var) DECLSPEC_HIDDEN; @@ -569,22 +597,24 @@ struct hlsl_ir_var *hlsl_get_var(struct hlsl_scope *scope, const char *name) DEC struct hlsl_type *hlsl_new_array_type(struct hlsl_ctx *ctx, struct hlsl_type *basic_type, unsigned int array_size) DECLSPEC_HIDDEN; -struct hlsl_ir_node *hlsl_new_binary_expr(enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1, +struct hlsl_ir_node *hlsl_new_binary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2) DECLSPEC_HIDDEN; -struct hlsl_ir_expr *hlsl_new_cast(struct hlsl_ir_node *node, struct hlsl_type *type, +struct hlsl_ir_expr *hlsl_new_cast(struct hlsl_ctx *ctx, struct hlsl_ir_node *node, struct hlsl_type *type, struct vkd3d_shader_location *loc) DECLSPEC_HIDDEN; -struct hlsl_ir_expr *hlsl_new_copy(struct hlsl_ir_node *node) DECLSPEC_HIDDEN; +struct hlsl_ir_expr *hlsl_new_copy(struct hlsl_ctx *ctx, struct hlsl_ir_node *node) DECLSPEC_HIDDEN; struct hlsl_ir_function_decl *hlsl_new_func_decl(struct hlsl_ctx *ctx, struct hlsl_type *return_type, struct list *parameters, const struct hlsl_semantic *semantic, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; -struct hlsl_ir_if *hlsl_new_if(struct hlsl_ir_node *condition, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; -struct hlsl_ir_jump *hlsl_new_jump(enum hlsl_ir_jump_type type, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; -struct hlsl_ir_load *hlsl_new_load(struct hlsl_ir_var *var, struct hlsl_ir_node *offset, struct hlsl_type *type, +struct hlsl_ir_if *hlsl_new_if(struct hlsl_ctx *ctx, struct hlsl_ir_node *condition, + struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; +struct hlsl_ir_jump *hlsl_new_jump(struct hlsl_ctx *ctx, enum hlsl_ir_jump_type type, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; -struct hlsl_ir_loop *hlsl_new_loop(struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; -struct hlsl_ir_store *hlsl_new_simple_store(struct hlsl_ir_var *lhs, +struct hlsl_ir_load *hlsl_new_load(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, struct hlsl_ir_node *offset, + struct hlsl_type *type, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; +struct hlsl_ir_loop *hlsl_new_loop(struct hlsl_ctx *ctx, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; +struct hlsl_ir_store *hlsl_new_simple_store(struct hlsl_ctx *ctx, struct hlsl_ir_var *lhs, struct hlsl_ir_node *rhs) DECLSPEC_HIDDEN; -struct hlsl_ir_store *hlsl_new_store(struct hlsl_ir_var *var, struct hlsl_ir_node *offset, +struct hlsl_ir_store *hlsl_new_store(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, struct hlsl_ir_node *offset, struct hlsl_ir_node *rhs, unsigned int writemask, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; struct hlsl_type *hlsl_new_struct_type(struct hlsl_ctx *ctx, const char *name, struct list *fields) DECLSPEC_HIDDEN; struct hlsl_ir_swizzle *hlsl_new_swizzle(struct hlsl_ctx *ctx, DWORD s, unsigned int components, @@ -595,12 +625,13 @@ struct hlsl_type *hlsl_new_type(struct hlsl_ctx *ctx, const char *name, enum hls enum hlsl_base_type base_type, unsigned dimx, unsigned dimy) DECLSPEC_HIDDEN; struct hlsl_ir_constant *hlsl_new_uint_constant(struct hlsl_ctx *ctx, unsigned int n, const struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; -struct hlsl_ir_node *hlsl_new_unary_expr(enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg, +struct hlsl_ir_node *hlsl_new_unary_expr(struct hlsl_ctx *ctx, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg, struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; -struct hlsl_ir_var *hlsl_new_var(const char *name, struct hlsl_type *type, +struct hlsl_ir_var *hlsl_new_var(struct hlsl_ctx *ctx, const char *name, struct hlsl_type *type, const struct vkd3d_shader_location loc, const struct hlsl_semantic *semantic, unsigned int modifiers, const struct hlsl_reg_reservation *reg_reservation) DECLSPEC_HIDDEN; -struct hlsl_ir_load *hlsl_new_var_load(struct hlsl_ir_var *var, const struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; +struct hlsl_ir_load *hlsl_new_var_load(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, + const struct vkd3d_shader_location loc) DECLSPEC_HIDDEN; void hlsl_error(struct hlsl_ctx *ctx, const struct vkd3d_shader_location loc, enum vkd3d_shader_error error, const char *fmt, ...) VKD3D_PRINTF_FUNC(4, 5) DECLSPEC_HIDDEN; diff --git a/libs/vkd3d-shader/hlsl.l b/libs/vkd3d-shader/hlsl.l index cee98ea5..f8ff2830 100644 --- a/libs/vkd3d-shader/hlsl.l +++ b/libs/vkd3d-shader/hlsl.l @@ -170,7 +170,7 @@ row_major {return KW_ROW_MAJOR; } {IDENTIFIER} { struct hlsl_ctx *ctx = yyget_extra(yyscanner); - yylval->name = vkd3d_strdup(yytext); + yylval->name = hlsl_strdup(ctx, yytext); if (hlsl_get_var(ctx->cur_scope, yytext) || hlsl_get_function(ctx, yytext)) return VAR_IDENTIFIER; else if (hlsl_get_type(ctx->cur_scope, yytext, true)) @@ -248,7 +248,8 @@ row_major {return KW_ROW_MAJOR; } return PRE_LINE; } <pp_line>{STRING} { - char *string = vkd3d_strdup(yytext + 1); + struct hlsl_ctx *ctx = yyget_extra(yyscanner); + char *string = hlsl_strdup(ctx, yytext + 1); BEGIN(pp_ignore); string[strlen(string) - 1] = 0; diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index bcb1c207..52544c43 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -127,11 +127,11 @@ static struct hlsl_ir_node *node_from_list(struct list *list) return LIST_ENTRY(list_tail(list), struct hlsl_ir_node, entry); } -static struct list *make_empty_list(void) +static struct list *make_empty_list(struct hlsl_ctx *ctx) { struct list *list; - if ((list = vkd3d_malloc(sizeof(*list)))) + if ((list = hlsl_alloc(ctx, sizeof(*list)))) list_init(list); return list; } @@ -286,7 +286,7 @@ static struct hlsl_ir_node *add_implicit_conversion(struct hlsl_ctx *ctx, struct hlsl_warning(ctx, *loc, VKD3D_SHADER_WARNING_HLSL_IMPLICIT_TRUNCATION, "Implicit truncation of %s type.", src_type->type == HLSL_CLASS_VECTOR ? "vector" : "matrix"); - if (!(cast = hlsl_new_cast(node, dst_type, loc))) + if (!(cast = hlsl_new_cast(ctx, node, dst_type, loc))) return NULL; list_add_tail(instrs, &cast->node.entry); return &cast->node; @@ -313,7 +313,7 @@ static DWORD add_modifiers(struct hlsl_ctx *ctx, DWORD modifiers, DWORD mod, con return modifiers | mod; } -static bool append_conditional_break(struct list *cond_list) +static bool append_conditional_break(struct hlsl_ctx *ctx, struct list *cond_list) { struct hlsl_ir_node *condition, *not; struct hlsl_ir_jump *jump; @@ -324,15 +324,15 @@ static bool append_conditional_break(struct list *cond_list) return true; condition = node_from_list(cond_list); - if (!(not = hlsl_new_unary_expr(HLSL_IR_UNOP_LOGIC_NOT, condition, condition->loc))) + if (!(not = hlsl_new_unary_expr(ctx, HLSL_IR_UNOP_LOGIC_NOT, condition, condition->loc))) return false; list_add_tail(cond_list, &not->entry); - if (!(iff = hlsl_new_if(not, condition->loc))) + if (!(iff = hlsl_new_if(ctx, not, condition->loc))) return false; list_add_tail(cond_list, &iff->node.entry); - if (!(jump = hlsl_new_jump(HLSL_IR_JUMP_BREAK, condition->loc))) + if (!(jump = hlsl_new_jump(ctx, HLSL_IR_JUMP_BREAK, condition->loc))) return false; list_add_head(&iff->then_instrs, &jump->node.entry); return true; @@ -345,24 +345,24 @@ enum loop_type LOOP_DO_WHILE }; -static struct list *create_loop(enum loop_type type, struct list *init, struct list *cond, +static struct list *create_loop(struct hlsl_ctx *ctx, enum loop_type type, struct list *init, struct list *cond, struct list *iter, struct list *body, struct vkd3d_shader_location loc) { struct list *list = NULL; struct hlsl_ir_loop *loop = NULL; struct hlsl_ir_if *cond_jump = NULL; - if (!(list = make_empty_list())) + if (!(list = make_empty_list(ctx))) goto oom; if (init) list_move_head(list, init); - if (!(loop = hlsl_new_loop(loc))) + if (!(loop = hlsl_new_loop(ctx, loc))) goto oom; list_add_tail(list, &loop->node.entry); - if (!append_conditional_break(cond)) + if (!append_conditional_break(ctx, cond)) goto oom; if (type != LOOP_DO_WHILE) @@ -504,7 +504,7 @@ static struct hlsl_ir_jump *add_return(struct hlsl_ctx *ctx, struct list *instrs if (!(return_value = add_implicit_conversion(ctx, instrs, return_value, return_type, &loc))) return NULL; - if (!(store = hlsl_new_simple_store(ctx->cur_function->return_var, return_value))) + if (!(store = hlsl_new_simple_store(ctx, ctx->cur_function->return_var, return_value))) return NULL; list_add_after(&return_value->entry, &store->node.entry); } @@ -514,7 +514,7 @@ static struct hlsl_ir_jump *add_return(struct hlsl_ctx *ctx, struct list *instrs return NULL; } - if (!(jump = hlsl_new_jump(HLSL_IR_JUMP_RETURN, loc))) + if (!(jump = hlsl_new_jump(ctx, HLSL_IR_JUMP_RETURN, loc))) return NULL; list_add_tail(instrs, &jump->node.entry); @@ -535,7 +535,7 @@ static struct hlsl_ir_load *add_load(struct hlsl_ctx *ctx, struct list *instrs, var = src->var; if (src->offset.node) { - if (!(add = hlsl_new_binary_expr(HLSL_IR_BINOP_ADD, src->offset.node, offset))) + if (!(add = hlsl_new_binary_expr(ctx, HLSL_IR_BINOP_ADD, src->offset.node, offset))) return NULL; list_add_tail(instrs, &add->entry); offset = add; @@ -550,13 +550,13 @@ static struct hlsl_ir_load *add_load(struct hlsl_ctx *ctx, struct list *instrs, if (!(var = hlsl_new_synthetic_var(ctx, name, var_node->data_type, var_node->loc))) return NULL; - if (!(store = hlsl_new_simple_store(var, var_node))) + if (!(store = hlsl_new_simple_store(ctx, var, var_node))) return NULL; list_add_tail(instrs, &store->node.entry); } - if (!(load = hlsl_new_load(var, offset, data_type, loc))) + if (!(load = hlsl_new_load(ctx, var, offset, data_type, loc))) return NULL; list_add_tail(instrs, &load->node.entry); return load; @@ -604,7 +604,7 @@ static struct hlsl_ir_load *add_array_load(struct hlsl_ctx *ctx, struct list *in if (!(c = hlsl_new_uint_constant(ctx, data_type->reg_size * 4, loc))) return NULL; list_add_tail(instrs, &c->node.entry); - if (!(mul = hlsl_new_binary_expr(HLSL_IR_BINOP_MUL, index, &c->node))) + if (!(mul = hlsl_new_binary_expr(ctx, HLSL_IR_BINOP_MUL, index, &c->node))) return NULL; list_add_tail(instrs, &mul->entry); index = mul; @@ -676,13 +676,13 @@ static struct list *gen_struct_fields(struct hlsl_ctx *ctx, struct hlsl_type *ty if (type->type == HLSL_CLASS_MATRIX) assert(type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK); - if (!(list = make_empty_list())) + if (!(list = make_empty_list(ctx))) return NULL; LIST_FOR_EACH_ENTRY_SAFE(v, v_next, fields, struct parse_variable_def, entry) { unsigned int i; - if (!(field = vkd3d_calloc(1, sizeof(*field)))) + if (!(field = hlsl_alloc(ctx, sizeof(*field)))) { vkd3d_free(v); return list; @@ -767,7 +767,7 @@ static bool add_func_parameter(struct hlsl_ctx *ctx, struct list *list, hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_MODIFIER, "Parameter '%s' is declared as both \"out\" and \"uniform\".", param->name); - if (!(var = hlsl_new_var(param->name, param->type, loc, &param->semantic, param->modifiers, param->reg_reservation))) + if (!(var = hlsl_new_var(ctx, param->name, param->type, loc, &param->semantic, param->modifiers, param->reg_reservation))) return false; var->is_param = 1; @@ -780,7 +780,7 @@ static bool add_func_parameter(struct hlsl_ctx *ctx, struct list *list, return true; } -static struct hlsl_reg_reservation *parse_reg_reservation(const char *reg_string) +static struct hlsl_reg_reservation *parse_reg_reservation(struct hlsl_ctx *ctx, const char *reg_string) { enum vkd3d_shader_register_type type; struct hlsl_reg_reservation *reg_res; @@ -811,7 +811,7 @@ static struct hlsl_reg_reservation *parse_reg_reservation(const char *reg_string return NULL; } - if (!(reg_res = vkd3d_malloc(sizeof(*reg_res)))) + if (!(reg_res = hlsl_alloc(ctx, sizeof(*reg_res)))) return NULL; reg_res->type = type; reg_res->regnum = regnum; @@ -841,11 +841,11 @@ static const struct hlsl_ir_function_decl *get_overloaded_func(struct rb_tree *f return NULL; } -static struct list *make_list(struct hlsl_ir_node *node) +static struct list *make_list(struct hlsl_ctx *ctx, struct hlsl_ir_node *node) { struct list *list; - if (!(list = make_empty_list())) + if (!(list = make_empty_list(ctx))) { hlsl_free_instr(node); return NULL; @@ -1112,13 +1112,13 @@ static struct hlsl_ir_expr *add_expr(struct hlsl_ctx *ctx, struct list *instrs, "Implicit truncation of %s type.", operands[i]->data_type->type == HLSL_CLASS_VECTOR ? "vector" : "matrix"); - if (!(cast = hlsl_new_cast(operands[i], type, &operands[i]->loc))) + if (!(cast = hlsl_new_cast(ctx, operands[i], type, &operands[i]->loc))) return NULL; list_add_after(&operands[i]->entry, &cast->node.entry); operands[i] = &cast->node; } - if (!(expr = vkd3d_calloc(1, sizeof(*expr)))) + if (!(expr = hlsl_alloc(ctx, sizeof(*expr)))) return NULL; init_node(&expr->node, HLSL_IR_EXPR, type, *loc); expr->op = op; @@ -1229,7 +1229,7 @@ static struct hlsl_ir_node *add_assignment(struct hlsl_ctx *ctx, struct list *in return NULL; } - if (!(store = vkd3d_malloc(sizeof(*store)))) + if (!(store = hlsl_alloc(ctx, sizeof(*store)))) return NULL; while (lhs->type != HLSL_IR_LOAD) @@ -1283,7 +1283,7 @@ static struct hlsl_ir_node *add_assignment(struct hlsl_ctx *ctx, struct list *in /* Don't use the instruction itself as a source, as this makes structure * splitting easier. Instead copy it here. Since we retrieve sources from * the last instruction in the list, we do need to copy. */ - if (!(copy = hlsl_new_copy(rhs))) + if (!(copy = hlsl_new_copy(ctx, rhs))) return NULL; list_add_tail(instrs, &copy->node.entry); return &copy->node; @@ -1310,7 +1310,7 @@ static bool add_increment(struct hlsl_ctx *ctx, struct list *instrs, bool decrem { struct hlsl_ir_expr *copy; - if (!(copy = hlsl_new_copy(lhs))) + if (!(copy = hlsl_new_copy(ctx, lhs))) return false; list_add_tail(instrs, &copy->node.entry); @@ -1357,7 +1357,7 @@ static void struct_var_initializer(struct hlsl_ctx *ctx, struct list *list, stru break; list_add_tail(list, &c->node.entry); - if (!(store = hlsl_new_store(var, &c->node, node, 0, node->loc))) + if (!(store = hlsl_new_store(ctx, var, &c->node, node, 0, node->loc))) break; list_add_tail(list, &store->node.entry); } @@ -1391,7 +1391,7 @@ static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_t if (basic_type->type == HLSL_CLASS_MATRIX) assert(basic_type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK); - if (!(statements_list = make_empty_list())) + if (!(statements_list = make_empty_list(ctx))) { LIST_FOR_EACH_ENTRY_SAFE(v, v_next, var_list, struct parse_variable_def, entry) free_parse_variable_def(v); @@ -1413,7 +1413,7 @@ static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_t if (type->type != HLSL_CLASS_MATRIX) check_invalid_matrix_modifiers(ctx, modifiers, v->loc); - if (!(var = hlsl_new_var(v->name, type, v->loc, &v->semantic, modifiers, v->reg_reservation))) + if (!(var = hlsl_new_var(ctx, v->name, type, v->loc, &v->semantic, modifiers, v->reg_reservation))) { free_parse_variable_def(v); continue; @@ -1538,7 +1538,7 @@ static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_t continue; } - load = hlsl_new_var_load(var, var->loc); + load = hlsl_new_var_load(ctx, var, var->loc); list_add_tail(v->initializer.instrs, &load->node.entry); add_assignment(ctx, v->initializer.instrs, &load->node, ASSIGN_OP_ASSIGN, v->initializer.args[0]); vkd3d_free(v->initializer.args); @@ -1800,7 +1800,7 @@ hlsl_prog: } } - hlsl_add_function(&ctx->functions, $2.name, $2.decl, false); + hlsl_add_function(ctx, $2.name, $2.decl, false); } | hlsl_prog declaration_statement { @@ -1893,7 +1893,7 @@ any_identifier: fields_list: %empty { - if (!($$ = make_empty_list())) + if (!($$ = make_empty_list(ctx))) YYABORT; } | fields_list field @@ -1996,7 +1996,7 @@ func_prototype: compound_statement: '{' '}' { - if (!($$ = make_empty_list())) + if (!($$ = make_empty_list(ctx))) YYABORT; } | '{' scope_start statement_list '}' @@ -2048,7 +2048,7 @@ semantic: register_opt: ':' KW_REGISTER '(' any_identifier ')' { - $$ = parse_reg_reservation($4); + $$ = parse_reg_reservation(ctx, $4); vkd3d_free($4); } | ':' KW_REGISTER '(' any_identifier ',' any_identifier ')' @@ -2056,14 +2056,14 @@ register_opt: FIXME("Ignoring shader target %s in a register reservation.\n", debugstr_a($4)); vkd3d_free($4); - $$ = parse_reg_reservation($6); + $$ = parse_reg_reservation(ctx, $6); vkd3d_free($6); } parameters: scope_start { - if (!($$ = make_empty_list())) + if (!($$ = make_empty_list(ctx))) YYABORT; } | scope_start param_list @@ -2074,12 +2074,11 @@ parameters: param_list: parameter { - if (!($$ = make_empty_list())) + if (!($$ = make_empty_list(ctx))) YYABORT; if (!add_func_parameter(ctx, $$, &$1, @1)) { ERR("Error adding function parameter %s.\n", $1.name); - ctx->failed = true; YYABORT; } } @@ -2244,7 +2243,7 @@ declaration_statement: | struct_declaration | typedef { - if (!($$ = make_empty_list())) + if (!($$ = make_empty_list(ctx))) YYABORT; } @@ -2272,7 +2271,7 @@ typedef: type_specs: type_spec { - if (!($$ = make_empty_list())) + if (!($$ = make_empty_list(ctx))) YYABORT; list_add_head($$, &$1->entry); } @@ -2285,7 +2284,7 @@ type_specs: type_spec: any_identifier arrays { - $$ = vkd3d_calloc(1, sizeof(*$$)); + $$ = hlsl_alloc(ctx, sizeof(*$$)); $$->loc = @1; $$->name = $1; $$->arrays = $2; @@ -2312,7 +2311,7 @@ variables_def_optional: variables_def: variable_def { - if (!($$ = make_empty_list())) + if (!($$ = make_empty_list(ctx))) YYABORT; list_add_head($$, &$1->entry); } @@ -2325,7 +2324,7 @@ variables_def: variable_def: any_identifier arrays colon_attribute { - $$ = vkd3d_calloc(1, sizeof(*$$)); + $$ = hlsl_alloc(ctx, sizeof(*$$)); $$->loc = @1; $$->name = $1; $$->arrays = $2; @@ -2334,7 +2333,7 @@ variable_def: } | any_identifier arrays colon_attribute '=' complex_initializer { - $$ = vkd3d_calloc(1, sizeof(*$$)); + $$ = hlsl_alloc(ctx, sizeof(*$$)); $$->loc = @1; $$->name = $1; $$->arrays = $2; @@ -2437,7 +2436,7 @@ complex_initializer: initializer_expr { $$.args_count = 1; - if (!($$.args = vkd3d_malloc(sizeof(*$$.args)))) + if (!($$.args = hlsl_alloc(ctx, sizeof(*$$.args)))) YYABORT; $$.args[0] = node_from_list($1); $$.instrs = $1; @@ -2458,7 +2457,7 @@ initializer_expr_list: initializer_expr { $$.args_count = 1; - if (!($$.args = vkd3d_malloc(sizeof(*$$.args)))) + if (!($$.args = hlsl_alloc(ctx, sizeof(*$$.args)))) YYABORT; $$.args[0] = node_from_list($1); $$.instrs = $1; @@ -2509,7 +2508,7 @@ jump_statement: } | KW_RETURN ';' { - if (!($$ = make_empty_list())) + if (!($$ = make_empty_list(ctx))) YYABORT; if (!add_return(ctx, $$, NULL, @1)) YYABORT; @@ -2521,7 +2520,7 @@ selection_statement: struct hlsl_ir_node *condition = node_from_list($3); struct hlsl_ir_if *instr; - if (!(instr = hlsl_new_if(condition, @1))) + if (!(instr = hlsl_new_if(ctx, condition, @1))) YYABORT; list_move_tail(&instr->then_instrs, $5.then_instrs); list_move_tail(&instr->else_instrs, $5.else_instrs); @@ -2555,27 +2554,27 @@ if_body: loop_statement: KW_WHILE '(' expr ')' statement { - $$ = create_loop(LOOP_WHILE, NULL, $3, NULL, $5, @1); + $$ = create_loop(ctx, LOOP_WHILE, NULL, $3, NULL, $5, @1); } | KW_DO statement KW_WHILE '(' expr ')' ';' { - $$ = create_loop(LOOP_DO_WHILE, NULL, $5, NULL, $2, @1); + $$ = create_loop(ctx, LOOP_DO_WHILE, NULL, $5, NULL, $2, @1); } | KW_FOR '(' scope_start expr_statement expr_statement expr ')' statement { - $$ = create_loop(LOOP_FOR, $4, $5, $6, $8, @1); + $$ = create_loop(ctx, LOOP_FOR, $4, $5, $6, $8, @1); hlsl_pop_scope(ctx); } | KW_FOR '(' scope_start declaration expr_statement expr ')' statement { - $$ = create_loop(LOOP_FOR, $4, $5, $6, $8, @1); + $$ = create_loop(ctx, LOOP_FOR, $4, $5, $6, $8, @1); hlsl_pop_scope(ctx); } expr_statement: ';' { - if (!($$ = make_empty_list())) + if (!($$ = make_empty_list(ctx))) YYABORT; } | expr ';' @@ -2588,33 +2587,33 @@ primary_expr: { struct hlsl_ir_constant *c; - if (!(c = vkd3d_malloc(sizeof(*c)))) + if (!(c = hlsl_alloc(ctx, sizeof(*c)))) YYABORT; init_node(&c->node, HLSL_IR_CONSTANT, ctx->builtin_types.scalar[HLSL_TYPE_FLOAT], @1); c->value.f[0] = $1; - if (!($$ = make_list(&c->node))) + if (!($$ = make_list(ctx, &c->node))) YYABORT; } | C_INTEGER { struct hlsl_ir_constant *c; - if (!(c = vkd3d_malloc(sizeof(*c)))) + if (!(c = hlsl_alloc(ctx, sizeof(*c)))) YYABORT; init_node(&c->node, HLSL_IR_CONSTANT, ctx->builtin_types.scalar[HLSL_TYPE_INT], @1); c->value.i[0] = $1; - if (!($$ = make_list(&c->node))) + if (!($$ = make_list(ctx, &c->node))) YYABORT; } | boolean { struct hlsl_ir_constant *c; - if (!(c = vkd3d_malloc(sizeof(*c)))) + if (!(c = hlsl_alloc(ctx, sizeof(*c)))) YYABORT; init_node(&c->node, HLSL_IR_CONSTANT, ctx->builtin_types.scalar[HLSL_TYPE_BOOL], @1); c->value.b[0] = $1; - if (!($$ = make_list(&c->node))) + if (!($$ = make_list(ctx, &c->node))) YYABORT; } | VAR_IDENTIFIER @@ -2627,9 +2626,9 @@ primary_expr: hlsl_error(ctx, @1, VKD3D_SHADER_ERROR_HLSL_NOT_DEFINED, "Variable \"%s\" is not defined.", $1); YYABORT; } - if ((load = hlsl_new_var_load(var, @1))) + if ((load = hlsl_new_var_load(ctx, var, @1))) { - if (!($$ = make_list(&load->node))) + if (!($$ = make_list(ctx, &load->node))) YYABORT; } else @@ -2711,7 +2710,7 @@ postfix_expr: YYABORT; } - if (!(cast = hlsl_new_cast(index, ctx->builtin_types.scalar[HLSL_TYPE_UINT], &index->loc))) + if (!(cast = hlsl_new_cast(ctx, index, ctx->builtin_types.scalar[HLSL_TYPE_UINT], &index->loc))) { hlsl_free_instr_list($1); YYABORT; @@ -2793,14 +2792,14 @@ postfix_expr: ctx->builtin_types.vector[$2->base_type][width - 1], &arg->loc))) continue; - if (!(store = hlsl_new_store(var, NULL, arg, + if (!(store = hlsl_new_store(ctx, var, NULL, arg, ((1 << width) - 1) << writemask_offset, arg->loc))) YYABORT; writemask_offset += width; list_add_tail($4.instrs, &store->node.entry); } vkd3d_free($4.args); - if (!(load = hlsl_new_var_load(var, @2))) + if (!(load = hlsl_new_var_load(ctx, var, @2))) YYABORT; $$ = append_unop($4.instrs, &load->node); } @@ -2833,7 +2832,7 @@ unary_expr: if ($1 == UNARY_OP_PLUS) $$ = $2; else - $$ = append_unop($2, hlsl_new_unary_expr(ops[$1], node_from_list($2), @1)); + $$ = append_unop($2, hlsl_new_unary_expr(ctx, ops[$1], node_from_list($2), @1)); } /* var_modifiers is necessary to avoid shift/reduce conflicts. */ @@ -2868,7 +2867,7 @@ unary_expr: YYABORT; } - $$ = append_unop($6, &hlsl_new_cast(node_from_list($6), dst_type, &@3)->node); + $$ = append_unop($6, &hlsl_new_cast(ctx, node_from_list($6), dst_type, &@3)->node); } unary_op: diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index c2cedd2a..1705529e 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -35,11 +35,8 @@ static void prepend_uniform_copy(struct hlsl_ctx *ctx, struct list *instrs, stru /* Use the synthetic name for the temp, rather than the uniform, so that we * can write the uniform name into the shader reflection data. */ - if (!(uniform = hlsl_new_var(temp->name, temp->data_type, temp->loc, NULL, 0, temp->reg_reservation))) - { - ctx->failed = true; + if (!(uniform = hlsl_new_var(ctx, temp->name, temp->data_type, temp->loc, NULL, 0, temp->reg_reservation))) return; - } list_add_before(&temp->scope_entry, &uniform->scope_entry); list_add_tail(&ctx->extern_vars, &uniform->extern_entry); uniform->is_uniform = 1; @@ -51,21 +48,15 @@ static void prepend_uniform_copy(struct hlsl_ctx *ctx, struct list *instrs, stru return; } vkd3d_string_buffer_printf(name, "<temp-%s>", temp->name); - temp->name = vkd3d_strdup(name->buffer); + temp->name = hlsl_strdup(ctx, name->buffer); vkd3d_string_buffer_release(&ctx->string_buffers, name); - if (!(load = hlsl_new_var_load(uniform, temp->loc))) - { - ctx->failed = true; + if (!(load = hlsl_new_var_load(ctx, uniform, temp->loc))) return; - } list_add_head(instrs, &load->node.entry); - if (!(store = hlsl_new_simple_store(temp, &load->node))) - { - ctx->failed = true; + if (!(store = hlsl_new_simple_store(ctx, temp, &load->node))) return; - } list_add_after(&load->node.entry, &store->node.entry); } @@ -85,18 +76,16 @@ static void prepend_input_copy(struct hlsl_ctx *ctx, struct list *instrs, struct return; } vkd3d_string_buffer_printf(name, "<input-%s%u>", semantic->name, semantic->index); - if (!(new_semantic.name = vkd3d_strdup(semantic->name))) + if (!(new_semantic.name = hlsl_strdup(ctx, semantic->name))) { vkd3d_string_buffer_release(&ctx->string_buffers, name); - ctx->failed = true; return; } new_semantic.index = semantic->index; - if (!(input = hlsl_new_var(vkd3d_strdup(name->buffer), type, var->loc, &new_semantic, 0, NULL))) + if (!(input = hlsl_new_var(ctx, hlsl_strdup(ctx, name->buffer), type, var->loc, &new_semantic, 0, NULL))) { vkd3d_string_buffer_release(&ctx->string_buffers, name); vkd3d_free((void *)new_semantic.name); - ctx->failed = true; return; } vkd3d_string_buffer_release(&ctx->string_buffers, name); @@ -105,25 +94,16 @@ static void prepend_input_copy(struct hlsl_ctx *ctx, struct list *instrs, struct list_add_before(&var->scope_entry, &input->scope_entry); list_add_tail(&ctx->extern_vars, &input->extern_entry); - if (!(load = hlsl_new_var_load(input, var->loc))) - { - ctx->failed = true; + if (!(load = hlsl_new_var_load(ctx, input, var->loc))) return; - } list_add_head(instrs, &load->node.entry); if (!(offset = hlsl_new_uint_constant(ctx, field_offset * 4, var->loc))) - { - ctx->failed = true; return; - } list_add_after(&load->node.entry, &offset->node.entry); - if (!(store = hlsl_new_store(var, &offset->node, &load->node, 0, var->loc))) - { - ctx->failed = true; + if (!(store = hlsl_new_store(ctx, var, &offset->node, &load->node, 0, var->loc))) return; - } list_add_after(&offset->node.entry, &store->node.entry); } @@ -170,18 +150,16 @@ static void append_output_copy(struct hlsl_ctx *ctx, struct list *instrs, struct return; } vkd3d_string_buffer_printf(name, "<output-%s%u>", semantic->name, semantic->index); - if (!(new_semantic.name = vkd3d_strdup(semantic->name))) + if (!(new_semantic.name = hlsl_strdup(ctx, semantic->name))) { vkd3d_string_buffer_release(&ctx->string_buffers, name); - ctx->failed = true; return; } new_semantic.index = semantic->index; - if (!(output = hlsl_new_var(vkd3d_strdup(name->buffer), type, var->loc, &new_semantic, 0, NULL))) + if (!(output = hlsl_new_var(ctx, hlsl_strdup(ctx, name->buffer), type, var->loc, &new_semantic, 0, NULL))) { vkd3d_free((void *)new_semantic.name); vkd3d_string_buffer_release(&ctx->string_buffers, name); - ctx->failed = true; return; } vkd3d_string_buffer_release(&ctx->string_buffers, name); @@ -191,24 +169,15 @@ static void append_output_copy(struct hlsl_ctx *ctx, struct list *instrs, struct list_add_tail(&ctx->extern_vars, &output->extern_entry); if (!(offset = hlsl_new_uint_constant(ctx, field_offset * 4, var->loc))) - { - ctx->failed = true; return; - } list_add_tail(instrs, &offset->node.entry); - if (!(load = hlsl_new_load(var, &offset->node, type, var->loc))) - { - ctx->failed = true; + if (!(load = hlsl_new_load(ctx, var, &offset->node, type, var->loc))) return; - } list_add_after(&offset->node.entry, &load->node.entry); - if (!(store = hlsl_new_store(output, NULL, &load->node, 0, var->loc))) - { - ctx->failed = true; + if (!(store = hlsl_new_store(ctx, output, NULL, &load->node, 0, var->loc))) return; - } list_add_after(&load->node.entry, &store->node.entry); } @@ -331,47 +300,32 @@ static bool split_struct_copies(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr struct hlsl_ir_constant *c; if (!(c = hlsl_new_uint_constant(ctx, field->reg_offset * 4, instr->loc))) - { - ctx->failed = true; return false; - } list_add_before(&instr->entry, &c->node.entry); offset = &c->node; if (rhs_load->src.offset.node) { - if (!(add = hlsl_new_binary_expr(HLSL_IR_BINOP_ADD, rhs_load->src.offset.node, &c->node))) - { - ctx->failed = true; + if (!(add = hlsl_new_binary_expr(ctx, HLSL_IR_BINOP_ADD, rhs_load->src.offset.node, &c->node))) return false; - } list_add_before(&instr->entry, &add->entry); offset = add; } - if (!(field_load = hlsl_new_load(rhs_load->src.var, offset, field->type, instr->loc))) - { - ctx->failed = true; + if (!(field_load = hlsl_new_load(ctx, rhs_load->src.var, offset, field->type, instr->loc))) return false; - } list_add_before(&instr->entry, &field_load->node.entry); offset = &c->node; if (store->lhs.offset.node) { - if (!(add = hlsl_new_binary_expr(HLSL_IR_BINOP_ADD, store->lhs.offset.node, &c->node))) - { - ctx->failed = true; + if (!(add = hlsl_new_binary_expr(ctx, HLSL_IR_BINOP_ADD, store->lhs.offset.node, &c->node))) return false; - } list_add_before(&instr->entry, &add->entry); offset = add; } - if (!(field_store = hlsl_new_store(store->lhs.var, offset, &field_load->node, 0, instr->loc))) - { - ctx->failed = true; + if (!(field_store = hlsl_new_store(ctx, store->lhs.var, offset, &field_load->node, 0, instr->loc))) return false; - } list_add_before(&instr->entry, &field_store->node.entry); } @@ -402,11 +356,8 @@ static bool fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, voi if (expr->operands[1].node) arg2 = hlsl_ir_constant(expr->operands[1].node); - if (!(res = vkd3d_calloc(1, sizeof(*res)))) - { - ctx->failed = true; + if (!(res = hlsl_alloc(ctx, sizeof(*res)))) return false; - } init_node(&res->node, HLSL_IR_CONSTANT, instr->data_type, instr->loc); switch (instr->data_type->base_type) @@ -657,11 +608,11 @@ static unsigned int get_available_writemask(struct liveness *liveness, return 0; } -static bool resize_liveness(struct liveness *liveness, size_t new_count) +static bool resize_liveness(struct hlsl_ctx *ctx, struct liveness *liveness, size_t new_count) { size_t old_capacity = liveness->size; - if (!vkd3d_array_reserve((void **)&liveness->regs, &liveness->size, new_count, sizeof(*liveness->regs))) + if (!hlsl_array_reserve(ctx, (void **)&liveness->regs, &liveness->size, new_count, sizeof(*liveness->regs))) return false; if (liveness->size > old_capacity) @@ -669,7 +620,7 @@ static bool resize_liveness(struct liveness *liveness, size_t new_count) return true; } -static struct hlsl_reg allocate_register(struct liveness *liveness, +static struct hlsl_reg allocate_register(struct hlsl_ctx *ctx, struct liveness *liveness, unsigned int first_write, unsigned int last_read, unsigned int component_count) { unsigned int component_idx, writemask, i; @@ -682,7 +633,7 @@ static struct hlsl_reg allocate_register(struct liveness *liveness, } if (component_idx == liveness->size) { - if (!resize_liveness(liveness, component_idx + 4)) + if (!resize_liveness(ctx, liveness, component_idx + 4)) return ret; writemask = (1u << component_count) - 1; } @@ -710,7 +661,7 @@ static bool is_range_available(struct liveness *liveness, unsigned int first_wri return true; } -static struct hlsl_reg allocate_range(struct liveness *liveness, +static struct hlsl_reg allocate_range(struct hlsl_ctx *ctx, struct liveness *liveness, unsigned int first_write, unsigned int last_read, unsigned int reg_count) { const unsigned int component_count = reg_count * 4; @@ -723,7 +674,7 @@ static struct hlsl_reg allocate_range(struct liveness *liveness, min(component_count, liveness->size - component_idx))) break; } - if (!resize_liveness(liveness, component_idx + component_count)) + if (!resize_liveness(ctx, liveness, component_idx + component_count)) return ret; for (i = 0; i < component_count; ++i) @@ -741,7 +692,7 @@ static const char *debug_register(char class, struct hlsl_reg reg, const struct return vkd3d_dbg_sprintf("%c%u%s", class, reg.id, debug_hlsl_writemask(reg.writemask)); } -static void allocate_variable_temp_register(struct hlsl_ir_var *var, struct liveness *liveness) +static void allocate_variable_temp_register(struct hlsl_ctx *ctx, struct hlsl_ir_var *var, struct liveness *liveness) { if (var->is_input_semantic || var->is_output_semantic || var->is_uniform) return; @@ -749,17 +700,17 @@ static void allocate_variable_temp_register(struct hlsl_ir_var *var, struct live if (!var->reg.allocated && var->last_read) { if (var->data_type->reg_size > 1) - var->reg = allocate_range(liveness, var->first_write, + var->reg = allocate_range(ctx, liveness, var->first_write, var->last_read, var->data_type->reg_size); else - var->reg = allocate_register(liveness, var->first_write, + var->reg = allocate_register(ctx, liveness, var->first_write, var->last_read, var->data_type->dimx); TRACE("Allocated %s to %s (liveness %u-%u).\n", var->name, debug_register('r', var->reg, var->data_type), var->first_write, var->last_read); } } -static void allocate_temp_registers_recurse(struct list *instrs, struct liveness *liveness) +static void allocate_temp_registers_recurse(struct hlsl_ctx *ctx, struct list *instrs, struct liveness *liveness) { struct hlsl_ir_node *instr; @@ -768,10 +719,10 @@ static void allocate_temp_registers_recurse(struct list *instrs, struct liveness if (!instr->reg.allocated && instr->last_read) { if (instr->data_type->reg_size > 1) - instr->reg = allocate_range(liveness, instr->index, + instr->reg = allocate_range(ctx, liveness, instr->index, instr->last_read, instr->data_type->reg_size); else - instr->reg = allocate_register(liveness, instr->index, + instr->reg = allocate_register(ctx, liveness, instr->index, instr->last_read, instr->data_type->dimx); TRACE("Allocated anonymous expression @%u to %s (liveness %u-%u).\n", instr->index, debug_register('r', instr->reg, instr->data_type), instr->index, instr->last_read); @@ -782,8 +733,8 @@ static void allocate_temp_registers_recurse(struct list *instrs, struct liveness case HLSL_IR_IF: { struct hlsl_ir_if *iff = hlsl_ir_if(instr); - allocate_temp_registers_recurse(&iff->then_instrs, liveness); - allocate_temp_registers_recurse(&iff->else_instrs, liveness); + allocate_temp_registers_recurse(ctx, &iff->then_instrs, liveness); + allocate_temp_registers_recurse(ctx, &iff->else_instrs, liveness); break; } @@ -792,21 +743,21 @@ static void allocate_temp_registers_recurse(struct list *instrs, struct liveness struct hlsl_ir_load *load = hlsl_ir_load(instr); /* We need to at least allocate a variable for undefs. * FIXME: We should probably find a way to remove them instead. */ - allocate_variable_temp_register(load->src.var, liveness); + allocate_variable_temp_register(ctx, load->src.var, liveness); break; } case HLSL_IR_LOOP: { struct hlsl_ir_loop *loop = hlsl_ir_loop(instr); - allocate_temp_registers_recurse(&loop->body, liveness); + allocate_temp_registers_recurse(ctx, &loop->body, liveness); break; } case HLSL_IR_STORE: { struct hlsl_ir_store *store = hlsl_ir_store(instr); - allocate_variable_temp_register(store->lhs.var, liveness); + allocate_variable_temp_register(ctx, store->lhs.var, liveness); break; } @@ -833,17 +784,14 @@ static void allocate_const_registers_recurse(struct hlsl_ctx *ctx, struct list * unsigned int x, y, i, writemask; if (reg_size > 1) - constant->reg = allocate_range(liveness, 1, UINT_MAX, reg_size); + constant->reg = allocate_range(ctx, liveness, 1, UINT_MAX, reg_size); else - constant->reg = allocate_register(liveness, 1, UINT_MAX, type->dimx); + constant->reg = allocate_register(ctx, liveness, 1, UINT_MAX, type->dimx); TRACE("Allocated constant @%u to %s.\n", instr->index, debug_register('c', constant->reg, type)); - if (!vkd3d_array_reserve((void **)&defs->values, &defs->size, + if (!hlsl_array_reserve(ctx, (void **)&defs->values, &defs->size, constant->reg.id + reg_size, sizeof(*defs->values))) - { - ctx->failed = true; return; - } defs->count = max(defs->count, constant->reg.id + reg_size); assert(type->type <= HLSL_CLASS_LAST_NUMERIC); @@ -927,10 +875,10 @@ static void allocate_const_registers(struct hlsl_ctx *ctx, struct hlsl_ir_functi if (var->is_uniform && var->last_read) { if (var->data_type->reg_size > 1) - var->reg = allocate_range(&liveness, 1, UINT_MAX, var->data_type->reg_size); + var->reg = allocate_range(ctx, &liveness, 1, UINT_MAX, var->data_type->reg_size); else { - var->reg = allocate_register(&liveness, 1, UINT_MAX, 4); + var->reg = allocate_register(ctx, &liveness, 1, UINT_MAX, 4); var->reg.writemask = (1u << var->data_type->dimx) - 1; } TRACE("Allocated %s to %s.\n", var->name, debug_register('c', var->reg, var->data_type)); @@ -942,10 +890,10 @@ static void allocate_const_registers(struct hlsl_ctx *ctx, struct hlsl_ir_functi * index to all (simultaneously live) variables or intermediate values. Agnostic * as to how many registers are actually available for the current backend, and * does not handle constants. */ -static void allocate_temp_registers(struct hlsl_ir_function_decl *entry_func) +static void allocate_temp_registers(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func) { struct liveness liveness = {0}; - allocate_temp_registers_recurse(entry_func->body, &liveness); + allocate_temp_registers_recurse(ctx, entry_func->body, &liveness); } static bool sm1_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semantic *semantic, bool output, @@ -1216,6 +1164,7 @@ static struct hlsl_reg hlsl_reg_from_deref(const struct hlsl_deref *deref, const struct bytecode_buffer { + struct hlsl_ctx *ctx; uint32_t *data; size_t count, size; int status; @@ -1229,7 +1178,8 @@ static unsigned int put_dword(struct bytecode_buffer *buffer, uint32_t value) if (buffer->status) return index; - if (!vkd3d_array_reserve((void **)&buffer->data, &buffer->size, buffer->count + 1, sizeof(*buffer->data))) + if (!hlsl_array_reserve(buffer->ctx, (void **)&buffer->data, &buffer->size, + buffer->count + 1, sizeof(*buffer->data))) { buffer->status = VKD3D_ERROR_OUT_OF_MEMORY; return index; @@ -1270,7 +1220,8 @@ static unsigned int put_string(struct bytecode_buffer *buffer, const char *str) if (buffer->status) return index; - if (!vkd3d_array_reserve((void **)&buffer->data, &buffer->size, buffer->count + token_count, sizeof(*buffer->data))) + if (!hlsl_array_reserve(buffer->ctx, (void **)&buffer->data, &buffer->size, + buffer->count + token_count, sizeof(*buffer->data))) { buffer->status = E_OUTOFMEMORY; return index; @@ -1478,7 +1429,7 @@ static void write_sm1_uniforms(struct hlsl_ctx *ctx, struct bytecode_buffer *buf } vkd3d_string_buffer_printf(name, "$%s", var->name); vkd3d_free((char *)var->name); - var->name = vkd3d_strdup(name->buffer); + var->name = hlsl_strdup(ctx, name->buffer); vkd3d_string_buffer_release(&ctx->string_buffers, name); } } @@ -1936,7 +1887,7 @@ static void write_sm1_instructions(struct hlsl_ctx *ctx, struct bytecode_buffer static int write_sm1_shader(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func, struct vkd3d_shader_code *out) { - struct bytecode_buffer buffer = {0}; + struct bytecode_buffer buffer = {.ctx = ctx}; int ret; put_dword(&buffer, sm1_version(ctx->profile->type, ctx->profile->major_version, ctx->profile->minor_version)); @@ -2018,7 +1969,7 @@ int hlsl_emit_dxbc(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_fun if (TRACE_ON()) rb_for_each_entry(&ctx->functions, dump_function, NULL); - allocate_temp_registers(entry_func); + allocate_temp_registers(ctx, entry_func); if (ctx->profile->major_version < 4) allocate_const_registers(ctx, entry_func); allocate_semantic_registers(ctx); -- 2.31.1

4 15

[PATCH 5/5] wordpad: Enable visual styles.
by Zhiyi Zhang 11 Jun '21

11 Jun '21

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- programs/wordpad/wordpad.manifest | 16 ++++++++++++++++ programs/wordpad/wordpad.rc | 3 +++ 2 files changed, 19 insertions(+) create mode 100644 programs/wordpad/wordpad.manifest diff --git a/programs/wordpad/wordpad.manifest b/programs/wordpad/wordpad.manifest new file mode 100644 index 00000000000..51fb21fa97d --- /dev/null +++ b/programs/wordpad/wordpad.manifest @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> +<assemblyIdentity type="win32" name="Wine.Wordpad" version="0.0.0.0"/> +<dependency> + <dependentAssembly> + <assemblyIdentity + type="win32" + name="Microsoft.Windows.Common-Controls" + version="6.0.0.0" + processorArchitecture="*" + publicKeyToken="6595b64144ccf1df" + language="*" + /> + </dependentAssembly> +</dependency> +</assembly> diff --git a/programs/wordpad/wordpad.rc b/programs/wordpad/wordpad.rc index abf9ed9c50a..324b6d06d53 100644 --- a/programs/wordpad/wordpad.rc +++ b/programs/wordpad/wordpad.rc @@ -301,6 +301,9 @@ END LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL +/* @makedep: wordpad.manifest */ +1 RT_MANIFEST wordpad.manifest + /* @makedep: toolbar.bmp */ IDB_TOOLBAR BITMAP "toolbar.bmp" -- 2.30.2

1 0

[PATCH 4/5] winver: Enable visual styles.
by Zhiyi Zhang 11 Jun '21

11 Jun '21

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- programs/winver/Makefile.in | 2 +- programs/winver/version.rc | 5 +++++ programs/winver/winver.c | 3 +++ programs/winver/winver.manifest | 16 ++++++++++++++++ 4 files changed, 25 insertions(+), 1 deletion(-) create mode 100644 programs/winver/winver.manifest diff --git a/programs/winver/Makefile.in b/programs/winver/Makefile.in index 0caef713865..8f74ab774df 100644 --- a/programs/winver/Makefile.in +++ b/programs/winver/Makefile.in @@ -1,5 +1,5 @@ MODULE = winver.exe -IMPORTS = shell32 +IMPORTS = shell32 comctl32 EXTRADLLFLAGS = -mwindows -mno-cygwin diff --git a/programs/winver/version.rc b/programs/winver/version.rc index ae042fb82a0..c079dde644a 100644 --- a/programs/winver/version.rc +++ b/programs/winver/version.rc @@ -15,6 +15,8 @@ * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include <windef.h> +#include <winuser.h> #define WINE_FILEDESCRIPTION_STR "Windows Version" #define WINE_FILENAME_STR "winver.exe" @@ -25,3 +27,6 @@ #define WINE_PRODUCTVERSION_STR "5.1.2600.0" #include "wine/wine_common_ver.rc" + +/* @makedep: winver.manifest */ +1 RT_MANIFEST winver.manifest diff --git a/programs/winver/winver.c b/programs/winver/winver.c index 019eb5248b2..ee3120443eb 100644 --- a/programs/winver/winver.c +++ b/programs/winver/winver.c @@ -19,6 +19,7 @@ */ #include "windows.h" +#include "commctrl.h" #include "shellapi.h" int PASCAL WinMain (HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show) @@ -26,6 +27,8 @@ int PASCAL WinMain (HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show) char name[128] = "Wine "; const char * (CDECL *wine_get_version)(void); + InitCommonControls(); + wine_get_version = (void *)GetProcAddress( GetModuleHandleA("ntdll.dll"), "wine_get_version" ); if (wine_get_version) strcat( name, wine_get_version() ); return !ShellAboutA( NULL, name, NULL, 0 ); diff --git a/programs/winver/winver.manifest b/programs/winver/winver.manifest new file mode 100644 index 00000000000..519bd175c19 --- /dev/null +++ b/programs/winver/winver.manifest @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> +<assemblyIdentity type="win32" name="Wine.Winver" version="0.0.0.0"/> +<dependency> + <dependentAssembly> + <assemblyIdentity + type="win32" + name="Microsoft.Windows.Common-Controls" + version="6.0.0.0" + processorArchitecture="*" + publicKeyToken="6595b64144ccf1df" + language="*" + /> + </dependentAssembly> +</dependency> +</assembly> -- 2.30.2

1 0

[PATCH 3/5] winevdm: Enable visual styles.
by Zhiyi Zhang 11 Jun '21

11 Jun '21

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- programs/winevdm/Makefile.in | 4 +++- programs/winevdm/winevdm.c | 3 +++ programs/winevdm/winevdm.manifest | 16 ++++++++++++++++ programs/winevdm/winevdm.rc | 25 +++++++++++++++++++++++++ 4 files changed, 47 insertions(+), 1 deletion(-) create mode 100644 programs/winevdm/winevdm.manifest create mode 100644 programs/winevdm/winevdm.rc diff --git a/programs/winevdm/Makefile.in b/programs/winevdm/Makefile.in index 0ea89f4b0de..c841f3c4d46 100644 --- a/programs/winevdm/Makefile.in +++ b/programs/winevdm/Makefile.in @@ -1,6 +1,8 @@ MODULE = winevdm.exe APPMODE = -mwindows -IMPORTS = user32 kernel +IMPORTS = user32 kernel comctl32 C_SRCS = \ winevdm.c + +RC_SRCS = winevdm.rc diff --git a/programs/winevdm/winevdm.c b/programs/winevdm/winevdm.c index 0a43e579793..1ab91f41d66 100644 --- a/programs/winevdm/winevdm.c +++ b/programs/winevdm/winevdm.c @@ -30,6 +30,7 @@ #include "wine/winbase16.h" #include "winuser.h" #include "wincon.h" +#include "commctrl.h" #include "wine/unicode.h" #include "wine/debug.h" @@ -504,6 +505,8 @@ int main( int argc, char *argv[] ) char *cmdline, *appname, **first_arg; char *p; + InitCommonControls(); + if (!argv[1]) usage(); if (!strcmp( argv[1], "--app-name" )) diff --git a/programs/winevdm/winevdm.manifest b/programs/winevdm/winevdm.manifest new file mode 100644 index 00000000000..9634ec55524 --- /dev/null +++ b/programs/winevdm/winevdm.manifest @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> +<assemblyIdentity type="win32" name="Wine.Winevdm" version="0.0.0.0"/> +<dependency> + <dependentAssembly> + <assemblyIdentity + type="win32" + name="Microsoft.Windows.Common-Controls" + version="6.0.0.0" + processorArchitecture="*" + publicKeyToken="6595b64144ccf1df" + language="*" + /> + </dependentAssembly> +</dependency> +</assembly> diff --git a/programs/winevdm/winevdm.rc b/programs/winevdm/winevdm.rc new file mode 100644 index 00000000000..5ccf9e47151 --- /dev/null +++ b/programs/winevdm/winevdm.rc @@ -0,0 +1,25 @@ +/* + * Winevdm resources + * + * Copyright 2021 Zhiyi Zhang for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <windef.h> +#include <winuser.h> + +/* @makedep: winevdm.manifest */ +1 RT_MANIFEST winevdm.manifest -- 2.30.2

1 0

[PATCH 2/5] winemine: Enable visual styles.
by Zhiyi Zhang 11 Jun '21

11 Jun '21

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- programs/winemine/Makefile.in | 2 +- programs/winemine/main.c | 3 +++ programs/winemine/winemine.manifest | 16 ++++++++++++++++ programs/winemine/winemine.rc | 3 +++ 4 files changed, 23 insertions(+), 1 deletion(-) create mode 100644 programs/winemine/winemine.manifest diff --git a/programs/winemine/Makefile.in b/programs/winemine/Makefile.in index 8f5aebd9645..5ae0eaf2c62 100644 --- a/programs/winemine/Makefile.in +++ b/programs/winemine/Makefile.in @@ -1,5 +1,5 @@ MODULE = winemine.exe -IMPORTS = user32 gdi32 advapi32 +IMPORTS = user32 gdi32 advapi32 comctl32 DELAYIMPORTS = shell32 EXTRADLLFLAGS = -mwindows -municode -mno-cygwin diff --git a/programs/winemine/main.c b/programs/winemine/main.c index 37ce1927047..cd0763042d3 100644 --- a/programs/winemine/main.c +++ b/programs/winemine/main.c @@ -23,6 +23,7 @@ #include <string.h> #include <time.h> #include <windows.h> +#include <commctrl.h> #include <stdlib.h> #include <shellapi.h> #include "main.h" @@ -1012,6 +1013,8 @@ int WINAPI wWinMain( HINSTANCE hInst, HINSTANCE hPrevInst, LPWSTR cmdline, int c HACCEL haccel; WCHAR appname[20]; + InitCommonControls(); + LoadStringW( hInst, IDS_APPNAME, appname, ARRAY_SIZE(appname)); wc.cbSize = sizeof(wc); diff --git a/programs/winemine/winemine.manifest b/programs/winemine/winemine.manifest new file mode 100644 index 00000000000..8850b090e37 --- /dev/null +++ b/programs/winemine/winemine.manifest @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> +<assemblyIdentity type="win32" name="Wine.Winemine" version="0.0.0.0"/> +<dependency> + <dependentAssembly> + <assemblyIdentity + type="win32" + name="Microsoft.Windows.Common-Controls" + version="6.0.0.0" + processorArchitecture="*" + publicKeyToken="6595b64144ccf1df" + language="*" + /> + </dependentAssembly> +</dependency> +</assembly> diff --git a/programs/winemine/winemine.rc b/programs/winemine/winemine.rc index 5bbd68247b8..1e1bdeae5bc 100644 --- a/programs/winemine/winemine.rc +++ b/programs/winemine/winemine.rc @@ -105,6 +105,9 @@ IDA_WINEMINE ACCELERATORS LANGUAGE LANG_NEUTRAL,SUBLANG_NEUTRAL +/* @makedep: winemine.manifest */ +1 RT_MANIFEST winemine.manifest + /* @makedep: winemine.ico */ IDI_WINEMINE ICON winemine.ico -- 2.30.2

1 0

[PATCH 1/5] winefile: Enable visual styles.
by Zhiyi Zhang 11 Jun '21

11 Jun '21

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- programs/winefile/winefile.manifest | 16 ++++++++++++++++ programs/winefile/winefile.rc | 3 +++ 2 files changed, 19 insertions(+) create mode 100644 programs/winefile/winefile.manifest diff --git a/programs/winefile/winefile.manifest b/programs/winefile/winefile.manifest new file mode 100644 index 00000000000..4ebd48c8933 --- /dev/null +++ b/programs/winefile/winefile.manifest @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="UTF-8" standalone="yes"?> +<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> +<assemblyIdentity type="win32" name="Wine.Winefile" version="0.0.0.0"/> +<dependency> + <dependentAssembly> + <assemblyIdentity + type="win32" + name="Microsoft.Windows.Common-Controls" + version="6.0.0.0" + processorArchitecture="*" + publicKeyToken="6595b64144ccf1df" + language="*" + /> + </dependentAssembly> +</dependency> +</assembly> diff --git a/programs/winefile/winefile.rc b/programs/winefile/winefile.rc index 4420019ec56..8d0f9940787 100644 --- a/programs/winefile/winefile.rc +++ b/programs/winefile/winefile.rc @@ -195,6 +195,9 @@ IDA_WINEFILE ACCELERATORS LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL +/* @makedep: winefile.manifest */ +1 RT_MANIFEST winefile.manifest + /* @makedep: winefile.ico */ IDI_WINEFILE ICON winefile.ico -- 2.30.2

1 0

[PATCH 1/6] server: Do not return the socket state from get_socket_event.
by Zebediah Figura 11 Jun '21

11 Jun '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- server/protocol.def | 1 - server/sock.c | 1 - 2 files changed, 2 deletions(-) diff --git a/server/protocol.def b/server/protocol.def index 30624a7cbaf..3609261b848 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -1441,7 +1441,6 @@ enum server_fd_type @REPLY unsigned int mask; /* event mask */ unsigned int pmask; /* pending events */ - unsigned int state; /* status bits */ VARARG(errors,ints); /* event errors */ @END diff --git a/server/sock.c b/server/sock.c index b4649abbf08..bbd82d57bd5 100644 --- a/server/sock.c +++ b/server/sock.c @@ -2376,7 +2376,6 @@ DECL_HANDLER(get_socket_event) if (get_unix_fd( sock->fd ) == -1) return; reply->mask = sock->mask; reply->pmask = sock->pending_events; - reply->state = sock->state; set_reply_data( sock->errors, min( get_reply_max_size(), sizeof(sock->errors) )); if (req->service) -- 2.30.2

1 5

[PATCH v7 1/4] winevulkan: Support use of extensions which mustn't be exposed.
by Derek Lesho 10 Jun '21

10 Jun '21

Signed-off-by: Derek Lesho <dlesho(a)codeweavers.com> --- v7: Fixed typo whereupon the presence the of the is_required method was checked, rather than the return value. --- dlls/winevulkan/make_vulkan | 35 ++++++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 11 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 7f76d328fc8..34dd9fc432f 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -120,6 +120,11 @@ UNSUPPORTED_EXTENSIONS = [ "VK_NV_external_memory_win32", ] +# Either internal extensions which aren't present on the win32 platform which +# winevulkan may nonetheless use, or extensions we want to generate headers for +# but not expose to applications (useful for test commits) +UNEXPOSED_EXTENSIONS = {} + # The Vulkan loader provides entry-points for core functionality and important # extensions. Based on vulkan-1.def this amounts to WSI extensions on 1.0.51. CORE_EXTENSIONS = [ @@ -521,8 +526,8 @@ class VkEnumValue(object): class VkFunction(object): - def __init__(self, _type=None, name=None, params=[], extensions=[], alias=None): - self.extensions = [] + def __init__(self, _type=None, name=None, params=[], alias=None): + self.extensions = set() self.name = name self.type = _type self.params = params @@ -665,6 +670,10 @@ class VkFunction(object): def needs_private_thunk(self): return self.thunk_type == ThunkType.PRIVATE + def needs_exposing(self): + # The function needs exposed if at-least one extension isn't both UNSUPPORTED and UNEXPOSED + return self.is_required() and (not self.extensions or not self.extensions.issubset(UNEXPOSED_EXTENSIONS)) + def pfn(self, prefix="p", call_conv=None, conv=False): """ Create function pointer. """ @@ -2653,7 +2662,7 @@ class VkGenerator(object): # Create thunks for instance and device functions. # Global functions don't go through the thunks. for vk_func in self.registry.funcs.values(): - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue if vk_func.is_global_func(): @@ -2676,6 +2685,8 @@ class VkGenerator(object): for ext in self.registry.extensions: if ext["type"] != "device": continue + if ext["name"] in UNEXPOSED_EXTENSIONS: + continue f.write(" \"{0}\",\n".format(ext["name"])) f.write("};\n\n") @@ -2685,6 +2696,8 @@ class VkGenerator(object): for ext in self.registry.extensions: if ext["type"] != "instance": continue + if ext["name"] in UNEXPOSED_EXTENSIONS: + continue f.write(" \"{0}\",\n".format(ext["name"])) f.write("};\n\n") @@ -2744,7 +2757,7 @@ class VkGenerator(object): f.write("const struct unix_funcs loader_funcs =\n") f.write("{\n") for vk_func in self.registry.funcs.values(): - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue if vk_func.loader_thunk_type == ThunkType.NONE: continue @@ -2763,7 +2776,7 @@ class VkGenerator(object): # Generate prototypes for device and instance functions requiring a custom implementation. f.write("/* Functions for which we have custom implementations outside of the thunks. */\n") for vk_func in self.registry.funcs.values(): - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue if vk_func.needs_thunk() and not vk_func.needs_private_thunk(): continue @@ -2872,7 +2885,7 @@ class VkGenerator(object): f.write("WINE_DEFAULT_DEBUG_CHANNEL(vulkan);\n\n") for vk_func in self.registry.funcs.values(): - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue if vk_func.loader_thunk_type != ThunkType.PUBLIC: continue @@ -2881,7 +2894,7 @@ class VkGenerator(object): f.write("static const struct vulkan_func vk_device_dispatch_table[] =\n{\n") for vk_func in self.registry.device_funcs: - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue f.write(" {{\"{0}\", &{0}}},\n".format(vk_func.name)) @@ -2889,7 +2902,7 @@ class VkGenerator(object): f.write("static const struct vulkan_func vk_phys_dev_dispatch_table[] =\n{\n") for vk_func in self.registry.phys_dev_funcs: - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue f.write(" {{\"{0}\", &{0}}},\n".format(vk_func.name)) @@ -2897,7 +2910,7 @@ class VkGenerator(object): f.write("static const struct vulkan_func vk_instance_dispatch_table[] =\n{\n") for vk_func in self.registry.instance_funcs: - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue f.write(" {{\"{0}\", &{0}}},\n".format(vk_func.name)) @@ -2954,7 +2967,7 @@ class VkGenerator(object): f.write("struct unix_funcs\n") f.write("{\n") for vk_func in self.registry.funcs.values(): - if not vk_func.is_required(): + if not vk_func.needs_exposing(): continue if vk_func.loader_thunk_type == ThunkType.NONE: continue @@ -3447,7 +3460,7 @@ class VkRegistry(object): # the XML file to handle this, but because of the manner in which we parse the XML # file we pre-populate from <commands> before we check if a command is enabled. if cmd_name in self.funcs: - self.funcs[cmd_name].extensions.append(ext_name) + self.funcs[cmd_name].extensions.add(ext_name) # Some extensions are not ready or have numbers reserved as a place holder. if ext.attrib["supported"] == "disabled": -- 2.31.1

4 18

[PATCH 1/5] ws2_32/tests: Add more tests for calling functions on a connecting socket.
by Zebediah Figura 10 Jun '21

10 Jun '21

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/ws2_32/tests/sock.c | 73 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) diff --git a/dlls/ws2_32/tests/sock.c b/dlls/ws2_32/tests/sock.c index d9cb629caa4..6cfdced79dc 100644 --- a/dlls/ws2_32/tests/sock.c +++ b/dlls/ws2_32/tests/sock.c @@ -10219,25 +10219,51 @@ static void test_bind(void) /* Test calling methods on a socket which is currently connecting. */ static void test_connecting_socket(void) { + const struct sockaddr_in bind_addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_ANY)}; const struct sockaddr_in invalid_addr = { .sin_family = AF_INET, .sin_addr.s_addr = inet_addr("192.0.2.0"), .sin_port = 255 }; + OVERLAPPED overlapped = {0}, overlapped2 = {0}; + GUID connectex_guid = WSAID_CONNECTEX; + LPFN_CONNECTEX pConnectEx; struct sockaddr_in addr; char buffer[4]; SOCKET client; int ret, len; + DWORD size; client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError()); set_blocking(client, FALSE); + ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(!ret, "expected success\n"); + ok(!WSAGetLastError(), "got %u\n", WSAGetLastError()); + ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr)); ok(ret == -1, "got %d\n", ret); ok(WSAGetLastError() == WSAEWOULDBLOCK, "got %u\n", WSAGetLastError()); + /* Mortal Kombat 11 connects to the same address twice and expects the + * second to return WSAEALREADY. */ + ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr)); + ok(ret == -1, "got %d\n", ret); + todo_wine ok(WSAGetLastError() == WSAEALREADY, "got %u\n", WSAGetLastError()); + + ret = WSAIoctl(client, SIO_GET_EXTENSION_FUNCTION_POINTER, &connectex_guid, sizeof(connectex_guid), + &pConnectEx, sizeof(pConnectEx), &size, NULL, NULL); + ok(!ret, "failed to get ConnectEx, error %u\n", WSAGetLastError()); + overlapped.Internal = 0xdeadbeef; + overlapped.InternalHigh = 0xdeadbeef; + ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped); + ok(!ret, "got %d\n", ret); + todo_wine ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError()); + ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal); + todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh); + len = sizeof(addr); ret = getsockname(client, (struct sockaddr *)&addr, &len); ok(!ret, "got error %u\n", WSAGetLastError()); @@ -10263,6 +10289,53 @@ static void test_connecting_socket(void) todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError()); closesocket(client); + + /* Test with ConnectEx(). */ + + client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + ok(client != -1, "failed to create socket, error %u\n", WSAGetLastError()); + set_blocking(client, FALSE); + + ret = bind(client, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)); + ok(!ret, "expected success\n"); + ok(!WSAGetLastError(), "got %u\n", WSAGetLastError()); + + ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped2); + ok(!ret, "got %d\n", ret); + ok(WSAGetLastError() == ERROR_IO_PENDING, "got error %u\n", WSAGetLastError()); + + ret = connect(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr)); + ok(ret == -1, "got %d\n", ret); + ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError()); + + overlapped.Internal = 0xdeadbeef; + overlapped.InternalHigh = 0xdeadbeef; + ret = pConnectEx(client, (struct sockaddr *)&invalid_addr, sizeof(invalid_addr), NULL, 0, &size, &overlapped); + ok(!ret, "got %d\n", ret); + todo_wine ok(WSAGetLastError() == WSAEINVAL, "got %u\n", WSAGetLastError()); + ok((NTSTATUS)overlapped.Internal == STATUS_PENDING, "got status %#x\n", (NTSTATUS)overlapped.Internal); + todo_wine ok(overlapped.InternalHigh == 0xdeadbeef, "got size %Iu\n", overlapped.InternalHigh); + + len = sizeof(addr); + ret = getsockname(client, (struct sockaddr *)&addr, &len); + ok(!ret, "got error %u\n", WSAGetLastError()); + ok(addr.sin_family == AF_INET, "got family %u\n", addr.sin_family); + ok(addr.sin_port, "expected nonzero port\n"); + + len = sizeof(addr); + ret = getpeername(client, (struct sockaddr *)&addr, &len); + ok(ret == -1, "got %d\n", ret); + ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError()); + + ret = recv(client, buffer, sizeof(buffer), 0); + ok(ret == -1, "got %d\n", ret); + todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError()); + + ret = send(client, "data", 5, 0); + ok(ret == -1, "got %d\n", ret); + todo_wine ok(WSAGetLastError() == WSAENOTCONN, "got %u\n", WSAGetLastError()); + + closesocket(client); } static DWORD map_status( NTSTATUS status ) -- 2.30.2

2 6

[PATCH 3/3 v2] msvcrt: Import powf implementation from musl.
by Piotr Caban 10 Jun '21

10 Jun '21

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcrt/math.c | 177 ++++++++++++++++++++++++++++++++++++++++-- dlls/msvcrt/unixlib.c | 9 --- dlls/msvcrt/unixlib.h | 1 - 3 files changed, 171 insertions(+), 16 deletions(-)

1 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel