fruncm server sql 无法生成 线程_FreeRDP(4/5)：Server处理图像

1、<FreeRDP>/server/shadow/Win/win_dxgi.h，去掉注释WITH_DXGI_1_2宏。
2、<FreeRDP>/server/shadow/Win/win_dxgi.c。
textureDesc.Width = subsystem->width;
textureDesc.Height = subsystem->height;
改为
textureDesc.Width = subsystem->base.monitors[0].right - subsystem->base.monitors[0].left;
textureDesc.Height = subsystem->base.monitors[0].bottom - subsystem->base.monitors[0].top;
注：估计freerdp已不再用subsystem->width、subsystem->height，它们总是0。monitors[0]存放着屏幕尺寸。width、height不对时，接下的CreateTexture2D会返回失败。
3、不编译<FreeRDP>/server/shadow/Win/win_rdp.c、<FreeRDP>/server/shadow/Win/win_wds.c
4、<FreeRDP>/server/shadow/Win/win_wds.h。注释宏WITH_WDS_API。

settings->GfxSmallCache = (flags & RDPGFX_CAPS_FLAG_SMALL_CACHE);
settings->GfxAVC444v2 = settings->GfxAVC444 = settings->GfxH264 = !(flags & RDPGFX_CAPS_FLAG_AVC_DISABLED);

INT32 avc444_compress(H264_CONTEXT* h264, const BYTE* pSrcData, DWORD SrcFormat, UINT32 nSrcStep,
                      UINT32 nSrcWidth, UINT32 nSrcHeight, BYTE version, BYTE* op, BYTE** ppDstData,
                      UINT32* pDstSize, BYTE** ppAuxDstData, UINT32* pAuxDstSize)
{
	prim_size_t roi;
	primitives_t* prims = primitives_get();
	BYTE* coded;
	UINT32 codedSize;
 
	if (!h264)
		return -1;
 
	if (!h264->subsystem->Compress)
		return -1;
 
	if (!avc420_ensure_buffer(h264, nSrcStep, nSrcWidth, nSrcHeight))
		return -1;

	if (!avc444_ensure_buffer(h264, nSrcHeight))
		return -1;

	roi.width = nSrcWidth;
	roi.height = nSrcHeight;
 
	switch (version)
	{
		case 1:
			if (prims->RGBToAVC444YUV(pSrcData, SrcFormat, nSrcStep, h264->pYUV444Data,
			                          h264->iStride, h264->pYUVData, h264->iStride,
			                          &roi) != PRIMITIVES_SUCCESS)
				return -1;
 
			break;
 
		case 2:
			if (prims->RGBToAVC444YUVv2(pSrcData, SrcFormat, nSrcStep, h264->pYUV444Data,
			                            h264->iStride, h264->pYUVData, h264->iStride,
			                            &roi) != PRIMITIVES_SUCCESS)
				return -1;

			break;
 
		default:
			return -1;
	}
 
	{
		const BYTE* pYUV444Data[3] = { h264->pYUV444Data[0], h264->pYUV444Data[1],
			                           h264->pYUV444Data[2] };
 
		if (h264->subsystem->Compress(h264, pYUV444Data, h264->iStride, &coded, &codedSize) < 0)
			return -1;

	}
 
	memcpy(h264->lumaData, coded, codedSize);
	*ppDstData = h264->lumaData;
	*pDstSize = codedSize;
	{
		const BYTE* pYUVData[3] = { h264->pYUVData[0], h264->pYUVData[1], h264->pYUVData[2] };
 
		if (h264->subsystem->Compress(h264, pYUVData, h264->iStride, &coded, &codedSize) < 0)
			return -1;
Auxillary View的h264压缩。
	}
	*ppAuxDstData = coded;
	*pAuxDstSize = codedSize;
	*op = 0;
	return 0;
}

static UINT rdpgfx_send_surface_frame_command(RdpgfxServerContext* context,
                                              const RDPGFX_SURFACE_COMMAND* cmd,
                                              const RDPGFX_START_FRAME_PDU* startFrame,
                                              const RDPGFX_END_FRAME_PDU* endFrame)
 
