github/FreeRDP
7
0
Fork 0
mirror of https://github.com/FreeRDP/FreeRDP.git synced 2025-06-03 00:00:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

winpr: rework alignment functions

Browse Source 
_align_XXX functions aren't widely available depending on the C runtime. That causes
problems with mingw where we can easily have some runtime mixes (which lead to mysterious
segfaults most of the time). This patch introduce winpr_aligned_XXX functions that will
either use the function available, or use an emulation layer.
This commit is contained in:
David Fort 2022-05-11 11:28:55 +02:00 committed by akallabeth
parent 82092f6752
commit 77413f49b2
38 changed files with 242 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
channels/printer/client/printer_main.c
View File

@ -847,7 +847,7 @@ static UINT printer_free(DEVICE* device)
CloseHandle(printer_dev->thread); CloseHandle(printer_dev->thread);
CloseHandle(printer_dev->stopEvent); CloseHandle(printer_dev->stopEvent);
CloseHandle(printer_dev->event); CloseHandle(printer_dev->event);
_aligned_free(printer_dev->pIrpList); winpr_aligned_free(printer_dev->pIrpList);
if (printer_dev->printer) if (printer_dev->printer)
printer_dev->printer->ReleaseRef(printer_dev->printer); printer_dev->printer->ReleaseRef(printer_dev->printer);
@ -887,7 +887,7 @@ static UINT printer_register(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, rdpPrint
printer_dev->device.Free = printer_free; printer_dev->device.Free = printer_free;
printer_dev->rdpcontext = pEntryPoints->rdpcontext; printer_dev->rdpcontext = pEntryPoints->rdpcontext;
printer_dev->printer = printer; printer_dev->printer = printer;
printer_dev->pIrpList = (WINPR_PSLIST_HEADER)_aligned_malloc(sizeof(WINPR_SLIST_HEADER), printer_dev->pIrpList = (WINPR_PSLIST_HEADER)winpr_aligned_malloc(sizeof(WINPR_SLIST_HEADER),
MEMORY_ALLOCATION_ALIGNMENT); MEMORY_ALLOCATION_ALIGNMENT);
if (!printer_dev->pIrpList) if (!printer_dev->pIrpList)

8
channels/rdpdr/client/irp.c
View File

@ -48,7 +48,7 @@ static UINT irp_free(IRP* irp)
Stream_Free(irp->input, TRUE); Stream_Free(irp->input, TRUE);
Stream_Free(irp->output, TRUE); Stream_Free(irp->output, TRUE);
_aligned_free(irp); winpr_aligned_free(irp);
return CHANNEL_RC_OK; return CHANNEL_RC_OK;
} }
@ -102,7 +102,7 @@ IRP* irp_new(DEVMAN* devman, wStream* s, UINT* error)
return NULL; return NULL;
} }
irp = (IRP*)_aligned_malloc(sizeof(IRP), MEMORY_ALLOCATION_ALIGNMENT); irp = (IRP*)winpr_aligned_malloc(sizeof(IRP), MEMORY_ALLOCATION_ALIGNMENT);
if (!irp) if (!irp)
{ {
@ -127,7 +127,7 @@ IRP* irp_new(DEVMAN* devman, wStream* s, UINT* error)
if (!irp->output) if (!irp->output)
{ {
WLog_ERR(TAG, "Stream_New failed!"); WLog_ERR(TAG, "Stream_New failed!");
_aligned_free(irp); winpr_aligned_free(irp);
if (error) if (error)
*error = CHANNEL_RC_NO_MEMORY; *error = CHANNEL_RC_NO_MEMORY;
return NULL; return NULL;
@ -136,7 +136,7 @@ IRP* irp_new(DEVMAN* devman, wStream* s, UINT* error)
if (!rdpdr_write_iocompletion_header(irp->output, DeviceId, irp->CompletionId, 0)) if (!rdpdr_write_iocompletion_header(irp->output, DeviceId, irp->CompletionId, 0))
{ {
Stream_Free(irp->output, TRUE); Stream_Free(irp->output, TRUE);
_aligned_free(irp); winpr_aligned_free(irp);
if (error) if (error)
*error = CHANNEL_RC_NO_MEMORY; *error = CHANNEL_RC_NO_MEMORY;
return NULL; return NULL;

6
client/Wayland/wlf_pointer.c
View File

@ -40,7 +40,7 @@ static BOOL wlf_Pointer_New(rdpContext* context, rdpPointer* pointer)
return FALSE; return FALSE;
ptr->size = pointer->width * pointer->height * 4ULL; ptr->size = pointer->width * pointer->height * 4ULL;
ptr->data = _aligned_malloc(ptr->size, 16); ptr->data = winpr_aligned_malloc(ptr->size, 16);
if (!ptr->data) if (!ptr->data)
return FALSE; return FALSE;
@ -50,7 +50,7 @@ static BOOL wlf_Pointer_New(rdpContext* context, rdpPointer* pointer)
pointer->xorMaskData, pointer->lengthXorMask, pointer->andMaskData, pointer->xorMaskData, pointer->lengthXorMask, pointer->andMaskData,
pointer->lengthAndMask, pointer->xorBpp, &context->gdi->palette)) pointer->lengthAndMask, pointer->xorBpp, &context->gdi->palette))
{ {
_aligned_free(ptr->data); winpr_aligned_free(ptr->data);
return FALSE; return FALSE;
} }
@ -63,7 +63,7 @@ static void wlf_Pointer_Free(rdpContext* context, rdpPointer* pointer)
WINPR_UNUSED(context); WINPR_UNUSED(context);
if (ptr) if (ptr)
_aligned_free(ptr->data); winpr_aligned_free(ptr->data);
} }
static BOOL wlf_Pointer_Set(rdpContext* context, rdpPointer* pointer) static BOOL wlf_Pointer_Set(rdpContext* context, rdpPointer* pointer)

10
client/Windows/wf_graphics.c
View File

@ -126,7 +126,7 @@ static void wf_Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
DeleteObject(wf_bitmap->bitmap); DeleteObject(wf_bitmap->bitmap);
DeleteDC(wf_bitmap->hdc); DeleteDC(wf_bitmap->hdc);
_aligned_free(wf_bitmap->_bitmap.data); winpr_aligned_free(wf_bitmap->_bitmap.data);
wf_bitmap->_bitmap.data = NULL; wf_bitmap->_bitmap.data = NULL;
} }
} }
@ -210,7 +210,7 @@ static BOOL wf_Pointer_New(rdpContext* context, const rdpPointer* pointer)
if ((pointer->lengthAndMask > 0) || (pointer->lengthXorMask > 0)) if ((pointer->lengthAndMask > 0) || (pointer->lengthXorMask > 0))
{ {
pdata = (BYTE*)_aligned_malloc(pointer->lengthAndMask + pointer->lengthXorMask, 16); pdata = (BYTE*)winpr_aligned_malloc(pointer->lengthAndMask + pointer->lengthXorMask, 16);
if (!pdata) if (!pdata)
goto fail; goto fail;
@ -219,7 +219,7 @@ static BOOL wf_Pointer_New(rdpContext* context, const rdpPointer* pointer)
CopyMemory(pdata, pointer->andMaskData, pointer->lengthAndMask); CopyMemory(pdata, pointer->andMaskData, pointer->lengthAndMask);
CopyMemory(pdata + pointer->lengthAndMask, pointer->xorMaskData, pointer->lengthXorMask); CopyMemory(pdata + pointer->lengthAndMask, pointer->xorMaskData, pointer->lengthXorMask);
info.hbmMask = CreateBitmap(pointer->width, pointer->height * 2, 1, 1, pdata); info.hbmMask = CreateBitmap(pointer->width, pointer->height * 2, 1, 1, pdata);
_aligned_free(pdata); winpr_aligned_free(pdata);
info.hbmColor = NULL; info.hbmColor = NULL;
} }
else else
@ -229,7 +229,7 @@ static BOOL wf_Pointer_New(rdpContext* context, const rdpPointer* pointer)
if (pointer->lengthAndMask > 0) if (pointer->lengthAndMask > 0)
{ {
pdata = (BYTE*)_aligned_malloc(pointer->lengthAndMask, 16); pdata = (BYTE*)winpr_aligned_malloc(pointer->lengthAndMask, 16);
if (!pdata) if (!pdata)
goto fail; goto fail;
@ -237,7 +237,7 @@ static BOOL wf_Pointer_New(rdpContext* context, const rdpPointer* pointer)
} }
info.hbmMask = CreateBitmap(pointer->width, pointer->height, 1, 1, pdata); info.hbmMask = CreateBitmap(pointer->width, pointer->height, 1, 1, pdata);
_aligned_free(pdata); winpr_aligned_free(pdata);
/* currently color xorBpp is only 24 per [T128] section 8.14.3 */ /* currently color xorBpp is only 24 per [T128] section 8.14.3 */
srcFormat = gdi_get_pixel_format(pointer->xorBpp); srcFormat = gdi_get_pixel_format(pointer->xorBpp);

4
client/X11/xf_gdi.c
View File

