C++ WLog_VRB函数代码示例

void* shadow_multiclient_get_subscriber(rdpShadowMultiClientEvent* event)
{
	struct rdp_shadow_multiclient_subscriber* subscriber;

	if (!event)
		return NULL;

	EnterCriticalSection(&(event->lock));

	subscriber = (struct rdp_shadow_multiclient_subscriber*) calloc(1, sizeof(struct rdp_shadow_multiclient_subscriber));
	if (!subscriber)
		goto out_error;

	subscriber->ref = event;
	subscriber->pleaseHandle = FALSE;

	if (ArrayList_Add(event->subscribers, subscriber) < 0)
		goto out_free;

	WLog_VRB(TAG, "Get subscriber %p. Wait event %d. %d clients.\n", (void *)subscriber, event->eventid, event->consuming);
	(void)_Consume(subscriber, TRUE);
	WLog_VRB(TAG, "Get subscriber %p. Quit event %d. %d clients.\n", (void *)subscriber, event->eventid, event->consuming);

	LeaveCriticalSection(&(event->lock));

	return subscriber;

out_free:
	free(subscriber);
out_error:
	LeaveCriticalSection(&(event->lock));
	return NULL;
}

/*
 * Consume my share and release my register
 * If we have update event and pleaseHandle flag
 * We need to consume. Anyway we need to clear
 * pleaseHandle flag
 */
void shadow_multiclient_release_subscriber(void* subscriber)
{
	struct rdp_shadow_multiclient_subscriber* s;
	rdpShadowMultiClientEvent* event;

	if (!subscriber)
		return;

	s = (struct rdp_shadow_multiclient_subscriber*)subscriber;
	event = s->ref;

	EnterCriticalSection(&(event->lock));

	WLog_VRB(TAG, "Release Subscriber %p. Drop event %d. %d clients.\n", subscriber, event->eventid, event->consuming);
	(void)_Consume(s, FALSE);
	WLog_VRB(TAG, "Release Subscriber %p. Quit event %d. %d clients.\n", subscriber, event->eventid, event->consuming);

	ArrayList_Remove(event->subscribers, subscriber);

	LeaveCriticalSection(&(event->lock));

	free(subscriber);

	return;
}

static BOOL autodetect_send_netchar_result(rdpContext* context, UINT16 sequenceNumber)
{
	wStream* s;

	s = rdp_message_channel_pdu_init(context->rdp);

	if (!s)
		return FALSE;

	WLog_VRB(AUTODETECT_TAG, "sending Bandwidth Network Characteristics Result PDU");

	if (context->rdp->autodetect->netCharBandwidth > 0)
	{
		Stream_Write_UINT8(s, 0x12); /* headerLength (1 byte) */
		Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST); /* headerTypeId (1 byte) */
		Stream_Write_UINT16(s, sequenceNumber); /* sequenceNumber (2 bytes) */
		Stream_Write_UINT16(s, 0x08C0); /* requestType (2 bytes) */
		Stream_Write_UINT32(s, context->rdp->autodetect->netCharBaseRTT); /* baseRTT (4 bytes) */
		Stream_Write_UINT32(s, context->rdp->autodetect->netCharBandwidth); /* bandwidth (4 bytes) */
		Stream_Write_UINT32(s, context->rdp->autodetect->netCharAverageRTT); /* averageRTT (4 bytes) */
	}
	else
	{
		Stream_Write_UINT8(s, 0x0E); /* headerLength (1 byte) */
		Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_REQUEST); /* headerTypeId (1 byte) */
		Stream_Write_UINT16(s, sequenceNumber); /* sequenceNumber (2 bytes) */
		Stream_Write_UINT16(s, 0x0840); /* requestType (2 bytes) */
		Stream_Write_UINT32(s, context->rdp->autodetect->netCharBaseRTT); /* baseRTT (4 bytes) */
		Stream_Write_UINT32(s, context->rdp->autodetect->netCharAverageRTT); /* averageRTT (4 bytes) */
	}

	return rdp_send_message_channel_pdu(context->rdp, s, SEC_AUTODETECT_REQ);
}