{
	UINT error = CHANNEL_RC_OK;
	wStream* s;
	UINT32 position = 0;
	UINT32 size = rdpgfx_pdu_length(rdpgfx_estimate_surface_command(cmd));

	if (startFrame)
	{
		size += rdpgfx_pdu_length(RDPGFX_START_FRAME_PDU_SIZE);
	}

	if (endFrame)
	{
		size += rdpgfx_pdu_length(RDPGFX_END_FRAME_PDU_SIZE);
	}

	s = Stream_New(NULL, size);
创建一条wStream，它将用于产生此次要发送的3 pdu。
	if (!s)
	{
		WLog_ERR(TAG, "Stream_New failed!");
		return CHANNEL_RC_NO_MEMORY;
	}
 
	/* Write start frame if exists */
	if (startFrame)
	{
		position = Stream_GetPosition(s);
		error = rdpgfx_server_packet_init_header(s, RDPGFX_CMDID_STARTFRAME, 0);
 
		if (error != CHANNEL_RC_OK)
		{
			WLog_ERR(TAG, "Failed to init header with error %" PRIu32 "!", error);
			goto error;
		}
 
		rdpgfx_write_start_frame_pdu(s, startFrame);
		rdpgfx_server_packet_complete_header(s, position);
	}

	/* Write RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2 */
	position = Stream_GetPosition(s);
	error = rdpgfx_server_packet_init_header(s, rdpgfx_surface_command_cmdid(cmd),
	                                         0); // Actual length will be filled later

	if (error != CHANNEL_RC_OK)
	{
		WLog_ERR(TAG, "Failed to init header with error %" PRIu32 "!", error);
		goto error;
	}
 
	error = rdpgfx_write_surface_command(s, cmd);

	if (error != CHANNEL_RC_OK)
	{
		WLog_ERR(TAG, "rdpgfx_write_surface_command failed!");
		goto error;
	}
 
	rdpgfx_server_packet_complete_header(s, position);

	/* Write end frame if exists */
	if (endFrame)
	{
		position = Stream_GetPosition(s);
		error = rdpgfx_server_packet_init_header(s, RDPGFX_CMDID_ENDFRAME, 0);
 
		if (error != CHANNEL_RC_OK)
		{
			WLog_ERR(TAG, "Failed to init header with error %" PRIu32 "!", error);
			goto error;
		}
 
		rdpgfx_write_end_frame_pdu(s, endFrame);
		rdpgfx_server_packet_complete_header(s, position);
	}

	return rdpgfx_server_packet_send(context, s);
封装3pdu负载、投递到drdynvc_channel->vcm->queue。
error:
	Stream_Free(s, TRUE);
	return error;
}

static UINT rdpgfx_write_surface_command(wStream* s, const RDPGFX_SURFACE_COMMAND* cmd)
{
	UINT error = CHANNEL_RC_OK;
	RDPGFX_AVC420_BITMAP_STREAM* havc420 = NULL;
	RDPGFX_AVC444_BITMAP_STREAM* havc444 = NULL;
	UINT32 bitmapDataStart = 0;
	UINT32 bitmapDataLength = 0;
	{

		/* Write RDPGFX_CMDID_WIRETOSURFACE_1 format for others */
		Stream_Write_UINT16(s, cmd->surfaceId); /* surfaceId (2 bytes) */
freerdp对cmd->surfaceId总是置0。
		Stream_Write_UINT16(s, cmd->codecId);   /* codecId (2 bytes) */
RDPGFX_CODECID_AVC444V2。表示工作在YUV444v2模式，使用MPEG-4 AVC/H.264压缩图像数据，压缩后的数据封装在bitmapData字段。
		Stream_Write_UINT8(s, pixelFormat);     /* pixelFormat (1 byte) */
pixelFormat值GFX_PIXEL_FORMAT_XRGB_8888(0x20)，对应[MS-RDPEGFX]中的PIXEL_FORMAT_XRGB_8888。
		Stream_Write_UINT16(s, cmd->left);      /* left (2 bytes) */
		Stream_Write_UINT16(s, cmd->top);       /* top (2 bytes) */
		Stream_Write_UINT16(s, cmd->right);     /* right (2 bytes) */
		Stream_Write_UINT16(s, cmd->bottom);    /* bottom (2 bytes) */
屏幕矩形，它总是屏尺寸。对2560x1600时，值分别是0、0、2560、1600。
		Stream_Write_UINT32(s, cmd->length);    /* bitmapDataLength (4 bytes) */
此时cmd->length值是0，对应[MS-RDPEGFX]中的bitmapDataLength。
		bitmapDataStart = Stream_GetPosition(s);

		if (cmd->codecId == RDPGFX_CODECID_AVC420)
		{
			havc420 = (RDPGFX_AVC420_BITMAP_STREAM*)cmd->extra;
			error = rdpgfx_write_h264_avc420(s, havc420);
 
			if (error != CHANNEL_RC_OK)
			{
				WLog_ERR(TAG, "rdpgfx_write_h264_avc420 failed!");
				return error;
			}
		}
		else if ((cmd->codecId == RDPGFX_CODECID_AVC444) ||
		         (cmd->codecId == RDPGFX_CODECID_AVC444v2))
		{

			havc444 = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;
			havc420 = &(havc444->bitstream[0]); /* avc420EncodedBitstreamInfo (4 bytes) */

			Stream_Write_UINT32(s, havc444->cbAvc420EncodedBitstream1 | (havc444->LC << 30UL));

			/* avc420EncodedBitstream1 */
			error = rdpgfx_write_h264_avc420(s, havc420);
写入第一个子帧avc420EncodedBitstream1：主视图(YUV420)
			if (error != CHANNEL_RC_OK)
			{
				WLog_ERR(TAG, "rdpgfx_write_h264_avc420 failed!");
				return error;
			}
 
			/* avc420EncodedBitstream2 */
			if (havc444->LC == 0)
			{
				havc420 = &(havc444->bitstream[1]);
				error = rdpgfx_write_h264_avc420(s, havc420);
写入第二个子帧avc420EncodedBitstream2：次视图(Chroma420)
				if (error != CHANNEL_RC_OK)
				{
					WLog_ERR(TAG, "rdpgfx_write_h264_avc420 failed!");
					return error;
				}
			}
		}
		else
		{
			Stream_Write(s, cmd->data, cmd->length);
		}
 
		/* Fill actual bitmap data length */
		bitmapDataLength = Stream_GetPosition(s) - bitmapDataStart;
		Stream_SetPosition(s, bitmapDataStart - sizeof(UINT32));
		Stream_Write_UINT32(s, bitmapDataLength); /* bitmapDataLength (4 bytes) */
		Stream_Seek(s, bitmapDataLength);

	}
 
	return error;
}

