mirrors/FreeRDP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libfreerdp-codec: start parsing progressive codec

Browse Source
This commit is contained in:
Marc-André Moreau 2014-07-28 23:41:16 -04:00
parent 0c408c213c
commit a3de93d867
4 changed files with 330 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
client/X11/xf_gfx.c
View File

@ -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;
@ -470,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;
@ -478,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 */

2
client/X11/xfreerdp.h
View File

@ -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;

127
include/freerdp/codec/progressive.h
View File

@ -23,8 +23,135 @@
#include <freerdp/api.h>
#include <freerdp/types.h>
#include <freerdp/codec/rfx.h>
#include <freerdp/codec/color.h>
#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_PROGRESSIVE_FIRST 0xCCC6
#define PROGRESSIVE_WBT_TILE_PROGRESSIVE_UPGRADE 0xCCC7
struct _PROGRESSIVE_SYNC
{
UINT16 blockType;
UINT32 blockLen;
UINT32 magic;
UINT16 version;
};
typedef struct _PROGRESSIVE_SYNC PROGRESSIVE_SYNC;
struct _PROGRESSIVE_REGION
{
UINT16 blockType;
UINT32 blockLen;
BYTE tileSize;
UINT16 numRects;
BYTE numQuant;
BYTE numProgQuant;
BYTE flags;
UINT16 numTiles;
UINT32 tileDataSize;
RFX_RECT* rects;
UINT32* quantVals;
UINT32* quantProgVals;
};
typedef struct _PROGRESSIVE_REGION PROGRESSIVE_REGION;
struct _PROGRESSIVE_FRAME_BEGIN
{
UINT16 blockType;
UINT32 blockLen;
UINT32 frameIndex;
UINT16 regionCount;
PROGRESSIVE_REGION* regions;
};
typedef struct _PROGRESSIVE_FRAME_BEGIN PROGRESSIVE_FRAME_BEGIN;
struct _PROGRESSIVE_FRAME_END
{
UINT16 blockType;
UINT32 blockLen;
};
typedef struct _PROGRESSIVE_FRAME_END PROGRESSIVE_FRAME_END;
struct _PROGRESSIVE_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_TILE_SIMPLE PROGRESSIVE_TILE_SIMPLE;
struct _PROGRESSIVE_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_TILE_FIRST PROGRESSIVE_TILE_FIRST;
struct _PROGRESSIVE_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_TILE_UPGRADE PROGRESSIVE_TILE_UPGRADE;
struct _PROGRESSIVE_CONTEXT
{
BOOL Compressor;

181
libfreerdp/codec/progressive.c
View File

@ -31,6 +31,187 @@
int progressive_decompress(PROGRESSIVE_CONTEXT* progressive, BYTE* pSrcData, UINT32 SrcSize,
BYTE** ppDstData, DWORD DstFormat, int nDstStep, int nXDst, int nYDst, int nWidth, int nHeight)
{
BYTE* block;
UINT32 boffset;
UINT32 ctxId;
UINT32 flags;
UINT32 tileSize;
UINT32 magic;
UINT32 version;
UINT16 blockType;
UINT32 blockLen;
UINT32 offset = 0;
UINT32 frameIndex;
UINT32 regionCount;
PROGRESSIVE_REGION region;
PROGRESSIVE_TILE_SIMPLE simple;
PROGRESSIVE_TILE_FIRST first;
PROGRESSIVE_TILE_UPGRADE upgrade;
printf("ProgressiveDecompress\n");
while ((SrcSize - offset) > 6)
{
boffset = 0;
block = &pSrcData[offset];
blockType = *((UINT16*) &block[boffset]); /* blockType (2 bytes) */
blockLen = *((UINT32*) &block[boffset + 2]); /* blockLen (4 bytes) */
boffset += 6;
switch (blockType)
{
case PROGRESSIVE_WBT_SYNC:
if (blockLen != 12)
return -1;
magic = (UINT32) *((UINT32*) &block[boffset]); /* magic (4 bytes) */
version = (UINT32) *((UINT16*) &block[boffset + 4]); /* version (2 bytes) */
boffset += 6;
break;
case PROGRESSIVE_WBT_FRAME_BEGIN:
frameIndex = (UINT32) *((UINT32*) &block[boffset]); /* frameIndex (4 bytes) */
regionCount = (UINT32) *((UINT16*) &block[boffset + 4]); /* regionCount (2 bytes) */
boffset += 6;
break;
case PROGRESSIVE_WBT_FRAME_END:
if (blockLen != 6)
return -1;
break;
case PROGRESSIVE_WBT_CONTEXT:
if (blockLen != 10)
return -1;
ctxId = (UINT32) block[boffset]; /* ctxId (1 byte) */
tileSize = (UINT32) *((UINT16*) &block[boffset + 1]); /* tileSize (2 bytes) */
flags = (UINT32) block[boffset + 3]; /* flags (1 byte) */
boffset += 4;
if (tileSize != 64)
return -1;
break;
case PROGRESSIVE_WBT_REGION:
region.tileSize = block[boffset]; /* 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;
break;
case PROGRESSIVE_WBT_TILE_SIMPLE:
simple.quantIdxY = block[boffset]; /* quantIdxY (1 byte) */
simple.quantIdxCb = block[boffset + 1]; /* quantIdxCb (1 byte) */
simple.quantIdxCr = block[boffset + 2]; /* quantIdxCr (1 byte) */
simple.xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */
simple.yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */
simple.flags = block[boffset + 7]; /* flags (1 byte) */
simple.yLen = *((UINT16*) &block[boffset + 8]); /* yLen (2 bytes) */
simple.cbLen = *((UINT16*) &block[boffset + 10]); /* cbLen (2 bytes) */
simple.crLen = *((UINT16*) &block[boffset + 12]); /* crLen (2 bytes) */
simple.tailLen = *((UINT16*) &block[boffset + 14]); /* tailLen (2 bytes) */
boffset += 16;
simple.yData = &block[boffset];
boffset += simple.yLen;
simple.cbData = &block[boffset];
boffset += simple.cbLen;
simple.crData = &block[boffset];
boffset += simple.crLen;
simple.tailData = &block[boffset];
boffset += simple.tailLen;
break;
case PROGRESSIVE_WBT_TILE_PROGRESSIVE_FIRST:
first.quantIdxY = block[boffset]; /* quantIdxY (1 byte) */
first.quantIdxCb = block[boffset + 1]; /* quantIdxCb (1 byte) */
first.quantIdxCr = block[boffset + 2]; /* quantIdxCr (1 byte) */
first.xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */
first.yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */
first.flags = block[boffset + 7]; /* flags (1 byte) */
first.quality = block[boffset + 8]; /* quality (1 byte) */
first.yLen = *((UINT16*) &block[boffset + 9]); /* yLen (2 bytes) */
first.cbLen = *((UINT16*) &block[boffset + 11]); /* cbLen (2 bytes) */
first.crLen = *((UINT16*) &block[boffset + 13]); /* crLen (2 bytes) */
first.tailLen = *((UINT16*) &block[boffset + 15]); /* tailLen (2 bytes) */
boffset += 17;
first.yData = &block[boffset];
boffset += first.yLen;
first.cbData = &block[boffset];
boffset += first.cbLen;
first.crData = &block[boffset];
boffset += first.crLen;
first.tailData = &block[boffset];
boffset += first.tailLen;
break;
case PROGRESSIVE_WBT_TILE_PROGRESSIVE_UPGRADE:
upgrade.quantIdxY = block[boffset]; /* quantIdxY (1 byte) */
upgrade.quantIdxCb = block[boffset + 1]; /* quantIdxCb (1 byte) */
upgrade.quantIdxCr = block[boffset + 2]; /* quantIdxCr (1 byte) */
upgrade.xIdx = *((UINT16*) &block[boffset + 3]); /* xIdx (2 bytes) */
upgrade.yIdx = *((UINT16*) &block[boffset + 5]); /* yIdx (2 bytes) */
upgrade.quality = block[boffset + 7]; /* quality (1 byte) */
upgrade.ySrlLen = *((UINT16*) &block[boffset + 8]); /* ySrlLen (2 bytes) */
upgrade.yRawLen = *((UINT16*) &block[boffset + 10]); /* yRawLen (2 bytes) */
upgrade.cbSrlLen = *((UINT16*) &block[boffset + 12]); /* cbSrlLen (2 bytes) */
upgrade.cbRawLen = *((UINT16*) &block[boffset + 14]); /* cbRawLen (2 bytes) */
upgrade.crSrlLen = *((UINT16*) &block[boffset + 16]); /* crSrlLen (2 bytes) */
upgrade.crRawLen = *((UINT16*) &block[boffset + 18]); /* crRawLen (2 bytes) */
boffset += 18;
upgrade.ySrlData = &block[boffset];
boffset += upgrade.ySrlLen;
upgrade.yRawData = &block[boffset];
boffset += upgrade.yRawLen;
upgrade.cbSrlData = &block[boffset];
boffset += upgrade.cbSrlLen;
upgrade.cbRawData = &block[boffset];
boffset += upgrade.cbRawLen;
upgrade.crSrlData = &block[boffset];
boffset += upgrade.crSrlLen;
upgrade.crRawData = &block[boffset];
boffset += upgrade.crRawLen;
break;
}
offset += blockLen;
}
return 1;
}