int rdp_recv_autodetect_request_packet(rdpRdp* rdp, wStream* s)
{
	AUTODETECT_REQ_PDU autodetectReqPdu;
	BOOL success = FALSE;

	if (Stream_GetRemainingLength(s) < 6)
		return -1;

	Stream_Read_UINT8(s, autodetectReqPdu.headerLength); /* headerLength (1 byte) */
	Stream_Read_UINT8(s, autodetectReqPdu.headerTypeId); /* headerTypeId (1 byte) */
	Stream_Read_UINT16(s, autodetectReqPdu.sequenceNumber); /* sequenceNumber (2 bytes) */
	Stream_Read_UINT16(s, autodetectReqPdu.requestType); /* requestType (2 bytes) */
	WLog_VRB(AUTODETECT_TAG,
	         "rdp_recv_autodetect_request_packet: headerLength=%"PRIu8", headerTypeId=%"PRIu8", sequenceNumber=%"PRIu16", requestType=%04"PRIx16"",
	         autodetectReqPdu.headerLength, autodetectReqPdu.headerTypeId,
	         autodetectReqPdu.sequenceNumber, autodetectReqPdu.requestType);

	if (autodetectReqPdu.headerTypeId != TYPE_ID_AUTODETECT_REQUEST)
		return -1;

	switch (autodetectReqPdu.requestType)
	{
		case RDP_RTT_REQUEST_TYPE_CONTINUOUS:
		case RDP_RTT_REQUEST_TYPE_CONNECTTIME:
			/* RTT Measure Request (RDP_RTT_REQUEST) - MS-RDPBCGR 2.2.14.1.1 */
			success = autodetect_recv_rtt_measure_request(rdp, s, &autodetectReqPdu);
			break;

		case RDP_BW_START_REQUEST_TYPE_CONTINUOUS:
		case RDP_BW_START_REQUEST_TYPE_TUNNEL:
		case RDP_BW_START_REQUEST_TYPE_CONNECTTIME:
			/* Bandwidth Measure Start (RDP_BW_START) - MS-RDPBCGR 2.2.14.1.2 */
			success = autodetect_recv_bandwidth_measure_start(rdp, s, &autodetectReqPdu);
			break;

		case RDP_BW_PAYLOAD_REQUEST_TYPE:
			/* Bandwidth Measure Payload (RDP_BW_PAYLOAD) - MS-RDPBCGR 2.2.14.1.3 */
			success = autodetect_recv_bandwidth_measure_payload(rdp, s, &autodetectReqPdu);
			break;

		case RDP_BW_STOP_REQUEST_TYPE_CONNECTTIME:
		case RDP_BW_STOP_REQUEST_TYPE_CONTINUOUS:
		case RDP_BW_STOP_REQUEST_TYPE_TUNNEL:
			/* Bandwidth Measure Stop (RDP_BW_STOP) - MS-RDPBCGR 2.2.14.1.4 */
			success = autodetect_recv_bandwidth_measure_stop(rdp, s, &autodetectReqPdu);
			break;

		case 0x0840:
		case 0x0880:
		case 0x08C0:
			/* Network Characteristics Result (RDP_NETCHAR_RESULT) - MS-RDPBCGR 2.2.14.1.5 */
			success = autodetect_recv_netchar_result(rdp, s, &autodetectReqPdu);
			break;

		default:
			break;
	}

	return success ? 0 : -1;
}

void rfx_context_free(RFX_CONTEXT* context)
{
	RFX_CONTEXT_PRIV *priv;

	assert(NULL != context);
	assert(NULL != context->priv);
	assert(NULL != context->priv->TilePool);
	assert(NULL != context->priv->BufferPool);

	priv = context->priv;
	free(context->quants);

	ObjectPool_Free(priv->TilePool);

	rfx_profiler_print(context);
	rfx_profiler_free(context);

	if (priv->UseThreads)
	{
		CloseThreadpool(context->priv->ThreadPool);
		DestroyThreadpoolEnvironment(&context->priv->ThreadPoolEnv);

		free(priv->workObjects);
		free(priv->tileWorkParams);

#ifdef WITH_PROFILER
		WLog_VRB(TAG,  "WARNING: Profiling results probably unusable with multithreaded RemoteFX codec!");
#endif
	}

	BufferPool_Free(context->priv->BufferPool);

	free(context->priv);
	free(context);
}