static INLINE UINT rdpgfx_write_h264_avc420(wStream* s, RDPGFX_AVC420_BITMAP_STREAM* havc420)
{
	UINT error = CHANNEL_RC_OK;
	if ((error = rdpgfx_write_h264_metablock(s, &(havc420->meta))))
	{
		WLog_ERR(TAG, "rdpgfx_write_h264_metablock failed with error %" PRIu32 "!", error);
		return error;
	}

	if (!Stream_EnsureRemainingCapacity(s, havc420->length))
		return ERROR_OUTOFMEMORY;
 
	Stream_Write(s, havc420->data, havc420->length);

	return error;
}

static UINT rdpgfx_server_packet_send(RdpgfxServerContext* context, wStream* s)
{
	UINT error;
	UINT32 flags = 0;
	ULONG written;
	BYTE* pSrcData = Stream_Buffer(s);
	UINT32 SrcSize = Stream_GetPosition(s);
	wStream* fs;
	/* Allocate new stream with enough capacity. Additional overhead is
	 * descriptor (1 bytes) + segmentCount (2 bytes) + uncompressedSize (4 bytes)
	 * + segmentCount * size (4 bytes) */
	fs = Stream_New(NULL, SrcSize + 7 + (SrcSize / ZGFX_SEGMENTED_MAXSIZE + 1) * 4);

	if (!fs)
	{
		WLog_ERR(TAG, "Stream_New failed!");
		error = CHANNEL_RC_NO_MEMORY;
		goto out;
	}
 
	if (zgfx_compress_to_stream(context->priv->zgfx, fs, pSrcData, SrcSize, &flags) < 0)
	{
		WLog_ERR(TAG, "zgfx_compress_to_stream failed!");
		error = ERROR_INTERNAL_ERROR;
		goto out;
	}

	if (!WTSVirtualChannelWrite(context->priv->rdpgfx_channel, (PCHAR)Stream_Buffer(fs),
	                            Stream_GetPosition(fs), &written))
	{
		WLog_ERR(TAG, "WTSVirtualChannelWrite failed!");
		error = ERROR_INTERNAL_ERROR;
		goto out;
	}

	if (written < Stream_GetPosition(fs))
	{
		WLog_WARN(TAG, "Unexpected bytes written: %" PRIu32 "/%" PRIuz "", written,
		          Stream_GetPosition(fs));
	}
 
	error = CHANNEL_RC_OK;
out:
	Stream_Free(fs, TRUE);
	Stream_Free(s, TRUE);
	return error;
}

