void wf_update_encoder_reset(wfInfo* wfi)
{
if (wf_info_lock(wfi) > 0)
{
printf("Resetting encoder\n");
if (wfi->rfx_context)
{
rfx_context_reset(wfi->rfx_context);
}
else
{
wfi->rfx_context = rfx_context_new();
wfi->rfx_context->mode = RLGR3;
wfi->rfx_context->width = wfi->width;
wfi->rfx_context->height = wfi->height;
rfx_context_set_pixel_format(wfi->rfx_context, RDP_PIXEL_FORMAT_B8G8R8A8);
wfi->s = stream_new(0xFFFF);
}
wf_info_invalidate_full_screen(wfi);
wf_info_unlock(wfi);
}
}
int freerds_encoder_init_rfx(rdsEncoder* encoder)
{
rdpSettings* settings = encoder->connection->settings;
if (!encoder->rfx)
encoder->rfx = rfx_context_new(TRUE);
if (!encoder->rfx)
return -1;
encoder->rfx->mode = RLGR3;
encoder->rfx->width = encoder->width;
encoder->rfx->height = encoder->height;
rfx_context_set_pixel_format(encoder->rfx, RDP_PIXEL_FORMAT_B8G8R8A8);
if (!encoder->frameList)
{
encoder->fps = 16;
encoder->maxFps = 32;
encoder->frameId = 0;
encoder->frameList = ListDictionary_New(TRUE);
encoder->frameAck = settings->SurfaceFrameMarkerEnabled;
}
encoder->codecs |= FREERDP_CODEC_REMOTEFX;
return 1;
}
int shadow_encoder_init_rfx(rdpShadowEncoder* encoder)
{
rdpContext* context = (rdpContext*) encoder->client;
rdpSettings* settings = context->settings;
if (!encoder->rfx)
encoder->rfx = rfx_context_new(TRUE);
if (!encoder->rfx)
goto fail;
if (!rfx_context_reset(encoder->rfx, encoder->width, encoder->height))
goto fail;
encoder->rfx->mode = RLGR3;
encoder->rfx->width = encoder->width;
encoder->rfx->height = encoder->height;
rfx_context_set_pixel_format(encoder->rfx, RDP_PIXEL_FORMAT_B8G8R8A8);
encoder->fps = 16;
encoder->maxFps = 32;
encoder->frameId = 0;
encoder->lastAckframeId = 0;
encoder->frameAck = settings->SurfaceFrameMarkerEnabled;
encoder->codecs |= FREERDP_CODEC_REMOTEFX;
return 1;
fail:
rfx_context_free(encoder->rfx);
return -1;
}
int shadow_encoder_init_rfx(rdpShadowEncoder* encoder)
{
if (!encoder->rfx)
encoder->rfx = rfx_context_new(TRUE);
if (!encoder->rfx)
return -1;
encoder->rfx->mode = RLGR3;
encoder->rfx->width = encoder->width;
encoder->rfx->height = encoder->height;
rfx_context_set_pixel_format(encoder->rfx, RDP_PIXEL_FORMAT_B8G8R8A8);
if (!encoder->frameList)
{
encoder->fps = 16;
encoder->maxFps = 32;
encoder->frameId = 0;
encoder->frameAck = TRUE;
encoder->frameList = ListDictionary_New(TRUE);
}
encoder->codecs |= SHADOW_CODEC_REMOTEFX;
return 1;
}
void
test_decode(void)
{
RFX_CONTEXT * context;
unsigned char * decode_buffer;
context = rfx_context_new();
context->mode = RLGR3;
rfx_context_set_pixel_format(context, RFX_PIXEL_FORMAT_RGB);
decode_buffer = rfx_decode_rgb(context,
y_data, sizeof(y_data), test_quantization_values,
cb_data, sizeof(cb_data), test_quantization_values,
cr_data, sizeof(cr_data), test_quantization_values);
rfx_context_free(context);
/* Dump a .ppm image. */
static int frame_id = 0;
char buf[100];
FILE * fp;
snprintf(buf, sizeof(buf), "/tmp/FreeRDP_Frame_%d.ppm", frame_id);
fp = fopen(buf, "wb");
fwrite("P6\n", 1, 3, fp);
fwrite("64 64\n", 1, 6, fp);
fwrite("255\n", 1, 4, fp);
fwrite(decode_buffer, 1, 4096 * 3, fp);
fflush(fp);
fclose(fp);
frame_id++;
free(decode_buffer);
}
static boolean remmina_rdp_pre_connect(freerdp* instance)
{
rfContext* rfi;
rdpSettings* settings;
RemminaProtocolWidget* gp;
rfi = (rfContext*) instance->context;
settings = instance->settings;
gp = rfi->protocol_widget;
settings->bitmap_cache = True;
settings->offscreen_bitmap_cache = True;
settings->order_support[NEG_DSTBLT_INDEX] = True;
settings->order_support[NEG_PATBLT_INDEX] = True;
settings->order_support[NEG_SCRBLT_INDEX] = True;
settings->order_support[NEG_OPAQUE_RECT_INDEX] = True;
settings->order_support[NEG_DRAWNINEGRID_INDEX] = False;
settings->order_support[NEG_MULTIDSTBLT_INDEX] = False;
settings->order_support[NEG_MULTIPATBLT_INDEX] = False;
settings->order_support[NEG_MULTISCRBLT_INDEX] = False;
settings->order_support[NEG_MULTIOPAQUERECT_INDEX] = True;
settings->order_support[NEG_MULTI_DRAWNINEGRID_INDEX] = False;
settings->order_support[NEG_LINETO_INDEX] = True;
settings->order_support[NEG_POLYLINE_INDEX] = True;
settings->order_support[NEG_MEMBLT_INDEX] = True;
settings->order_support[NEG_MEM3BLT_INDEX] = False;
settings->order_support[NEG_MEMBLT_V2_INDEX] = True;
settings->order_support[NEG_MEM3BLT_V2_INDEX] = False;
settings->order_support[NEG_SAVEBITMAP_INDEX] = False;
settings->order_support[NEG_GLYPH_INDEX_INDEX] = True;
settings->order_support[NEG_FAST_INDEX_INDEX] = True;
settings->order_support[NEG_FAST_GLYPH_INDEX] = False;
settings->order_support[NEG_POLYGON_SC_INDEX] = False;
settings->order_support[NEG_POLYGON_CB_INDEX] = False;
settings->order_support[NEG_ELLIPSE_SC_INDEX] = False;
settings->order_support[NEG_ELLIPSE_CB_INDEX] = False;
if (settings->rfx_codec == True)
{
settings->frame_acknowledge = False;
settings->large_pointer = True;
settings->performance_flags = PERF_FLAG_NONE;
rfi->rfx_context = rfx_context_new();
rfx_context_set_cpu_opt(rfi->rfx_context, CPU_SSE2);
}
freerdp_channels_pre_connect(rfi->channels, instance);
rfi->clrconv = xnew(CLRCONV);
rfi->clrconv->alpha = true;
rfi->clrconv->invert = false;
rfi->clrconv->rgb555 = false;
rfi->clrconv->palette = xnew(rdpPalette);
instance->context->cache = cache_new(instance->settings);
return True;
}
void test_decode(void)
{
RFX_CONTEXT* context;
BYTE decode_buffer[4096 * 3];
STREAM* s;
s = stream_new(sizeof(y_data) + sizeof(cb_data) + sizeof(cr_data));
stream_write(s, y_data, sizeof(y_data));
stream_write(s, cb_data, sizeof(cb_data));
stream_write(s, cr_data, sizeof(cr_data));
stream_set_pos(s, 0);
context = rfx_context_new();
context->mode = RLGR3;
rfx_context_set_pixel_format(context, RDP_PIXEL_FORMAT_R8G8B8);
rfx_decode_rgb(context, s,
sizeof(y_data), test_quantization_values,
sizeof(cb_data), test_quantization_values,
sizeof(cr_data), test_quantization_values,
decode_buffer);
rfx_context_free(context);
stream_free(s);
dump_ppm_image(decode_buffer);
}
int xf_ResetGraphics(RdpgfxClientContext* context, RDPGFX_RESET_GRAPHICS_PDU* resetGraphics)
{
xfContext* xfc = (xfContext*) context->custom;
if (xfc->codecs->rfx)
{
rfx_context_free(xfc->codecs->rfx);
xfc->codecs->rfx = NULL;
}
xfc->codecs->rfx = rfx_context_new(FALSE);
xfc->codecs->rfx->width = resetGraphics->width;
xfc->codecs->rfx->height = resetGraphics->height;
rfx_context_set_pixel_format(xfc->codecs->rfx, RDP_PIXEL_FORMAT_B8G8R8A8);
if (xfc->codecs->nsc)
{
nsc_context_free(xfc->codecs->nsc);
xfc->codecs->nsc = NULL;
}
xfc->codecs->nsc = nsc_context_new();
xfc->codecs->nsc->width = resetGraphics->width;
xfc->codecs->nsc->height = resetGraphics->height;
nsc_context_set_pixel_format(xfc->codecs->nsc, RDP_PIXEL_FORMAT_B8G8R8A8);
if (xfc->codecs->clear)
{
clear_context_free(xfc->codecs->clear);
xfc->codecs->clear = NULL;
}
xfc->codecs->clear = clear_context_new(FALSE);
if (xfc->codecs->h264)
{
h264_context_free(xfc->codecs->h264);
xfc->codecs->h264 = NULL;
}
xfc->codecs->h264 = h264_context_new(FALSE);
if (xfc->codecs->progressive)
{
progressive_context_free(xfc->codecs->progressive);
xfc->codecs->progressive = NULL;
}
xfc->codecs->progressive = progressive_context_new(TRUE);
region16_init(&(xfc->invalidRegion));
xfc->graphicsReset = TRUE;
return 1;
}
static BOOL remmina_rdp_pre_connect(freerdp* instance)
{
rfContext* rfi;
ALIGN64 rdpSettings* settings;
RemminaProtocolWidget* gp;
rdpChannels *channels;
rfi = (rfContext*) instance->context;
settings = instance->settings;
gp = rfi->protocol_widget;
channels = instance->context->channels;
settings->BitmapCacheEnabled = True;
settings->OffscreenSupportLevel = True;
settings->OrderSupport[NEG_DSTBLT_INDEX] = True;
settings->OrderSupport[NEG_PATBLT_INDEX] = True;
settings->OrderSupport[NEG_SCRBLT_INDEX] = True;
settings->OrderSupport[NEG_OPAQUE_RECT_INDEX] = True;
settings->OrderSupport[NEG_DRAWNINEGRID_INDEX] = False;
settings->OrderSupport[NEG_MULTIDSTBLT_INDEX] = False;
settings->OrderSupport[NEG_MULTIPATBLT_INDEX] = False;
settings->OrderSupport[NEG_MULTISCRBLT_INDEX] = False;
settings->OrderSupport[NEG_MULTIOPAQUERECT_INDEX] = True;
settings->OrderSupport[NEG_MULTI_DRAWNINEGRID_INDEX] = False;
settings->OrderSupport[NEG_LINETO_INDEX] = True;
settings->OrderSupport[NEG_POLYLINE_INDEX] = True;
settings->OrderSupport[NEG_MEMBLT_INDEX] = settings->BitmapCacheEnabled;
settings->OrderSupport[NEG_MEM3BLT_INDEX] = True;
settings->OrderSupport[NEG_MEMBLT_V2_INDEX] = settings->BitmapCacheEnabled;
settings->OrderSupport[NEG_MEM3BLT_V2_INDEX] = False;
settings->OrderSupport[NEG_SAVEBITMAP_INDEX] = False;
settings->OrderSupport[NEG_GLYPH_INDEX_INDEX] = True;
settings->OrderSupport[NEG_FAST_INDEX_INDEX] = True;
settings->OrderSupport[NEG_FAST_GLYPH_INDEX] = True;
settings->OrderSupport[NEG_POLYGON_SC_INDEX] = False;
settings->OrderSupport[NEG_POLYGON_CB_INDEX] = False;
settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = False;
settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = False;
if (settings->RemoteFxCodec == True)
{
settings->FrameAcknowledge = False;
settings->LargePointerFlag = True;
settings->PerformanceFlags = PERF_FLAG_NONE;
rfi->rfx_context = rfx_context_new();
}
freerdp_client_load_addins(instance->context->channels, instance->settings);
freerdp_channels_pre_connect(instance->context->channels, instance);
rfi->clrconv = freerdp_clrconv_new(CLRCONV_ALPHA);
instance->context->cache = cache_new(instance->settings);
return True;
}
void test_dwt(void)
{
RFX_CONTEXT* context;
context = rfx_context_new();
rfx_dwt_2d_decode(buffer, context->priv->dwt_buffer);
//dump_buffer(buffer, 4096);
rfx_context_free(context);
}
void test_peer_context_new(freerdp_peer* client, testPeerContext* context)
{
context->rfx_context = rfx_context_new();
context->rfx_context->mode = RLGR3;
context->rfx_context->width = client->settings->width;
context->rfx_context->height = client->settings->height;
rfx_context_set_pixel_format(context->rfx_context, RFX_PIXEL_FORMAT_RGB);
context->s = stream_new(65536);
context->icon_x = -1;
context->icon_y = -1;
}
void
xf_decode_init(xfInfo * xfi)
{
switch (xfi->codec)
{
case XF_CODEC_REMOTEFX:
xfi->rfx_context = rfx_context_new();
break;
default:
break;
}
}
void mf_peer_context_new(freerdp_peer* client, mfPeerContext* context)
{
context->rfx_context = rfx_context_new();
context->rfx_context->mode = RLGR3;
context->rfx_context->width = client->settings->DesktopWidth;
context->rfx_context->height = client->settings->DesktopHeight;
rfx_context_set_pixel_format(context->rfx_context, RDP_PIXEL_FORMAT_R8G8B8);
context->nsc_context = nsc_context_new();
nsc_context_set_pixel_format(context->nsc_context, RDP_PIXEL_FORMAT_R8G8B8);
context->s = stream_new(0xFFFF);
context->vcm = WTSCreateVirtualChannelManager(client);
}
void test_message(void)
{
RFX_CONTEXT* context;
STREAM* s;
int i, j;
RFX_RECT rect = {0, 0, 100, 80};
RFX_MESSAGE * message;
rgb_data = (BYTE *) malloc(100 * 80 * 3);
for (i = 0; i < 80; i++)
memcpy(rgb_data + i * 100 * 3, rgb_scanline_data, 100 * 3);
s = stream_new(65536);
stream_clear(s);
context = rfx_context_new();
context->mode = RLGR3;
context->width = 800;
context->height = 600;
rfx_context_set_pixel_format(context, RDP_PIXEL_FORMAT_R8G8B8);
for (i = 0; i < 1000; i++)
{
s = stream_new(65536);
stream_clear(s);
rfx_compose_message(context, s,
&rect, 1, rgb_data, 100, 80, 100 * 3);
stream_seal(s);
/*hexdump(buffer, size);*/
stream_set_pos(s, 0);
message = rfx_process_message(context, s->p, s->size);
if (i == 0)
{
for (j = 0; j < message->num_tiles; j++)
{
dump_ppm_image(message->tiles[j]->data);
}
}
rfx_message_free(context, message);
stream_free(s);
}
rfx_context_free(context);
free(rgb_data);
}
void test_peer_context_new(freerdp_peer* client, testPeerContext* context)
{
context->rfx_context = rfx_context_new(TRUE);
context->rfx_context->mode = RLGR3;
context->rfx_context->width = SAMPLE_SERVER_DEFAULT_WIDTH;
context->rfx_context->height = SAMPLE_SERVER_DEFAULT_HEIGHT;
rfx_context_set_pixel_format(context->rfx_context, RDP_PIXEL_FORMAT_R8G8B8);
context->nsc_context = nsc_context_new();
nsc_context_set_pixel_format(context->nsc_context, RDP_PIXEL_FORMAT_R8G8B8);
context->s = Stream_New(NULL, 65536);
context->icon_x = -1;
context->icon_y = -1;
context->vcm = WTSOpenServerA((LPSTR) client->context);
}
void test_peer_context_new(freerdp_peer* client, testPeerContext* context)
{
context->rfx_context = rfx_context_new();
context->rfx_context->mode = RLGR3;
context->rfx_context->width = client->settings->width;
context->rfx_context->height = client->settings->height;
rfx_context_set_pixel_format(context->rfx_context, RDP_PIXEL_FORMAT_R8G8B8);
context->nsc_context = nsc_context_new();
nsc_context_set_pixel_format(context->nsc_context, RDP_PIXEL_FORMAT_R8G8B8);
context->s = stream_new(65536);
context->icon_x = -1;
context->icon_y = -1;
context->vcm = WTSCreateVirtualChannelManager(client);
}
void
test_decode(void)
{
RFX_CONTEXT * context;
uint8 decode_buffer[4096 * 3];
context = rfx_context_new();
context->mode = RLGR3;
rfx_context_set_pixel_format(context, RFX_PIXEL_FORMAT_RGB);
rfx_decode_rgb(context,
y_data, sizeof(y_data), test_quantization_values,
cb_data, sizeof(cb_data), test_quantization_values,
cr_data, sizeof(cr_data), test_quantization_values,
decode_buffer);
rfx_context_free(context);
dump_ppm_image(decode_buffer);
}
void test_peer_context_new(freerdp_peer* client, testPeerContext* context)
{
context->rfx_context = rfx_context_new();
context->rfx_context->mode = RLGR3;
context->rfx_context->width = SAMPLE_SERVER_DEFAULT_WIDTH;
context->rfx_context->height = SAMPLE_SERVER_DEFAULT_HEIGHT;
rfx_context_set_pixel_format(context->rfx_context, RDP_PIXEL_FORMAT_R8G8B8);
context->nsc_context = nsc_context_new();
nsc_context_set_pixel_format(context->nsc_context, RDP_PIXEL_FORMAT_R8G8B8);
context->s = Stream_New(NULL, 65536);
context->icon_x = -1;
context->icon_y = -1;
context->vcm = WTSCreateVirtualChannelManager(client);
}
void test_encode(void)
{
RFX_CONTEXT* context;
STREAM* enc_stream;
int y_size, cb_size, cr_size;
int i;
BYTE decode_buffer[4096 * 3];
rgb_data = (BYTE *) malloc(64 * 64 * 3);
for (i = 0; i < 64; i++)
memcpy(rgb_data + i * 64 * 3, rgb_scanline_data, 64 * 3);
//freerdp_hexdump(rgb_data, 64 * 64 * 3);
enc_stream = stream_new(65536);
stream_clear(enc_stream);
context = rfx_context_new();
context->mode = RLGR3;
rfx_context_set_pixel_format(context, RDP_PIXEL_FORMAT_R8G8B8);
rfx_encode_rgb(context, rgb_data, 64, 64, 64 * 3,
test_quantization_values, test_quantization_values, test_quantization_values,
enc_stream, &y_size, &cb_size, &cr_size);
//dump_buffer(context->priv->cb_g_buffer, 4096);
/*printf("*** Y ***\n");
freerdp_hexdump(stream_get_head(enc_stream), y_size);
printf("*** Cb ***\n");
freerdp_hexdump(stream_get_head(enc_stream) + y_size, cb_size);
printf("*** Cr ***\n");
freerdp_hexdump(stream_get_head(enc_stream) + y_size + cb_size, cr_size);*/
stream_set_pos(enc_stream, 0);
rfx_decode_rgb(context, enc_stream,
y_size, test_quantization_values,
cb_size, test_quantization_values,
cr_size, test_quantization_values,
decode_buffer);
dump_ppm_image(decode_buffer);
rfx_context_free(context);
stream_free(enc_stream);
free(rgb_data);
}
void
test_message(void)
{
RFX_CONTEXT * context;
uint8 buffer[1024000];
int size;
int i, j;
RFX_RECT rect = {0, 0, 100, 80};
RFX_MESSAGE * message;
rgb_data = (uint8 *) malloc(100 * 80 * 3);
for (i = 0; i < 80; i++)
memcpy(rgb_data + i * 100 * 3, rgb_scanline_data, 100 * 3);
context = rfx_context_new();
context->mode = RLGR3;
context->width = 800;
context->height = 600;
rfx_context_set_pixel_format(context, RFX_PIXEL_FORMAT_RGB);
size = rfx_compose_message_header(context, buffer, sizeof(buffer));
/*hexdump(buffer, size);*/
message = rfx_process_message(context, buffer, size);
rfx_message_free(context, message);
for (i = 0; i < 1000; i++)
{
size = rfx_compose_message_data(context, buffer, sizeof(buffer),
&rect, 1, rgb_data, 100, 80, 100 * 3);
/*hexdump(buffer, size);*/
message = rfx_process_message(context, buffer, size);
if (i == 0)
{
for (j = 0; j < message->num_tiles; j++)
{
dump_ppm_image(message->tiles[j]->data);
}
}
rfx_message_free(context, message);
}
rfx_context_free(context);
free(rgb_data);
}
static int shadow_encoder_init_rfx(rdpShadowEncoder* encoder)
{
if (!encoder->rfx)
encoder->rfx = rfx_context_new(TRUE);
if (!encoder->rfx)
goto fail;
if (!rfx_context_reset(encoder->rfx, encoder->width, encoder->height))
goto fail;
encoder->rfx->mode = encoder->server->rfxMode;
rfx_context_set_pixel_format(encoder->rfx, PIXEL_FORMAT_BGRX32);
encoder->codecs |= FREERDP_CODEC_REMOTEFX;
return 1;
fail:
rfx_context_free(encoder->rfx);
return -1;
}
/* Called when we have a new peer connecting */
void mf_peer_context_new(freerdp_peer* client, mfPeerContext* context)
{
context->info = mf_info_get_instance();
context->rfx_context = rfx_context_new();
context->rfx_context->mode = RLGR3;
context->rfx_context->width = client->settings->DesktopWidth;
context->rfx_context->height = client->settings->DesktopHeight;
rfx_context_set_pixel_format(context->rfx_context, RDP_PIXEL_FORMAT_B8G8R8A8);
//context->nsc_context = nsc_context_new();
//nsc_context_set_pixel_format(context->nsc_context, RDP_PIXEL_FORMAT_B8G8R8A8);
context->s = stream_new(0xFFFF);
//#ifdef WITH_SERVER_CHANNELS
context->vcm = WTSCreateVirtualChannelManager(client);
//#endif
mf_info_peer_register(context->info, context);
}
BOOL test_peer_context_new(freerdp_peer* client, testPeerContext* context)
{
if (!(context->rfx_context = rfx_context_new(TRUE)))
goto fail_rfx_context;
context->rfx_context->mode = RLGR3;
context->rfx_context->width = SAMPLE_SERVER_DEFAULT_WIDTH;
context->rfx_context->height = SAMPLE_SERVER_DEFAULT_HEIGHT;
rfx_context_set_pixel_format(context->rfx_context, RDP_PIXEL_FORMAT_R8G8B8);
if (!(context->nsc_context = nsc_context_new()))
goto fail_nsc_context;
nsc_context_set_pixel_format(context->nsc_context, RDP_PIXEL_FORMAT_R8G8B8);
if (!(context->s = Stream_New(NULL, 65536)))
goto fail_stream_new;
context->icon_x = -1;
context->icon_y = -1;
context->vcm = WTSOpenServerA((LPSTR) client->context);
if (!context->vcm || context->vcm == INVALID_HANDLE_VALUE)
goto fail_open_server;
return TRUE;
fail_open_server:
context->vcm = NULL;
Stream_Free(context->s, TRUE);
context->s = NULL;
fail_stream_new:
nsc_context_free(context->nsc_context);
context->nsc_context = NULL;
fail_nsc_context:
rfx_context_free(context->rfx_context);
context->rfx_context = NULL;
fail_rfx_context:
return FALSE;
}
void
test_encode(void)
{
RFX_CONTEXT * context;
uint8 ycbcr_buffer[1024000];
int y_size, cb_size, cr_size;
int i;
uint8 decode_buffer[4096 * 3];
rgb_data = (uint8 *) malloc(64 * 64 * 3);
for (i = 0; i < 64; i++)
memcpy(rgb_data + i * 64 * 3, rgb_scanline_data, 64 * 3);
//hexdump(rgb_data, 64 * 64 * 3);
context = rfx_context_new();
context->mode = RLGR3;
rfx_context_set_pixel_format(context, RFX_PIXEL_FORMAT_RGB);
rfx_encode_rgb(context, rgb_data, 64, 64, 64 * 3,
test_quantization_values, test_quantization_values, test_quantization_values,
ycbcr_buffer, sizeof(ycbcr_buffer), &y_size, &cb_size, &cr_size);
//dump_buffer(context->cb_g_buffer, 4096);
/*printf("*** Y ***\n");
hexdump(ycbcr_buffer, y_size);
printf("*** Cb ***\n");
hexdump(ycbcr_buffer + y_size, cb_size);
printf("*** Cr ***\n");
hexdump(ycbcr_buffer + y_size + cb_size, cr_size);*/
rfx_decode_rgb(context,
ycbcr_buffer, y_size, test_quantization_values,
ycbcr_buffer + y_size, cb_size, test_quantization_values,
ycbcr_buffer + y_size + cb_size, cr_size, test_quantization_values,
decode_buffer);
dump_ppm_image(decode_buffer);
rfx_context_free(context);
free(rgb_data);
}
/* Called when we have a new peer connecting */
BOOL mf_peer_context_new(freerdp_peer* client, mfPeerContext* context)
{
if (!(context->info = mf_info_get_instance()))
return FALSE;
if (!(context->rfx_context = rfx_context_new(TRUE)))
goto fail_rfx_context;
context->rfx_context->mode = RLGR3;
context->rfx_context->width = client->settings->DesktopWidth;
context->rfx_context->height = client->settings->DesktopHeight;
rfx_context_set_pixel_format(context->rfx_context, RDP_PIXEL_FORMAT_B8G8R8A8);
//if (!(context->nsc_context = nsc_context_new()))
// goto fail_nsc_context;
//nsc_context_set_pixel_format(context->nsc_context, RDP_PIXEL_FORMAT_B8G8R8A8);
if (!(context->s = Stream_New(NULL, 0xFFFF)))
goto fail_stream_new;
context->vcm = WTSOpenServerA((LPSTR) client->context);
if (!context->vcm || context->vcm == INVALID_HANDLE_VALUE)
goto fail_open_server;
mf_info_peer_register(context->info, context);
return TRUE;
fail_open_server:
Stream_Free(context->s, TRUE);
context->s = NULL;
fail_stream_new:
rfx_context_free(context->rfx_context);
context->rfx_context = NULL;
fail_rfx_context:
return FALSE;
}
BOOL freerdp_client_codecs_prepare(rdpCodecs* codecs, UINT32 flags)
{
if ((flags & FREERDP_CODEC_INTERLEAVED) && !codecs->interleaved)
{
if (!(codecs->interleaved = bitmap_interleaved_context_new(FALSE)))
{
WLog_ERR(TAG, "Failed to create interleaved codec context");
return FALSE;
}
}
if ((flags & FREERDP_CODEC_PLANAR) && !codecs->planar)
{
if (!(codecs->planar = freerdp_bitmap_planar_context_new(FALSE, 64, 64)))
{
WLog_ERR(TAG, "Failed to create planar bitmap codec context");
return FALSE;
}
}
if ((flags & FREERDP_CODEC_NSCODEC) && !codecs->nsc)
{
if (!(codecs->nsc = nsc_context_new()))
{
WLog_ERR(TAG, "Failed to create nsc codec context");
return FALSE;
}
}
if ((flags & FREERDP_CODEC_REMOTEFX) && !codecs->rfx)
{
if (!(codecs->rfx = rfx_context_new(FALSE)))
{
WLog_ERR(TAG, "Failed to create rfx codec context");
return FALSE;
}
}
if ((flags & FREERDP_CODEC_CLEARCODEC) && !codecs->clear)
{
if (!(codecs->clear = clear_context_new(FALSE)))
{
WLog_ERR(TAG, "Failed to create clear codec context");
return FALSE;
}
}
if (flags & FREERDP_CODEC_ALPHACODEC)
{
}
if ((flags & FREERDP_CODEC_PROGRESSIVE) && !codecs->progressive)
{
if (!(codecs->progressive = progressive_context_new(FALSE)))
{
WLog_ERR(TAG, "Failed to create progressive codec context");
return FALSE;
}
}
if ((flags & (FREERDP_CODEC_AVC420 | FREERDP_CODEC_AVC444)) && !codecs->h264)
{
if (!(codecs->h264 = h264_context_new(FALSE)))
{
WLog_ERR(TAG, "Failed to create h264 codec context");
return FALSE;
}
}
return TRUE;
}
boolean wf_post_connect(freerdp* instance)
{
rdpGdi* gdi;
wfInfo* wfi;
rdpCache* cache;
wfContext* context;
int width, height;
wchar_t win_title[64];
rdpSettings* settings;
settings = instance->settings;
context = (wfContext*) instance->context;
cache = instance->context->cache;
wfi = context->wfi;
wfi->dstBpp = 32;
width = settings->width;
height = settings->height;
if (wfi->sw_gdi)
{
gdi_init(instance, CLRCONV_ALPHA | CLRCONV_INVERT | CLRBUF_32BPP, NULL);
gdi = instance->context->gdi;
wfi->hdc = gdi->primary->hdc;
wfi->primary = wf_image_new(wfi, width, height, wfi->dstBpp, gdi->primary_buffer);
rfx_context_set_cpu_opt(gdi->rfx_context, wfi_detect_cpu());
}
else
{
wf_gdi_register_update_callbacks(instance->update);
wfi->srcBpp = instance->settings->color_depth;
wfi->primary = wf_image_new(wfi, width, height, wfi->dstBpp, NULL);
wfi->hdc = gdi_GetDC();
wfi->hdc->bitsPerPixel = wfi->dstBpp;
wfi->hdc->bytesPerPixel = wfi->dstBpp / 8;
wfi->hdc->alpha = wfi->clrconv->alpha;
wfi->hdc->invert = wfi->clrconv->invert;
wfi->hdc->hwnd = (HGDI_WND) xmalloc(sizeof(GDI_WND));
wfi->hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0);
wfi->hdc->hwnd->invalid->null = 1;
wfi->hdc->hwnd->count = 32;
wfi->hdc->hwnd->cinvalid = (HGDI_RGN) xmalloc(sizeof(GDI_RGN) * wfi->hdc->hwnd->count);
wfi->hdc->hwnd->ninvalid = 0;
wfi->image = wf_bitmap_new(wfi, 64, 64, 32, NULL);
wfi->image->_bitmap.data = NULL;
if (settings->rfx_codec)
{
wfi->tile = wf_bitmap_new(wfi, 64, 64, 32, NULL);
wfi->rfx_context = rfx_context_new();
rfx_context_set_cpu_opt(wfi->rfx_context, wfi_detect_cpu());
}
if (settings->ns_codec)
wfi->nsc_context = nsc_context_new();
}
if (settings->window_title != NULL)
_snwprintf(win_title, sizeof(win_title), L"%S", settings->window_title);
else if (settings->port == 3389)
_snwprintf(win_title, ARRAY_SIZE(win_title), L"FreeRDP: %S", settings->hostname);
else
_snwprintf(win_title, ARRAY_SIZE(win_title), L"FreeRDP: %S:%d", settings->hostname, settings->port);
if (wfi->hwnd == 0)
{
wfi->hwnd = CreateWindowEx((DWORD) NULL, g_wnd_class_name, win_title,
0, 0, 0, 0, 0, NULL, NULL, g_hInstance, NULL);
SetWindowLongPtr(wfi->hwnd, GWLP_USERDATA, (LONG_PTR) wfi);
}
if (wfi->fullscreen)
{
SetWindowLongPtr(wfi->hwnd, GWL_STYLE, WS_POPUP);
SetWindowPos(wfi->hwnd, HWND_TOP, 0, 0, width, height, SWP_FRAMECHANGED);
}
else
{
POINT diff;
RECT rc_client, rc_wnd;
SetWindowLongPtr(wfi->hwnd, GWL_STYLE, WS_CAPTION | WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX);
/* Now resize to get full canvas size and room for caption and borders */
SetWindowPos(wfi->hwnd, HWND_TOP, 10, 10, width, height, SWP_FRAMECHANGED);
GetClientRect(wfi->hwnd, &rc_client);
GetWindowRect(wfi->hwnd, &rc_wnd);
diff.x = (rc_wnd.right - rc_wnd.left) - rc_client.right;
diff.y = (rc_wnd.bottom - rc_wnd.top) - rc_client.bottom;
SetWindowPos(wfi->hwnd, HWND_TOP, -1, -1, width + diff.x, height + diff.y, SWP_NOMOVE | SWP_FRAMECHANGED);
}
BitBlt(wfi->primary->hdc, 0, 0, width, height, NULL, 0, 0, BLACKNESS);
wfi->drawing = wfi->primary;
ShowWindow(wfi->hwnd, SW_SHOWNORMAL);
UpdateWindow(wfi->hwnd);
if (wfi->sw_gdi)
{
instance->update->BeginPaint = wf_sw_begin_paint;
instance->update->EndPaint = wf_sw_end_paint;
}
else
{
instance->update->BeginPaint = wf_hw_begin_paint;
instance->update->EndPaint = wf_hw_end_paint;
}
pointer_cache_register_callbacks(instance->update);
if (wfi->sw_gdi != true)
{
brush_cache_register_callbacks(instance->update);
bitmap_cache_register_callbacks(instance->update);
offscreen_cache_register_callbacks(instance->update);
}
wf_register_graphics(instance->context->graphics);
freerdp_channels_post_connect(instance->context->channels, instance);
return true;
}
BOOL wf_post_connect(freerdp* instance)
{
rdpGdi* gdi;
wfInfo* wfi;
rdpCache* cache;
wfContext* context;
WCHAR lpWindowName[64];
rdpSettings* settings;
settings = instance->settings;
context = (wfContext*) instance->context;
cache = instance->context->cache;
wfi = context->wfi;
wfi->dstBpp = 32;
wfi->width = settings->DesktopWidth;
wfi->height = settings->DesktopHeight;
if (wfi->sw_gdi)
{
gdi_init(instance, CLRCONV_ALPHA | CLRCONV_INVERT | CLRBUF_32BPP, NULL);
gdi = instance->context->gdi;
wfi->hdc = gdi->primary->hdc;
wfi->primary = wf_image_new(wfi, wfi->width, wfi->height, wfi->dstBpp, gdi->primary_buffer);
}
else
{
wf_gdi_register_update_callbacks(instance->update);
wfi->srcBpp = instance->settings->ColorDepth;
wfi->primary = wf_image_new(wfi, wfi->width, wfi->height, wfi->dstBpp, NULL);
wfi->hdc = gdi_GetDC();
wfi->hdc->bitsPerPixel = wfi->dstBpp;
wfi->hdc->bytesPerPixel = wfi->dstBpp / 8;
wfi->hdc->alpha = wfi->clrconv->alpha;
wfi->hdc->invert = wfi->clrconv->invert;
wfi->hdc->hwnd = (HGDI_WND) malloc(sizeof(GDI_WND));
wfi->hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0);
wfi->hdc->hwnd->invalid->null = 1;
wfi->hdc->hwnd->count = 32;
wfi->hdc->hwnd->cinvalid = (HGDI_RGN) malloc(sizeof(GDI_RGN) * wfi->hdc->hwnd->count);
wfi->hdc->hwnd->ninvalid = 0;
if (settings->RemoteFxCodec)
{
wfi->tile = wf_image_new(wfi, 64, 64, 32, NULL);
wfi->rfx_context = rfx_context_new();
}
if (settings->NSCodec)
{
wfi->nsc_context = nsc_context_new();
}
}
if (settings->WindowTitle != NULL)
_snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"%S", settings->WindowTitle);
else if (settings->ServerPort == 3389)
_snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"FreeRDP: %S", settings->ServerHostname);
else
_snwprintf(lpWindowName, ARRAYSIZE(lpWindowName), L"FreeRDP: %S:%d", settings->ServerHostname, settings->ServerPort);
if (!wfi->hwnd)
{
wfi->hwnd = CreateWindowEx((DWORD) NULL, wfi->wndClassName, lpWindowName,
0, 0, 0, 0, 0, wfi->hWndParent, NULL, wfi->hInstance, NULL);
SetWindowLongPtr(wfi->hwnd, GWLP_USERDATA, (LONG_PTR) wfi);
}
wf_resize_window(wfi);
BitBlt(wfi->primary->hdc, 0, 0, wfi->width, wfi->height, NULL, 0, 0, BLACKNESS);
wfi->drawing = wfi->primary;
ShowWindow(wfi->hwnd, SW_SHOWNORMAL);
UpdateWindow(wfi->hwnd);
if (wfi->sw_gdi)
{
instance->update->BeginPaint = wf_sw_begin_paint;
instance->update->EndPaint = wf_sw_end_paint;
instance->update->DesktopResize = wf_sw_desktop_resize;
}
else
{
instance->update->BeginPaint = wf_hw_begin_paint;
instance->update->EndPaint = wf_hw_end_paint;
instance->update->DesktopResize = wf_hw_desktop_resize;
}
pointer_cache_register_callbacks(instance->update);
if (wfi->sw_gdi != TRUE)
{
brush_cache_register_callbacks(instance->update);
bitmap_cache_register_callbacks(instance->update);
offscreen_cache_register_callbacks(instance->update);
}
wf_register_graphics(instance->context->graphics);
freerdp_channels_post_connect(instance->context->channels, instance);
wf_cliprdr_init(wfi, instance->context->channels);
return TRUE;
}
