wine-devel

wine-devel@winehq.org

84463 discussions

Start a nNew thread

[PATCH 0/5] MR34: windows.media.speech: Changes for IAsyncAction.
by Bernhard Kölbl (＠besentv) 04 May '22

04 May '22

Signed-off-by: Bernhard Kölbl <besentv(a)gmail.com> -- https://gitlab.winehq.org/wine/wine/-/merge_requests/34

3 6

[PATCH 7/7] wineoss: Implement Wow64 aux entry point in the Unix library.
by Huw Davies 04 May '22

04 May '22

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/oss.c | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index 0c9fef90d58..e9616a84b36 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -1961,6 +1961,29 @@ static NTSTATUS wow64_set_event_handle(void *args) return STATUS_SUCCESS; } +static NTSTATUS wow64_aux_message(void *args) +{ + struct + { + UINT dev_id; + UINT msg; + UINT user; + UINT param_1; + UINT param_2; + PTR32 err; + } *params32 = args; + struct aux_message_params params = + { + .dev_id = params32->dev_id, + .msg = params32->msg, + .user = params32->user, + .param_1 = params32->param_1, + .param_2 = params32->param_2, + .err = ULongToPtr(params32->err), + }; + return aux_message(&params); +} + unixlib_entry_t __wine_unix_call_wow64_funcs[] = { test_connect, @@ -1990,7 +2013,7 @@ unixlib_entry_t __wine_unix_call_wow64_funcs[] = wow64_midi_out_message, wow64_midi_in_message, wow64_midi_notify_wait, - aux_message, + wow64_aux_message, }; #endif /* _WIN64 */ -- 2.25.1

2 1

[PATCH 6/7] wineoss: Implement Wow64 midi entry points in the Unix library.
by Huw Davies 04 May '22