int zgfx_compress_to_stream(ZGFX_CONTEXT* zgfx, wStream* sDst, const BYTE* pUncompressed,
                            UINT32 uncompressedSize, UINT32* pFlags)
{
	int fragment;
	UINT16 maxLength;
	UINT32 totalLength;
	size_t posSegmentCount = 0;
	const BYTE* pSrcData;
	int status = 0;
	maxLength = ZGFX_SEGMENTED_MAXSIZE;
	totalLength = uncompressedSize;
	pSrcData = pUncompressed;
 
	for (fragment = 0; (totalLength > 0) || (fragment == 0); fragment++)
	{
		UINT32 SrcSize;
		size_t posDstSize;
		size_t posDataStart;
		UINT32 DstSize;
		SrcSize = (totalLength > maxLength) ? maxLength : totalLength;
		posDstSize = 0;
		totalLength -= SrcSize;
 
		/* Ensure we have enough space for headers */
		if (!Stream_EnsureRemainingCapacity(sDst, 12))
		{
			WLog_ERR(TAG, "Stream_EnsureRemainingCapacity failed!");
			return -1;
		}
SEGMENTED负载语法在“[MS-RDPEGFX] 2.2.5.1 RDP_SEGMENTED_DATA”。
		if (fragment == 0)
		{
			/* First fragment */
			/* descriptor (1 byte) */
			Stream_Write_UINT8(sDst, (totalLength == 0) ? ZGFX_SEGMENTED_SINGLE
			                                            : ZGFX_SEGMENTED_MULTIPART);
这是第一分段，totalLength == 0意味着此次3pdu负载一个分段就够了。
			if (totalLength > 0)
			{
				posSegmentCount = Stream_GetPosition(sDst); /* segmentCount (2 bytes) */
				Stream_Seek(sDst, 2);
				Stream_Write_UINT32(sDst, uncompressedSize); /* uncompressedSize (4 bytes) */

			}
		}
 
		if (fragment > 0 || totalLength > 0)
		{
			/* Multipart */
			posDstSize = Stream_GetPosition(sDst); /* size (4 bytes) */
			Stream_Seek(sDst, 4);

		}
 
		posDataStart = Stream_GetPosition(sDst);
 
		if (!zgfx_compress_segment(zgfx, sDst, pSrcData, SrcSize, pFlags))
			return -1;

		if (posDstSize)
		{
			/* Fill segment data size */
			DstSize = Stream_GetPosition(sDst) - posDataStart;
			Stream_SetPosition(sDst, posDstSize);
			Stream_Write_UINT32(sDst, DstSize);
			Stream_SetPosition(sDst, posDataStart + DstSize);

		}
		pSrcData += SrcSize;
	}
	Stream_SealLength(sDst);
	/* fill back segmentCount */
	if (posSegmentCount)
	{
		Stream_SetPosition(sDst, posSegmentCount);
		Stream_Write_UINT16(sDst, fragment);
		Stream_SetPosition(sDst, Stream_Length(sDst));
	}
	return status;
}

BOOL WINAPI FreeRDP_WTSVirtualChannelWrite(HANDLE hChannelHandle, PCHAR Buffer, ULONG Length,
                                 PULONG pBytesWritten)
{
	wStream* s;
	int cbLen;
	int cbChId;
	int first;
	BYTE* buffer;
	UINT32 length;
	UINT32 written;
	UINT32 totalWritten = 0;
	rdpPeerChannel* channel = (rdpPeerChannel*)hChannelHandle;
	BOOL ret = TRUE;
 
	...
	{
		first = TRUE;
 
		while (Length > 0)
		{
			s = Stream_New(NULL, channel->client->settings->VirtualChannelChunkSize);

			if (!s)
			{
				WLog_ERR(TAG, "Stream_New failed!");
				SetLastError(E_OUTOFMEMORY);
				return FALSE;
			}

			buffer = Stream_Buffer(s);
			Stream_Seek_UINT8(s);
			cbChId = wts_write_variable_uint(s, channel->channelId);
 
			if (first && (Length > (UINT32)Stream_GetRemainingLength(s)))
			{
				cbLen = wts_write_variable_uint(s, Length);
				buffer[0] = (DATA_FIRST_PDU << 4) | (cbLen << 2) | cbChId;

			}
			else
			{
				buffer[0] = (DATA_PDU << 4) | cbChId;
			}
 
			first = FALSE;
			written = Stream_GetRemainingLength(s);
 
			if (written > Length)
				written = Length;
 
			Stream_Write(s, Buffer, written);
written是此次取出的SEGMENTED负载长度，因为有DVC消息头，它略小于1600。
			length = Stream_GetPosition(s);
			Stream_Free(s, FALSE);
Stream_Free第二个参数是FALSE，表示只释放wStream这个struct，不释放当中的buffer。
			Length -= written;
			Buffer += written;
			totalWritten += written;
			ret = wts_queue_send_item(channel->vcm->drdynvc_channel, buffer, length);
把此次written字节数的SEGMENTED负载投递到drdynvc_channel的队列。
		}
	}
 
	if (pBytesWritten)
		*pBytesWritten = totalWritten;
要是不出错，pBytesWritten值应该等于此次要发送的SEGMENTED负载字节数Length。
 
	return ret;
}
 
