void test_peer_context_free(freerdp_peer* client, testPeerContext* context)
{
if (context)
{
if (context->debug_channel_thread)
{
SetEvent(context->stopEvent);
WaitForSingleObject(context->debug_channel_thread, INFINITE);
CloseHandle(context->debug_channel_thread);
}
Stream_Free(context->s, TRUE);
free(context->icon_data);
free(context->bg_data);
rfx_context_free(context->rfx_context);
nsc_context_free(context->nsc_context);
if (context->debug_channel)
WTSVirtualChannelClose(context->debug_channel);
if (context->audin)
audin_server_context_free(context->audin);
if (context->rdpsnd)
rdpsnd_server_context_free(context->rdpsnd);
WTSCloseServer((HANDLE) context->vcm);
}
}
/* Called after a peer disconnects */
void mf_peer_context_free(freerdp_peer* client, mfPeerContext* context)
{
if (context)
{
mf_info_peer_unregister(context->info, context);
dispatch_suspend(info_timer);
Stream_Free(context->s, TRUE);
rfx_context_free(context->rfx_context);
//nsc_context_free(context->nsc_context);
#ifdef CHANNEL_AUDIN_SERVER
if (context->audin)
audin_server_context_free(context->audin);
#endif
//#ifdef CHANNEL_RDPSND_SERVER
mf_peer_rdpsnd_stop();
if (context->rdpsnd)
rdpsnd_server_context_free(context->rdpsnd);
//#endif
WTSCloseServer(context->vcm);
}
}
void test_peer_context_free(freerdp_peer* client, testPeerContext* context)
{
if (context)
{
if (context->debug_channel_thread)
{
freerdp_thread_stop(context->debug_channel_thread);
freerdp_thread_free(context->debug_channel_thread);
}
stream_free(context->s);
free(context->icon_data);
free(context->bg_data);
rfx_context_free(context->rfx_context);
nsc_context_free(context->nsc_context);
if (context->debug_channel)
WTSVirtualChannelClose(context->debug_channel);
if (context->audin)
audin_server_context_free(context->audin);
if (context->rdpsnd)
rdpsnd_server_context_free(context->rdpsnd);
WTSDestroyVirtualChannelManager(context->vcm);
}
}
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);
}
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);
}
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;
}
/* Called after a peer disconnects */
void mf_peer_context_free(freerdp_peer* client, mfPeerContext* context)
{
if (context)
{
mf_info_peer_unregister(context->info, context);
dispatch_suspend(info_timer);
stream_free(context->s);
rfx_context_free(context->rfx_context);
//nsc_context_free(context->nsc_context);
#ifdef CHANNEL_AUDIN_SERVER
if (context->audin)
audin_server_context_free(context->audin);
#endif
//#ifdef CHANNEL_RDPSND_SERVER
mf_peer_rdpsnd_stop();
if (context->rdpsnd)
rdpsnd_server_context_free(context->rdpsnd);
//#endif
//#ifdef WITH_SERVER_CHANNELS
WTSDestroyVirtualChannelManager(context->vcm);
//#endif
}
}
static gboolean remmina_rdp_close_connection(RemminaProtocolWidget* gp)
{
rfContext* rfi;
freerdp* instance;
rfi = GET_DATA(gp);
instance = rfi->instance;
if (rfi->thread)
{
pthread_cancel(rfi->thread);
if (rfi->thread)
pthread_join(rfi->thread, NULL);
}
pthread_mutex_destroy(&rfi->mutex);
g_mutex_free(rfi->gmutex);
g_cond_free(rfi->gcond);
remmina_rdp_event_uninit(gp);
remmina_plugin_service->protocol_plugin_emit_signal(gp, "disconnect");
if (instance)
{
if ( rfi->connected ) {
if (instance->context->channels)
freerdp_channels_close(instance->context->channels, instance);
freerdp_disconnect(instance);
rfi->connected = False;
}
}
if (rfi->rfx_context)
{
rfx_context_free(rfi->rfx_context);
rfi->rfx_context = NULL;
}
if (instance)
{
/* Remove instance->context from gp object data to avoid double free */
g_object_steal_data(G_OBJECT(gp), "plugin-data");
if (instance->context->channels) {
freerdp_channels_free(instance->context->channels);
instance->context->channels = NULL;
}
freerdp_context_free(instance); /* context is rfContext* rfi */
freerdp_free(instance);
rfi->instance = NULL;
}
return FALSE;
}
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;
}
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);
}
static int shadow_encoder_uninit_rfx(rdpShadowEncoder* encoder)
{
if (encoder->rfx)
{
rfx_context_free(encoder->rfx);
encoder->rfx = NULL;
}
encoder->codecs &= ~FREERDP_CODEC_REMOTEFX;
return 1;
}
void test_peer_context_free(freerdp_peer* client, testPeerContext* context)
{
if (context)
{
stream_free(context->s);
xfree(context->icon_data);
xfree(context->bg_data);
rfx_context_free(context->rfx_context);
xfree(context);
}
}
static gboolean remmina_rdp_close_connection(RemminaProtocolWidget* gp)
{
rfContext* rfi;
freerdp* instance;
rfi = GET_DATA(gp);
instance = rfi->instance;
if (rfi->thread)
{
pthread_cancel(rfi->thread);
if (rfi->thread)
pthread_join(rfi->thread, NULL);
}
pthread_mutex_destroy(&rfi->mutex);
g_mutex_free(rfi->gmutex);
g_cond_free(rfi->gcond);
remmina_rdp_event_uninit(gp);
remmina_plugin_service->protocol_plugin_emit_signal(gp, "disconnect");
if (instance)
{
if (rfi->channels)
{
//freerdp_channels_close(rfi->channels, instance);
freerdp_channels_free(rfi->channels);
rfi->channels = NULL;
}
if (freerdp_shall_disconnect(instance))
{
freerdp_disconnect(instance);
}
}
if (rfi->rfx_context)
{
rfx_context_free(rfi->rfx_context);
rfi->rfx_context = NULL;
}
if (instance)
{
//freerdp_context_free(instance); /* context is rfContext* rfi */
freerdp_free(instance);
}
return FALSE;
}
void codecs_free(rdpCodecs* codecs)
{
if (!codecs)
return;
if (codecs->rfx)
{
rfx_context_free(codecs->rfx);
codecs->rfx = NULL;
}
if (codecs->nsc)
{
nsc_context_free(codecs->nsc);
codecs->nsc = NULL;
}
if (codecs->h264)
{
h264_context_free(codecs->h264);
codecs->h264 = NULL;
}
if (codecs->clear)
{
clear_context_free(codecs->clear);
codecs->clear = NULL;
}
if (codecs->progressive)
{
progressive_context_free(codecs->progressive);
codecs->progressive = NULL;
}
if (codecs->planar)
{
freerdp_bitmap_planar_context_free(codecs->planar);
codecs->planar = NULL;
}
if (codecs->interleaved)
{
bitmap_interleaved_context_free(codecs->interleaved);
codecs->interleaved = NULL;
}
free(codecs);
}
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 mf_peer_context_free(freerdp_peer* client, mfPeerContext* context)
{
if (context)
{
stream_free(context->s);
rfx_context_free(context->rfx_context);
nsc_context_free(context->nsc_context);
if (context->audin)
audin_server_context_free(context->audin);
if (context->rdpsnd)
rdpsnd_server_context_free(context->rdpsnd);
WTSDestroyVirtualChannelManager(context->vcm);
}
}
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);
}
int shadow_encoder_uninit_rfx(rdpShadowEncoder* encoder)
{
if (encoder->rfx)
{
rfx_context_free(encoder->rfx);
encoder->rfx = NULL;
}
if (encoder->frameList)
{
ListDictionary_Free(encoder->frameList);
encoder->frameList = NULL;
}
encoder->codecs &= ~SHADOW_CODEC_REMOTEFX;
return 1;
}
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;
}
int freerds_encoder_uninit_rfx(rdsEncoder* encoder)
{
encoder->frameId = 0;
if (encoder->rfx)
{
rfx_context_free(encoder->rfx);
encoder->rfx = NULL;
}
if (encoder->frameList)
{
ListDictionary_Free(encoder->frameList);
encoder->frameList = NULL;
}
encoder->codecs &= ~FREERDP_CODEC_REMOTEFX;
return 1;
}
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;
}
void
xf_decode_uninit(xfInfo * xfi)
{
if (xfi->rfx_context)
rfx_context_free((RFX_CONTEXT *) xfi->rfx_context);
}