int freerds_orders_mem_blt(rdsConnection* connection, int cache_id,
                           int color_table, int x, int y, int cx, int cy, int rop, int srcx,
                           int srcy, int cache_idx, rdsRect* rect)
{
    MEMBLT_ORDER memblt;
    rdpPrimaryUpdate* primary = connection->client->update->primary;

    WLog_VRB(TAG, "%s id: %d index: %d width: %d height: %d",
             __FUNCTION__, cache_id, cache_idx, cx, cy);

    memblt.nLeftRect = x;
    memblt.nTopRect = y;
    memblt.nWidth = cx;
    memblt.nHeight = cy;
    memblt.bRop = rop;
    memblt.nXSrc = srcx;
    memblt.nYSrc = srcy;
    memblt.cacheId = cache_id;
    memblt.cacheIndex = cache_idx;
    memblt.colorIndex = color_table;

    freerds_set_bounds_rect(connection, rect);

    IFCALL(primary->MemBlt, (rdpContext*) connection, &memblt);

    return 0;
}

static BOOL autodetect_send_bandwidth_measure_results(rdpRdp* rdp, UINT16 responseType, UINT16 sequenceNumber)
{
	BOOL success = TRUE;
	wStream* s;
	UINT32 timeDelta;

	/* Compute the total time */
	timeDelta = GetTickCountPrecise() - rdp->autodetect->bandwidthMeasureStartTime;

	/* Send the result PDU to the server */

	s = rdp_message_channel_pdu_init(rdp);

	if (!s)
		return FALSE;

	WLog_VRB(AUTODETECT_TAG, "sending Bandwidth Measure Results PDU -> timeDelta=%u, byteCount=%u", timeDelta, rdp->autodetect->bandwidthMeasureByteCount);

	Stream_Write_UINT8(s, 0x0E); /* headerLength (1 byte) */
	Stream_Write_UINT8(s, TYPE_ID_AUTODETECT_RESPONSE); /* headerTypeId (1 byte) */
	Stream_Write_UINT16(s, sequenceNumber); /* sequenceNumber (2 bytes) */
	Stream_Write_UINT16(s, responseType); /* responseType (1 byte) */
	Stream_Write_UINT32(s, timeDelta); /* timeDelta (4 bytes) */
	Stream_Write_UINT32(s, rdp->autodetect->bandwidthMeasureByteCount); /* byteCount (4 bytes) */

	IFCALLRET(rdp->autodetect->ClientBandwidthMeasureResult, success,
						rdp->context, rdp->autodetect);

	if (!success)
		return FALSE;

	return rdp_send_message_channel_pdu(rdp, s, SEC_AUTODETECT_RSP);
}

int freerds_orders_text(rdsConnection* connection, RDS_MSG_GLYPH_INDEX* msg, rdsRect* rect)
{
    GLYPH_INDEX_ORDER glyphIndex;
    rdpPrimaryUpdate* primary = connection->client->update->primary;

    WLog_VRB(TAG, "%s: cacheId: %d", __FUNCTION__, msg->cacheId);

    glyphIndex.backColor = msg->backColor;
    glyphIndex.foreColor = msg->foreColor;
    glyphIndex.cacheId = msg->cacheId;
    glyphIndex.flAccel = msg->flAccel;
    glyphIndex.ulCharInc = msg->ulCharInc;
    glyphIndex.fOpRedundant = msg->fOpRedundant;
    glyphIndex.bkLeft = msg->bkLeft;
    glyphIndex.bkTop = msg->bkTop;
    glyphIndex.bkRight = msg->bkRight;
    glyphIndex.bkBottom = msg->bkBottom;
    glyphIndex.opLeft = msg->opLeft;
    glyphIndex.opTop = msg->opTop;
    glyphIndex.opRight = msg->opRight;
    glyphIndex.opBottom = msg->opBottom;
    CopyMemory(&glyphIndex.brush, &msg->brush, sizeof(rdpBrush));
    glyphIndex.brush.data = glyphIndex.brush.p8x8;
    glyphIndex.x = msg->x;
    glyphIndex.y = msg->y;
    glyphIndex.cbData = msg->cbData;
    CopyMemory(glyphIndex.data, msg->data, glyphIndex.cbData);

    freerds_set_bounds_rect(connection, rect);

    IFCALL(primary->GlyphIndex, (rdpContext*) connection, &glyphIndex);

    return 0;
}