04 May '22

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/oss.c | 6 +- dlls/wineoss.drv/ossmidi.c | 354 +++++++++++++++++++++++++++++++++++++ dlls/wineoss.drv/unixlib.h | 6 + 3 files changed, 363 insertions(+), 3 deletions(-) diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index 9f2cba68f86..0c9fef90d58 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -1987,9 +1987,9 @@ unixlib_entry_t __wine_unix_call_wow64_funcs[] = wow64_set_event_handle, is_started, midi_release, - midi_out_message, - midi_in_message, - midi_notify_wait, + wow64_midi_out_message, + wow64_midi_in_message, + wow64_midi_notify_wait, aux_message, }; diff --git a/dlls/wineoss.drv/ossmidi.c b/dlls/wineoss.drv/ossmidi.c index 6677609a5a6..09eed8085c4 100644 --- a/dlls/wineoss.drv/ossmidi.c +++ b/dlls/wineoss.drv/ossmidi.c @@ -1771,3 +1771,357 @@ NTSTATUS midi_notify_wait(void *args) return STATUS_SUCCESS; } + +#ifdef _WIN64 + +typedef UINT PTR32; + +struct notify_context32 +{ + BOOL send_notify; + WORD dev_id; + WORD msg; + UINT param_1; + UINT param_2; + UINT callback; + UINT flags; + PTR32 device; + UINT instance; +}; + +static void notify_to_notify32(struct notify_context32 *notify32, + const struct notify_context *notify) +{ + notify32->send_notify = notify->send_notify; + notify32->dev_id = notify->dev_id; + notify32->msg = notify->msg; + notify32->param_1 = notify->param_1; + notify32->param_2 = notify->param_2; + notify32->callback = notify->callback; + notify32->flags = notify->flags; + notify32->device = PtrToUlong(notify->device); + notify32->instance = notify->instance; +} + +struct midi_open_desc32 +{ + PTR32 hMidi; + UINT dwCallback; + UINT dwInstance; + UINT dnDevNode; + UINT cIds; + MIDIOPENSTRMID rgIds; +}; + +struct midi_hdr32 +{ + PTR32 lpData; + UINT dwBufferLength; + UINT dwBytesRecorded; + UINT dwUser; + UINT dwFlags; + PTR32 lpNext; + UINT reserved; + UINT dwOffset; + UINT dwReserved[8]; +}; + +static UINT wow64_midi_out_prepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (hdr->dwFlags & MHDR_PREPARED) + return MMSYSERR_NOERROR; + + hdr->lpNext = 0; + hdr->dwFlags |= MHDR_PREPARED; + hdr->dwFlags &= ~(MHDR_DONE | MHDR_INQUEUE); + return MMSYSERR_NOERROR; +} + +static UINT wow64_midi_out_unprepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (!(hdr->dwFlags & MHDR_PREPARED)) + return MMSYSERR_NOERROR; + if (hdr->dwFlags & MHDR_INQUEUE) + return MIDIERR_STILLPLAYING; + + hdr->dwFlags &= ~MHDR_PREPARED; + return MMSYSERR_NOERROR; +} + +NTSTATUS wow64_midi_out_message(void *args) +{ + struct + { + UINT dev_id; + UINT msg; + UINT user; + UINT param_1; + UINT param_2; + PTR32 err; + PTR32 notify; + } *params32 = args; + struct notify_context32 *notify32 = ULongToPtr(params32->notify); + struct midi_open_desc32 *desc32; + struct midi_hdr32 *hdr32; + struct notify_context notify; + MIDIOPENDESC open_desc; + MIDIHDR hdr; + struct midi_out_message_params params = + { + .dev_id = params32->dev_id, + .msg = params32->msg, + .user = params32->user, + .param_1 = params32->param_1, + .param_2 = params32->param_2, + .err = ULongToPtr(params32->err), + .notify = &notify + }; + notify32->send_notify = FALSE; + + switch (params32->msg) + { + case MODM_OPEN: + desc32 = ULongToPtr(params32->param_1); + + open_desc.hMidi = ULongToPtr(desc32->hMidi); + open_desc.dwCallback = desc32->dwCallback; + open_desc.dwInstance = desc32->dwInstance; + open_desc.dnDevNode = desc32->dnDevNode; + open_desc.cIds = desc32->cIds; + open_desc.rgIds.dwStreamID = desc32->rgIds.dwStreamID; + open_desc.rgIds.wDeviceID = desc32->rgIds.wDeviceID; + + params.param_1 = (UINT_PTR)&open_desc; + break; + + case MODM_LONGDATA: + hdr32 = ULongToPtr(params32->param_1); + + memset(&hdr, 0, sizeof(hdr)); + hdr.lpData = ULongToPtr(hdr32->lpData); + hdr.dwBufferLength = hdr32->dwBufferLength; + hdr.dwFlags = hdr32->dwFlags; + + params.param_1 = (UINT_PTR)&hdr; + params.param_2 = sizeof(hdr); + break; + + case MODM_PREPARE: /* prepare and unprepare are easier to handle explicitly */ + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_out_prepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + + case MODM_UNPREPARE: + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_out_unprepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + } + + midi_out_message(&params); + + switch (params32->msg) + { + case MODM_LONGDATA: + hdr32 = ULongToPtr(params32->param_1); + + hdr32->dwFlags = hdr.dwFlags; + break; + } + + if (notify.send_notify) + { + notify_to_notify32(notify32, &notify); + + if (notify.msg == MOM_DONE) + notify32->param_1 = params32->param_1; /* restore the 32-bit hdr */ + } + return STATUS_SUCCESS; +} + +static UINT wow64_midi_in_prepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (hdr->dwFlags & MHDR_PREPARED) + return MMSYSERR_NOERROR; + + hdr->lpNext = 0; + hdr->dwFlags |= MHDR_PREPARED; + hdr->dwFlags &= ~(MHDR_DONE | MHDR_INQUEUE); + + return MMSYSERR_NOERROR; +} + +static UINT wow64_midi_in_unprepare(WORD dev_id, struct midi_hdr32 *hdr, UINT hdr_size) +{ + TRACE("(%04X, %p, %d);\n", dev_id, hdr, hdr_size); + + if (hdr_size < offsetof(struct midi_hdr32, dwOffset) || !hdr || !hdr->lpData) + return MMSYSERR_INVALPARAM; + if (!(hdr->dwFlags & MHDR_PREPARED)) + return MMSYSERR_NOERROR; + if (hdr->dwFlags & MHDR_INQUEUE) + return MIDIERR_STILLPLAYING; + + hdr->dwFlags &= ~MHDR_PREPARED; + + return MMSYSERR_NOERROR; +} + +NTSTATUS wow64_midi_in_message(void *args) +{ + struct + { + UINT dev_id; + UINT msg; + UINT user; + UINT param_1; + UINT param_2; + PTR32 err; + PTR32 notify; + } *params32 = args; + struct notify_context32 *notify32 = ULongToPtr(params32->notify); + struct midi_open_desc32 *desc32; + struct midi_hdr32 *hdr32; + struct notify_context notify; + MIDIOPENDESC open_desc; + MIDIHDR *hdr = NULL; + struct midi_in_message_params params = + { + .dev_id = params32->dev_id, + .msg = params32->msg, + .user = params32->user, + .param_1 = params32->param_1, + .param_2 = params32->param_2, + .err = ULongToPtr(params32->err), + .notify = &notify + }; + notify32->send_notify = FALSE; + + switch (params32->msg) + { + case MIDM_OPEN: + desc32 = ULongToPtr(params32->param_1); + + open_desc.hMidi = ULongToPtr(desc32->hMidi); + open_desc.dwCallback = desc32->dwCallback; + open_desc.dwInstance = desc32->dwInstance; + open_desc.dnDevNode = desc32->dnDevNode; + open_desc.cIds = desc32->cIds; + open_desc.rgIds.dwStreamID = desc32->rgIds.dwStreamID; + open_desc.rgIds.wDeviceID = desc32->rgIds.wDeviceID; + + params.param_1 = (UINT_PTR)&open_desc; + break; + + case MIDM_ADDBUFFER: + hdr32 = ULongToPtr(params32->param_1); + + hdr = calloc(1, sizeof(*hdr)); + hdr->lpData = ULongToPtr(hdr32->lpData); + hdr->dwBufferLength = hdr32->dwBufferLength; + hdr->dwFlags = hdr32->dwFlags; + hdr->dwReserved[7] = params32->param_1; /* keep hdr32 for MIM_LONGDATA notification */ + + params.param_1 = (UINT_PTR)hdr; + params.param_2 = sizeof(*hdr); + break; + + case MIDM_PREPARE: /* prepare and unprepare are easier to handle explicitly */ + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_in_prepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + + case MIDM_UNPREPARE: + hdr32 = ULongToPtr(params32->param_1); + + *params.err = wow64_midi_in_unprepare(params32->dev_id, hdr32, params32->param_2); + return STATUS_SUCCESS; + } + + midi_in_message(&params); + + switch (params32->msg) + { + case MIDM_ADDBUFFER: + hdr32 = ULongToPtr(params32->param_1); + + if (!*params.err) + { + hdr32->dwFlags = hdr->dwFlags; + hdr32->dwBytesRecorded = hdr->dwBytesRecorded; + hdr32->lpNext = 0; + } + else + free(hdr); + break; + } + + if (notify.send_notify) + { + notify_to_notify32(notify32, &notify); + + if (notify.msg == MIM_LONGDATA) + { + hdr = (MIDIHDR *)notify.param_1; + notify32->param_1 = hdr->dwReserved[7]; + hdr32 = ULongToPtr(notify32->param_1); + hdr32->dwBytesRecorded = hdr->dwBytesRecorded; + hdr32->dwFlags = hdr->dwFlags; + free(hdr); + } + } + return STATUS_SUCCESS; +} + +NTSTATUS wow64_midi_notify_wait(void *args) +{ + struct + { + PTR32 quit; + PTR32 notify; + } *params32 = args; + struct notify_context32 *notify32 = ULongToPtr(params32->notify); + struct midi_hdr32 *hdr32; + struct notify_context notify; + MIDIHDR *hdr; + struct midi_notify_wait_params params = + { + .quit = ULongToPtr(params32->quit), + .notify = &notify + }; + notify32->send_notify = FALSE; + + midi_notify_wait(&params); + + if (!*params.quit && notify.send_notify) + { + notify_to_notify32(notify32, &notify); + + if (notify.msg == MIM_LONGDATA) + { + hdr = (MIDIHDR *)notify.param_1; + notify32->param_1 = hdr->dwReserved[7]; + hdr32 = ULongToPtr(notify32->param_1); + hdr32->dwBytesRecorded = hdr->dwBytesRecorded; + hdr32->dwFlags = hdr->dwFlags; + free(hdr); + } + } + return STATUS_SUCCESS; +} + +#endif /* _WIN64 */ diff --git a/dlls/wineoss.drv/unixlib.h b/dlls/wineoss.drv/unixlib.h index 208dec7f69d..e36c82ff35b 100644 --- a/dlls/wineoss.drv/unixlib.h +++ b/dlls/wineoss.drv/unixlib.h @@ -297,6 +297,12 @@ NTSTATUS midi_out_message(void *args) DECLSPEC_HIDDEN; NTSTATUS midi_in_message(void *args) DECLSPEC_HIDDEN; NTSTATUS midi_notify_wait(void *args) DECLSPEC_HIDDEN; +#ifdef _WIN64 +NTSTATUS wow64_midi_out_message(void *args) DECLSPEC_HIDDEN; +NTSTATUS wow64_midi_in_message(void *args) DECLSPEC_HIDDEN; +NTSTATUS wow64_midi_notify_wait(void *args) DECLSPEC_HIDDEN; +#endif + extern unixlib_handle_t oss_handle; #define OSS_CALL(func, params) __wine_unix_call(oss_handle, oss_ ## func, params) -- 2.25.1

2 1

[PATCH 5/7] wineoss: Implement Wow64 mmdevapi entry points in the Unix libraray.
by Huw Davies 04 May '22

04 May '22

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/oss.c | 353 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 353 insertions(+) diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index 40b8879ef47..9f2cba68f86 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -1641,3 +1641,356 @@ unixlib_entry_t __wine_unix_call_funcs[] = midi_notify_wait, aux_message, }; + +#ifdef _WIN64 + +typedef UINT PTR32; + +static NTSTATUS wow64_get_endpoint_ids(void *args) +{ + struct + { + EDataFlow flow; + PTR32 endpoints; + unsigned int size; + HRESULT result; + unsigned int num; + unsigned int default_idx; + } *params32 = args; + struct get_endpoint_ids_params params = + { + .flow = params32->flow, + .endpoints = ULongToPtr(params32->endpoints), + .size = params32->size + }; + get_endpoint_ids(&params); + params32->size = params.size; + params32->result = params.result; + params32->num = params.num; + params32->default_idx = params.default_idx; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_create_stream(void *args) +{ + struct + { + PTR32 device; + EDataFlow flow; + AUDCLNT_SHAREMODE share; + UINT flags; + REFERENCE_TIME duration; + REFERENCE_TIME period; + PTR32 fmt; + HRESULT result; + PTR32 stream; + } *params32 = args; + struct create_stream_params params = + { + .device = ULongToPtr(params32->device), + .flow = params32->flow, + .share = params32->share, + .flags = params32->flags, + .duration = params32->duration, + .period = params32->period, + .fmt = ULongToPtr(params32->fmt), + .stream = ULongToPtr(params32->stream) + }; + create_stream(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_release_stream(void *args) +{ + struct + { + stream_handle stream; + PTR32 timer_thread; + HRESULT result; + } *params32 = args; + struct release_stream_params params = + { + .stream = params32->stream, + .timer_thread = ULongToHandle(params32->timer_thread) + }; + release_stream(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_render_buffer(void *args) +{ + struct + { + stream_handle stream; + UINT32 frames; + HRESULT result; + PTR32 data; + } *params32 = args; + BYTE *data = NULL; + struct get_render_buffer_params params = + { + .stream = params32->stream, + .frames = params32->frames, + .data = &data + }; + get_render_buffer(&params); + params32->result = params.result; + *(unsigned int *)ULongToPtr(params32->data) = PtrToUlong(data); + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_capture_buffer(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 data; + PTR32 frames; + PTR32 flags; + PTR32 devpos; + PTR32 qpcpos; + } *params32 = args; + BYTE *data = NULL; + struct get_capture_buffer_params params = + { + .stream = params32->stream, + .data = &data, + .frames = ULongToPtr(params32->frames), + .flags = ULongToPtr(params32->flags), + .devpos = ULongToPtr(params32->devpos), + .qpcpos = ULongToPtr(params32->qpcpos) + }; + get_capture_buffer(&params); + params32->result = params.result; + *(unsigned int *)ULongToPtr(params32->data) = PtrToUlong(data); + return STATUS_SUCCESS; +}; + +static NTSTATUS wow64_is_format_supported(void *args) +{ + struct + { + PTR32 device; + EDataFlow flow; + AUDCLNT_SHAREMODE share; + PTR32 fmt_in; + PTR32 fmt_out; + HRESULT result; + } *params32 = args; + struct is_format_supported_params params = + { + .device = ULongToPtr(params32->device), + .flow = params32->flow, + .share = params32->share, + .fmt_in = ULongToPtr(params32->fmt_in), + .fmt_out = ULongToPtr(params32->fmt_out) + }; + is_format_supported(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_mix_format(void *args) +{ + struct + { + PTR32 device; + EDataFlow flow; + PTR32 fmt; + HRESULT result; + } *params32 = args; + struct get_mix_format_params params = + { + .device = ULongToPtr(params32->device), + .flow = params32->flow, + .fmt = ULongToPtr(params32->fmt) + }; + get_mix_format(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_buffer_size(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 size; + } *params32 = args; + struct get_buffer_size_params params = + { + .stream = params32->stream, + .size = ULongToPtr(params32->size) + }; + get_buffer_size(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_latency(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 latency; + } *params32 = args; + struct get_latency_params params = + { + .stream = params32->stream, + .latency = ULongToPtr(params32->latency) + }; + get_latency(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_current_padding(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 padding; + } *params32 = args; + struct get_current_padding_params params = + { + .stream = params32->stream, + .padding = ULongToPtr(params32->padding) + }; + get_current_padding(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_next_packet_size(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 frames; + } *params32 = args; + struct get_next_packet_size_params params = + { + .stream = params32->stream, + .frames = ULongToPtr(params32->frames) + }; + get_next_packet_size(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_frequency(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 frequency; + } *params32 = args; + struct get_frequency_params params = + { + .stream = params32->stream, + .frequency = ULongToPtr(params32->frequency) + }; + get_frequency(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_get_position(void *args) +{ + struct + { + stream_handle stream; + HRESULT result; + PTR32 position; + PTR32 qpctime; + } *params32 = args; + struct get_position_params params = + { + .stream = params32->stream, + .position = ULongToPtr(params32->position), + .qpctime = ULongToPtr(params32->qpctime) + }; + get_position(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +static NTSTATUS wow64_set_volumes(void *args) +{ + struct + { + stream_handle stream; + float master_volume; + PTR32 volumes; + PTR32 session_volumes; + } *params32 = args; + struct set_volumes_params params = + { + .stream = params32->stream, + .master_volume = params32->master_volume, + .volumes = ULongToPtr(params32->volumes), + .session_volumes = ULongToPtr(params32->session_volumes) + }; + return set_volumes(&params); +} + +static NTSTATUS wow64_set_event_handle(void *args) +{ + struct + { + stream_handle stream; + PTR32 event; + HRESULT result; + } *params32 = args; + struct set_event_handle_params params = + { + .stream = params32->stream, + .event = ULongToHandle(params32->event) + }; + + set_event_handle(&params); + params32->result = params.result; + return STATUS_SUCCESS; +} + +unixlib_entry_t __wine_unix_call_wow64_funcs[] = +{ + test_connect, + wow64_get_endpoint_ids, + wow64_create_stream, + wow64_release_stream, + start, + stop, + reset, + timer_loop, + wow64_get_render_buffer, + release_render_buffer, + wow64_get_capture_buffer, + release_capture_buffer, + wow64_is_format_supported, + wow64_get_mix_format, + wow64_get_buffer_size, + wow64_get_latency, + wow64_get_current_padding, + wow64_get_next_packet_size, + wow64_get_frequency, + wow64_get_position, + wow64_set_volumes, + wow64_set_event_handle, + is_started, + midi_release, + midi_out_message, + midi_in_message, + midi_notify_wait, + aux_message, +}; + +#endif /* _WIN64 */ -- 2.25.1

