1505 lines
53 KiB
C
1505 lines
53 KiB
C
#include <errno.h>
|
|
|
|
#include <winpr/wtypes.h>
|
|
#include <winpr/crt.h>
|
|
#include <winpr/string.h>
|
|
#include <winpr/path.h>
|
|
#include <winpr/image.h>
|
|
#include <winpr/print.h>
|
|
#include <winpr/wlog.h>
|
|
#include <winpr/sysinfo.h>
|
|
#include <winpr/file.h>
|
|
|
|
#include <freerdp/codec/region.h>
|
|
|
|
#include <freerdp/codecs.h>
|
|
#include <freerdp/utils/gfx.h>
|
|
|
|
#include <freerdp/codec/progressive.h>
|
|
#include <freerdp/channels/rdpgfx.h>
|
|
#include <freerdp/crypto/crypto.h>
|
|
|
|
#include "../progressive.h"
|
|
|
|
/**
|
|
* Microsoft Progressive Codec Sample Data
|
|
* (available under NDA only)
|
|
*
|
|
* <enc/dec>_<image#>_<quarter#>_<prog%>_<bitmap>.<type>
|
|
*
|
|
* readme.pdf
|
|
*
|
|
* bitmaps/
|
|
* 1920by1080-SampleImage1.bmp
|
|
* 1920by1080-SampleImage2.bmp
|
|
* 1920by1080-SampleImage3.bmp
|
|
*
|
|
* compress/
|
|
* enc_0_0_025_sampleimage1.bin
|
|
* enc_0_0_050_sampleimage1.bin
|
|
* enc_0_0_075_sampleimage1.bin
|
|
* enc_0_0_100_sampleimage1.bin
|
|
* enc_0_1_025_sampleimage1.bin
|
|
* enc_0_1_050_sampleimage1.bin
|
|
* enc_0_1_075_sampleimage1.bin
|
|
* enc_0_1_100_sampleimage1.bin
|
|
* enc_0_2_025_sampleimage1.bin
|
|
* enc_0_2_050_sampleimage1.bin
|
|
* enc_0_2_075_sampleimage1.bin
|
|
* enc_0_2_100_sampleimage1.bin
|
|
* enc_0_3_025_sampleimage1.bin
|
|
* enc_0_3_050_sampleimage1.bin
|
|
* enc_0_3_075_sampleimage1.bin
|
|
* enc_0_3_100_sampleimage1.bin
|
|
* enc_1_0_025_sampleimage2.bin
|
|
* enc_1_0_050_sampleimage2.bin
|
|
* enc_1_0_075_sampleimage2.bin
|
|
* enc_1_0_100_sampleimage2.bin
|
|
* enc_1_1_025_sampleimage2.bin
|
|
* enc_1_1_050_sampleimage2.bin
|
|
* enc_1_1_075_sampleimage2.bin
|
|
* enc_1_1_100_sampleimage2.bin
|
|
* enc_1_2_025_sampleimage2.bin
|
|
* enc_1_2_050_sampleimage2.bin
|
|
* enc_1_2_075_sampleimage2.bin
|
|
* enc_1_2_100_sampleimage2.bin
|
|
* enc_1_3_025_sampleimage2.bin
|
|
* enc_1_3_050_sampleimage2.bin
|
|
* enc_1_3_075_sampleimage2.bin
|
|
* enc_1_3_100_sampleimage2.bin
|
|
* enc_2_0_025_sampleimage3.bin
|
|
* enc_2_0_050_sampleimage3.bin
|
|
* enc_2_0_075_sampleimage3.bin
|
|
* enc_2_0_100_sampleimage3.bin
|
|
* enc_2_1_025_sampleimage3.bin
|
|
* enc_2_1_050_sampleimage3.bin
|
|
* enc_2_1_075_sampleimage3.bin
|
|
* enc_2_1_100_sampleimage3.bin
|
|
* enc_2_2_025_sampleimage3.bin
|
|
* enc_2_2_050_sampleimage3.bin
|
|
* enc_2_2_075_sampleimage3.bin
|
|
* enc_2_2_100_sampleimage3.bin
|
|
* enc_2_3_025_sampleimage3.bin
|
|
* enc_2_3_050_sampleimage3.bin
|
|
* enc_2_3_075_sampleimage3.bin
|
|
* enc_2_3_100_sampleimage3.bin
|
|
*
|
|
* decompress/
|
|
* dec_0_0_025_sampleimage1.bmp
|
|
* dec_0_0_050_sampleimage1.bmp
|
|
* dec_0_0_075_sampleimage1.bmp
|
|
* dec_0_0_100_sampleimage1.bmp
|
|
* dec_0_1_025_sampleimage1.bmp
|
|
* dec_0_1_050_sampleimage1.bmp
|
|
* dec_0_1_075_sampleimage1.bmp
|
|
* dec_0_1_100_sampleimage1.bmp
|
|
* dec_0_2_025_sampleimage1.bmp
|
|
* dec_0_2_050_sampleimage1.bmp
|
|
* dec_0_2_075_sampleimage1.bmp
|
|
* dec_0_2_100_sampleimage1.bmp
|
|
* dec_0_3_025_sampleimage1.bmp
|
|
* dec_0_3_050_sampleimage1.bmp
|
|
* dec_0_3_075_sampleimage1.bmp
|
|
* dec_0_3_100_sampleimage1.bmp
|
|
* dec_1_0_025_sampleimage2.bmp
|
|
* dec_1_0_050_sampleimage2.bmp
|
|
* dec_1_0_075_sampleimage2.bmp
|
|
* dec_1_0_100_sampleimage2.bmp
|
|
* dec_1_1_025_sampleimage2.bmp
|
|
* dec_1_1_050_sampleimage2.bmp
|
|
* dec_1_1_075_sampleimage2.bmp
|
|
* dec_1_1_100_sampleimage2.bmp
|
|
* dec_1_2_025_sampleimage2.bmp
|
|
* dec_1_2_050_sampleimage2.bmp
|
|
* dec_1_2_075_sampleimage2.bmp
|
|
* dec_1_2_100_sampleimage2.bmp
|
|
* dec_1_3_025_sampleimage2.bmp
|
|
* dec_1_3_050_sampleimage2.bmp
|
|
* dec_1_3_075_sampleimage2.bmp
|
|
* dec_1_3_100_sampleimage2.bmp
|
|
* dec_2_0_025_sampleimage3.bmp
|
|
* dec_2_0_050_sampleimage3.bmp
|
|
* dec_2_0_075_sampleimage3.bmp
|
|
* dec_2_0_100_sampleimage3.bmp
|
|
* dec_2_1_025_sampleimage3.bmp
|
|
* dec_2_1_050_sampleimage3.bmp
|
|
* dec_2_1_075_sampleimage3.bmp
|
|
* dec_2_1_100_sampleimage3.bmp
|
|
* dec_2_2_025_sampleimage3.bmp
|
|
* dec_2_2_050_sampleimage3.bmp
|
|
* dec_2_2_075_sampleimage3.bmp
|
|
* dec_2_2_100_sampleimage3.bmp
|
|
* dec_2_3_025_sampleimage3.bmp
|
|
* dec_2_3_050_sampleimage3.bmp
|
|
* dec_2_3_075_sampleimage3.bmp
|
|
* dec_2_3_100_sampleimage3.bmp
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
BYTE* buffer;
|
|
size_t size;
|
|
} EGFX_SAMPLE_FILE;
|
|
|
|
static int g_Width = 0;
|
|
static int g_Height = 0;
|
|
static int g_DstStep = 0;
|
|
static BYTE* g_DstData = nullptr;
|
|
|
|
static void sample_file_free(EGFX_SAMPLE_FILE* file)
|
|
{
|
|
if (!file)
|
|
return;
|
|
|
|
free(file->buffer);
|
|
file->buffer = nullptr;
|
|
file->size = 0;
|
|
}
|
|
|
|
static void test_fill_image_alpha_channel(BYTE* data, UINT32 width, UINT32 height, BYTE value)
|
|
{
|
|
UINT32* pixel = nullptr;
|
|
|
|
for (UINT32 i = 0; i < height; i++)
|
|
{
|
|
for (UINT32 j = 0; j < width; j++)
|
|
{
|
|
pixel = (UINT32*)&data[((1ULL * i * width) + j) * 4ULL];
|
|
*pixel = ((*pixel & 0x00FFFFFF) | (value << 24));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void* test_image_memset32(UINT32* ptr, UINT32 fill, size_t length)
|
|
{
|
|
while (length--)
|
|
{
|
|
*ptr++ = fill;
|
|
}
|
|
|
|
return (void*)ptr;
|
|
}
|
|
|
|
static int test_image_fill(BYTE* pDstData, UINT32 nDstStep, UINT32 nXDst, UINT32 nYDst,
|
|
UINT32 nWidth, UINT32 nHeight, UINT32 color)
|
|
{
|
|
UINT32* pDstPixel = nullptr;
|
|
|
|
if (nDstStep < 0)
|
|
nDstStep = 4 * nWidth;
|
|
|
|
for (UINT32 y = 0; y < nHeight; y++)
|
|
{
|
|
pDstPixel = (UINT32*)&pDstData[((nYDst + y) * nDstStep) + (nXDst * 4)];
|
|
test_image_memset32(pDstPixel, color, nWidth);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int test_image_fill_quarter(BYTE* pDstData, UINT32 nDstStep, UINT32 nWidth, UINT32 nHeight,
|
|
UINT32 color, UINT32 quarter)
|
|
{
|
|
UINT32 x = 0;
|
|
UINT32 y = 0;
|
|
UINT32 width = 0;
|
|
UINT32 height = 0;
|
|
|
|
switch (quarter)
|
|
{
|
|
case 0:
|
|
x = 0;
|
|
y = 0;
|
|
width = nWidth / 2;
|
|
height = nHeight / 2;
|
|
break;
|
|
|
|
case 1:
|
|
x = nWidth / 2;
|
|
y = nHeight / 2;
|
|
width = nWidth / 2;
|
|
height = nHeight / 2;
|
|
break;
|
|
|
|
case 2:
|
|
x = 0;
|
|
y = nHeight / 2;
|
|
width = nWidth / 2;
|
|
height = nHeight / 2;
|
|
break;
|
|
|
|
case 3:
|
|
x = nWidth / 2;
|
|
y = 0;
|
|
width = nWidth / 2;
|
|
height = nHeight / 2;
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
test_image_fill(pDstData, nDstStep, x, y, width, height, 0xFF000000);
|
|
return 1;
|
|
}
|
|
|
|
static int test_image_fill_unused_quarters(BYTE* pDstData, UINT32 nDstStep, UINT32 nWidth,
|
|
UINT32 nHeight, UINT32 color, UINT32 quarter)
|
|
{
|
|
return 1;
|
|
|
|
if (quarter == 0)
|
|
{
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 1);
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 2);
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 3);
|
|
}
|
|
else if (quarter == 1)
|
|
{
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 0);
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 2);
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 3);
|
|
}
|
|
else if (quarter == 2)
|
|
{
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 0);
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 1);
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 3);
|
|
}
|
|
else if (quarter == 3)
|
|
{
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 0);
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 1);
|
|
test_image_fill_quarter(pDstData, nDstStep, nWidth, nHeight, color, 2);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static BYTE* test_progressive_load_file(const char* path, const char* file, size_t* size)
|
|
{
|
|
char* filename = GetCombinedPath(path, file);
|
|
|
|
if (!filename)
|
|
return nullptr;
|
|
|
|
FILE* fp = winpr_fopen(filename, "r");
|
|
free(filename);
|
|
|
|
if (!fp)
|
|
return nullptr;
|
|
|
|
(void)_fseeki64(fp, 0, SEEK_END);
|
|
const INT64 pos = _ftelli64(fp);
|
|
WINPR_ASSERT(pos >= 0);
|
|
WINPR_ASSERT(pos <= SIZE_MAX);
|
|
*size = (size_t)pos;
|
|
(void)_fseeki64(fp, 0, SEEK_SET);
|
|
BYTE* buffer = (BYTE*)malloc(*size);
|
|
|
|
if (!buffer)
|
|
{
|
|
(void)fclose(fp);
|
|
return nullptr;
|
|
}
|
|
|
|
if (fread(buffer, *size, 1, fp) != 1)
|
|
{
|
|
free(buffer);
|
|
(void)fclose(fp);
|
|
return nullptr;
|
|
}
|
|
|
|
(void)fclose(fp);
|
|
return buffer;
|
|
}
|
|
|
|
static int test_progressive_load_files(char* ms_sample_path, EGFX_SAMPLE_FILE files[3][4][4])
|
|
{
|
|
int imageNo = 0;
|
|
int quarterNo = 0;
|
|
int passNo = 0;
|
|
/* image 1 */
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_0_025_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_0_050_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_0_075_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_0_100_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_1_025_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_1_050_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_1_075_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_1_100_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_2_025_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_2_050_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_2_075_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_2_100_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_3_025_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_3_050_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_3_075_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_0_3_100_sampleimage1.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
imageNo++;
|
|
/* image 2 */
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_0_025_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_0_050_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_0_075_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_0_100_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_1_025_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_1_050_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_1_075_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_1_100_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_2_025_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_2_050_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_2_075_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_2_100_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_3_025_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_3_050_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_3_075_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_1_3_100_sampleimage2.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
imageNo++;
|
|
/* image 3 */
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_0_025_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_0_050_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_0_075_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_0_100_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_1_025_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_1_050_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_1_075_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_1_100_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_2_025_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_2_050_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_2_075_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_2_100_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_3_025_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_3_050_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_3_075_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
passNo = (passNo + 1) % 4;
|
|
files[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_file(ms_sample_path, "compress/enc_2_3_100_sampleimage3.bin",
|
|
&(files[imageNo][quarterNo][passNo].size));
|
|
|
|
/* check if all test data has been loaded */
|
|
|
|
for (imageNo = 0; imageNo < 3; imageNo++)
|
|
{
|
|
for (quarterNo = 0; quarterNo < 4; quarterNo++)
|
|
{
|
|
for (passNo = 0; passNo < 4; passNo++)
|
|
{
|
|
if (!files[imageNo][quarterNo][passNo].buffer)
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static BYTE* test_progressive_load_bitmap(char* path, char* file, size_t* size, int quarter)
|
|
{
|
|
int status = 0;
|
|
BYTE* buffer = nullptr;
|
|
wImage* image = nullptr;
|
|
char* filename = nullptr;
|
|
filename = GetCombinedPath(path, file);
|
|
|
|
if (!filename)
|
|
return nullptr;
|
|
|
|
image = winpr_image_new();
|
|
|
|
if (!image)
|
|
return nullptr;
|
|
|
|
status = winpr_image_read(image, filename);
|
|
|
|
if (status < 0)
|
|
return nullptr;
|
|
|
|
buffer = image->data;
|
|
*size = 1ULL * image->height * image->scanline;
|
|
test_fill_image_alpha_channel(image->data, image->width, image->height, 0xFF);
|
|
test_image_fill_unused_quarters(image->data, image->scanline, image->width, image->height,
|
|
quarter, 0xFF000000);
|
|
winpr_image_free(image, FALSE);
|
|
free(filename);
|
|
return buffer;
|
|
}
|
|
|
|
static int test_progressive_load_bitmaps(char* ms_sample_path, EGFX_SAMPLE_FILE bitmaps[3][4][4])
|
|
{
|
|
int imageNo = 0;
|
|
int quarterNo = 0;
|
|
int passNo = 0;
|
|
/* image 1 */
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_0_025_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_0_050_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_0_075_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_0_100_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_1_025_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_1_050_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_1_075_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_1_100_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_2_025_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_2_050_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_2_075_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_2_100_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_3_025_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_3_050_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_3_075_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_0_3_100_sampleimage1.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
imageNo++;
|
|
/* image 2 */
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_0_025_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_0_050_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_0_075_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_0_100_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_1_025_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_1_050_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_1_075_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_1_100_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_2_025_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_2_050_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_2_075_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_2_100_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_3_025_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_3_050_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_3_075_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_1_3_100_sampleimage2.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
imageNo++;
|
|
/* image 3 */
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_0_025_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_0_050_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_0_075_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_0_100_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_1_025_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_1_050_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_1_075_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_1_100_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_2_025_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_2_050_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_2_075_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_2_100_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
quarterNo = (quarterNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_3_025_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_3_050_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_3_075_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
passNo = (passNo + 1) % 4;
|
|
bitmaps[imageNo][quarterNo][passNo].buffer =
|
|
test_progressive_load_bitmap(ms_sample_path, "decompress/dec_2_3_100_sampleimage3.bmp",
|
|
&(bitmaps[imageNo][quarterNo][passNo].size), quarterNo);
|
|
|
|
/* check if all test data has been loaded */
|
|
|
|
for (imageNo = 0; imageNo < 3; imageNo++)
|
|
{
|
|
for (quarterNo = 0; quarterNo < 4; quarterNo++)
|
|
{
|
|
for (passNo = 0; passNo < 4; passNo++)
|
|
{
|
|
if (!bitmaps[imageNo][quarterNo][passNo].buffer)
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static size_t test_memcmp_count(const BYTE* mem1, const BYTE* mem2, size_t size, int margin)
|
|
{
|
|
size_t count = 0;
|
|
|
|
for (size_t index = 0; index < size; index++)
|
|
{
|
|
if (*mem1 != *mem2)
|
|
{
|
|
const int error = (*mem1 > *mem2) ? *mem1 - *mem2 : *mem2 - *mem1;
|
|
|
|
if (error > margin)
|
|
count++;
|
|
}
|
|
|
|
mem1++;
|
|
mem2++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
static int test_progressive_decode(PROGRESSIVE_CONTEXT* progressive, EGFX_SAMPLE_FILE files[4],
|
|
EGFX_SAMPLE_FILE bitmaps[4], int quarter, int count)
|
|
{
|
|
int nXSrc = 0;
|
|
int nYSrc = 0;
|
|
|
|
RECTANGLE_16 clippingRect = WINPR_C_ARRAY_INIT;
|
|
clippingRect.right = g_Width;
|
|
clippingRect.bottom = g_Height;
|
|
|
|
for (int pass = 0; pass < count; pass++)
|
|
{
|
|
const int status =
|
|
progressive_decompress(progressive, files[pass].buffer, files[pass].size, g_DstData,
|
|
PIXEL_FORMAT_XRGB32, g_DstStep, 0, 0, nullptr, 0, 0);
|
|
printf("ProgressiveDecompress: status: %d pass: %d\n", status, pass + 1);
|
|
PROGRESSIVE_BLOCK_REGION* region = &(progressive->region);
|
|
|
|
switch (quarter)
|
|
{
|
|
case 0:
|
|
clippingRect.left = 0;
|
|
clippingRect.top = 0;
|
|
clippingRect.right = g_Width / 2;
|
|
clippingRect.bottom = g_Height / 2;
|
|
break;
|
|
|
|
case 1:
|
|
clippingRect.left = g_Width / 2;
|
|
clippingRect.top = g_Height / 2;
|
|
clippingRect.right = g_Width;
|
|
clippingRect.bottom = g_Height;
|
|
break;
|
|
|
|
case 2:
|
|
clippingRect.left = 0;
|
|
clippingRect.top = g_Height / 2;
|
|
clippingRect.right = g_Width / 2;
|
|
clippingRect.bottom = g_Height;
|
|
break;
|
|
|
|
case 3:
|
|
clippingRect.left = g_Width / 2;
|
|
clippingRect.top = 0;
|
|
clippingRect.right = g_Width;
|
|
clippingRect.bottom = g_Height / 2;
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
for (UINT16 index = 0; index < region->numTiles; index++)
|
|
{
|
|
RFX_PROGRESSIVE_TILE* tile = region->tiles[index];
|
|
|
|
const RECTANGLE_16 tileRect = { tile->x, tile->y, tile->x + tile->width,
|
|
tile->y + tile->height };
|
|
RECTANGLE_16 updateRect = WINPR_C_ARRAY_INIT;
|
|
rectangles_intersection(&tileRect, &clippingRect, &updateRect);
|
|
const UINT16 nXDst = updateRect.left;
|
|
const UINT16 nYDst = updateRect.top;
|
|
const UINT16 nWidth = updateRect.right - updateRect.left;
|
|
const UINT16 nHeight = updateRect.bottom - updateRect.top;
|
|
|
|
if ((nWidth <= 0) || (nHeight <= 0))
|
|
continue;
|
|
|
|
nXSrc = nXDst - WINPR_ASSERTING_INT_CAST(int, tile->x);
|
|
nYSrc = nYDst - WINPR_ASSERTING_INT_CAST(int, tile->y);
|
|
freerdp_image_copy(g_DstData, PIXEL_FORMAT_XRGB32, g_DstStep, nXDst, nYDst, nWidth,
|
|
nHeight, tile->data, PIXEL_FORMAT_XRGB32, 64 * 4, nXSrc, nYSrc,
|
|
nullptr, FREERDP_FLIP_NONE);
|
|
}
|
|
|
|
const size_t size = bitmaps[pass].size;
|
|
const size_t cnt = test_memcmp_count(g_DstData, bitmaps[pass].buffer, size, 1);
|
|
|
|
if (cnt)
|
|
{
|
|
const float rate = ((float)cnt) / ((float)size) * 100.0f;
|
|
printf("Progressive RemoteFX decompression failure\n");
|
|
printf("Actual, Expected (%" PRIuz "/%" PRIuz " = %.3f%%):\n", cnt, size, rate);
|
|
}
|
|
|
|
// WLog_Image(progressive->log, WLOG_TRACE, g_DstData, g_Width, g_Height, 32);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int test_progressive_ms_sample(char* ms_sample_path)
|
|
{
|
|
int count = 0;
|
|
int status = 0;
|
|
EGFX_SAMPLE_FILE files[3][4][4] = WINPR_C_ARRAY_INIT;
|
|
EGFX_SAMPLE_FILE bitmaps[3][4][4] = WINPR_C_ARRAY_INIT;
|
|
PROGRESSIVE_CONTEXT* progressive = nullptr;
|
|
g_Width = 1920;
|
|
g_Height = 1080;
|
|
g_DstStep = g_Width * 4;
|
|
status = test_progressive_load_files(ms_sample_path, files);
|
|
|
|
if (status < 0)
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
for (int k = 0; k < 4; k++)
|
|
sample_file_free(&files[i][j][k]);
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
status = test_progressive_load_bitmaps(ms_sample_path, bitmaps);
|
|
|
|
if (status < 0)
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
for (int k = 0; k < 4; k++)
|
|
sample_file_free(&files[i][j][k]);
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
count = 4;
|
|
progressive = progressive_context_new(FALSE);
|
|
g_DstData = winpr_aligned_malloc(1LL * g_DstStep * g_Height, 16);
|
|
progressive_create_surface_context(progressive, 0, g_Width, g_Height);
|
|
|
|
/* image 1 */
|
|
|
|
if (1)
|
|
{
|
|
printf("\nSample Image 1\n");
|
|
test_image_fill(g_DstData, g_DstStep, 0, 0, g_Width, g_Height, 0xFF000000);
|
|
test_progressive_decode(progressive, files[0][0], bitmaps[0][0], 0, count);
|
|
test_progressive_decode(progressive, files[0][1], bitmaps[0][1], 1, count);
|
|
test_progressive_decode(progressive, files[0][2], bitmaps[0][2], 2, count);
|
|
test_progressive_decode(progressive, files[0][3], bitmaps[0][3], 3, count);
|
|
}
|
|
|
|
/* image 2 */
|
|
|
|
if (0)
|
|
{
|
|
printf("\nSample Image 2\n"); /* sample data is in incorrect order */
|
|
test_image_fill(g_DstData, g_DstStep, 0, 0, g_Width, g_Height, 0xFF000000);
|
|
test_progressive_decode(progressive, files[1][0], bitmaps[1][0], 0, count);
|
|
test_progressive_decode(progressive, files[1][1], bitmaps[1][1], 1, count);
|
|
test_progressive_decode(progressive, files[1][2], bitmaps[1][2], 2, count);
|
|
test_progressive_decode(progressive, files[1][3], bitmaps[1][3], 3, count);
|
|
}
|
|
|
|
/* image 3 */
|
|
|
|
if (0)
|
|
{
|
|
printf("\nSample Image 3\n"); /* sample data is in incorrect order */
|
|
test_image_fill(g_DstData, g_DstStep, 0, 0, g_Width, g_Height, 0xFF000000);
|
|
test_progressive_decode(progressive, files[2][0], bitmaps[2][0], 0, count);
|
|
test_progressive_decode(progressive, files[2][1], bitmaps[2][1], 1, count);
|
|
test_progressive_decode(progressive, files[2][2], bitmaps[2][2], 2, count);
|
|
test_progressive_decode(progressive, files[2][3], bitmaps[2][3], 3, count);
|
|
}
|
|
|
|
progressive_context_free(progressive);
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
for (int k = 0; k < 4; k++)
|
|
{
|
|
sample_file_free(&bitmaps[i][j][k]);
|
|
sample_file_free(&files[i][j][k]);
|
|
}
|
|
}
|
|
}
|
|
|
|
winpr_aligned_free(g_DstData);
|
|
return 0;
|
|
}
|
|
|
|
static BOOL diff(BYTE a, BYTE b)
|
|
{
|
|
BYTE big = MAX(a, b);
|
|
BYTE little = MIN(a, b);
|
|
return (big - little <= 0x25);
|
|
}
|
|
|
|
static BOOL colordiff(UINT32 format, UINT32 a, UINT32 b)
|
|
{
|
|
BYTE ar = 0;
|
|
BYTE ag = 0;
|
|
BYTE ab = 0;
|
|
BYTE aa = 0;
|
|
BYTE br = 0;
|
|
BYTE bg = 0;
|
|
BYTE bb = 0;
|
|
BYTE ba = 0;
|
|
FreeRDPSplitColor(a, format, &ar, &ag, &ab, &aa, nullptr);
|
|
FreeRDPSplitColor(b, format, &br, &bg, &bb, &ba, nullptr);
|
|
return !(!diff(aa, ba) || !diff(ar, br) || !diff(ag, bg) || !diff(ab, bb));
|
|
}
|
|
|
|
static BOOL test_encode_decode(const char* path)
|
|
{
|
|
BOOL res = FALSE;
|
|
int rc = 0;
|
|
BYTE* resultData = nullptr;
|
|
BYTE* dstData = nullptr;
|
|
UINT32 dstSize = 0;
|
|
UINT32 ColorFormat = PIXEL_FORMAT_BGRX32;
|
|
REGION16 invalidRegion = WINPR_C_ARRAY_INIT;
|
|
wImage* image = winpr_image_new();
|
|
wImage* dstImage = winpr_image_new();
|
|
char* name = GetCombinedPath(path, "progressive.bmp");
|
|
PROGRESSIVE_CONTEXT* progressiveEnc = progressive_context_new(TRUE);
|
|
PROGRESSIVE_CONTEXT* progressiveDec = progressive_context_new(FALSE);
|
|
|
|
region16_init(&invalidRegion);
|
|
if (!image || !dstImage || !name || !progressiveEnc || !progressiveDec)
|
|
goto fail;
|
|
|
|
rc = winpr_image_read(image, name);
|
|
if (rc <= 0)
|
|
goto fail;
|
|
|
|
resultData = calloc(image->scanline, image->height);
|
|
if (!resultData)
|
|
goto fail;
|
|
|
|
// Progressive encode
|
|
rc = progressive_compress(progressiveEnc, image->data, image->scanline * image->height,
|
|
ColorFormat, image->width, image->height, image->scanline, nullptr,
|
|
&dstData, &dstSize);
|
|
if (rc < 0)
|
|
goto fail;
|
|
|
|
// Progressive decode
|
|
rc = progressive_create_surface_context(progressiveDec, 0, image->width, image->height);
|
|
if (rc <= 0)
|
|
goto fail;
|
|
|
|
rc = progressive_decompress(progressiveDec, dstData, dstSize, resultData, ColorFormat,
|
|
image->scanline, 0, 0, &invalidRegion, 0, 0);
|
|
if (rc < 0)
|
|
goto fail;
|
|
|
|
// Compare result
|
|
if (0) // Dump result image for manual inspection
|
|
{
|
|
*dstImage = *image;
|
|
dstImage->data = resultData;
|
|
winpr_image_write(dstImage, "/tmp/test.bmp");
|
|
}
|
|
for (size_t y = 0; y < image->height; y++)
|
|
{
|
|
const BYTE* orig = &image->data[y * image->scanline];
|
|
const BYTE* dec = &resultData[y * image->scanline];
|
|
for (size_t x = 0; x < image->width; x++)
|
|
{
|
|
const BYTE* po = &orig[x * 4];
|
|
const BYTE* pd = &dec[x * 4];
|
|
|
|
const DWORD a = FreeRDPReadColor(po, ColorFormat);
|
|
const DWORD b = FreeRDPReadColor(pd, ColorFormat);
|
|
if (!colordiff(ColorFormat, a, b))
|
|
{
|
|
printf("xxxxxxx [%" PRIuz ":%" PRIuz "] [%s] %08X != %08X\n", x, y,
|
|
FreeRDPGetColorFormatName(ColorFormat), a, b);
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
res = TRUE;
|
|
fail:
|
|
region16_uninit(&invalidRegion);
|
|
progressive_context_free(progressiveEnc);
|
|
progressive_context_free(progressiveDec);
|
|
winpr_image_free(image, TRUE);
|
|
winpr_image_free(dstImage, FALSE);
|
|
free(resultData);
|
|
free(name);
|
|
return res;
|
|
}
|
|
|
|
static BOOL readUInt(FILE* fp, const char* prefix, const char* postfix, UINT32* pval)
|
|
{
|
|
WINPR_ASSERT(fp);
|
|
WINPR_ASSERT(prefix);
|
|
WINPR_ASSERT(postfix);
|
|
WINPR_ASSERT(pval);
|
|
|
|
BOOL rc = FALSE;
|
|
const size_t plen = strlen(prefix);
|
|
const size_t polen = strlen(postfix);
|
|
|
|
char* str = nullptr;
|
|
size_t len = SIZE_MAX;
|
|
const INT64 res = GetLine(&str, &len, fp);
|
|
if ((res < plen + polen) || !str)
|
|
goto fail;
|
|
|
|
if (strncmp(str, prefix, plen) != 0)
|
|
goto fail;
|
|
|
|
char* start = &str[plen];
|
|
char* end = strstr(start, postfix);
|
|
if (!end)
|
|
goto fail;
|
|
*end = '\0';
|
|
|
|
errno = 0;
|
|
unsigned long val = strtoul(start, nullptr, 0);
|
|
if ((errno != 0) || (val > UINT32_MAX))
|
|
goto fail;
|
|
|
|
*pval = val;
|
|
rc = TRUE;
|
|
|
|
fail:
|
|
free(str);
|
|
return rc;
|
|
}
|
|
|
|
static BOOL read_cmd(FILE* fp, RDPGFX_SURFACE_COMMAND* cmd, UINT32* frameId)
|
|
{
|
|
WINPR_ASSERT(fp);
|
|
WINPR_ASSERT(cmd);
|
|
WINPR_ASSERT(frameId);
|
|
|
|
if (!readUInt(fp, "frameid: ", "\n", frameId))
|
|
return FALSE;
|
|
if (!readUInt(fp, "surfaceId: ", "\n", &cmd->surfaceId))
|
|
return FALSE;
|
|
if (!readUInt(fp, "codecId: ", "\n", &cmd->codecId))
|
|
return FALSE;
|
|
if (!readUInt(fp, "contextId: ", "\n", &cmd->contextId))
|
|
return FALSE;
|
|
if (!readUInt(fp, "format: ", "\n", &cmd->format))
|
|
return FALSE;
|
|
if (!readUInt(fp, "left: ", "\n", &cmd->left))
|
|
return FALSE;
|
|
if (!readUInt(fp, "top: ", "\n", &cmd->top))
|
|
return FALSE;
|
|
if (!readUInt(fp, "right: ", "\n", &cmd->right))
|
|
return FALSE;
|
|
if (!readUInt(fp, "bottom: ", "\n", &cmd->bottom))
|
|
return FALSE;
|
|
if (!readUInt(fp, "width: ", "\n", &cmd->width))
|
|
return FALSE;
|
|
if (!readUInt(fp, "height: ", "\n", &cmd->height))
|
|
return FALSE;
|
|
if (!readUInt(fp, "length: ", "\n", &cmd->length))
|
|
return FALSE;
|
|
|
|
char* data = nullptr;
|
|
size_t dlen = SIZE_MAX;
|
|
INT64 slen = GetLine(&data, &dlen, fp);
|
|
if (slen < 0)
|
|
return FALSE;
|
|
|
|
if (slen >= 7)
|
|
{
|
|
const char* b64 = &data[6];
|
|
slen -= 7;
|
|
crypto_base64_decode(b64, slen, &cmd->data, &dlen);
|
|
}
|
|
free(data);
|
|
|
|
return cmd->length == dlen;
|
|
}
|
|
|
|
static void free_cmd(RDPGFX_SURFACE_COMMAND* cmd)
|
|
{
|
|
free(cmd->data);
|
|
}
|
|
|
|
WINPR_NORETURN(static void usage(const char* name))
|
|
{
|
|
FILE* fp = stdout;
|
|
(void)fprintf(fp, "%s <directory> <width> <height>\n", name);
|
|
// NOLINTNEXTLINE(concurrency-mt-unsafe)
|
|
exit(-1);
|
|
}
|
|
|
|
static void print_codec_stats(const char* name, UINT64 timeNS)
|
|
{
|
|
const double dectimeMS = (double)timeNS / 1000.0 / 1000.0;
|
|
(void)fprintf(stderr, "[%s] took %lf ms to decode\n", name, dectimeMS);
|
|
}
|
|
|
|
static UINT64 measure_diff_and_print(const char* cname, UINT32 frameId, UINT64 start)
|
|
{
|
|
const UINT64 end = winpr_GetTickCount64NS();
|
|
const UINT64 diff = end - start;
|
|
const double ddiff = (double)diff / 1000000.0;
|
|
(void)fprintf(stderr, "frame [%s] %" PRIu32 " took %lf ms\n", cname, frameId, ddiff);
|
|
return diff;
|
|
}
|
|
|
|
static int test_dump(int argc, char* argv[])
|
|
{
|
|
int success = -1;
|
|
UINT32 count = 0;
|
|
|
|
UINT64 CAPROGRESSIVE_dectime = 0;
|
|
UINT64 UNCOMPRESSED_dectime = 0;
|
|
UINT64 CAVIDEO_dectime = 0;
|
|
UINT64 CLEARCODEC_dectime = 0;
|
|
UINT64 PLANAR_dectime = 0;
|
|
UINT64 AVC420_dectime = 0;
|
|
UINT64 ALPHA_dectime = 0;
|
|
UINT64 AVC444_dectime = 0;
|
|
UINT64 AVC444v2_dectime = 0;
|
|
UINT64 copytime = 0;
|
|
|
|
if (argc < 4)
|
|
usage(argv[0]);
|
|
|
|
const char* path = argv[1];
|
|
errno = 0;
|
|
const unsigned long width = strtoul(argv[2], nullptr, 0);
|
|
if ((errno != 0) || (width <= 0))
|
|
usage(argv[0]);
|
|
const unsigned long height = strtoul(argv[3], nullptr, 0);
|
|
if ((errno != 0) || (height <= 0))
|
|
usage(argv[0]);
|
|
|
|
rdpCodecs* codecs = freerdp_client_codecs_new(0);
|
|
if (!codecs)
|
|
return -2;
|
|
|
|
UINT32 DstFormat = PIXEL_FORMAT_BGRA32;
|
|
const UINT32 stride = (width + 16) * FreeRDPGetBytesPerPixel(DstFormat);
|
|
|
|
BYTE* dst = calloc(stride, height);
|
|
BYTE* output = calloc(stride, height);
|
|
if (!dst || !output)
|
|
goto fail;
|
|
|
|
if (!freerdp_client_codecs_prepare(codecs, FREERDP_CODEC_ALL, width, height))
|
|
goto fail;
|
|
|
|
success = 0;
|
|
while (success >= 0)
|
|
{
|
|
char* fname = nullptr;
|
|
size_t flen = 0;
|
|
winpr_asprintf(&fname, &flen, "%s/%08" PRIx32 ".raw", path, count++);
|
|
FILE* fp = fopen(fname, "r");
|
|
free(fname);
|
|
|
|
if (!fp)
|
|
break;
|
|
|
|
UINT32 frameId = 0;
|
|
RDPGFX_SURFACE_COMMAND cmd = WINPR_C_ARRAY_INIT;
|
|
|
|
if (read_cmd(fp, &cmd, &frameId))
|
|
{
|
|
REGION16 invalid = WINPR_C_ARRAY_INIT;
|
|
region16_init(&invalid);
|
|
|
|
const char* cname = rdpgfx_get_codec_id_string(cmd.codecId);
|
|
switch (cmd.codecId)
|
|
{
|
|
case RDPGFX_CODECID_CAPROGRESSIVE:
|
|
{
|
|
const UINT64 start = winpr_GetTickCount64NS();
|
|
success = progressive_create_surface_context(codecs->progressive, cmd.surfaceId,
|
|
width, height);
|
|
if (success >= 0)
|
|
success = progressive_decompress(codecs->progressive, cmd.data, cmd.length,
|
|
dst, DstFormat, 0, cmd.left, cmd.top,
|
|
&invalid, cmd.surfaceId, frameId);
|
|
CAPROGRESSIVE_dectime += measure_diff_and_print(cname, frameId, start);
|
|
}
|
|
break;
|
|
|
|
case RDPGFX_CODECID_UNCOMPRESSED:
|
|
{
|
|
const UINT64 start = winpr_GetTickCount64NS();
|
|
if (!freerdp_image_copy_no_overlap(dst, DstFormat, stride, cmd.left, cmd.top,
|
|
cmd.width, cmd.height, cmd.data, cmd.format,
|
|
0, 0, 0, nullptr, FREERDP_FLIP_NONE))
|
|
success = -1;
|
|
|
|
RECTANGLE_16 invalidRect = { .left = (UINT16)MIN(UINT16_MAX, cmd.left),
|
|
.top = (UINT16)MIN(UINT16_MAX, cmd.top),
|
|
.right = (UINT16)MIN(UINT16_MAX, cmd.right),
|
|
.bottom = (UINT16)MIN(UINT16_MAX, cmd.bottom) };
|
|
region16_union_rect(&invalid, &invalid, &invalidRect);
|
|
UNCOMPRESSED_dectime += measure_diff_and_print(cname, frameId, start);
|
|
}
|
|
break;
|
|
case RDPGFX_CODECID_CAVIDEO:
|
|
{
|
|
const UINT64 start = winpr_GetTickCount64NS();
|
|
if (!rfx_process_message(codecs->rfx, cmd.data, cmd.length, cmd.left, cmd.top,
|
|
dst, DstFormat, stride, height, &invalid))
|
|
success = -1;
|
|
|
|
CAVIDEO_dectime += measure_diff_and_print(cname, frameId, start);
|
|
}
|
|
break;
|
|
case RDPGFX_CODECID_CLEARCODEC:
|
|
{
|
|
const UINT64 start = winpr_GetTickCount64NS();
|
|
success = clear_decompress(codecs->clear, cmd.data, cmd.length, cmd.width,
|
|
cmd.height, dst, DstFormat, stride, cmd.left,
|
|
cmd.top, width, height, nullptr);
|
|
|
|
const RECTANGLE_16 invalidRect = { .left = (UINT16)MIN(UINT16_MAX, cmd.left),
|
|
.top = (UINT16)MIN(UINT16_MAX, cmd.top),
|
|
.right = (UINT16)MIN(UINT16_MAX, cmd.right),
|
|
.bottom =
|
|
(UINT16)MIN(UINT16_MAX, cmd.bottom) };
|
|
region16_union_rect(&invalid, &invalid, &invalidRect);
|
|
CLEARCODEC_dectime += measure_diff_and_print(cname, frameId, start);
|
|
}
|
|
break;
|
|
case RDPGFX_CODECID_PLANAR:
|
|
{
|
|
const UINT64 start = winpr_GetTickCount64NS();
|
|
|
|
if (!freerdp_bitmap_decompress_planar(
|
|
codecs->planar, cmd.data, cmd.length, cmd.width, cmd.height, dst,
|
|
DstFormat, stride, cmd.left, cmd.top, cmd.width, cmd.height, FALSE))
|
|
success = -1;
|
|
|
|
const RECTANGLE_16 invalidRect = { .left = (UINT16)MIN(UINT16_MAX, cmd.left),
|
|
.top = (UINT16)MIN(UINT16_MAX, cmd.top),
|
|
.right = (UINT16)MIN(UINT16_MAX, cmd.right),
|
|
.bottom =
|
|
(UINT16)MIN(UINT16_MAX, cmd.bottom) };
|
|
region16_union_rect(&invalid, &invalid, &invalidRect);
|
|
|
|
PLANAR_dectime += measure_diff_and_print(cname, frameId, start);
|
|
}
|
|
break;
|
|
case RDPGFX_CODECID_AVC420:
|
|
{
|
|
const UINT64 start = winpr_GetTickCount64NS();
|
|
|
|
AVC420_dectime += measure_diff_and_print(cname, frameId, start);
|
|
success = -1;
|
|
}
|
|
break;
|
|
case RDPGFX_CODECID_ALPHA:
|
|
{
|
|
const UINT64 start = winpr_GetTickCount64NS();
|
|
|
|
ALPHA_dectime += measure_diff_and_print(cname, frameId, start);
|
|
success = -1;
|
|
}
|
|
break;
|
|
case RDPGFX_CODECID_AVC444:
|
|
{
|
|
const UINT64 start = winpr_GetTickCount64NS();
|
|
|
|
AVC444_dectime += measure_diff_and_print(cname, frameId, start);
|
|
success = -1;
|
|
}
|
|
break;
|
|
case RDPGFX_CODECID_AVC444v2:
|
|
{
|
|
const UINT64 start = winpr_GetTickCount64NS();
|
|
|
|
AVC444v2_dectime += measure_diff_and_print(cname, frameId, start);
|
|
success = -1;
|
|
}
|
|
break;
|
|
default:
|
|
(void)fprintf(stderr, "unexpected codec %s [0x%08" PRIx32 "]",
|
|
rdpgfx_get_codec_id_string(cmd.codecId), cmd.codecId);
|
|
success = -1;
|
|
break;
|
|
}
|
|
|
|
if (success >= 0)
|
|
{
|
|
UINT32 nbRects = 0;
|
|
const UINT64 start = winpr_GetTickCount64NS();
|
|
|
|
const RECTANGLE_16* rects = region16_rects(&invalid, &nbRects);
|
|
for (size_t x = 0; x < nbRects; x++)
|
|
{
|
|
const RECTANGLE_16* rect = &rects[x];
|
|
const UINT32 w = rect->right - rect->left;
|
|
const UINT32 h = rect->bottom - rect->top;
|
|
if (!freerdp_image_copy_no_overlap(output, DstFormat, stride, rect->left,
|
|
rect->top, w, h, dst, DstFormat, stride,
|
|
rect->left, rect->top, nullptr, 0))
|
|
success = -42;
|
|
}
|
|
copytime += measure_diff_and_print(cname, frameId, start);
|
|
}
|
|
region16_clear(&invalid);
|
|
}
|
|
free_cmd(&cmd);
|
|
(void)fclose(fp);
|
|
}
|
|
|
|
fail:
|
|
freerdp_client_codecs_free(codecs);
|
|
free(output);
|
|
free(dst);
|
|
|
|
print_codec_stats(rdpgfx_get_codec_id_string(RDPGFX_CODECID_UNCOMPRESSED),
|
|
UNCOMPRESSED_dectime);
|
|
print_codec_stats(rdpgfx_get_codec_id_string(RDPGFX_CODECID_CAPROGRESSIVE),
|
|
CAPROGRESSIVE_dectime);
|
|
print_codec_stats(rdpgfx_get_codec_id_string(RDPGFX_CODECID_CAVIDEO), CAVIDEO_dectime);
|
|
print_codec_stats(rdpgfx_get_codec_id_string(RDPGFX_CODECID_CLEARCODEC), CLEARCODEC_dectime);
|
|
print_codec_stats(rdpgfx_get_codec_id_string(RDPGFX_CODECID_PLANAR), PLANAR_dectime);
|
|
print_codec_stats(rdpgfx_get_codec_id_string(RDPGFX_CODECID_AVC420), AVC420_dectime);
|
|
print_codec_stats(rdpgfx_get_codec_id_string(RDPGFX_CODECID_AVC444), AVC444_dectime);
|
|
print_codec_stats(rdpgfx_get_codec_id_string(RDPGFX_CODECID_AVC444v2), AVC444v2_dectime);
|
|
print_codec_stats(rdpgfx_get_codec_id_string(RDPGFX_CODECID_ALPHA), ALPHA_dectime);
|
|
|
|
const UINT64 decodetime = UNCOMPRESSED_dectime + CAPROGRESSIVE_dectime + CAVIDEO_dectime +
|
|
CLEARCODEC_dectime + PLANAR_dectime + AVC420_dectime +
|
|
AVC444_dectime + AVC444v2_dectime + ALPHA_dectime;
|
|
print_codec_stats("surface copy", copytime);
|
|
print_codec_stats("total decode", decodetime);
|
|
print_codec_stats("total", decodetime + copytime);
|
|
|
|
return success;
|
|
}
|
|
|
|
int TestFreeRDPCodecProgressive(int argc, char* argv[])
|
|
{
|
|
if (argc > 1)
|
|
return test_dump(argc, argv);
|
|
|
|
int rc = -1;
|
|
char* ms_sample_path = nullptr;
|
|
char name[8192];
|
|
SYSTEMTIME systemTime;
|
|
WINPR_UNUSED(argc);
|
|
WINPR_UNUSED(argv);
|
|
|
|
GetSystemTime(&systemTime);
|
|
(void)sprintf_s(name, sizeof(name),
|
|
"EGFX_PROGRESSIVE_MS_SAMPLE-%04" PRIu16 "%02" PRIu16 "%02" PRIu16 "%02" PRIu16
|
|
"%02" PRIu16 "%02" PRIu16 "%04" PRIu16,
|
|
systemTime.wYear, systemTime.wMonth, systemTime.wDay, systemTime.wHour,
|
|
systemTime.wMinute, systemTime.wSecond, systemTime.wMilliseconds);
|
|
ms_sample_path = _strdup(CMAKE_CURRENT_SOURCE_DIR);
|
|
|
|
if (!ms_sample_path)
|
|
{
|
|
printf("Memory allocation failed\n");
|
|
goto fail;
|
|
}
|
|
|
|
if (winpr_PathFileExists(ms_sample_path))
|
|
{
|
|
/*
|
|
if (test_progressive_ms_sample(ms_sample_path) < 0)
|
|
goto fail;
|
|
*/
|
|
if (!test_encode_decode(ms_sample_path))
|
|
goto fail;
|
|
rc = 0;
|
|
}
|
|
|
|
fail:
|
|
free(ms_sample_path);
|
|
return rc;
|
|
}
|