@ -236,7 +236,7 @@ static Pixmap xf_brush_new(xfContext* xfc, UINT32 width, UINT32 height, UINT32 b
if (data) if (data)
{ {
brushFormat = gdi_get_pixel_format(bpp); brushFormat = gdi_get_pixel_format(bpp);
cdata = (BYTE*)_aligned_malloc(width * height * 4ULL, 16); cdata = (BYTE*)winpr_aligned_malloc(width * height * 4ULL, 16);
freerdp_image_copy(cdata, gdi->dstFormat, 0, 0, 0, width, height, data, brushFormat, 0, 0, freerdp_image_copy(cdata, gdi->dstFormat, 0, 0, 0, width, height, data, brushFormat, 0, 0,
0, &gdi->palette, FREERDP_FLIP_NONE); 0, &gdi->palette, FREERDP_FLIP_NONE);
image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0, (char*)cdata, width, image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0, (char*)cdata, width,
@ -249,7 +249,7 @@ static Pixmap xf_brush_new(xfContext* xfc, UINT32 width, UINT32 height, UINT32 b
XDestroyImage(image); XDestroyImage(image);
if (cdata != data) if (cdata != data)
_aligned_free(cdata); winpr_aligned_free(cdata);
XFreeGC(xfc->display, gc); XFreeGC(xfc->display, gc);
} }

12
client/X11/xf_gfx.c
View File

@ -305,7 +305,7 @@ static UINT xf_CreateSurface(RdpgfxClientContext* context,
surface->gdi.scanline = surface->gdi.width * FreeRDPGetBytesPerPixel(surface->gdi.format); surface->gdi.scanline = surface->gdi.width * FreeRDPGetBytesPerPixel(surface->gdi.format);
surface->gdi.scanline = x11_pad_scanline(surface->gdi.scanline, xfc->scanline_pad); surface->gdi.scanline = x11_pad_scanline(surface->gdi.scanline, xfc->scanline_pad);
size = surface->gdi.scanline * surface->gdi.height * 1ULL; size = surface->gdi.scanline * surface->gdi.height * 1ULL;
surface->gdi.data = (BYTE*)_aligned_malloc(size, 16); surface->gdi.data = (BYTE*)winpr_aligned_malloc(size, 16);
if (!surface->gdi.data) if (!surface->gdi.data)
{ {
@ -329,7 +329,7 @@ static UINT xf_CreateSurface(RdpgfxClientContext* context,
surface->stageScanline = width * bytes; surface->stageScanline = width * bytes;
surface->stageScanline = x11_pad_scanline(surface->stageScanline, xfc->scanline_pad); surface->stageScanline = x11_pad_scanline(surface->stageScanline, xfc->scanline_pad);
size = surface->stageScanline * surface->gdi.height * 1ULL; size = surface->stageScanline * surface->gdi.height * 1ULL;
surface->stage = (BYTE*)_aligned_malloc(size, 16); surface->stage = (BYTE*)winpr_aligned_malloc(size, 16);
if (!surface->stage) if (!surface->stage)
{ {
@ -366,9 +366,9 @@ error_set_surface_data:
surface->image->data = NULL; surface->image->data = NULL;
XDestroyImage(surface->image); XDestroyImage(surface->image);
error_surface_image: error_surface_image:
_aligned_free(surface->stage); winpr_aligned_free(surface->stage);
out_free_gdidata: out_free_gdidata:
_aligned_free(surface->gdi.data); winpr_aligned_free(surface->gdi.data);
out_free: out_free:
free(surface); free(surface);
return ret; return ret;
@ -398,8 +398,8 @@ static UINT xf_DeleteSurface(RdpgfxClientContext* context,
#endif #endif
surface->image->data = NULL; surface->image->data = NULL;
XDestroyImage(surface->image); XDestroyImage(surface->image);
_aligned_free(surface->gdi.data); winpr_aligned_free(surface->gdi.data);
_aligned_free(surface->stage); winpr_aligned_free(surface->stage);
region16_uninit(&surface->gdi.invalidRegion); region16_uninit(&surface->gdi.invalidRegion);
codecs = surface->gdi.codecs; codecs = surface->gdi.codecs;
free(surface); free(surface);

20
client/X11/xf_graphics.c
View File

@ -124,18 +124,18 @@ static BOOL xf_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
if ((INT64)depth != xfc->depth) if ((INT64)depth != xfc->depth)
{ {
if (!(data = _aligned_malloc(bitmap->width * bitmap->height * 4ULL, 16))) if (!(data = winpr_aligned_malloc(bitmap->width * bitmap->height * 4ULL, 16)))
goto unlock; goto unlock;
if (!freerdp_image_copy(data, gdi->dstFormat, 0, 0, 0, bitmap->width, bitmap->height, if (!freerdp_image_copy(data, gdi->dstFormat, 0, 0, 0, bitmap->width, bitmap->height,
bitmap->data, bitmap->format, 0, 0, 0, &context->gdi->palette, bitmap->data, bitmap->format, 0, 0, 0, &context->gdi->palette,
FREERDP_FLIP_NONE)) FREERDP_FLIP_NONE))
{ {
_aligned_free(data); winpr_aligned_free(data);
goto unlock; goto unlock;
} }
_aligned_free(bitmap->data); winpr_aligned_free(bitmap->data);
bitmap->data = data; bitmap->data = data;
bitmap->format = gdi->dstFormat; bitmap->format = gdi->dstFormat;
} }
@ -183,7 +183,7 @@ static void xf_Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
} }
xf_unlock_x11(xfc); xf_unlock_x11(xfc);
_aligned_free(bitmap->data); winpr_aligned_free(bitmap->data);
free(xbitmap); free(xbitmap);
} }
@ -312,7 +312,7 @@ static BOOL _xf_Pointer_GetCursorForCurrentScale(rdpContext* context, rdpPointer
ci.yhot = pointer->yPos * yscale; ci.yhot = pointer->yPos * yscale;
size = ci.height * ci.width * FreeRDPGetBytesPerPixel(CursorFormat) * 1ULL; size = ci.height * ci.width * FreeRDPGetBytesPerPixel(CursorFormat) * 1ULL;
tmp = _aligned_malloc(size, 16); tmp = winpr_aligned_malloc(size, 16);
if (!tmp) if (!tmp)
{ {
xf_unlock_x11(xfc); xf_unlock_x11(xfc);
@ -326,7 +326,7 @@ static BOOL _xf_Pointer_GetCursorForCurrentScale(rdpContext* context, rdpPointer
(BYTE*)xpointer->cursorPixels, CursorFormat, 0, 0, 0, (BYTE*)xpointer->cursorPixels, CursorFormat, 0, 0, 0,
pointer->width, pointer->height)) pointer->width, pointer->height))
{ {
_aligned_free(tmp); winpr_aligned_free(tmp);
xf_unlock_x11(xfc); xf_unlock_x11(xfc);
return FALSE; return FALSE;
} }
@ -342,7 +342,7 @@ static BOOL _xf_Pointer_GetCursorForCurrentScale(rdpContext* context, rdpPointer
xpointer->cursors[cursorIndex] = XcursorImageLoadCursor(xfc->display, &ci); xpointer->cursors[cursorIndex] = XcursorImageLoadCursor(xfc->display, &ci);
xpointer->nCursors += 1; xpointer->nCursors += 1;
_aligned_free(tmp); winpr_aligned_free(tmp);
xf_unlock_x11(xfc); xf_unlock_x11(xfc);
} }
@ -401,7 +401,7 @@ static BOOL xf_Pointer_New(rdpContext* context, rdpPointer* pointer)
size = pointer->height * pointer->width * FreeRDPGetBytesPerPixel(CursorFormat) * 1ULL; size = pointer->height * pointer->width * FreeRDPGetBytesPerPixel(CursorFormat) * 1ULL;
if (!(xpointer->cursorPixels = (XcursorPixel*)_aligned_malloc(size, 16))) if (!(xpointer->cursorPixels = (XcursorPixel*)winpr_aligned_malloc(size, 16)))
return FALSE; return FALSE;
if (!freerdp_image_copy_from_pointer_data( if (!freerdp_image_copy_from_pointer_data(
@ -409,7 +409,7 @@ static BOOL xf_Pointer_New(rdpContext* context, rdpPointer* pointer)
pointer->xorMaskData, pointer->lengthXorMask, pointer->andMaskData, pointer->xorMaskData, pointer->lengthXorMask, pointer->andMaskData,
pointer->lengthAndMask, pointer->xorBpp, &context->gdi->palette)) pointer->lengthAndMask, pointer->xorBpp, &context->gdi->palette))
{ {
_aligned_free(xpointer->cursorPixels); winpr_aligned_free(xpointer->cursorPixels);
return FALSE; return FALSE;
} }
@ -428,7 +428,7 @@ static void xf_Pointer_Free(rdpContext* context, rdpPointer* pointer)
xf_lock_x11(xfc); xf_lock_x11(xfc);
_aligned_free(xpointer->cursorPixels); winpr_aligned_free(xpointer->cursorPixels);
free(xpointer->cursorWidths); free(xpointer->cursorWidths);
free(xpointer->cursorHeights); free(xpointer->cursorHeights);

4
include/freerdp/codec/color.h
View File

@ -274,8 +274,8 @@ extern "C"
* @param height height to copy in pixels * @param height height to copy in pixels
* @param data source buffer, must be (nWidth + 7) / 8 bytes long * @param data source buffer, must be (nWidth + 7) / 8 bytes long
* *
* @return A buffer allocated with _aligned_malloc(width * height, 16) * @return A buffer allocated with winpr_aligned_malloc(width * height, 16)
* if successufl, NULL otherwise. * if successful, NULL otherwise.
*/ */
FREERDP_API BYTE* freerdp_glyph_convert(UINT32 width, UINT32 height, const BYTE* data); FREERDP_API BYTE* freerdp_glyph_convert(UINT32 width, UINT32 height, const BYTE* data);

4
libfreerdp/CMakeLists.txt
View File

@ -402,10 +402,6 @@ if (WITH_LIBRARY_VERSIONING)
set_target_properties(${MODULE_NAME} PROPERTIES VERSION ${FREERDP_VERSION} SOVERSION ${FREERDP_API_VERSION}) set_target_properties(${MODULE_NAME} PROPERTIES VERSION ${FREERDP_VERSION} SOVERSION ${FREERDP_API_VERSION})
endif() endif()
if (MINGW)
freerdp_library_add(ucrt)
endif()
target_link_libraries(${MODULE_NAME} PRIVATE ${LIBFREERDP_LIBS} winpr) target_link_libraries(${MODULE_NAME} PRIVATE ${LIBFREERDP_LIBS} winpr)
install(TARGETS ${MODULE_NAME} COMPONENT libraries EXPORT FreeRDPTargets install(TARGETS ${MODULE_NAME} COMPONENT libraries EXPORT FreeRDPTargets

2
libfreerdp/codec/color.c
View File

@ -54,7 +54,7 @@ BYTE* freerdp_glyph_convert(UINT32 width, UINT32 height, const BYTE* data)
* means of accessing individual pixels in blitting operations * means of accessing individual pixels in blitting operations
*/ */
scanline = (width + 7) / 8; scanline = (width + 7) / 8;
dstData = (BYTE*)_aligned_malloc(width * height * 1ULL, 16); dstData = (BYTE*)winpr_aligned_malloc(width * height * 1ULL, 16);
if (!dstData) if (!dstData)
return NULL; return NULL;

20
libfreerdp/codec/h264.c
View File

@ -72,8 +72,8 @@ BOOL avc420_ensure_buffer(H264_CONTEXT* h264, UINT32 stride, UINT32 width, UINT3
for (x = 0; x < 3; x++) for (x = 0; x < 3; x++)
{ {
BYTE* tmp1 = _aligned_recalloc(h264->pYUVData[x], h264->iStride[x], pheight, 16); BYTE* tmp1 = winpr_aligned_recalloc(h264->pYUVData[x], h264->iStride[x], pheight, 16);
BYTE* tmp2 = _aligned_recalloc(h264->pOldYUVData[x], h264->iStride[x], pheight, 16); BYTE* tmp2 = winpr_aligned_recalloc(h264->pOldYUVData[x], h264->iStride[x], pheight, 16);
if (tmp1) if (tmp1)
h264->pYUVData[x] = tmp1; h264->pYUVData[x] = tmp1;
if (tmp2) if (tmp2)
@ -415,10 +415,10 @@ static BOOL avc444_ensure_buffer(H264_CONTEXT* h264, DWORD nDstHeight)
BYTE* tmp2; BYTE* tmp2;
piDstStride[x] = piMainStride[0]; piDstStride[x] = piMainStride[0];
piDstSize[x] = piDstStride[x] * padDstHeight; piDstSize[x] = piDstStride[x] * padDstHeight;
tmp1 = _aligned_recalloc(ppYUVDstData[x], piDstSize[x], 1, 16); tmp1 = winpr_aligned_recalloc(ppYUVDstData[x], piDstSize[x], 1, 16);
if (tmp1) if (tmp1)
ppYUVDstData[x] = tmp1; ppYUVDstData[x] = tmp1;
tmp2 = _aligned_recalloc(ppOldYUVDstData[x], piDstSize[x], 1, 16); tmp2 = winpr_aligned_recalloc(ppOldYUVDstData[x], piDstSize[x], 1, 16);
if (tmp2) if (tmp2)
ppOldYUVDstData[x] = tmp2; ppOldYUVDstData[x] = tmp2;
if (!tmp1 || !tmp2) if (!tmp1 || !tmp2)
@ -426,7 +426,7 @@ static BOOL avc444_ensure_buffer(H264_CONTEXT* h264, DWORD nDstHeight)
} }
{ {
BYTE* tmp = _aligned_recalloc(h264->lumaData, piDstSize[0], 4, 16); BYTE* tmp = winpr_aligned_recalloc(h264->lumaData, piDstSize[0], 4, 16);
if (!tmp) if (!tmp)
goto fail; goto fail;
h264->lumaData = tmp; h264->lumaData = tmp;
@ -696,13 +696,13 @@ void h264_context_free(H264_CONTEXT* h264)
{ {
if (h264->Compressor) if (h264->Compressor)
{ {
_aligned_free(h264->pYUVData[x]); winpr_aligned_free(h264->pYUVData[x]);
_aligned_free(h264->pOldYUVData[x]); winpr_aligned_free(h264->pOldYUVData[x]);
} }
_aligned_free(h264->pYUV444Data[x]); winpr_aligned_free(h264->pYUV444Data[x]);
_aligned_free(h264->pOldYUV444Data[x]); winpr_aligned_free(h264->pOldYUV444Data[x]);
} }
_aligned_free(h264->lumaData); winpr_aligned_free(h264->lumaData);
yuv_context_free(h264->yuv); yuv_context_free(h264->yuv);
free(h264); free(h264);

2
libfreerdp/codec/h264_mf.c
View File

@ -441,7 +441,7 @@ static void mf_uninit(H264_CONTEXT* h264)
} }
for (x = 0; x < sizeof(h264->pYUVData) / sizeof(h264->pYUVData[0]); x++) for (x = 0; x < sizeof(h264->pYUVData) / sizeof(h264->pYUVData[0]); x++)
_aligned_free(h264->pYUVData[x]); winpr_aligned_free(h264->pYUVData[x]);
memset(h264->pYUVData, 0, sizeof(h264->pYUVData)); memset(h264->pYUVData, 0, sizeof(h264->pYUVData));
memset(h264->iStride, 0, sizeof(h264->iStride)); memset(h264->iStride, 0, sizeof(h264->iStride));

8
libfreerdp/codec/interleaved.c
View File

@ -376,7 +376,7 @@ BOOL interleaved_decompress(BITMAP_INTERLEAVED_CONTEXT* interleaved, const BYTE*
if (BufferSize > interleaved->TempSize) if (BufferSize > interleaved->TempSize)
{ {
interleaved->TempBuffer = _aligned_realloc(interleaved->TempBuffer, BufferSize, 16); interleaved->TempBuffer = winpr_aligned_realloc(interleaved->TempBuffer, BufferSize, 16);
interleaved->TempSize = BufferSize; interleaved->TempSize = BufferSize;
} }
@ -504,7 +504,7 @@ BITMAP_INTERLEAVED_CONTEXT* bitmap_interleaved_context_new(BOOL Compressor)
if (interleaved) if (interleaved)
{ {
interleaved->TempSize = 64 * 64 * 4; interleaved->TempSize = 64 * 64 * 4;
interleaved->TempBuffer = _aligned_malloc(interleaved->TempSize, 16); interleaved->TempBuffer = winpr_aligned_malloc(interleaved->TempSize, 16);
if (!interleaved->TempBuffer) if (!interleaved->TempBuffer)
{ {
@ -517,7 +517,7 @@ BITMAP_INTERLEAVED_CONTEXT* bitmap_interleaved_context_new(BOOL Compressor)
if (!interleaved->bts) if (!interleaved->bts)
{ {
_aligned_free(interleaved->TempBuffer); winpr_aligned_free(interleaved->TempBuffer);
free(interleaved); free(interleaved);
WLog_ERR(TAG, "Stream_New failed!"); WLog_ERR(TAG, "Stream_New failed!");
return NULL; return NULL;
@ -532,7 +532,7 @@ void bitmap_interleaved_context_free(BITMAP_INTERLEAVED_CONTEXT* interleaved)
if (!interleaved) if (!interleaved)
return; return;
_aligned_free(interleaved->TempBuffer); winpr_aligned_free(interleaved->TempBuffer);
Stream_Free(interleaved->bts, TRUE); Stream_Free(interleaved->bts, TRUE);
free(interleaved); free(interleaved);
} }

12
libfreerdp/codec/progressive.c
View File

@ -376,9 +376,9 @@ static void progressive_tile_free(RFX_PROGRESSIVE_TILE* tile)
{ {
if (tile) if (tile)
{ {
_aligned_free(tile->sign); winpr_aligned_free(tile->sign);
_aligned_free(tile->current); winpr_aligned_free(tile->current);
_aligned_free(tile->data); winpr_aligned_free(tile->data);
} }
} }
@ -418,19 +418,19 @@ static INLINE BOOL progressive_tile_allocate(RFX_PROGRESSIVE_TILE* tile)
{ {
size_t dataLen = tile->stride * tile->height * 1ULL; size_t dataLen = tile->stride * tile->height * 1ULL;
tile->data = (BYTE*)_aligned_malloc(dataLen, 16); tile->data = (BYTE*)winpr_aligned_malloc(dataLen, 16);
if (tile->data) if (tile->data)
memset(tile->data, 0xFF, dataLen); memset(tile->data, 0xFF, dataLen);
} }
{ {
size_t signLen = (8192 + 32) * 3; size_t signLen = (8192 + 32) * 3;
tile->sign = (BYTE*)_aligned_malloc(signLen, 16); tile->sign = (BYTE*)winpr_aligned_malloc(signLen, 16);
} }
{ {
size_t currentLen = (8192 + 32) * 3; size_t currentLen = (8192 + 32) * 3;
tile->current = (BYTE*)_aligned_malloc(currentLen, 16); tile->current = (BYTE*)winpr_aligned_malloc(currentLen, 16);
} }
rc = tile->data && tile->sign && tile->current; rc = tile->data && tile->sign && tile->current;

4
libfreerdp/codec/rfx.c
View File

@ -167,7 +167,7 @@ static void* rfx_decoder_tile_new(const void* val)
if (!(tile = (RFX_TILE*)calloc(1, sizeof(RFX_TILE)))) if (!(tile = (RFX_TILE*)calloc(1, sizeof(RFX_TILE))))
return NULL; return NULL;
if (!(tile->data = (BYTE*)_aligned_malloc(size, 16))) if (!(tile->data = (BYTE*)winpr_aligned_malloc(size, 16)))
{ {
free(tile); free(tile);
return NULL; return NULL;
@ -184,7 +184,7 @@ static void rfx_decoder_tile_free(void* obj)
if (tile) if (tile)
{ {
if (tile->allocated) if (tile->allocated)
_aligned_free(tile->data); winpr_aligned_free(tile->data);
free(tile); free(tile);
} }

4
libfreerdp/codec/test/TestFreeRDPCodecProgressive.c
View File

@ -962,7 +962,7 @@ static int test_progressive_ms_sample(char* ms_sample_path)
count = 4; count = 4;
progressive = progressive_context_new(FALSE); progressive = progressive_context_new(FALSE);
g_DstData = _aligned_malloc(g_DstStep * g_Height, 16); g_DstData = winpr_aligned_malloc(g_DstStep * g_Height, 16);
progressive_create_surface_context(progressive, 0, g_Width, g_Height); progressive_create_surface_context(progressive, 0, g_Width, g_Height);
/* image 1 */ /* image 1 */
@ -1015,7 +1015,7 @@ static int test_progressive_ms_sample(char* ms_sample_path)
} }
} }
_aligned_free(g_DstData); winpr_aligned_free(g_DstData);
return 0; return 0;
} }

6
libfreerdp/gdi/bitmap.c
View File

@ -98,7 +98,7 @@ UINT32 gdi_SetPixel(HGDI_DC hdc, UINT32 X, UINT32 Y, UINT32 crColor)
HGDI_BITMAP gdi_CreateBitmap(UINT32 nWidth, UINT32 nHeight, UINT32 format, BYTE* data) HGDI_BITMAP gdi_CreateBitmap(UINT32 nWidth, UINT32 nHeight, UINT32 format, BYTE* data)
{ {
return gdi_CreateBitmapEx(nWidth, nHeight, format, 0, data, _aligned_free); return gdi_CreateBitmapEx(nWidth, nHeight, format, 0, data, winpr_aligned_free);
} }
/** /**
@ -156,8 +156,8 @@ HGDI_BITMAP gdi_CreateCompatibleBitmap(HGDI_DC hdc, UINT32 nWidth, UINT32 nHeigh
hBitmap->width = nWidth; hBitmap->width = nWidth;
hBitmap->height = nHeight; hBitmap->height = nHeight;
hBitmap->data = hBitmap->data =
_aligned_malloc(nWidth * nHeight * FreeRDPGetBytesPerPixel(hBitmap->format) * 1ULL, 16); winpr_aligned_malloc(nWidth * nHeight * FreeRDPGetBytesPerPixel(hBitmap->format) * 1ULL, 16);
hBitmap->free = _aligned_free; hBitmap->free = winpr_aligned_free;
if (!hBitmap->data) if (!hBitmap->data)
{ {

10
libfreerdp/gdi/gdi.c
View File

@ -868,7 +868,7 @@ static BOOL gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
{ {
HGDI_BITMAP hBmp; HGDI_BITMAP hBmp;
UINT32 brushFormat; UINT32 brushFormat;
BYTE* data = (BYTE*)_aligned_malloc( BYTE* data = (BYTE*)winpr_aligned_malloc(
8 * 8 * FreeRDPGetBytesPerPixel(gdi->drawing->hdc->format), 16); 8 * 8 * FreeRDPGetBytesPerPixel(gdi->drawing->hdc->format), 16);
if (!data) if (!data)
@ -891,7 +891,7 @@ static BOOL gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
brushFormat, 0, 0, 0, &gdi->palette, FREERDP_FLIP_NONE)) brushFormat, 0, 0, 0, &gdi->palette, FREERDP_FLIP_NONE))
{ {
ret = FALSE; ret = FALSE;
_aligned_free(data); winpr_aligned_free(data);
goto out_fail; goto out_fail;
} }
} }
@ -902,7 +902,7 @@ static BOOL gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
&gdi->palette)) &gdi->palette))
{ {
ret = FALSE; ret = FALSE;
_aligned_free(data); winpr_aligned_free(data);
goto out_fail; goto out_fail;
} }
} }
@ -912,7 +912,7 @@ static BOOL gdi_mem3blt(rdpContext* context, MEM3BLT_ORDER* mem3blt)
if (!hBmp) if (!hBmp)
{ {
ret = FALSE; ret = FALSE;
_aligned_free(data); winpr_aligned_free(data);
goto out_fail; goto out_fail;
} }
@ -1271,7 +1271,7 @@ BOOL gdi_resize_ex(rdpGdi* gdi, UINT32 width, UINT32 height, UINT32 stride, UINT
*/ */
BOOL gdi_init(freerdp* instance, UINT32 format) BOOL gdi_init(freerdp* instance, UINT32 format)
{ {
return gdi_init_ex(instance, format, 0, NULL, _aligned_free); return gdi_init_ex(instance, format, 0, NULL, winpr_aligned_free);
} }
BOOL gdi_init_ex(freerdp* instance, UINT32 format, UINT32 stride, BYTE* buffer, BOOL gdi_init_ex(freerdp* instance, UINT32 format, UINT32 stride, BYTE* buffer,

4
libfreerdp/gdi/gfx.c
View File

@ -1123,7 +1123,7 @@ static UINT gdi_CreateSurface(RdpgfxClientContext* context,
} }
surface->scanline = gfx_align_scanline(surface->width * 4UL, 16); surface->scanline = gfx_align_scanline(surface->width * 4UL, 16);
surface->data = (BYTE*)_aligned_malloc(surface->scanline * surface->height * 1ULL, 16); surface->data = (BYTE*)winpr_aligned_malloc(surface->scanline * surface->height * 1ULL, 16);
if (!surface->data) if (!surface->data)
{ {
@ -1166,7 +1166,7 @@ static UINT gdi_DeleteSurface(RdpgfxClientContext* context,
#endif #endif
region16_uninit(&surface->invalidRegion); region16_uninit(&surface->invalidRegion);
codecs = surface->codecs; codecs = surface->codecs;
_aligned_free(surface->data); winpr_aligned_free(surface->data);
free(surface); free(surface);
} }

10
libfreerdp/gdi/graphics.c
View File

@ -50,7 +50,7 @@ HGDI_BITMAP gdi_create_bitmap(rdpGdi* gdi, UINT32 nWidth, UINT32 nHeight, UINT32
return NULL; return NULL;
nDstStep = nWidth * FreeRDPGetBytesPerPixel(gdi->dstFormat); nDstStep = nWidth * FreeRDPGetBytesPerPixel(gdi->dstFormat);
pDstData = _aligned_malloc(nHeight * nDstStep * 1ULL, 16); pDstData = winpr_aligned_malloc(nHeight * nDstStep * 1ULL, 16);
if (!pDstData) if (!pDstData)
return NULL; return NULL;
@ -61,7 +61,7 @@ HGDI_BITMAP gdi_create_bitmap(rdpGdi* gdi, UINT32 nWidth, UINT32 nHeight, UINT32
if (!freerdp_image_copy(pDstData, gdi->dstFormat, nDstStep, 0, 0, nWidth, nHeight, pSrcData, if (!freerdp_image_copy(pDstData, gdi->dstFormat, nDstStep, 0, 0, nWidth, nHeight, pSrcData,
SrcFormat, nSrcStep, 0, 0, &gdi->palette, FREERDP_FLIP_NONE)) SrcFormat, nSrcStep, 0, 0, &gdi->palette, FREERDP_FLIP_NONE))
{ {
_aligned_free(pDstData); winpr_aligned_free(pDstData);
return NULL; return NULL;
} }
@ -112,7 +112,7 @@ static void gdi_Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
gdi_DeleteObject((HGDIOBJECT)gdi_bitmap->bitmap); gdi_DeleteObject((HGDIOBJECT)gdi_bitmap->bitmap);
gdi_DeleteDC(gdi_bitmap->hdc); gdi_DeleteDC(gdi_bitmap->hdc);
_aligned_free(bitmap->data); winpr_aligned_free(bitmap->data);
} }
free(bitmap); free(bitmap);
@ -144,7 +144,7 @@ static BOOL gdi_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap, const
size *= FreeRDPGetBytesPerPixel(bitmap->format); size *= FreeRDPGetBytesPerPixel(bitmap->format);
bitmap->length = size; bitmap->length = size;
bitmap->data = (BYTE*)_aligned_malloc(bitmap->length, 16); bitmap->data = (BYTE*)winpr_aligned_malloc(bitmap->length, 16);
if (!bitmap->data) if (!bitmap->data)
return FALSE; return FALSE;
@ -242,7 +242,7 @@ static BOOL gdi_Glyph_New(rdpContext* context, rdpGlyph* glyph)
if (!gdi_glyph->bitmap) if (!gdi_glyph->bitmap)
{ {
gdi_DeleteDC(gdi_glyph->hdc); gdi_DeleteDC(gdi_glyph->hdc);
_aligned_free(data); winpr_aligned_free(data);
return FALSE; return FALSE;
} }

2
libfreerdp/gdi/test/TestGdiCreate.c
View File

@ -92,7 +92,7 @@ static int test_gdi_CreateBitmap(void)
width = 32; width = 32;
height = 16; height = 16;
if (!(data = (BYTE*)_aligned_malloc(width * height * 4, 16))) if (!(data = (BYTE*)winpr_aligned_malloc(width * height * 4, 16)))
{ {
printf("failed to allocate aligned bitmap data memory\n"); printf("failed to allocate aligned bitmap data memory\n");
return -1; return -1;

6
libfreerdp/gdi/test/helpers.c
View File

@ -30,7 +30,7 @@ HGDI_BITMAP test_convert_to_bitmap(const BYTE* src, UINT32 SrcFormat, UINT32 Src
if (DstStride == 0) if (DstStride == 0)
DstStride = nWidth * FreeRDPGetBytesPerPixel(DstFormat); DstStride = nWidth * FreeRDPGetBytesPerPixel(DstFormat);
data = _aligned_malloc(DstStride * nHeight, 16); data = winpr_aligned_malloc(DstStride * nHeight, 16);
if (!data) if (!data)
return NULL; return NULL;
@ -38,7 +38,7 @@ HGDI_BITMAP test_convert_to_bitmap(const BYTE* src, UINT32 SrcFormat, UINT32 Src
if (!freerdp_image_copy(data, DstFormat, DstStride, xDst, yDst, nWidth, nHeight, src, SrcFormat, if (!freerdp_image_copy(data, DstFormat, DstStride, xDst, yDst, nWidth, nHeight, src, SrcFormat,
SrcStride, xSrc, ySrc, hPalette, FREERDP_FLIP_NONE)) SrcStride, xSrc, ySrc, hPalette, FREERDP_FLIP_NONE))
{ {
_aligned_free(data); winpr_aligned_free(data);
return NULL; return NULL;
} }
@ -46,7 +46,7 @@ HGDI_BITMAP test_convert_to_bitmap(const BYTE* src, UINT32 SrcFormat, UINT32 Src
if (!bmp) if (!bmp)
{ {
_aligned_free(data); winpr_aligned_free(data);
return NULL; return NULL;
} }

4
libfreerdp/gdi/video.c
View File

@ -194,7 +194,7 @@ VideoSurface* VideoClient_CreateCommonContext(size_t size, UINT32 x, UINT32 y, U
ret->alignedHeight = ret->h + 32 - ret->h % 16; ret->alignedHeight = ret->h + 32 - ret->h % 16;
ret->scanline = ret->alignedWidth * FreeRDPGetBytesPerPixel(ret->format); ret->scanline = ret->alignedWidth * FreeRDPGetBytesPerPixel(ret->format);
ret->data = _aligned_malloc(ret->scanline * ret->alignedHeight * 1ULL, 64); ret->data = winpr_aligned_malloc(ret->scanline * ret->alignedHeight * 1ULL, 64);
if (!ret->data) if (!ret->data)
goto fail; goto fail;
return ret; return ret;
@ -207,6 +207,6 @@ void VideoClient_DestroyCommonContext(VideoSurface* surface)
{ {
if (!surface) if (!surface)
return; return;
_aligned_free(surface->data); winpr_aligned_free(surface->data);
free(surface); free(surface);
} }

20
libfreerdp/primitives/test/TestPrimitivesColors.c
View File

@ -36,11 +36,11 @@ static BOOL test_RGBToRGB_16s8u_P3AC4R_func(prim_size_t roi, DWORD DstFormat)
PROFILER_DEFINE(optProf) PROFILER_DEFINE(optProf)
PROFILER_CREATE(genericProf, "RGBToRGB_16s8u_P3AC4R-GENERIC") PROFILER_CREATE(genericProf, "RGBToRGB_16s8u_P3AC4R-GENERIC")
PROFILER_CREATE(optProf, "RGBToRGB_16s8u_P3AC4R-OPTIMIZED") PROFILER_CREATE(optProf, "RGBToRGB_16s8u_P3AC4R-OPTIMIZED")
r = _aligned_recalloc(NULL, 1, rgbStride * roi.height, 16); r = winpr_aligned_recalloc(NULL, 1, rgbStride * roi.height, 16);
g = _aligned_recalloc(NULL, 1, rgbStride * roi.height, 16); g = winpr_aligned_recalloc(NULL, 1, rgbStride * roi.height, 16);
b = _aligned_recalloc(NULL, 1, rgbStride * roi.height, 16); b = winpr_aligned_recalloc(NULL, 1, rgbStride * roi.height, 16);
out1 = _aligned_recalloc(NULL, 1, dstStride * roi.height, 16); out1 = winpr_aligned_recalloc(NULL, 1, dstStride * roi.height, 16);
out2 = _aligned_recalloc(NULL, 1, dstStride * roi.height, 16); out2 = winpr_aligned_recalloc(NULL, 1, dstStride * roi.height, 16);
if (!r || !g || !b || !out1 || !out2) if (!r || !g || !b || !out1 || !out2)
goto fail; goto fail;
@ -108,11 +108,11 @@ static BOOL test_RGBToRGB_16s8u_P3AC4R_func(prim_size_t roi, DWORD DstFormat)
fail: fail:
PROFILER_FREE(genericProf) PROFILER_FREE(genericProf)
PROFILER_FREE(optProf) PROFILER_FREE(optProf)
_aligned_free(r); winpr_aligned_free(r);
_aligned_free(g); winpr_aligned_free(g);
_aligned_free(b); winpr_aligned_free(b);
_aligned_free(out1); winpr_aligned_free(out1);
_aligned_free(out2); winpr_aligned_free(out2);
return !failed; return !failed;
} }

32
libfreerdp/primitives/test/TestPrimitivesYCbCr.c
View File

@ -1586,8 +1586,8 @@ static int test_PrimitivesYCbCr(const primitives_t* prims, UINT32 format, prim_s
PROFILER_DEFINE(prof2) PROFILER_DEFINE(prof2)
// return test_YCbCr_pixels(); // return test_YCbCr_pixels();
actual = _aligned_malloc(dstSize, 16); actual = winpr_aligned_malloc(dstSize, 16);
actual1 = _aligned_malloc(dstSize, 16); actual1 = winpr_aligned_malloc(dstSize, 16);
PROFILER_CREATE(prof, "yCbCrToRGB_16s8u") PROFILER_CREATE(prof, "yCbCrToRGB_16s8u")
PROFILER_CREATE(prof1, "yCbCrToRGB16s16s") PROFILER_CREATE(prof1, "yCbCrToRGB16s16s")
PROFILER_CREATE(prof2, "RGBToRGB_16s8u") PROFILER_CREATE(prof2, "RGBToRGB_16s8u")
@ -1597,9 +1597,9 @@ static int test_PrimitivesYCbCr(const primitives_t* prims, UINT32 format, prim_s
ZeroMemory(actual, dstSize); ZeroMemory(actual, dstSize);
ZeroMemory(actual1, dstSize); ZeroMemory(actual1, dstSize);
pYCbCr[0] = _aligned_malloc(srcSize, 16); pYCbCr[0] = winpr_aligned_malloc(srcSize, 16);
pYCbCr[1] = _aligned_malloc(srcSize, 16); pYCbCr[1] = winpr_aligned_malloc(srcSize, 16);
pYCbCr[2] = _aligned_malloc(srcSize, 16); pYCbCr[2] = winpr_aligned_malloc(srcSize, 16);
if (!pYCbCr[0] || !pYCbCr[1] || !pYCbCr[2]) if (!pYCbCr[0] || !pYCbCr[1] || !pYCbCr[2])
goto fail; goto fail;
@ -1628,9 +1628,9 @@ static int test_PrimitivesYCbCr(const primitives_t* prims, UINT32 format, prim_s
{ {
INT16* pSrcDst[3]; INT16* pSrcDst[3];
pSrcDst[0] = _aligned_malloc(srcSize, 16); pSrcDst[0] = winpr_aligned_malloc(srcSize, 16);
pSrcDst[1] = _aligned_malloc(srcSize, 16); pSrcDst[1] = winpr_aligned_malloc(srcSize, 16);
pSrcDst[2] = _aligned_malloc(srcSize, 16); pSrcDst[2] = winpr_aligned_malloc(srcSize, 16);
CopyMemory(pSrcDst[0], pYCbCr[0], srcSize); CopyMemory(pSrcDst[0], pYCbCr[0], srcSize);
CopyMemory(pSrcDst[1], pYCbCr[1], srcSize); CopyMemory(pSrcDst[1], pYCbCr[1], srcSize);
CopyMemory(pSrcDst[2], pYCbCr[2], srcSize); CopyMemory(pSrcDst[2], pYCbCr[2], srcSize);
@ -1646,9 +1646,9 @@ static int test_PrimitivesYCbCr(const primitives_t* prims, UINT32 format, prim_s
status = prims->RGBToRGB_16s8u_P3AC4R(cnv.cpi, srcStride, actual1, dstStride, format, &roi); status = prims->RGBToRGB_16s8u_P3AC4R(cnv.cpi, srcStride, actual1, dstStride, format, &roi);
PROFILER_EXIT(prof2) PROFILER_EXIT(prof2)
fail2: fail2:
_aligned_free(pSrcDst[0]); winpr_aligned_free(pSrcDst[0]);
_aligned_free(pSrcDst[1]); winpr_aligned_free(pSrcDst[1]);
_aligned_free(pSrcDst[2]); winpr_aligned_free(pSrcDst[2]);
if (status != PRIMITIVES_SUCCESS) if (status != PRIMITIVES_SUCCESS)
goto fail; goto fail;
@ -1705,11 +1705,11 @@ static int test_PrimitivesYCbCr(const primitives_t* prims, UINT32 format, prim_s
PROFILER_PRINT(prof2) PROFILER_PRINT(prof2)
PROFILER_PRINT_FOOTER PROFILER_PRINT_FOOTER
fail: fail:
_aligned_free((BYTE*)pYCbCr[0]); winpr_aligned_free((BYTE*)pYCbCr[0]);
_aligned_free((BYTE*)pYCbCr[1]); winpr_aligned_free((BYTE*)pYCbCr[1]);
_aligned_free((BYTE*)pYCbCr[2]); winpr_aligned_free((BYTE*)pYCbCr[2]);
_aligned_free(actual); winpr_aligned_free(actual);
_aligned_free(actual1); winpr_aligned_free(actual1);
PROFILER_FREE(prof) PROFILER_FREE(prof)
PROFILER_FREE(prof1) PROFILER_FREE(prof1)
PROFILER_FREE(prof2) PROFILER_FREE(prof2)

12
libfreerdp/primitives/test/TestPrimitivesYCoCg.c
View File

@ -36,9 +36,9 @@ static BOOL test_YCoCgRToRGB_8u_AC4R_func(UINT32 width, UINT32 height)
PIXEL_FORMAT_RGBX32, PIXEL_FORMAT_BGRA32, PIXEL_FORMAT_BGRX32 }; PIXEL_FORMAT_RGBX32, PIXEL_FORMAT_BGRA32, PIXEL_FORMAT_BGRX32 };
PROFILER_DEFINE(genericProf) PROFILER_DEFINE(genericProf)
PROFILER_DEFINE(optProf) PROFILER_DEFINE(optProf)
in = _aligned_recalloc(NULL, 1, size, 16); in = winpr_aligned_recalloc(NULL, 1, size, 16);
out_c = _aligned_recalloc(NULL, 1, size, 16); out_c = winpr_aligned_recalloc(NULL, 1, size, 16);
out_sse = _aligned_recalloc(NULL, 1, size, 16); out_sse = winpr_aligned_recalloc(NULL, 1, size, 16);
if (!in || !out_c || !out_sse) if (!in || !out_c || !out_sse)
goto fail; goto fail;
@ -101,9 +101,9 @@ static BOOL test_YCoCgRToRGB_8u_AC4R_func(UINT32 width, UINT32 height)
} }
fail: fail:
_aligned_free(in); winpr_aligned_free(in);
_aligned_free(out_c); winpr_aligned_free(out_c);
_aligned_free(out_sse); winpr_aligned_free(out_sse);
return status == PRIMITIVES_SUCCESS; return status == PRIMITIVES_SUCCESS;
} }

6
libfreerdp/primitives/test/TestPrimitivesYUV.c
View File

@ -140,7 +140,7 @@ static void* set_padding(size_t size, size_t padding)
{ {
size_t halfPad = (padding + 1) / 2; size_t halfPad = (padding + 1) / 2;
BYTE* psrc; BYTE* psrc;
BYTE* src = _aligned_malloc(size + 2 * halfPad, 16); BYTE* src = winpr_aligned_malloc(size + 2 * halfPad, 16);
if (!src) if (!src)
return NULL; return NULL;
@ -152,7 +152,7 @@ static void* set_padding(size_t size, size_t padding)
if (!check_padding(psrc, size, padding, "init")) if (!check_padding(psrc, size, padding, "init"))
{ {
_aligned_free(src); winpr_aligned_free(src);
return NULL; return NULL;
} }
@ -167,7 +167,7 @@ static void free_padding(void* src, size_t padding)
return; return;
ptr = ((BYTE*)src) - (padding + 1) / 2; ptr = ((BYTE*)src) - (padding + 1) / 2;
_aligned_free(ptr); winpr_aligned_free(ptr);
} }
/* Create 2 pseudo YUV420 frames of same size. /* Create 2 pseudo YUV420 frames of same size.

4
server/shadow/X11/x11_shadow.c
View File

@ -1320,7 +1320,7 @@ static int x11_shadow_subsystem_init(rdpShadowSubsystem* sub)
subsystem->cursorMaxWidth = 256; subsystem->cursorMaxWidth = 256;
subsystem->cursorMaxHeight = 256; subsystem->cursorMaxHeight = 256;
subsystem->cursorPixels = subsystem->cursorPixels =
_aligned_malloc(subsystem->cursorMaxWidth * subsystem->cursorMaxHeight * 4, 16); winpr_aligned_malloc(subsystem->cursorMaxWidth * subsystem->cursorMaxHeight * 4, 16);
if (!subsystem->cursorPixels) if (!subsystem->cursorPixels)
return -1; return -1;
@ -1394,7 +1394,7 @@ static int x11_shadow_subsystem_uninit(rdpShadowSubsystem* sub)
if (subsystem->cursorPixels) if (subsystem->cursorPixels)
{ {
_aligned_free(subsystem->cursorPixels); winpr_aligned_free(subsystem->cursorPixels);
subsystem->cursorPixels = NULL; subsystem->cursorPixels = NULL;
} }

76
winpr/include/winpr/crt.h
View File

@ -125,6 +125,8 @@ extern "C"
} }
#endif #endif
#endif /* _WIN32 */
/* Data Alignment */ /* Data Alignment */
#if defined(__clang__) #if defined(__clang__)
@ -146,19 +148,7 @@ extern "C"
{ {
#endif #endif
WINPR_API void* _aligned_malloc(size_t size, size_t alignment); #ifndef _WIN32
WINPR_API void* _aligned_realloc(void* memblock, size_t size, size_t alignment);
WINPR_API void* _aligned_recalloc(void* memblock, size_t num, size_t size, size_t alignment);
WINPR_API void* _aligned_offset_malloc(size_t size, size_t alignment, size_t offset);
WINPR_API void* _aligned_offset_realloc(void* memblock, size_t size, size_t alignment,
size_t offset);
WINPR_API void* _aligned_offset_recalloc(void* memblock, size_t num, size_t size,
size_t alignment, size_t offset);
WINPR_API size_t _aligned_msize(void* memblock, size_t alignment, size_t offset);
WINPR_API void _aligned_free(void* memblock);
/* Data Conversion */ /* Data Conversion */
@ -169,11 +159,69 @@ extern "C"
WINPR_API errno_t memmove_s(void* dest, size_t numberOfElements, const void* src, size_t count); WINPR_API errno_t memmove_s(void* dest, size_t numberOfElements, const void* src, size_t count);
WINPR_API errno_t wmemmove_s(WCHAR* dest, size_t numberOfElements, const WCHAR* src, WINPR_API errno_t wmemmove_s(WCHAR* dest, size_t numberOfElements, const WCHAR* src,
size_t count); size_t count);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _WIN32 */ #endif /* _WIN32 */
#if !defined(_WIN32) || (defined(__MINGW32__) && ! defined(_UCRT))
/* note: we use our own implementation of _aligned_XXX function when:
* - it's not win32
* - it's mingw with native libs (not ucrt64) because we didn't managed to have it working
* and not have C runtime deadly mixes
*/
#if WINPR_MSVCR_ALIGNMENT_EMULATE
#define _aligned_malloc winpr_aligned_malloc
#define _aligned_realloc winpr_aligned_realloc
#define _aligned_recalloc winpr_aligned_recalloc
#define _aligned_offset_malloc winpr_aligned_offset_malloc
#define _aligned_offset_realloc winpr_aligned_offset_realloc
#define _aligned_offset_recalloc winpr_aligned_offset_recalloc
#define _aligned_msize winpr_aligned_msize
#define _aligned_free winpr_aligned_free
#endif
#ifdef __cplusplus
extern "C"
{
#endif
WINPR_API void* winpr_aligned_malloc(size_t size, size_t alignment);
WINPR_API void* winpr_aligned_realloc(void* memblock, size_t size, size_t alignment);
WINPR_API void* winpr_aligned_recalloc(void* memblock, size_t num, size_t size, size_t alignment);
WINPR_API void* winpr_aligned_offset_malloc(size_t size, size_t alignment, size_t offset);
WINPR_API void* winpr_aligned_offset_realloc(void* memblock, size_t size, size_t alignment,
size_t offset);
WINPR_API void* winpr_aligned_offset_recalloc(void* memblock, size_t num, size_t size,
size_t alignment, size_t offset);
WINPR_API size_t winpr_aligned_msize(void* memblock, size_t alignment, size_t offset);
WINPR_API void winpr_aligned_free(void* memblock);
#ifdef __cplusplus
}
#endif
#else
#define winpr_aligned_malloc _aligned_malloc
#define winpr_aligned_realloc _aligned_realloc
#define winpr_aligned_recalloc _aligned_recalloc
#define winpr_aligned_offset_malloc _aligned_offset_malloc
#define winpr_aligned_offset_realloc _aligned_offset_realloc
#define winpr_aligned_offset_recalloc _aligned_offset_recalloc
#define winpr_aligned_msize _aligned_msize
#define winpr_aligned_free _aligned_free
#endif /* !defined(_WIN32) || (defined(__MINGW32__) ... */
#endif /* WINPR_CRT_H */ #endif /* WINPR_CRT_H */

38
winpr/libwinpr/crt/alignment.c
View File

@ -23,7 +23,7 @@
/* Data Alignment: http://msdn.microsoft.com/en-us/library/fs9stz4e/ */ /* Data Alignment: http://msdn.microsoft.com/en-us/library/fs9stz4e/ */
#ifndef _WIN32 #if !defined(_WIN32) || (defined(__MINGW32__) && ! defined(_UCRT))
#include <stdint.h> #include <stdint.h>
#include <limits.h> #include <limits.h>
@ -54,22 +54,22 @@ struct winpr_aligned_mem
}; };
typedef struct winpr_aligned_mem WINPR_ALIGNED_MEM; typedef struct winpr_aligned_mem WINPR_ALIGNED_MEM;
void* _aligned_malloc(size_t size, size_t alignment) void* winpr_aligned_malloc(size_t size, size_t alignment)
{ {
return _aligned_offset_malloc(size, alignment, 0); return winpr_aligned_offset_malloc(size, alignment, 0);
} }
void* _aligned_realloc(void* memblock, size_t size, size_t alignment) void* winpr_aligned_realloc(void* memblock, size_t size, size_t alignment)
{ {
return _aligned_offset_realloc(memblock, size, alignment, 0); return winpr_aligned_offset_realloc(memblock, size, alignment, 0);
} }
void* _aligned_recalloc(void* memblock, size_t num, size_t size, size_t alignment) void* winpr_aligned_recalloc(void* memblock, size_t num, size_t size, size_t alignment)
{ {
return _aligned_offset_recalloc(memblock, num, size, alignment, 0); return winpr_aligned_offset_recalloc(memblock, num, size, alignment, 0);
} }
void* _aligned_offset_malloc(size_t size, size_t alignment, size_t offset) void* winpr_aligned_offset_malloc(size_t size, size_t alignment, size_t offset)
{ {
size_t header, alignsize; size_t header, alignsize;
uintptr_t basesize; uintptr_t basesize;
@ -121,7 +121,7 @@ void* _aligned_offset_malloc(size_t size, size_t alignment, size_t offset)
return memblock; return memblock;
} }
void* _aligned_offset_realloc(void* memblock, size_t size, size_t alignment, size_t offset) void* winpr_aligned_offset_realloc(void* memblock, size_t size, size_t alignment, size_t offset)
{ {
size_t copySize; size_t copySize;
void* newMemblock; void* newMemblock;
@ -129,7 +129,7 @@ void* _aligned_offset_realloc(void* memblock, size_t size, size_t alignment, siz
WINPR_ALIGNED_MEM* pNewMem; WINPR_ALIGNED_MEM* pNewMem;
if (!memblock) if (!memblock)
return _aligned_offset_malloc(size, alignment, offset); return winpr_aligned_offset_malloc(size, alignment, offset);
pMem = WINPR_ALIGNED_MEM_STRUCT_FROM_PTR(memblock); pMem = WINPR_ALIGNED_MEM_STRUCT_FROM_PTR(memblock);
@ -142,11 +142,11 @@ void* _aligned_offset_realloc(void* memblock, size_t size, size_t alignment, siz
if (size == 0) if (size == 0)
{ {
_aligned_free(memblock); winpr_aligned_free(memblock);
return NULL; return NULL;
} }
newMemblock = _aligned_offset_malloc(size, alignment, offset); newMemblock = winpr_aligned_offset_malloc(size, alignment, offset);
if (!newMemblock) if (!newMemblock)
return NULL; return NULL;
@ -154,7 +154,7 @@ void* _aligned_offset_realloc(void* memblock, size_t size, size_t alignment, siz
pNewMem = WINPR_ALIGNED_MEM_STRUCT_FROM_PTR(newMemblock); pNewMem = WINPR_ALIGNED_MEM_STRUCT_FROM_PTR(newMemblock);
copySize = (pNewMem->size < pMem->size) ? pNewMem->size : pMem->size; copySize = (pNewMem->size < pMem->size) ? pNewMem->size : pMem->size;
CopyMemory(newMemblock, memblock, copySize); CopyMemory(newMemblock, memblock, copySize);
_aligned_free(memblock); winpr_aligned_free(memblock);
return newMemblock; return newMemblock;
} }
@ -165,7 +165,7 @@ static INLINE size_t cMIN(size_t a, size_t b)
return a; return a;
} }
void* _aligned_offset_recalloc(void* memblock, size_t num, size_t size, size_t alignment, void* winpr_aligned_offset_recalloc(void* memblock, size_t num, size_t size, size_t alignment,
size_t offset) size_t offset)
{ {
char* newMemblock = NULL; char* newMemblock = NULL;
@ -174,7 +174,7 @@ void* _aligned_offset_recalloc(void* memblock, size_t num, size_t size, size_t a
if (!memblock) if (!memblock)
{ {
newMemblock = _aligned_offset_malloc(size * num, alignment, offset); newMemblock = winpr_aligned_offset_malloc(size * num, alignment, offset);
if (newMemblock) if (newMemblock)
{ {
@ -197,7 +197,7 @@ void* _aligned_offset_recalloc(void* memblock, size_t num, size_t size, size_t a
if (size == 0) if (size == 0)
goto fail; goto fail;
newMemblock = _aligned_offset_malloc(size * num, alignment, offset); newMemblock = winpr_aligned_offset_malloc(size * num, alignment, offset);
if (!newMemblock) if (!newMemblock)
goto fail; goto fail;
@ -209,11 +209,11 @@ void* _aligned_offset_recalloc(void* memblock, size_t num, size_t size, size_t a
ZeroMemory(newMemblock + csize, pNewMem->size - csize); ZeroMemory(newMemblock + csize, pNewMem->size - csize);
} }
fail: fail:
_aligned_free(memblock); winpr_aligned_free(memblock);
return newMemblock; return newMemblock;
} }
size_t _aligned_msize(void* memblock, size_t alignment, size_t offset) size_t winpr_aligned_msize(void* memblock, size_t alignment, size_t offset)
{ {
WINPR_ALIGNED_MEM* pMem; WINPR_ALIGNED_MEM* pMem;
@ -231,7 +231,7 @@ size_t _aligned_msize(void* memblock, size_t alignment, size_t offset)
return pMem->size; return pMem->size;
} }
void _aligned_free(void* memblock) void winpr_aligned_free(void* memblock)
{ {
WINPR_ALIGNED_MEM* pMem; WINPR_ALIGNED_MEM* pMem;

12
winpr/libwinpr/crt/test/TestAlignment.c
View File

@ -19,7 +19,7 @@ int TestAlignment(int argc, char* argv[])
/* _aligned_malloc */ /* _aligned_malloc */
ptr = _aligned_malloc(100, alignment); ptr = winpr_aligned_malloc(100, alignment);
if (ptr == NULL) if (ptr == NULL)
{ {
@ -35,7 +35,7 @@ int TestAlignment(int argc, char* argv[])
/* _aligned_realloc */ /* _aligned_realloc */
ptr = _aligned_realloc(ptr, 200, alignment); ptr = winpr_aligned_realloc(ptr, 200, alignment);
if (((size_t)ptr % alignment) != 0) if (((size_t)ptr % alignment) != 0)
{ {
@ -43,11 +43,11 @@ int TestAlignment(int argc, char* argv[])
return -1; return -1;
} }
_aligned_free(ptr); winpr_aligned_free(ptr);
/* _aligned_offset_malloc */ /* _aligned_offset_malloc */
ptr = _aligned_offset_malloc(200, alignment, offset); ptr = winpr_aligned_offset_malloc(200, alignment, offset);
if (ptr == NULL) if (ptr == NULL)
{ {
@ -64,7 +64,7 @@ int TestAlignment(int argc, char* argv[])
/* _aligned_offset_realloc */ /* _aligned_offset_realloc */
ptr = _aligned_offset_realloc(ptr, 200, alignment, offset); ptr = winpr_aligned_offset_realloc(ptr, 200, alignment, offset);
if (ptr == NULL) if (ptr == NULL)
{ {
@ -81,7 +81,7 @@ int TestAlignment(int argc, char* argv[])
/* _aligned_free works for both _aligned_malloc and _aligned_offset_malloc. free() should not be /* _aligned_free works for both _aligned_malloc and _aligned_offset_malloc. free() should not be
* used. */ * used. */
_aligned_free(ptr); winpr_aligned_free(ptr);
return 0; return 0;
} }

3
winpr/libwinpr/error/test/TestErrorSetLastError.c
View File

@ -83,7 +83,7 @@ int TestErrorSetLastError(int argc, char* argv[])
return -1; return -1;
} }
pLoopCount = _aligned_malloc(sizeof(LONG), sizeof(LONG)); pLoopCount = winpr_aligned_malloc(sizeof(LONG), sizeof(LONG));
if (!pLoopCount) if (!pLoopCount)
{ {
printf("Unable to allocate memory\n"); printf("Unable to allocate memory\n");
@ -130,6 +130,7 @@ int TestErrorSetLastError(int argc, char* argv[])
} }
printf("Completed %" PRId32 " iterations.\n", *pLoopCount); printf("Completed %" PRId32 " iterations.\n", *pLoopCount);
winpr_aligned_free(pLoopCount);
return status; return status;
} }

16
winpr/libwinpr/interlocked/test/TestInterlockedAccess.c
View File

@ -16,7 +16,7 @@ int TestInterlockedAccess(int argc, char* argv[])
WINPR_UNUSED(argv); WINPR_UNUSED(argv);
/* InterlockedIncrement */ /* InterlockedIncrement */
Addend = _aligned_malloc(sizeof(LONG), sizeof(LONG)); Addend = winpr_aligned_malloc(sizeof(LONG), sizeof(LONG));
if (!Addend) if (!Addend)
{ {
printf("Failed to allocate memory\n"); printf("Failed to allocate memory\n");
@ -47,7 +47,7 @@ int TestInterlockedAccess(int argc, char* argv[])
/* InterlockedExchange */ /* InterlockedExchange */
Target = _aligned_malloc(sizeof(LONG), sizeof(LONG)); Target = winpr_aligned_malloc(sizeof(LONG), sizeof(LONG));
if (!Target) if (!Target)
{ {
@ -91,7 +91,7 @@ int TestInterlockedAccess(int argc, char* argv[])
/* InterlockedCompareExchange (*Destination == Comparand) */ /* InterlockedCompareExchange (*Destination == Comparand) */
Destination = _aligned_malloc(sizeof(LONG), sizeof(LONG)); Destination = winpr_aligned_malloc(sizeof(LONG), sizeof(LONG));
if (!Destination) if (!Destination)
{ {
printf("Failed to allocate memory\n"); printf("Failed to allocate memory\n");
@ -142,7 +142,7 @@ int TestInterlockedAccess(int argc, char* argv[])
/* InterlockedCompareExchange64 (*Destination == Comparand) */ /* InterlockedCompareExchange64 (*Destination == Comparand) */
Destination64 = _aligned_malloc(sizeof(LONGLONG), sizeof(LONGLONG)); Destination64 = winpr_aligned_malloc(sizeof(LONGLONG), sizeof(LONGLONG));
if (!Destination64) if (!Destination64)
{ {
printf("Failed to allocate memory\n"); printf("Failed to allocate memory\n");
@ -192,10 +192,10 @@ int TestInterlockedAccess(int argc, char* argv[])
return -1; return -1;
} }
_aligned_free(Addend); winpr_aligned_free(Addend);
_aligned_free(Target); winpr_aligned_free(Target);
_aligned_free(Destination); winpr_aligned_free(Destination);
_aligned_free(Destination64); winpr_aligned_free(Destination64);
return 0; return 0;
} }

12
winpr/libwinpr/interlocked/test/TestInterlockedDList.c
View File

@ -19,7 +19,7 @@ int TestInterlockedDList(int argc, char* argv[])
WINPR_UNUSED(argc); WINPR_UNUSED(argc);
WINPR_UNUSED(argv); WINPR_UNUSED(argv);
pListHead = pListHead =
(WINPR_PLIST_ENTRY)_aligned_malloc(sizeof(WINPR_LIST_ENTRY), MEMORY_ALLOCATION_ALIGNMENT); (WINPR_PLIST_ENTRY)winpr_aligned_malloc(sizeof(WINPR_LIST_ENTRY), MEMORY_ALLOCATION_ALIGNMENT);
if (!pListHead) if (!pListHead)
{ {
@ -41,7 +41,7 @@ int TestInterlockedDList(int argc, char* argv[])
for (Count = 1; Count <= 10; Count += 1) for (Count = 1; Count <= 10; Count += 1)
{ {
pListItem = (PLIST_ITEM)_aligned_malloc(sizeof(LIST_ITEM), MEMORY_ALLOCATION_ALIGNMENT); pListItem = (PLIST_ITEM)winpr_aligned_malloc(sizeof(LIST_ITEM), MEMORY_ALLOCATION_ALIGNMENT);
pListItem->Signature = Count; pListItem->Signature = Count;
InsertHeadList(pListHead, &(pListItem->ItemEntry)); InsertHeadList(pListHead, &(pListItem->ItemEntry));
} }
@ -50,7 +50,7 @@ int TestInterlockedDList(int argc, char* argv[])
{ {
pListEntry = RemoveHeadList(pListHead); pListEntry = RemoveHeadList(pListHead);
pListItem = (PLIST_ITEM)pListEntry; pListItem = (PLIST_ITEM)pListEntry;
_aligned_free(pListItem); winpr_aligned_free(pListItem);
} }
/* InsertTailList / RemoveTailList */ /* InsertTailList / RemoveTailList */
@ -59,7 +59,7 @@ int TestInterlockedDList(int argc, char* argv[])
for (Count = 1; Count <= 10; Count += 1) for (Count = 1; Count <= 10; Count += 1)
{ {
pListItem = (PLIST_ITEM)_aligned_malloc(sizeof(LIST_ITEM), MEMORY_ALLOCATION_ALIGNMENT); pListItem = (PLIST_ITEM)winpr_aligned_malloc(sizeof(LIST_ITEM), MEMORY_ALLOCATION_ALIGNMENT);
pListItem->Signature = Count; pListItem->Signature = Count;
InsertTailList(pListHead, &(pListItem->ItemEntry)); InsertTailList(pListHead, &(pListItem->ItemEntry));
} }
@ -68,10 +68,10 @@ int TestInterlockedDList(int argc, char* argv[])
{ {
pListEntry = RemoveTailList(pListHead); pListEntry = RemoveTailList(pListHead);
pListItem = (PLIST_ITEM)pListEntry; pListItem = (PLIST_ITEM)pListEntry;
_aligned_free(pListItem); winpr_aligned_free(pListItem);
} }
_aligned_free(pListHead); winpr_aligned_free(pListHead);
return 0; return 0;
} }

8
winpr/libwinpr/interlocked/test/TestInterlockedSList.c
View File

@ -18,7 +18,7 @@ int TestInterlockedSList(int argc, char* argv[])
WINPR_UNUSED(argc); WINPR_UNUSED(argc);
WINPR_UNUSED(argv); WINPR_UNUSED(argv);
/* Initialize the list header to a MEMORY_ALLOCATION_ALIGNMENT boundary. */ /* Initialize the list header to a MEMORY_ALLOCATION_ALIGNMENT boundary. */
pListHead = (WINPR_PSLIST_HEADER)_aligned_malloc(sizeof(WINPR_SLIST_HEADER), pListHead = (WINPR_PSLIST_HEADER)winpr_aligned_malloc(sizeof(WINPR_SLIST_HEADER),
MEMORY_ALLOCATION_ALIGNMENT); MEMORY_ALLOCATION_ALIGNMENT);
if (!pListHead) if (!pListHead)
@ -33,7 +33,7 @@ int TestInterlockedSList(int argc, char* argv[])
for (Count = 1; Count <= 10; Count += 1) for (Count = 1; Count <= 10; Count += 1)
{ {
PPROGRAM_ITEM pProgramItem = PPROGRAM_ITEM pProgramItem =
(PPROGRAM_ITEM)_aligned_malloc(sizeof(PROGRAM_ITEM), MEMORY_ALLOCATION_ALIGNMENT); (PPROGRAM_ITEM)winpr_aligned_malloc(sizeof(PROGRAM_ITEM), MEMORY_ALLOCATION_ALIGNMENT);
if (!pProgramItem) if (!pProgramItem)
{ {
@ -67,7 +67,7 @@ int TestInterlockedSList(int argc, char* argv[])
* of the structure before calling the free function. * of the structure before calling the free function.
*/ */
_aligned_free(pListEntry); winpr_aligned_free(pListEntry);
} }
/* Flush the list and verify that the items are gone. */ /* Flush the list and verify that the items are gone. */
@ -79,7 +79,7 @@ int TestInterlockedSList(int argc, char* argv[])
return -1; return -1;
} }
_aligned_free(pListHead); winpr_aligned_free(pListHead);
return 0; return 0;
} }

4
winpr/libwinpr/pool/test/CMakeLists.txt
View File

@ -18,10 +18,6 @@ create_test_sourcelist(${MODULE_PREFIX}_SRCS
add_executable(${MODULE_NAME} ${${MODULE_PREFIX}_SRCS}) add_executable(${MODULE_NAME} ${${MODULE_PREFIX}_SRCS})
target_link_libraries(${MODULE_NAME} winpr) target_link_libraries(${MODULE_NAME} winpr)
if (MINGW)
target_link_libraries(${MODULE_NAME} ucrt)
endif()
set_target_properties(${MODULE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${TESTING_OUTPUT_DIRECTORY}") set_target_properties(${MODULE_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${TESTING_OUTPUT_DIRECTORY}")

16
winpr/libwinpr/synch/test/TestSynchInit.c
View File

@ -75,10 +75,10 @@ int TestSynchInit(int argc, char* argv[])
WINPR_UNUSED(argc); WINPR_UNUSED(argc);
WINPR_UNUSED(argv); WINPR_UNUSED(argv);
pErrors = _aligned_malloc(sizeof(LONG), sizeof(LONG)); pErrors = winpr_aligned_malloc(sizeof(LONG), sizeof(LONG));
pTestThreadFunctionCalls = _aligned_malloc(sizeof(LONG), sizeof(LONG)); pTestThreadFunctionCalls = winpr_aligned_malloc(sizeof(LONG), sizeof(LONG));
pTestOnceFunctionCalls = _aligned_malloc(sizeof(LONG), sizeof(LONG)); pTestOnceFunctionCalls = winpr_aligned_malloc(sizeof(LONG), sizeof(LONG));
pInitOnceExecuteOnceCalls = _aligned_malloc(sizeof(LONG), sizeof(LONG)); pInitOnceExecuteOnceCalls = winpr_aligned_malloc(sizeof(LONG), sizeof(LONG));
if (!pErrors || !pTestThreadFunctionCalls || !pTestOnceFunctionCalls || if (!pErrors || !pTestThreadFunctionCalls || !pTestOnceFunctionCalls ||
!pInitOnceExecuteOnceCalls) !pInitOnceExecuteOnceCalls)
@ -141,10 +141,10 @@ out:
fprintf(stderr, "TestOnceFunctionCalls: %" PRId32 "\n", fprintf(stderr, "TestOnceFunctionCalls: %" PRId32 "\n",
pTestOnceFunctionCalls ? *pTestOnceFunctionCalls : -1); pTestOnceFunctionCalls ? *pTestOnceFunctionCalls : -1);
_aligned_free(pErrors); winpr_aligned_free(pErrors);
_aligned_free(pTestThreadFunctionCalls); winpr_aligned_free(pTestThreadFunctionCalls);
_aligned_free(pTestOnceFunctionCalls); winpr_aligned_free(pTestOnceFunctionCalls);
_aligned_free(pInitOnceExecuteOnceCalls); winpr_aligned_free(pInitOnceExecuteOnceCalls);
CloseHandle(hStartEvent); CloseHandle(hStartEvent);

18
winpr/libwinpr/utils/collections/BufferPool.c
View File

@ -92,7 +92,7 @@ static BOOL BufferPool_ShiftAvailable(wBufferPool* pool, size_t index, int count
SSIZE_T newCapacity = pool->aCapacity * 2; SSIZE_T newCapacity = pool->aCapacity * 2;
if (pool->alignment > 0) if (pool->alignment > 0)
newArray = (wBufferPoolItem*)_aligned_realloc( newArray = (wBufferPoolItem*)winpr_aligned_realloc(
pool->aArray, sizeof(wBufferPoolItem) * newCapacity, pool->alignment); pool->aArray, sizeof(wBufferPoolItem) * newCapacity, pool->alignment);
else else
newArray = newArray =
@ -125,7 +125,7 @@ static BOOL BufferPool_ShiftUsed(wBufferPool* pool, SSIZE_T index, SSIZE_T count
SSIZE_T newUCapacity = pool->uCapacity * 2; SSIZE_T newUCapacity = pool->uCapacity * 2;
wBufferPoolItem* newUArray; wBufferPoolItem* newUArray;
if (pool->alignment > 0) if (pool->alignment > 0)
newUArray = (wBufferPoolItem*)_aligned_realloc( newUArray = (wBufferPoolItem*)winpr_aligned_realloc(
pool->uArray, sizeof(wBufferPoolItem) * newUCapacity, pool->alignment); pool->uArray, sizeof(wBufferPoolItem) * newUCapacity, pool->alignment);
else else
newUArray = newUArray =
@ -238,7 +238,7 @@ void* BufferPool_Take(wBufferPool* pool, SSIZE_T size)
if (!buffer) if (!buffer)
{ {
if (pool->alignment) if (pool->alignment)
buffer = _aligned_malloc(pool->fixedSize, pool->alignment); buffer = winpr_aligned_malloc(pool->fixedSize, pool->alignment);
else else
buffer = malloc(pool->fixedSize); buffer = malloc(pool->fixedSize);
} }
@ -285,7 +285,7 @@ void* BufferPool_Take(wBufferPool* pool, SSIZE_T size)
else else
{ {
if (pool->alignment) if (pool->alignment)
buffer = _aligned_malloc(size, pool->alignment); buffer = winpr_aligned_malloc(size, pool->alignment);
else else
buffer = malloc(size); buffer = malloc(size);
@ -301,7 +301,7 @@ void* BufferPool_Take(wBufferPool* pool, SSIZE_T size)
{ {
void* newBuffer; void* newBuffer;
if (pool->alignment) if (pool->alignment)
newBuffer = _aligned_realloc(buffer, size, pool->alignment); newBuffer = winpr_aligned_realloc(buffer, size, pool->alignment);
else else
newBuffer = realloc(buffer, size); newBuffer = realloc(buffer, size);
@ -341,7 +341,7 @@ void* BufferPool_Take(wBufferPool* pool, SSIZE_T size)
out_error: out_error:
if (pool->alignment) if (pool->alignment)
_aligned_free(buffer); winpr_aligned_free(buffer);
else else
free(buffer); free(buffer);
out_error_no_free: out_error_no_free:
@ -442,7 +442,7 @@ void BufferPool_Clear(wBufferPool* pool)
(pool->size)--; (pool->size)--;
if (pool->alignment) if (pool->alignment)
_aligned_free(pool->array[pool->size]); winpr_aligned_free(pool->array[pool->size]);
else else
free(pool->array[pool->size]); free(pool->array[pool->size]);
} }
@ -456,7 +456,7 @@ void BufferPool_Clear(wBufferPool* pool)
(pool->aSize)--; (pool->aSize)--;
if (pool->alignment) if (pool->alignment)
_aligned_free(pool->aArray[pool->aSize].buffer); winpr_aligned_free(pool->aArray[pool->aSize].buffer);
else else
free(pool->aArray[pool->aSize].buffer); free(pool->aArray[pool->aSize].buffer);
} }
@ -466,7 +466,7 @@ void BufferPool_Clear(wBufferPool* pool)
(pool->uSize)--; (pool->uSize)--;
if (pool->alignment) if (pool->alignment)
_aligned_free(pool->uArray[pool->uSize].buffer); winpr_aligned_free(pool->uArray[pool->uSize].buffer);
else else
free(pool->uArray[pool->uSize].buffer); free(pool->uArray[pool->uSize].buffer);
} }