2 2

[PATCH 4/7] wineoss: Limit Wow64 buffer allocations to 32-bit addresses.
by Huw Davies 04 May '22

04 May '22

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/oss.c | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index 986ed274445..40b8879ef47 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -535,6 +535,15 @@ static HRESULT setup_oss_device(AUDCLNT_SHAREMODE share, int fd, return ret; } +static ULONG_PTR zero_bits(void) +{ +#ifdef _WIN64 + return !NtCurrentTeb()->WowTebOffset ? 0 : 0x7fffffff; +#else + return 0; +#endif +} + static NTSTATUS create_stream(void *args) { struct create_stream_params *params = args; @@ -597,8 +606,8 @@ static NTSTATUS create_stream(void *args) if(params->share == AUDCLNT_SHAREMODE_EXCLUSIVE) stream->bufsize_frames -= stream->bufsize_frames % stream->period_frames; size = stream->bufsize_frames * params->fmt->nBlockAlign; - if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->local_buffer, 0, &size, - MEM_COMMIT, PAGE_READWRITE)){ + if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->local_buffer, zero_bits(), + &size, MEM_COMMIT, PAGE_READWRITE)){ params->result = E_OUTOFMEMORY; goto exit; } @@ -931,8 +940,8 @@ static NTSTATUS get_render_buffer(void *args) stream->tmp_buffer = NULL; } size = frames * stream->fmt->nBlockAlign; - if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, 0, &size, - MEM_COMMIT, PAGE_READWRITE)){ + if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, zero_bits(), + &size, MEM_COMMIT, PAGE_READWRITE)){ stream->tmp_buffer_frames = 0; return oss_unlock_result(stream, &params->result, E_OUTOFMEMORY); } @@ -1041,8 +1050,8 @@ static NTSTATUS get_capture_buffer(void *args) stream->tmp_buffer = NULL; } size = *frames * stream->fmt->nBlockAlign; - if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, 0, &size, - MEM_COMMIT, PAGE_READWRITE)){ + if(NtAllocateVirtualMemory(GetCurrentProcess(), (void **)&stream->tmp_buffer, zero_bits(), + &size, MEM_COMMIT, PAGE_READWRITE)){ stream->tmp_buffer_frames = 0; return oss_unlock_result(stream, &params->result, E_OUTOFMEMORY); } -- 2.25.1

2 1

[PATCH 3/7] wineoss: Return offsets rather than ptrs to the strings.
by Huw Davies 04 May '22

04 May '22

This will make the Wow64 syscall rather simpler. Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/mmdevdrv.c | 12 +++++++----- dlls/wineoss.drv/oss.c | 18 ++++++++---------- dlls/wineoss.drv/unixlib.h | 4 ++-- 3 files changed, 17 insertions(+), 17 deletions(-) diff --git a/dlls/wineoss.drv/mmdevdrv.c b/dlls/wineoss.drv/mmdevdrv.c index c9aae98ec2e..9c1261ce05c 100644 --- a/dlls/wineoss.drv/mmdevdrv.c +++ b/dlls/wineoss.drv/mmdevdrv.c @@ -390,8 +390,10 @@ HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids_out, GUID **gu } for(i = 0; i < params.num; i++){ - unsigned int name_size = (wcslen(params.endpoints[i].name) + 1) * sizeof(WCHAR); - unsigned int dev_size = strlen(params.endpoints[i].device) + 1; + WCHAR *name = (WCHAR *)((char *)params.endpoints + params.endpoints[i].name); + char *device = (char *)params.endpoints + params.endpoints[i].device; + unsigned int name_size = (wcslen(name) + 1) * sizeof(WCHAR); + unsigned int dev_size = strlen(device) + 1; OSSDevice *oss_dev; ids[i] = HeapAlloc(GetProcessHeap(), 0, name_size); @@ -401,12 +403,12 @@ HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids_out, GUID **gu params.result = E_OUTOFMEMORY; goto end; } - memcpy(ids[i], params.endpoints[i].name, name_size); - get_device_guid(flow, params.endpoints[i].device, guids + i); + memcpy(ids[i], name, name_size); + get_device_guid(flow, device, guids + i); oss_dev->flow = flow; oss_dev->guid = guids[i]; - memcpy(oss_dev->devnode, params.endpoints[i].device, dev_size); + memcpy(oss_dev->devnode, device, dev_size); device_add(oss_dev); } *def_index = params.default_idx; diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index a628548ddcd..986ed274445 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -226,11 +226,10 @@ static NTSTATUS get_endpoint_ids(void *args) WCHAR name[ARRAY_SIZE(ai.name) + ARRAY_SIZE(outW)]; char device[OSS_DEVNODE_SIZE]; } *info; - unsigned int i, j, num, needed, name_len, device_len, default_idx = 0; + unsigned int i, j, num, needed, name_len, device_len, offset, default_idx = 0; char default_device[OSS_DEVNODE_SIZE]; struct endpoint *endpoint; int mixer_fd; - char *ptr; mixer_fd = open("/dev/mixer", O_RDONLY, 0); if(mixer_fd < 0){ @@ -333,9 +332,8 @@ static NTSTATUS get_endpoint_ids(void *args) } close(mixer_fd); - needed = num * sizeof(*params->endpoints); + offset = needed = num * sizeof(*params->endpoints); endpoint = params->endpoints; - ptr = (char *)(endpoint + num); for(i = 0; i < num; i++){ name_len = wcslen(info[i].name) + 1; @@ -343,12 +341,12 @@ static NTSTATUS get_endpoint_ids(void *args) needed += name_len * sizeof(WCHAR) + ((device_len + 1) & ~1); if(needed <= params->size){ - endpoint->name = (WCHAR *)ptr; - memcpy(endpoint->name, info[i].name, name_len * sizeof(WCHAR)); - ptr += name_len * sizeof(WCHAR); - endpoint->device = ptr; - memcpy(endpoint->device, info[i].device, device_len); - ptr += (device_len + 1) & ~1; + endpoint->name = offset; + memcpy((char *)params->endpoints + offset, info[i].name, name_len * sizeof(WCHAR)); + offset += name_len * sizeof(WCHAR); + endpoint->device = offset; + memcpy((char *)params->endpoints + offset, info[i].device, device_len); + offset += (device_len + 1) & ~1; endpoint++; } } diff --git a/dlls/wineoss.drv/unixlib.h b/dlls/wineoss.drv/unixlib.h index 278dfdbe612..208dec7f69d 100644 --- a/dlls/wineoss.drv/unixlib.h +++ b/dlls/wineoss.drv/unixlib.h @@ -36,8 +36,8 @@ struct test_connect_params struct endpoint { - WCHAR *name; - char *device; + unsigned int name; + unsigned int device; }; struct get_endpoint_ids_params -- 2.25.1

