mirror of https://github.com/FreeRDP/FreeRDP
Merge pull request #2033 from awakecoding/master
RLGR, Progressive, RDP8.1 H264, MS-RDPEDISP
This commit is contained in:
Marc-André Moreau
commit
2f6575a7e6
|
|
@ -66,8 +66,8 @@ struct _DISP_PLUGIN
|
|||
DISP_LISTENER_CALLBACK* listener_callback;
|
||||
|
||||
UINT32 MaxNumMonitors;
|
||||
UINT32 MaxMonitorWidth;
|
||||
UINT32 MaxMonitorHeight;
|
||||
UINT32 MaxMonitorAreaFactorA;
|
||||
UINT32 MaxMonitorAreaFactorB;
|
||||
};
|
||||
typedef struct _DISP_PLUGIN DISP_PLUGIN;
|
||||
|
||||
|
|
@ -110,15 +110,9 @@ int disp_send_display_control_monitor_layout_pdu(DISP_CHANNEL_CALLBACK* callback
|
|||
if (Monitors[index].Width < 200)
|
||||
Monitors[index].Width = 200;
|
||||
|
||||
if (Monitors[index].Width > disp->MaxMonitorWidth)
|
||||
Monitors[index].Width = disp->MaxMonitorWidth;
|
||||
|
||||
if (Monitors[index].Height < 200)
|
||||
Monitors[index].Height = 200;
|
||||
|
||||
if (Monitors[index].Height > disp->MaxMonitorHeight)
|
||||
Monitors[index].Height = disp->MaxMonitorHeight;
|
||||
|
||||
Stream_Write_UINT32(s, Monitors[index].Flags); /* Flags (4 bytes) */
|
||||
Stream_Write_UINT32(s, Monitors[index].Left); /* Left (4 bytes) */
|
||||
Stream_Write_UINT32(s, Monitors[index].Top); /* Top (4 bytes) */
|
||||
|
|
@ -127,6 +121,8 @@ int disp_send_display_control_monitor_layout_pdu(DISP_CHANNEL_CALLBACK* callback
|
|||
Stream_Write_UINT32(s, Monitors[index].PhysicalWidth); /* PhysicalWidth (4 bytes) */
|
||||
Stream_Write_UINT32(s, Monitors[index].PhysicalHeight); /* PhysicalHeight (4 bytes) */
|
||||
Stream_Write_UINT32(s, Monitors[index].Orientation); /* Orientation (4 bytes) */
|
||||
Stream_Write_UINT32(s, Monitors[index].DesktopScaleFactor); /* DesktopScaleFactor (4 bytes) */
|
||||
Stream_Write_UINT32(s, Monitors[index].DeviceScaleFactor); /* DeviceScaleFactor (4 bytes) */
|
||||
|
||||
#if 0
|
||||
CLOG_ERR( "\t: Flags: 0x%04X\n", Monitors[index].Flags);
|
||||
|
|
@ -138,9 +134,6 @@ int disp_send_display_control_monitor_layout_pdu(DISP_CHANNEL_CALLBACK* callback
|
|||
CLOG_ERR( "\t: PhysicalHeight: %d\n", Monitors[index].PhysicalHeight);
|
||||
CLOG_ERR( "\t: Orientation: %d\n", Monitors[index].Orientation);
|
||||
#endif
|
||||
|
||||
Stream_Write_UINT32(s, Monitors[index].DesktopScaleFactor); /* DesktopScaleFactor (4 bytes) */
|
||||
Stream_Write_UINT32(s, Monitors[index].DeviceScaleFactor); /* DeviceScaleFactor (4 bytes) */
|
||||
}
|
||||
|
||||
Stream_SealLength(s);
|
||||
|
|
@ -158,9 +151,12 @@ int disp_recv_display_control_caps_pdu(DISP_CHANNEL_CALLBACK* callback, wStream*
|
|||
|
||||
disp = (DISP_PLUGIN*) callback->plugin;
|
||||
|
||||
if (Stream_GetRemainingLength(s) < 12)
|
||||
return -1;
|
||||
|
||||
Stream_Read_UINT32(s, disp->MaxNumMonitors); /* MaxNumMonitors (4 bytes) */
|
||||
Stream_Read_UINT32(s, disp->MaxMonitorWidth); /* MaxMonitorWidth (4 bytes) */
|
||||
Stream_Read_UINT32(s, disp->MaxMonitorHeight); /* MaxMonitorHeight (4 bytes) */
|
||||
Stream_Read_UINT32(s, disp->MaxMonitorAreaFactorA); /* MaxMonitorAreaFactorA (4 bytes) */
|
||||
Stream_Read_UINT32(s, disp->MaxMonitorAreaFactorB); /* MaxMonitorAreaFactorB (4 bytes) */
|
||||
|
||||
//CLOG_ERR( "DisplayControlCapsPdu: MaxNumMonitors: %d MaxMonitorWidth: %d MaxMonitorHeight: %d\n",
|
||||
// disp->MaxNumMonitors, disp->MaxMonitorWidth, disp->MaxMonitorHeight);
|
||||
|
|
@ -173,6 +169,9 @@ int disp_recv_pdu(DISP_CHANNEL_CALLBACK* callback, wStream* s)
|
|||
UINT32 type;
|
||||
UINT32 length;
|
||||
|
||||
if (Stream_GetRemainingLength(s) < 8)
|
||||
return -1;
|
||||
|
||||
Stream_Read_UINT32(s, type); /* Type (4 bytes) */
|
||||
Stream_Read_UINT32(s, length); /* Length (4 bytes) */
|
||||
|
||||
|
|
@ -220,8 +219,10 @@ static int disp_on_new_channel_connection(IWTSListenerCallback* pListenerCallbac
|
|||
DISP_CHANNEL_CALLBACK* callback;
|
||||
DISP_LISTENER_CALLBACK* listener_callback = (DISP_LISTENER_CALLBACK*) pListenerCallback;
|
||||
|
||||
callback = (DISP_CHANNEL_CALLBACK*) malloc(sizeof(DISP_CHANNEL_CALLBACK));
|
||||
ZeroMemory(callback, sizeof(DISP_CHANNEL_CALLBACK));
|
||||
callback = (DISP_CHANNEL_CALLBACK*) calloc(1, sizeof(DISP_CHANNEL_CALLBACK));
|
||||
|
||||
if (!callback)
|
||||
return -1;
|
||||
|
||||
callback->iface.OnDataReceived = disp_on_data_received;
|
||||
callback->iface.OnClose = disp_on_close;
|
||||
|
|
@ -240,8 +241,10 @@ static int disp_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManager
|
|||
int status;
|
||||
DISP_PLUGIN* disp = (DISP_PLUGIN*) pPlugin;
|
||||
|
||||
disp->listener_callback = (DISP_LISTENER_CALLBACK*) malloc(sizeof(DISP_LISTENER_CALLBACK));
|
||||
ZeroMemory(disp->listener_callback, sizeof(DISP_LISTENER_CALLBACK));
|
||||
disp->listener_callback = (DISP_LISTENER_CALLBACK*) calloc(1, sizeof(DISP_LISTENER_CALLBACK));
|
||||
|
||||
if (!disp->listener_callback)
|
||||
return -1;
|
||||
|
||||
disp->listener_callback->iface.OnNewChannelConnection = disp_on_new_channel_connection;
|
||||
disp->listener_callback->plugin = pPlugin;
|
||||
|
|
@ -281,11 +284,7 @@ int disp_send_monitor_layout(DispClientContext* context, UINT32 NumMonitors, DIS
|
|||
return 1;
|
||||
}
|
||||
|
||||
#ifdef STATIC_CHANNELS
|
||||
#define DVCPluginEntry disp_DVCPluginEntry
|
||||
#endif
|
||||
|
||||
int DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
|
||||
int disp_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
|
||||
{
|
||||
int error = 0;
|
||||
DISP_PLUGIN* disp;
|
||||
|
|
@ -317,8 +316,8 @@ int DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
|
|||
disp->iface.pInterface = (void*) context;
|
||||
|
||||
disp->MaxNumMonitors = 16;
|
||||
disp->MaxMonitorWidth = 8192;
|
||||
disp->MaxMonitorHeight = 8192;
|
||||
disp->MaxMonitorAreaFactorA = 8192;
|
||||
disp->MaxMonitorAreaFactorB = 8192;
|
||||
|
||||
error = pEntryPoints->RegisterPlugin(pEntryPoints, "disp", (IWTSPlugin*) disp);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,8 +31,8 @@
|
|||
|
||||
#include <freerdp/client/disp.h>
|
||||
|
||||
#define DISPLAY_CONTROL_PDU_TYPE_CAPS 0x00000005
|
||||
#define DISPLAY_CONTROL_PDU_TYPE_MONITOR_LAYOUT 0x00000002
|
||||
#define DISPLAY_CONTROL_PDU_TYPE_CAPS 0x00000003
|
||||
|
||||
#endif /* FREERDP_CHANNEL_DISP_CLIENT_MAIN_H */
|
||||
|
||||
|
|
|
|||
|
|
@ -26,12 +26,11 @@
|
|||
#include <string.h>
|
||||
|
||||
#include <winpr/crt.h>
|
||||
#include <winpr/stream.h>
|
||||
#include <winpr/cmdline.h>
|
||||
|
||||
#include <freerdp/addin.h>
|
||||
|
||||
#include <winpr/stream.h>
|
||||
|
||||
#include "echo_main.h"
|
||||
|
||||
typedef struct _ECHO_LISTENER_CALLBACK ECHO_LISTENER_CALLBACK;
|
||||
|
|
@ -63,47 +62,21 @@ struct _ECHO_PLUGIN
|
|||
|
||||
static int echo_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, wStream *data)
|
||||
{
|
||||
int error;
|
||||
int status;
|
||||
ECHO_CHANNEL_CALLBACK* callback = (ECHO_CHANNEL_CALLBACK*) pChannelCallback;
|
||||
BYTE *pBuffer = Stream_Pointer(data);
|
||||
UINT32 cbSize = Stream_GetRemainingLength(data);
|
||||
|
||||
#ifdef WITH_DEBUG_DVC
|
||||
int i = 0;
|
||||
char* debug_buffer;
|
||||
char* p;
|
||||
|
||||
if (cbSize > 0)
|
||||
{
|
||||
debug_buffer = (char*) malloc(3 * cbSize);
|
||||
ZeroMemory(debug_buffer, 3 * cbSize);
|
||||
|
||||
p = debug_buffer;
|
||||
|
||||
for (i = 0; i < (int) (cbSize - 1); i++)
|
||||
{
|
||||
sprintf(p, "%02x ", pBuffer[i]);
|
||||
p += 3;
|
||||
}
|
||||
sprintf(p, "%02x", pBuffer[i]);
|
||||
|
||||
DEBUG_DVC("ECHO %d: %s", cbSize, debug_buffer);
|
||||
free(debug_buffer);
|
||||
}
|
||||
#endif
|
||||
BYTE* pBuffer = Stream_Pointer(data);
|
||||
UINT32 cbSize = Stream_GetRemainingLength(data);
|
||||
|
||||
/* echo back what we have received. ECHO does not have any message IDs. */
|
||||
error = callback->channel->Write(callback->channel, cbSize, pBuffer, NULL);
|
||||
status = callback->channel->Write(callback->channel, cbSize, pBuffer, NULL);
|
||||
|
||||
return error;
|
||||
return status;
|
||||
}
|
||||
|
||||
static int echo_on_close(IWTSVirtualChannelCallback* pChannelCallback)
|
||||
{
|
||||
ECHO_CHANNEL_CALLBACK* callback = (ECHO_CHANNEL_CALLBACK*) pChannelCallback;
|
||||
|
||||
DEBUG_DVC("");
|
||||
|
||||
free(callback);
|
||||
|
||||
return 0;
|
||||
|
|
@ -116,10 +89,10 @@ static int echo_on_new_channel_connection(IWTSListenerCallback* pListenerCallbac
|
|||
ECHO_CHANNEL_CALLBACK* callback;
|
||||
ECHO_LISTENER_CALLBACK* listener_callback = (ECHO_LISTENER_CALLBACK*) pListenerCallback;
|
||||
|
||||
DEBUG_DVC("");
|
||||
callback = (ECHO_CHANNEL_CALLBACK*) calloc(1, sizeof(ECHO_CHANNEL_CALLBACK));
|
||||
|
||||
callback = (ECHO_CHANNEL_CALLBACK*) malloc(sizeof(ECHO_CHANNEL_CALLBACK));
|
||||
ZeroMemory(callback, sizeof(ECHO_CHANNEL_CALLBACK));
|
||||
if (!callback)
|
||||
return -1;
|
||||
|
||||
callback->iface.OnDataReceived = echo_on_data_received;
|
||||
callback->iface.OnClose = echo_on_close;
|
||||
|
|
@ -136,10 +109,10 @@ static int echo_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManager
|
|||
{
|
||||
ECHO_PLUGIN* echo = (ECHO_PLUGIN*) pPlugin;
|
||||
|
||||
DEBUG_DVC("");
|
||||
echo->listener_callback = (ECHO_LISTENER_CALLBACK*) calloc(1, sizeof(ECHO_LISTENER_CALLBACK));
|
||||
|
||||
echo->listener_callback = (ECHO_LISTENER_CALLBACK*) malloc(sizeof(ECHO_LISTENER_CALLBACK));
|
||||
ZeroMemory(echo->listener_callback, sizeof(ECHO_LISTENER_CALLBACK));
|
||||
if (!echo->listener_callback)
|
||||
return -1;
|
||||
|
||||
echo->listener_callback->iface.OnNewChannelConnection = echo_on_new_channel_connection;
|
||||
echo->listener_callback->plugin = pPlugin;
|
||||
|
|
@ -153,36 +126,35 @@ static int echo_plugin_terminated(IWTSPlugin* pPlugin)
|
|||
{
|
||||
ECHO_PLUGIN* echo = (ECHO_PLUGIN*) pPlugin;
|
||||
|
||||
DEBUG_DVC("");
|
||||
|
||||
free(echo);
|
||||
if (echo)
|
||||
{
|
||||
free(echo);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef STATIC_CHANNELS
|
||||
#define DVCPluginEntry echo_DVCPluginEntry
|
||||
#endif
|
||||
|
||||
int DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
|
||||
int echo_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
|
||||
{
|
||||
int error = 0;
|
||||
int status = 0;
|
||||
ECHO_PLUGIN* echo;
|
||||
|
||||
echo = (ECHO_PLUGIN*) pEntryPoints->GetPlugin(pEntryPoints, "echo");
|
||||
|
||||
if (echo == NULL)
|
||||
if (!echo)
|
||||
{
|
||||
echo = (ECHO_PLUGIN*) malloc(sizeof(ECHO_PLUGIN));
|
||||
ZeroMemory(echo, sizeof(ECHO_PLUGIN));
|
||||
echo = (ECHO_PLUGIN*) calloc(1, sizeof(ECHO_PLUGIN));
|
||||
|
||||
if (!echo)
|
||||
return -1;
|
||||
|
||||
echo->iface.Initialize = echo_plugin_initialize;
|
||||
echo->iface.Connected = NULL;
|
||||
echo->iface.Disconnected = NULL;
|
||||
echo->iface.Terminated = echo_plugin_terminated;
|
||||
|
||||
error = pEntryPoints->RegisterPlugin(pEntryPoints, "echo", (IWTSPlugin*) echo);
|
||||
status = pEntryPoints->RegisterPlugin(pEntryPoints, "echo", (IWTSPlugin*) echo);
|
||||
}
|
||||
|
||||
return error;
|
||||
return status;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -91,7 +91,7 @@ int encomsp_read_unicode_string(wStream* s, ENCOMSP_UNICODE_STRING* str)
|
|||
if (str->cchString > 1024)
|
||||
return -1;
|
||||
|
||||
if (Stream_GetRemainingLength(s) < (str->cchString * 2))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) (str->cchString * 2))
|
||||
return -1;
|
||||
|
||||
Stream_Read(s, &(str->wString), (str->cchString * 2)); /* String (variable) */
|
||||
|
|
@ -126,7 +126,7 @@ int encomsp_recv_filter_updated_pdu(encomspPlugin* encomsp, wStream* s, ENCOMSP_
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
@ -171,7 +171,7 @@ int encomsp_recv_application_created_pdu(encomspPlugin* encomsp, wStream* s, ENC
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
@ -212,7 +212,7 @@ int encomsp_recv_application_removed_pdu(encomspPlugin* encomsp, wStream* s, ENC
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
@ -258,7 +258,7 @@ int encomsp_recv_window_created_pdu(encomspPlugin* encomsp, wStream* s, ENCOMSP_
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
@ -299,7 +299,7 @@ int encomsp_recv_window_removed_pdu(encomspPlugin* encomsp, wStream* s, ENCOMSP_
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
@ -340,7 +340,7 @@ int encomsp_recv_show_window_pdu(encomspPlugin* encomsp, wStream* s, ENCOMSP_ORD
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
@ -386,7 +386,7 @@ int encomsp_recv_participant_created_pdu(encomspPlugin* encomsp, wStream* s, ENC
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
@ -429,7 +429,7 @@ int encomsp_recv_participant_removed_pdu(encomspPlugin* encomsp, wStream* s, ENC
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
@ -471,7 +471,7 @@ int encomsp_recv_change_participant_control_level_pdu(encomspPlugin* encomsp, wS
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
@ -531,7 +531,7 @@ int encomsp_recv_graphics_stream_paused_pdu(encomspPlugin* encomsp, wStream* s,
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
@ -567,7 +567,7 @@ int encomsp_recv_graphics_stream_resumed_pdu(encomspPlugin* encomsp, wStream* s,
|
|||
|
||||
if ((beg + header->Length) > end)
|
||||
{
|
||||
if (Stream_GetRemainingLength(s) < ((beg + header->Length) - end))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) ((beg + header->Length) - end))
|
||||
return -1;
|
||||
|
||||
Stream_SetPosition(s, (beg + header->Length));
|
||||
|
|
|
|||
|
|
@ -24,6 +24,8 @@
|
|||
#include <winpr/crt.h>
|
||||
#include <winpr/stream.h>
|
||||
|
||||
#include "rdpgfx_common.h"
|
||||
|
||||
#include "rdpgfx_codec.h"
|
||||
|
||||
int rdpgfx_decode_uncompressed(RDPGFX_PLUGIN* gfx, RDPGFX_SURFACE_COMMAND* cmd)
|
||||
|
|
@ -46,8 +48,93 @@ int rdpgfx_decode_planar(RDPGFX_PLUGIN* gfx, RDPGFX_SURFACE_COMMAND* cmd)
|
|||
return 1;
|
||||
}
|
||||
|
||||
int rdpgfx_read_h264_metablock(RDPGFX_PLUGIN* gfx, wStream* s, RDPGFX_H264_METABLOCK* meta)
|
||||
{
|
||||
UINT32 index;
|
||||
RDPGFX_RECT16* regionRect;
|
||||
RDPGFX_H264_QUANT_QUALITY* quantQualityVal;
|
||||
|
||||
if (Stream_GetRemainingLength(s) < 4)
|
||||
return -1;
|
||||
|
||||
Stream_Read_UINT32(s, meta->numRegionRects); /* numRegionRects (4 bytes) */
|
||||
|
||||
if (Stream_GetRemainingLength(s) < (meta->numRegionRects * 8))
|
||||
return -1;
|
||||
|
||||
meta->regionRects = (RDPGFX_RECT16*) malloc(meta->numRegionRects * sizeof(RDPGFX_RECT16));
|
||||
|
||||
if (!meta->regionRects)
|
||||
return -1;
|
||||
|
||||
meta->quantQualityVals = (RDPGFX_H264_QUANT_QUALITY*) malloc(meta->numRegionRects * sizeof(RDPGFX_H264_QUANT_QUALITY));
|
||||
|
||||
if (!meta->quantQualityVals)
|
||||
return -1;
|
||||
|
||||
printf("H264_METABLOCK: numRegionRects: %d\n", (int) meta->numRegionRects);
|
||||
|
||||
for (index = 0; index < meta->numRegionRects; index++)
|
||||
{
|
||||
regionRect = &(meta->regionRects[index]);
|
||||
rdpgfx_read_rect16(s, regionRect);
|
||||
|
||||
printf("regionRects[%d]: left: %d top: %d right: %d bottom: %d\n",
|
||||
index, regionRect->left, regionRect->top, regionRect->right, regionRect->bottom);
|
||||
}
|
||||
|
||||
if (Stream_GetRemainingLength(s) < (meta->numRegionRects * 2))
|
||||
return -1;
|
||||
|
||||
for (index = 0; index < meta->numRegionRects; index++)
|
||||
{
|
||||
quantQualityVal = &(meta->quantQualityVals[index]);
|
||||
Stream_Read_UINT8(s, quantQualityVal->qpVal); /* qpVal (1 byte) */
|
||||
Stream_Read_UINT8(s, quantQualityVal->qualityVal); /* qualityVal (1 byte) */
|
||||
|
||||
quantQualityVal->qp = quantQualityVal->qpVal & 0x3F;
|
||||
quantQualityVal->r = (quantQualityVal->qpVal >> 6) & 1;
|
||||
quantQualityVal->p = (quantQualityVal->qpVal >> 7) & 1;
|
||||
|
||||
printf("quantQualityVals[%d]: qp: %d r: %d p: %d qualityVal: %d\n",
|
||||
index, quantQualityVal->qp, quantQualityVal->r, quantQualityVal->p, quantQualityVal->qualityVal);
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int rdpgfx_decode_h264(RDPGFX_PLUGIN* gfx, RDPGFX_SURFACE_COMMAND* cmd)
|
||||
{
|
||||
int status;
|
||||
wStream* s;
|
||||
RDPGFX_H264_BITMAP_STREAM h264;
|
||||
RdpgfxClientContext* context = (RdpgfxClientContext*) gfx->iface.pInterface;
|
||||
|
||||
s = Stream_New(cmd->data, cmd->length);
|
||||
|
||||
if (!s)
|
||||
return -1;
|
||||
|
||||
status = rdpgfx_read_h264_metablock(gfx, s, &(h264.meta));
|
||||
|
||||
if (status < 0)
|
||||
return -1;
|
||||
|
||||
h264.data = Stream_Pointer(s);
|
||||
h264.length = (UINT32) Stream_GetRemainingLength(s);
|
||||
|
||||
Stream_Free(s, FALSE);
|
||||
|
||||
cmd->extra = (void*) &h264;
|
||||
|
||||
if (context && context->SurfaceCommand)
|
||||
{
|
||||
context->SurfaceCommand(context, cmd);
|
||||
}
|
||||
|
||||
free(h264.meta.regionRects);
|
||||
free(h264.meta.quantQualityVals);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -203,7 +203,7 @@ int rdpgfx_recv_reset_graphics_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream* s
|
|||
|
||||
pad = 340 - (RDPGFX_HEADER_SIZE + 12 + (pdu.monitorCount * 20));
|
||||
|
||||
if (Stream_GetRemainingLength(s) < pad)
|
||||
if (Stream_GetRemainingLength(s) < (size_t) pad)
|
||||
return -1;
|
||||
|
||||
Stream_Seek(s, pad); /* pad (total size is 340 bytes) */
|
||||
|
|
@ -254,7 +254,7 @@ int rdpgfx_recv_cache_import_reply_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStrea
|
|||
|
||||
Stream_Read_UINT16(s, pdu.importedEntriesCount); /* cacheSlot (2 bytes) */
|
||||
|
||||
if (Stream_GetRemainingLength(s) < (pdu.importedEntriesCount * 2))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) (pdu.importedEntriesCount * 2))
|
||||
return -1;
|
||||
|
||||
pdu.cacheSlots = (UINT16*) calloc(pdu.importedEntriesCount, sizeof(UINT16));
|
||||
|
|
@ -427,9 +427,16 @@ int rdpgfx_recv_wire_to_surface_1_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream
|
|||
cmd.length = pdu.bitmapDataLength;
|
||||
cmd.data = pdu.bitmapData;
|
||||
|
||||
if (context && context->SurfaceCommand)
|
||||
if (cmd.codecId == RDPGFX_CODECID_H264)
|
||||
{
|
||||
context->SurfaceCommand(context, &cmd);
|
||||
rdpgfx_decode(gfx, &cmd);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (context && context->SurfaceCommand)
|
||||
{
|
||||
context->SurfaceCommand(context, &cmd);
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
|
|
@ -518,7 +525,7 @@ int rdpgfx_recv_solid_fill_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream* s)
|
|||
rdpgfx_read_color32(s, &(pdu.fillPixel)); /* fillPixel (4 bytes) */
|
||||
Stream_Read_UINT16(s, pdu.fillRectCount); /* fillRectCount (2 bytes) */
|
||||
|
||||
if (Stream_GetRemainingLength(s) < (pdu.fillRectCount * 8))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) (pdu.fillRectCount * 8))
|
||||
return -1;
|
||||
|
||||
pdu.fillRects = (RDPGFX_RECT16*) calloc(pdu.fillRectCount, sizeof(RDPGFX_RECT16));
|
||||
|
|
@ -559,7 +566,7 @@ int rdpgfx_recv_surface_to_surface_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStrea
|
|||
rdpgfx_read_rect16(s, &(pdu.rectSrc)); /* rectSrc (8 bytes ) */
|
||||
Stream_Read_UINT16(s, pdu.destPtsCount); /* destPtsCount (2 bytes) */
|
||||
|
||||
if (Stream_GetRemainingLength(s) < (pdu.destPtsCount * 4))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) (pdu.destPtsCount * 4))
|
||||
return -1;
|
||||
|
||||
pdu.destPts = (RDPGFX_POINT16*) calloc(pdu.destPtsCount, sizeof(RDPGFX_POINT16));
|
||||
|
|
@ -630,7 +637,7 @@ int rdpgfx_recv_cache_to_surface_pdu(RDPGFX_CHANNEL_CALLBACK* callback, wStream*
|
|||
Stream_Read_UINT16(s, pdu.surfaceId); /* surfaceId (2 bytes) */
|
||||
Stream_Read_UINT16(s, pdu.destPtsCount); /* destPtsCount (2 bytes) */
|
||||
|
||||
if (Stream_GetRemainingLength(s) < (pdu.destPtsCount * 4))
|
||||
if (Stream_GetRemainingLength(s) < (size_t) (pdu.destPtsCount * 4))
|
||||
return -1;
|
||||
|
||||
pdu.destPts = (RDPGFX_POINT16*) calloc(pdu.destPtsCount, sizeof(RDPGFX_POINT16));
|
||||
|
|
@ -840,7 +847,7 @@ static int rdpgfx_on_data_received(IWTSVirtualChannelCallback* pChannelCallback,
|
|||
|
||||
s = Stream_New(pDstData, DstSize);
|
||||
|
||||
while (Stream_GetPosition(s) < Stream_Length(s))
|
||||
while (((size_t) Stream_GetPosition(s)) < Stream_Length(s))
|
||||
{
|
||||
status = rdpgfx_recv_pdu(callback, s);
|
||||
|
||||
|
|
@ -1034,11 +1041,7 @@ void* rdpgfx_get_cache_slot_data(RdpgfxClientContext* context, UINT16 cacheSlot)
|
|||
return pData;
|
||||
}
|
||||
|
||||
#ifdef STATIC_CHANNELS
|
||||
#define DVCPluginEntry rdpgfx_DVCPluginEntry
|
||||
#endif
|
||||
|
||||
int DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
|
||||
int rdpgfx_DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
|
||||
{
|
||||
int status = 0;
|
||||
RDPGFX_PLUGIN* gfx;
|
||||
|
|
@ -1096,6 +1099,9 @@ int DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
|
|||
|
||||
gfx->zgfx = zgfx_context_new(FALSE);
|
||||
|
||||
if (!gfx->zgfx)
|
||||
return -1;
|
||||
|
||||
status = pEntryPoints->RegisterPlugin(pEntryPoints, "rdpgfx", (IWTSPlugin*) gfx);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -67,6 +67,14 @@ int xf_ResetGraphics(RdpgfxClientContext* context, RDPGFX_RESET_GRAPHICS_PDU* re
|
|||
|
||||
xfc->h264 = h264_context_new(FALSE);
|
||||
|
||||
if (xfc->progressive)
|
||||
{
|
||||
progressive_context_free(xfc->progressive);
|
||||
xfc->progressive = NULL;
|
||||
}
|
||||
|
||||
xfc->progressive = progressive_context_new(TRUE);
|
||||
|
||||
region16_init(&(xfc->invalidRegion));
|
||||
|
||||
xfc->graphicsReset = TRUE;
|
||||
|
|
@ -336,9 +344,30 @@ int xf_SurfaceCommand_Planar(xfContext* xfc, RdpgfxClientContext* context, RDPGF
|
|||
int xf_SurfaceCommand_H264(xfContext* xfc, RdpgfxClientContext* context, RDPGFX_SURFACE_COMMAND* cmd)
|
||||
{
|
||||
int status;
|
||||
UINT32 i, j;
|
||||
int nXDst, nYDst;
|
||||
int nWidth, nHeight;
|
||||
int nbUpdateRects;
|
||||
BYTE* DstData = NULL;
|
||||
RDPGFX_RECT16* rect;
|
||||
H264_CONTEXT* h264;
|
||||
xfGfxSurface* surface;
|
||||
RECTANGLE_16 invalidRect;
|
||||
REGION16 updateRegion;
|
||||
RECTANGLE_16 updateRect;
|
||||
RECTANGLE_16* updateRects;
|
||||
REGION16 clippingRects;
|
||||
RECTANGLE_16 clippingRect;
|
||||
RDPGFX_H264_METABLOCK* meta;
|
||||
RDPGFX_H264_BITMAP_STREAM* bs;
|
||||
|
||||
h264 = xfc->h264;
|
||||
|
||||
bs = (RDPGFX_H264_BITMAP_STREAM*) cmd->extra;
|
||||
|
||||
if (!bs)
|
||||
return -1;
|
||||
|
||||
meta = &(bs->meta);
|
||||
|
||||
surface = (xfGfxSurface*) context->GetSurfaceData(context, cmd->surfaceId);
|
||||
|
||||
|
|
@ -347,15 +376,61 @@ int xf_SurfaceCommand_H264(xfContext* xfc, RdpgfxClientContext* context, RDPGFX_
|
|||
|
||||
DstData = surface->data;
|
||||
|
||||
#if 1
|
||||
status = h264_decompress(xfc->h264, cmd->data, cmd->length, &DstData,
|
||||
status = h264_decompress(xfc->h264, bs->data, bs->length, &DstData,
|
||||
PIXEL_FORMAT_XRGB32, surface->scanline, cmd->left, cmd->top, cmd->width, cmd->height);
|
||||
#else
|
||||
status = -1;
|
||||
#endif
|
||||
|
||||
printf("xf_SurfaceCommand_H264: status: %d\n", status);
|
||||
|
||||
if (status < 0)
|
||||
return -1;
|
||||
|
||||
region16_init(&clippingRects);
|
||||
|
||||
for (i = 0; i < meta->numRegionRects; i++)
|
||||
{
|
||||
rect = &(meta->regionRects[i]);
|
||||
|
||||
clippingRect.left = rect->left;
|
||||
clippingRect.top = rect->top;
|
||||
clippingRect.right = rect->right;
|
||||
clippingRect.bottom = rect->bottom;
|
||||
|
||||
region16_union_rect(&clippingRects, &clippingRects, &clippingRect);
|
||||
}
|
||||
|
||||
updateRect.left = cmd->left;
|
||||
updateRect.top = cmd->top;
|
||||
updateRect.right = cmd->right;
|
||||
updateRect.bottom = cmd->bottom;
|
||||
|
||||
region16_init(&updateRegion);
|
||||
region16_intersect_rect(&updateRegion, &clippingRects, &updateRect);
|
||||
updateRects = (RECTANGLE_16*) region16_rects(&updateRegion, &nbUpdateRects);
|
||||
|
||||
printf("numRegionRects: %d nbUpdateRects: %d\n", meta->numRegionRects, nbUpdateRects);
|
||||
|
||||
for (j = 0; j < nbUpdateRects; j++)
|
||||
{
|
||||
nXDst = updateRects[j].left;
|
||||
nYDst = updateRects[j].top;
|
||||
nWidth = updateRects[j].right - updateRects[j].left;
|
||||
nHeight = updateRects[j].bottom - updateRects[j].top;
|
||||
|
||||
/* update region from decoded H264 buffer */
|
||||
|
||||
printf("nXDst: %d nYDst: %d nWidth: %d nHeight: %d decoded: width: %d height: %d cmd: left: %d top: %d right: %d bottom: %d\n",
|
||||
nXDst, nYDst, nWidth, nHeight, h264->width, h264->height,
|
||||
cmd->left, cmd->top, cmd->right, cmd->bottom);
|
||||
|
||||
freerdp_image_copy(surface->data, PIXEL_FORMAT_XRGB32, surface->scanline,
|
||||
nXDst, nYDst, nWidth, nHeight,
|
||||
h264->data, PIXEL_FORMAT_XRGB32, h264->scanline, nXDst, nYDst);
|
||||
|
||||
region16_union_rect(&(xfc->invalidRegion), &(xfc->invalidRegion), &updateRects[j]);
|
||||
}
|
||||
|
||||
region16_uninit(&updateRegion);
|
||||
|
||||
#if 0
|
||||
/* fill with red for now to distinguish from the rest */
|
||||
|
||||
|
|
@ -363,13 +438,6 @@ int xf_SurfaceCommand_H264(xfContext* xfc, RdpgfxClientContext* context, RDPGFX_
|
|||
cmd->left, cmd->top, cmd->width, cmd->height, 0xFF0000);
|
||||
#endif
|
||||
|
||||
invalidRect.left = cmd->left;
|
||||
invalidRect.top = cmd->top;
|
||||
invalidRect.right = cmd->right;
|
||||
invalidRect.bottom = cmd->bottom;
|
||||
|
||||
region16_union_rect(&(xfc->invalidRegion), &(xfc->invalidRegion), &invalidRect);
|
||||
|
||||
if (!xfc->inGfxFrame)
|
||||
xf_OutputUpdate(xfc);
|
||||
|
||||
|
|
@ -410,6 +478,7 @@ int xf_SurfaceCommand_Alpha(xfContext* xfc, RdpgfxClientContext* context, RDPGFX
|
|||
int xf_SurfaceCommand_Progressive(xfContext* xfc, RdpgfxClientContext* context, RDPGFX_SURFACE_COMMAND* cmd)
|
||||
{
|
||||
int status = 0;
|
||||
BYTE* DstData = NULL;
|
||||
xfGfxSurface* surface;
|
||||
RECTANGLE_16 invalidRect;
|
||||
|
||||
|
|
@ -418,6 +487,17 @@ int xf_SurfaceCommand_Progressive(xfContext* xfc, RdpgfxClientContext* context,
|
|||
if (!surface)
|
||||
return -1;
|
||||
|
||||
DstData = surface->data;
|
||||
|
||||
status = progressive_decompress(xfc->progressive, cmd->data, cmd->length, &DstData,
|
||||
PIXEL_FORMAT_XRGB32, surface->scanline, cmd->left, cmd->top, cmd->width, cmd->height);
|
||||
|
||||
if (status < 0)
|
||||
{
|
||||
printf("progressive_decompress failure: %d\n", status);
|
||||
return -1;
|
||||
}
|
||||
|
||||
printf("xf_SurfaceCommand_Progressive: status: %d\n", status);
|
||||
|
||||
/* fill with blue for now to distinguish from the rest */
|
||||
|
|
|
|||
|
|
@ -35,6 +35,7 @@ typedef struct xf_context xfContext;
|
|||
#include <freerdp/codec/color.h>
|
||||
#include <freerdp/codec/bitmap.h>
|
||||
#include <freerdp/codec/h264.h>
|
||||
#include <freerdp/codec/progressive.h>
|
||||
#include <freerdp/codec/region.h>
|
||||
|
||||
struct xf_WorkArea
|
||||
|
|
@ -155,6 +156,7 @@ struct xf_context
|
|||
NSC_CONTEXT* nsc;
|
||||
CLEAR_CONTEXT* clear;
|
||||
H264_CONTEXT* h264;
|
||||
PROGRESSIVE_CONTEXT* progressive;
|
||||
void* xv_context;
|
||||
void* clipboard_context;
|
||||
|
||||
|
|
|
|||
|
|
@ -258,3 +258,4 @@ int freerdp_client_settings_parse_assistance_file(rdpSettings* settings, const c
|
|||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1641,6 +1641,7 @@ int freerdp_client_settings_parse_command_line_arguments(rdpSettings* settings,
|
|||
CommandLineSwitchCase(arg, "gfx-progressive")
|
||||
{
|
||||
settings->GfxProgressive = arg->Value ? TRUE : FALSE;
|
||||
settings->GfxThinClient = settings->GfxProgressive ? FALSE : TRUE;
|
||||
settings->SupportGraphicsPipeline = TRUE;
|
||||
}
|
||||
CommandLineSwitchCase(arg, "gfx-h264")
|
||||
|
|
|
|||
|
|
@ -1014,6 +1014,11 @@ BOOL freerdp_client_populate_settings_from_rdp_file(rdpFile* file, rdpSettings*
|
|||
freerdp_set_param_bool(settings, FreeRDP_RedirectDrives, TRUE);
|
||||
}
|
||||
|
||||
if (~file->KeyboardHook)
|
||||
{
|
||||
freerdp_set_param_uint32(settings, FreeRDP_KeyboardHook, file->KeyboardHook);
|
||||
}
|
||||
|
||||
if (file->argc > 1)
|
||||
{
|
||||
char* ConnectionFile = settings->ConnectionFile;
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@
|
|||
|
||||
#define CLOG_PRINT(level, file, fkt, line, dbg_str, fmt, ...) \
|
||||
do { \
|
||||
char tag[1024] = {0}; \
|
||||
char tag[1024] = { 0 }; \
|
||||
wLogMessage msg; \
|
||||
wLog *log; \
|
||||
\
|
||||
|
|
|
|||
|
|
@ -179,6 +179,7 @@ struct _RDPGFX_SURFACE_COMMAND
|
|||
UINT32 height;
|
||||
UINT32 length;
|
||||
BYTE* data;
|
||||
void* extra;
|
||||
};
|
||||
typedef struct _RDPGFX_SURFACE_COMMAND RDPGFX_SURFACE_COMMAND;
|
||||
|
||||
|
|
@ -332,5 +333,34 @@ struct _RDPGFX_MAP_SURFACE_TO_WINDOW_PDU
|
|||
};
|
||||
typedef struct _RDPGFX_MAP_SURFACE_TO_WINDOW_PDU RDPGFX_MAP_SURFACE_TO_WINDOW_PDU;
|
||||
|
||||
/* H264 */
|
||||
|
||||
struct _RDPGFX_H264_QUANT_QUALITY
|
||||
{
|
||||
BYTE qpVal;
|
||||
BYTE qualityVal;
|
||||
|
||||
BYTE qp;
|
||||
BYTE r;
|
||||
BYTE p;
|
||||
};
|
||||
typedef struct _RDPGFX_H264_QUANT_QUALITY RDPGFX_H264_QUANT_QUALITY;
|
||||
|
||||
struct _RDPGFX_H264_METABLOCK
|
||||
{
|
||||
UINT32 numRegionRects;
|
||||
RDPGFX_RECT16* regionRects;
|
||||
RDPGFX_H264_QUANT_QUALITY* quantQualityVals;
|
||||
};
|
||||
typedef struct _RDPGFX_H264_METABLOCK RDPGFX_H264_METABLOCK;
|
||||
|
||||
struct _RDPGFX_H264_BITMAP_STREAM
|
||||
{
|
||||
RDPGFX_H264_METABLOCK meta;
|
||||
UINT32 length;
|
||||
BYTE* data;
|
||||
};
|
||||
typedef struct _RDPGFX_H264_BITMAP_STREAM RDPGFX_H264_BITMAP_STREAM;
|
||||
|
||||
#endif /* FREERDP_CHANNEL_RDPGFX_H */
|
||||
|
||||
|
|
|
|||
|
|
@ -23,18 +23,42 @@
|
|||
#include <freerdp/api.h>
|
||||
#include <freerdp/types.h>
|
||||
|
||||
#ifdef WITH_LIBAVCODEC
|
||||
#ifdef WITH_OPENH264
|
||||
#undef WITH_OPENH264
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef WITH_OPENH264
|
||||
#include "wels/codec_def.h"
|
||||
#include "wels/codec_api.h"
|
||||
#endif
|
||||
|
||||
#ifdef WITH_LIBAVCODEC
|
||||
#include <libavcodec/avcodec.h>
|
||||
#include <libavutil/avutil.h>
|
||||
#endif
|
||||
|
||||
struct _H264_CONTEXT
|
||||
{
|
||||
BOOL Compressor;
|
||||
|
||||
BYTE* data;
|
||||
UINT32 size;
|
||||
UINT32 width;
|
||||
UINT32 height;
|
||||
int scanline;
|
||||
|
||||
#ifdef WITH_OPENH264
|
||||
ISVCDecoder* pDecoder;
|
||||
#endif
|
||||
|
||||
#ifdef WITH_LIBAVCODEC
|
||||
AVCodec* codec;
|
||||
AVCodecContext* codecContext;
|
||||
AVCodecParserContext* codecParser;
|
||||
AVFrame* videoFrame;
|
||||
#endif
|
||||
};
|
||||
typedef struct _H264_CONTEXT H264_CONTEXT;
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,290 @@
|
|||
/**
|
||||
* FreeRDP: A Remote Desktop Protocol Implementation
|
||||
* Progressive Codec Bitmap Compression
|
||||
*
|
||||
* Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef FREERDP_CODEC_PROGRESSIVE_H
|
||||
#define FREERDP_CODEC_PROGRESSIVE_H
|
||||
|
||||
#include <freerdp/api.h>
|
||||
#include <freerdp/types.h>
|
||||
|
||||
#include <winpr/collections.h>
|
||||
|
||||
#include <freerdp/codec/rfx.h>
|
||||
#include <freerdp/codec/color.h>
|
||||
|
||||
#define RFX_SUBBAND_DIFFING 0x01
|
||||
|
||||
#define RFX_TILE_DIFFERENCE 0x01
|
||||
|
||||
#define RFX_DWT_REDUCE_EXTRAPOLATE 0x01
|
||||
|
||||
#define PROGRESSIVE_WBT_SYNC 0xCCC0
|
||||
#define PROGRESSIVE_WBT_FRAME_BEGIN 0xCCC1
|
||||
#define PROGRESSIVE_WBT_FRAME_END 0xCCC2
|
||||
#define PROGRESSIVE_WBT_CONTEXT 0xCCC3
|
||||
#define PROGRESSIVE_WBT_REGION 0xCCC4
|
||||
#define PROGRESSIVE_WBT_TILE_SIMPLE 0xCCC5
|
||||
#define PROGRESSIVE_WBT_TILE_FIRST 0xCCC6
|
||||
#define PROGRESSIVE_WBT_TILE_UPGRADE 0xCCC7
|
||||
|
||||
#define PROGRESSIVE_BLOCKS_ALL 0x0001
|
||||
#define PROGRESSIVE_BLOCKS_REGION 0x0002
|
||||
#define PROGRESSIVE_BLOCKS_TILE 0x0004
|
||||
|
||||
struct _RFX_PROGRESSIVE_CODEC_QUANT
|
||||
{
|
||||
BYTE quality;
|
||||
BYTE yQuantValues[5];
|
||||
BYTE cbQuantValues[5];
|
||||
BYTE crQuantValues[5];
|
||||
};
|
||||
typedef struct _RFX_PROGRESSIVE_CODEC_QUANT RFX_PROGRESSIVE_CODEC_QUANT;
|
||||
|
||||
struct _RFX_COMPONENT_CODEC_QUANT
|
||||
{
|
||||
BYTE LL3;
|
||||
BYTE HL3;
|
||||
BYTE LH3;
|
||||
BYTE HH3;
|
||||
BYTE HL2;
|
||||
BYTE LH2;
|
||||
BYTE HH2;
|
||||
BYTE HL1;
|
||||
BYTE LH1;
|
||||
BYTE HH1;
|
||||
};
|
||||
typedef struct _RFX_COMPONENT_CODEC_QUANT RFX_COMPONENT_CODEC_QUANT;
|
||||
|
||||
struct _PROGRESSIVE_BLOCK
|
||||
{
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
};
|
||||
typedef struct _PROGRESSIVE_BLOCK PROGRESSIVE_BLOCK;
|
||||
|
||||
struct _PROGRESSIVE_BLOCK_SYNC
|
||||
{
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
|
||||
UINT32 magic;
|
||||
UINT16 version;
|
||||
};
|
||||
typedef struct _PROGRESSIVE_BLOCK_SYNC PROGRESSIVE_BLOCK_SYNC;
|
||||
|
||||
struct _PROGRESSIVE_BLOCK_CONTEXT
|
||||
{
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
|
||||
BYTE ctxId;
|
||||
UINT16 tileSize;
|
||||
BYTE flags;
|
||||
};
|
||||
typedef struct _PROGRESSIVE_BLOCK_CONTEXT PROGRESSIVE_BLOCK_CONTEXT;
|
||||
|
||||
struct _PROGRESSIVE_BLOCK_TILE_SIMPLE
|
||||
{
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
|
||||
BYTE quantIdxY;
|
||||
BYTE quantIdxCb;
|
||||
BYTE quantIdxCr;
|
||||
UINT16 xIdx;
|
||||
UINT16 yIdx;
|
||||
BYTE flags;
|
||||
UINT16 yLen;
|
||||
UINT16 cbLen;
|
||||
UINT16 crLen;
|
||||
UINT16 tailLen;
|
||||
BYTE* yData;
|
||||
BYTE* cbData;
|
||||
BYTE* crData;
|
||||
BYTE* tailData;
|
||||
};
|
||||
typedef struct _PROGRESSIVE_BLOCK_TILE_SIMPLE PROGRESSIVE_BLOCK_TILE_SIMPLE;
|
||||
|
||||
struct _PROGRESSIVE_BLOCK_TILE_FIRST
|
||||
{
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
|
||||
BYTE quantIdxY;
|
||||
BYTE quantIdxCb;
|
||||
BYTE quantIdxCr;
|
||||
UINT16 xIdx;
|
||||
UINT16 yIdx;
|
||||
BYTE flags;
|
||||
BYTE quality;
|
||||
UINT16 yLen;
|
||||
UINT16 cbLen;
|
||||
UINT16 crLen;
|
||||
UINT16 tailLen;
|
||||
BYTE* yData;
|
||||
BYTE* cbData;
|
||||
BYTE* crData;
|
||||
BYTE* tailData;
|
||||
};
|
||||
typedef struct _PROGRESSIVE_BLOCK_TILE_FIRST PROGRESSIVE_BLOCK_TILE_FIRST;
|
||||
|
||||
struct _PROGRESSIVE_BLOCK_TILE_UPGRADE
|
||||
{
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
|
||||
BYTE quantIdxY;
|
||||
BYTE quantIdxCb;
|
||||
BYTE quantIdxCr;
|
||||
UINT16 xIdx;
|
||||
UINT16 yIdx;
|
||||
BYTE quality;
|
||||
UINT16 ySrlLen;
|
||||
UINT16 yRawLen;
|
||||
UINT16 cbSrlLen;
|
||||
UINT16 cbRawLen;
|
||||
UINT16 crSrlLen;
|
||||
UINT16 crRawLen;
|
||||
BYTE* ySrlData;
|
||||
BYTE* yRawData;
|
||||
BYTE* cbSrlData;
|
||||
BYTE* cbRawData;
|
||||
BYTE* crSrlData;
|
||||
BYTE* crRawData;
|
||||
};
|
||||
typedef struct _PROGRESSIVE_BLOCK_TILE_UPGRADE PROGRESSIVE_BLOCK_TILE_UPGRADE;
|
||||
|
||||
struct _RFX_PROGRESSIVE_TILE
|
||||
{
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
|
||||
BYTE quantIdxY;
|
||||
BYTE quantIdxCb;
|
||||
BYTE quantIdxCr;
|
||||
UINT16 xIdx;
|
||||
UINT16 yIdx;
|
||||
|
||||
BYTE flags;
|
||||
BYTE quality;
|
||||
|
||||
UINT16 yLen;
|
||||
UINT16 cbLen;
|
||||
UINT16 crLen;
|
||||
UINT16 tailLen;
|
||||
BYTE* yData;
|
||||
BYTE* cbData;
|
||||
BYTE* crData;
|
||||
BYTE* tailData;
|
||||
|
||||
UINT16 ySrlLen;
|
||||
UINT16 yRawLen;
|
||||
UINT16 cbSrlLen;
|
||||
UINT16 cbRawLen;
|
||||
UINT16 crSrlLen;
|
||||
UINT16 crRawLen;
|
||||
BYTE* ySrlData;
|
||||
BYTE* yRawData;
|
||||
BYTE* cbSrlData;
|
||||
BYTE* cbRawData;
|
||||
BYTE* crSrlData;
|
||||
BYTE* crRawData;
|
||||
};
|
||||
typedef struct _RFX_PROGRESSIVE_TILE RFX_PROGRESSIVE_TILE;
|
||||
|
||||
struct _PROGRESSIVE_BLOCK_REGION
|
||||
{
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
|
||||
BYTE tileSize;
|
||||
UINT16 numRects;
|
||||
BYTE numQuant;
|
||||
BYTE numProgQuant;
|
||||
BYTE flags;
|
||||
UINT16 numTiles;
|
||||
UINT32 tileDataSize;
|
||||
RFX_RECT* rects;
|
||||
RFX_COMPONENT_CODEC_QUANT* quantVals;
|
||||
RFX_PROGRESSIVE_CODEC_QUANT* quantProgVals;
|
||||
RFX_PROGRESSIVE_TILE* tiles;
|
||||
};
|
||||
typedef struct _PROGRESSIVE_BLOCK_REGION PROGRESSIVE_BLOCK_REGION;
|
||||
|
||||
struct _PROGRESSIVE_BLOCK_FRAME_BEGIN
|
||||
{
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
|
||||
UINT32 frameIndex;
|
||||
UINT16 regionCount;
|
||||
PROGRESSIVE_BLOCK_REGION* regions;
|
||||
};
|
||||
typedef struct _PROGRESSIVE_BLOCK_FRAME_BEGIN PROGRESSIVE_BLOCK_FRAME_BEGIN;
|
||||
|
||||
struct _PROGRESSIVE_BLOCK_FRAME_END
|
||||
{
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
};
|
||||
typedef struct _PROGRESSIVE_BLOCK_FRAME_END PROGRESSIVE_BLOCK_FRAME_END;
|
||||
|
||||
struct _PROGRESSIVE_CONTEXT
|
||||
{
|
||||
BOOL Compressor;
|
||||
|
||||
wBufferPool* bufferPool;
|
||||
|
||||
UINT32 cRects;
|
||||
RFX_RECT* rects;
|
||||
|
||||
UINT32 cTiles;
|
||||
RFX_PROGRESSIVE_TILE* tiles;
|
||||
|
||||
UINT32 cQuant;
|
||||
RFX_COMPONENT_CODEC_QUANT* quantVals;
|
||||
|
||||
UINT32 cProgQuant;
|
||||
RFX_PROGRESSIVE_CODEC_QUANT* quantProgVals;
|
||||
|
||||
PROGRESSIVE_BLOCK_REGION region;
|
||||
RFX_PROGRESSIVE_CODEC_QUANT quantProgValFull;
|
||||
};
|
||||
typedef struct _PROGRESSIVE_CONTEXT PROGRESSIVE_CONTEXT;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
FREERDP_API int progressive_compress(PROGRESSIVE_CONTEXT* progressive, BYTE* pSrcData, UINT32 SrcSize, BYTE** ppDstData, UINT32* pDstSize);
|
||||
|
||||
FREERDP_API int progressive_decompress(PROGRESSIVE_CONTEXT* progressive, BYTE* pSrcData, UINT32 SrcSize,
|
||||
BYTE** ppDstData, DWORD DstFormat, int nDstStep, int nXDst, int nYDst, int nWidth, int nHeight);
|
||||
|
||||
FREERDP_API void progressive_context_reset(PROGRESSIVE_CONTEXT* progressive);
|
||||
|
||||
FREERDP_API PROGRESSIVE_CONTEXT* progressive_context_new(BOOL Compressor);
|
||||
FREERDP_API void progressive_context_free(PROGRESSIVE_CONTEXT* progressive);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* FREERDP_CODEC_PROGRESSIVE_H */
|
||||
|
||||
|
|
@ -146,8 +146,6 @@ struct _RFX_CONTEXT
|
|||
void (*quantization_encode)(INT16* buffer, const UINT32* quantization_values);
|
||||
void (*dwt_2d_decode)(INT16* buffer, INT16* dwt_buffer);
|
||||
void (*dwt_2d_encode)(INT16* buffer, INT16* dwt_buffer);
|
||||
int (*rlgr_decode)(RLGR_MODE mode, const BYTE* data, int data_size, INT16* buffer, int buffer_size);
|
||||
int (*rlgr_encode)(RLGR_MODE mode, const INT16* data, int data_size, BYTE* buffer, int buffer_size);
|
||||
|
||||
/* private definitions */
|
||||
RFX_CONTEXT_PRIV* priv;
|
||||
|
|
@ -159,6 +157,8 @@ FREERDP_API void rfx_context_free(RFX_CONTEXT* context);
|
|||
FREERDP_API void rfx_context_set_pixel_format(RFX_CONTEXT* context, RDP_PIXEL_FORMAT pixel_format);
|
||||
FREERDP_API void rfx_context_reset(RFX_CONTEXT* context);
|
||||
|
||||
FREERDP_API int rfx_rlgr_decode(const BYTE* pSrcData, UINT32 SrcSize, INT16* pDstData, UINT32 DstSize, int mode);
|
||||
|
||||
FREERDP_API RFX_MESSAGE* rfx_process_message(RFX_CONTEXT* context, BYTE* data, UINT32 length);
|
||||
FREERDP_API UINT16 rfx_message_get_tile_count(RFX_MESSAGE* message);
|
||||
FREERDP_API RFX_TILE* rfx_message_get_tile(RFX_MESSAGE* message, int index);
|
||||
|
|
|
|||
|
|
@ -222,6 +222,11 @@
|
|||
#define LB_CLIENT_TSV_URL 0x00001000
|
||||
#define LB_SERVER_TSV_CAPABLE 0x00002000
|
||||
|
||||
/* Keyboard Hook */
|
||||
#define KEYBOARD_HOOK_LOCAL 0
|
||||
#define KEYBOARD_HOOK_REMOTE 1
|
||||
#define KEYBOARD_HOOK_FULLSCREEN_ONLY 2
|
||||
|
||||
struct _TARGET_NET_ADDRESS
|
||||
{
|
||||
UINT32 Length;
|
||||
|
|
@ -531,6 +536,8 @@ typedef struct _RDPDR_PARALLEL RDPDR_PARALLEL;
|
|||
#define FreeRDP_ServerRandomLength 197
|
||||
#define FreeRDP_ServerCertificate 198
|
||||
#define FreeRDP_ServerCertificateLength 199
|
||||
#define FreeRDP_ClientRandom 200
|
||||
#define FreeRDP_ClientRandomLength 201
|
||||
#define FreeRDP_ChannelCount 256
|
||||
#define FreeRDP_ChannelDefArraySize 257
|
||||
#define FreeRDP_ChannelDefArray 258
|
||||
|
|
@ -726,6 +733,7 @@ typedef struct _RDPDR_PARALLEL RDPDR_PARALLEL;
|
|||
#define FreeRDP_FastPathInput 2630
|
||||
#define FreeRDP_MultiTouchInput 2631
|
||||
#define FreeRDP_MultiTouchGestures 2632
|
||||
#define FreeRDP_KeyboardHook 2633
|
||||
#define FreeRDP_BrushSupportLevel 2688
|
||||
#define FreeRDP_GlyphSupportLevel 2752
|
||||
#define FreeRDP_GlyphCache 2753
|
||||
|
|
@ -845,11 +853,12 @@ struct rdp_settings
|
|||
ALIGN64 UINT32 ExtEncryptionMethods; /* 194 */
|
||||
ALIGN64 UINT32 EncryptionLevel; /* 195 */
|
||||
ALIGN64 BYTE* ServerRandom; /* 196 */
|
||||
ALIGN64 DWORD ServerRandomLength; /* 197 */
|
||||
ALIGN64 UINT32 ServerRandomLength; /* 197 */
|
||||
ALIGN64 BYTE* ServerCertificate; /* 198 */
|
||||
ALIGN64 DWORD ServerCertificateLength; /* 199 */
|
||||
ALIGN64 UINT32 ServerCertificateLength; /* 199 */
|
||||
ALIGN64 BYTE* ClientRandom; /* 200 */
|
||||
UINT64 padding0256[256 - 201]; /* 201 */
|
||||
ALIGN64 UINT32 ClientRandomLength; /* 201 */
|
||||
UINT64 padding0256[256 - 202]; /* 202 */
|
||||
|
||||
/* Client Network Data */
|
||||
ALIGN64 UINT32 ChannelCount; /* 256 */
|
||||
|
|
@ -1008,7 +1017,7 @@ struct rdp_settings
|
|||
|
||||
/* Credentials Cache */
|
||||
ALIGN64 BYTE* Password51; /* 1280 */
|
||||
ALIGN64 DWORD Password51Length; /* 1281 */
|
||||
ALIGN64 UINT32 Password51Length; /* 1281 */
|
||||
UINT64 padding1344[1344 - 1282]; /* 1282 */
|
||||
|
||||
/* Kerberos Authentication */
|
||||
|
|
@ -1114,8 +1123,8 @@ struct rdp_settings
|
|||
ALIGN64 char* RemoteApplicationFile; /* 2116 */
|
||||
ALIGN64 char* RemoteApplicationGuid; /* 2117 */
|
||||
ALIGN64 char* RemoteApplicationCmdLine; /* 2118 */
|
||||
ALIGN64 DWORD RemoteApplicationExpandCmdLine; /* 2119 */
|
||||
ALIGN64 DWORD RemoteApplicationExpandWorkingDir; /* 2120 */
|
||||
ALIGN64 UINT32 RemoteApplicationExpandCmdLine; /* 2119 */
|
||||
ALIGN64 UINT32 RemoteApplicationExpandWorkingDir; /* 2120 */
|
||||
ALIGN64 BOOL DisableRemoteAppCapsCheck; /* 2121 */
|
||||
ALIGN64 UINT32 RemoteAppNumIconCaches; /* 2122 */
|
||||
ALIGN64 UINT32 RemoteAppNumIconCacheEntries; /* 2123 */
|
||||
|
|
@ -1181,7 +1190,8 @@ struct rdp_settings
|
|||
ALIGN64 BOOL FastPathInput; /* 2630 */
|
||||
ALIGN64 BOOL MultiTouchInput; /* 2631 */
|
||||
ALIGN64 BOOL MultiTouchGestures; /* 2632 */
|
||||
UINT64 padding2688[2688 - 2633]; /* 2633 */
|
||||
ALIGN64 UINT32 KeyboardHook; /* 2633 */
|
||||
UINT64 padding2688[2688 - 2634]; /* 2634 */
|
||||
|
||||
/* Brush Capabilities */
|
||||
ALIGN64 UINT32 BrushSupportLevel; /* 2688 */
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@ set(${MODULE_PREFIX}_SRCS
|
|||
audio.c
|
||||
planar.c
|
||||
planar.h
|
||||
progressive.c
|
||||
bitmap_decode.c
|
||||
bitmap_encode.c
|
||||
rfx_bitstream.h
|
||||
|
|
@ -93,6 +94,13 @@ if(WITH_OPENH264)
|
|||
set(FREERDP_OPENH264_LIBS ${OPENH264_LIBRARIES})
|
||||
endif()
|
||||
|
||||
if(WITH_LIBAVCODEC)
|
||||
add_definitions(-DWITH_LIBAVCODEC)
|
||||
find_library(LIBAVCODEC_LIB avcodec)
|
||||
find_library(LIBAVUTIL_LIB avutil)
|
||||
set(FREERDP_LIBAVCODEC_LIBS ${LIBAVCODEC_LIB} ${LIBAVUTIL_LIB})
|
||||
endif()
|
||||
|
||||
add_complex_library(MODULE ${MODULE_NAME} TYPE "OBJECT"
|
||||
MONOLITHIC ${MONOLITHIC_BUILD}
|
||||
SOURCES ${${MODULE_PREFIX}_SRCS}
|
||||
|
|
@ -105,7 +113,8 @@ set_target_properties(${MODULE_NAME} PROPERTIES PREFIX "lib")
|
|||
|
||||
set(${MODULE_PREFIX}_LIBS
|
||||
${FREERDP_JPEG_LIBS}
|
||||
${FREERDP_OPENH264_LIBS})
|
||||
${FREERDP_OPENH264_LIBS}
|
||||
${FREERDP_LIBAVCODEC_LIBS})
|
||||
|
||||
set_complex_link_libraries(VARIABLE ${MODULE_PREFIX}_LIBS
|
||||
MONOLITHIC ${MONOLITHIC_BUILD} INTERNAL
|
||||
|
|
|
|||
|
|
@ -135,14 +135,14 @@ int clear_decompress(CLEAR_CONTEXT* clear, BYTE* pSrcData, UINT32 SrcSize,
|
|||
if (!glyphData)
|
||||
return -1010;
|
||||
|
||||
if ((nWidth * nHeight) > glyphEntry->count)
|
||||
if ((nWidth * nHeight) > (int) glyphEntry->count)
|
||||
return -1011;
|
||||
|
||||
nSrcStep = nWidth * 4;
|
||||
pSrcPixel8 = glyphData;
|
||||
pDstPixel8 = &pDstData[(nYDst * nDstStep) + (nXDst * 4)];
|
||||
|
||||
for (y = 0; y < nHeight; y++)
|
||||
for (y = 0; y < (UINT32) nHeight; y++)
|
||||
{
|
||||
CopyMemory(pDstPixel8, pSrcPixel8, nSrcStep);
|
||||
pSrcPixel8 += nSrcStep;
|
||||
|
|
@ -177,7 +177,7 @@ int clear_decompress(CLEAR_CONTEXT* clear, BYTE* pSrcData, UINT32 SrcSize,
|
|||
suboffset = 0;
|
||||
residualData = &pSrcData[offset];
|
||||
|
||||
if ((nWidth * nHeight * 4) > clear->TempSize)
|
||||
if ((nWidth * nHeight * 4) > (int) clear->TempSize)
|
||||
{
|
||||
clear->TempSize = (nWidth * nHeight * 4);
|
||||
clear->TempBuffer = (BYTE*) realloc(clear->TempBuffer, clear->TempSize);
|
||||
|
|
@ -238,7 +238,7 @@ int clear_decompress(CLEAR_CONTEXT* clear, BYTE* pSrcData, UINT32 SrcSize,
|
|||
if (pixelIndex != pixelCount)
|
||||
return -1019;
|
||||
|
||||
for (y = 0; y < nHeight; y++)
|
||||
for (y = 0; y < (UINT32) nHeight; y++)
|
||||
{
|
||||
CopyMemory(pDstPixel8, pSrcPixel8, nSrcStep);
|
||||
pSrcPixel8 += nSrcStep;
|
||||
|
|
@ -543,7 +543,7 @@ int clear_decompress(CLEAR_CONTEXT* clear, BYTE* pSrcData, UINT32 SrcSize,
|
|||
if (height > nHeight)
|
||||
return -1043;
|
||||
|
||||
if ((width * height * 4) > clear->TempSize)
|
||||
if (((UINT32) (width * height * 4)) > clear->TempSize)
|
||||
{
|
||||
clear->TempSize = (width * height * 4);
|
||||
clear->TempBuffer = (BYTE*) realloc(clear->TempBuffer, clear->TempSize);
|
||||
|
|
@ -732,7 +732,7 @@ int clear_decompress(CLEAR_CONTEXT* clear, BYTE* pSrcData, UINT32 SrcSize,
|
|||
pDstPixel8 = glyphData;
|
||||
pSrcPixel8 = &pDstData[(nYDst * nDstStep) + (nXDst * 4)];
|
||||
|
||||
for (y = 0; y < nHeight; y++)
|
||||
for (y = 0; y < (UINT32) nHeight; y++)
|
||||
{
|
||||
CopyMemory(pDstPixel8, pSrcPixel8, nSrcStep);
|
||||
pDstPixel8 += nSrcStep;
|
||||
|
|
|
|||
|
|
@ -365,3 +365,4 @@ void h264_context_free(H264_CONTEXT* h264)
|
|||
free(h264);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,732 @@
|
|||
/**
|
||||
* FreeRDP: A Remote Desktop Protocol Implementation
|
||||
* Progressive Codec Bitmap Compression
|
||||
*
|
||||
* Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <winpr/crt.h>
|
||||
#include <winpr/print.h>
|
||||
#include <winpr/bitstream.h>
|
||||
|
||||
#include <freerdp/codec/color.h>
|
||||
#include <freerdp/codec/progressive.h>
|
||||
|
||||
const char* progressive_get_block_type_string(UINT16 blockType)
|
||||
{
|
||||
switch (blockType)
|
||||
{
|
||||
case PROGRESSIVE_WBT_SYNC:
|
||||
return "PROGRESSIVE_WBT_SYNC";
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_FRAME_BEGIN:
|
||||
return "PROGRESSIVE_WBT_FRAME_BEGIN";
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_FRAME_END:
|
||||
return "PROGRESSIVE_WBT_FRAME_END";
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_CONTEXT:
|
||||
return "PROGRESSIVE_WBT_CONTEXT";
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_REGION:
|
||||
return "PROGRESSIVE_WBT_REGION";
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_TILE_SIMPLE:
|
||||
return "PROGRESSIVE_WBT_TILE_SIMPLE";
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_TILE_FIRST:
|
||||
return "PROGRESSIVE_WBT_TILE_FIRST";
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_TILE_UPGRADE:
|
||||
return "PROGRESSIVE_WBT_TILE_UPGRADE";
|
||||
break;
|
||||
|
||||
default:
|
||||
return "PROGRESSIVE_WBT_UNKNOWN";
|
||||
break;
|
||||
}
|
||||
|
||||
return "PROGRESSIVE_WBT_UNKNOWN";
|
||||
}
|
||||
|
||||
int progressive_rfx_decode_component(PROGRESSIVE_CONTEXT* progressive,
|
||||
RFX_COMPONENT_CODEC_QUANT* quant, const BYTE* data, int length, INT16* buffer)
|
||||
{
|
||||
int status;
|
||||
|
||||
status = rfx_rlgr_decode(data, length, buffer, 4096, 1);
|
||||
|
||||
if (status < 0)
|
||||
return status;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int progressive_decompress_tile_first(PROGRESSIVE_CONTEXT* progressive, RFX_PROGRESSIVE_TILE* tile)
|
||||
{
|
||||
BYTE* pBuffer;
|
||||
INT16* pSrcDst[3];
|
||||
PROGRESSIVE_BLOCK_REGION* region;
|
||||
RFX_COMPONENT_CODEC_QUANT* quantY;
|
||||
RFX_COMPONENT_CODEC_QUANT* quantCb;
|
||||
RFX_COMPONENT_CODEC_QUANT* quantCr;
|
||||
RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal;
|
||||
|
||||
printf("ProgressiveTileFirst: quantIdx Y: %d Cb: %d Cr: %d xIdx: %d yIdx: %d flags: %d quality: %d yLen: %d cbLen: %d crLen: %d tailLen: %d\n",
|
||||
tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr, tile->xIdx, tile->yIdx, tile->flags, tile->quality, tile->yLen, tile->cbLen, tile->crLen, tile->tailLen);
|
||||
|
||||
region = &(progressive->region);
|
||||
|
||||
if (tile->quantIdxY >= region->numQuant)
|
||||
return -1;
|
||||
|
||||
quantY = &(region->quantVals[tile->quantIdxY]);
|
||||
|
||||
if (tile->quantIdxCb >= region->numQuant)
|
||||
return -1;
|
||||
|
||||
quantCb = &(region->quantVals[tile->quantIdxCb]);
|
||||
|
||||
if (tile->quantIdxCr >= region->numQuant)
|
||||
return -1;
|
||||
|
||||
quantCr = &(region->quantVals[tile->quantIdxCr]);
|
||||
|
||||
if (tile->quality == 0xFF)
|
||||
{
|
||||
quantProgVal = &(progressive->quantProgValFull);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (tile->quality >= region->numProgQuant)
|
||||
return -1;
|
||||
|
||||
quantProgVal = &(region->quantProgVals[tile->quality]);
|
||||
}
|
||||
|
||||
pBuffer = (BYTE*) BufferPool_Take(progressive->bufferPool, -1);
|
||||
pSrcDst[0] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 0) + 16])); /* Y/R buffer */
|
||||
pSrcDst[1] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 1) + 16])); /* Cb/G buffer */
|
||||
pSrcDst[2] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 2) + 16])); /* Cr/B buffer */
|
||||
|
||||
progressive_rfx_decode_component(progressive, quantY, tile->yData, tile->yLen, pSrcDst[0]); /* Y */
|
||||
progressive_rfx_decode_component(progressive, quantCb, tile->cbData, tile->cbLen, pSrcDst[1]); /* Cb */
|
||||
progressive_rfx_decode_component(progressive, quantCr, tile->crData, tile->crLen, pSrcDst[2]); /* Cr */
|
||||
|
||||
BufferPool_Return(progressive->bufferPool, pBuffer);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int progressive_decompress_tile_upgrade(PROGRESSIVE_CONTEXT* progressive, RFX_PROGRESSIVE_TILE* tile)
|
||||
{
|
||||
PROGRESSIVE_BLOCK_REGION* region;
|
||||
RFX_COMPONENT_CODEC_QUANT* quantY;
|
||||
RFX_COMPONENT_CODEC_QUANT* quantCb;
|
||||
RFX_COMPONENT_CODEC_QUANT* quantCr;
|
||||
RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal;
|
||||
|
||||
printf("ProgressiveTileUpgrade: quantIdx Y: %d Cb: %d Cr: %d xIdx: %d yIdx: %d quality: %d ySrlLen: %d yRawLen: %d cbSrlLen: %d cbRawLen: %d crSrlLen: %d crRawLen: %d\n",
|
||||
tile->quantIdxY, tile->quantIdxCb, tile->quantIdxCr, tile->xIdx, tile->yIdx, tile->quality, tile->ySrlLen, tile->yRawLen, tile->cbSrlLen, tile->cbRawLen, tile->crSrlLen, tile->crRawLen);
|
||||
|
||||
region = &(progressive->region);
|
||||
|
||||
if (tile->quantIdxY >= region->numQuant)
|
||||
return -1;
|
||||
|
||||
quantY = &(region->quantVals[tile->quantIdxY]);
|
||||
|
||||
if (tile->quantIdxCb >= region->numQuant)
|
||||
return -1;
|
||||
|
||||
quantCb = &(region->quantVals[tile->quantIdxCb]);
|
||||
|
||||
if (tile->quantIdxCr >= region->numQuant)
|
||||
return -1;
|
||||
|
||||
quantCr = &(region->quantVals[tile->quantIdxCr]);
|
||||
|
||||
if (tile->quality == 0xFF)
|
||||
{
|
||||
quantProgVal = &(progressive->quantProgValFull);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (tile->quality >= region->numProgQuant)
|
||||
return -1;
|
||||
|
||||
quantProgVal = &(region->quantProgVals[tile->quality]);
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int progressive_process_tiles(PROGRESSIVE_CONTEXT* progressive, BYTE* blocks, UINT32 blocksLen)
|
||||
{
|
||||
BYTE* block;
|
||||
UINT16 index;
|
||||
UINT32 boffset;
|
||||
UINT32 count = 0;
|
||||
UINT32 offset = 0;
|
||||
RFX_PROGRESSIVE_TILE* tile;
|
||||
RFX_PROGRESSIVE_TILE* tiles;
|
||||
PROGRESSIVE_BLOCK_REGION* region;
|
||||
|
||||
region = &(progressive->region);
|
||||
|
||||
tiles = region->tiles;
|
||||
|
||||
while ((blocksLen - offset) >= 6)
|
||||
{
|
||||
boffset = 0;
|
||||
block = &blocks[offset];
|
||||
|
||||
tile = &tiles[count];
|
||||
|
||||
tile->blockType = *((UINT16*) &block[boffset + 0]); /* blockType (2 bytes) */
|
||||
tile->blockLen = *((UINT32*) &block[boffset + 2]); /* blockLen (4 bytes) */
|
||||
boffset += 6;
|
||||
|
||||
printf("%s\n", progressive_get_block_type_string(tile->blockType));
|
||||
|
||||
if ((blocksLen - offset) < tile->blockLen)
|
||||
return -1003;
|
||||
|
||||
switch (tile->blockType)
|
||||
{
|
||||
case PROGRESSIVE_WBT_TILE_SIMPLE:
|
||||
|
||||
if ((tile->blockLen - boffset) < 16)
|
||||
return -1022;
|
||||
|
||||
tile->quality = 0xFF; /* simple tiles use no progressive techniques */
|
||||
|
||||
tile->quantIdxY = block[boffset + 0]; /* quantIdxY (1 byte) */
|
||||
tile->quantIdxCb = block[boffset + 1]; /* quantIdxCb (1 byte) */
|
||||
tile->quantIdxCr = block[boffset + 2]; /* quantIdxCr (1 byte) */
|
||||
tile->xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */
|
||||
tile->yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */
|
||||
tile->flags = block[boffset + 7]; /* flags (1 byte) */
|
||||
tile->yLen = *((UINT16*) &block[boffset + 8]); /* yLen (2 bytes) */
|
||||
tile->cbLen = *((UINT16*) &block[boffset + 10]); /* cbLen (2 bytes) */
|
||||
tile->crLen = *((UINT16*) &block[boffset + 12]); /* crLen (2 bytes) */
|
||||
tile->tailLen = *((UINT16*) &block[boffset + 14]); /* tailLen (2 bytes) */
|
||||
boffset += 16;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->yLen)
|
||||
return -1023;
|
||||
|
||||
tile->yData = &block[boffset];
|
||||
boffset += tile->yLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->cbLen)
|
||||
return -1024;
|
||||
|
||||
tile->cbData = &block[boffset];
|
||||
boffset += tile->cbLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->crLen)
|
||||
return -1025;
|
||||
|
||||
tile->crData = &block[boffset];
|
||||
boffset += tile->crLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->tailLen)
|
||||
return -1026;
|
||||
|
||||
tile->tailData = &block[boffset];
|
||||
boffset += tile->tailLen;
|
||||
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_TILE_FIRST:
|
||||
|
||||
if ((tile->blockLen - boffset) < 17)
|
||||
return -1027;
|
||||
|
||||
tile->quantIdxY = block[boffset + 0]; /* quantIdxY (1 byte) */
|
||||
tile->quantIdxCb = block[boffset + 1]; /* quantIdxCb (1 byte) */
|
||||
tile->quantIdxCr = block[boffset + 2]; /* quantIdxCr (1 byte) */
|
||||
tile->xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */
|
||||
tile->yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */
|
||||
tile->flags = block[boffset + 7]; /* flags (1 byte) */
|
||||
tile->quality = block[boffset + 8]; /* quality (1 byte) */
|
||||
tile->yLen = *((UINT16*) &block[boffset + 9]); /* yLen (2 bytes) */
|
||||
tile->cbLen = *((UINT16*) &block[boffset + 11]); /* cbLen (2 bytes) */
|
||||
tile->crLen = *((UINT16*) &block[boffset + 13]); /* crLen (2 bytes) */
|
||||
tile->tailLen = *((UINT16*) &block[boffset + 15]); /* tailLen (2 bytes) */
|
||||
boffset += 17;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->yLen)
|
||||
return -1028;
|
||||
|
||||
tile->yData = &block[boffset];
|
||||
boffset += tile->yLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->cbLen)
|
||||
return -1029;
|
||||
|
||||
tile->cbData = &block[boffset];
|
||||
boffset += tile->cbLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->crLen)
|
||||
return -1030;
|
||||
|
||||
tile->crData = &block[boffset];
|
||||
boffset += tile->crLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->tailLen)
|
||||
return -1031;
|
||||
|
||||
tile->tailData = &block[boffset];
|
||||
boffset += tile->tailLen;
|
||||
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_TILE_UPGRADE:
|
||||
|
||||
if ((tile->blockLen - boffset) < 20)
|
||||
return -1032;
|
||||
|
||||
tile->quantIdxY = block[boffset + 0]; /* quantIdxY (1 byte) */
|
||||
tile->quantIdxCb = block[boffset + 1]; /* quantIdxCb (1 byte) */
|
||||
tile->quantIdxCr = block[boffset + 2]; /* quantIdxCr (1 byte) */
|
||||
tile->xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */
|
||||
tile->yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */
|
||||
tile->quality = block[boffset + 7]; /* quality (1 byte) */
|
||||
tile->ySrlLen = *((UINT16*) &block[boffset + 8]); /* ySrlLen (2 bytes) */
|
||||
tile->yRawLen = *((UINT16*) &block[boffset + 10]); /* yRawLen (2 bytes) */
|
||||
tile->cbSrlLen = *((UINT16*) &block[boffset + 12]); /* cbSrlLen (2 bytes) */
|
||||
tile->cbRawLen = *((UINT16*) &block[boffset + 14]); /* cbRawLen (2 bytes) */
|
||||
tile->crSrlLen = *((UINT16*) &block[boffset + 16]); /* crSrlLen (2 bytes) */
|
||||
tile->crRawLen = *((UINT16*) &block[boffset + 18]); /* crRawLen (2 bytes) */
|
||||
boffset += 20;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->ySrlLen)
|
||||
return -1033;
|
||||
|
||||
tile->ySrlData = &block[boffset];
|
||||
boffset += tile->ySrlLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->yRawLen)
|
||||
return -1034;
|
||||
|
||||
tile->yRawData = &block[boffset];
|
||||
boffset += tile->yRawLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->cbSrlLen)
|
||||
return -1035;
|
||||
|
||||
tile->cbSrlData = &block[boffset];
|
||||
boffset += tile->cbSrlLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->cbRawLen)
|
||||
return -1036;
|
||||
|
||||
tile->cbRawData = &block[boffset];
|
||||
boffset += tile->cbRawLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->crSrlLen)
|
||||
return -1037;
|
||||
|
||||
tile->crSrlData = &block[boffset];
|
||||
boffset += tile->crSrlLen;
|
||||
|
||||
if ((tile->blockLen - boffset) < tile->crRawLen)
|
||||
return -1038;
|
||||
|
||||
tile->crRawData = &block[boffset];
|
||||
boffset += tile->crRawLen;
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
return -1039;
|
||||
break;
|
||||
}
|
||||
|
||||
if (boffset != tile->blockLen)
|
||||
return -1040;
|
||||
|
||||
offset += tile->blockLen;
|
||||
count++;
|
||||
}
|
||||
|
||||
if (offset != blocksLen)
|
||||
return -1041;
|
||||
|
||||
for (index = 0; index < region->numTiles; index++)
|
||||
{
|
||||
tile = &tiles[index];
|
||||
|
||||
switch (tile->blockType)
|
||||
{
|
||||
case PROGRESSIVE_WBT_TILE_SIMPLE:
|
||||
case PROGRESSIVE_WBT_TILE_FIRST:
|
||||
progressive_decompress_tile_first(progressive, tile);
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_TILE_UPGRADE:
|
||||
progressive_decompress_tile_upgrade(progressive, tile);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return (int) offset;
|
||||
}
|
||||
|
||||
int progressive_decompress(PROGRESSIVE_CONTEXT* progressive, BYTE* pSrcData, UINT32 SrcSize,
|
||||
BYTE** ppDstData, DWORD DstFormat, int nDstStep, int nXDst, int nYDst, int nWidth, int nHeight)
|
||||
{
|
||||
int status;
|
||||
BYTE* block;
|
||||
BYTE* blocks;
|
||||
UINT16 index;
|
||||
UINT32 boffset;
|
||||
UINT16 blockType;
|
||||
UINT32 blockLen;
|
||||
UINT32 blocksLen;
|
||||
UINT32 count = 0;
|
||||
UINT32 offset = 0;
|
||||
RFX_RECT* rect = NULL;
|
||||
PROGRESSIVE_BLOCK_SYNC sync;
|
||||
PROGRESSIVE_BLOCK_REGION* region;
|
||||
PROGRESSIVE_BLOCK_CONTEXT context;
|
||||
PROGRESSIVE_BLOCK_FRAME_BEGIN frameBegin;
|
||||
PROGRESSIVE_BLOCK_FRAME_END frameEnd;
|
||||
RFX_COMPONENT_CODEC_QUANT* quantVal;
|
||||
RFX_PROGRESSIVE_CODEC_QUANT* quantProgVal;
|
||||
|
||||
blocks = pSrcData;
|
||||
blocksLen = SrcSize;
|
||||
|
||||
region = &(progressive->region);
|
||||
|
||||
while ((blocksLen - offset) >= 6)
|
||||
{
|
||||
boffset = 0;
|
||||
block = &blocks[offset];
|
||||
|
||||
blockType = *((UINT16*) &block[boffset + 0]); /* blockType (2 bytes) */
|
||||
blockLen = *((UINT32*) &block[boffset + 2]); /* blockLen (4 bytes) */
|
||||
boffset += 6;
|
||||
|
||||
printf("%s\n", progressive_get_block_type_string(blockType));
|
||||
|
||||
if ((blocksLen - offset) < blockLen)
|
||||
return -1003;
|
||||
|
||||
switch (blockType)
|
||||
{
|
||||
case PROGRESSIVE_WBT_SYNC:
|
||||
|
||||
sync.blockType = blockType;
|
||||
sync.blockLen = blockLen;
|
||||
|
||||
if ((blockLen - boffset) != 6)
|
||||
return -1004;
|
||||
|
||||
sync.magic = (UINT32) *((UINT32*) &block[boffset + 0]); /* magic (4 bytes) */
|
||||
sync.version = (UINT32) *((UINT16*) &block[boffset + 4]); /* version (2 bytes) */
|
||||
boffset += 6;
|
||||
|
||||
if (sync.magic != 0xCACCACCA)
|
||||
return -1005;
|
||||
|
||||
if (sync.version != 0x0100)
|
||||
return -1006;
|
||||
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_FRAME_BEGIN:
|
||||
|
||||
frameBegin.blockType = blockType;
|
||||
frameBegin.blockLen = blockLen;
|
||||
|
||||
if ((blockLen - boffset) < 6)
|
||||
return -1007;
|
||||
|
||||
frameBegin.frameIndex = (UINT32) *((UINT32*) &block[boffset + 0]); /* frameIndex (4 bytes) */
|
||||
frameBegin.regionCount = (UINT32) *((UINT16*) &block[boffset + 4]); /* regionCount (2 bytes) */
|
||||
boffset += 6;
|
||||
|
||||
/**
|
||||
* If the number of elements specified by the regionCount field is
|
||||
* larger than the actual number of elements in the regions field,
|
||||
* the decoder SHOULD ignore this inconsistency.
|
||||
*/
|
||||
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_FRAME_END:
|
||||
|
||||
frameEnd.blockType = blockType;
|
||||
frameEnd.blockLen = blockLen;
|
||||
|
||||
if ((blockLen - boffset) != 0)
|
||||
return -1008;
|
||||
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_CONTEXT:
|
||||
|
||||
context.blockType = blockType;
|
||||
context.blockLen = blockLen;
|
||||
|
||||
if ((blockLen - boffset) != 4)
|
||||
return -1009;
|
||||
|
||||
context.ctxId = block[boffset + 0]; /* ctxId (1 byte) */
|
||||
context.tileSize = *((UINT16*) &block[boffset + 1]); /* tileSize (2 bytes) */
|
||||
context.flags = block[boffset + 3]; /* flags (1 byte) */
|
||||
boffset += 4;
|
||||
|
||||
if (context.tileSize != 64)
|
||||
return -1010;
|
||||
|
||||
break;
|
||||
|
||||
case PROGRESSIVE_WBT_REGION:
|
||||
|
||||
region->blockType = blockType;
|
||||
region->blockLen = blockLen;
|
||||
|
||||
if ((blockLen - boffset) < 12)
|
||||
return -1011;
|
||||
|
||||
region->tileSize = block[boffset + 0]; /* tileSize (1 byte) */
|
||||
region->numRects = *((UINT16*) &block[boffset + 1]); /* numRects (2 bytes) */
|
||||
region->numQuant = block[boffset + 3]; /* numQuant (1 byte) */
|
||||
region->numProgQuant = block[boffset + 4]; /* numProgQuant (1 byte) */
|
||||
region->flags = block[boffset + 5]; /* flags (1 byte) */
|
||||
region->numTiles = *((UINT16*) &block[boffset + 6]); /* numTiles (2 bytes) */
|
||||
region->tileDataSize = *((UINT32*) &block[boffset + 8]); /* tileDataSize (4 bytes) */
|
||||
boffset += 12;
|
||||
|
||||
if (region->tileSize != 64)
|
||||
return -1012;
|
||||
|
||||
if (region->numRects < 1)
|
||||
return -1013;
|
||||
|
||||
if (region->numQuant > 7)
|
||||
return -1014;
|
||||
|
||||
if ((blockLen - boffset) < (region->numRects * 8))
|
||||
return -1015;
|
||||
|
||||
if (region->numRects > progressive->cRects)
|
||||
{
|
||||
progressive->rects = (RFX_RECT*) realloc(progressive->rects, region->numRects * sizeof(RFX_RECT));
|
||||
progressive->cRects = region->numRects;
|
||||
}
|
||||
|
||||
region->rects = progressive->rects;
|
||||
|
||||
if (!region->rects)
|
||||
return -1016;
|
||||
|
||||
for (index = 0; index < region->numRects; index++)
|
||||
{
|
||||
rect = &(region->rects[index]);
|
||||
rect->x = *((UINT16*) &block[boffset + 0]);
|
||||
rect->y = *((UINT16*) &block[boffset + 2]);
|
||||
rect->width = *((UINT16*) &block[boffset + 4]);
|
||||
rect->height = *((UINT16*) &block[boffset + 6]);
|
||||
boffset += 8;
|
||||
}
|
||||
|
||||
if ((blockLen - boffset) < (region->numQuant * 5))
|
||||
return -1017;
|
||||
|
||||
if (region->numQuant > progressive->cQuant)
|
||||
{
|
||||
progressive->quantVals = (RFX_COMPONENT_CODEC_QUANT*) realloc(progressive->quantVals,
|
||||
region->numQuant * sizeof(RFX_COMPONENT_CODEC_QUANT));
|
||||
progressive->cQuant = region->numQuant;
|
||||
}
|
||||
|
||||
region->quantVals = progressive->quantVals;
|
||||
|
||||
if (!region->quantVals)
|
||||
return -1018;
|
||||
|
||||
for (index = 0; index < region->numQuant; index++)
|
||||
{
|
||||
quantVal = &(region->quantVals[index]);
|
||||
quantVal->LL3 = block[boffset + 0] & 0x0F;
|
||||
quantVal->HL3 = block[boffset + 0] >> 4;
|
||||
quantVal->LH3 = block[boffset + 1] & 0x0F;
|
||||
quantVal->HH3 = block[boffset + 1] >> 4;
|
||||
quantVal->HL2 = block[boffset + 2] & 0x0F;
|
||||
quantVal->LH2 = block[boffset + 2] >> 4;
|
||||
quantVal->HH2 = block[boffset + 3] & 0x0F;
|
||||
quantVal->HL1 = block[boffset + 3] >> 4;
|
||||
quantVal->LH1 = block[boffset + 4] & 0x0F;
|
||||
quantVal->HH1 = block[boffset + 4] >> 4;
|
||||
boffset += 5;
|
||||
}
|
||||
|
||||
if ((blockLen - boffset) < (region->numProgQuant * 16))
|
||||
return -1019;
|
||||
|
||||
if (region->numProgQuant > progressive->cProgQuant)
|
||||
{
|
||||
progressive->quantProgVals = (RFX_PROGRESSIVE_CODEC_QUANT*) realloc(progressive->quantProgVals,
|
||||
region->numProgQuant * sizeof(RFX_PROGRESSIVE_CODEC_QUANT));
|
||||
progressive->cProgQuant = region->numProgQuant;
|
||||
}
|
||||
|
||||
region->quantProgVals = progressive->quantProgVals;
|
||||
|
||||
if (!region->quantProgVals)
|
||||
return -1020;
|
||||
|
||||
for (index = 0; index < region->numProgQuant; index++)
|
||||
{
|
||||
quantProgVal = &(region->quantProgVals[index]);
|
||||
quantProgVal->quality = block[boffset + 0];
|
||||
CopyMemory(quantProgVal->yQuantValues, &block[boffset + 1], 5);
|
||||
CopyMemory(quantProgVal->cbQuantValues, &block[boffset + 6], 5);
|
||||
CopyMemory(quantProgVal->crQuantValues, &block[boffset + 11], 5);
|
||||
boffset += 16;
|
||||
}
|
||||
|
||||
if ((blockLen - boffset) < region->tileDataSize)
|
||||
return -1021;
|
||||
|
||||
if (region->numTiles > progressive->cTiles)
|
||||
{
|
||||
progressive->tiles = (RFX_PROGRESSIVE_TILE*) realloc(progressive->tiles,
|
||||
region->numTiles * sizeof(RFX_PROGRESSIVE_TILE));
|
||||
progressive->cTiles = region->numTiles;
|
||||
}
|
||||
|
||||
region->tiles = progressive->tiles;
|
||||
|
||||
if (!region->tiles)
|
||||
return -1;
|
||||
|
||||
printf("numRects: %d numTiles: %d numQuant: %d numProgQuant: %d\n",
|
||||
region->numRects, region->numTiles, region->numQuant, region->numProgQuant);
|
||||
|
||||
status = progressive_process_tiles(progressive, &block[boffset], region->tileDataSize);
|
||||
|
||||
if (status < 0)
|
||||
return status;
|
||||
|
||||
boffset += (UINT32) status;
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
return -1039;
|
||||
break;
|
||||
}
|
||||
|
||||
if (boffset != blockLen)
|
||||
return -1040;
|
||||
|
||||
offset += blockLen;
|
||||
count++;
|
||||
}
|
||||
|
||||
if (offset != blocksLen)
|
||||
return -1041;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int progressive_compress(PROGRESSIVE_CONTEXT* progressive, BYTE* pSrcData, UINT32 SrcSize, BYTE** ppDstData, UINT32* pDstSize)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
void progressive_context_reset(PROGRESSIVE_CONTEXT* progressive)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
PROGRESSIVE_CONTEXT* progressive_context_new(BOOL Compressor)
|
||||
{
|
||||
PROGRESSIVE_CONTEXT* progressive;
|
||||
|
||||
progressive = (PROGRESSIVE_CONTEXT*) calloc(1, sizeof(PROGRESSIVE_CONTEXT));
|
||||
|
||||
if (progressive)
|
||||
{
|
||||
progressive->Compressor = Compressor;
|
||||
|
||||
progressive->bufferPool = BufferPool_New(TRUE, (8192 + 32) * 3, 16);
|
||||
|
||||
progressive->cRects = 64;
|
||||
progressive->rects = (RFX_RECT*) malloc(progressive->cRects * sizeof(RFX_RECT));
|
||||
|
||||
if (!progressive->rects)
|
||||
return NULL;
|
||||
|
||||
progressive->cTiles = 64;
|
||||
progressive->tiles = (RFX_PROGRESSIVE_TILE*) malloc(progressive->cTiles * sizeof(RFX_PROGRESSIVE_TILE));
|
||||
|
||||
if (!progressive->tiles)
|
||||
return NULL;
|
||||
|
||||
progressive->cQuant = 8;
|
||||
progressive->quantVals = (RFX_COMPONENT_CODEC_QUANT*) malloc(progressive->cQuant * sizeof(RFX_COMPONENT_CODEC_QUANT));
|
||||
|
||||
if (!progressive->quantVals)
|
||||
return NULL;
|
||||
|
||||
progressive->cProgQuant = 8;
|
||||
progressive->quantProgVals = (RFX_PROGRESSIVE_CODEC_QUANT*) malloc(progressive->cProgQuant * sizeof(RFX_PROGRESSIVE_CODEC_QUANT));
|
||||
|
||||
if (!progressive->quantProgVals)
|
||||
return NULL;
|
||||
|
||||
ZeroMemory(&(progressive->quantProgValFull), sizeof(RFX_PROGRESSIVE_CODEC_QUANT));
|
||||
progressive->quantProgValFull.quality = 100;
|
||||
|
||||
progressive_context_reset(progressive);
|
||||
}
|
||||
|
||||
return progressive;
|
||||
}
|
||||
|
||||
void progressive_context_free(PROGRESSIVE_CONTEXT* progressive)
|
||||
{
|
||||
if (!progressive)
|
||||
return;
|
||||
|
||||
BufferPool_Free(progressive->bufferPool);
|
||||
|
||||
free(progressive->rects);
|
||||
free(progressive->tiles);
|
||||
free(progressive->quantVals);
|
||||
free(progressive->quantProgVals);
|
||||
|
||||
free(progressive);
|
||||
}
|
||||
|
||||
|
|
@ -330,8 +330,6 @@ RFX_CONTEXT* rfx_context_new(BOOL encoder)
|
|||
context->quantization_encode = rfx_quantization_encode;
|
||||
context->dwt_2d_decode = rfx_dwt_2d_decode;
|
||||
context->dwt_2d_encode = rfx_dwt_2d_encode;
|
||||
context->rlgr_decode = rfx_rlgr_decode;
|
||||
context->rlgr_encode = rfx_rlgr_encode;
|
||||
|
||||
RFX_INIT_SIMD(context);
|
||||
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ static void rfx_decode_component(RFX_CONTEXT* context, const UINT32* quantizatio
|
|||
PROFILER_ENTER(context->priv->prof_rfx_decode_component);
|
||||
|
||||
PROFILER_ENTER(context->priv->prof_rfx_rlgr_decode);
|
||||
context->rlgr_decode(context->mode, data, size, buffer, 4096);
|
||||
rfx_rlgr_decode(data, size, buffer, 4096, (context->mode == RLGR1) ? 1 : 3);
|
||||
PROFILER_EXIT(context->priv->prof_rfx_rlgr_decode);
|
||||
|
||||
PROFILER_ENTER(context->priv->prof_rfx_differential_decode);
|
||||
|
|
|
|||
|
|
@ -209,7 +209,7 @@ static void rfx_encode_component(RFX_CONTEXT* context, const UINT32* quantizatio
|
|||
PROFILER_EXIT(context->priv->prof_rfx_differential_encode);
|
||||
|
||||
PROFILER_ENTER(context->priv->prof_rfx_rlgr_encode);
|
||||
*size = context->rlgr_encode(context->mode, data, 4096, buffer, buffer_size);
|
||||
*size = rfx_rlgr_encode(context->mode, data, 4096, buffer, buffer_size);
|
||||
PROFILER_EXIT(context->priv->prof_rfx_rlgr_encode);
|
||||
|
||||
PROFILER_EXIT(context->priv->prof_rfx_encode_component);
|
||||
|
|
|
|||
|
|
@ -31,43 +31,21 @@
|
|||
#include <string.h>
|
||||
|
||||
#include <winpr/crt.h>
|
||||
#include <winpr/print.h>
|
||||
#include <winpr/sysinfo.h>
|
||||
#include <winpr/bitstream.h>
|
||||
|
||||
#include "rfx_bitstream.h"
|
||||
|
||||
#include "rfx_rlgr.h"
|
||||
|
||||
/* Constants used within the RLGR1/RLGR3 algorithm */
|
||||
#define KPMAX (80) /* max value for kp or krp */
|
||||
#define LSGR (3) /* shift count to convert kp to k */
|
||||
#define UP_GR (4) /* increase in kp after a zero run in RL mode */
|
||||
#define DN_GR (6) /* decrease in kp after a nonzero symbol in RL mode */
|
||||
#define UQ_GR (3) /* increase in kp after nonzero symbol in GR mode */
|
||||
#define DQ_GR (3) /* decrease in kp after zero symbol in GR mode */
|
||||
|
||||
/* Gets (returns) the next nBits from the bitstream */
|
||||
#define GetBits(nBits, r) rfx_bitstream_get_bits(bs, nBits, r)
|
||||
|
||||
/* From current output pointer, write "value", check and update buffer_size */
|
||||
#define WriteValue(value) \
|
||||
{ \
|
||||
if (buffer_size > 0) \
|
||||
*dst++ = (value); \
|
||||
buffer_size--; \
|
||||
}
|
||||
|
||||
/* From current output pointer, write next nZeroes terms with value 0, check and update buffer_size */
|
||||
#define WriteZeroes(nZeroes) \
|
||||
{ \
|
||||
int nZeroesWritten = (nZeroes); \
|
||||
if (nZeroesWritten > buffer_size) \
|
||||
nZeroesWritten = buffer_size; \
|
||||
if (nZeroesWritten > 0) \
|
||||
{ \
|
||||
memset(dst, 0, nZeroesWritten * sizeof(INT16)); \
|
||||
dst += nZeroesWritten; \
|
||||
} \
|
||||
buffer_size -= (nZeroes); \
|
||||
}
|
||||
/* Constants used in RLGR1/RLGR3 algorithm */
|
||||
#define KPMAX (80) /* max value for kp or krp */
|
||||
#define LSGR (3) /* shift count to convert kp to k */
|
||||
#define UP_GR (4) /* increase in kp after a zero run in RL mode */
|
||||
#define DN_GR (6) /* decrease in kp after a nonzero symbol in RL mode */
|
||||
#define UQ_GR (3) /* increase in kp after nonzero symbol in GR mode */
|
||||
#define DQ_GR (3) /* decrease in kp after zero symbol in GR mode */
|
||||
|
||||
/* Returns the least number of bits required to represent a given value */
|
||||
#define GetMinBits(_val, _nbits) \
|
||||
|
|
@ -81,9 +59,6 @@
|
|||
} \
|
||||
}
|
||||
|
||||
/* Converts from (2 * magnitude - sign) to integer */
|
||||
#define GetIntFrom2MagSign(twoMs) (((twoMs) & 1) ? -1 * (INT16)(((twoMs) + 1) >> 1) : (INT16)((twoMs) >> 1))
|
||||
|
||||
/*
|
||||
* Update the passed parameter and clamp it to the range [0, KPMAX]
|
||||
* Return the value of parameter right-shifted by LSGR
|
||||
|
|
@ -98,147 +73,444 @@
|
|||
_k = (_param >> LSGR); \
|
||||
}
|
||||
|
||||
/* Outputs the Golomb/Rice encoding of a non-negative integer */
|
||||
#define GetGRCode(krp, kr, vk, _mag) \
|
||||
vk = 0; \
|
||||
_mag = 0; \
|
||||
/* chew up/count leading 1s and escape 0 */ \
|
||||
do { \
|
||||
GetBits(1, r); \
|
||||
if (r == 1) \
|
||||
vk++; \
|
||||
else \
|
||||
break; \
|
||||
} while (1); \
|
||||
/* get next *kr bits, and combine with leading 1s */ \
|
||||
GetBits(*kr, _mag); \
|
||||
_mag |= (vk << *kr); \
|
||||
/* adjust krp and kr based on vk */ \
|
||||
if (!vk) { \
|
||||
UpdateParam(*krp, -2, *kr); \
|
||||
} \
|
||||
else if (vk != 1) { \
|
||||
UpdateParam(*krp, vk, *kr); /* at 1, no change! */ \
|
||||
static BOOL g_LZCNT = FALSE;
|
||||
|
||||
static INLINE UINT32 lzcnt_s(UINT32 x)
|
||||
{
|
||||
if (!x)
|
||||
return 32;
|
||||
|
||||
if (!g_LZCNT)
|
||||
{
|
||||
UINT32 y;
|
||||
int n = 32;
|
||||
y = x >> 16; if (y != 0) { n = n - 16; x = y; }
|
||||
y = x >> 8; if (y != 0) { n = n - 8; x = y; }
|
||||
y = x >> 4; if (y != 0) { n = n - 4; x = y; }
|
||||
y = x >> 2; if (y != 0) { n = n - 2; x = y; }
|
||||
y = x >> 1; if (y != 0) return n - 2;
|
||||
return n - x;
|
||||
}
|
||||
|
||||
int rfx_rlgr_decode(RLGR_MODE mode, const BYTE* data, int data_size, INT16* buffer, int buffer_size)
|
||||
return __lzcnt(x);
|
||||
}
|
||||
|
||||
int rfx_rlgr_decode(const BYTE* pSrcData, UINT32 SrcSize, INT16* pDstData, UINT32 DstSize, int mode)
|
||||
{
|
||||
int k;
|
||||
int kp;
|
||||
int kr;
|
||||
int krp;
|
||||
UINT16 r;
|
||||
INT16* dst;
|
||||
RFX_BITSTREAM* bs;
|
||||
|
||||
int vk;
|
||||
UINT16 mag16;
|
||||
int run;
|
||||
int cnt;
|
||||
int size;
|
||||
int nbits;
|
||||
int offset;
|
||||
INT16 mag;
|
||||
int k, kp;
|
||||
int kr, krp;
|
||||
UINT16 code;
|
||||
UINT32 sign;
|
||||
UINT32 nIdx;
|
||||
UINT32 val1;
|
||||
UINT32 val2;
|
||||
INT16* pOutput;
|
||||
wBitStream* bs;
|
||||
wBitStream s_bs;
|
||||
|
||||
bs = (RFX_BITSTREAM*) malloc(sizeof(RFX_BITSTREAM));
|
||||
ZeroMemory(bs, sizeof(RFX_BITSTREAM));
|
||||
g_LZCNT = IsProcessorFeaturePresentEx(PF_EX_LZCNT);
|
||||
|
||||
rfx_bitstream_attach(bs, data, data_size);
|
||||
dst = buffer;
|
||||
|
||||
/* initialize the parameters */
|
||||
k = 1;
|
||||
kp = k << LSGR;
|
||||
|
||||
kr = 1;
|
||||
krp = kr << LSGR;
|
||||
|
||||
while (!rfx_bitstream_eos(bs) && buffer_size > 0)
|
||||
if ((mode != 1) && (mode != 3))
|
||||
mode = 1;
|
||||
|
||||
if (!pSrcData || !SrcSize)
|
||||
return -1;
|
||||
|
||||
if (!pDstData || !DstSize)
|
||||
return -1;
|
||||
|
||||
pOutput = pDstData;
|
||||
|
||||
bs = &s_bs;
|
||||
|
||||
BitStream_Attach(bs, pSrcData, SrcSize);
|
||||
BitStream_Fetch(bs);
|
||||
|
||||
while ((BitStream_GetRemainingLength(bs) > 0) && ((pOutput - pDstData) < DstSize))
|
||||
{
|
||||
int run;
|
||||
if (k)
|
||||
{
|
||||
int mag;
|
||||
UINT32 sign;
|
||||
/* Run-Length (RL) Mode */
|
||||
|
||||
/* RL MODE */
|
||||
while (!rfx_bitstream_eos(bs))
|
||||
run = 0;
|
||||
|
||||
/* count number of leading 0s */
|
||||
|
||||
cnt = lzcnt_s(bs->accumulator);
|
||||
|
||||
nbits = BitStream_GetRemainingLength(bs);
|
||||
|
||||
if (cnt > nbits)
|
||||
cnt = nbits;
|
||||
|
||||
vk = cnt;
|
||||
|
||||
while ((cnt == 32) && (BitStream_GetRemainingLength(bs) > 0))
|
||||
{
|
||||
GetBits(1, r);
|
||||
if (r)
|
||||
break;
|
||||
/* we have an RL escape "0", which translates to a run (1<<k) of zeros */
|
||||
WriteZeroes(1 << k);
|
||||
UpdateParam(kp, UP_GR, k); /* raise k and kp up because of zero run */
|
||||
BitStream_Shift32(bs);
|
||||
|
||||
cnt = lzcnt_s(bs->accumulator);
|
||||
|
||||
nbits = BitStream_GetRemainingLength(bs);
|
||||
|
||||
if (cnt > nbits)
|
||||
cnt = nbits;
|
||||
|
||||
vk += cnt;
|
||||
}
|
||||
|
||||
/* next k bits will contain remaining run or zeros */
|
||||
GetBits(k, run);
|
||||
WriteZeroes(run);
|
||||
BitStream_Shift(bs, (vk % 32));
|
||||
|
||||
/* get nonzero value, starting with sign bit and then GRCode for magnitude -1 */
|
||||
GetBits(1, sign);
|
||||
if (BitStream_GetRemainingLength(bs) < 1)
|
||||
break;
|
||||
|
||||
/* magnitude - 1 was coded (because it was nonzero) */
|
||||
GetGRCode(&krp, &kr, vk, mag16)
|
||||
mag = (int) (mag16 + 1);
|
||||
BitStream_Shift(bs, 1);
|
||||
|
||||
WriteValue(sign ? -mag : mag);
|
||||
UpdateParam(kp, -DN_GR, k); /* lower k and kp because of nonzero term */
|
||||
while (vk--)
|
||||
{
|
||||
run += (1 << k); /* add (1 << k) to run length */
|
||||
|
||||
/* update k, kp params */
|
||||
|
||||
kp += UP_GR;
|
||||
|
||||
if (kp > KPMAX)
|
||||
kp = KPMAX;
|
||||
|
||||
k = kp >> LSGR;
|
||||
}
|
||||
|
||||
/* next k bits contain run length remainder */
|
||||
|
||||
if (BitStream_GetRemainingLength(bs) < k)
|
||||
break;
|
||||
|
||||
bs->mask = ((1 << k) - 1);
|
||||
run += ((bs->accumulator >> (32 - k)) & bs->mask);
|
||||
BitStream_Shift(bs, k);
|
||||
|
||||
/* read sign bit */
|
||||
|
||||
if (BitStream_GetRemainingLength(bs) < 1)
|
||||
break;
|
||||
|
||||
sign = (bs->accumulator & 0x80000000) ? 1 : 0;
|
||||
BitStream_Shift(bs, 1);
|
||||
|
||||
/* count number of leading 1s */
|
||||
|
||||
cnt = lzcnt_s(~(bs->accumulator));
|
||||
|
||||
nbits = BitStream_GetRemainingLength(bs);
|
||||
|
||||
if (cnt > nbits)
|
||||
cnt = nbits;
|
||||
|
||||
vk = cnt;
|
||||
|
||||
while ((cnt == 32) && (BitStream_GetRemainingLength(bs) > 0))
|
||||
{
|
||||
BitStream_Shift32(bs);
|
||||
|
||||
cnt = lzcnt_s(~(bs->accumulator));
|
||||
|
||||
nbits = BitStream_GetRemainingLength(bs);
|
||||
|
||||
if (cnt > nbits)
|
||||
cnt = nbits;
|
||||
|
||||
vk += cnt;
|
||||
}
|
||||
|
||||
BitStream_Shift(bs, (vk % 32));
|
||||
|
||||
if (BitStream_GetRemainingLength(bs) < 1)
|
||||
break;
|
||||
|
||||
BitStream_Shift(bs, 1);
|
||||
|
||||
/* next kr bits contain code remainder */
|
||||
|
||||
if (BitStream_GetRemainingLength(bs) < kr)
|
||||
break;
|
||||
|
||||
bs->mask = ((1 << kr) - 1);
|
||||
code = (UINT16) ((bs->accumulator >> (32 - kr)) & bs->mask);
|
||||
BitStream_Shift(bs, kr);
|
||||
|
||||
/* add (vk << kr) to code */
|
||||
|
||||
code |= (vk << kr);
|
||||
|
||||
if (!vk)
|
||||
{
|
||||
/* update kr, krp params */
|
||||
|
||||
krp -= 2;
|
||||
|
||||
if (krp < 0)
|
||||
krp = 0;
|
||||
|
||||
kr = krp >> LSGR;
|
||||
}
|
||||
else if (vk != 1)
|
||||
{
|
||||
/* update kr, krp params */
|
||||
|
||||
krp += vk;
|
||||
|
||||
if (krp > KPMAX)
|
||||
krp = KPMAX;
|
||||
|
||||
kr = krp >> LSGR;
|
||||
}
|
||||
|
||||
/* update k, kp params */
|
||||
|
||||
kp -= DN_GR;
|
||||
|
||||
if (kp < 0)
|
||||
kp = 0;
|
||||
|
||||
k = kp >> LSGR;
|
||||
|
||||
/* compute magnitude from code */
|
||||
|
||||
if (sign)
|
||||
mag = ((INT16) (code + 1)) * -1;
|
||||
else
|
||||
mag = (INT16) (code + 1);
|
||||
|
||||
/* write to output stream */
|
||||
|
||||
offset = (int) (pOutput - pDstData);
|
||||
size = run;
|
||||
|
||||
if ((offset + size) > DstSize)
|
||||
size = DstSize - offset;
|
||||
|
||||
if (size)
|
||||
{
|
||||
ZeroMemory(pOutput, size * sizeof(INT16));
|
||||
pOutput += size;
|
||||
}
|
||||
|
||||
if ((pOutput - pDstData) < DstSize)
|
||||
{
|
||||
*pOutput = mag;
|
||||
pOutput++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
UINT32 mag;
|
||||
UINT32 nIdx;
|
||||
UINT32 val1;
|
||||
UINT32 val2;
|
||||
/* Golomb-Rice (GR) Mode */
|
||||
|
||||
/* GR (GOLOMB-RICE) MODE */
|
||||
GetGRCode(&krp, &kr, vk, mag16) /* values coded are 2 * magnitude - sign */
|
||||
mag = (UINT32) mag16;
|
||||
/* count number of leading 1s */
|
||||
|
||||
if (mode == RLGR1)
|
||||
cnt = lzcnt_s(~(bs->accumulator));
|
||||
|
||||
nbits = BitStream_GetRemainingLength(bs);
|
||||
|
||||
if (cnt > nbits)
|
||||
cnt = nbits;
|
||||
|
||||
vk = cnt;
|
||||
|
||||
while ((cnt == 32) && (BitStream_GetRemainingLength(bs) > 0))
|
||||
{
|
||||
if (!mag)
|
||||
BitStream_Shift32(bs);
|
||||
|
||||
cnt = lzcnt_s(~(bs->accumulator));
|
||||
|
||||
nbits = BitStream_GetRemainingLength(bs);
|
||||
|
||||
if (cnt > nbits)
|
||||
cnt = nbits;
|
||||
|
||||
vk += cnt;
|
||||
}
|
||||
|
||||
BitStream_Shift(bs, (vk % 32));
|
||||
|
||||
if (BitStream_GetRemainingLength(bs) < 1)
|
||||
break;
|
||||
|
||||
BitStream_Shift(bs, 1);
|
||||
|
||||
/* next kr bits contain code remainder */
|
||||
|
||||
if (BitStream_GetRemainingLength(bs) < kr)
|
||||
break;
|
||||
|
||||
bs->mask = ((1 << kr) - 1);
|
||||
code = (UINT16) ((bs->accumulator >> (32 - kr)) & bs->mask);
|
||||
BitStream_Shift(bs, kr);
|
||||
|
||||
/* add (vk << kr) to code */
|
||||
|
||||
code |= (vk << kr);
|
||||
|
||||
if (!vk)
|
||||
{
|
||||
/* update kr, krp params */
|
||||
|
||||
krp -= 2;
|
||||
|
||||
if (krp < 0)
|
||||
krp = 0;
|
||||
|
||||
kr = krp >> LSGR;
|
||||
}
|
||||
else if (vk != 1)
|
||||
{
|
||||
/* update kr, krp params */
|
||||
|
||||
krp += vk;
|
||||
|
||||
if (krp > KPMAX)
|
||||
krp = KPMAX;
|
||||
|
||||
kr = krp >> LSGR;
|
||||
}
|
||||
|
||||
if (mode == 1) /* RLGR1 */
|
||||
{
|
||||
if (!code)
|
||||
{
|
||||
WriteValue(0);
|
||||
UpdateParam(kp, UQ_GR, k); /* raise k and kp due to zero */
|
||||
/* update k, kp params */
|
||||
|
||||
kp += UQ_GR;
|
||||
|
||||
if (kp > KPMAX)
|
||||
kp = KPMAX;
|
||||
|
||||
k = kp >> LSGR;
|
||||
|
||||
mag = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
WriteValue(GetIntFrom2MagSign(mag));
|
||||
UpdateParam(kp, -DQ_GR, k); /* lower k and kp due to nonzero */
|
||||
/* update k, kp params */
|
||||
|
||||
kp -= DQ_GR;
|
||||
|
||||
if (kp < 0)
|
||||
kp = 0;
|
||||
|
||||
k = kp >> LSGR;
|
||||
|
||||
/*
|
||||
* code = 2 * mag - sign
|
||||
* sign + code = 2 * mag
|
||||
*/
|
||||
|
||||
if (code & 1)
|
||||
mag = ((INT16) ((code + 1) >> 1)) * -1;
|
||||
else
|
||||
mag = (INT16) (code >> 1);
|
||||
}
|
||||
|
||||
if ((pOutput - pDstData) < DstSize)
|
||||
{
|
||||
*pOutput = mag;
|
||||
pOutput++;
|
||||
}
|
||||
}
|
||||
else /* mode == RLGR3 */
|
||||
else if (mode == 3) /* RLGR3 */
|
||||
{
|
||||
/*
|
||||
* In GR mode FOR RLGR3, we have encoded the
|
||||
* sum of two (2 * mag - sign) values
|
||||
*/
|
||||
nIdx = 0;
|
||||
|
||||
/* maximum possible bits for first term */
|
||||
GetMinBits(mag, nIdx);
|
||||
if (code)
|
||||
{
|
||||
mag = (UINT32) code;
|
||||
nIdx = 32 - lzcnt_s(mag);
|
||||
}
|
||||
|
||||
/* decode val1 is first term's (2 * mag - sign) value */
|
||||
GetBits(nIdx, val1);
|
||||
if (BitStream_GetRemainingLength(bs) < nIdx)
|
||||
break;
|
||||
|
||||
/* val2 is second term's (2 * mag - sign) value */
|
||||
val2 = mag - val1;
|
||||
bs->mask = ((1 << nIdx) - 1);
|
||||
val1 = ((bs->accumulator >> (32 - nIdx)) & bs->mask);
|
||||
BitStream_Shift(bs, nIdx);
|
||||
|
||||
val2 = code - val1;
|
||||
|
||||
if (val1 && val2)
|
||||
{
|
||||
/* raise k and kp if both terms nonzero */
|
||||
UpdateParam(kp, -2 * DQ_GR, k);
|
||||
/* update k, kp params */
|
||||
|
||||
kp -= (2 * DQ_GR);
|
||||
|
||||
if (kp < 0)
|
||||
kp = 0;
|
||||
|
||||
k = kp >> LSGR;
|
||||
}
|
||||
else if (!val1 && !val2)
|
||||
{
|
||||
/* lower k and kp if both terms zero */
|
||||
UpdateParam(kp, 2 * UQ_GR, k);
|
||||
/* update k, kp params */
|
||||
|
||||
kp += (2 * UQ_GR);
|
||||
|
||||
if (kp > KPMAX)
|
||||
kp = KPMAX;
|
||||
|
||||
k = kp >> LSGR;
|
||||
}
|
||||
|
||||
WriteValue(GetIntFrom2MagSign(val1));
|
||||
WriteValue(GetIntFrom2MagSign(val2));
|
||||
if (val1 & 1)
|
||||
mag = ((INT16) ((val1 + 1) >> 1)) * -1;
|
||||
else
|
||||
mag = (INT16) (val1 >> 1);
|
||||
|
||||
if ((pOutput - pDstData) < DstSize)
|
||||
{
|
||||
*pOutput = mag;
|
||||
pOutput++;
|
||||
}
|
||||
|
||||
if (val2 & 1)
|
||||
mag = ((INT16) ((val2 + 1) >> 1)) * -1;
|
||||
else
|
||||
mag = (INT16) (val2 >> 1);
|
||||
|
||||
if ((pOutput - pDstData) < DstSize)
|
||||
{
|
||||
*pOutput = mag;
|
||||
pOutput++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
free(bs);
|
||||
offset = (int) (pOutput - pDstData);
|
||||
|
||||
return (dst - buffer);
|
||||
if (offset < DstSize)
|
||||
{
|
||||
size = DstSize - offset;
|
||||
ZeroMemory(pOutput, size * 2);
|
||||
pOutput += size;
|
||||
}
|
||||
|
||||
offset = (int) (pOutput - pDstData);
|
||||
|
||||
if (offset != DstSize)
|
||||
return -1;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Returns the next coefficient (a signed int) to encode, from the input stream */
|
||||
|
|
|
|||
|
|
@ -22,7 +22,6 @@
|
|||
|
||||
#include <freerdp/codec/rfx.h>
|
||||
|
||||
int rfx_rlgr_decode(RLGR_MODE mode, const BYTE* data, int data_size, INT16* buffer, int buffer_size);
|
||||
int rfx_rlgr_encode(RLGR_MODE mode, const INT16* data, int data_size, BYTE* buffer, int buffer_size);
|
||||
|
||||
#endif /* __RFX_RLGR_H */
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ set(${MODULE_PREFIX}_TESTS
|
|||
TestFreeRDPCodecZGfx.c
|
||||
TestFreeRDPCodecPlanar.c
|
||||
TestFreeRDPCodecClear.c
|
||||
TestFreeRDPCodecProgressive.c
|
||||
TestFreeRDPCodecRemoteFX.c)
|
||||
|
||||
create_test_sourcelist(${MODULE_PREFIX}_SRCS
|
||||
|
|
|
|||
|
|
@ -0,0 +1,10 @@
|
|||
#include <winpr/crt.h>
|
||||
#include <winpr/print.h>
|
||||
|
||||
#include <freerdp/codec/progressive.h>
|
||||
|
||||
int TestFreeRDPCodecProgressive(int argc, char* argv[])
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1626,6 +1626,12 @@ UINT32 freerdp_get_param_uint32(rdpSettings* settings, int id)
|
|||
case FreeRDP_EncryptionLevel:
|
||||
return settings->EncryptionLevel;
|
||||
|
||||
case FreeRDP_ServerRandomLength:
|
||||
return settings->ServerRandomLength;
|
||||
|
||||
case FreeRDP_ClientRandomLength:
|
||||
return settings->ClientRandomLength;
|
||||
|
||||
case FreeRDP_ChannelCount:
|
||||
return settings->ChannelCount;
|
||||
|
||||
|
|
@ -1737,6 +1743,10 @@ UINT32 freerdp_get_param_uint32(rdpSettings* settings, int id)
|
|||
case FreeRDP_KeyboardFunctionKey:
|
||||
return settings->KeyboardFunctionKey;
|
||||
|
||||
case FreeRDP_KeyboardHook:
|
||||
return settings->KeyboardHook;
|
||||
break;
|
||||
|
||||
case FreeRDP_BrushSupportLevel:
|
||||
return settings->BrushSupportLevel;
|
||||
|
||||
|
|
@ -1871,6 +1881,14 @@ int freerdp_set_param_uint32(rdpSettings* settings, int id, UINT32 param)
|
|||
settings->EncryptionLevel = param;
|
||||
break;
|
||||
|
||||
case FreeRDP_ServerRandomLength:
|
||||
settings->ServerRandomLength = param;
|
||||
break;
|
||||
|
||||
case FreeRDP_ClientRandomLength:
|
||||
settings->ClientRandomLength = param;
|
||||
break;
|
||||
|
||||
case FreeRDP_ChannelCount:
|
||||
settings->ChannelCount = param;
|
||||
break;
|
||||
|
|
@ -2019,6 +2037,10 @@ int freerdp_set_param_uint32(rdpSettings* settings, int id, UINT32 param)
|
|||
settings->KeyboardFunctionKey = param;
|
||||
break;
|
||||
|
||||
case FreeRDP_KeyboardHook:
|
||||
settings->KeyboardHook = param;
|
||||
break;
|
||||
|
||||
case FreeRDP_BrushSupportLevel:
|
||||
settings->BrushSupportLevel = param;
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -388,11 +388,14 @@ static BOOL rdp_client_establish_keys(rdpRdp* rdp)
|
|||
wStream* s;
|
||||
UINT32 length;
|
||||
UINT32 key_len;
|
||||
BYTE *crypt_client_random = NULL;
|
||||
BOOL ret = FALSE;
|
||||
int status = 0;
|
||||
BOOL ret = FALSE;
|
||||
rdpSettings* settings;
|
||||
BYTE* crypt_client_random = NULL;
|
||||
|
||||
if (!rdp->settings->DisableEncryption)
|
||||
settings = rdp->settings;
|
||||
|
||||
if (!settings->DisableEncryption)
|
||||
{
|
||||
/* no RDP encryption */
|
||||
return TRUE;
|
||||
|
|
@ -400,27 +403,30 @@ static BOOL rdp_client_establish_keys(rdpRdp* rdp)
|
|||
|
||||
/* encrypt client random */
|
||||
|
||||
if (rdp->settings->ClientRandom)
|
||||
free(rdp->settings->ClientRandom);
|
||||
if (settings->ClientRandom)
|
||||
free(settings->ClientRandom);
|
||||
|
||||
rdp->settings->ClientRandom = malloc(CLIENT_RANDOM_LENGTH);
|
||||
settings->ClientRandomLength = CLIENT_RANDOM_LENGTH;
|
||||
settings->ClientRandom = malloc(settings->ClientRandomLength);
|
||||
|
||||
if (!rdp->settings->ClientRandom)
|
||||
if (!settings->ClientRandom)
|
||||
return FALSE;
|
||||
|
||||
crypto_nonce(settings->ClientRandom, settings->ClientRandomLength);
|
||||
key_len = settings->RdpServerCertificate->cert_info.ModulusLength;
|
||||
mod = settings->RdpServerCertificate->cert_info.Modulus;
|
||||
exp = settings->RdpServerCertificate->cert_info.exponent;
|
||||
|
||||
crypto_nonce(rdp->settings->ClientRandom, CLIENT_RANDOM_LENGTH);
|
||||
key_len = rdp->settings->RdpServerCertificate->cert_info.ModulusLength;
|
||||
mod = rdp->settings->RdpServerCertificate->cert_info.Modulus;
|
||||
exp = rdp->settings->RdpServerCertificate->cert_info.exponent;
|
||||
/*
|
||||
* client random must be (bitlen / 8) + 8 - see [MS-RDPBCGR] 5.3.4.1
|
||||
* for details
|
||||
*/
|
||||
crypt_client_random = calloc(1,key_len+8);
|
||||
crypt_client_random = calloc(1, key_len + 8);
|
||||
|
||||
if (!crypt_client_random)
|
||||
return FALSE;
|
||||
crypto_rsa_public_encrypt(rdp->settings->ClientRandom, CLIENT_RANDOM_LENGTH, key_len, mod, exp, crypt_client_random);
|
||||
|
||||
crypto_rsa_public_encrypt(settings->ClientRandom, settings->ClientRandomLength, key_len, mod, exp, crypt_client_random);
|
||||
|
||||
/* send crypt client random to server */
|
||||
length = RDP_PACKET_HEADER_MAX_LENGTH + RDP_SECURITY_HEADER_LENGTH + 4 + key_len + 8;
|
||||
|
|
@ -441,15 +447,15 @@ static BOOL rdp_client_establish_keys(rdpRdp* rdp)
|
|||
goto end;
|
||||
|
||||
/* now calculate encrypt / decrypt and update keys */
|
||||
if (!security_establish_keys(rdp->settings->ClientRandom, rdp))
|
||||
if (!security_establish_keys(settings->ClientRandom, rdp))
|
||||
goto end;
|
||||
|
||||
rdp->do_crypt = TRUE;
|
||||
|
||||
if (rdp->settings->SaltedChecksum)
|
||||
if (settings->SaltedChecksum)
|
||||
rdp->do_secure_checksum = TRUE;
|
||||
|
||||
if (rdp->settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
|
||||
if (settings->EncryptionMethods == ENCRYPTION_METHOD_FIPS)
|
||||
{
|
||||
rdp->fips_encrypt = crypto_des3_encrypt_init(rdp->fips_encrypt_key, fips_ivec);
|
||||
if (!rdp->fips_encrypt)
|
||||
|
|
|
|||
|
|
@ -105,13 +105,31 @@ BOOL rdp_read_client_auto_reconnect_cookie(wStream* s, rdpSettings* settings)
|
|||
|
||||
void rdp_write_client_auto_reconnect_cookie(wStream* s, rdpSettings* settings)
|
||||
{
|
||||
CryptoHmac hmac;
|
||||
BYTE nullRandom[32];
|
||||
BYTE cryptSecurityVerifier[16];
|
||||
ARC_CS_PRIVATE_PACKET* autoReconnectCookie;
|
||||
autoReconnectCookie = settings->ClientAutoReconnectCookie;
|
||||
|
||||
/* SecurityVerifier = HMAC(AutoReconnectRandom, ClientRandom) */
|
||||
|
||||
hmac = crypto_hmac_new();
|
||||
ZeroMemory(nullRandom, sizeof(nullRandom));
|
||||
|
||||
crypto_hmac_md5_init(hmac, autoReconnectCookie->securityVerifier, 16);
|
||||
|
||||
if (settings->ClientRandomLength > 0)
|
||||
crypto_hmac_update(hmac, settings->ClientRandom, settings->ClientRandomLength);
|
||||
else
|
||||
crypto_hmac_update(hmac, nullRandom, sizeof(nullRandom));
|
||||
|
||||
crypto_hmac_final(hmac, cryptSecurityVerifier, 16);
|
||||
crypto_hmac_free(hmac);
|
||||
|
||||
Stream_Write_UINT32(s, autoReconnectCookie->cbLen); /* cbLen (4 bytes) */
|
||||
Stream_Write_UINT32(s, autoReconnectCookie->version); /* version (4 bytes) */
|
||||
Stream_Write_UINT32(s, autoReconnectCookie->logonId); /* LogonId (4 bytes) */
|
||||
Stream_Write(s, autoReconnectCookie->securityVerifier, 16); /* SecurityVerifier */
|
||||
Stream_Write(s, cryptSecurityVerifier, 16); /* SecurityVerifier */
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -431,6 +449,9 @@ void rdp_write_info_packet(wStream* s, rdpSettings* settings)
|
|||
if (settings->RemoteConsoleAudio)
|
||||
flags |= INFO_REMOTECONSOLEAUDIO;
|
||||
|
||||
if (settings->HiDefRemoteApp)
|
||||
flags |= INFO_HIDEF_RAIL_SUPPORTED;
|
||||
|
||||
if (settings->CompressionEnabled)
|
||||
{
|
||||
flags |= INFO_COMPRESSION;
|
||||
|
|
|
|||
|
|
@ -49,6 +49,7 @@
|
|||
#define INFO_USING_SAVED_CREDS 0x00100000
|
||||
#define INFO_AUDIOCAPTURE 0x00200000
|
||||
#define INFO_VIDEO_DISABLE 0x00400000
|
||||
#define INFO_HIDEF_RAIL_SUPPORTED 0x02000000
|
||||
|
||||
/* Logon Information Types */
|
||||
#define INFO_TYPE_LOGON 0x00000000
|
||||
|
|
|
|||
|
|
@ -522,6 +522,7 @@ rdpSettings* freerdp_settings_clone(rdpSettings* settings)
|
|||
_settings->EncryptionLevel = settings->EncryptionLevel; /* 195 */
|
||||
_settings->ServerRandomLength = settings->ServerRandomLength; /* 197 */
|
||||
_settings->ServerCertificateLength = settings->ServerCertificateLength; /* 199 */
|
||||
_settings->ClientRandomLength = settings->ClientRandomLength; /* 201 */
|
||||
_settings->ChannelCount = settings->ChannelCount; /* 256 */
|
||||
_settings->ChannelDefArraySize = settings->ChannelDefArraySize; /* 257 */
|
||||
_settings->ClusterInfoFlags = settings->ClusterInfoFlags; /* 320 */
|
||||
|
|
@ -563,6 +564,7 @@ rdpSettings* freerdp_settings_clone(rdpSettings* settings)
|
|||
_settings->KeyboardType = settings->KeyboardType; /* 2625 */
|
||||
_settings->KeyboardSubType = settings->KeyboardSubType; /* 2626 */
|
||||
_settings->KeyboardFunctionKey = settings->KeyboardFunctionKey; /* 2627 */
|
||||
_settings->KeyboardHook = settings->KeyboardHook; /* 2633 */
|
||||
_settings->BrushSupportLevel = settings->BrushSupportLevel; /* 2688 */
|
||||
_settings->GlyphSupportLevel = settings->GlyphSupportLevel; /* 2752 */
|
||||
_settings->OffscreenSupportLevel = settings->OffscreenSupportLevel; /* 2816 */
|
||||
|
|
@ -724,6 +726,18 @@ rdpSettings* freerdp_settings_clone(rdpSettings* settings)
|
|||
* Manual Code
|
||||
*/
|
||||
|
||||
if (_settings->ServerRandomLength)
|
||||
{
|
||||
_settings->ServerRandom = (BYTE*) malloc(_settings->ServerRandomLength);
|
||||
CopyMemory(_settings->ServerRandom, settings->ServerRandom, _settings->ServerRandomLength);
|
||||
}
|
||||
|
||||
if (_settings->ClientRandomLength)
|
||||
{
|
||||
_settings->ClientRandom = (BYTE*) malloc(_settings->ClientRandomLength);
|
||||
CopyMemory(_settings->ClientRandom, settings->ClientRandom, _settings->ClientRandomLength);
|
||||
}
|
||||
|
||||
_settings->ChannelCount = settings->ChannelCount;
|
||||
_settings->ChannelDefArraySize = settings->ChannelDefArraySize;
|
||||
_settings->ChannelDefArray = (CHANNEL_DEF*) malloc(sizeof(CHANNEL_DEF) * settings->ChannelDefArraySize);
|
||||
|
|
@ -835,7 +849,7 @@ void freerdp_settings_free(rdpSettings* settings)
|
|||
free(settings->ClientHostname);
|
||||
free(settings->ClientProductId);
|
||||
free(settings->ServerRandom);
|
||||
if (settings->ClientRandom) free(settings->ClientRandom);
|
||||
free(settings->ClientRandom);
|
||||
free(settings->ServerCertificate);
|
||||
free(settings->RdpKeyFile);
|
||||
certificate_free(settings->RdpServerCertificate);
|
||||
|
|
|
|||
|
|
@ -182,7 +182,7 @@ BOOL tpdu_read_connection_confirm(wStream* s, BYTE* li)
|
|||
*/
|
||||
bytes_read = (Stream_GetPosition(s) - position) - 1;
|
||||
|
||||
return (Stream_GetRemainingLength(s) >= (*li - bytes_read));
|
||||
return (Stream_GetRemainingLength(s) >= (size_t) (*li - bytes_read));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -981,6 +981,7 @@ void gdi_resize(rdpGdi* gdi, int width, int height)
|
|||
gdi->width = width;
|
||||
gdi->height = height;
|
||||
gdi_bitmap_free_ex(gdi->primary);
|
||||
gdi->primary_buffer = NULL;
|
||||
gdi_init_primary(gdi);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,11 +27,11 @@
|
|||
|
||||
struct _wBitStream
|
||||
{
|
||||
BYTE* buffer;
|
||||
const BYTE* buffer;
|
||||
BYTE* pointer;
|
||||
DWORD position;
|
||||
DWORD length;
|
||||
DWORD capacity;
|
||||
int position;
|
||||
int length;
|
||||
int capacity;
|
||||
UINT32 mask;
|
||||
UINT32 offset;
|
||||
UINT32 prefetch;
|
||||
|
|
@ -83,28 +83,38 @@ extern "C" {
|
|||
} while(0)
|
||||
|
||||
#define BitStream_Shift(_bs, _nbits) do { \
|
||||
_bs->accumulator <<= _nbits; \
|
||||
_bs->position += _nbits; \
|
||||
_bs->offset += _nbits; \
|
||||
if (_bs->offset < 32) { \
|
||||
_bs->mask = ((1 << _nbits) - 1); \
|
||||
_bs->accumulator |= ((_bs->prefetch >> (32 - _nbits)) & _bs->mask); \
|
||||
_bs->prefetch <<= _nbits; \
|
||||
} else { \
|
||||
_bs->mask = ((1 << _nbits) - 1); \
|
||||
_bs->accumulator |= ((_bs->prefetch >> (32 - _nbits)) & _bs->mask); \
|
||||
_bs->prefetch <<= _nbits; \
|
||||
_bs->offset -= 32; \
|
||||
_bs->pointer += 4; \
|
||||
BitStream_Prefetch(_bs); \
|
||||
if (_bs->offset) { \
|
||||
_bs->mask = ((1 << _bs->offset) - 1); \
|
||||
_bs->accumulator |= ((_bs->prefetch >> (32 - _bs->offset)) & _bs->mask); \
|
||||
_bs->prefetch <<= _bs->offset; \
|
||||
if (_nbits == 0) { \
|
||||
} else if ((_nbits > 0) && (_nbits < 32)) { \
|
||||
_bs->accumulator <<= _nbits; \
|
||||
_bs->position += _nbits; \
|
||||
_bs->offset += _nbits; \
|
||||
if (_bs->offset < 32) { \
|
||||
_bs->mask = ((1 << _nbits) - 1); \
|
||||
_bs->accumulator |= ((_bs->prefetch >> (32 - _nbits)) & _bs->mask); \
|
||||
_bs->prefetch <<= _nbits; \
|
||||
} else { \
|
||||
_bs->mask = ((1 << _nbits) - 1); \
|
||||
_bs->accumulator |= ((_bs->prefetch >> (32 - _nbits)) & _bs->mask); \
|
||||
_bs->prefetch <<= _nbits; \
|
||||
_bs->offset -= 32; \
|
||||
_bs->pointer += 4; \
|
||||
BitStream_Prefetch(_bs); \
|
||||
if (_bs->offset) { \
|
||||
_bs->mask = ((1 << _bs->offset) - 1); \
|
||||
_bs->accumulator |= ((_bs->prefetch >> (32 - _bs->offset)) & _bs->mask); \
|
||||
_bs->prefetch <<= _bs->offset; \
|
||||
} \
|
||||
} \
|
||||
} else { \
|
||||
fprintf(stderr, "warning: BitStream_Shift(%d)\n", _nbits); \
|
||||
} \
|
||||
} while(0)
|
||||
|
||||
#define BitStream_Shift32(_bs) do { \
|
||||
BitStream_Shift(_bs, 16); \
|
||||
BitStream_Shift(_bs, 16); \
|
||||
} while(0)
|
||||
|
||||
#define BitStream_Write_Bits(_bs, _bits, _nbits) do { \
|
||||
_bs->position += _nbits; \
|
||||
_bs->offset += _nbits; \
|
||||
|
|
@ -124,10 +134,13 @@ extern "C" {
|
|||
} \
|
||||
} while(0)
|
||||
|
||||
#define BitStream_GetRemainingLength(_bs) \
|
||||
(_bs->length - _bs->position)
|
||||
|
||||
WINPR_API void BitDump(const BYTE* buffer, UINT32 length, UINT32 flags);
|
||||
WINPR_API UINT32 ReverseBits32(UINT32 bits, UINT32 nbits);
|
||||
|
||||
WINPR_API void BitStream_Attach(wBitStream* bs, BYTE* buffer, UINT32 capacity);
|
||||
WINPR_API void BitStream_Attach(wBitStream* bs, const BYTE* buffer, UINT32 capacity);
|
||||
|
||||
WINPR_API wBitStream* BitStream_New();
|
||||
WINPR_API void BitStream_Free(wBitStream* bs);
|
||||
|
|
|
|||
|
|
@ -82,6 +82,47 @@ static INLINE UINT64 _rotr64(UINT64 value, int shift) {
|
|||
|
||||
#endif
|
||||
|
||||
/**
|
||||
* __lzcnt16, __lzcnt, __lzcnt64:
|
||||
* http://msdn.microsoft.com/en-us/library/bb384809/
|
||||
*/
|
||||
|
||||
#if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 2))
|
||||
|
||||
/**
|
||||
* __lzcnt16, __lzcnt, __lzcnt64:
|
||||
* http://msdn.microsoft.com/en-us/library/bb384809/
|
||||
*
|
||||
* Beware: the result of __builtin_clz(0) is undefined
|
||||
*/
|
||||
|
||||
static INLINE UINT32 __lzcnt(UINT32 _val32) {
|
||||
return _val32 ? ((UINT32) __builtin_clz(_val32)) : 32;
|
||||
}
|
||||
|
||||
static INLINE UINT16 __lzcnt16(UINT16 _val16) {
|
||||
return _val16 ? ((UINT16) (__builtin_clz((UINT32) _val16) - 16)) : 16;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static INLINE UINT32 __lzcnt(UINT32 x) {
|
||||
unsigned y;
|
||||
int n = 32;
|
||||
y = x >> 16; if (y != 0) { n = n - 16; x = y; }
|
||||
y = x >> 8; if (y != 0) { n = n - 8; x = y; }
|
||||
y = x >> 4; if (y != 0) { n = n - 4; x = y; }
|
||||
y = x >> 2; if (y != 0) { n = n - 2; x = y; }
|
||||
y = x >> 1; if (y != 0) return n - 2;
|
||||
return n - x;
|
||||
}
|
||||
|
||||
static INLINE UINT16 __lzcnt16(UINT16 x) {
|
||||
return ((UINT16) __lzcnt((UINT32) x));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#ifndef _WIN32
|
||||
|
|
|
|||
|
|
@ -298,20 +298,21 @@ WINPR_API ULONGLONG GetTickCount64(void);
|
|||
WINPR_API BOOL IsProcessorFeaturePresentEx(DWORD ProcessorFeature);
|
||||
|
||||
/* extended flags */
|
||||
#define PF_EX_3DNOW_PREFETCH 1
|
||||
#define PF_EX_SSSE3 2
|
||||
#define PF_EX_SSE41 3
|
||||
#define PF_EX_SSE42 4
|
||||
#define PF_EX_AVX 5
|
||||
#define PF_EX_FMA 6
|
||||
#define PF_EX_AVX_AES 7
|
||||
#define PF_EX_AVX2 8
|
||||
#define PF_EX_ARM_VFP1 9
|
||||
#define PF_EX_ARM_VFP3D16 10
|
||||
#define PF_EX_ARM_VFP4 11
|
||||
#define PF_EX_ARM_IDIVA 12
|
||||
#define PF_EX_ARM_IDIVT 13
|
||||
#define PF_EX_AVX_PCLMULQDQ 14
|
||||
#define PF_EX_LZCNT 1
|
||||
#define PF_EX_3DNOW_PREFETCH 2
|
||||
#define PF_EX_SSSE3 3
|
||||
#define PF_EX_SSE41 4
|
||||
#define PF_EX_SSE42 5
|
||||
#define PF_EX_AVX 6
|
||||
#define PF_EX_FMA 7
|
||||
#define PF_EX_AVX_AES 8
|
||||
#define PF_EX_AVX2 9
|
||||
#define PF_EX_ARM_VFP1 10
|
||||
#define PF_EX_ARM_VFP3D16 11
|
||||
#define PF_EX_ARM_VFP4 12
|
||||
#define PF_EX_ARM_IDIVA 13
|
||||
#define PF_EX_ARM_IDIVT 14
|
||||
#define PF_EX_AVX_PCLMULQDQ 15
|
||||
|
||||
/*
|
||||
* some "aliases" for the standard defines
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ set(${MODULE_PREFIX}_TESTS
|
|||
TestTypes.c
|
||||
TestAlignment.c
|
||||
TestString.c
|
||||
TestIntrinsics.c
|
||||
TestUnicodeConversion.c)
|
||||
|
||||
create_test_sourcelist(${MODULE_PREFIX}_SRCS
|
||||
|
|
|
|||
|
|
@ -0,0 +1,88 @@
|
|||
|
||||
#include <winpr/crt.h>
|
||||
#include <winpr/sysinfo.h>
|
||||
#include <winpr/windows.h>
|
||||
|
||||
static BOOL g_LZCNT = FALSE;
|
||||
|
||||
static INLINE UINT32 lzcnt_s(UINT32 x)
|
||||
{
|
||||
if (!x)
|
||||
return 32;
|
||||
|
||||
if (!g_LZCNT)
|
||||
{
|
||||
UINT32 y;
|
||||
int n = 32;
|
||||
y = x >> 16; if (y != 0) { n = n - 16; x = y; }
|
||||
y = x >> 8; if (y != 0) { n = n - 8; x = y; }
|
||||
y = x >> 4; if (y != 0) { n = n - 4; x = y; }
|
||||
y = x >> 2; if (y != 0) { n = n - 2; x = y; }
|
||||
y = x >> 1; if (y != 0) return n - 2;
|
||||
return n - x;
|
||||
}
|
||||
|
||||
return __lzcnt(x);
|
||||
}
|
||||
|
||||
int test_lzcnt()
|
||||
{
|
||||
if (lzcnt_s(0x1) != 31) {
|
||||
fprintf(stderr, "__lzcnt(0x1) != 31: %d\n", __lzcnt(0x1));
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (lzcnt_s(0xFF) != 24) {
|
||||
fprintf(stderr, "__lzcnt(0xFF) != 24\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (lzcnt_s(0xFFFF) != 16) {
|
||||
fprintf(stderr, "__lzcnt(0xFFFF) != 16\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (lzcnt_s(0xFFFFFF) != 8) {
|
||||
fprintf(stderr, "__lzcnt(0xFFFFFF) != 8\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (lzcnt_s(0xFFFFFFFF) != 0) {
|
||||
fprintf(stderr, "__lzcnt(0xFFFFFFFF) != 0\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int test_lzcnt16()
|
||||
{
|
||||
if (__lzcnt16(0x1) != 15) {
|
||||
fprintf(stderr, "__lzcnt16(0x1) != 15\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (__lzcnt16(0xFF) != 8) {
|
||||
fprintf(stderr, "__lzcnt16(0xFF) != 8\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (__lzcnt16(0xFFFF) != 0) {
|
||||
fprintf(stderr, "__lzcnt16(0xFFFF) != 0\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int TestIntrinsics(int argc, char* argv[])
|
||||
{
|
||||
g_LZCNT = IsProcessorFeaturePresentEx(PF_EX_LZCNT);
|
||||
|
||||
printf("LZCNT available: %d\n", g_LZCNT);
|
||||
|
||||
test_lzcnt();
|
||||
//test_lzcnt16();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -438,6 +438,7 @@ ULONGLONG GetTickCount64(void)
|
|||
#define D_BIT_3DN (1<<30)
|
||||
#define C_BIT_SSE3 (1<<0)
|
||||
#define C_BIT_PCLMULQDQ (1<<1)
|
||||
#define C_BIT_LZCNT (1<<5)
|
||||
#define C_BIT_3DNP (1<<8)
|
||||
#define C_BIT_3DNP (1<<8)
|
||||
#define C_BIT_SSSE3 (1<<9)
|
||||
|
|
@ -691,6 +692,10 @@ BOOL IsProcessorFeaturePresentEx(DWORD ProcessorFeature)
|
|||
|
||||
switch (ProcessorFeature)
|
||||
{
|
||||
case PF_EX_LZCNT:
|
||||
if (c & C_BIT_LZCNT)
|
||||
ret = TRUE;
|
||||
break;
|
||||
case PF_EX_3DNOW_PREFETCH:
|
||||
if (c & C_BIT_3DNP)
|
||||
ret = TRUE;
|
||||
|
|
|
|||
|
|
@ -316,13 +316,13 @@ void BitStream_Write_Bits(wBitStream* bs, UINT32 bits, UINT32 nbits)
|
|||
|
||||
#endif
|
||||
|
||||
void BitStream_Attach(wBitStream* bs, BYTE* buffer, UINT32 capacity)
|
||||
void BitStream_Attach(wBitStream* bs, const BYTE* buffer, UINT32 capacity)
|
||||
{
|
||||
bs->position = 0;
|
||||
bs->buffer = buffer;
|
||||
bs->offset = 0;
|
||||
bs->accumulator = 0;
|
||||
bs->pointer = bs->buffer;
|
||||
bs->pointer = (BYTE*) bs->buffer;
|
||||
bs->capacity = capacity;
|
||||
bs->length = bs->capacity * 8;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -44,6 +44,161 @@ static HMODULE g_WtsApiModule = NULL;
|
|||
|
||||
static PWtsApiFunctionTable g_WtsApi = NULL;
|
||||
|
||||
static HMODULE g_WtsApi32Module = NULL;
|
||||
|
||||
static WtsApiFunctionTable WtsApi32_WtsApiFunctionTable =
|
||||
{
|
||||
0, /* dwVersion */
|
||||
0, /* dwFlags */
|
||||
|
||||
NULL, /* StopRemoteControlSession */
|
||||
NULL, /* StartRemoteControlSessionW */
|
||||
NULL, /* StartRemoteControlSessionA */
|
||||
NULL, /* ConnectSessionW */
|
||||
NULL, /* ConnectSessionA */
|
||||
NULL, /* EnumerateServersW */
|
||||
NULL, /* EnumerateServersA */
|
||||
NULL, /* OpenServerW */
|
||||
NULL, /* OpenServerA */
|
||||
NULL, /* OpenServerExW */
|
||||
NULL, /* OpenServerExA */
|
||||
NULL, /* CloseServer */
|
||||
NULL, /* EnumerateSessionsW */
|
||||
NULL, /* EnumerateSessionsA */
|
||||
NULL, /* EnumerateSessionsExW */
|
||||
NULL, /* EnumerateSessionsExA */
|
||||
NULL, /* EnumerateProcessesW */
|
||||
NULL, /* EnumerateProcessesA */
|
||||
NULL, /* TerminateProcess */
|
||||
NULL, /* QuerySessionInformationW */
|
||||
NULL, /* QuerySessionInformationA */
|
||||
NULL, /* QueryUserConfigW */
|
||||
NULL, /* QueryUserConfigA */
|
||||
NULL, /* SetUserConfigW */
|
||||
NULL, /* SetUserConfigA */
|
||||
NULL, /* SendMessageW */
|
||||
NULL, /* SendMessageA */
|
||||
NULL, /* DisconnectSession */
|
||||
NULL, /* LogoffSession */
|
||||
NULL, /* ShutdownSystem */
|
||||
NULL, /* WaitSystemEvent */
|
||||
NULL, /* VirtualChannelOpen */
|
||||
NULL, /* VirtualChannelOpenEx */
|
||||
NULL, /* VirtualChannelClose */
|
||||
NULL, /* VirtualChannelRead */
|
||||
NULL, /* VirtualChannelWrite */
|
||||
NULL, /* VirtualChannelPurgeInput */
|
||||
NULL, /* VirtualChannelPurgeOutput */
|
||||
NULL, /* VirtualChannelQuery */
|
||||
NULL, /* FreeMemory */
|
||||
NULL, /* RegisterSessionNotification */
|
||||
NULL, /* UnRegisterSessionNotification */
|
||||
NULL, /* RegisterSessionNotificationEx */
|
||||
NULL, /* UnRegisterSessionNotificationEx */
|
||||
NULL, /* QueryUserToken */
|
||||
NULL, /* FreeMemoryExW */
|
||||
NULL, /* FreeMemoryExA */
|
||||
NULL, /* EnumerateProcessesExW */
|
||||
NULL, /* EnumerateProcessesExA */
|
||||
NULL, /* EnumerateListenersW */
|
||||
NULL, /* EnumerateListenersA */
|
||||
NULL, /* QueryListenerConfigW */
|
||||
NULL, /* QueryListenerConfigA */
|
||||
NULL, /* CreateListenerW */
|
||||
NULL, /* CreateListenerA */
|
||||
NULL, /* SetListenerSecurityW */
|
||||
NULL, /* SetListenerSecurityA */
|
||||
NULL, /* GetListenerSecurityW */
|
||||
NULL, /* GetListenerSecurityA */
|
||||
NULL, /* EnableChildSessions */
|
||||
NULL, /* IsChildSessionsEnabled */
|
||||
NULL, /* GetChildSessionId */
|
||||
NULL /* GetActiveConsoleSessionId */
|
||||
};
|
||||
|
||||
#define WTSAPI32_LOAD_PROC(_name, _type) \
|
||||
WtsApi32_WtsApiFunctionTable.p ## _name = (## _type) GetProcAddress(g_WtsApi32Module, "WTS" #_name);
|
||||
|
||||
int WtsApi32_InitializeWtsApi(void)
|
||||
{
|
||||
g_WtsApi32Module = LoadLibraryA("wtsapi32.dll");
|
||||
|
||||
if (!g_WtsApi32Module)
|
||||
return -1;
|
||||
|
||||
#ifdef _WIN32
|
||||
WTSAPI32_LOAD_PROC(StopRemoteControlSession, WTS_STOP_REMOTE_CONTROL_SESSION_FN);
|
||||
WTSAPI32_LOAD_PROC(StartRemoteControlSessionW, WTS_START_REMOTE_CONTROL_SESSION_FN_W);
|
||||
WTSAPI32_LOAD_PROC(StartRemoteControlSessionA, WTS_START_REMOTE_CONTROL_SESSION_FN_A);
|
||||
WTSAPI32_LOAD_PROC(ConnectSessionW, WTS_CONNECT_SESSION_FN_W);
|
||||
WTSAPI32_LOAD_PROC(ConnectSessionA, WTS_CONNECT_SESSION_FN_A);
|
||||
WTSAPI32_LOAD_PROC(EnumerateServersW, WTS_ENUMERATE_SERVERS_FN_W);
|
||||
WTSAPI32_LOAD_PROC(EnumerateServersA, WTS_ENUMERATE_SERVERS_FN_A);
|
||||
WTSAPI32_LOAD_PROC(OpenServerW, WTS_OPEN_SERVER_FN_W);
|
||||
WTSAPI32_LOAD_PROC(OpenServerA, WTS_OPEN_SERVER_FN_A);
|
||||
WTSAPI32_LOAD_PROC(OpenServerExW, WTS_OPEN_SERVER_EX_FN_W);
|
||||
WTSAPI32_LOAD_PROC(OpenServerExA, WTS_OPEN_SERVER_EX_FN_A);
|
||||
WTSAPI32_LOAD_PROC(CloseServer, WTS_CLOSE_SERVER_FN);
|
||||
WTSAPI32_LOAD_PROC(EnumerateSessionsW, WTS_ENUMERATE_SESSIONS_FN_W);
|
||||
WTSAPI32_LOAD_PROC(EnumerateSessionsA, WTS_ENUMERATE_SESSIONS_FN_A);
|
||||
WTSAPI32_LOAD_PROC(EnumerateSessionsExW, WTS_ENUMERATE_SESSIONS_EX_FN_W);
|
||||
WTSAPI32_LOAD_PROC(EnumerateSessionsExA, WTS_ENUMERATE_SESSIONS_EX_FN_A);
|
||||
WTSAPI32_LOAD_PROC(EnumerateProcessesW, WTS_ENUMERATE_PROCESSES_FN_W);
|
||||
WTSAPI32_LOAD_PROC(EnumerateProcessesA, WTS_ENUMERATE_PROCESSES_FN_A);
|
||||
WTSAPI32_LOAD_PROC(TerminateProcess, WTS_TERMINATE_PROCESS_FN);
|
||||
WTSAPI32_LOAD_PROC(QuerySessionInformationW, WTS_QUERY_SESSION_INFORMATION_FN_W);
|
||||
WTSAPI32_LOAD_PROC(QuerySessionInformationA, WTS_QUERY_SESSION_INFORMATION_FN_A);
|
||||
WTSAPI32_LOAD_PROC(QueryUserConfigW, WTS_QUERY_USER_CONFIG_FN_W);
|
||||
WTSAPI32_LOAD_PROC(QueryUserConfigA, WTS_QUERY_USER_CONFIG_FN_A);
|
||||
WTSAPI32_LOAD_PROC(SetUserConfigW, WTS_SET_USER_CONFIG_FN_W);
|
||||
WTSAPI32_LOAD_PROC(SetUserConfigA, WTS_SET_USER_CONFIG_FN_A);
|
||||
WTSAPI32_LOAD_PROC(SendMessageW, WTS_SEND_MESSAGE_FN_W);
|
||||
WTSAPI32_LOAD_PROC(SendMessageA, WTS_SEND_MESSAGE_FN_A);
|
||||
WTSAPI32_LOAD_PROC(DisconnectSession, WTS_DISCONNECT_SESSION_FN);
|
||||
WTSAPI32_LOAD_PROC(LogoffSession, WTS_LOGOFF_SESSION_FN);
|
||||
WTSAPI32_LOAD_PROC(ShutdownSystem, WTS_SHUTDOWN_SYSTEM_FN);
|
||||
WTSAPI32_LOAD_PROC(WaitSystemEvent, WTS_WAIT_SYSTEM_EVENT_FN);
|
||||
WTSAPI32_LOAD_PROC(VirtualChannelOpen, WTS_VIRTUAL_CHANNEL_OPEN_FN);
|
||||
WTSAPI32_LOAD_PROC(VirtualChannelOpenEx, WTS_VIRTUAL_CHANNEL_OPEN_EX_FN);
|
||||
WTSAPI32_LOAD_PROC(VirtualChannelClose, WTS_VIRTUAL_CHANNEL_CLOSE_FN);
|
||||
WTSAPI32_LOAD_PROC(VirtualChannelRead, WTS_VIRTUAL_CHANNEL_READ_FN);
|
||||
WTSAPI32_LOAD_PROC(VirtualChannelWrite, WTS_VIRTUAL_CHANNEL_WRITE_FN);
|
||||
WTSAPI32_LOAD_PROC(VirtualChannelPurgeInput, WTS_VIRTUAL_CHANNEL_PURGE_INPUT_FN);
|
||||
WTSAPI32_LOAD_PROC(VirtualChannelPurgeOutput, WTS_VIRTUAL_CHANNEL_PURGE_OUTPUT_FN);
|
||||
WTSAPI32_LOAD_PROC(VirtualChannelQuery, WTS_VIRTUAL_CHANNEL_QUERY_FN);
|
||||
WTSAPI32_LOAD_PROC(FreeMemory, WTS_FREE_MEMORY_FN);
|
||||
WTSAPI32_LOAD_PROC(RegisterSessionNotification, WTS_REGISTER_SESSION_NOTIFICATION_FN);
|
||||
WTSAPI32_LOAD_PROC(UnRegisterSessionNotification, WTS_UNREGISTER_SESSION_NOTIFICATION_FN);
|
||||
WTSAPI32_LOAD_PROC(RegisterSessionNotificationEx, WTS_REGISTER_SESSION_NOTIFICATION_EX_FN);
|
||||
WTSAPI32_LOAD_PROC(UnRegisterSessionNotificationEx, WTS_UNREGISTER_SESSION_NOTIFICATION_EX_FN);
|
||||
WTSAPI32_LOAD_PROC(QueryUserToken, WTS_QUERY_USER_TOKEN_FN);
|
||||
WTSAPI32_LOAD_PROC(FreeMemoryExW, WTS_FREE_MEMORY_EX_FN_W);
|
||||
WTSAPI32_LOAD_PROC(FreeMemoryExA, WTS_FREE_MEMORY_EX_FN_A);
|
||||
WTSAPI32_LOAD_PROC(EnumerateProcessesExW, WTS_ENUMERATE_PROCESSES_EX_FN_W);
|
||||
WTSAPI32_LOAD_PROC(EnumerateProcessesExA, WTS_ENUMERATE_PROCESSES_EX_FN_A);
|
||||
WTSAPI32_LOAD_PROC(EnumerateListenersW, WTS_ENUMERATE_LISTENERS_FN_W);
|
||||
WTSAPI32_LOAD_PROC(EnumerateListenersA, WTS_ENUMERATE_LISTENERS_FN_A);
|
||||
WTSAPI32_LOAD_PROC(QueryListenerConfigW, WTS_QUERY_LISTENER_CONFIG_FN_W);
|
||||
WTSAPI32_LOAD_PROC(QueryListenerConfigA, WTS_QUERY_LISTENER_CONFIG_FN_A);
|
||||
WTSAPI32_LOAD_PROC(CreateListenerW, WTS_CREATE_LISTENER_FN_W);
|
||||
WTSAPI32_LOAD_PROC(CreateListenerA, WTS_CREATE_LISTENER_FN_A);
|
||||
WTSAPI32_LOAD_PROC(SetListenerSecurityW, WTS_SET_LISTENER_SECURITY_FN_W);
|
||||
WTSAPI32_LOAD_PROC(SetListenerSecurityA, WTS_SET_LISTENER_SECURITY_FN_A);
|
||||
WTSAPI32_LOAD_PROC(GetListenerSecurityW, WTS_GET_LISTENER_SECURITY_FN_W);
|
||||
WTSAPI32_LOAD_PROC(GetListenerSecurityA, WTS_GET_LISTENER_SECURITY_FN_A);
|
||||
WTSAPI32_LOAD_PROC(EnableChildSessions, WTS_ENABLE_CHILD_SESSIONS_FN);
|
||||
WTSAPI32_LOAD_PROC(IsChildSessionsEnabled, WTS_IS_CHILD_SESSIONS_ENABLED_FN);
|
||||
WTSAPI32_LOAD_PROC(GetChildSessionId, WTS_GET_CHILD_SESSION_ID_FN);
|
||||
WTSAPI32_LOAD_PROC(GetActiveConsoleSessionId, WTS_GET_ACTIVE_CONSOLE_SESSION_ID_FN);
|
||||
#endif
|
||||
|
||||
g_WtsApi = &WtsApi32_WtsApiFunctionTable;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* WtsApi Functions */
|
||||
|
||||
BOOL WINAPI WTSStartRemoteControlSessionW(LPWSTR pTargetServerName, ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers)
|
||||
{
|
||||
WTSAPI_STUB_CALL_BOOL(StartRemoteControlSessionW, pTargetServerName, TargetLogonId, HotkeyVk, HotkeyModifiers);
|
||||
|
|
@ -432,11 +587,13 @@ void InitializeWtsApiStubs_Env()
|
|||
|
||||
env = (LPSTR) malloc(nSize);
|
||||
nSize = GetEnvironmentVariableA("WTSAPI_LIBRARY", env, nSize);
|
||||
|
||||
if (env)
|
||||
LoadAndInitialize(env);
|
||||
}
|
||||
|
||||
#define FREERDS_LIBRARY_NAME "libfreerds-fdsapi.so"
|
||||
|
||||
void InitializeWtsApiStubs_FreeRDS()
|
||||
{
|
||||
char* prefix;
|
||||
|
|
@ -489,7 +646,11 @@ void InitializeWtsApiStubs(void)
|
|||
g_Initialized = TRUE;
|
||||
|
||||
InitializeWtsApiStubs_Env();
|
||||
|
||||
|
||||
#ifdef _WIN32
|
||||
WtsApi32_InitializeWtsApi();
|
||||
#endif
|
||||
|
||||
if (!g_WtsApi)
|
||||
InitializeWtsApiStubs_FreeRDS();
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue