Merge remote branch 'origin/remotefx' into remotefx

channels/rdpdr/devman.c

@@ -103,11 +103,11 @@ devman_unregister_service(DEVMAN* devman, SERVICE* srv)
 
 		if (pdev->service == srv)
 		{
-			devman_unregister_device(devman, pdev);
-			devman_rewind(devman);
-
 			if (pdev->service->type == RDPDR_DTYP_SMARTCARD && pdev->service->control)
 				pthread_cancel(scard_thread);
+
+			devman_unregister_device(devman, pdev);
+			devman_rewind(devman);
 		}
 	}
 

cunit/test_librfx.c

@@ -269,7 +269,7 @@ test_dwt(void)
 	RFX_CONTEXT * context;
 
 	context = rfx_context_new();
-	rfx_dwt_2d_decode(buffer, context->dwt_buffer_8, context->dwt_buffer_16, context->dwt_buffer_32);
+	rfx_dwt_2d_decode(buffer, context->dwt_buffer);
 	//dump_buffer(buffer, 4096);
 	rfx_context_free(context);
 }

include/freerdp/rfx.h

@@ -157,20 +157,17 @@ struct _RFX_CONTEXT
 	sint16 * cb_g_buffer;
 	sint16 * cr_b_buffer;
 
-	sint16 dwt_mem_8[8*8*2*2 + 8]; /* sub-band width 8 */
-	sint16 dwt_mem_16[16*16*2*2 + 8]; /* sub-band width 16 */
-	sint16 dwt_mem_32[32*32*2*2 + 8]; /* sub-band width 32 */
+	sint16 dwt_mem[32*32*2*2 + 8]; /* maximum sub-band width is 32 */
 
- 	sint16 * dwt_buffer_8;
-	sint16 * dwt_buffer_16;
-	sint16 * dwt_buffer_32;
+	sint16 * dwt_buffer;
 
 	/* routines */
 	void (* decode_YCbCr_to_RGB)(sint16 * y_r_buf, sint16 * cb_g_buf, sint16 * cr_b_buf);
 	void (* encode_RGB_to_YCbCr)(sint16 * y_r_buf, sint16 * cb_g_buf, sint16 * cr_b_buf);
 	void (* quantization_decode)(sint16 * buffer, const uint32 * quantization_values);
 	void (* quantization_encode)(sint16 * buffer, const uint32 * quantization_values);
-	void (* dwt_2d_decode)(sint16 * buffer, sint16 * dwt_buffer_8, sint16 * dwt_buffer_16, sint16 * dwt_buffer_32);
+	void (* dwt_2d_decode)(sint16 * buffer, sint16 * dwt_buffer);
+	void (* dwt_2d_encode)(sint16 * buffer, sint16 * dwt_buffer);
 
 	/* profiler definitions */
 	PROFILER_DEFINE(prof_rfx_decode_rgb);

libfreerdp-core/crypto/openssl.c

@@ -21,6 +21,7 @@
 #include "crypto.h"
 #include <freerdp/utils/memory.h>
 #include <freerdp/constants/constants.h>
+#include <time.h>
 
 #include "tls.h"
 #include "crypto/openssl.h"
@@ -349,6 +350,7 @@ struct rdp_tls
 {
 	SSL_CTX * ctx;
 	SSL * ssl;
+	struct timespec ts;
 };
 
 RD_BOOL
@@ -428,6 +430,10 @@ tls_new(void)
 
 	SSL_CTX_set_options(tls->ctx, SSL_OP_ALL);
 
+	/* a small 0.1ms delay when network blocking happens. */
+	tls->ts.tv_sec = 0;
+	tls->ts.tv_nsec = 100000;
+
 	return tls;
 }
 
@@ -515,6 +521,7 @@ tls_write(rdpTls * tls, char* b, int length)
 				break;
 
 			case SSL_ERROR_WANT_WRITE:
+				nanosleep(&tls->ts, NULL);
 				break;
 
 			default:
@@ -543,6 +550,7 @@ tls_read(rdpTls * tls, char* b, int length)
 				break;
 
 			case SSL_ERROR_WANT_READ:
+				nanosleep(&tls->ts, NULL);
 				break;
 
 			default:

libfreerdp-gdi/decode.c

