/**
* Function description
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT xf_DeleteSurface(RdpgfxClientContext* context,
const RDPGFX_DELETE_SURFACE_PDU* deleteSurface)
{
rdpCodecs* codecs = NULL;
xfGfxSurface* surface = NULL;
UINT status;
EnterCriticalSection(&context->mux);
surface = (xfGfxSurface*) context->GetSurfaceData(context,
deleteSurface->surfaceId);
if (surface)
{
#ifdef WITH_GFX_H264
h264_context_free(surface->gdi.h264);
#endif
surface->image->data = NULL;
XDestroyImage(surface->image);
_aligned_free(surface->gdi.data);
_aligned_free(surface->stage);
region16_uninit(&surface->gdi.invalidRegion);
codecs = surface->gdi.codecs;
free(surface);
}
status = context->SetSurfaceData(context, deleteSurface->surfaceId, NULL);
if (codecs && codecs->progressive)
progressive_delete_surface_context(codecs->progressive,
deleteSurface->surfaceId);
LeaveCriticalSection(&context->mux);
return status;
}
/**
* Function description
*
* @return 0 on success, otherwise a Win32 error code
*/
static UINT gdi_DeleteSurface(RdpgfxClientContext* context,
const RDPGFX_DELETE_SURFACE_PDU* deleteSurface)
{
rdpCodecs* codecs = NULL;
gdiGfxSurface* surface = NULL;
surface = (gdiGfxSurface*) context->GetSurfaceData(context, deleteSurface->surfaceId);
if (surface)
{
#ifdef WITH_GFX_H264
h264_context_free(surface->h264);
#endif
region16_uninit(&surface->invalidRegion);
codecs = surface->codecs;
_aligned_free(surface->data);
free(surface);
}
context->SetSurfaceData(context, deleteSurface->surfaceId, NULL);
if (codecs && codecs->progressive)
progressive_delete_surface_context(codecs->progressive, deleteSurface->surfaceId);
return CHANNEL_RC_OK;
}
static void PresentationContext_unref(PresentationContext *presentation)
{
VideoClientContextPriv *priv;
MAPPED_GEOMETRY *geometry;
if (!presentation)
return;
if (InterlockedDecrement(&presentation->refCounter) != 0)
return;
geometry = presentation->geometry;
if (geometry)
{
geometry->MappedGeometryUpdate = NULL;
geometry->MappedGeometryClear = NULL;
geometry->custom = NULL;
mappedGeometryUnref(geometry);
}
priv = presentation->video->priv;
h264_context_free(presentation->h264);
Stream_Free(presentation->currentSample, TRUE);
presentation->video->deleteSurface(presentation->video, presentation->surface);
BufferPool_Return(priv->surfacePool, presentation->surfaceData);
yuv_context_free(presentation->yuv);
free(presentation);
}
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 int shadow_encoder_uninit_h264(rdpShadowEncoder* encoder)
{
if (encoder->h264)
{
h264_context_free(encoder->h264);
encoder->h264 = NULL;
}
encoder->codecs &= ~FREERDP_CODEC_AVC420;
return 1;
}
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);
}
static int shadow_encoder_init_h264(rdpShadowEncoder* encoder)
{
if (!encoder->h264)
encoder->h264 = h264_context_new(TRUE);
if (!encoder->h264)
goto fail;
if (!h264_context_reset(encoder->h264, encoder->width, encoder->height))
goto fail;
encoder->h264->RateControlMode = encoder->server->h264RateControlMode;
encoder->h264->BitRate = encoder->server->h264BitRate;
encoder->h264->FrameRate = encoder->server->h264FrameRate;
encoder->h264->QP = encoder->server->h264QP;
encoder->codecs |= FREERDP_CODEC_AVC420;
return 1;
fail:
h264_context_free(encoder->h264);
return -1;
}
static PresentationContext *PresentationContext_new(VideoClientContext *video, BYTE PresentationId,
UINT32 x, UINT32 y, UINT32 width, UINT32 height)
{
VideoClientContextPriv *priv = video->priv;
PresentationContext *ret = calloc(1, sizeof(*ret));
if (!ret)
return NULL;
ret->video = video;
ret->PresentationId = PresentationId;
ret->h264 = h264_context_new(FALSE);
if (!ret->h264)
{
WLog_ERR(TAG, "unable to create a h264 context");
goto error_h264;
}
h264_context_reset(ret->h264, width, height);
ret->currentSample = Stream_New(NULL, 4096);
if (!ret->currentSample)
{
WLog_ERR(TAG, "unable to create current packet stream");
goto error_currentSample;
}
ret->surfaceData = BufferPool_Take(priv->surfacePool, width * height * 4);
if (!ret->surfaceData)
{
WLog_ERR(TAG, "unable to allocate surfaceData");
goto error_surfaceData;
}
ret->surface = video->createSurface(video, ret->surfaceData, x, y, width, height);
if (!ret->surface)
{
WLog_ERR(TAG, "unable to create surface");
goto error_surface;
}
ret->yuv = yuv_context_new(FALSE);
if (!ret->yuv)
{
WLog_ERR(TAG, "unable to create YUV decoder");
goto error_yuv;
}
yuv_context_reset(ret->yuv, width, height);
ret->refCounter = 1;
return ret;
error_yuv:
video->deleteSurface(video, ret->surface);
error_surface:
BufferPool_Return(priv->surfacePool, ret->surfaceData);
error_surfaceData:
Stream_Free(ret->currentSample, TRUE);
error_currentSample:
h264_context_free(ret->h264);
error_h264:
free(ret);
return NULL;
}