static BOOL wts_queue_send_item(rdpPeerChannel* channel, BYTE* Buffer, UINT32 Length)
{
	BYTE* buffer;
	UINT32 length;
	UINT16 channelId;
	buffer = Buffer;
	length = Length;
	channelId = channel->channelId;
	return MessageQueue_Post(channel->vcm->queue, (void*)(UINT_PTR)channelId, 0, (void*)buffer,
	                         (void*)(UINT_PTR)length);
}

static DWORD WINAPI shadow_client_thread(LPVOID arg) {
  ...
  ChannelEvent = WTSVirtualChannelManagerGetEventHandle(client->vcm);
  while (1) {
    if (WaitForSingleObject(ChannelEvent, 0) == WAIT_OBJECT_0)
    {
      if (!WTSVirtualChannelManagerCheckFileDescriptor(client->vcm))
      {
        WLog_ERR(TAG, "WTSVirtualChannelManagerCheckFileDescriptor failure");
        goto fail;
      }
    }
    ...
  }
}

return RDPGFX_WIRE_TO_SURFACE_PDU_1_SIZE + cmd->length;

<freerdp>/server/shadow/shadow_client.c
static INLINE UINT32 rdpgfx_estimate_bitmapdata_avc444v2(RDPGFX_SURFACE_COMMAND* cmd)
{
	RDPGFX_AVC420_BITMAP_STREAM* havc420 = NULL;
	RDPGFX_AVC444_BITMAP_STREAM* havc444 = NULL;
	UINT32 h264Size = 0;
 
	if (cmd->codecId == RDPGFX_CODECID_AVC444v2) {
		havc444 = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;
		h264Size = sizeof(UINT32); /* cbAvc420EncodedBitstream1 */
		/* avc420EncodedBitstream1 */
		havc420 = &(havc444->bitstream[0]);
		h264Size += rdpgfx_estimate_h264_avc420(havc420);
 
		/* avc420EncodedBitstream2 */
		if (havc444->LC == 0)
		{
			havc420 = &(havc444->bitstream[1]);
			h264Size += rdpgfx_estimate_h264_avc420(havc420);
		}
	}
	return h264Size;
}
static BOOL shadow_client_send_surface_gfx(...)
{
	...
	if (settings->GfxAVC444 || settings->GfxAVC444v2) {
		cmd.extra = (void*)&avc444;
		cmd.length = rdpgfx_estimate_bitmapdata_avc444v2(&cmd);
		...
	}
	...
}

因为cmd->length=0，rdpgfx_send_surface_command内变量size=53，即s->capability = 53。
  41字节。start_frame+SURFACE_PDU_1除bitmapData外的字节数。
+ 18字节。4字节cbAvc420EncodedBitstream1 + (4字节矩形数 + numRegionRects*10)。其中numRegionRects=1。
+ 40字节。bitstream[0].length。由于53不够存了，此步骤s->capability被加大一倍到106。
+ 12字节。end_frame。之前累计99字节，加上12字节就超过106了，而写end_frame时不会调用Stream_EnsureRemainingCapacity。

static UINT rdpgfx_server_packet_send(RdpgfxServerContext* context, wStream* s) {
  fs = Stream_New(NULL, SrcSize + 7 + (SrcSize / ZGFX_SEGMENTED_MAXSIZE + 1) * 4);
改为
  fs = Stream_New(NULL, SrcSize + 7 + (SrcSize / ZGFX_SEGMENTED_MAXSIZE + 1) * 5);
}