{
XSetRegion(xfc->display, xfc->gc, reg1);
XFillRectangle(xfc->display, xfc->window->handle, xfc->gc, 0, 0,
- xfc->window->width, xfc->window->height);
+ xfc->window->width, xfc->window->height);
XSetClipMask(xfc->display, xfc->gc, None);
}
picFormat = XRenderFindVisualFormat(xfc->display, xfc->visual);
pa.subwindow_mode = IncludeInferiors;
primaryPicture = XRenderCreatePicture(xfc->display, xfc->primary, picFormat,
- CPSubwindowMode, &pa);
+ CPSubwindowMode, &pa);
windowPicture = XRenderCreatePicture(xfc->display, xfc->window->handle,
- picFormat, CPSubwindowMode, &pa);
+ picFormat, CPSubwindowMode, &pa);
XRenderSetPictureFilter(xfc->display, primaryPicture, FilterBilinear, 0, 0);
transform.matrix[0][0] = XDoubleToFixed(xScalingFactor);
transform.matrix[0][1] = XDoubleToFixed(0.0);
h = ceil(y2 / yScalingFactor) + 1 - y;
XRenderSetPictureTransform(xfc->display, primaryPicture, &transform);
XRenderComposite(xfc->display, PictOpSrc, primaryPicture, 0, windowPicture, x,
- y, 0, 0, xfc->offset_x + x, xfc->offset_y + y, w, h);
+ y, 0, 0, xfc->offset_x + x, xfc->offset_y + y, w, h);
XRenderFreePicture(xfc->display, primaryPicture);
XRenderFreePicture(xfc->display, windowPicture);
}
BOOL xf_picture_transform_required(xfContext* xfc)
{
if (xfc->offset_x || xfc->offset_y ||
- xfc->scaledWidth != xfc->sessionWidth ||
- xfc->scaledHeight != xfc->sessionHeight)
+ xfc->scaledWidth != xfc->sessionWidth ||
+ xfc->scaledHeight != xfc->sessionHeight)
{
return TRUE;
}
#endif
XCopyArea(xfc->display, xfc->primary, xfc->window->handle, xfc->gc, x, y, w, h,
- x, y);
+ x, y);
}
static BOOL xf_desktop_resize(rdpContext* context)
XFreePixmap(xfc->display, xfc->primary);
if (!(xfc->primary = XCreatePixmap(
- xfc->display, xfc->drawable,
- xfc->sessionWidth, xfc->sessionHeight, xfc->depth)))
+ xfc->display, xfc->drawable,
+ xfc->sessionWidth, xfc->sessionHeight, xfc->depth)))
return FALSE;
if (same)
if (!xfc->fullscreen)
{
xf_ResizeDesktopWindow(xfc, xfc->window, settings->DesktopWidth,
- settings->DesktopHeight);
+ settings->DesktopHeight);
}
else
{
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, 0);
XFillRectangle(xfc->display, xfc->drawable, xfc->gc, 0, 0, xfc->window->width,
- xfc->window->height);
+ xfc->window->height);
}
return TRUE;
xf_lock_x11(xfc, FALSE);
XPutImage(xfc->display, xfc->primary, xfc->gc, xfc->image,
- x, y, x, y, w, h);
+ x, y, x, y, w, h);
xf_draw_screen(xfc, x, y, w, h);
xf_unlock_x11(xfc, FALSE);
}
w = cinvalid[i].w;
h = cinvalid[i].h;
XPutImage(xfc->display, xfc->primary, xfc->gc,
- xfc->image, x, y, x, y, w, h);
+ xfc->image, x, y, x, y, w, h);
xf_draw_screen(xfc, x, y, w, h);
}
}
if (!(xfc->image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap,
- 0,
- (char*) gdi->primary_buffer, gdi->width, gdi->height, xfc->scanline_pad, 0)))
+ 0,
+ (char*) gdi->primary_buffer, gdi->width, gdi->height, xfc->scanline_pad, 0)))
{
goto out;
}
return ret;
}
-BOOL xf_get_fds(freerdp* instance, void** rfds, int* rcount, void** wfds,
- int* wcount)
-{
- xfContext* xfc = (xfContext*) instance->context;
- rfds[*rcount] = (void*)(long)(xfc->xfds);
- (*rcount)++;
- return TRUE;
-}
-
-BOOL xf_process_x_events(freerdp* instance)
+static BOOL xf_process_x_events(freerdp* instance)
{
BOOL status;
XEvent xevent;
else if (settings->ServerPort == 3389)
{
windowTitle = malloc(1 + sizeof("FreeRDP: ") + strlen(
- settings->ServerHostname));
+ settings->ServerHostname));
sprintf(windowTitle, "FreeRDP: %s", settings->ServerHostname);
}
else
{
windowTitle = malloc(1 + sizeof("FreeRDP: ") + strlen(settings->ServerHostname)
- + sizeof(":00000"));
+ + sizeof(":00000"));
sprintf(windowTitle, "FreeRDP: %s:%i", settings->ServerHostname,
- settings->ServerPort);
+ settings->ServerPort);
}
#ifdef WITH_XRENDER
if (!xfc->primary)
xfc->primary = XCreatePixmap(xfc->display, xfc->drawable, xfc->sessionWidth,
- xfc->sessionHeight, xfc->depth);
+ xfc->sessionHeight, xfc->depth);
xfc->drawing = xfc->primary;
if (!xfc->gc_mono)
xfc->gc_mono = XCreateGC(xfc->display, xfc->bitmap_mono, GCGraphicsExposures,
- &gcv);
+ &gcv);
XSetFunction(xfc->display, xfc->gc, GXcopy);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, BlackPixelOfScreen(xfc->screen));
XFillRectangle(xfc->display, xfc->primary, xfc->gc, 0, 0, xfc->sessionWidth,
- xfc->sessionHeight);
+ xfc->sessionHeight);
XFlush(xfc->display);
if (!xfc->image)
{
rdpGdi* gdi = xfc->context.gdi;
xfc->image = XCreateImage(xfc->display, xfc->visual,
- xfc->depth,
- ZPixmap, 0, (char*) gdi->primary_buffer,
- xfc->sessionWidth, xfc->sessionHeight,
- xfc->scanline_pad, 0);
+ xfc->depth,
+ ZPixmap, 0, (char*) gdi->primary_buffer,
+ xfc->sessionWidth, xfc->sessionHeight,
+ xfc->scanline_pad, 0);
}
return TRUE;
}
-void xf_window_free(xfContext* xfc)
+static void xf_window_free(xfContext* xfc)
{
if (xfc->gc_mono)
{
*
* @return 0 on success, otherwise a Win32 error code
*/
-UINT xf_encomsp_participant_created(EncomspClientContext* context,
- ENCOMSP_PARTICIPANT_CREATED_PDU* participantCreated)
+static UINT xf_encomsp_participant_created(EncomspClientContext* context,
+ ENCOMSP_PARTICIPANT_CREATED_PDU* participantCreated)
{
return CHANNEL_RC_OK;
}
(*rsh)--;
}
-BOOL xf_get_pixmap_info(xfContext* xfc)
+static BOOL xf_get_pixmap_info(xfContext* xfc)
{
int i;
int vi_count;
template.screen = xfc->screen_number;
if (XGetWindowAttributes(xfc->display, RootWindowOfScreen(xfc->screen),
- &window_attributes) == 0)
+ &window_attributes) == 0)
{
WLog_ERR(TAG, "XGetWindowAttributes failed");
return FALSE;
}
vis = XGetVisualInfo(xfc->display, VisualClassMask | VisualScreenMask,
- &template, &vi_count);
+ &template, &vi_count);
if (!vis)
{
/* calculate color shifts required for rdp order color conversion */
xf_calculate_color_shifts(vi->red_mask, &xfc->red_shift_r, &xfc->red_shift_l);
xf_calculate_color_shifts(vi->green_mask, &xfc->green_shift_r,
- &xfc->green_shift_l);
+ &xfc->green_shift_l);
xf_calculate_color_shifts(vi->blue_mask, &xfc->blue_shift_r,
- &xfc->blue_shift_l);
+ &xfc->blue_shift_l);
}
XFree(vis);
return TRUE;
}
-int xf_error_handler(Display* d, XErrorEvent* ev)
+static int xf_error_handler(Display* d, XErrorEvent* ev)
{
char buf[256];
int do_abort = TRUE;
return FALSE;
}
-int _xf_error_handler(Display* d, XErrorEvent* ev)
+static int _xf_error_handler(Display* d, XErrorEvent* ev)
{
/*
* ungrab the keyboard, in case a debugger is running in
}
static BOOL xf_play_sound(rdpContext* context,
- const PLAY_SOUND_UPDATE* play_sound)
+ const PLAY_SOUND_UPDATE* play_sound)
{
xfContext* xfc = (xfContext*) context;
XkbBell(xfc->display, None, 100, 0);
return TRUE;
}
-void xf_check_extensions(xfContext* context)
+static void xf_check_extensions(xfContext* context)
{
int xkb_opcode, xkb_event, xkb_error;
int xkb_major = XkbMajorVersion;
int xkb_minor = XkbMinorVersion;
if (XkbLibraryVersion(&xkb_major, &xkb_minor)
- && XkbQueryExtension(context->display, &xkb_opcode, &xkb_event,
- &xkb_error, &xkb_major, &xkb_minor))
+ && XkbQueryExtension(context->display, &xkb_opcode, &xkb_event,
+ &xkb_error, &xkb_major, &xkb_minor))
{
context->xkbAvailable = TRUE;
}
int xrender_error_base;
if (XRenderQueryExtension(context->display, &xrender_event_base,
- &xrender_error_base))
+ &xrender_error_base))
{
context->xrenderAvailable = TRUE;
}
for (i = 0; i < num_devices; ++i)
{
if ((devices2[i].use == XISlavePointer) &&
- (strncmp(devices2[i].name, TEST_PTR_STR, TEST_PTR_LEN) != 0))
+ (strncmp(devices2[i].name, TEST_PTR_STR, TEST_PTR_LEN) != 0))
{
xid = devices2[i].deviceid;
break;
for (i = 0; i < num_devices; ++i)
{
if ((devices1[i].use == IsXExtensionPointer) &&
- (strncmp(devices1[i].name, TEST_PTR_STR, TEST_PTR_LEN) != 0))
+ (strncmp(devices1[i].name, TEST_PTR_STR, TEST_PTR_LEN) != 0))
{
xid = devices1[i].id;
break;
else
{
WLog_ERR(TAG, "Mouse physical button %d is mapped to logical button %d",
- physical, logical);
+ physical, logical);
}
}
}
* @return TRUE if successful. FALSE otherwise.
* Can exit with error code XF_EXIT_PARSE_ARGUMENTS if there is an error in the parameters.
*/
-BOOL xf_pre_connect(freerdp* instance)
+static BOOL xf_pre_connect(freerdp* instance)
{
rdpChannels* channels;
rdpSettings* settings;
xfContext* xfc = (xfContext*) instance->context;
UINT32 maxWidth = 0;
UINT32 maxHeight = 0;
- xfc->codecs = context->codecs;
xfc->settings = instance->settings;
xfc->instance = instance;
settings = instance->settings;
settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = FALSE;
settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = FALSE;
PubSub_SubscribeChannelConnected(instance->context->pubSub,
- (pChannelConnectedEventHandler) xf_OnChannelConnectedEventHandler);
+ (pChannelConnectedEventHandler) xf_OnChannelConnectedEventHandler);
PubSub_SubscribeChannelDisconnected(instance->context->pubSub,
- (pChannelDisconnectedEventHandler) xf_OnChannelDisconnectedEventHandler);
+ (pChannelDisconnectedEventHandler) xf_OnChannelDisconnectedEventHandler);
if (!freerdp_client_load_addins(channels, instance->settings))
return FALSE;
* we run the session in the /smart-sizing dimensions scaled to full screen
*/
if (settings->Fullscreen && settings->SmartSizing &&
- settings->SmartSizingWidth && settings->SmartSizingHeight)
+ settings->SmartSizingWidth && settings->SmartSizingHeight)
{
settings->DesktopWidth = settings->SmartSizingWidth;
settings->DesktopHeight = settings->SmartSizingHeight;
* It will be called only if the connection was initialized properly, and will continue the initialization based on the
* newly created connection.
*/
-BOOL xf_post_connect(freerdp* instance)
+static BOOL xf_post_connect(freerdp* instance)
{
rdpUpdate* update;
rdpContext* context;
}
xf_window_free(xfc);
-
xf_keyboard_free(xfc);
}
-int xf_logon_error_info(freerdp* instance, UINT32 data, UINT32 type)
+static int xf_logon_error_info(freerdp* instance, UINT32 data, UINT32 type)
{
xfContext* xfc = (xfContext*) instance->context;
xf_rail_disable_remoteapp_mode(xfc);
return 1;
}
-void* xf_input_thread(void* arg)
+static void* xf_input_thread(void* arg)
{
DWORD status;
DWORD nCount;
return NULL;
}
-BOOL xf_auto_reconnect(freerdp* instance)
+static BOOL xf_auto_reconnect(freerdp* instance)
{
UINT32 maxRetries;
UINT32 numRetries = 0;
* @param instance - pointer to the rdp_freerdp structure that contains the session's settings
* @return A code from the enum XF_EXIT_CODE (0 if successful)
*/
-void* xf_client_thread(void* param)
+static void* xf_client_thread(void* param)
{
BOOL status;
int exit_code;
if (!status)
{
if (freerdp_get_last_error(instance->context) ==
- FREERDP_ERROR_AUTHENTICATION_FAILED)
+ FREERDP_ERROR_AUTHENTICATION_FAILED)
exit_code = XF_EXIT_AUTH_FAILURE;
else
exit_code = XF_EXIT_CONN_FAILED;
exit_code = freerdp_error_info(instance);
if (freerdp_get_last_error(instance->context) ==
- FREERDP_ERROR_AUTHENTICATION_FAILED)
+ FREERDP_ERROR_AUTHENTICATION_FAILED)
exit_code = XF_EXIT_AUTH_FAILURE;
else
exit_code = XF_EXIT_CONN_FAILED;
else
{
if (!(inputEvent = freerdp_get_message_queue_event_handle(instance,
- FREERDP_INPUT_MESSAGE_QUEUE)))
+ FREERDP_INPUT_MESSAGE_QUEUE)))
{
WLog_ERR(TAG, "async input: failed to get input event handle");
exit_code = XF_EXIT_UNKNOWN;
}
if (!(inputThread = CreateThread(NULL, 0,
- (LPTHREAD_START_ROUTINE) xf_input_thread, instance, 0, NULL)))
+ (LPTHREAD_START_ROUTINE) xf_input_thread, instance, 0, NULL)))
{
WLog_ERR(TAG, "async input: failed to create input thread");
exit_code = XF_EXIT_UNKNOWN;
if (WaitForSingleObject(inputEvent, 0) == WAIT_OBJECT_0)
{
if (!freerdp_message_queue_process_pending_messages(instance,
- FREERDP_INPUT_MESSAGE_QUEUE))
+ FREERDP_INPUT_MESSAGE_QUEUE))
{
WLog_INFO(TAG, "User Disconnect");
xfc->disconnect = TRUE;
if (settings->AsyncInput)
{
wMessageQueue* inputQueue = freerdp_get_message_queue(instance,
- FREERDP_INPUT_MESSAGE_QUEUE);
+ FREERDP_INPUT_MESSAGE_QUEUE);
if (MessageQueue_PostQuit(inputQueue, 0))
WaitForSingleObject(inputThread, INFINITE);
DWORD xf_exit_code_from_disconnect_reason(DWORD reason)
{
if (reason == 0 || (reason >= XF_EXIT_PARSE_ARGUMENTS
- && reason <= XF_EXIT_AUTH_FAILURE))
- return reason;
+ && reason <= XF_EXIT_AUTH_FAILURE))
+ return reason;
/* License error set */
else if (reason >= 0x100 && reason <= 0x10A)
- reason -= 0x100 + XF_EXIT_LICENSE_INTERNAL;
+ reason -= 0x100 + XF_EXIT_LICENSE_INTERNAL;
/* RDP protocol error set */
else if (reason >= 0x10c9 && reason <= 0x1193)
- reason = XF_EXIT_RDP;
+ reason = XF_EXIT_RDP;
/* There's no need to test protocol-independent codes: they match */
else if (!(reason <= 0xC))
- reason = XF_EXIT_UNKNOWN;
+ reason = XF_EXIT_UNKNOWN;
return reason;
}
-void xf_TerminateEventHandler(rdpContext* context, TerminateEventArgs* e)
+static void xf_TerminateEventHandler(rdpContext* context, TerminateEventArgs* e)
{
wMessageQueue* queue;
xfContext* xfc = (xfContext*) context;
if (context->settings->AsyncInput)
{
queue = freerdp_get_message_queue(context->instance,
- FREERDP_INPUT_MESSAGE_QUEUE);
+ FREERDP_INPUT_MESSAGE_QUEUE);
if (queue)
MessageQueue_PostQuit(queue, 0);
#ifdef WITH_XRENDER
static void xf_ZoomingChangeEventHandler(rdpContext* context,
- ZoomingChangeEventArgs* e)
+ ZoomingChangeEventArgs* e)
{
xfContext* xfc = (xfContext*) context;
int w = xfc->scaledWidth + e->dx;
return;
if (w < 10)
- w = 10;
+ w = 10;
if (h < 10)
- h = 10;
+ h = 10;
if (w == xfc->scaledWidth && h == xfc->scaledHeight)
return;
}
static void xf_PanningChangeEventHandler(rdpContext* context,
- PanningChangeEventArgs* e)
+ PanningChangeEventArgs* e)
{
xfContext* xfc = (xfContext*) context;
if (!settings->ServerHostname)
{
WLog_ERR(TAG,
- "error: server hostname was not specified with /v:<server>[:port]");
+ "error: server hostname was not specified with /v:<server>[:port]");
return -1;
}
xfc->disconnect = FALSE;
if (!(xfc->thread = CreateThread(NULL, 0,
- (LPTHREAD_START_ROUTINE) xf_client_thread,
- context->instance, 0, NULL)))
+ (LPTHREAD_START_ROUTINE) xf_client_thread,
+ context->instance, 0, NULL)))
{
WLog_ERR(TAG, "failed to create client thread");
return -1;
{
wMessageQueue* queue;
queue = freerdp_get_message_queue(context->instance,
- FREERDP_INPUT_MESSAGE_QUEUE);
+ FREERDP_INPUT_MESSAGE_QUEUE);
if (queue)
MessageQueue_PostQuit(queue, 0);
settings = instance->settings;
xfc->settings = instance->context->settings;
PubSub_SubscribeTerminate(context->pubSub,
- (pTerminateEventHandler) xf_TerminateEventHandler);
+ (pTerminateEventHandler) xf_TerminateEventHandler);
#ifdef WITH_XRENDER
PubSub_SubscribeZoomingChange(context->pubSub,
- (pZoomingChangeEventHandler) xf_ZoomingChangeEventHandler);
+ (pZoomingChangeEventHandler) xf_ZoomingChangeEventHandler);
PubSub_SubscribePanningChange(context->pubSub,
- (pPanningChangeEventHandler) xf_PanningChangeEventHandler);
+ (pPanningChangeEventHandler) xf_PanningChangeEventHandler);
#endif
xfc->UseXThreads = TRUE;
//xfc->debug = TRUE;
{
WLog_ERR(TAG, "failed to open display: %s", XDisplayName(NULL));
WLog_ERR(TAG,
- "Please check that the $DISPLAY environment variable is properly set.");
+ "Please check that the $DISPLAY environment variable is properly set.");
goto fail_open_display;
}
xfc->_NET_WM_ICON = XInternAtom(xfc->display, "_NET_WM_ICON", False);
xfc->_MOTIF_WM_HINTS = XInternAtom(xfc->display, "_MOTIF_WM_HINTS", False);
xfc->_NET_CURRENT_DESKTOP = XInternAtom(xfc->display, "_NET_CURRENT_DESKTOP",
- False);
+ False);
xfc->_NET_WORKAREA = XInternAtom(xfc->display, "_NET_WORKAREA", False);
xfc->_NET_WM_STATE = XInternAtom(xfc->display, "_NET_WM_STATE", False);
xfc->_NET_WM_STATE_FULLSCREEN = XInternAtom(xfc->display,
- "_NET_WM_STATE_FULLSCREEN", False);
+ "_NET_WM_STATE_FULLSCREEN", False);
xfc->_NET_WM_STATE_MAXIMIZED_HORZ = XInternAtom(xfc->display,
- "_NET_WM_STATE_MAXIMIZED_HORZ", False);
+ "_NET_WM_STATE_MAXIMIZED_HORZ", False);
xfc->_NET_WM_STATE_MAXIMIZED_VERT = XInternAtom(xfc->display,
- "_NET_WM_STATE_MAXIMIZED_VERT", False);
+ "_NET_WM_STATE_MAXIMIZED_VERT", False);
xfc->_NET_WM_FULLSCREEN_MONITORS = XInternAtom(xfc->display,
- "_NET_WM_FULLSCREEN_MONITORS", False);
+ "_NET_WM_FULLSCREEN_MONITORS", False);
xfc->_NET_WM_NAME = XInternAtom(xfc->display, "_NET_WM_NAME", False);
xfc->_NET_WM_PID = XInternAtom(xfc->display, "_NET_WM_PID", False);
xfc->_NET_WM_WINDOW_TYPE = XInternAtom(xfc->display, "_NET_WM_WINDOW_TYPE",
- False);
+ False);
xfc->_NET_WM_WINDOW_TYPE_NORMAL = XInternAtom(xfc->display,
- "_NET_WM_WINDOW_TYPE_NORMAL", False);
+ "_NET_WM_WINDOW_TYPE_NORMAL", False);
xfc->_NET_WM_WINDOW_TYPE_DIALOG = XInternAtom(xfc->display,
- "_NET_WM_WINDOW_TYPE_DIALOG", False);
+ "_NET_WM_WINDOW_TYPE_DIALOG", False);
xfc->_NET_WM_WINDOW_TYPE_POPUP = XInternAtom(xfc->display,
- "_NET_WM_WINDOW_TYPE_POPUP", False);
+ "_NET_WM_WINDOW_TYPE_POPUP", False);
xfc->_NET_WM_WINDOW_TYPE_UTILITY = XInternAtom(xfc->display,
- "_NET_WM_WINDOW_TYPE_UTILITY", False);
+ "_NET_WM_WINDOW_TYPE_UTILITY", False);
xfc->_NET_WM_WINDOW_TYPE_DROPDOWN_MENU = XInternAtom(xfc->display,
- "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", False);
+ "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", False);
xfc->_NET_WM_STATE_SKIP_TASKBAR = XInternAtom(xfc->display,
- "_NET_WM_STATE_SKIP_TASKBAR", False);
+ "_NET_WM_STATE_SKIP_TASKBAR", False);
xfc->_NET_WM_STATE_SKIP_PAGER = XInternAtom(xfc->display,
- "_NET_WM_STATE_SKIP_PAGER", False);
+ "_NET_WM_STATE_SKIP_PAGER", False);
xfc->_NET_WM_MOVERESIZE = XInternAtom(xfc->display, "_NET_WM_MOVERESIZE",
- False);
+ False);
xfc->_NET_MOVERESIZE_WINDOW = XInternAtom(xfc->display,
- "_NET_MOVERESIZE_WINDOW", False);
+ "_NET_MOVERESIZE_WINDOW", False);
xfc->UTF8_STRING = XInternAtom(xfc->display, "UTF8_STRING", FALSE);
xfc->WM_PROTOCOLS = XInternAtom(xfc->display, "WM_PROTOCOLS", False);
xfc->WM_DELETE_WINDOW = XInternAtom(xfc->display, "WM_DELETE_WINDOW", False);
xfc->invert = (ImageByteOrder(xfc->display) == MSBFirst) ? TRUE : FALSE;
xfc->complex_regions = TRUE;
xfc->x11event = CreateFileDescriptorEvent(NULL, FALSE, FALSE, xfc->xfds,
- WINPR_FD_READ);
+ WINPR_FD_READ);
if (!xfc->x11event)
{
case 32:
case 24:
if (xfc->visual->red_mask == 0xFF0000 &&
- xfc->visual->green_mask == 0xFF00 &&
- xfc->visual->blue_mask == 0xFF)
+ xfc->visual->green_mask == 0xFF00 &&
+ xfc->visual->blue_mask == 0xFF)
{
return color;
}
color = (color & 0xFF00) | ((color >> 16) & 0xFF);
if (xfc->visual->red_mask == 0xF800 &&
- xfc->visual->green_mask == 0x07E0 &&
- xfc->visual->blue_mask == 0x001F)
+ xfc->visual->green_mask == 0x07E0 &&
+ xfc->visual->blue_mask == 0x001F)
{
return color;
}
case 8:
color = (color >> 16) & (UINT32) 0xFF;
-
UINT32 dstColor = xfc->palette.palette[color];
SplitColor(dstColor, xfc->format, &r, &g, &b,
- NULL, NULL);
-
+ NULL, NULL);
break;
default:
}
return (((r >> xfc->red_shift_r) << xfc->red_shift_l) |
- ((g >> xfc->green_shift_r) << xfc->green_shift_l) |
- ((b >> xfc->blue_shift_r) << xfc->blue_shift_l));
+ ((g >> xfc->green_shift_r) << xfc->green_shift_l) |
+ ((b >> xfc->blue_shift_r) << xfc->blue_shift_l));
}
Pixmap xf_brush_new(xfContext* xfc, int width, int height, int bpp, BYTE* data)
brushFormat = gdi_get_pixel_format(bpp, FALSE);
cdata = (BYTE*) _aligned_malloc(width * height * 4, 16);
freerdp_image_copy(cdata, xfc->format, -1, 0, 0,
- width, height, data, brushFormat, -1, 0, 0,
- &xfc->palette);
+ width, height, data, brushFormat, -1, 0, 0,
+ &xfc->palette);
image = XCreateImage(xfc->display, xfc->visual, xfc->depth,
- ZPixmap, 0, (char*) cdata, width, height, xfc->scanline_pad, 0);
+ ZPixmap, 0, (char*) cdata, width, height, xfc->scanline_pad, 0);
gc = XCreateGC(xfc->display, xfc->drawable, 0, NULL);
XPutImage(xfc->display, bitmap, gc, image, 0, 0, 0, 0, width, height);
XFree(image);
scanline = (width + 7) / 8;
bitmap = XCreatePixmap(xfc->display, xfc->drawable, width, height, 1);
image = XCreateImage(xfc->display, xfc->visual, 1,
- ZPixmap, 0, (char*) data, width, height, 8, scanline);
+ ZPixmap, 0, (char*) data, width, height, 8, scanline);
XPutImage(xfc->display, bitmap, xfc->gc_mono, image, 0, 0, 0, 0, width, height);
XFree(image);
return bitmap;
}
BOOL xf_gdi_bitmap_update(rdpContext* context,
- const BITMAP_UPDATE* bitmapUpdate)
+ const BITMAP_UPDATE* bitmapUpdate)
{
int status;
int nXDst;
if (bitsPerPixel < 32)
{
- if (!freerdp_client_codecs_prepare(codecs, FREERDP_CODEC_INTERLEAVED,
- xfc->settings->DesktopWidth,
- xfc->settings->DesktopHeight))
- return FALSE;
-
status = interleaved_decompress(codecs->interleaved,
- pSrcData, SrcSize,
- bitsPerPixel,
- pDstData,
- xfc->format, -1,
- 0, 0,
- nWidth, nHeight,
- &xfc->palette);
+ pSrcData, SrcSize,
+ bitsPerPixel,
+ pDstData,
+ xfc->format, -1,
+ 0, 0,
+ nWidth, nHeight,
+ &xfc->palette);
}
else
{
- if (!freerdp_client_codecs_prepare(codecs, FREERDP_CODEC_PLANAR,
- xfc->settings->DesktopWidth,
- xfc->settings->DesktopHeight))
- return FALSE;
-
status = planar_decompress(codecs->planar, pSrcData, SrcSize, pDstData,
- xfc->format, -1, 0, 0, nWidth, nHeight, TRUE);
+ xfc->format, -1, 0, 0, nWidth, nHeight, TRUE);
}
if (status < 0)
{
pDstData = xfc->bitmap_buffer;
status = freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
- nWidth, nHeight, pSrcData, SrcFormat,
- -1, 0, 0, &xfc->palette);
+ nWidth, nHeight, pSrcData, SrcFormat,
+ -1, 0, 0, &xfc->palette);
pSrcData = xfc->bitmap_buffer;
}
xf_lock_x11(xfc, FALSE);
XSetFunction(xfc->display, xfc->gc, GXcopy);
image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,
- (char*) pSrcData, nWidth, nHeight, xfc->scanline_pad, 0);
+ (char*) pSrcData, nWidth, nHeight, xfc->scanline_pad, 0);
if (!image)
{
nWidth = bitmap->destRight - bitmap->destLeft + 1; /* clip width */
nHeight = bitmap->destBottom - bitmap->destTop + 1; /* clip height */
XPutImage(xfc->display, xfc->primary, xfc->gc,
- image, 0, 0, nXDst, nYDst, nWidth, nHeight);
+ image, 0, 0, nXDst, nYDst, nWidth, nHeight);
XFree(image);
ret = gdi_InvalidateRegion(xfc->hdc, nXDst, nYDst, nWidth, nHeight);
xf_unlock_x11(xfc, FALSE);
}
static BOOL xf_gdi_palette_update(rdpContext* context,
- const PALETTE_UPDATE* palette)
+ const PALETTE_UPDATE* palette)
{
int index;
const PALETTE_ENTRY* pe;
xfContext* xfc = (xfContext*) context;
xf_lock_x11(xfc, FALSE);
-
xfc->palette.format = xfc->format;
+
for (index = 0; index < palette->number; index++)
{
pe = &(palette->entries[index]);
xfc->palette.palette[index] = GetColor(xfc->format,
- pe->red, pe->green, pe->blue, 0xFF);
+ pe->red, pe->green, pe->blue, 0xFF);
}
xf_unlock_x11(xfc, FALSE);
}
static BOOL xf_gdi_set_bounds(rdpContext* context,
- const rdpBounds* bounds)
+ const rdpBounds* bounds)
{
XRectangle clip;
xfContext* xfc = (xfContext*) context;
xf_set_rop3(xfc, gdi_rop3_code(dstblt->bRop));
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
- dstblt->nLeftRect, dstblt->nTopRect,
- dstblt->nWidth, dstblt->nHeight);
+ dstblt->nLeftRect, dstblt->nTopRect,
+ dstblt->nWidth, dstblt->nHeight);
if (xfc->drawing == xfc->primary)
ret = gdi_InvalidateRegion(xfc->hdc, dstblt->nLeftRect, dstblt->nTopRect,
- dstblt->nWidth, dstblt->nHeight);
+ dstblt->nWidth, dstblt->nHeight);
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, foreColor);
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
- patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
+ patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
}
else if (brush->style == GDI_BS_HATCHED)
{
pattern = xf_mono_bitmap_new(xfc, 8, 8,
- GDI_BS_HATCHED_PATTERNS + 8 * brush->hatch);
+ GDI_BS_HATCHED_PATTERNS + 8 * brush->hatch);
XSetForeground(xfc->display, xfc->gc, backColor);
XSetBackground(xfc->display, xfc->gc, foreColor);
XSetFillStyle(xfc->display, xfc->gc, FillOpaqueStippled);
XSetStipple(xfc->display, xfc->gc, pattern);
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
- patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
+ patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XFreePixmap(xfc->display, pattern);
}
else if (brush->style == GDI_BS_PATTERN)
XSetTile(xfc->display, xfc->gc, pattern);
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
- patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
+ patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XSetTile(xfc->display, xfc->gc, xfc->primary);
XFreePixmap(xfc->display, pattern);
}
XSetStipple(xfc->display, xfc->gc, pattern);
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
- patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
+ patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
XFreePixmap(xfc->display, pattern);
}
}
if (xfc->drawing == xfc->primary)
ret = gdi_InvalidateRegion(xfc->hdc, patblt->nLeftRect, patblt->nTopRect,
- patblt->nWidth, patblt->nHeight);
+ patblt->nWidth, patblt->nHeight);
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
xf_lock_x11(xfc, FALSE);
xf_set_rop3(xfc, gdi_rop3_code(scrblt->bRop));
XCopyArea(xfc->display, xfc->primary, xfc->drawing, xfc->gc, scrblt->nXSrc,
- scrblt->nYSrc,
- scrblt->nWidth, scrblt->nHeight, scrblt->nLeftRect, scrblt->nTopRect);
+ scrblt->nYSrc,
+ scrblt->nWidth, scrblt->nHeight, scrblt->nLeftRect, scrblt->nTopRect);
if (xfc->drawing == xfc->primary)
ret = gdi_InvalidateRegion(xfc->hdc, scrblt->nLeftRect, scrblt->nTopRect,
- scrblt->nWidth, scrblt->nHeight);
+ scrblt->nWidth, scrblt->nHeight);
XSetFunction(xfc->display, xfc->gc, GXcopy);
xf_unlock_x11(xfc, FALSE);
}
static BOOL xf_gdi_opaque_rect(rdpContext* context,
- const OPAQUE_RECT_ORDER* opaque_rect)
+ const OPAQUE_RECT_ORDER* opaque_rect)
{
UINT32 color;
xfContext* xfc = (xfContext*) context;
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, color);
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
- opaque_rect->nLeftRect, opaque_rect->nTopRect,
- opaque_rect->nWidth, opaque_rect->nHeight);
+ opaque_rect->nLeftRect, opaque_rect->nTopRect,
+ opaque_rect->nWidth, opaque_rect->nHeight);
if (xfc->drawing == xfc->primary)
ret = gdi_InvalidateRegion(xfc->hdc, opaque_rect->nLeftRect,
- opaque_rect->nTopRect,
- opaque_rect->nWidth, opaque_rect->nHeight);
+ opaque_rect->nTopRect,
+ opaque_rect->nWidth, opaque_rect->nHeight);
xf_unlock_x11(xfc, FALSE);
return ret;
}
static BOOL xf_gdi_multi_opaque_rect(rdpContext* context,
- const MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
+ const MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
{
UINT32 i;
UINT32 color;
{
rectangle = &multi_opaque_rect->rectangles[i];
XFillRectangle(xfc->display, xfc->drawing, xfc->gc,
- rectangle->left, rectangle->top,
- rectangle->width, rectangle->height);
+ rectangle->left, rectangle->top,
+ rectangle->width, rectangle->height);
if (xfc->drawing == xfc->primary)
{
if (!(ret = gdi_InvalidateRegion(xfc->hdc, rectangle->left, rectangle->top,
- rectangle->width, rectangle->height)))
+ rectangle->width, rectangle->height)))
break;
}
}
}
void xf_gdi_draw_nine_grid(rdpContext* context,
- DRAW_NINE_GRID_ORDER* draw_nine_grid)
+ DRAW_NINE_GRID_ORDER* draw_nine_grid)
{
WLog_ERR(TAG, "DrawNineGrid");
}
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, color);
XDrawLine(xfc->display, xfc->drawing, xfc->gc,
- line_to->nXStart, line_to->nYStart, line_to->nXEnd, line_to->nYEnd);
+ line_to->nXStart, line_to->nYStart, line_to->nXEnd, line_to->nYEnd);
if (xfc->drawing == xfc->primary)
{
}
static BOOL xf_gdi_invalidate_poly_region(xfContext* xfc, XPoint* points,
- int npoints)
+ int npoints)
{
int x, y, x1, y1, x2, y2;
}
static BOOL xf_gdi_polyline(rdpContext* context,
- const POLYLINE_ORDER* polyline)
+ const POLYLINE_ORDER* polyline)
{
int i;
int npoints;
}
XDrawLines(xfc->display, xfc->drawing, xfc->gc, points, npoints,
- CoordModePrevious);
+ CoordModePrevious);
if (xfc->drawing == xfc->primary)
{
if (xf_set_rop3(xfc, gdi_rop3_code(memblt->bRop)))
{
XCopyArea(xfc->display, bitmap->pixmap, xfc->drawing, xfc->gc,
- memblt->nXSrc, memblt->nYSrc, memblt->nWidth, memblt->nHeight,
- memblt->nLeftRect, memblt->nTopRect);
+ memblt->nXSrc, memblt->nYSrc, memblt->nWidth, memblt->nHeight,
+ memblt->nLeftRect, memblt->nTopRect);
if (xfc->drawing == xfc->primary)
ret = gdi_InvalidateRegion(xfc->hdc, memblt->nLeftRect,
- memblt->nTopRect, memblt->nWidth,
- memblt->nHeight);
+ memblt->nTopRect, memblt->nWidth,
+ memblt->nHeight);
XSetFunction(xfc->display, xfc->gc, GXcopy);
}
}
XCopyArea(xfc->display, bitmap->pixmap, xfc->drawing, xfc->gc,
- mem3blt->nXSrc, mem3blt->nYSrc, mem3blt->nWidth, mem3blt->nHeight,
- mem3blt->nLeftRect, mem3blt->nTopRect);
+ mem3blt->nXSrc, mem3blt->nYSrc, mem3blt->nWidth, mem3blt->nHeight,
+ mem3blt->nLeftRect, mem3blt->nTopRect);
if (xfc->drawing == xfc->primary)
ret = gdi_InvalidateRegion(xfc->hdc, mem3blt->nLeftRect, mem3blt->nTopRect,
- mem3blt->nWidth, mem3blt->nHeight);
+ mem3blt->nWidth, mem3blt->nHeight);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetTSOrigin(xfc->display, xfc->gc, 0, 0);
static BOOL xf_gdi_polygon_sc(rdpContext* context,
- const POLYGON_SC_ORDER* polygon_sc)
+ const POLYGON_SC_ORDER* polygon_sc)
{
int i, npoints;
XPoint* points;
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetForeground(xfc->display, xfc->gc, brush_color);
XFillPolygon(xfc->display, xfc->drawing, xfc->gc,
- points, npoints, Complex, CoordModePrevious);
+ points, npoints, Complex, CoordModePrevious);
if (xfc->drawing == xfc->primary)
{
}
static BOOL xf_gdi_polygon_cb(rdpContext* context,
- POLYGON_CB_ORDER* polygon_cb)
+ POLYGON_CB_ORDER* polygon_cb)
{
int i, npoints;
XPoint* points;
XSetTSOrigin(xfc->display, xfc->gc, brush->x, brush->y);
XFillPolygon(xfc->display, xfc->drawing, xfc->gc,
- points, npoints, Complex, CoordModePrevious);
+ points, npoints, Complex, CoordModePrevious);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
XSetTSOrigin(xfc->display, xfc->gc, 0, 0);
XFreePixmap(xfc->display, pattern);
}
static BOOL xf_gdi_ellipse_sc(rdpContext* context,
- const ELLIPSE_SC_ORDER* ellipse_sc)
+ const ELLIPSE_SC_ORDER* ellipse_sc)
{
WLog_ERR(TAG, "Not implemented: EllipseSC");
return TRUE;
}
static BOOL xf_gdi_ellipse_cb(rdpContext* context,
- const ELLIPSE_CB_ORDER* ellipse_cb)
+ const ELLIPSE_CB_ORDER* ellipse_cb)
{
WLog_ERR(TAG, "Not implemented: EllipseCB");
return TRUE;
}
static BOOL xf_gdi_frame_marker(rdpContext* context,
- const FRAME_MARKER_ORDER* frameMarker)
+ const FRAME_MARKER_ORDER* frameMarker)
{
return TRUE;
}
static BOOL xf_gdi_surface_frame_marker(rdpContext* context,
- const SURFACE_FRAME_MARKER* surface_frame_marker)
+ const SURFACE_FRAME_MARKER* surface_frame_marker)
{
rdpSettings* settings;
xfContext* xfc = (xfContext*) context;
if ((xfc->frame_x2 > xfc->frame_x1) && (xfc->frame_y2 > xfc->frame_y1))
ret = gdi_InvalidateRegion(xfc->hdc, xfc->frame_x1, xfc->frame_y1,
- xfc->frame_x2 - xfc->frame_x1, xfc->frame_y2 - xfc->frame_y1);
+ xfc->frame_x2 - xfc->frame_x1, xfc->frame_y2 - xfc->frame_y1);
if (settings->FrameAcknowledge > 0)
{
IFCALL(xfc->instance->update->SurfaceFrameAcknowledge, context,
- surface_frame_marker->frameId);
+ surface_frame_marker->frameId);
}
break;
}
static BOOL xf_gdi_surface_update_frame(xfContext* xfc, UINT16 tx, UINT16 ty,
- UINT16 width, UINT16 height)
+ UINT16 width, UINT16 height)
{
BOOL ret = TRUE;
}
static BOOL xf_gdi_surface_bits(rdpContext* context,
- const SURFACE_BITS_COMMAND* cmd)
+ const SURFACE_BITS_COMMAND* cmd)
{
XImage* image;
BYTE* pSrcData;
REGION16 invalidRegion;
xf_lock_x11(xfc, FALSE);
- if (cmd->codecID == RDP_CODEC_ID_REMOTEFX)
+ switch (cmd->codecID)
{
- if (!freerdp_client_codecs_prepare(xfc->codecs, FREERDP_CODEC_REMOTEFX,
- xfc->settings->DesktopWidth,
- xfc->settings->DesktopHeight))
- {
- xf_unlock_x11(xfc, FALSE);
- return FALSE;
- }
+ case RDP_CODEC_ID_REMOTEFX:
+ if (!rfx_process_message(context->codecs->rfx, cmd->bitmapData,
+ PIXEL_FORMAT_XRGB32, cmd->bitmapDataLength,
+ cmd->destLeft, cmd->destTop,
+ gdi->primary_buffer, gdi->dstFormat, gdi->stride,
+ gdi->height, &invalidRegion))
+ {
+ WLog_ERR(TAG, "Failed to process RemoteFX message");
+ xf_unlock_x11(xfc, FALSE);
+ return FALSE;
+ }
- if (!rfx_process_message(xfc->codecs->rfx, cmd->bitmapData,
- PIXEL_FORMAT_XRGB32, cmd->bitmapDataLength,
- cmd->destLeft, cmd->destTop,
- gdi->primary_buffer, gdi->dstFormat, gdi->stride,
- gdi->height, &invalidRegion))
- {
- WLog_ERR(TAG, "Failed to process RemoteFX message");
- xf_unlock_x11(xfc, FALSE);
- return FALSE;
- }
+ XRectangle rect;
+ rect.x = cmd->destLeft;
+ rect.y = cmd->destTop;
+ rect.width = cmd->width;
+ rect.height = cmd->height;
+ XSetFunction(xfc->display, xfc->gc, GXcopy);
+ XSetFillStyle(xfc->display, xfc->gc, FillSolid);
+ XSetClipRectangles(xfc->display, xfc->gc, cmd->destLeft, cmd->destTop,
+ &rect, 1, YXBanded);
+
+ /* Invalidate the updated region */
+ if (!xf_gdi_surface_update_frame(xfc, rect.x, rect.y,
+ rect.width, rect.height))
+ ret = FALSE;
- XRectangle rect;
- rect.x = cmd->destLeft;
- rect.y = cmd->destTop;
- rect.width = cmd->width;
- rect.height = cmd->height;
- XSetFunction(xfc->display, xfc->gc, GXcopy);
- XSetFillStyle(xfc->display, xfc->gc, FillSolid);
- XSetClipRectangles(xfc->display, xfc->gc, cmd->destLeft, cmd->destTop,
- &rect, 1, YXBanded);
+ XSetClipMask(xfc->display, xfc->gc, None);
+ break;
- /* Invalidate the updated region */
- if (!xf_gdi_surface_update_frame(xfc, rect.x, rect.y,
- rect.width, rect.height))
- ret = FALSE;
+ case RDP_CODEC_ID_NSCODEC:
+ if (!nsc_process_message(context->codecs->nsc, cmd->bpp, cmd->width,
+ cmd->height,
+ cmd->bitmapData, cmd->bitmapDataLength,
+ xfc->bitmap_buffer, xfc->format, 0, 0, 0, cmd->width, cmd->height))
+ {
+ xf_unlock_x11(xfc, FALSE);
+ return FALSE;
+ }
- XSetClipMask(xfc->display, xfc->gc, None);
- }
- else if (cmd->codecID == RDP_CODEC_ID_NSCODEC)
- {
- if (!freerdp_client_codecs_prepare(xfc->codecs, FREERDP_CODEC_NSCODEC,
- xfc->settings->DesktopWidth,
- xfc->settings->DesktopHeight))
- {
- xf_unlock_x11(xfc, FALSE);
- return FALSE;
- }
+ XSetFunction(xfc->display, xfc->gc, GXcopy);
+ XSetFillStyle(xfc->display, xfc->gc, FillSolid);
+ pSrcData = context->codecs->nsc->BitmapData;
+ pDstData = xfc->bitmap_buffer;
+ image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,
+ (char*) pDstData, cmd->width, cmd->height, xfc->scanline_pad, 0);
+ XPutImage(xfc->display, xfc->primary, xfc->gc, image, 0, 0,
+ cmd->destLeft, cmd->destTop, cmd->width, cmd->height);
+ XFree(image);
+ ret = xf_gdi_surface_update_frame(xfc, cmd->destLeft, cmd->destTop, cmd->width,
+ cmd->height);
+ XSetClipMask(xfc->display, xfc->gc, None);
+ break;
- if (!nsc_process_message(xfc->codecs->nsc, cmd->bpp, cmd->width, cmd->height,
- cmd->bitmapData, cmd->bitmapDataLength,
- xfc->bitmap_buffer, xfc->format, 0, 0, 0, cmd->width, cmd->height))
- {
- xf_unlock_x11(xfc, FALSE);
- return FALSE;
- }
+ case RDP_CODEC_ID_NONE:
+ XSetFunction(xfc->display, xfc->gc, GXcopy);
+ XSetFillStyle(xfc->display, xfc->gc, FillSolid);
+ pSrcData = cmd->bitmapData;
+ pDstData = xfc->bitmap_buffer;
+ freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
+ cmd->width, cmd->height, pSrcData,
+ PIXEL_FORMAT_BGRX32_VF, -1, 0, 0, &xfc->palette);
+ image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,
+ (char*) pDstData, cmd->width, cmd->height, xfc->scanline_pad, 0);
+ XPutImage(xfc->display, xfc->primary, xfc->gc, image, 0, 0,
+ cmd->destLeft, cmd->destTop,
+ cmd->width, cmd->height);
+ XFree(image);
+ ret = xf_gdi_surface_update_frame(xfc, cmd->destLeft, cmd->destTop, cmd->width,
+ cmd->height);
+ XSetClipMask(xfc->display, xfc->gc, None);
+ break;
- XSetFunction(xfc->display, xfc->gc, GXcopy);
- XSetFillStyle(xfc->display, xfc->gc, FillSolid);
- pSrcData = xfc->codecs->nsc->BitmapData;
- pDstData = xfc->bitmap_buffer;
- image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,
- (char*) pDstData, cmd->width, cmd->height, xfc->scanline_pad, 0);
- XPutImage(xfc->display, xfc->primary, xfc->gc, image, 0, 0,
- cmd->destLeft, cmd->destTop, cmd->width, cmd->height);
- XFree(image);
- ret = xf_gdi_surface_update_frame(xfc, cmd->destLeft, cmd->destTop, cmd->width,
- cmd->height);
- XSetClipMask(xfc->display, xfc->gc, None);
- }
- else if (cmd->codecID == RDP_CODEC_ID_NONE)
- {
- XSetFunction(xfc->display, xfc->gc, GXcopy);
- XSetFillStyle(xfc->display, xfc->gc, FillSolid);
- pSrcData = cmd->bitmapData;
- pDstData = xfc->bitmap_buffer;
- freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
- cmd->width, cmd->height, pSrcData,
- PIXEL_FORMAT_BGRX32_VF, -1, 0, 0, &xfc->palette);
- image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,
- (char*) pDstData, cmd->width, cmd->height, xfc->scanline_pad, 0);
- XPutImage(xfc->display, xfc->primary, xfc->gc, image, 0, 0,
- cmd->destLeft, cmd->destTop,
- cmd->width, cmd->height);
- XFree(image);
- ret = xf_gdi_surface_update_frame(xfc, cmd->destLeft, cmd->destTop, cmd->width,
- cmd->height);
- XSetClipMask(xfc->display, xfc->gc, None);
- }
- else
- {
- WLog_ERR(TAG, "Unsupported codecID %d", cmd->codecID);
+ default:
+ WLog_ERR(TAG, "Unsupported codecID %d", cmd->codecID);
}
xf_unlock_x11(xfc, FALSE);
UINT32 surfaceX, surfaceY;
RECTANGLE_16 surfaceRect;
const RECTANGLE_16* extents;
-
surfaceX = surface->gdi.outputOriginX;
surfaceY = surface->gdi.outputOriginY;
-
surfaceRect.left = surfaceX;
surfaceRect.top = surfaceY;
surfaceRect.right = surfaceX + surface->gdi.width;
surfaceRect.bottom = surfaceY + surface->gdi.height;
-
XSetClipMask(xfc->display, xfc->gc, None);
XSetFunction(xfc->display, xfc->gc, GXcopy);
XSetFillStyle(xfc->display, xfc->gc, FillSolid);
if (!region16_is_empty(&surface->gdi.invalidRegion))
{
extents = region16_extents(&surface->gdi.invalidRegion);
-
width = extents->right - extents->left;
height = extents->bottom - extents->top;
if (surface->stage)
{
freerdp_image_copy(surface->stage, xfc->format,
- surface->stageScanline, 0, 0,
- surface->gdi.width, surface->gdi.height,
- surface->gdi.data, surface->gdi.format,
- surface->gdi.scanline, 0, 0, NULL);
+ surface->stageScanline, 0, 0,
+ surface->gdi.width, surface->gdi.height,
+ surface->gdi.data, surface->gdi.format,
+ surface->gdi.scanline, 0, 0, NULL);
}
#ifdef WITH_XRENDER
+
if (xfc->settings->SmartSizing || xfc->settings->MultiTouchGestures)
{
XPutImage(xfc->display, xfc->primary, xfc->gc, surface->image,
- extents->left, extents->top, extents->left + surfaceX, extents->top + surfaceY, width, height);
-
+ extents->left, extents->top, extents->left + surfaceX, extents->top + surfaceY,
+ width, height);
xf_draw_screen(xfc, extents->left, extents->top, width, height);
}
else
#endif
{
XPutImage(xfc->display, xfc->drawable, xfc->gc,
- surface->image, extents->left, extents->top,
- extents->left + surfaceX, extents->top + surfaceY,
- width, height);
+ surface->image, extents->left, extents->top,
+ extents->left + surfaceX, extents->top + surfaceY,
+ width, height);
}
}
region16_clear(&surface->gdi.invalidRegion);
-
XSetClipMask(xfc->display, xfc->gc, None);
XSync(xfc->display, False);
-
return 0;
}
}
free(pSurfaceIds);
-
return status;
}
UINT xf_OutputExpose(xfContext* xfc, UINT32 x, UINT32 y,
- UINT32 width, UINT32 height)
+ UINT32 width, UINT32 height)
{
UINT16 count;
UINT32 index;
RECTANGLE_16 intersection;
UINT16* pSurfaceIds = NULL;
RdpgfxClientContext* context = xfc->gfx;
-
invalidRect.left = x;
invalidRect.top = y;
invalidRect.right = x + width;
invalidRect.bottom = y + height;
-
context->GetSurfaceIds(context, &pSurfaceIds, &count);
for (index = 0; index < count; index++)
intersection.top -= surfaceRect.top;
intersection.right -= surfaceRect.left;
intersection.bottom -= surfaceRect.top;
-
region16_union_rect(&surface->gdi.invalidRegion,
- &surface->gdi.invalidRegion,
- &intersection);
+ &surface->gdi.invalidRegion,
+ &intersection);
}
}
free(pSurfaceIds);
-
IFCALLRET(context->UpdateSurfaces, status, context);
+
if (status < 0)
status = -1;
* @return 0 on success, otherwise a Win32 error code
*/
static UINT xf_CreateSurface(RdpgfxClientContext* context,
- const RDPGFX_CREATE_SURFACE_PDU* createSurface)
+ const RDPGFX_CREATE_SURFACE_PDU* createSurface)
{
size_t size;
xfGfxSurface* surface;
rdpGdi* gdi = (rdpGdi*)context->custom;
xfContext* xfc = (xfContext*) gdi->context;
-
surface = (xfGfxSurface*) calloc(1, sizeof(xfGfxSurface));
if (!surface)
return CHANNEL_RC_NO_MEMORY;
- surface->gdi.codecs = codecs_new((rdpContext*) xfc);
+ surface->gdi.codecs = codecs_new(gdi->context);
if (!surface->gdi.codecs)
{
- free (surface);
+ free(surface);
return CHANNEL_RC_NO_MEMORY;
}
- if (!freerdp_client_codecs_reset(surface->gdi.codecs, FREERDP_CODEC_ALL,
- createSurface->width, createSurface->height))
+ if (!freerdp_client_codecs_prepare(surface->gdi.codecs, FREERDP_CODEC_ALL,
+ createSurface->width, createSurface->height))
{
- free (surface);
+ free(surface);
return ERROR_INTERNAL_ERROR;
}
surface->gdi.surfaceId = createSurface->surfaceId;
surface->gdi.width = (UINT32) createSurface->width;
surface->gdi.height = (UINT32) createSurface->height;
- switch(createSurface->pixelFormat)
+
+ switch (createSurface->pixelFormat)
{
- case GFX_PIXEL_FORMAT_ARGB_8888:
- surface->gdi.format = PIXEL_FORMAT_BGRA32;
- break;
- case GFX_PIXEL_FORMAT_XRGB_8888:
- surface->gdi.format = PIXEL_FORMAT_BGRX32;
- break;
- default:
- free (surface);
- return ERROR_INTERNAL_ERROR;
+ case GFX_PIXEL_FORMAT_ARGB_8888:
+ surface->gdi.format = PIXEL_FORMAT_BGRA32;
+ break;
+
+ case GFX_PIXEL_FORMAT_XRGB_8888:
+ surface->gdi.format = PIXEL_FORMAT_BGRX32;
+ break;
+
+ default:
+ free(surface);
+ return ERROR_INTERNAL_ERROR;
}
- surface->gdi.scanline = surface->gdi.width * GetBytesPerPixel(surface->gdi.format);
+ surface->gdi.scanline = surface->gdi.width * GetBytesPerPixel(
+ surface->gdi.format);
+
if (xfc->scanline_pad > 0)
{
surface->gdi.scanline += (xfc->scanline_pad / 8);
}
ZeroMemory(surface->gdi.data, size);
+
if (xfc->format == surface->gdi.format)
{
surface->image = XCreateImage(xfc->display, xfc->visual, xfc->depth, ZPixmap, 0,
- (char*) surface->gdi.data, surface->gdi.width, surface->gdi.height, xfc->scanline_pad, surface->gdi.scanline);
+ (char*) surface->gdi.data, surface->gdi.width, surface->gdi.height,
+ xfc->scanline_pad, surface->gdi.scanline);
}
else
{
UINT32 width = surface->gdi.width;
UINT32 bytes = GetBytesPerPixel(xfc->format);
-
surface->stageScanline = width * bytes;
+
if (xfc->scanline_pad > 0)
{
surface->stageScanline += (xfc->scanline_pad / 8);
}
size = surface->stageScanline * surface->gdi.height;
-
surface->stage = (BYTE*) _aligned_malloc(size, 16);
if (!surface->stage)
}
ZeroMemory(surface->stage, size);
-
surface->image = XCreateImage(xfc->display, xfc->visual, xfc->depth,
- ZPixmap, 0, (char*) surface->stage,
- surface->gdi.width, surface->gdi.height,
- xfc->scanline_pad, surface->gdi.scanline);
+ ZPixmap, 0, (char*) surface->stage,
+ surface->gdi.width, surface->gdi.height,
+ xfc->scanline_pad, surface->gdi.scanline);
}
surface->gdi.outputMapped = FALSE;
-
region16_init(&surface->gdi.invalidRegion);
-
context->SetSurfaceData(context, surface->gdi.surfaceId, (void*) surface);
-
return CHANNEL_RC_OK;
}
* @return 0 on success, otherwise a Win32 error code
*/
static UINT xf_DeleteSurface(RdpgfxClientContext* context,
- const RDPGFX_DELETE_SURFACE_PDU* deleteSurface)
+ const RDPGFX_DELETE_SURFACE_PDU* deleteSurface)
{
rdpCodecs* codecs = NULL;
xfGfxSurface* surface = NULL;
-
- surface = (xfGfxSurface*) context->GetSurfaceData(context, deleteSurface->surfaceId);
+ surface = (xfGfxSurface*) context->GetSurfaceData(context,
+ deleteSurface->surfaceId);
if (surface)
{
context->SetSurfaceData(context, deleteSurface->surfaceId, NULL);
if (codecs && codecs->progressive)
- progressive_delete_surface_context(codecs->progressive, deleteSurface->surfaceId);
+ progressive_delete_surface_context(codecs->progressive,
+ deleteSurface->surfaceId);
codecs_free(codecs);
-
return CHANNEL_RC_OK;
}
void xf_graphics_pipeline_init(xfContext* xfc, RdpgfxClientContext* gfx)
{
rdpGdi* gdi = xfc->context.gdi;
-
gdi_graphics_pipeline_init(gdi, gfx);
-
gfx->UpdateSurfaces = xf_UpdateSurfaces;
gfx->CreateSurface = xf_CreateSurface;
gfx->DeleteSurface = xf_DeleteSurface;
XImage* image;
UINT32 SrcFormat;
xfContext* xfc = (xfContext*) context;
-
xf_lock_x11(xfc, FALSE);
-
data = bitmap->data;
depth = GetBitsPerPixel(bitmap->format);
-
- pixmap = XCreatePixmap(xfc->display, xfc->drawable, bitmap->width, bitmap->height, xfc->depth);
+ pixmap = XCreatePixmap(xfc->display, xfc->drawable, bitmap->width,
+ bitmap->height, xfc->depth);
if (bitmap->data)
{
}
SrcFormat = bitmap->format;
-
freerdp_image_copy(data, xfc->format, -1, 0, 0,
- bitmap->width, bitmap->height,
- bitmap->data, SrcFormat,
- -1, 0, 0, &xfc->palette);
-
+ bitmap->width, bitmap->height,
+ bitmap->data, SrcFormat,
+ -1, 0, 0, &xfc->palette);
_aligned_free(bitmap->data);
bitmap->data = data;
-
bitmap->format = xfc->format;
}
image = XCreateImage(xfc->display, xfc->visual, xfc->depth,
- ZPixmap, 0, (char*) bitmap->data, bitmap->width, bitmap->height, xfc->scanline_pad, 0);
-
- XPutImage(xfc->display, pixmap, xfc->gc, image, 0, 0, 0, 0, bitmap->width, bitmap->height);
-
+ ZPixmap, 0, (char*) bitmap->data, bitmap->width, bitmap->height,
+ xfc->scanline_pad, 0);
+ XPutImage(xfc->display, pixmap, xfc->gc, image, 0, 0, 0, 0, bitmap->width,
+ bitmap->height);
XFree(image);
}
((xfBitmap*) bitmap)->pixmap = pixmap;
-
xf_unlock_x11(xfc, FALSE);
return TRUE;
}
static void xf_Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
{
xfContext* xfc = (xfContext*) context;
-
xf_lock_x11(xfc, FALSE);
if (((xfBitmap*) bitmap)->pixmap != 0)
int width, height;
xfContext* xfc = (xfContext*) context;
BOOL ret = TRUE;
-
width = bitmap->right - bitmap->left + 1;
height = bitmap->bottom - bitmap->top + 1;
-
xf_lock_x11(xfc, FALSE);
-
XSetFunction(xfc->display, xfc->gc, GXcopy);
-
image = XCreateImage(xfc->display, xfc->visual, xfc->depth,
- ZPixmap, 0, (char*) bitmap->data, bitmap->width, bitmap->height, xfc->scanline_pad, 0);
-
+ ZPixmap, 0, (char*) bitmap->data, bitmap->width, bitmap->height,
+ xfc->scanline_pad, 0);
XPutImage(xfc->display, xfc->primary, xfc->gc,
- image, 0, 0, bitmap->left, bitmap->top, width, height);
-
+ image, 0, 0, bitmap->left, bitmap->top, width, height);
XFree(image);
-
ret = gdi_InvalidateRegion(xfc->hdc, bitmap->left, bitmap->top, width, height);
-
xf_unlock_x11(xfc, FALSE);
return TRUE;
}
static BOOL xf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
- const BYTE* data, UINT32 width, UINT32 height, UINT32 bpp, UINT32 length,
- BOOL compressed, UINT32 codecId)
+ const BYTE* data, UINT32 width, UINT32 height, UINT32 bpp, UINT32 length,
+ BOOL compressed, UINT32 codecId)
{
int status;
UINT16 size;
UINT32 SrcFormat;
UINT32 bytesPerPixel;
xfContext* xfc = (xfContext*) context;
-
bytesPerPixel = (bpp + 7) / 8;
size = width * height * 4;
-
bitmap->data = (BYTE*) _aligned_malloc(size, 16);
+
if (!bitmap->data)
return FALSE;
{
if (bpp < 32)
{
- if (!freerdp_client_codecs_prepare(xfc->codecs, FREERDP_CODEC_INTERLEAVED,
- xfc->settings->DesktopWidth,
- xfc->settings->DesktopHeight))
- return FALSE;
-
- status = interleaved_decompress(xfc->codecs->interleaved,
- pSrcData, SrcSize, bpp,
- pDstData, xfc->format,
- -1, 0, 0, width, height,
- &xfc->palette);
+ status = interleaved_decompress(context->codecs->interleaved,
+ pSrcData, SrcSize, bpp,
+ pDstData, xfc->format,
+ -1, 0, 0, width, height,
+ &xfc->palette);
}
else
{
- if (!freerdp_client_codecs_prepare(xfc->codecs, FREERDP_CODEC_PLANAR,
- xfc->settings->DesktopWidth,
- xfc->settings->DesktopHeight))
- return FALSE;
-
- status = planar_decompress(xfc->codecs->planar, pSrcData, SrcSize,
- pDstData, xfc->format, -1, 0, 0, width, height, TRUE);
+ status = planar_decompress(context->codecs->planar, pSrcData, SrcSize,
+ pDstData, xfc->format, -1, 0, 0, width, height, TRUE);
}
if (status < 0)
else
{
SrcFormat = gdi_get_pixel_format(bpp, TRUE);
-
status = freerdp_image_copy(pDstData, xfc->format, -1, 0, 0,
- width, height, pSrcData,
- SrcFormat, -1, 0, 0, &xfc->palette);
+ width, height, pSrcData,
+ SrcFormat, -1, 0, 0, &xfc->palette);
}
bitmap->compressed = FALSE;
return TRUE;
}
-static BOOL xf_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
+static BOOL xf_Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap,
+ BOOL primary)
{
xfContext* xfc = (xfContext*) context;
-
xf_lock_x11(xfc, FALSE);
if (primary)
#ifdef WITH_XCURSOR
XcursorImage ci;
xfContext* xfc = (xfContext*) context;
-
xf_lock_x11(xfc, FALSE);
-
ZeroMemory(&ci, sizeof(ci));
ci.version = XCURSOR_IMAGE_VERSION;
ci.size = sizeof(ci);
}
if (freerdp_image_copy_from_pointer_data(
- (BYTE*) ci.pixels, xfc->format,
- pointer->width * 4, 0, 0, pointer->width, pointer->height,
- pointer->xorMaskData, pointer->lengthXorMask,
- pointer->andMaskData, pointer->lengthAndMask,
- pointer->xorBpp, &xfc->palette) < 0)
+ (BYTE*) ci.pixels, xfc->format,
+ pointer->width * 4, 0, 0, pointer->width, pointer->height,
+ pointer->xorMaskData, pointer->lengthXorMask,
+ pointer->andMaskData, pointer->lengthAndMask,
+ pointer->xorBpp, &xfc->palette) < 0)
{
free(ci.pixels);
xf_unlock_x11(xfc, FALSE);
}
((xfPointer*) pointer)->cursor = XcursorImageLoadCursor(xfc->display, &ci);
-
free(ci.pixels);
-
xf_unlock_x11(xfc, FALSE);
#endif
return TRUE;
{
#ifdef WITH_XCURSOR
xfContext* xfc = (xfContext*) context;
-
xf_lock_x11(xfc, FALSE);
if (((xfPointer*) pointer)->cursor)
}
static BOOL xf_Pointer_Set(rdpContext* context,
- const rdpPointer* pointer)
+ const rdpPointer* pointer)
{
#ifdef WITH_XCURSOR
xfContext* xfc = (xfContext*) context;
-
xf_lock_x11(xfc, FALSE);
-
xfc->pointer = (xfPointer*) pointer;
/* in RemoteApp mode, window can be null if none has had focus */
#ifdef WITH_XCURSOR
xfContext* xfc = (xfContext*) context;
static Cursor nullcursor = None;
-
xf_lock_x11(xfc, FALSE);
if (nullcursor == None)
{
#ifdef WITH_XCURSOR
xfContext* xfc = (xfContext*) context;
-
xf_lock_x11(xfc, FALSE);
-
xfc->pointer = NULL;
if (xfc->window)
goto out;
tmp.event_mask = (current.your_event_mask & ~(PointerMotionMask));
- if (XChangeWindowAttributes(xfc->display, xfc->window->handle, CWEventMask, &tmp) == 0)
+
+ if (XChangeWindowAttributes(xfc->display, xfc->window->handle, CWEventMask,
+ &tmp) == 0)
goto out;
XWarpPointer(xfc->display, None, xfc->window->handle, 0, 0, 0, 0, x, y);
-
tmp.event_mask = current.your_event_mask;
XChangeWindowAttributes(xfc->display, xfc->window->handle, CWEventMask, &tmp);
-
ret = TRUE;
out:
xf_unlock_x11(xfc, FALSE);
return ret;
-
}
/* Glyph Class */
int scanline;
XImage* image;
xfGlyph* xf_glyph;
-
xf_glyph = (xfGlyph*) glyph;
xfContext* xfc = (xfContext*) context;
-
xf_lock_x11(xfc, FALSE);
-
scanline = (glyph->cx + 7) / 8;
-
- xf_glyph->pixmap = XCreatePixmap(xfc->display, xfc->drawing, glyph->cx, glyph->cy, 1);
-
+ xf_glyph->pixmap = XCreatePixmap(xfc->display, xfc->drawing, glyph->cx,
+ glyph->cy, 1);
image = XCreateImage(xfc->display, xfc->visual, 1,
- ZPixmap, 0, (char*) glyph->aj, glyph->cx, glyph->cy, 8, scanline);
-
+ ZPixmap, 0, (char*) glyph->aj, glyph->cx, glyph->cy, 8, scanline);
image->byte_order = MSBFirst;
image->bitmap_bit_order = MSBFirst;
-
XInitImage(image);
- XPutImage(xfc->display, xf_glyph->pixmap, xfc->gc_mono, image, 0, 0, 0, 0, glyph->cx, glyph->cy);
+ XPutImage(xfc->display, xf_glyph->pixmap, xfc->gc_mono, image, 0, 0, 0, 0,
+ glyph->cx, glyph->cy);
XFree(image);
-
xf_unlock_x11(xfc, FALSE);
return TRUE;
}
static void xf_Glyph_Free(rdpContext* context, rdpGlyph* glyph)
{
xfContext* xfc = (xfContext*) context;
-
xf_lock_x11(xfc, FALSE);
if (((xfGlyph*) glyph)->pixmap != 0)
xf_unlock_x11(xfc, FALSE);
}
-static BOOL xf_Glyph_Draw(rdpContext* context, rdpGlyph* glyph, UINT32 x, UINT32 y)
+static BOOL xf_Glyph_Draw(rdpContext* context, rdpGlyph* glyph, UINT32 x,
+ UINT32 y)
{
xfGlyph* xf_glyph;
xfContext* xfc = (xfContext*) context;
-
xf_glyph = (xfGlyph*) glyph;
-
xf_lock_x11(xfc, FALSE);
-
XSetStipple(xfc->display, xfc->gc, xf_glyph->pixmap);
XSetTSOrigin(xfc->display, xfc->gc, x, y);
XFillRectangle(xfc->display, xfc->drawing, xfc->gc, x, y, glyph->cx, glyph->cy);
XSetStipple(xfc->display, xfc->gc, xfc->bitmap_mono);
-
xf_unlock_x11(xfc, FALSE);
return TRUE;
}
static BOOL xf_Glyph_BeginDraw(rdpContext* context, UINT32 x, UINT32 y,
- UINT32 width, UINT32 height, UINT32 bgcolor,
- UINT32 fgcolor, BOOL fOpRedundant)
+ UINT32 width, UINT32 height, UINT32 bgcolor,
+ UINT32 fgcolor, BOOL fOpRedundant)
{
xfContext* xfc = (xfContext*) context;
-
bgcolor = xf_convert_rdp_order_color(xfc, bgcolor);
fgcolor = xf_convert_rdp_order_color(xfc, fgcolor);
-
xf_lock_x11(xfc, FALSE);
-
XSetFunction(xfc->display, xfc->gc, GXcopy);
if (width && height)
XSetForeground(xfc->display, xfc->gc, bgcolor);
XSetBackground(xfc->display, xfc->gc, fgcolor);
-
- XSetFillStyle(xfc->display, xfc->gc, fOpRedundant ? FillOpaqueStippled : FillStippled);
-
+ XSetFillStyle(xfc->display, xfc->gc,
+ fOpRedundant ? FillOpaqueStippled : FillStippled);
xf_unlock_x11(xfc, FALSE);
return TRUE;
}
static BOOL xf_Glyph_EndDraw(rdpContext* context, UINT32 x, UINT32 y,
- UINT32 width, UINT32 height,
- UINT32 bgcolor, UINT32 fgcolor)
+ UINT32 width, UINT32 height,
+ UINT32 bgcolor, UINT32 fgcolor)
{
xfContext* xfc = (xfContext*) context;
BOOL ret = TRUE;
-
xf_lock_x11(xfc, FALSE);
if (xfc->drawing == xfc->primary)
bitmap->Paint = xf_Bitmap_Paint;
bitmap->Decompress = xf_Bitmap_Decompress;
bitmap->SetSurface = xf_Bitmap_SetSurface;
-
graphics_register_bitmap(graphics, bitmap);
-
pointer->size = sizeof(xfPointer);
pointer->New = xf_Pointer_New;
pointer->Free = xf_Pointer_Free;
pointer->SetNull = xf_Pointer_SetNull;
pointer->SetDefault = xf_Pointer_SetDefault;
pointer->SetPosition = xf_Pointer_SetPosition;
-
graphics_register_pointer(graphics, pointer);
-
glyph->size = sizeof(xfGlyph);
glyph->New = xf_Glyph_New;
glyph->Free = xf_Glyph_Free;
glyph->Draw = xf_Glyph_Draw;
glyph->BeginDraw = xf_Glyph_BeginDraw;
glyph->EndDraw = xf_Glyph_EndDraw;
-
graphics_register_glyph(graphics, glyph);
-
ret = TRUE;
-
out:
free(bitmap);
free(pointer);
free(glyph);
-
return ret;
}
freerdp* instance;
rdpSettings* settings;
- rdpCodecs* codecs;
GC gc;
int xfds;
HANDLE mutex;
BOOL UseXThreads;
BOOL cursorHidden;
- gdiPalette palette;
+ gdiPalette palette;
HGDI_DC hdc;
UINT32 bitmap_size;
BOOL xf_create_window(xfContext* xfc);
void xf_toggle_fullscreen(xfContext* xfc);
void xf_toggle_control(xfContext* xfc);
-BOOL xf_post_connect(freerdp* instance);
void xf_encomsp_init(xfContext* xfc, EncomspClientContext* encomsp);
void xf_encomsp_uninit(xfContext* xfc, EncomspClientContext* encomsp);
#include <freerdp/codec/color.h>
#include <freerdp/codec/clear.h>
+#include <freerdp/log.h>
-static UINT32 CLEAR_LOG2_FLOOR[256] =
+#define TAG FREERDP_TAG("codec.clear")
+
+static const UINT32 CLEAR_LOG2_FLOOR[256] =
{
0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
};
-static BYTE CLEAR_8BIT_MASKS[9] =
+static const BYTE CLEAR_8BIT_MASKS[9] =
{
0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF
};
static void convert_color(BYTE* dst, UINT32 nDstStep, UINT32 DstFormat,
- UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight,
- const BYTE* src, UINT32 nSrcStep, UINT32 SrcFormat,
- UINT32 nDstWidth, UINT32 nDstHeight, const gdiPalette* palette)
+ UINT32 nXDst, UINT32 nYDst, UINT32 nWidth, UINT32 nHeight,
+ const BYTE* src, UINT32 nSrcStep, UINT32 SrcFormat,
+ UINT32 nDstWidth, UINT32 nDstHeight, const gdiPalette* palette)
{
UINT32 x, y;
if (nWidth + nXDst > nDstWidth)
nWidth = nDstWidth - nXDst;
+
if (nHeight + nYDst > nDstHeight)
nHeight = nDstHeight - nYDst;
for (x = 0; x < nWidth; x++)
{
const BYTE* pSrcPixel =
- &pSrcLine[x * GetBytesPerPixel(SrcFormat)];
+ &pSrcLine[x * GetBytesPerPixel(SrcFormat)];
BYTE* pDstPixel =
- &pDstLine[(nXDst + x) * GetBytesPerPixel(DstFormat)];
+ &pDstLine[(nXDst + x) * GetBytesPerPixel(DstFormat)];
UINT32 color = ReadColor(pSrcPixel, SrcFormat);
color = ConvertColor(color, SrcFormat,
- DstFormat, palette);
+ DstFormat, palette);
WriteColor(pDstPixel, DstFormat, color);
}
}
}
static BOOL clear_decompress_nscodec(NSC_CONTEXT* nsc, UINT32 width,
- UINT32 height,
- const BYTE* bitmapData, UINT32 bitmapDataByteCount,
- BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
- UINT32 nXDstRel, UINT32 nYDstRel)
+ UINT32 height,
+ wStream* s, UINT32 bitmapDataByteCount,
+ BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
+ UINT32 nXDstRel, UINT32 nYDstRel)
{
- return nsc_process_message(nsc, 32, width, height, bitmapData,
- bitmapDataByteCount, pDstData, DstFormat,
- nDstStep, nXDstRel, nYDstRel, width, height);
+ BOOL rc;
+
+ if (Stream_GetRemainingLength(s) < bitmapDataByteCount)
+ return FALSE;
+
+ rc = nsc_process_message(nsc, 32, width, height, Stream_Pointer(s),
+ bitmapDataByteCount, pDstData, DstFormat,
+ nDstStep, nXDstRel, nYDstRel, width, height);
+ Stream_Seek(s, bitmapDataByteCount);
+ return rc;
}
-static BOOL clear_decompress_subcode_rlex(const BYTE* bitmapData,
- UINT32 bitmapDataByteCount,
- UINT32 width, UINT32 height,
- BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
- UINT32 nXDstRel, UINT32 nYDstRel, UINT32 nDstWidth, UINT32 nDstHeight)
+static BOOL clear_decompress_subcode_rlex(wStream* s,
+ UINT32 bitmapDataByteCount,
+ UINT32 width, UINT32 height,
+ BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
+ UINT32 nXDstRel, UINT32 nYDstRel, UINT32 nDstWidth, UINT32 nDstHeight)
{
UINT32 x = 0, y = 0;
UINT32 i;
BYTE suiteIndex;
BYTE suiteDepth;
BYTE paletteCount;
- const BYTE* pSrcPixel8;
UINT32 palette[128];
- paletteCount = bitmapData[0];
- pSrcPixel8 = &bitmapData[1];
+
+ if (Stream_GetRemainingLength(s) < bitmapDataByteCount)
+ return FALSE;
+
+ Stream_Read_UINT8(s, paletteCount);
bitmapDataOffset = 1 + (paletteCount * 3);
if (paletteCount > 127)
for (i = 0; i < paletteCount; i++)
{
- UINT32 color = GetColor(
- SrcFormat,
- pSrcPixel8[2],
- pSrcPixel8[1],
- pSrcPixel8[0],
- 0xFF);
+ BYTE r, g, b;
+ Stream_Read_UINT8(s, b);
+ Stream_Read_UINT8(s, g);
+ Stream_Read_UINT8(s, r);
+ UINT32 color = GetColor(SrcFormat, r, g, b, 0xFF);
palette[i] = ConvertColor(color, SrcFormat, DstFormat, NULL);
- pSrcPixel8 += GetBytesPerPixel(SrcFormat);
}
pixelIndex = 0;
while (bitmapDataOffset < bitmapDataByteCount)
{
+ UINT32 tmp;
UINT32 color;
UINT32 runLengthFactor;
- if ((bitmapDataByteCount - bitmapDataOffset) < 2)
+ if (Stream_GetRemainingLength(s) < 2)
return FALSE;
- stopIndex = bitmapData[bitmapDataOffset] & CLEAR_8BIT_MASKS[numBits];
- suiteDepth = (bitmapData[bitmapDataOffset] >> numBits) & CLEAR_8BIT_MASKS[(8 -
- numBits)];
+ Stream_Read_UINT8(s, tmp);
+ Stream_Read_UINT8(s, runLengthFactor);
+ bitmapDataOffset += 2;
+ suiteDepth = (tmp >> numBits) & CLEAR_8BIT_MASKS[(8 - numBits)];
+ stopIndex = tmp & CLEAR_8BIT_MASKS[numBits];
startIndex = stopIndex - suiteDepth;
- bitmapDataOffset++;
- runLengthFactor = (UINT32) bitmapData[bitmapDataOffset];
- bitmapDataOffset++;
if (runLengthFactor >= 0xFF)
{
- if ((bitmapDataByteCount - bitmapDataOffset) < 2)
+ if (Stream_GetRemainingLength(s) < 2)
return FALSE;
- runLengthFactor = (UINT32) * ((UINT16*) &bitmapData[bitmapDataOffset]);
+ Stream_Read_UINT16(s, runLengthFactor);
bitmapDataOffset += 2;
if (runLengthFactor >= 0xFFFF)
{
- if ((bitmapDataByteCount - bitmapDataOffset) < 4)
+ if (Stream_GetRemainingLength(s) < 4)
return FALSE;
- runLengthFactor = *((UINT32*) &bitmapData[bitmapDataOffset]);
+ Stream_Read_UINT32(s, runLengthFactor);
bitmapDataOffset += 4;
}
}
for (i = 0; i < runLengthFactor; i++)
{
- BYTE* pTmpData = &pDstData[(nXDstRel + x) * GetBytesPerPixel(DstFormat) + (nYDstRel + y) * nDstStep];
+ BYTE* pTmpData = &pDstData[(nXDstRel + x) * GetBytesPerPixel(DstFormat) +
+ (nYDstRel + y) * nDstStep];
+
if ((nXDstRel + x < nDstWidth) && (nYDstRel + y < nDstHeight))
WriteColor(pTmpData, DstFormat, color);
- if (++x >= width) {
+ if (++x >= width)
+ {
y++;
x = 0;
-
}
}
for (i = 0; i <= suiteDepth; i++)
{
- BYTE* pTmpData = &pDstData[(nXDstRel + x) * GetBytesPerPixel(DstFormat) + (nYDstRel + y) * nDstStep];
+ BYTE* pTmpData = &pDstData[(nXDstRel + x) * GetBytesPerPixel(DstFormat) +
+ (nYDstRel + y) * nDstStep];
UINT32 color = palette[suiteIndex++];
+
if ((nXDstRel + x < nDstWidth) && (nYDstRel + y < nDstHeight))
WriteColor(pTmpData, DstFormat, color);
- if (++x >= width) {
+ if (++x >= width)
+ {
y++;
x = 0;
}
nSrcStep = width * GetBytesPerPixel(DstFormat);
if (pixelIndex != pixelCount)
- return -1055;
+ return FALSE;
return TRUE;
}
static BOOL clear_decompress_residual_data(CLEAR_CONTEXT* clear,
- const BYTE* residualData,
- UINT32 residualByteCount, UINT32 SrcSize,
- UINT32 nWidth, UINT32 nHeight,
- BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
- UINT32 nXDst, UINT32 nYDst,
- UINT32 nDstWidth, UINT32 nDstHeight,
- const gdiPalette* palette)
+ wStream* s,
+ UINT32 residualByteCount,
+ UINT32 nWidth, UINT32 nHeight,
+ BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
+ UINT32 nXDst, UINT32 nYDst,
+ UINT32 nDstWidth, UINT32 nDstHeight,
+ const gdiPalette* palette)
{
UINT32 i;
UINT32 nSrcStep;
UINT32 pixelIndex;
UINT32 pixelCount;
- if (SrcSize < residualByteCount)
- return -1013;
+ if (Stream_GetRemainingLength(s) < residualByteCount)
+ return FALSE;
suboffset = 0;
-
pixelIndex = 0;
pixelCount = nWidth * nHeight;
dstBuffer = clear->TempBuffer;
while (suboffset < residualByteCount)
{
+ BYTE r, g, b;
UINT32 runLengthFactor;
UINT32 color;
- if ((residualByteCount - suboffset) < 4)
- return -1015;
+ if (Stream_GetRemainingLength(s) < 4)
+ return FALSE;
- color = GetColor(clear->format, residualData[suboffset + 2],
- residualData[suboffset + 1],
- residualData[suboffset + 0], 0xFF);
- suboffset += 3;
- runLengthFactor = residualData[suboffset];
- suboffset++;
+ Stream_Read_UINT8(s, b);
+ Stream_Read_UINT8(s, g);
+ Stream_Read_UINT8(s, r);
+ Stream_Read_UINT8(s, runLengthFactor);
+ suboffset += 4;
+ color = GetColor(clear->format, r, g, b, 0xFF);
if (runLengthFactor >= 0xFF)
{
- if ((residualByteCount - suboffset) < 2)
- return -1016;
+ if (Stream_GetRemainingLength(s) < 2)
+ return FALSE;
- runLengthFactor = (UINT32) * ((UINT16*) &residualData[suboffset]);
+ Stream_Read_UINT16(s, runLengthFactor);
suboffset += 2;
if (runLengthFactor >= 0xFFFF)
{
- if ((residualByteCount - suboffset) < 4)
- return -1017;
+ if (Stream_GetRemainingLength(s) < 4)
+ return FALSE;
- runLengthFactor = *((UINT32*) &residualData[suboffset]);
+ Stream_Read_UINT32(s, runLengthFactor);
suboffset += 4;
}
}
if ((pixelIndex + runLengthFactor) > pixelCount)
- return -1018;
+ return FALSE;
for (i = 0; i < runLengthFactor; i++)
{
return -1019;
convert_color(pDstData, nDstStep, DstFormat,
- nXDst, nYDst, nWidth, nHeight,
- clear->TempBuffer, nSrcStep, clear->format,
- nDstWidth, nDstHeight, palette);
+ nXDst, nYDst, nWidth, nHeight,
+ clear->TempBuffer, nSrcStep, clear->format,
+ nDstWidth, nDstHeight, palette);
+ return TRUE;
+}
+
+static BOOL clear_decompress_subcodecs_data(CLEAR_CONTEXT* clear, wStream* s,
+ UINT32 subcodecByteCount, UINT32 nWidth, UINT32 nHeight,
+ BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
+ UINT32 nXDst, UINT32 nYDst, UINT32 nDstWidth, UINT32 nDstHeight,
+ const gdiPalette* palette)
+{
+ UINT16 xStart;
+ UINT16 yStart;
+ UINT16 width;
+ UINT16 height;
+ UINT32 bitmapDataByteCount;
+ BYTE subcodecId;
+ UINT32 suboffset;
+
+ if (Stream_GetRemainingLength(s) < subcodecByteCount)
+ return FALSE;
+
+ suboffset = 0;
+
+ while (suboffset < subcodecByteCount)
+ {
+ UINT32 nXDstRel;
+ UINT32 nYDstRel;
+
+ if (Stream_GetRemainingLength(s) < 13)
+ return FALSE;
+
+ Stream_Read_UINT16(s, xStart);
+ Stream_Read_UINT16(s, yStart);
+ Stream_Read_UINT16(s, width);
+ Stream_Read_UINT16(s, height);
+ Stream_Read_UINT32(s, bitmapDataByteCount);
+ Stream_Read_UINT8(s, subcodecId);
+ suboffset += 13;
+
+ if (Stream_GetRemainingLength(s) < bitmapDataByteCount)
+ return FALSE;
+
+ nXDstRel = nXDst + xStart;
+ nYDstRel = nYDst + yStart;
+
+ if (width > nWidth)
+ return FALSE;
+
+ if (height > nHeight)
+ return FALSE;
+
+ if ((width * height * GetBytesPerPixel(clear->format)) >
+ clear->TempSize)
+ {
+ clear->TempSize = (width * height * GetBytesPerPixel(clear->format));
+ clear->TempBuffer = (BYTE*) realloc(clear->TempBuffer, clear->TempSize);
+
+ if (!clear->TempBuffer)
+ return FALSE;
+ }
+
+ switch (subcodecId)
+ {
+ case 0: /* Uncompressed */
+ {
+ UINT32 nSrcStep = width * GetBytesPerPixel(PIXEL_FORMAT_BGR24);;
+ UINT32 nSrcSize = nSrcStep * height;
+
+ if (bitmapDataByteCount != nSrcSize)
+ return FALSE;
+
+ convert_color(pDstData, nDstStep, DstFormat,
+ nXDstRel, nYDstRel, width, height,
+ Stream_Pointer(s), nSrcStep,
+ PIXEL_FORMAT_BGR24,
+ nDstWidth, nDstHeight, palette);
+ Stream_Seek(s, bitmapDataByteCount);
+ }
+ break;
+
+ case 1: /* NSCodec */
+ if (!clear_decompress_nscodec(clear->nsc, width, height,
+ s, bitmapDataByteCount,
+ pDstData, DstFormat, nDstStep,
+ nXDstRel, nYDstRel))
+ return FALSE;
+
+ break;
+
+ case 2: /* CLEARCODEC_SUBCODEC_RLEX */
+ if (!clear_decompress_subcode_rlex(s,
+ bitmapDataByteCount,
+ width, height,
+ pDstData, DstFormat, nDstStep,
+ nXDstRel, nYDstRel,
+ nDstWidth, nDstHeight))
+ return FALSE;
+
+ break;
+
+ default:
+ return FALSE;
+ }
+
+ suboffset += bitmapDataByteCount;
+ }
+
+ return TRUE;
+}
+
+static BOOL resize_vbar_entry(CLEAR_CONTEXT* clear, CLEAR_VBAR_ENTRY* vBarEntry)
+{
+ if (vBarEntry->count > vBarEntry->size)
+ {
+ const UINT32 bpp = GetBytesPerPixel(clear->format);
+ BYTE* tmp;
+ vBarEntry->size = vBarEntry->count;
+ tmp = (BYTE*) realloc(vBarEntry->pixels,
+ vBarEntry->count * bpp);
+
+ if (!tmp)
+ return FALSE;
+
+ vBarEntry->pixels = tmp;
+ }
+
+ if (!vBarEntry->pixels && vBarEntry->size)
+ return FALSE;
+
return TRUE;
}
static BOOL clear_decompress_bands_data(CLEAR_CONTEXT* clear,
- const BYTE* bandsData,
- UINT32 bandsByteCount, UINT32 SrcSize,
- UINT32 nWidth, UINT32 nHeight,
- BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
- UINT32 nXDst, UINT32 nYDst)
+ wStream* s, UINT32 bandsByteCount,
+ UINT32 nWidth, UINT32 nHeight,
+ BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
+ UINT32 nXDst, UINT32 nYDst)
{
UINT32 i, y;
UINT32 count;
UINT32 nXDstRel;
UINT32 nYDstRel;
- if (SrcSize < bandsByteCount)
- return -1020;
+ if (Stream_GetRemainingLength(s) < bandsByteCount)
+ return FALSE;
suboffset = 0;
while (suboffset < bandsByteCount)
{
+ BYTE r, g, b;
UINT16 xStart;
UINT16 xEnd;
UINT16 yStart;
UINT16 yEnd;
- const BYTE* vBar;
- BOOL vBarUpdate;
UINT32 colorBkg;
UINT16 vBarHeader;
UINT16 vBarIndex;
CLEAR_VBAR_ENTRY* vBarEntry;
CLEAR_VBAR_ENTRY* vBarShortEntry;
- if ((bandsByteCount - suboffset) < 11)
- return -1021;
+ if (Stream_GetRemainingLength(s) < 11)
+ return FALSE;
- xStart = *((UINT16*) &bandsData[suboffset]);
- xEnd = *((UINT16*) &bandsData[suboffset + 2]);
- yStart = *((UINT16*) &bandsData[suboffset + 4]);
- yEnd = *((UINT16*) &bandsData[suboffset + 6]);
- suboffset += 8;
- colorBkg = GetColor(clear->format, bandsData[suboffset + 2],
- bandsData[suboffset + 1],
- bandsData[suboffset + 0],
- 0xFF);
- suboffset += 3;
+ Stream_Read_UINT16(s, xStart);
+ Stream_Read_UINT16(s, xEnd);
+ Stream_Read_UINT16(s, yStart);
+ Stream_Read_UINT16(s, yEnd);
+ Stream_Read_UINT8(s, b);
+ Stream_Read_UINT8(s, g);
+ Stream_Read_UINT8(s, r);
+ suboffset += 11;
+ colorBkg = GetColor(clear->format, r, g, b, 0xFF);
if (xEnd < xStart)
- return -1022;
+ return FALSE;
if (yEnd < yStart)
- return -1023;
+ return FALSE;
vBarCount = (xEnd - xStart) + 1;
for (i = 0; i < vBarCount; i++)
{
+ BOOL vBarUpdate = FALSE;
const BYTE* pSrcPixel;
- vBarUpdate = FALSE;
- vBar = &bandsData[suboffset];
- if ((bandsByteCount - suboffset) < 2)
- return -1024;
+ if (Stream_GetRemainingLength(s) < 2)
+ return FALSE;
- vBarHeader = *((UINT16*) &vBar[0]);
+ Stream_Read_UINT16(s, vBarHeader);;
suboffset += 2;
vBarHeight = (yEnd - yStart + 1);
if (vBarHeight > 52)
- return -1025;
+ return FALSE;
if ((vBarHeader & 0xC000) == 0x4000) /* SHORT_VBAR_CACHE_HIT */
{
vBarIndex = (vBarHeader & 0x3FFF);
if (vBarIndex >= 16384)
- return -1026;
+ return FALSE;
- if ((bandsByteCount - suboffset) < 1)
- return -1027;
+ if (Stream_GetRemainingLength(s) < 1)
+ return FALSE;
- vBarYOn = vBar[2];
+ Stream_Read_UINT8(s, vBarYOn);
suboffset += 1;
vBarShortEntry = &(clear->ShortVBarStorage[vBarIndex]);
if (!vBarShortEntry)
- return -1028;
+ return FALSE;
vBarShortPixelCount = vBarShortEntry->count;
vBarUpdate = TRUE;
}
else if ((vBarHeader & 0xC000) == 0x0000) /* SHORT_VBAR_CACHE_MISS */
{
- const BYTE* pSrcPixel8;
vBarYOn = (vBarHeader & 0xFF);
vBarYOff = ((vBarHeader >> 8) & 0x3F);
if (vBarYOff < vBarYOn)
- return -1029;
+ return FALSE;
- pSrcPixel8 = &vBar[2];
vBarShortPixelCount = (vBarYOff - vBarYOn);
if (vBarShortPixelCount > 52)
- return -1030;
+ return FALSE;
- if ((bandsByteCount - suboffset) < (vBarShortPixelCount * 3))
- return -1031;
+ if (Stream_GetRemainingLength(s) < (vBarShortPixelCount * 3))
+ return FALSE;
if (clear->ShortVBarStorageCursor >= 16384)
- return -1032;
+ return FALSE;
vBarShortEntry = &(clear->ShortVBarStorage[clear->ShortVBarStorageCursor]);
vBarShortEntry->count = vBarShortPixelCount;
- if (vBarShortEntry->count > vBarShortEntry->size)
- {
- BYTE* tmp;
- vBarShortEntry->size = vBarShortEntry->count;
- tmp = (BYTE*) realloc(
- vBarShortEntry->pixels,
- vBarShortEntry->count * GetBytesPerPixel(clear->format));
-
- if (!tmp)
- return -1;
-
- vBarShortEntry->pixels = tmp;
- }
-
- if (!vBarShortEntry->pixels && vBarShortEntry->size)
- return -1033;
+ if (!resize_vbar_entry(clear, vBarShortEntry))
+ return FALSE;
for (y = 0; y < vBarShortPixelCount; y++)
{
+ BYTE r, g, b;
BYTE* dstBuffer =
- &vBarShortEntry->pixels[y * GetBytesPerPixel(clear->format)];
- UINT32 color = GetColor(clear->format,
- pSrcPixel8[2],
- pSrcPixel8[1],
- pSrcPixel8[0],
- 0xFF);
+ &vBarShortEntry->pixels[y * GetBytesPerPixel(clear->format)];
+ UINT32 color;
+ Stream_Read_UINT8(s, b);
+ Stream_Read_UINT8(s, g);
+ Stream_Read_UINT8(s, r);
+ color = GetColor(clear->format, r, g, b, 0xFF);
WriteColor(dstBuffer, clear->format, color);
- pSrcPixel8 += 3;
}
suboffset += (vBarShortPixelCount * 3);
vBarIndex = (vBarHeader & 0x7FFF);
if (vBarIndex >= 32768)
- return -1034;
+ return FALSE;
vBarEntry = &(clear->VBarStorage[vBarIndex]);
}
else
{
- return -1035; /* invalid vBarHeader */
+ return FALSE; /* invalid vBarHeader */
}
if (vBarUpdate)
BYTE* dstBuffer;
if (clear->VBarStorageCursor >= 32768)
- return -1036;
+ return FALSE;
vBarEntry = &(clear->VBarStorage[clear->VBarStorageCursor]);
vBarPixelCount = vBarHeight;
vBarEntry->count = vBarPixelCount;
- if (vBarEntry->count > vBarEntry->size)
- {
- BYTE* tmp;
- vBarEntry->size = vBarEntry->count;
- tmp = (BYTE*) realloc(vBarEntry->pixels,
- vBarEntry->count * GetBytesPerPixel(clear->format));
-
- if (!tmp)
- return -1;
-
- vBarEntry->pixels = tmp;
- }
-
- if (!vBarEntry->pixels && vBarEntry->size)
- return -1037;
+ if (!resize_vbar_entry(clear, vBarEntry))
+ return FALSE;
dstBuffer = vBarEntry->pixels;
/* if (y < vBarYOn), use colorBkg */
count = (vBarPixelCount > y) ? (vBarPixelCount - y) : 0;
pSrcPixel = &vBarShortEntry->pixels[(y - vBarYOn) * GetBytesPerPixel(
- clear->format)];
+ clear->format)];
for (x = 0; x < count; x++)
{
UINT32 color;
color = ReadColor(&vBarShortEntry->pixels[x * GetBytesPerPixel(clear->format)],
- clear->format);
+ clear->format);
WriteColor(dstBuffer, clear->format, color);
dstBuffer += GetBytesPerPixel(clear->format);
}
clear->VBarStorageCursor = (clear->VBarStorageCursor + 1) % 32768;
}
- nXDstRel = nXDst + xStart;
- nYDstRel = nYDst + yStart;
- pSrcPixel = vBarEntry->pixels;
count = yEnd - yStart + 1;
if (vBarEntry->count != count)
- return -1038;
+ return FALSE;
+
+ nXDstRel = nXDst + xStart;
+ nYDstRel = nYDst + yStart;
+ pSrcPixel = vBarEntry->pixels;
for (y = 0; y < count; y++)
{
BYTE* pDstPixel8 = &pDstData[((nYDstRel + y) * nDstStep) +
- ((nXDstRel + i) * GetBytesPerPixel(DstFormat))];
+ ((nXDstRel + i) * GetBytesPerPixel(DstFormat))];
UINT32 color = ReadColor(pSrcPixel, clear->format);
color = ConvertColor(color, clear->format,
- DstFormat, NULL);
+ DstFormat, NULL);
WriteColor(pDstPixel8, DstFormat, color);
pSrcPixel += GetBytesPerPixel(clear->format);
}
return TRUE;
}
-INT32 clear_decompress(CLEAR_CONTEXT* clear, const BYTE* pSrcData,
- UINT32 SrcSize, UINT32 nWidth, UINT32 nHeight,
- BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
- UINT32 nXDst, UINT32 nYDst, UINT32 nDstWidth,
- UINT32 nDstHeight, const gdiPalette* palette)
+static BOOL clear_decompress_glyph_data(CLEAR_CONTEXT* clear,
+ wStream* s, UINT32 glyphFlags,
+ UINT32 nWidth, UINT32 nHeight,
+ BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
+ UINT32 nXDst, UINT32 nYDst,
+ UINT32 nDstWidth, UINT32 nDstHeight,
+ const gdiPalette* palette)
{
- BYTE seqNumber;
- BYTE glyphFlags;
- BYTE* glyphData;
- UINT32 offset = 0;
UINT16 glyphIndex = 0;
- UINT32 residualByteCount;
- UINT32 bandsByteCount;
- UINT32 subcodecByteCount;
- CLEAR_GLYPH_ENTRY* glyphEntry;
-
- if (!pDstData)
- return -1002;
-
- if ((nDstWidth == 0) || (nDstHeight == 0))
- return -1022;
-
- if (SrcSize < 2)
- return -1003;
-
- if ((nWidth > 0xFFFF) || (nHeight > 0xFFFF))
- return -1004;
- glyphFlags = pSrcData[0];
- seqNumber = pSrcData[1];
- offset += 2;
-
- if (!clear->seqNumber && seqNumber)
- clear->seqNumber = seqNumber;
-
- if (seqNumber != clear->seqNumber)
- return -1005;
-
- clear->seqNumber = (seqNumber + 1) % 256;
-
- if (glyphFlags & CLEARCODEC_FLAG_CACHE_RESET)
+ if ((glyphFlags & CLEARCODEC_FLAG_GLYPH_HIT) &&
+ !(glyphFlags & CLEARCODEC_FLAG_GLYPH_INDEX))
{
- clear->VBarStorageCursor = 0;
- clear->ShortVBarStorageCursor = 0;
+ WLog_ERR(TAG, "Invalid glyph flags %08X", glyphFlags);
+ return FALSE;
}
- if ((glyphFlags & CLEARCODEC_FLAG_GLYPH_HIT) &&
- !(glyphFlags & CLEARCODEC_FLAG_GLYPH_INDEX))
- return -1006;
+ if ((glyphFlags & CLEARCODEC_FLAG_GLYPH_INDEX) == 0)
+ return TRUE;
- if (glyphFlags & CLEARCODEC_FLAG_GLYPH_INDEX)
+ if ((nWidth * nHeight) > (1024 * 1024))
{
- if ((nWidth * nHeight) > (1024 * 1024))
- return -1007;
-
- if (SrcSize < 4)
- return -1008;
-
- glyphIndex = *((UINT16*) &pSrcData[2]);
- offset += 2;
-
- if (glyphIndex >= 4000)
- return -1009;
-
- if (glyphFlags & CLEARCODEC_FLAG_GLYPH_HIT)
- {
- UINT32 nSrcStep;
- glyphEntry = &(clear->GlyphCache[glyphIndex]);
- glyphData = (BYTE*) glyphEntry->pixels;
-
- if (!glyphData)
- return -1010;
-
- if ((nWidth * nHeight) > (int) glyphEntry->count)
- return -1011;
-
- nSrcStep = nWidth * GetBytesPerPixel(clear->format);
- convert_color(pDstData, nDstStep, DstFormat,
- nXDst, nYDst, nWidth, nHeight,
- glyphData, nSrcStep, clear->format,
- nDstWidth, nDstHeight, palette);
- return 1; /* Finish */
- }
+ WLog_ERR(TAG, "glyph too large: %ux%u", nWidth, nHeight);
+ return FALSE;
}
- /* Read composition payload header parameters */
- if ((SrcSize - offset) < 12)
- return -1012;
+ if (Stream_GetRemainingLength(s) < 2)
+ return FALSE;
- residualByteCount = *((UINT32*) &pSrcData[offset]);
- bandsByteCount = *((UINT32*) &pSrcData[offset + 4]);
- subcodecByteCount = *((UINT32*) &pSrcData[offset + 8]);
- offset += 12;
+ Stream_Read_UINT16(s, glyphIndex);
- if (residualByteCount > 0)
+ if (glyphIndex >= 4000)
{
- if (!clear_decompress_residual_data(clear,
- &pSrcData[offset], residualByteCount,
- SrcSize - offset, nWidth, nHeight,
- pDstData, DstFormat, nDstStep, nXDst, nYDst,
- nDstWidth, nDstHeight, palette))
- return -1111;
-
- offset += residualByteCount;
+ WLog_ERR(TAG, "Invalid glyphIndex %u", glyphIndex);
+ return FALSE;
}
- if (bandsByteCount > 0)
+ if (glyphFlags & CLEARCODEC_FLAG_GLYPH_HIT)
{
- if (!clear_decompress_bands_data(clear,
- &pSrcData[offset], bandsByteCount,
- SrcSize - offset, nWidth, nHeight,
- pDstData, DstFormat, nDstStep, nXDst, nYDst))
- return -1122;
+ UINT32 nSrcStep;
+ CLEAR_GLYPH_ENTRY* glyphEntry = &(clear->GlyphCache[glyphIndex]);
+ BYTE* glyphData = (BYTE*) glyphEntry->pixels;
+
+ if (!glyphData)
+ return FALSE;
+
+ if ((nWidth * nHeight) > (int) glyphEntry->count)
+ return FALSE;
- offset += bandsByteCount;
+ nSrcStep = nWidth * GetBytesPerPixel(clear->format);
+ convert_color(pDstData, nDstStep, DstFormat,
+ nXDst, nYDst, nWidth, nHeight,
+ glyphData, nSrcStep, clear->format,
+ nDstWidth, nDstHeight, palette);
+ return TRUE;
}
- if (subcodecByteCount > 0)
+ if (glyphFlags & CLEARCODEC_FLAG_GLYPH_INDEX)
{
- UINT16 xStart;
- UINT16 yStart;
- UINT16 width;
- UINT16 height;
- const BYTE* bitmapData;
- UINT32 bitmapDataByteCount;
- BYTE subcodecId;
- const BYTE* subcodecs;
- UINT32 suboffset;
+ BYTE* glyphData;
+ UINT32 nSrcStep;
+ CLEAR_GLYPH_ENTRY* glyphEntry = &(clear->GlyphCache[glyphIndex]);
+ glyphEntry->count = nWidth * nHeight;
- if ((SrcSize - offset) < subcodecByteCount)
- return -1039;
+ if (glyphEntry->count > glyphEntry->size)
+ {
+ UINT32* tmp;
+ glyphEntry->size = glyphEntry->count;
+ tmp = (UINT32*) realloc(glyphEntry->pixels, glyphEntry->size * 4);
- suboffset = 0;
- subcodecs = &pSrcData[offset];
+ if (!tmp)
+ return FALSE;
- while (suboffset < subcodecByteCount)
- {
- UINT32 nXDstRel;
- UINT32 nYDstRel;
+ glyphEntry->pixels = tmp;
+ }
- if ((subcodecByteCount - suboffset) < 13)
- return -1040;
+ if (!glyphEntry->pixels)
+ return FALSE;
- xStart = *((UINT16*) &subcodecs[suboffset]);
- yStart = *((UINT16*) &subcodecs[suboffset + 2]);
- width = *((UINT16*) &subcodecs[suboffset + 4]);
- height = *((UINT16*) &subcodecs[suboffset + 6]);
- bitmapDataByteCount = *((UINT32*) &subcodecs[suboffset + 8]);
- subcodecId = subcodecs[suboffset + 12];
- suboffset += 13;
+ glyphData = (BYTE*) glyphEntry->pixels;
+ nSrcStep = nWidth * GetBytesPerPixel(clear->format);
+ convert_color(pDstData, nDstStep, DstFormat,
+ nXDst, nYDst, nWidth, nHeight,
+ glyphData, nSrcStep, clear->format,
+ nDstWidth, nDstHeight, palette);
+ }
- if ((subcodecByteCount - suboffset) < bitmapDataByteCount)
- return -1041;
+ return TRUE;
+}
- nXDstRel = nXDst + xStart;
- nYDstRel = nYDst + yStart;
+INT32 clear_decompress(CLEAR_CONTEXT* clear, const BYTE* pSrcData,
+ UINT32 SrcSize, UINT32 nWidth, UINT32 nHeight,
+ BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
+ UINT32 nXDst, UINT32 nYDst, UINT32 nDstWidth,
+ UINT32 nDstHeight, const gdiPalette* palette)
+{
+ INT32 rc = -1;
+ BYTE seqNumber;
+ BYTE glyphFlags;
+ UINT32 residualByteCount;
+ UINT32 bandsByteCount;
+ UINT32 subcodecByteCount;
+ wStream* s;
- if (width > nWidth)
- return -1042;
+ if (!pDstData)
+ return -1002;
- if (height > nHeight)
- return -1043;
+ if ((nDstWidth == 0) || (nDstHeight == 0))
+ return -1022;
- if (((UINT32)(width * height * GetBytesPerPixel(clear->format))) >
- clear->TempSize)
- {
- clear->TempSize = (width * height * GetBytesPerPixel(clear->format));
- clear->TempBuffer = (BYTE*) realloc(clear->TempBuffer, clear->TempSize);
+ if ((nWidth > 0xFFFF) || (nHeight > 0xFFFF))
+ return -1004;
- if (!clear->TempBuffer)
- return -1044;
- }
+ s = Stream_New((BYTE*)pSrcData, SrcSize);
- bitmapData = &subcodecs[suboffset];
+ if (!s)
+ return -2005;
- if (subcodecId == 0) /* Uncompressed */
- {
- UINT32 nSrcStep = width * GetBytesPerPixel(PIXEL_FORMAT_BGR24);;
- UINT32 nSrcSize = nSrcStep * height;
+ Stream_SetLength(s, SrcSize);
- if (bitmapDataByteCount != nSrcSize)
- return -1045;
+ if (Stream_GetRemainingLength(s) < 2)
+ goto fail;
- convert_color(pDstData, nDstStep, DstFormat,
- nXDstRel, nYDstRel, width, height,
- bitmapData, nSrcStep,
- PIXEL_FORMAT_BGR24,
- nDstWidth, nDstHeight, palette);
- }
- else if (subcodecId == 1) /* NSCodec */
- {
- if (!clear_decompress_nscodec(clear->nsc, width, height,
- bitmapData, bitmapDataByteCount,
- pDstData, DstFormat, nDstStep,
- nXDstRel, nYDstRel))
- return -1046;
- }
- else if (subcodecId == 2) /* CLEARCODEC_SUBCODEC_RLEX */
- {
- if (!clear_decompress_subcode_rlex(bitmapData,
- bitmapDataByteCount,
- width, height,
- pDstData, DstFormat, nDstStep,
- nXDstRel, nYDstRel,
- nDstWidth, nDstHeight))
- return -1047;
- }
- else
- {
- return -1056;
- }
+ Stream_Read_UINT8(s, glyphFlags);
+ Stream_Read_UINT8(s, seqNumber);
- suboffset += bitmapDataByteCount;
- }
+ if (!clear->seqNumber && seqNumber)
+ clear->seqNumber = seqNumber;
- offset += subcodecByteCount;
+ if (seqNumber != clear->seqNumber)
+ {
+ WLog_ERR(TAG, "Sequence number unexpected %u - %u",
+ seqNumber, clear->seqNumber);
+ goto fail;
}
- if (glyphFlags & CLEARCODEC_FLAG_GLYPH_INDEX)
+ clear->seqNumber = (seqNumber + 1) % 256;
+
+ if (glyphFlags & CLEARCODEC_FLAG_CACHE_RESET)
{
- UINT32 nSrcStep;
- glyphEntry = &(clear->GlyphCache[glyphIndex]);
- glyphEntry->count = nWidth * nHeight;
+ clear->VBarStorageCursor = 0;
+ clear->ShortVBarStorageCursor = 0;
+ }
- if (glyphEntry->count > glyphEntry->size)
- {
- UINT32* tmp;
- glyphEntry->size = glyphEntry->count;
- tmp = (UINT32*) realloc(glyphEntry->pixels, glyphEntry->size * 4);
+ if (!clear_decompress_glyph_data(clear, s, glyphFlags, nWidth,
+ nHeight, pDstData, DstFormat,
+ nDstStep, nXDst, nYDst,
+ nDstWidth, nDstHeight, palette))
+ goto fail;
- if (!tmp)
- return -1;
+ /* Read composition payload header parameters */
+ if (Stream_GetRemainingLength(s) < 12)
+ goto fail;
- glyphEntry->pixels = tmp;
- }
+ Stream_Read_UINT32(s, residualByteCount);
+ Stream_Read_UINT32(s, bandsByteCount);
+ Stream_Read_UINT32(s, subcodecByteCount);
- if (!glyphEntry->pixels)
- return -1057;
+ if (residualByteCount > 0)
+ {
+ if (!clear_decompress_residual_data(clear, s, residualByteCount, nWidth,
+ nHeight, pDstData, DstFormat, nDstStep, nXDst, nYDst,
+ nDstWidth, nDstHeight, palette))
+ goto fail;
+ }
- glyphData = (BYTE*) glyphEntry->pixels;
- nSrcStep = nWidth * GetBytesPerPixel(clear->format);
- convert_color(pDstData, nDstStep, DstFormat,
- nXDst, nYDst, nWidth, nHeight,
- glyphData, nSrcStep, clear->format,
- nDstWidth, nDstHeight, palette);
+ if (bandsByteCount > 0)
+ {
+ if (!clear_decompress_bands_data(clear, s, bandsByteCount, nWidth, nHeight,
+ pDstData, DstFormat, nDstStep, nXDst, nYDst))
+ goto fail;
}
- if (offset != SrcSize)
- return -1058;
+ if (subcodecByteCount > 0)
+ {
+ if (!clear_decompress_subcodecs_data(clear, s, subcodecByteCount, nWidth,
+ nHeight, pDstData, DstFormat,
+ nDstStep, nXDst, nYDst,
+ nDstWidth, nDstHeight, palette))
+ goto fail;
+ }
- return 1;
+ rc = 0;
+fail:
+ Stream_Free(s, FALSE);
+ return rc;
}
int clear_compress(CLEAR_CONTEXT* clear, BYTE* pSrcData, UINT32 SrcSize,
- BYTE** ppDstData, UINT32* pDstSize)
+ BYTE** ppDstData, UINT32* pDstSize)
{
return 1;
}
-
BOOL clear_context_reset(CLEAR_CONTEXT* clear)
{
if (!clear)
clear->ShortVBarStorageCursor = 0;
return TRUE;
}
-
CLEAR_CONTEXT* clear_context_new(BOOL Compressor)
{
CLEAR_CONTEXT* clear;
nsc_context_set_pixel_format(clear->nsc, PIXEL_FORMAT_RGB24);
clear->TempSize = 512 * 512 * 4;
clear->TempBuffer = (BYTE*) malloc(clear->TempSize);
-
clear_context_reset(clear);
return clear;
-
error_nsc:
free(clear);
return NULL;
}
-
void clear_context_free(CLEAR_CONTEXT* clear)
{
int i;
free(clear);
}
-
while (left > 0)
{
s = rdp_send_stream_init(rdp);
+
if (!s)
return FALSE;
Stream_Write_UINT32(s, size);
Stream_Write_UINT32(s, flags);
+
if (!Stream_EnsureCapacity(s, chunkSize))
{
Stream_Release(s);
return FALSE;
}
+
Stream_Write(s, data, chunkSize);
if (!rdp_send(rdp, s, channelId))
Stream_Read_UINT32(s, length);
Stream_Read_UINT32(s, flags);
chunkLength = Stream_GetRemainingLength(s);
-
IFCALL(instance->ReceiveChannelData, instance,
- channelId, Stream_Pointer(s), chunkLength, flags, length);
-
+ channelId, Stream_Pointer(s), chunkLength, flags, length);
return TRUE;
}
-BOOL freerdp_channel_peer_process(freerdp_peer* client, wStream* s, UINT16 channelId)
+BOOL freerdp_channel_peer_process(freerdp_peer* client, wStream* s,
+ UINT16 channelId)
{
UINT32 length;
UINT32 flags;
if (!found)
return FALSE;
- client->VirtualChannelRead(client, hChannel, Stream_Pointer(s), Stream_GetRemainingLength(s));
+ client->VirtualChannelRead(client, hChannel, Stream_Pointer(s),
+ Stream_GetRemainingLength(s));
}
else if (client->ReceiveChannelData)
{
- client->ReceiveChannelData(client, channelId, Stream_Pointer(s), chunkLength, flags, length);
+ client->ReceiveChannelData(client, channelId, Stream_Pointer(s), chunkLength,
+ flags, length);
}
return TRUE;
}
-static WtsApiFunctionTable FreeRDP_WtsApiFunctionTable =
+static const WtsApiFunctionTable FreeRDP_WtsApiFunctionTable =
{
0, /* dwVersion */
0, /* dwFlags */
/* For locking the global resources */
static CRITICAL_SECTION g_channels_lock;
-CHANNEL_OPEN_DATA* freerdp_channels_find_channel_open_data_by_name(rdpChannels* channels, const char* name)
+CHANNEL_OPEN_DATA* freerdp_channels_find_channel_open_data_by_name(
+ rdpChannels* channels, const char* name)
{
int index;
CHANNEL_OPEN_DATA* pChannelOpenData;
}
/* returns rdpChannel for the channel name passed in */
-rdpMcsChannel* freerdp_channels_find_channel_by_name(rdpRdp* rdp, const char* name)
+rdpMcsChannel* freerdp_channels_find_channel_by_name(rdpRdp* rdp,
+ const char* name)
{
UINT32 index;
rdpMcsChannel* channel;
rdpChannels* freerdp_channels_new(void)
{
rdpChannels* channels;
-
channels = (rdpChannels*) calloc(1, sizeof(rdpChannels));
+
if (!channels)
return NULL;
channels->queue = MessageQueue_New(NULL);
+
if (!channels->queue)
goto error_queue;
if (!g_OpenHandles)
{
g_OpenHandles = HashTable_New(TRUE);
+
if (!g_OpenHandles)
goto error_open_handles;
}
return channels;
-
error_open_handles:
MessageQueue_Free(channels->queue);
error_queue:
pChannelOpenData->pInterface = NULL;
}
- HashTable_Remove(g_OpenHandles, (void*) (UINT_PTR)pChannelOpenData->OpenHandle);
-
+ HashTable_Remove(g_OpenHandles, (void*)(UINT_PTR)pChannelOpenData->OpenHandle);
}
if (g_OpenHandles)
*
* @return 0 on success, otherwise a Win32 error code
*/
-UINT freerdp_drdynvc_on_channel_connected(DrdynvcClientContext* context, const char* name, void* pInterface)
+UINT freerdp_drdynvc_on_channel_connected(DrdynvcClientContext* context,
+ const char* name, void* pInterface)
{
UINT status = CHANNEL_RC_OK;
ChannelConnectedEventArgs e;
rdpChannels* channels = (rdpChannels*) context->custom;
freerdp* instance = channels->instance;
-
EventArgsInit(&e, "freerdp");
e.name = name;
e.pInterface = pInterface;
PubSub_OnChannelConnected(instance->context->pubSub, instance->context, &e);
-
return status;
}
*
* @return 0 on success, otherwise a Win32 error code
*/
-UINT freerdp_drdynvc_on_channel_disconnected(DrdynvcClientContext* context, const char* name, void* pInterface)
+UINT freerdp_drdynvc_on_channel_disconnected(DrdynvcClientContext* context,
+ const char* name, void* pInterface)
{
UINT status = CHANNEL_RC_OK;
ChannelDisconnectedEventArgs e;
rdpChannels* channels = (rdpChannels*) context->custom;
freerdp* instance = channels->instance;
-
EventArgsInit(&e, "freerdp");
e.name = name;
e.pInterface = pInterface;
PubSub_OnChannelDisconnected(instance->context->pubSub, instance->context, &e);
-
return status;
}
UINT error = CHANNEL_RC_OK;
int index;
CHANNEL_CLIENT_DATA* pChannelClientData;
-
channels->instance = instance;
for (index = 0; index < channels->clientDataCount; index++)
if (pChannelClientData->pChannelInitEventProc)
pChannelClientData->pChannelInitEventProc(
- pChannelClientData->pInitHandle,
- CHANNEL_EVENT_INITIALIZED, 0, 0);
+ pChannelClientData->pInitHandle,
+ CHANNEL_EVENT_INITIALIZED, 0, 0);
+
if (CHANNEL_RC_OK != getChannelError(instance->context))
break;
}
char* hostname;
int hostnameLength;
CHANNEL_CLIENT_DATA* pChannelClientData;
-
channels->connected = 1;
hostname = instance->settings->ServerHostname;
hostnameLength = (int) strlen(hostname);
{
ChannelConnectedEventArgs e;
CHANNEL_OPEN_DATA* pChannelOpenData;
-
pChannelOpenData = &channels->openDataList[index];
-
pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
- CHANNEL_EVENT_CONNECTED, hostname, hostnameLength);
+ CHANNEL_EVENT_CONNECTED, hostname, hostnameLength);
+
if (getChannelError(instance->context) != CHANNEL_RC_OK)
goto fail;
name = (char*) malloc(9);
+
if (!name)
{
error = CHANNEL_RC_NO_MEMORY;
goto fail;
}
+
CopyMemory(name, pChannelOpenData->name, 8);
name[8] = '\0';
-
EventArgsInit(&e, "freerdp");
e.name = name;
e.pInterface = pChannelOpenData->pInterface;
PubSub_OnChannelConnected(instance->context->pubSub, instance->context, &e);
-
free(name);
name = NULL;
}
}
- channels->drdynvc = (DrdynvcClientContext*) freerdp_channels_get_static_channel_interface(channels, "drdynvc");
+ channels->drdynvc = (DrdynvcClientContext*)
+ freerdp_channels_get_static_channel_interface(channels, "drdynvc");
if (channels->drdynvc)
{
channels->drdynvc->custom = (void*) channels;
channels->drdynvc->OnChannelConnected = freerdp_drdynvc_on_channel_connected;
- channels->drdynvc->OnChannelDisconnected = freerdp_drdynvc_on_channel_disconnected;
+ channels->drdynvc->OnChannelDisconnected =
+ freerdp_drdynvc_on_channel_disconnected;
}
fail:
- free (name);
+ free(name);
return error;
}
-int freerdp_channels_data(freerdp* instance, UINT16 channelId, BYTE* data, int dataSize, int flags, int totalSize)
+int freerdp_channels_data(freerdp* instance, UINT16 channelId, BYTE* data,
+ int dataSize, int flags, int totalSize)
{
UINT32 index;
rdpMcs* mcs;
rdpChannels* channels;
rdpMcsChannel* channel = NULL;
CHANNEL_OPEN_DATA* pChannelOpenData;
-
mcs = instance->context->rdp->mcs;
channels = instance->context->channels;
return 1;
}
- pChannelOpenData = freerdp_channels_find_channel_open_data_by_name(channels, channel->Name);
+ pChannelOpenData = freerdp_channels_find_channel_open_data_by_name(channels,
+ channel->Name);
if (!pChannelOpenData)
{
if (pChannelOpenData->pChannelOpenEventProc)
{
pChannelOpenData->pChannelOpenEventProc(pChannelOpenData->OpenHandle,
- CHANNEL_EVENT_DATA_RECEIVED, data, dataSize, totalSize, flags);
+ CHANNEL_EVENT_DATA_RECEIVED, data, dataSize, totalSize, flags);
}
return 0;
/**
* called only from main thread
*/
-static int freerdp_channels_process_sync(rdpChannels* channels, freerdp* instance)
+static int freerdp_channels_process_sync(rdpChannels* channels,
+ freerdp* instance)
{
int status = TRUE;
wMessage message;
break;
pChannelOpenData = item->pChannelOpenData;
-
- channel = freerdp_channels_find_channel_by_name(instance->context->rdp, pChannelOpenData->name);
+ channel = freerdp_channels_find_channel_by_name(instance->context->rdp,
+ pChannelOpenData->name);
if (channel)
- instance->SendChannelData(instance, channel->ChannelId, item->Data, item->DataLength);
+ instance->SendChannelData(instance, channel->ChannelId, item->Data,
+ item->DataLength);
if (pChannelOpenData->pChannelOpenEventProc)
{
pChannelOpenData->pChannelOpenEventProc(pChannelOpenData->OpenHandle,
- CHANNEL_EVENT_WRITE_COMPLETE, item->UserData, item->DataLength, item->DataLength, 0);
+ CHANNEL_EVENT_WRITE_COMPLETE, item->UserData, item->DataLength,
+ item->DataLength, 0);
}
free(item);
/**
* called only from main thread
*/
-BOOL freerdp_channels_get_fds(rdpChannels* channels, freerdp* instance, void** read_fds,
- int* read_count, void** write_fds, int* write_count)
+BOOL freerdp_channels_get_fds(rdpChannels* channels, freerdp* instance,
+ void** read_fds,
+ int* read_count, void** write_fds, int* write_count)
{
void* pfd;
-
pfd = GetEventWaitObject(MessageQueue_Event(channels->queue));
if (pfd)
return TRUE;
}
-void* freerdp_channels_get_static_channel_interface(rdpChannels* channels, const char* name)
+void* freerdp_channels_get_static_channel_interface(rdpChannels* channels,
+ const char* name)
{
void* pInterface = NULL;
CHANNEL_OPEN_DATA* pChannelOpenData;
-
- pChannelOpenData = freerdp_channels_find_channel_open_data_by_name(channels, name);
+ pChannelOpenData = freerdp_channels_find_channel_open_data_by_name(channels,
+ name);
if (pChannelOpenData)
pInterface = pChannelOpenData->pInterface;
{
HANDLE event = NULL;
rdpChannels* channels;
-
channels = instance->context->channels;
event = MessageQueue_Event(channels->queue);
-
return event;
}
int freerdp_channels_process_pending_messages(freerdp* instance)
{
rdpChannels* channels;
-
channels = instance->context->channels;
- if (WaitForSingleObject(MessageQueue_Event(channels->queue), 0) == WAIT_OBJECT_0)
+ if (WaitForSingleObject(MessageQueue_Event(channels->queue),
+ 0) == WAIT_OBJECT_0)
{
- return freerdp_channels_process_sync(channels, instance);
+ return freerdp_channels_process_sync(channels, instance);
}
return TRUE;
*/
BOOL freerdp_channels_check_fds(rdpChannels* channels, freerdp* instance)
{
- if (WaitForSingleObject(MessageQueue_Event(channels->queue), 0) == WAIT_OBJECT_0)
+ if (WaitForSingleObject(MessageQueue_Event(channels->queue),
+ 0) == WAIT_OBJECT_0)
{
freerdp_channels_process_sync(channels, instance);
}
for (index = 0; index < channels->clientDataCount; index++)
{
ChannelDisconnectedEventArgs e;
-
pChannelClientData = &channels->clientDataList[index];
if (pChannelClientData->pChannelInitEventProc)
pChannelClientData->pChannelInitEventProc(
- pChannelClientData->pInitHandle,
- CHANNEL_EVENT_DISCONNECTED, 0, 0);
+ pChannelClientData->pInitHandle,
+ CHANNEL_EVENT_DISCONNECTED, 0, 0);
+
if (getChannelError(instance->context) != CHANNEL_RC_OK)
goto fail;
pChannelOpenData = &channels->openDataList[index];
-
name = (char*) malloc(9);
+
if (!name)
return -1;
+
CopyMemory(name, pChannelOpenData->name, 8);
name[8] = '\0';
-
EventArgsInit(&e, "freerdp");
e.name = name;
e.pInterface = pChannelOpenData->pInterface;
PubSub_OnChannelDisconnected(instance->context->pubSub, instance->context, &e);
-
free(name);
}
{
int index;
CHANNEL_CLIENT_DATA* pChannelClientData;
-
freerdp_channels_check_fds(channels, instance);
/* tell all libraries we are shutting down */
pChannelClientData = &channels->clientDataList[index];
if (pChannelClientData->pChannelInitEventProc)
- pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle, CHANNEL_EVENT_TERMINATED, 0, 0);
+ pChannelClientData->pChannelInitEventProc(pChannelClientData->pInitHandle,
+ CHANNEL_EVENT_TERMINATED, 0, 0);
}
MessageQueue_PostQuit(channels->queue, 0);
}
-UINT VCAPITYPE FreeRDP_VirtualChannelInit(LPVOID* ppInitHandle, PCHANNEL_DEF pChannel,
- INT channelCount, ULONG versionRequested, PCHANNEL_INIT_EVENT_FN pChannelInitEventProc)
+UINT VCAPITYPE FreeRDP_VirtualChannelInit(LPVOID* ppInitHandle,
+ PCHANNEL_DEF pChannel,
+ INT channelCount, ULONG versionRequested,
+ PCHANNEL_INIT_EVENT_FN pChannelInitEventProc)
{
- int index;
+ INT index;
void* pInterface;
DWORD OpenHandle;
CHANNEL_DEF* channel;
if (!ppInitHandle)
return CHANNEL_RC_BAD_INIT_HANDLE;
+ if (!pChannel || (channelCount <= 0) || !pChannelInitEventProc)
+ return CHANNEL_RC_INITIALIZATION_ERROR;
+
channels = g_ChannelInitData.channels;
pInterface = g_pInterface;
-
pChannelInitData = &(channels->initDataList[channels->initDataCount]);
*ppInitHandle = pChannelInitData;
channels->initDataCount++;
-
pChannelInitData->channels = channels;
pChannelInitData->pInterface = pInterface;
if (versionRequested != VIRTUAL_CHANNEL_VERSION_WIN2000)
{
-
}
for (index = 0; index < channelCount; index++)
{
pChannelDef = &pChannel[index];
- if (freerdp_channels_find_channel_open_data_by_name(channels, pChannelDef->name) != 0)
+ if (freerdp_channels_find_channel_open_data_by_name(channels,
+ pChannelDef->name) != 0)
{
return CHANNEL_RC_BAD_CHANNEL;
}
pChannelClientData->pChannelInitEventProc = pChannelInitEventProc;
pChannelClientData->pInitHandle = *ppInitHandle;
channels->clientDataCount++;
-
settings = channels->settings;
for (index = 0; index < channelCount; index++)
{
pChannelDef = &pChannel[index];
pChannelOpenData = &channels->openDataList[channels->openDataCount];
-
OpenHandle = g_open_handle_sequence++;
-
pChannelOpenData->OpenHandle = OpenHandle;
pChannelOpenData->channels = channels;
-
- HashTable_Add(g_OpenHandles, (void*) (UINT_PTR) OpenHandle, (void*) pChannelOpenData);
-
+ HashTable_Add(g_OpenHandles, (void*)(UINT_PTR) OpenHandle,
+ (void*) pChannelOpenData);
pChannelOpenData->flags = 1; /* init */
strncpy(pChannelOpenData->name, pChannelDef->name, CHANNEL_NAME_LEN);
pChannelOpenData->options = pChannelDef->options;
return CHANNEL_RC_OK;
}
-UINT VCAPITYPE FreeRDP_VirtualChannelOpen(LPVOID pInitHandle, LPDWORD pOpenHandle,
- PCHAR pChannelName, PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc)
+UINT VCAPITYPE FreeRDP_VirtualChannelOpen(LPVOID pInitHandle,
+ LPDWORD pOpenHandle,
+ PCHAR pChannelName, PCHANNEL_OPEN_EVENT_FN pChannelOpenEventProc)
{
void* pInterface;
rdpChannels* channels;
CHANNEL_INIT_DATA* pChannelInitData;
CHANNEL_OPEN_DATA* pChannelOpenData;
-
pChannelInitData = (CHANNEL_INIT_DATA*) pInitHandle;
channels = pChannelInitData->channels;
pInterface = pChannelInitData->pInterface;
if (!channels->connected)
return CHANNEL_RC_NOT_CONNECTED;
- pChannelOpenData = freerdp_channels_find_channel_open_data_by_name(channels, pChannelName);
+ pChannelOpenData = freerdp_channels_find_channel_open_data_by_name(channels,
+ pChannelName);
if (!pChannelOpenData)
return CHANNEL_RC_UNKNOWN_CHANNEL_NAME;
pChannelOpenData->pInterface = pInterface;
pChannelOpenData->pChannelOpenEventProc = pChannelOpenEventProc;
*pOpenHandle = pChannelOpenData->OpenHandle;
-
return CHANNEL_RC_OK;
}
UINT VCAPITYPE FreeRDP_VirtualChannelClose(DWORD openHandle)
{
CHANNEL_OPEN_DATA* pChannelOpenData;
-
- pChannelOpenData = HashTable_GetItemValue(g_OpenHandles, (void*) (UINT_PTR) openHandle);
+ pChannelOpenData = HashTable_GetItemValue(g_OpenHandles,
+ (void*)(UINT_PTR) openHandle);
if (!pChannelOpenData)
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
return CHANNEL_RC_NOT_OPEN;
pChannelOpenData->flags = 0;
-
return CHANNEL_RC_OK;
}
-UINT VCAPITYPE FreeRDP_VirtualChannelWrite(DWORD openHandle, LPVOID pData, ULONG dataLength, LPVOID pUserData)
+UINT VCAPITYPE FreeRDP_VirtualChannelWrite(DWORD openHandle, LPVOID pData,
+ ULONG dataLength, LPVOID pUserData)
{
rdpChannels* channels;
CHANNEL_OPEN_DATA* pChannelOpenData;
CHANNEL_OPEN_EVENT* pChannelOpenEvent;
-
- pChannelOpenData = HashTable_GetItemValue(g_OpenHandles, (void*) (UINT_PTR) openHandle);
+ pChannelOpenData = HashTable_GetItemValue(g_OpenHandles,
+ (void*)(UINT_PTR) openHandle);
if (!pChannelOpenData)
return CHANNEL_RC_BAD_CHANNEL_HANDLE;
pChannelOpenEvent->UserData = pUserData;
pChannelOpenEvent->pChannelOpenData = pChannelOpenData;
- if (!MessageQueue_Post(channels->queue, (void*) channels, 0, (void*) pChannelOpenEvent, NULL))
+ if (!MessageQueue_Post(channels->queue, (void*) channels, 0,
+ (void*) pChannelOpenEvent, NULL))
{
free(pChannelOpenEvent);
return CHANNEL_RC_NO_MEMORY;
return CHANNEL_RC_OK;
}
-static BOOL freerdp_channels_is_loaded(rdpChannels* channels, PVIRTUALCHANNELENTRY entry)
+static BOOL freerdp_channels_is_loaded(rdpChannels* channels,
+ PVIRTUALCHANNELENTRY entry)
{
int i;
- for (i=0; i<channels->clientDataCount; i++)
+ for (i = 0; i < channels->clientDataCount; i++)
{
CHANNEL_CLIENT_DATA* pChannelClientData = &channels->clientDataList[i];
return FALSE;
}
-int freerdp_channels_client_load(rdpChannels* channels, rdpSettings* settings, PVIRTUALCHANNELENTRY entry, void* data)
+int freerdp_channels_client_load(rdpChannels* channels, rdpSettings* settings,
+ PVIRTUALCHANNELENTRY entry, void* data)
{
int status;
CHANNEL_ENTRY_POINTS_FREERDP EntryPoints;
pChannelClientData = &channels->clientDataList[channels->clientDataCount];
pChannelClientData->entry = entry;
-
ZeroMemory(&EntryPoints, sizeof(CHANNEL_ENTRY_POINTS_FREERDP));
-
EntryPoints.cbSize = sizeof(EntryPoints);
EntryPoints.protocolVersion = VIRTUAL_CHANNEL_VERSION_WIN2000;
EntryPoints.pVirtualChannelInit = FreeRDP_VirtualChannelInit;
EntryPoints.pVirtualChannelOpen = FreeRDP_VirtualChannelOpen;
EntryPoints.pVirtualChannelClose = FreeRDP_VirtualChannelClose;
EntryPoints.pVirtualChannelWrite = FreeRDP_VirtualChannelWrite;
-
EntryPoints.MagicNumber = FREERDP_CHANNEL_MAGIC_NUMBER;
EntryPoints.ppInterface = &g_pInterface;
EntryPoints.pExtendedData = data;
EntryPoints.context = ((freerdp*)settings->instance)->context;
-
/* enable VirtualChannelInit */
channels->can_call_init = TRUE;
channels->settings = settings;
-
EnterCriticalSection(&g_channels_lock);
-
g_pInterface = NULL;
g_ChannelInitData.channels = channels;
status = pChannelClientData->entry((PCHANNEL_ENTRY_POINTS) &EntryPoints);
-
LeaveCriticalSection(&g_channels_lock);
-
/* disable MyVirtualChannelInit */
channels->settings = NULL;
channels->can_call_init = FALSE;
* this is called when processing the command line parameters
* called only from main thread
*/
-int freerdp_channels_load_plugin(rdpChannels* channels, rdpSettings* settings, const char* name, void* data)
+int freerdp_channels_load_plugin(rdpChannels* channels, rdpSettings* settings,
+ const char* name, void* data)
{
void* entry;
-
- entry = (PVIRTUALCHANNELENTRY) freerdp_load_channel_addin_entry(name, NULL, NULL, FREERDP_ADDIN_CHANNEL_STATIC);
+ entry = (PVIRTUALCHANNELENTRY) freerdp_load_channel_addin_entry(name, NULL,
+ NULL, FREERDP_ADDIN_CHANNEL_STATIC);
if (!entry)
{
#define TAG FREERDP_TAG("core.codecs")
-BOOL freerdp_client_codecs_prepare(rdpCodecs* codecs, UINT32 flags, UINT32 width, UINT32 height)
+BOOL freerdp_client_codecs_prepare(rdpCodecs* codecs, UINT32 flags,
+ UINT32 width, UINT32 height)
{
if ((flags & FREERDP_CODEC_INTERLEAVED) && !codecs->interleaved)
{
WLog_ERR(TAG, "Failed to create interleaved codec context");
return FALSE;
}
-
- if (!bitmap_interleaved_context_reset(codecs->interleaved))
- {
- WLog_ERR(TAG, "Failed to reset interleaved codec context");
- bitmap_interleaved_context_free(codecs->interleaved);
- return FALSE;
- }
}
if ((flags & FREERDP_CODEC_PLANAR) && !codecs->planar)
WLog_ERR(TAG, "Failed to create planar bitmap codec context");
return FALSE;
}
-
- if (!freerdp_bitmap_planar_context_reset(codecs->planar, 64, 64))
- {
- WLog_ERR(TAG, "Failed to reset plannar bitmap codec context");
- freerdp_bitmap_planar_context_free(codecs->planar);
- return FALSE;
- }
}
if ((flags & FREERDP_CODEC_NSCODEC) && !codecs->nsc)
WLog_ERR(TAG, "Failed to create nsc codec context");
return FALSE;
}
-
- if (!nsc_context_reset(codecs->nsc, width, height))
- {
- WLog_ERR(TAG, "Failed to reset nsc codec context");
- nsc_context_free(codecs->nsc);
- return FALSE;
- }
}
if ((flags & FREERDP_CODEC_REMOTEFX) && !codecs->rfx)
WLog_ERR(TAG, "Failed to create rfx codec context");
return FALSE;
}
-
- if (!rfx_context_reset(codecs->rfx, width, height))
- {
- WLog_ERR(TAG, "Failed to reset rfx codec context");
- rfx_context_free(codecs->rfx);
- return FALSE;
- }
}
if ((flags & FREERDP_CODEC_CLEARCODEC) && !codecs->clear)
WLog_ERR(TAG, "Failed to create clear codec context");
return FALSE;
}
-
- if (!clear_context_reset(codecs->clear))
- {
- WLog_ERR(TAG, "Failed to reset clear codec context");
- clear_context_free(codecs->clear);
- return FALSE;
- }
}
if (flags & FREERDP_CODEC_ALPHACODEC)
{
-
}
if ((flags & FREERDP_CODEC_PROGRESSIVE) && !codecs->progressive)
WLog_ERR(TAG, "Failed to create progressive codec context");
return FALSE;
}
-
- if (!progressive_context_reset(codecs->progressive))
- {
- WLog_ERR(TAG, "Failed to reset progressive codec context");
- progressive_context_free(codecs->progressive);
- return FALSE;
- }
}
if ((flags & (FREERDP_CODEC_AVC420 | FREERDP_CODEC_AVC444)) && !codecs->h264)
WLog_ERR(TAG, "Failed to create h264 codec context");
return FALSE;
}
-
- if (!h264_context_reset(codecs->h264, width, height))
- {
- WLog_ERR(TAG, "Failed to reset h264 codec context");
- h264_context_free(codecs->h264);
- return FALSE;
- }
}
- return TRUE;
+ return freerdp_client_codecs_reset(codecs, flags, width, height);
}
-BOOL freerdp_client_codecs_reset(rdpCodecs* codecs, UINT32 flags, UINT32 width, UINT32 height)
+BOOL freerdp_client_codecs_reset(rdpCodecs* codecs, UINT32 flags, UINT32 width,
+ UINT32 height)
{
BOOL rc = TRUE;
if (flags & FREERDP_CODEC_ALPHACODEC)
{
-
}
if (flags & FREERDP_CODEC_PROGRESSIVE)
rdpCodecs* codecs_new(rdpContext* context)
{
rdpCodecs* codecs;
-
codecs = (rdpCodecs*) calloc(1, sizeof(rdpCodecs));
if (codecs)
{
if (bitsPerPixel < 32)
{
- if (!freerdp_client_codecs_prepare(codecs,
- FREERDP_CODEC_INTERLEAVED,
- gdi->width, gdi->height))
- return FALSE;
-
status = interleaved_decompress(codecs->interleaved,
pSrcData, SrcSize,
bitsPerPixel,
}
else
{
- if (!freerdp_client_codecs_prepare(codecs,
- FREERDP_CODEC_PLANAR,
- gdi->width, gdi->height))
- return FALSE;
-
status = planar_decompress(codecs->planar, pSrcData,
SrcSize, gdi->primary_buffer,
gdi->dstFormat,
goto fail;
}
- if (!freerdp_client_codecs_reset(context->codecs, FREERDP_CODEC_ALL, gdi->width,
- gdi->height))
+ if (!freerdp_client_codecs_prepare(context->codecs, FREERDP_CODEC_ALL,
+ gdi->width, gdi->height))
goto fail;
gdi_register_update_callbacks(instance->update);
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_ResetGraphics(RdpgfxClientContext* context,
- const RDPGFX_RESET_GRAPHICS_PDU* resetGraphics)
+ const RDPGFX_RESET_GRAPHICS_PDU* resetGraphics)
{
UINT32 index;
UINT16 count;
DesktopHeight = resetGraphics->height;
if ((DesktopWidth != settings->DesktopWidth)
- || (DesktopHeight != settings->DesktopHeight))
+ || (DesktopHeight != settings->DesktopHeight))
{
settings->DesktopWidth = DesktopWidth;
settings->DesktopHeight = DesktopHeight;
continue;
if (!freerdp_client_codecs_reset(surface->codecs, FREERDP_CODEC_ALL,
- surface->width, surface->height))
+ surface->width, surface->height))
{
free(pSurfaceIds);
return ERROR_INTERNAL_ERROR;
free(pSurfaceIds);
if (!freerdp_client_codecs_reset(gdi->context->codecs, FREERDP_CODEC_ALL,
- gdi->width, gdi->height))
+ gdi->width, gdi->height))
return ERROR_INTERNAL_ERROR;
gdi->graphicsReset = TRUE;
surfaceRect.right = surface->width;
surfaceRect.bottom = surface->height;
region16_intersect_rect(&(surface->invalidRegion),
- &(surface->invalidRegion), &surfaceRect);
+ &(surface->invalidRegion), &surfaceRect);
if (!region16_is_empty(&(surface->invalidRegion)))
{
height = extents->bottom - extents->top;
update->BeginPaint(gdi->context);
freerdp_image_copy(gdi->primary_buffer, gdi->dstFormat, gdi->stride,
- nXDst, nYDst, width, height,
- surface->data, surface->format,
- surface->scanline, nXSrc, nYSrc, NULL);
+ nXDst, nYDst, width, height,
+ surface->data, surface->format,
+ surface->scanline, nXSrc, nYSrc, NULL);
gdi_InvalidateRegion(gdi->primary->hdc, nXDst, nYDst, width, height);
update->EndPaint(gdi->context);
}
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_StartFrame(RdpgfxClientContext* context,
- const RDPGFX_START_FRAME_PDU* startFrame)
+ const RDPGFX_START_FRAME_PDU* startFrame)
{
rdpGdi* gdi = (rdpGdi*) context->custom;
gdi->inGfxFrame = TRUE;
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_EndFrame(RdpgfxClientContext* context,
- const RDPGFX_END_FRAME_PDU* endFrame)
+ const RDPGFX_END_FRAME_PDU* endFrame)
{
UINT status = CHANNEL_RC_NOT_INITIALIZED;
rdpGdi* gdi = (rdpGdi*) context->custom;
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceCommand_Uncompressed(rdpGdi* gdi,
- RdpgfxClientContext* context,
- const RDPGFX_SURFACE_COMMAND* cmd)
+ RdpgfxClientContext* context,
+ const RDPGFX_SURFACE_COMMAND* cmd)
{
UINT status = CHANNEL_RC_OK;
gdiGfxSurface* surface;
return ERROR_INTERNAL_ERROR;
if (!freerdp_image_copy(surface->data, surface->format, surface->scanline,
- cmd->left, cmd->top, cmd->width, cmd->height,
- cmd->data, cmd->format, 0, 0, 0, NULL))
+ cmd->left, cmd->top, cmd->width, cmd->height,
+ cmd->data, cmd->format, 0, 0, 0, NULL))
return ERROR_INTERNAL_ERROR;
invalidRect.left = cmd->left;
invalidRect.right = cmd->right;
invalidRect.bottom = cmd->bottom;
region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
- &invalidRect);
+ &invalidRect);
if (!gdi->inGfxFrame)
{
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceCommand_RemoteFX(rdpGdi* gdi,
- RdpgfxClientContext* context,
- const RDPGFX_SURFACE_COMMAND* cmd)
+ RdpgfxClientContext* context,
+ const RDPGFX_SURFACE_COMMAND* cmd)
{
UINT status = CHANNEL_RC_OK;
gdiGfxSurface* surface;
if (!surface)
return ERROR_INTERNAL_ERROR;
- if (!freerdp_client_codecs_prepare(surface->codecs,
- FREERDP_CODEC_REMOTEFX,
- surface->width, surface->height))
- return ERROR_INTERNAL_ERROR;
-
if (!rfx_process_message(surface->codecs->rfx, cmd->data, cmd->format,
- cmd->length,
- cmd->left, cmd->top,
- surface->data, surface->format, surface->scanline,
- surface->height, &surface->invalidRegion))
+ cmd->length,
+ cmd->left, cmd->top,
+ surface->data, surface->format, surface->scanline,
+ surface->height, &surface->invalidRegion))
{
WLog_ERR(TAG, "Failed to process RemoteFX message");
return ERROR_INTERNAL_ERROR;
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceCommand_ClearCodec(rdpGdi* gdi,
- RdpgfxClientContext* context,
- const RDPGFX_SURFACE_COMMAND* cmd)
+ RdpgfxClientContext* context,
+ const RDPGFX_SURFACE_COMMAND* cmd)
{
INT32 rc;
UINT status = CHANNEL_RC_OK;
if (!surface)
return ERROR_INTERNAL_ERROR;
- if (!freerdp_client_codecs_prepare(surface->codecs,
- FREERDP_CODEC_CLEARCODEC,
- surface->width, surface->height))
- return ERROR_INTERNAL_ERROR;
-
rc = clear_decompress(surface->codecs->clear, cmd->data, cmd->length,
- cmd->width, cmd->height,
- surface->data, surface->format,
- surface->scanline, cmd->left, cmd->top,
- surface->width, surface->height, &gdi->palette);
+ cmd->width, cmd->height,
+ surface->data, surface->format,
+ surface->scanline, cmd->left, cmd->top,
+ surface->width, surface->height, &gdi->palette);
if (rc < 0)
{
invalidRect.right = cmd->right;
invalidRect.bottom = cmd->bottom;
region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
- &invalidRect);
+ &invalidRect);
if (!gdi->inGfxFrame)
{
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceCommand_Planar(rdpGdi* gdi, RdpgfxClientContext* context,
- const RDPGFX_SURFACE_COMMAND* cmd)
+ const RDPGFX_SURFACE_COMMAND* cmd)
{
INT32 rc;
UINT status = CHANNEL_RC_OK;
if (!surface)
return ERROR_INTERNAL_ERROR;
- if (!freerdp_client_codecs_prepare(surface->codecs,
- FREERDP_CODEC_PLANAR,
- surface->width, surface->height))
- return ERROR_INTERNAL_ERROR;
-
DstData = surface->data;
rc = planar_decompress(surface->codecs->planar, cmd->data, cmd->length,
- DstData, surface->format,
- surface->scanline, cmd->left, cmd->top,
- cmd->width, cmd->height, FALSE);
+ DstData, surface->format,
+ surface->scanline, cmd->left, cmd->top,
+ cmd->width, cmd->height, FALSE);
if (rc < 0)
return ERROR_INTERNAL_ERROR;
invalidRect.right = cmd->right;
invalidRect.bottom = cmd->bottom;
region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
- &invalidRect);
+ &invalidRect);
if (!gdi->inGfxFrame)
{
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceCommand_AVC420(rdpGdi* gdi,
- RdpgfxClientContext* context,
- const RDPGFX_SURFACE_COMMAND* cmd)
+ RdpgfxClientContext* context,
+ const RDPGFX_SURFACE_COMMAND* cmd)
{
INT32 rc;
UINT status = CHANNEL_RC_OK;
if (!surface)
return ERROR_INTERNAL_ERROR;
- if (!freerdp_client_codecs_prepare(surface->codecs,
- FREERDP_CODEC_AVC420,
- surface->width, surface->height))
- return ERROR_INTERNAL_ERROR;
-
bs = (RDPGFX_AVC420_BITMAP_STREAM*) cmd->extra;
if (!bs)
meta = &(bs->meta);
rc = avc420_decompress(surface->codecs->h264, bs->data, bs->length,
- surface->data, surface->format,
- surface->scanline, surface->width,
- surface->height, meta->regionRects,
- meta->numRegionRects);
+ surface->data, surface->format,
+ surface->scanline, surface->width,
+ surface->height, meta->regionRects,
+ meta->numRegionRects);
if (rc < 0)
{
for (i = 0; i < meta->numRegionRects; i++)
{
region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
- (RECTANGLE_16*) & (meta->regionRects[i]));
+ (RECTANGLE_16*) & (meta->regionRects[i]));
}
if (!gdi->inGfxFrame)
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceCommand_AVC444(rdpGdi* gdi, RdpgfxClientContext* context,
- const RDPGFX_SURFACE_COMMAND* cmd)
+ const RDPGFX_SURFACE_COMMAND* cmd)
{
INT32 rc;
UINT status = CHANNEL_RC_OK;
if (!surface)
return ERROR_INTERNAL_ERROR;
- if (!freerdp_client_codecs_prepare(surface->codecs,
- FREERDP_CODEC_AVC444,
- surface->width, surface->height))
- return ERROR_INTERNAL_ERROR;
-
bs = (RDPGFX_AVC444_BITMAP_STREAM*) cmd->extra;
if (!bs)
meta1 = &avc1->meta;
meta2 = &avc2->meta;
rc = avc444_decompress(surface->codecs->h264, bs->LC,
- meta1->regionRects, meta1->numRegionRects,
- avc1->data, avc1->length,
- meta2->regionRects, meta2->numRegionRects,
- avc2->data, avc2->length,
- surface->data, surface->format,
- surface->scanline, surface->width,
- surface->height);
+ meta1->regionRects, meta1->numRegionRects,
+ avc1->data, avc1->length,
+ meta2->regionRects, meta2->numRegionRects,
+ avc2->data, avc2->length,
+ surface->data, surface->format,
+ surface->scanline, surface->width,
+ surface->height);
if (rc < 0)
{
for (i = 0; i < meta1->numRegionRects; i++)
{
region16_union_rect(&(surface->invalidRegion),
- &(surface->invalidRegion),
- &(meta1->regionRects[i]));
+ &(surface->invalidRegion),
+ &(meta1->regionRects[i]));
}
for (i = 0; i < meta2->numRegionRects; i++)
{
region16_union_rect(&(surface->invalidRegion),
- &(surface->invalidRegion),
- &(meta2->regionRects[i]));
+ &(surface->invalidRegion),
+ &(meta2->regionRects[i]));
}
if (!gdi->inGfxFrame)
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceCommand_Alpha(rdpGdi* gdi, RdpgfxClientContext* context,
- const RDPGFX_SURFACE_COMMAND* cmd)
+ const RDPGFX_SURFACE_COMMAND* cmd)
{
UINT status = CHANNEL_RC_OK;
gdiGfxSurface* surface;
if (!surface)
return ERROR_INTERNAL_ERROR;
- if (!freerdp_client_codecs_prepare(surface->codecs,
- FREERDP_CODEC_ALPHACODEC,
- surface->width, surface->height))
- return ERROR_INTERNAL_ERROR;
-
WLog_DBG(TAG, "TODO gdi_SurfaceCommand_Alpha: status: %d", status);
/* fill with green for now to distinguish from the rest */
if (!freerdp_image_fill(surface->data, surface->format, surface->scanline,
- cmd->left, cmd->top, cmd->width, cmd->height, 0x00FF00))
+ cmd->left, cmd->top, cmd->width, cmd->height, 0x00FF00))
return ERROR_INTERNAL_ERROR;
invalidRect.left = cmd->left;
invalidRect.right = cmd->right;
invalidRect.bottom = cmd->bottom;
region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
- &invalidRect);
+ &invalidRect);
if (!gdi->inGfxFrame)
{
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceCommand_Progressive(rdpGdi* gdi,
- RdpgfxClientContext* context,
- const RDPGFX_SURFACE_COMMAND* cmd)
+ RdpgfxClientContext* context,
+ const RDPGFX_SURFACE_COMMAND* cmd)
{
INT32 rc;
UINT status = CHANNEL_RC_OK;
if (!surface)
return ERROR_INTERNAL_ERROR;
- if (!freerdp_client_codecs_prepare(surface->codecs,
- FREERDP_CODEC_PROGRESSIVE,
- surface->width, surface->height))
- return ERROR_INTERNAL_ERROR;
-
rc = progressive_create_surface_context(surface->codecs->progressive,
- cmd->surfaceId,
- surface->width, surface->height);
+ cmd->surfaceId,
+ surface->width, surface->height);
if (rc < 0)
{
}
rc = progressive_decompress(surface->codecs->progressive, cmd->data,
- cmd->length, surface->data, surface->format,
- surface->scanline, cmd->left, cmd->top,
- cmd->width, cmd->height, cmd->surfaceId);
+ cmd->length, surface->data, surface->format,
+ surface->scanline, cmd->left, cmd->top,
+ cmd->width, cmd->height, cmd->surfaceId);
if (rc < 0)
{
invalidRect.right = cmd->right;
invalidRect.bottom = cmd->bottom;
region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
- &invalidRect);
+ &invalidRect);
if (!gdi->inGfxFrame)
{
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceCommand(RdpgfxClientContext* context,
- const RDPGFX_SURFACE_COMMAND* cmd)
+ const RDPGFX_SURFACE_COMMAND* cmd)
{
UINT status = CHANNEL_RC_OK;
rdpGdi* gdi = (rdpGdi*) context->custom;
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_DeleteEncodingContext(RdpgfxClientContext* context,
- const RDPGFX_DELETE_ENCODING_CONTEXT_PDU* deleteEncodingContext)
+ const RDPGFX_DELETE_ENCODING_CONTEXT_PDU* deleteEncodingContext)
{
return CHANNEL_RC_OK;
}
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_CreateSurface(RdpgfxClientContext* context,
- const RDPGFX_CREATE_SURFACE_PDU* createSurface)
+ const RDPGFX_CREATE_SURFACE_PDU* createSurface)
{
gdiGfxSurface* surface;
rdpGdi* gdi = (rdpGdi*) context->custom;
return CHANNEL_RC_NO_MEMORY;
}
- if (!freerdp_client_codecs_reset(surface->codecs, FREERDP_CODEC_ALL,
- createSurface->width, createSurface->height))
+ if (!freerdp_client_codecs_prepare(surface->codecs, FREERDP_CODEC_ALL,
+ createSurface->width, createSurface->height))
{
free(surface);
return ERROR_INTERNAL_ERROR;
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_DeleteSurface(RdpgfxClientContext* context,
- const RDPGFX_DELETE_SURFACE_PDU* deleteSurface)
+ const RDPGFX_DELETE_SURFACE_PDU* deleteSurface)
{
rdpCodecs* codecs = NULL;
gdiGfxSurface* surface = NULL;
surface = (gdiGfxSurface*) context->GetSurfaceData(context,
- deleteSurface->surfaceId);
+ deleteSurface->surfaceId);
if (surface)
{
if (codecs && codecs->progressive)
progressive_delete_surface_context(codecs->progressive,
- deleteSurface->surfaceId);
+ deleteSurface->surfaceId);
codecs_free(codecs);
return CHANNEL_RC_OK;
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SolidFill(RdpgfxClientContext* context,
- const RDPGFX_SOLID_FILL_PDU* solidFill)
+ const RDPGFX_SOLID_FILL_PDU* solidFill)
{
UINT status = CHANNEL_RC_OK;
UINT16 index;
RECTANGLE_16 invalidRect;
rdpGdi* gdi = (rdpGdi*) context->custom;
surface = (gdiGfxSurface*) context->GetSurfaceData(context,
- solidFill->surfaceId);
+ solidFill->surfaceId);
if (!surface)
return ERROR_INTERNAL_ERROR;
a = solidFill->fillPixel.XA;
color = GetColor(PIXEL_FORMAT_ARGB32, r, g, b, a);
color = ConvertColor(color, PIXEL_FORMAT_ARGB32, surface->format,
- &gdi->palette);
+ &gdi->palette);
for (index = 0; index < solidFill->fillRectCount; index++)
{
invalidRect.right = rect->right;
invalidRect.bottom = rect->bottom;
freerdp_image_fill(surface->data, surface->format, surface->scanline,
- rect->left, rect->top, nWidth, nHeight, color);
+ rect->left, rect->top, nWidth, nHeight, color);
region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
- &invalidRect);
+ &invalidRect);
}
if (!gdi->inGfxFrame)
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceToSurface(RdpgfxClientContext* context,
- const RDPGFX_SURFACE_TO_SURFACE_PDU* surfaceToSurface)
+ const RDPGFX_SURFACE_TO_SURFACE_PDU* surfaceToSurface)
{
UINT status = CHANNEL_RC_OK;
UINT16 index;
rdpGdi* gdi = (rdpGdi*) context->custom;
rectSrc = &(surfaceToSurface->rectSrc);
surfaceSrc = (gdiGfxSurface*) context->GetSurfaceData(context,
- surfaceToSurface->surfaceIdSrc);
+ surfaceToSurface->surfaceIdSrc);
sameSurface = (surfaceToSurface->surfaceIdSrc ==
- surfaceToSurface->surfaceIdDest) ? TRUE : FALSE;
+ surfaceToSurface->surfaceIdDest) ? TRUE : FALSE;
if (!sameSurface)
surfaceDst = (gdiGfxSurface*) context->GetSurfaceData(context,
- surfaceToSurface->surfaceIdDest);
+ surfaceToSurface->surfaceIdDest);
else
surfaceDst = surfaceSrc;
{
destPt = &surfaceToSurface->destPts[index];
freerdp_image_copy(surfaceDst->data, surfaceDst->format,
- surfaceDst->scanline,
- destPt->x, destPt->y, nWidth, nHeight,
- surfaceSrc->data, surfaceSrc->format,
- surfaceSrc->scanline,
- rectSrc->left, rectSrc->top, NULL);
+ surfaceDst->scanline,
+ destPt->x, destPt->y, nWidth, nHeight,
+ surfaceSrc->data, surfaceSrc->format,
+ surfaceSrc->scanline,
+ rectSrc->left, rectSrc->top, NULL);
invalidRect.left = destPt->x;
invalidRect.top = destPt->y;
invalidRect.right = destPt->x + rectSrc->right;
invalidRect.bottom = destPt->y + rectSrc->bottom;
region16_union_rect(&surfaceDst->invalidRegion, &surfaceDst->invalidRegion,
- &invalidRect);
+ &invalidRect);
}
if (!gdi->inGfxFrame)
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_SurfaceToCache(RdpgfxClientContext* context,
- const RDPGFX_SURFACE_TO_CACHE_PDU* surfaceToCache)
+ const RDPGFX_SURFACE_TO_CACHE_PDU* surfaceToCache)
{
const RECTANGLE_16* rect;
gdiGfxSurface* surface;
gdiGfxCacheEntry* cacheEntry;
rect = &(surfaceToCache->rectSrc);
surface = (gdiGfxSurface*) context->GetSurfaceData(context,
- surfaceToCache->surfaceId);
+ surfaceToCache->surfaceId);
if (!surface)
return ERROR_INTERNAL_ERROR;
}
freerdp_image_copy(cacheEntry->data, cacheEntry->format, cacheEntry->scanline,
- 0, 0, cacheEntry->width, cacheEntry->height, surface->data,
- surface->format, surface->scanline, rect->left, rect->top, NULL);
+ 0, 0, cacheEntry->width, cacheEntry->height, surface->data,
+ surface->format, surface->scanline, rect->left, rect->top, NULL);
context->SetCacheSlotData(context, surfaceToCache->cacheSlot,
- (void*) cacheEntry);
+ (void*) cacheEntry);
return CHANNEL_RC_OK;
}
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_CacheToSurface(RdpgfxClientContext* context,
- const RDPGFX_CACHE_TO_SURFACE_PDU* cacheToSurface)
+ const RDPGFX_CACHE_TO_SURFACE_PDU* cacheToSurface)
{
UINT status = CHANNEL_RC_OK;
UINT16 index;
RECTANGLE_16 invalidRect;
rdpGdi* gdi = (rdpGdi*) context->custom;
surface = (gdiGfxSurface*) context->GetSurfaceData(context,
- cacheToSurface->surfaceId);
+ cacheToSurface->surfaceId);
cacheEntry = (gdiGfxCacheEntry*) context->GetCacheSlotData(context,
- cacheToSurface->cacheSlot);
+ cacheToSurface->cacheSlot);
if (!surface || !cacheEntry)
return ERROR_INTERNAL_ERROR;
{
destPt = &cacheToSurface->destPts[index];
freerdp_image_copy(surface->data, surface->format, surface->scanline,
- destPt->x, destPt->y, cacheEntry->width, cacheEntry->height,
- cacheEntry->data, cacheEntry->format, cacheEntry->scanline, 0, 0, NULL);
+ destPt->x, destPt->y, cacheEntry->width, cacheEntry->height,
+ cacheEntry->data, cacheEntry->format, cacheEntry->scanline, 0, 0, NULL);
invalidRect.left = destPt->x;
invalidRect.top = destPt->y;
invalidRect.right = destPt->x + cacheEntry->width - 1;
invalidRect.bottom = destPt->y + cacheEntry->height - 1;
region16_union_rect(&surface->invalidRegion, &surface->invalidRegion,
- &invalidRect);
+ &invalidRect);
}
if (!gdi->inGfxFrame)
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_CacheImportReply(RdpgfxClientContext* context,
- const RDPGFX_CACHE_IMPORT_REPLY_PDU* cacheImportReply)
+ const RDPGFX_CACHE_IMPORT_REPLY_PDU* cacheImportReply)
{
return CHANNEL_RC_OK;
}
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_EvictCacheEntry(RdpgfxClientContext* context,
- const RDPGFX_EVICT_CACHE_ENTRY_PDU* evictCacheEntry)
+ const RDPGFX_EVICT_CACHE_ENTRY_PDU* evictCacheEntry)
{
gdiGfxCacheEntry* cacheEntry;
cacheEntry = (gdiGfxCacheEntry*) context->GetCacheSlotData(context,
- evictCacheEntry->cacheSlot);
+ evictCacheEntry->cacheSlot);
if (cacheEntry)
{
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_MapSurfaceToOutput(RdpgfxClientContext* context,
- const RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU* surfaceToOutput)
+ const RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU* surfaceToOutput)
{
gdiGfxSurface* surface;
surface = (gdiGfxSurface*) context->GetSurfaceData(context,
- surfaceToOutput->surfaceId);
+ surfaceToOutput->surfaceId);
if (!surface)
return ERROR_INTERNAL_ERROR;
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_MapSurfaceToWindow(RdpgfxClientContext* context,
- const RDPGFX_MAP_SURFACE_TO_WINDOW_PDU* surfaceToWindow)
+ const RDPGFX_MAP_SURFACE_TO_WINDOW_PDU* surfaceToWindow)
{
return CHANNEL_RC_OK;
}
{
if (bpp < 32)
{
- if (!freerdp_client_codecs_prepare(context->codecs,
- FREERDP_CODEC_INTERLEAVED,
- gdi->width, gdi->height))
- return FALSE;
-
status = interleaved_decompress(context->codecs->interleaved,
pSrcData, SrcSize,
bpp,
}
else
{
- if (!freerdp_client_codecs_prepare(context->codecs,
- FREERDP_CODEC_PLANAR,
- gdi->width, gdi->height))
- return FALSE;
-
status = planar_decompress(context->codecs->planar, pSrcData, SrcSize,
pDstData, gdi->dstFormat, 0, 0, 0,
width, height, TRUE);
projects / platform / upstream / freerdp.git / commitdiff