static void _Publish(rdpShadowMultiClientEvent* event)
{
	wArrayList* subscribers;
	struct rdp_shadow_multiclient_subscriber* subscriber = NULL;
	int i;

	subscribers = event->subscribers;

	assert(event->consuming == 0);

	/* Count subscribing clients */
	ArrayList_Lock(subscribers);
	for (i = 0; i < ArrayList_Count(subscribers); i++)
	{
		subscriber = (struct rdp_shadow_multiclient_subscriber *)ArrayList_GetItem(subscribers, i);
		/* Set flag to subscriber: I acknowledge and please handle */
		subscriber->pleaseHandle = TRUE;
		event->consuming++;
	}
	ArrayList_Unlock(subscribers);

	if (event->consuming > 0)
	{
		event->eventid = (event->eventid & 0xff) + 1;
		WLog_VRB(TAG, "Server published event %d. %d clients.\n", event->eventid, event->consuming);
		ResetEvent(event->doneEvent);
		SetEvent(event->event);
	}

	return;
}

int freerds_orders_pat_blt(rdsConnection* connection, int x, int y,
                           int cx, int cy, int rop, int bg_color, int fg_color,
                           rdpBrush* brush, rdsRect* rect)
{
    PATBLT_ORDER patblt;
    rdpPrimaryUpdate* primary = connection->client->update->primary;

    WLog_VRB(TAG, "%s", __FUNCTION__);

    patblt.nLeftRect = x;
    patblt.nTopRect = y;
    patblt.nWidth = cx;
    patblt.nHeight = cy;
    patblt.bRop = (UINT32) rop;
    patblt.backColor = (UINT32) fg_color;
    patblt.foreColor = (UINT32) bg_color;

    patblt.brush.x = brush->x;
    patblt.brush.y = brush->y;
    patblt.brush.style = brush->style;
    patblt.brush.data = patblt.brush.p8x8;
    CopyMemory(patblt.brush.data, brush->data, 8);
    patblt.brush.hatch = patblt.brush.data[0];

    freerds_set_bounds_rect(connection, rect);

    IFCALL(primary->PatBlt, (rdpContext*) connection, &patblt);

    return 0;
}

static void _WaitForSubscribers(rdpShadowMultiClientEvent* event)
{
	if (event->consuming > 0)
	{
		/* Wait for clients done */
		WLog_VRB(TAG, "Server wait event %d. %d clients.\n", event->eventid, event->consuming);
		LeaveCriticalSection(&(event->lock));
		WaitForSingleObject(event->doneEvent, INFINITE);
		EnterCriticalSection(&(event->lock));
		WLog_VRB(TAG, "Server quit event %d. %d clients.\n", event->eventid, event->consuming);
	}

	/* Last subscriber should have already reset the event */
	assert(WaitForSingleObject(event->event, 0) != WAIT_OBJECT_0);

	return;
}

int freerds_reset(rdsConnection* connection, RDS_MSG_RESET* msg)
{
    WLog_VRB(TAG, "%s", __FUNCTION__);

    connection->settings->DesktopWidth = msg->DesktopWidth;
    connection->settings->DesktopHeight = msg->DesktopHeight;
    connection->settings->ColorDepth = msg->ColorDepth;

    return 0;
}

int freerds_orders_end_paint(rdsConnection* connection)
{
    rdpUpdate* update = ((rdpContext*) connection)->update;

    WLog_VRB(TAG, "%s", __FUNCTION__);

    update->EndPaint((rdpContext*) connection);

    return 0;
}

static BOOL autodetect_recv_rtt_measure_request(rdpRdp* rdp, wStream* s, AUTODETECT_REQ_PDU* autodetectReqPdu)
{
	if (autodetectReqPdu->headerLength != 0x06)
		return FALSE;

	WLog_VRB(AUTODETECT_TAG, "received RTT Measure Request PDU");

	/* Send a response to the server */
	return autodetect_send_rtt_measure_response(rdp, autodetectReqPdu->sequenceNumber);
}

int freerds_orders_send_create_os_surface(rdsConnection* connection, CREATE_OFFSCREEN_BITMAP_ORDER* createOffscreenBitmap)
{
    rdpAltSecUpdate* altsec = connection->client->update->altsec;

    WLog_VRB(TAG, "%s: id: %d width: %d height: %d", __FUNCTION__,
             createOffscreenBitmap->id, createOffscreenBitmap->cx, createOffscreenBitmap->cy);

    IFCALL(altsec->CreateOffscreenBitmap, (rdpContext*) connection, createOffscreenBitmap);

    return 0;
}