2 1

[PATCH 2/7] wineoss: Use UINT64 handles to represent the stream.
by Huw Davies 04 May '22

04 May '22

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/mmdevdrv.c | 6 +++--- dlls/wineoss.drv/oss.c | 43 +++++++++++++++++++++---------------- dlls/wineoss.drv/unixlib.h | 40 +++++++++++++++++----------------- 3 files changed, 47 insertions(+), 42 deletions(-) diff --git a/dlls/wineoss.drv/mmdevdrv.c b/dlls/wineoss.drv/mmdevdrv.c index 93bf775ebc8..c9aae98ec2e 100644 --- a/dlls/wineoss.drv/mmdevdrv.c +++ b/dlls/wineoss.drv/mmdevdrv.c @@ -96,7 +96,7 @@ struct ACImpl { EDataFlow dataflow; float *vols; UINT32 channel_count; - struct oss_stream *stream; + stream_handle stream; HANDLE timer_thread; @@ -239,7 +239,7 @@ int WINAPI AUDDRV_GetPriority(void) return params.priority; } -static HRESULT stream_release(struct oss_stream *stream, HANDLE timer_thread) +static HRESULT stream_release(stream_handle stream, HANDLE timer_thread) { struct release_stream_params params; @@ -651,7 +651,7 @@ static HRESULT WINAPI AudioClient_Initialize(IAudioClient3 *iface, { ACImpl *This = impl_from_IAudioClient3(iface); struct create_stream_params params; - struct oss_stream *stream; + stream_handle stream; unsigned int i; TRACE("(%p)->(%x, %x, %s, %s, %p, %s)\n", This, mode, flags, diff --git a/dlls/wineoss.drv/oss.c b/dlls/wineoss.drv/oss.c index 6490081e069..a628548ddcd 100644 --- a/dlls/wineoss.drv/oss.c +++ b/dlls/wineoss.drv/oss.c @@ -111,6 +111,11 @@ static NTSTATUS oss_unlock_result(struct oss_stream *stream, return STATUS_SUCCESS; } +static struct oss_stream *handle_get_stream(stream_handle h) +{ + return (struct oss_stream *)(UINT_PTR)h; +} + static NTSTATUS test_connect(void *args) { struct test_connect_params *params = args; @@ -615,7 +620,7 @@ exit: free(stream->fmt); free(stream); }else{ - *params->stream = stream; + *params->stream = (stream_handle)(UINT_PTR)stream; } return STATUS_SUCCESS; @@ -624,7 +629,7 @@ exit: static NTSTATUS release_stream(void *args) { struct release_stream_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); SIZE_T size; if(params->timer_thread){ @@ -653,7 +658,7 @@ static NTSTATUS release_stream(void *args) static NTSTATUS start(void *args) { struct start_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -671,7 +676,7 @@ static NTSTATUS start(void *args) static NTSTATUS stop(void *args) { struct stop_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -687,7 +692,7 @@ static NTSTATUS stop(void *args) static NTSTATUS reset(void *args) { struct reset_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -860,7 +865,7 @@ static void oss_read_data(struct oss_stream *stream) static NTSTATUS timer_loop(void *args) { struct timer_loop_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); LARGE_INTEGER delay, now, next; int adjust; @@ -902,7 +907,7 @@ static NTSTATUS timer_loop(void *args) static NTSTATUS get_render_buffer(void *args) { struct get_render_buffer_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT32 write_pos, frames = params->frames; BYTE **data = params->data; SIZE_T size; @@ -968,7 +973,7 @@ static void oss_wrap_buffer(struct oss_stream *stream, BYTE *buffer, UINT32 writ static NTSTATUS release_render_buffer(void *args) { struct release_render_buffer_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT32 written_frames = params->written_frames; UINT flags = params->flags; BYTE *buffer; @@ -1008,7 +1013,7 @@ static NTSTATUS release_render_buffer(void *args) static NTSTATUS get_capture_buffer(void *args) { struct get_capture_buffer_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT64 *devpos = params->devpos, *qpcpos = params->qpcpos; UINT32 *frames = params->frames; UINT *flags = params->flags; @@ -1074,7 +1079,7 @@ static NTSTATUS get_capture_buffer(void *args) static NTSTATUS release_capture_buffer(void *args) { struct release_capture_buffer_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT32 done = params->done; oss_lock(stream); @@ -1231,7 +1236,7 @@ static NTSTATUS get_mix_format(void *args) static NTSTATUS get_buffer_size(void *args) { struct get_buffer_size_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -1243,7 +1248,7 @@ static NTSTATUS get_buffer_size(void *args) static NTSTATUS get_latency(void *args) { struct get_latency_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -1257,7 +1262,7 @@ static NTSTATUS get_latency(void *args) static NTSTATUS get_current_padding(void *args) { struct get_current_padding_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -1269,7 +1274,7 @@ static NTSTATUS get_current_padding(void *args) static NTSTATUS get_next_packet_size(void *args) { struct get_next_packet_size_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT32 *frames = params->frames; oss_lock(stream); @@ -1282,7 +1287,7 @@ static NTSTATUS get_next_packet_size(void *args) static NTSTATUS get_frequency(void *args) { struct get_frequency_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT64 *freq = params->frequency; oss_lock(stream); @@ -1298,7 +1303,7 @@ static NTSTATUS get_frequency(void *args) static NTSTATUS get_position(void *args) { struct get_position_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); UINT64 *pos = params->position, *qpctime = params->qpctime; oss_lock(stream); @@ -1342,7 +1347,7 @@ static NTSTATUS get_position(void *args) static NTSTATUS set_volumes(void *args) { struct set_volumes_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); stream->mute = !params->master_volume; @@ -1354,7 +1359,7 @@ static NTSTATUS set_volumes(void *args) static NTSTATUS set_event_handle(void *args) { struct set_event_handle_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); @@ -1374,7 +1379,7 @@ static NTSTATUS set_event_handle(void *args) static NTSTATUS is_started(void *args) { struct is_started_params *params = args; - struct oss_stream *stream = params->stream; + struct oss_stream *stream = handle_get_stream(params->stream); oss_lock(stream); diff --git a/dlls/wineoss.drv/unixlib.h b/dlls/wineoss.drv/unixlib.h index 25e9a7007b3..278dfdbe612 100644 --- a/dlls/wineoss.drv/unixlib.h +++ b/dlls/wineoss.drv/unixlib.h @@ -18,7 +18,7 @@ #include "mmdeviceapi.h" -struct stream_oss; +typedef UINT64 stream_handle; /* From <dlls/mmdevapi/mmdevapi.h> */ enum DriverPriority @@ -60,42 +60,42 @@ struct create_stream_params REFERENCE_TIME period; const WAVEFORMATEX *fmt; HRESULT result; - struct oss_stream **stream; + stream_handle *stream; }; struct release_stream_params { - struct oss_stream *stream; + stream_handle stream; HANDLE timer_thread; HRESULT result; }; struct start_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; }; struct stop_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; }; struct reset_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; }; struct timer_loop_params { - struct oss_stream *stream; + stream_handle stream; }; struct get_render_buffer_params { - struct oss_stream *stream; + stream_handle stream; UINT32 frames; HRESULT result; BYTE **data; @@ -103,7 +103,7 @@ struct get_render_buffer_params struct release_render_buffer_params { - struct oss_stream *stream; + stream_handle stream; UINT32 written_frames; UINT flags; HRESULT result; @@ -111,7 +111,7 @@ struct release_render_buffer_params struct get_capture_buffer_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; BYTE **data; UINT32 *frames; @@ -122,7 +122,7 @@ struct get_capture_buffer_params struct release_capture_buffer_params { - struct oss_stream *stream; + stream_handle stream; UINT32 done; HRESULT result; }; @@ -147,42 +147,42 @@ struct get_mix_format_params struct get_buffer_size_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; UINT32 *size; }; struct get_latency_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; REFERENCE_TIME *latency; }; struct get_current_padding_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; UINT32 *padding; }; struct get_next_packet_size_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; UINT32 *frames; }; struct get_frequency_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; UINT64 *frequency; }; struct get_position_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; UINT64 *position; UINT64 *qpctime; @@ -190,7 +190,7 @@ struct get_position_params struct set_volumes_params { - struct oss_stream *stream; + stream_handle stream; float master_volume; const float *volumes; const float *session_volumes; @@ -198,14 +198,14 @@ struct set_volumes_params struct set_event_handle_params { - struct oss_stream *stream; + stream_handle stream; HANDLE event; HRESULT result; }; struct is_started_params { - struct oss_stream *stream; + stream_handle stream; HRESULT result; }; -- 2.25.1

2 1

[PATCH 1/7] wineoss: Pass a client ptr to the callback instead of a stream.
by Huw Davies 04 May '22

04 May '22

This is to allow stream handles to be larger than sizeof(void *). Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/wineoss.drv/mmdevdrv.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/wineoss.drv/mmdevdrv.c b/dlls/wineoss.drv/mmdevdrv.c index c282ff14f01..93bf775ebc8 100644 --- a/dlls/wineoss.drv/mmdevdrv.c +++ b/dlls/wineoss.drv/mmdevdrv.c @@ -252,10 +252,10 @@ static HRESULT stream_release(struct oss_stream *stream, HANDLE timer_thread) static DWORD WINAPI timer_thread(void *user) { - struct oss_stream *stream = user; struct timer_loop_params params; + struct ACImpl *This = user; - params.stream = stream; + params.stream = This->stream; OSS_CALL(timer_loop, &params); return 0; @@ -913,7 +913,7 @@ static HRESULT WINAPI AudioClient_Start(IAudioClient3 *iface) OSS_CALL(start, &params); if(SUCCEEDED(params.result) && !This->timer_thread){ - This->timer_thread = CreateThread(NULL, 0, timer_thread, This->stream, 0, NULL); + This->timer_thread = CreateThread(NULL, 0, timer_thread, This, 0, NULL); SetThreadPriority(This->timer_thread, THREAD_PRIORITY_TIME_CRITICAL); } -- 2.25.1

2 1

[PATCH 0/1] MR29: mfplat: Avoid a race condition when releasing a tracked sample.
by Giovanni Mascellani (＠giomasce) 04 May '22

04 May '22

Right now, if the same tracked sample is released at the same time from two different threads it might happen that neither of them calls the callback, because they might go through the critical section at the same time (while neither has decremented the reference count yet). Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> -- https://gitlab.winehq.org/wine/wine/-/merge_requests/29

3 4

[PATCH 0/11] MR36: winex11: PE conversion preparation
by Jacek Caban (＠jacek) 04 May '22

04 May '22

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/36

2 11

Jump to page:

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