cunit/test_librfx.c

   1 /**
   2  * FreeRDP: A Remote Desktop Protocol Client
   3  * RemoteFX Codec Library Unit Tests
   4  *
   5  * Copyright 2011 Vic Lee
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 /**
  21  * The sample data comes from [MS-RDPRFX] 4.2.3, which is decoded into three
  22  * vertical bands in red (21x64), green (23x64) and blue(20x64) color.
  23  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <freerdp/types.h>
  29 #include <freerdp/utils/print.h>
  30 #include <freerdp/utils/memory.h>
  31 #include <freerdp/utils/hexdump.h>
  32 #include <freerdp/codec/rfx.h>
  33 #include "rfx_types.h"
  34 #include "rfx_bitstream.h"
  35 #include "rfx_rlgr.h"
  36 #include "rfx_differential.h"
  37 #include "rfx_quantization.h"
  38 #include "rfx_dwt.h"
  39 #include "rfx_decode.h"
  40 #include "rfx_encode.h"
  41
  42 #include "test_librfx.h"
  43
  44 static const uint8 y_data[] =
  45 {
  46                           0x19, 0x82, 0x1d, 0x10, 0x62, 0x9d, 0x28, 0x85, 0x2c, 0xa2, 0x14, 0xb2, 0x88,
  47         0x52, 0xca, 0x21, 0x4b, 0x28, 0x85, 0x2c, 0xa2, 0x14, 0xb2, 0x88, 0x52, 0xca, 0x21, 0x4b, 0x28,
  48         0x85, 0x2c, 0xa2, 0x14, 0xb2, 0x88, 0x52, 0xca, 0x21, 0x4b, 0x28, 0x85, 0x2c, 0xa2, 0x14, 0xb2,
  49         0x88, 0x52, 0xca, 0x21, 0x4b, 0x28, 0x85, 0x2c, 0xa2, 0x14, 0xb2, 0x88, 0x52, 0xca, 0x21, 0x4b,
  50         0x28, 0x85, 0x2c, 0xa2, 0x14, 0xb2, 0x88, 0x52, 0xca, 0x21, 0x4b, 0x28, 0x85, 0x2c, 0xa2, 0x14,
  51         0xb2, 0x88, 0x52, 0xca, 0x21, 0x4b, 0x28, 0x85, 0x2c, 0xa2, 0x14, 0xb0, 0x00, 0x20, 0xf4, 0x40,
  52         0x0c, 0xc1, 0x1e, 0x20, 0x26, 0x22, 0x20, 0x33, 0x23, 0xc4, 0x23, 0x88, 0x86, 0x50, 0xf1, 0x22,
  53         0x68, 0x4c, 0x91, 0x85, 0x10, 0x34, 0x4c, 0x84, 0x78, 0xa2, 0x0d, 0x13, 0x21, 0x1e, 0x29, 0x06,
  54         0x89, 0x90, 0x8f, 0x14, 0x83, 0x44, 0xf4, 0x23, 0xc5, 0x20, 0xd1, 0x3d, 0x08, 0xf1, 0x48, 0x34,
  55         0x4f, 0x42, 0x3c, 0x52, 0x0d, 0x13, 0xd0, 0x8f, 0x14, 0x83, 0x44, 0xf4, 0x23, 0xc5, 0x20, 0xd1,
  56         0x3d, 0x08, 0xf1, 0x48, 0x34, 0x4f, 0x42, 0x3c, 0x52, 0x0d, 0x13, 0xd0, 0x8f, 0x14, 0x83, 0x44,
  57         0xf4, 0x23, 0xc5, 0x20, 0x00, 0x08, 0x47, 0x70, 0x15, 0x02, 0xe0, 0x7f, 0xe4, 0x9d, 0xc2, 0x51,
  58         0x71, 0xf4, 0x99, 0xc9, 0x57, 0xff, 0x32, 0x87, 0x9d, 0x17, 0xd6, 0x50, 0x6e, 0x06, 0x2f, 0xac,
  59         0xa0, 0x9c, 0x0c, 0x5f, 0x59, 0x41, 0x38, 0x18, 0xbe, 0xb2, 0x82, 0x70, 0x31, 0x7d, 0x65, 0x00,
  60         0x00, 0x10, 0xff, 0x9c, 0x33, 0x41, 0xf1, 0xc4, 0xb0, 0x3c, 0xff, 0xa2, 0x15, 0xbd, 0x7b, 0xea,
  61         0x86, 0x9b, 0x5f, 0xfc, 0x78, 0x8c, 0xf5, 0xed, 0xa8, 0x68, 0xda, 0xfd, 0x3c, 0x45, 0x7a, 0xf4,
  62         0xd4, 0x34, 0x6d, 0x7e, 0x9e, 0x22, 0xbd, 0x7a, 0x6a, 0x1a, 0x36, 0xbf, 0x4f, 0x11, 0x5e, 0xbd,
  63         0x35, 0x0d, 0x1b, 0x5f, 0xa7, 0x88, 0xaf, 0x5e, 0x9a, 0x86, 0x8d, 0xaf, 0xd3, 0xc4, 0x57, 0xaf,
  64         0x4d, 0x43, 0x46, 0xd7, 0xe9, 0xe2, 0x20, 0x30, 0x00
  65 };
  66
  67 static const uint8 cb_data[] =
  68 {
  69                                                               0x1b, 0x04, 0x7f, 0x04, 0x31, 0x5f, 0xc2,
  70         0x94, 0xaf, 0x05, 0x29, 0x5e, 0x0a, 0x52, 0xbc, 0x14, 0xa5, 0x78, 0x29, 0x25, 0x78, 0x29, 0x25,
  71         0x78, 0x29, 0x25, 0x68, 0x52, 0x4a, 0xf0, 0x52, 0x4a, 0xf0, 0x52, 0x4a, 0xd0, 0xa4, 0x95, 0xe0,
  72         0xa4, 0x95, 0xe0, 0xa4, 0x95, 0xa1, 0x49, 0x2b, 0xc1, 0x49, 0x2b, 0xc1, 0x49, 0x2b, 0x42, 0x92,
  73         0x57, 0x82, 0x92, 0x57, 0x82, 0x92, 0x56, 0x85, 0x24, 0xaf, 0x05, 0x24, 0xaf, 0x05, 0x24, 0xad,
  74         0x0a, 0x49, 0x5e, 0x0a, 0x49, 0x5e, 0x0a, 0x49, 0x5a, 0x14, 0x92, 0xbc, 0x14, 0x92, 0xbc, 0x14,
  75         0x92, 0xb4, 0x29, 0x25, 0x78, 0x29, 0x25, 0x78, 0x00, 0x02, 0x0f, 0x02, 0x00, 0xac, 0x13, 0xfc,
  76         0xc0, 0x0a, 0x20, 0x10, 0x2b, 0x27, 0xf9, 0x80, 0xb0, 0x08, 0xaa, 0x3d, 0x60, 0x8c, 0x0b, 0x24,
  77         0xff, 0x30, 0x80, 0xc0, 0xaa, 0x13, 0xfc, 0xc2, 0x03, 0x05, 0x90, 0x9f, 0xe6, 0x10, 0x18, 0x2c,
  78         0x84, 0xff, 0x30, 0x81, 0x82, 0xc8, 0x4f, 0xf3, 0x08, 0x18, 0x2c, 0x84, 0xff, 0x31, 0x03, 0x05,
  79         0x90, 0x9f, 0xff, 0xd8, 0x40, 0x60, 0x59, 0x09, 0xfe, 0x61, 0x01, 0x81, 0x64, 0x27, 0xf9, 0x84,
  80         0x06, 0x0b, 0x21, 0x3f, 0xcc, 0x20, 0x30, 0x59, 0x09, 0xfe, 0x61, 0x03, 0x05, 0x90, 0x9f, 0xe6,
  81         0x10, 0x30, 0x59, 0x09, 0xfe, 0x62, 0x00, 0x00, 0x42, 0x15, 0x00, 0x10, 0x15, 0x01, 0xfe, 0x20,
  82         0x84, 0xd5, 0x01, 0x0a, 0x8f, 0xf1, 0x40, 0x33, 0x78, 0x17, 0xf9, 0xc2, 0x03, 0x83, 0x01, 0x78,
  83         0xe1, 0x01, 0xc1, 0x00, 0xbc, 0x70, 0x80, 0xe0, 0x80, 0x5e, 0x38, 0x40, 0x70, 0x40, 0x2f, 0x1c,
  84         0x20, 0x38, 0x20, 0x17, 0x8e, 0x10, 0x00, 0x00, 0x87, 0xd5, 0x08, 0x70, 0xef, 0x81, 0xa2, 0xd8,
  85         0xff, 0xff, 0xff, 0xfb, 0xd1, 0x2d, 0x4e, 0xa6, 0xce, 0x20, 0xa4, 0xef, 0x05, 0x78, 0x35, 0x3a,
  86         0x9b, 0x38, 0x82, 0x93, 0xbc, 0x15, 0xe0, 0xd4, 0xea, 0x66, 0x71, 0x05, 0x27, 0x78, 0x2b, 0xc1,
  87         0x29, 0xd4, 0xcc, 0xe2, 0x0a, 0x4e, 0xf0, 0x57, 0x82, 0x53, 0xa9, 0x99, 0xc4, 0x14, 0x9d, 0xe0,
  88         0xaf, 0x04, 0xa7, 0x53, 0x33, 0x88, 0x29, 0x3b, 0xc1, 0x5e, 0x09, 0x4e, 0xa6, 0x67, 0x10, 0x52,
  89         0x77, 0x82, 0xbc, 0x00, 0x18, 0x00
  90 };
  91
  92 static const uint8 cr_data[] =
  93 {
  94                                             0x1b, 0xfc, 0x11, 0xc1, 0x0f, 0x4a, 0xc1, 0x4f, 0x4a, 0xc1,
  95         0x4f, 0x4a, 0xa1, 0x4d, 0x95, 0x42, 0x9e, 0x95, 0x42, 0x9e, 0x95, 0x42, 0x9b, 0x2a, 0x85, 0x3d,
  96         0x2a, 0x85, 0x3d, 0x2a, 0x85, 0x36, 0x55, 0x0a, 0x7a, 0x55, 0x0a, 0x7a, 0x55, 0x0a, 0x6c, 0xaa,
  97         0x14, 0xf4, 0xaa, 0x14, 0xf4, 0xaa, 0x14, 0xd9, 0x54, 0x29, 0xe9, 0x54, 0x29, 0xe9, 0x54, 0x29,
  98         0xb2, 0xa8, 0x53, 0xd2, 0xa8, 0x53, 0xd2, 0xa8, 0x53, 0x65, 0x50, 0xa7, 0xa5, 0x50, 0xa7, 0xa5,
  99         0x50, 0xa6, 0xca, 0xa1, 0x4f, 0x4a, 0xa1, 0x4f, 0x4a, 0xa1, 0x4d, 0x95, 0x42, 0x9e, 0x95, 0x42,
 100         0x9e, 0x95, 0x42, 0x9b, 0x2a, 0x80, 0x00, 0x41, 0xe3, 0x80, 0x3f, 0xe2, 0x09, 0x9c, 0x00, 0x22,
 101         0x07, 0x03, 0xe1, 0x26, 0x70, 0x06, 0x07, 0x1f, 0x04, 0x67, 0x00, 0x61, 0xdf, 0x02, 0x67, 0x00,
 102         0x0c, 0x3b, 0xfe, 0x01, 0x33, 0x80, 0x06, 0x1d, 0xff, 0x00, 0x99, 0xc0, 0x03, 0x0e, 0xff, 0x80,
 103         0x4c, 0xe0, 0x01, 0x87, 0x7f, 0xc0, 0x26, 0x70, 0x00, 0xc3, 0xbf, 0xe0, 0x13, 0x38, 0x00, 0x61,
 104         0xdf, 0xf0, 0x09, 0x9c, 0x00, 0x30, 0xef, 0xf8, 0x04, 0xce, 0x00, 0x18, 0x77, 0xfc, 0x02, 0x67,
 105         0x00, 0x0c, 0x3b, 0xfe, 0x01, 0x33, 0x80, 0x06, 0x1d, 0xff, 0x00, 0x99, 0xc0, 0x03, 0x0e, 0xff,
 106         0x80, 0x4c, 0xe0, 0x01, 0x87, 0x7f, 0xc0, 0x26, 0x70, 0x00, 0x00, 0x08, 0x3c, 0x20, 0x1f, 0xf1,
 107         0x00, 0xf0, 0x05, 0x02, 0x93, 0x84, 0x3d, 0x20, 0xf0, 0x52, 0x81, 0xc7, 0xff, 0xff, 0xea, 0x54,
 108         0x01, 0x80, 0x05, 0xf5, 0x4a, 0x80, 0x30, 0x00, 0xb6, 0xa5, 0x40, 0x18, 0x00, 0x5f, 0x54, 0xa8,
 109         0x03, 0x00, 0x0b, 0xea, 0x95, 0x00, 0x60, 0x01, 0x6d, 0x4a, 0x80, 0x30, 0x00, 0x00, 0x22, 0x3f,
 110         0xba, 0x08, 0x10, 0x2b, 0x1f, 0xf2, 0x20, 0x3e, 0x49, 0x9c, 0x1f, 0x6e, 0x0f, 0x5a, 0x0f, 0xfb,
 111         0x18, 0x46, 0xae, 0x27, 0x9b, 0x83, 0xcb, 0x41, 0xf3, 0x18, 0x46, 0xae, 0x27, 0x9b, 0x83, 0xc5,
 112         0xa0, 0xf9, 0x8c, 0x22, 0xd7, 0x13, 0x8d, 0xc1, 0xe2, 0xd0, 0x7c, 0xc6, 0x11, 0x6b, 0x89, 0xc6,
 113         0xe0, 0xf1, 0x68, 0x3e, 0x63, 0x08, 0xb5, 0xc4, 0xe3, 0x70, 0x78, 0xb4, 0x1f, 0x31, 0x84, 0x5a,
 114         0xe2, 0x71, 0xb8, 0x3c, 0x5a, 0x0f, 0x98, 0xc2, 0x2d, 0x71, 0x30, 0x83, 0xc0, 0x00
 115 };
 116
 117 /* HL1, LH1, HH1, HL2, LH2, HH2, HL3, LH3, HH3, LL3 */
 118 static const unsigned int test_quantization_values[] =
 119 {
 120         6, 6, 6, 6, 7, 7, 8, 8, 8, 9
 121 };
 122
 123 static const uint8 rgb_scanline_data[] =
 124 {
 125         0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
 126         0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
 127         0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
 128         0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
 129         0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
 130         0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 131         0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 132         0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 133         0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 134         0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 135         0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 136         0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
 137         0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
 138         0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
 139         0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
 140         0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
 141
 142         0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
 143         0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
 144         0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
 145         0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
 146         0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00,
 147         0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 148         0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 149         0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 150         0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 151         0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 152         0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00,
 153         0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
 154         0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
 155         0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
 156         0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF,
 157         0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF
 158 };
 159
 160 static uint8* rgb_data;
 161
 162 int init_librfx_suite(void)
 163 {
 164         return 0;
 165 }
 166
 167 int clean_librfx_suite(void)
 168 {
 169         return 0;
 170 }
 171
 172 int add_librfx_suite(void)
 173 {
 174         add_test_suite(librfx);
 175
 176         add_test_function(bitstream);
 177         add_test_function(bitstream_enc);
 178         add_test_function(rlgr);
 179         add_test_function(differential);
 180         add_test_function(quantization);
 181         add_test_function(dwt);
 182         add_test_function(decode);
 183         add_test_function(encode);
 184         add_test_function(message);
 185
 186         return 0;
 187 }
 188
 189 void test_bitstream(void)
 190 {
 191         uint16 b;
 192         RFX_BITSTREAM* bs;
 193
 194         bs = xnew(RFX_BITSTREAM);
 195         rfx_bitstream_attach(bs, (uint8*) y_data, sizeof(y_data));
 196         while (!rfx_bitstream_eos(bs))
 197         {
 198                 rfx_bitstream_get_bits(bs, 3, b);
 199                 (void) b;
 200                 //printf("%u ", b);
 201         }
 202         xfree(bs);
 203
 204         //printf("\n");
 205 }
 206
 207 void test_bitstream_enc(void)
 208 {
 209         uint8 buffer[10];
 210         RFX_BITSTREAM* bs;
 211         int i;
 212
 213         bs = xnew(RFX_BITSTREAM);
 214         memset(buffer, 0, sizeof(buffer));
 215         rfx_bitstream_attach(bs, buffer, sizeof(buffer));
 216         for (i = 0; i < 16; i++)
 217         {
 218                 rfx_bitstream_put_bits(bs, i, 5);
 219         }
 220         /*for (i = 0; i < sizeof(buffer); i++)
 221         {
 222                 printf("%X ", buffer[i]);
 223         }*/
 224         xfree(bs);
 225
 226         //printf("\n");
 227 }
 228
 229 static sint16 buffer[4096];
 230
 231 void dump_buffer(sint16* buf, int n)
 232 {
 233         int i;
 234
 235         for (i = 0; i < n; i++)
 236         {
 237                 if (i % 16 == 0)
 238                         printf("\n%04d ", i);
 239                 printf("% 4d ", buf[i]);
 240         }
 241         printf("\n");
 242 }
 243
 244 void test_rlgr(void)
 245 {
 246         int n;
 247
 248         n = rfx_rlgr_decode(RLGR3, y_data, sizeof(y_data), buffer, sizeof(buffer) / sizeof(unsigned int));
 249
 250         //printf("RLGR decode %d bytes to %d values.", sizeof(y_data), n);
 251         //dump_buffer(buffer, n);
 252 }
 253
 254 void test_differential(void)
 255 {
 256         rfx_differential_decode(buffer + 4032, 64);
 257         //dump_buffer(buffer + 4032, 64);
 258 }
 259
 260 void test_quantization(void)
 261 {
 262         rfx_quantization_decode(buffer, test_quantization_values);
 263         //dump_buffer(buffer, 4096);
 264 }
 265
 266 void test_dwt(void)
 267 {
 268         RFX_CONTEXT* context;
 269
 270         context = rfx_context_new();
 271         rfx_dwt_2d_decode(buffer, context->priv->dwt_buffer);
 272         //dump_buffer(buffer, 4096);
 273         rfx_context_free(context);
 274 }
 275
 276 /* Dump a .ppm image. */
 277 static void dump_ppm_image(uint8* image_buf)
 278 {
 279         static int frame_id = 0;
 280         char buf[100];
 281         FILE* fp;
 282
 283         snprintf(buf, sizeof(buf), "/tmp/FreeRDP_Frame_%d.ppm", frame_id);
 284         fp = fopen(buf, "wb");
 285         fwrite("P6\n", 1, 3, fp);
 286         fwrite("# Created by FreeRDP\n", 1, 21, fp);
 287         fwrite("64 64\n", 1, 6, fp);
 288         fwrite("255\n", 1, 4, fp);
 289         fwrite(image_buf, 1, 4096 * 3, fp);
 290         fflush(fp);
 291         fclose(fp);
 292         frame_id++;
 293 }
 294
 295 void test_decode(void)
 296 {
 297         RFX_CONTEXT* context;
 298         uint8 decode_buffer[4096 * 3];
 299         STREAM* s;
 300
 301         s = stream_new(sizeof(y_data) + sizeof(cb_data) + sizeof(cr_data));
 302         stream_write(s, y_data, sizeof(y_data));
 303         stream_write(s, cb_data, sizeof(cb_data));
 304         stream_write(s, cr_data, sizeof(cr_data));
 305         stream_set_pos(s, 0);
 306
 307         context = rfx_context_new();
 308         context->mode = RLGR3;
 309         rfx_context_set_pixel_format(context, RFX_PIXEL_FORMAT_RGB);
 310         rfx_decode_rgb(context, s,
 311                 sizeof(y_data), test_quantization_values,
 312                 sizeof(cb_data), test_quantization_values,
 313                 sizeof(cr_data), test_quantization_values,
 314                 decode_buffer);
 315         rfx_context_free(context);
 316         stream_free(s);
 317
 318         dump_ppm_image(decode_buffer);
 319 }
 320
 321 void test_encode(void)
 322 {
 323         RFX_CONTEXT* context;
 324         STREAM* enc_stream;
 325         int y_size, cb_size, cr_size;
 326         int i;
 327         uint8 decode_buffer[4096 * 3];
 328
 329         rgb_data = (uint8 *) malloc(64 * 64 * 3);
 330         for (i = 0; i < 64; i++)
 331                 memcpy(rgb_data + i * 64 * 3, rgb_scanline_data, 64 * 3);
 332         //freerdp_hexdump(rgb_data, 64 * 64 * 3);
 333
 334         enc_stream = stream_new(65536);
 335         stream_clear(enc_stream);
 336
 337         context = rfx_context_new();
 338         context->mode = RLGR3;
 339         rfx_context_set_pixel_format(context, RFX_PIXEL_FORMAT_RGB);
 340
 341         rfx_encode_rgb(context, rgb_data, 64, 64, 64 * 3,
 342                 test_quantization_values, test_quantization_values, test_quantization_values,
 343                 enc_stream, &y_size, &cb_size, &cr_size);
 344         //dump_buffer(context->priv->cb_g_buffer, 4096);
 345
 346         /*printf("*** Y ***\n");
 347         freerdp_hexdump(stream_get_head(enc_stream), y_size);
 348         printf("*** Cb ***\n");
 349         freerdp_hexdump(stream_get_head(enc_stream) + y_size, cb_size);
 350         printf("*** Cr ***\n");
 351         freerdp_hexdump(stream_get_head(enc_stream) + y_size + cb_size, cr_size);*/
 352
 353         stream_set_pos(enc_stream, 0);
 354         rfx_decode_rgb(context, enc_stream,
 355                 y_size, test_quantization_values,
 356                 cb_size, test_quantization_values,
 357                 cr_size, test_quantization_values,
 358                 decode_buffer);
 359         dump_ppm_image(decode_buffer);
 360
 361         rfx_context_free(context);
 362         stream_free(enc_stream);
 363         free(rgb_data);
 364 }
 365
 366 void test_message(void)
 367 {
 368         RFX_CONTEXT* context;
 369         STREAM* s;
 370         int i, j;
 371         RFX_RECT rect = {0, 0, 100, 80};
 372         RFX_MESSAGE * message;
 373
 374         rgb_data = (uint8 *) malloc(100 * 80 * 3);
 375         for (i = 0; i < 80; i++)
 376                 memcpy(rgb_data + i * 100 * 3, rgb_scanline_data, 100 * 3);
 377
 378         s = stream_new(65536);
 379         stream_clear(s);
 380
 381         context = rfx_context_new();
 382         context->mode = RLGR3;
 383         context->width = 800;
 384         context->height = 600;
 385         rfx_context_set_pixel_format(context, RFX_PIXEL_FORMAT_RGB);
 386
 387         for (i = 0; i < 1000; i++)
 388         {
 389                 s = stream_new(65536);
 390                 stream_clear(s);
 391                 rfx_compose_message(context, s,
 392                         &rect, 1, rgb_data, 100, 80, 100 * 3);
 393                 stream_seal(s);
 394                 /*hexdump(buffer, size);*/
 395                 stream_set_pos(s, 0);
 396                 message = rfx_process_message(context, s->p, s->size);
 397                 if (i == 0)
 398                 {
 399                         for (j = 0; j < message->num_tiles; j++)
 400                         {
 401                                 dump_ppm_image(message->tiles[j]->data);
 402                         }
 403                 }
 404                 rfx_message_free(context, message);
 405                 stream_free(s);
 406         }
 407
 408         rfx_context_free(context);
 409         free(rgb_data);
 410 }