@@ -32,7 +32,8 @@
 
 int gdi_decode_bitmap_data_ex(GDI *gdi, uint16 x, uint16 y, uint8 * data, int size)
 {
-	int i, tx, ty;
+	int i, j;
+	int tx, ty;
 	uint8* bitmapData;
 	uint32 bitmapDataLength;
 	RFX_MESSAGE * message;
@@ -50,17 +51,49 @@ int gdi_decode_bitmap_data_ex(GDI *gdi, uint16 x, uint16 y, uint8 * data, int si
 	/* decode bitmap data */
 	message = rfx_process_message((RFX_CONTEXT *) gdi->rfx_context, bitmapData, bitmapDataLength);
 
-	/* blit each tile */
-	for (i = 0; i < message->num_tiles; i++)
+	if (message->num_rects > 1) /* RDVH */
 	{
-		tx = message->tiles[i]->x + x;
-		ty = message->tiles[i]->y + y;
-		data = message->tiles[i]->data;
+		/* blit each tile */
+		for (i = 0; i < message->num_tiles; i++)
+		{
+			tx = message->tiles[i]->x + x;
+			ty = message->tiles[i]->y + y;
+			data = message->tiles[i]->data;
+
+			gdi_image_convert(data, gdi->tile->bitmap->data, 64, 64, 32, 32, gdi->clrconv);
 
-		gdi_image_convert(data, gdi->tile->bitmap->data, 64, 64, 32, 32, gdi->clrconv);
-		gdi_BitBlt(gdi->primary->hdc, tx, ty, 64, 64, gdi->tile->hdc, 0, 0, GDI_SRCCOPY);
+			for (j = 0; j < message->num_rects; j++)
+			{
+				gdi_SetClipRgn(gdi->primary->hdc,
+						message->rects[j].x, message->rects[j].y,
+						message->rects[j].width, message->rects[j].height);
+
+				gdi_BitBlt(gdi->primary->hdc, tx, ty, 64, 64, gdi->tile->hdc, 0, 0, GDI_SRCCOPY);
+			}
+		}
 
-		gdi_InvalidateRegion(gdi->primary->hdc, tx, ty, 64, 64);
+		for (i = 0; i < message->num_rects; i++)
+		{
+			gdi_InvalidateRegion(gdi->primary->hdc,
+					message->rects[i].x, message->rects[i].y,
+					message->rects[i].width, message->rects[i].height);
+		}
+	}
+	else /* RDSH */
+	{
+		/* blit each tile */
+		for (i = 0; i < message->num_tiles; i++)
+		{
+			tx = message->tiles[i]->x + x;
+			ty = message->tiles[i]->y + y;
+			data = message->tiles[i]->data;
+
+			gdi_image_convert(data, gdi->tile->bitmap->data, 64, 64, 32, 32, gdi->clrconv);
+
+			gdi_BitBlt(gdi->primary->hdc, tx, ty, 64, 64, gdi->tile->hdc, 0, 0, GDI_SRCCOPY);
+
+			gdi_InvalidateRegion(gdi->primary->hdc, tx, ty, 64, 64);
+		}
 	}
 
 	rfx_message_free(gdi->rfx_context, message);

libfreerdp-rfx/librfx.c

@@ -135,9 +135,7 @@ rfx_context_new(void)
 	context->cb_g_buffer = (sint16 *)(((uintptr_t)context->cb_g_mem + 16) & ~ 0x0F);
 	context->cr_b_buffer = (sint16 *)(((uintptr_t)context->cr_b_mem + 16) & ~ 0x0F);
 
-	context->dwt_buffer_8 = (sint16 *)(((uintptr_t)context->dwt_mem_8 + 16) & ~ 0x0F);
-	context->dwt_buffer_16 = (sint16 *)(((uintptr_t)context->dwt_mem_16 + 16) & ~ 0x0F);
-	context->dwt_buffer_32 = (sint16 *)(((uintptr_t)context->dwt_mem_32 + 16) & ~ 0x0F);
+	context->dwt_buffer = (sint16 *)(((uintptr_t)context->dwt_mem + 16) & ~ 0x0F);
 
 	/* create profilers for default decoding routines */
 	rfx_profiler_create(context);
@@ -148,6 +146,7 @@ rfx_context_new(void)
 	context->quantization_decode = rfx_quantization_decode;	
 	context->quantization_encode = rfx_quantization_encode;	
 	context->dwt_2d_decode = rfx_dwt_2d_decode;
+	context->dwt_2d_encode = rfx_dwt_2d_encode;
 
 	/* detect and enable SIMD CPU acceleration */
 	RFX_INIT_SIMD(context);

libfreerdp-rfx/rfx_decode.c

@@ -120,7 +120,7 @@ rfx_decode_component(RFX_CONTEXT * context, const uint32 * quantization_values,
 	PROFILER_EXIT(context->prof_rfx_quantization_decode);
 
 	PROFILER_ENTER(context->prof_rfx_dwt_2d_decode);
-		context->dwt_2d_decode(buffer, context->dwt_buffer_8, context->dwt_buffer_16, context->dwt_buffer_32);
+		context->dwt_2d_decode(buffer, context->dwt_buffer);
 	PROFILER_EXIT(context->prof_rfx_dwt_2d_decode);
 
 	PROFILER_EXIT(context->prof_rfx_decode_component);

libfreerdp-rfx/rfx_dwt.c

@@ -106,11 +106,11 @@ rfx_dwt_2d_decode_block(sint16 * buffer, sint16 * idwt, int subband_width)
 }
 
 void
-rfx_dwt_2d_decode(sint16 * buffer, sint16 * dwt_buffer_8, sint16 * dwt_buffer_16, sint16 * dwt_buffer_32)
+rfx_dwt_2d_decode(sint16 * buffer, sint16 * dwt_buffer)
 {
-	rfx_dwt_2d_decode_block(buffer + 3840, dwt_buffer_8, 8);
-	rfx_dwt_2d_decode_block(buffer + 3072, dwt_buffer_16, 16);
-	rfx_dwt_2d_decode_block(buffer, dwt_buffer_32, 32);
+	rfx_dwt_2d_decode_block(buffer + 3840, dwt_buffer, 8);
+	rfx_dwt_2d_decode_block(buffer + 3072, dwt_buffer, 16);
+	rfx_dwt_2d_decode_block(buffer, dwt_buffer, 32);
 }
 
 void
@@ -136,7 +136,7 @@ rfx_dwt_2d_encode_block(sint16 * buffer, sint16 * dwt, int subband_width)
 			src = buffer + y * total_width + x;
 
 			/* H */
-			*h = (src[total_width] - ((src[0] + src[n < subband_width - 1 ? 2 * total_width : 0]) >> 1)) >> 1;
+			*h = (src[total_width] - ((src[0] + src[n < subband_width - 1 ? 2 * total_width : total_width]) >> 1)) >> 1;
 
 			/* L */
 			*l = src[0] + (n == 0 ? *h : (*(h - total_width) + *h) >> 1);
@@ -190,9 +190,9 @@ rfx_dwt_2d_encode_block(sint16 * buffer, sint16 * dwt, int subband_width)
 }
 
 void
-rfx_dwt_2d_encode(sint16 * buffer, sint16 * dwt_buffer_8, sint16 * dwt_buffer_16, sint16 * dwt_buffer_32)
+rfx_dwt_2d_encode(sint16 * buffer, sint16 * dwt_buffer)
 {
-	rfx_dwt_2d_encode_block(buffer, dwt_buffer_32, 32);
-	rfx_dwt_2d_encode_block(buffer + 3072, dwt_buffer_16, 16);
-	rfx_dwt_2d_encode_block(buffer + 3840, dwt_buffer_8, 8);
+	rfx_dwt_2d_encode_block(buffer, dwt_buffer, 32);
+	rfx_dwt_2d_encode_block(buffer + 3072, dwt_buffer, 16);
+	rfx_dwt_2d_encode_block(buffer + 3840, dwt_buffer, 8);
 }

libfreerdp-rfx/rfx_dwt.h

@@ -23,9 +23,9 @@
 #include <freerdp/rfx.h>
 
 void
-rfx_dwt_2d_decode(sint16 * buffer, sint16 * dwt_buffer_8, sint16 * dwt_buffer_16, sint16 * dwt_buffer_32);
+rfx_dwt_2d_decode(sint16 * buffer, sint16 * dwt_buffer);
 void
-rfx_dwt_2d_encode(sint16 * buffer, sint16 * dwt_buffer_8, sint16 * dwt_buffer_16, sint16 * dwt_buffer_32);
+rfx_dwt_2d_encode(sint16 * buffer, sint16 * dwt_buffer);
 
 #endif
 

libfreerdp-rfx/rfx_encode.c

@@ -132,7 +132,7 @@ rfx_encode_component(RFX_CONTEXT * context, const uint32 * quantization_values,
 	PROFILER_ENTER(context->prof_rfx_encode_component);
 
 	PROFILER_ENTER(context->prof_rfx_dwt_2d_encode);
-		rfx_dwt_2d_encode(data, context->dwt_buffer_8, context->dwt_buffer_16, context->dwt_buffer_32);
+		context->dwt_2d_encode(data, context->dwt_buffer);
 	PROFILER_EXIT(context->prof_rfx_dwt_2d_encode);
 
 	PROFILER_ENTER(context->prof_rfx_quantization_encode);

libfreerdp-rfx/sse/rfx_sse.c

@@ -33,10 +33,12 @@ void rfx_init_sse(RFX_CONTEXT * context)
 		IF_PROFILER(context->prof_rfx_quantization_decode->name = "rfx_quantization_decode_SSE2");
 		IF_PROFILER(context->prof_rfx_quantization_encode->name = "rfx_quantization_encode_SSE2");
 		IF_PROFILER(context->prof_rfx_dwt_2d_decode->name = "rfx_dwt_2d_decode_SSE2");
+		IF_PROFILER(context->prof_rfx_dwt_2d_encode->name = "rfx_dwt_2d_encode_SSE2");
 
 		context->decode_YCbCr_to_RGB = rfx_decode_YCbCr_to_RGB_SSE2;
 		context->encode_RGB_to_YCbCr = rfx_encode_RGB_to_YCbCr_SSE2;
 		context->quantization_decode = rfx_quantization_decode_SSE2;
 		context->quantization_encode = rfx_quantization_encode_SSE2;
 		context->dwt_2d_decode = rfx_dwt_2d_decode_SSE2;
+		context->dwt_2d_encode = rfx_dwt_2d_encode_SSE2;
 }