static void audin_server_send_formats(audin_server* audin, STREAM* s)
{
int i;
UINT32 nAvgBytesPerSec;
stream_set_pos(s, 0);
stream_write_BYTE(s, MSG_SNDIN_FORMATS);
stream_write_UINT32(s, audin->context.num_server_formats); /* NumFormats (4 bytes) */
stream_write_UINT32(s, 0); /* cbSizeFormatsPacket (4 bytes), client-to-server only */
for (i = 0; i < audin->context.num_server_formats; i++)
{
nAvgBytesPerSec = audin->context.server_formats[i].nSamplesPerSec *
audin->context.server_formats[i].nChannels *
audin->context.server_formats[i].wBitsPerSample / 8;
stream_check_size(s, 18);
stream_write_UINT16(s, audin->context.server_formats[i].wFormatTag);
stream_write_UINT16(s, audin->context.server_formats[i].nChannels);
stream_write_UINT32(s, audin->context.server_formats[i].nSamplesPerSec);
stream_write_UINT32(s, nAvgBytesPerSec);
stream_write_UINT16(s, audin->context.server_formats[i].nBlockAlign);
stream_write_UINT16(s, audin->context.server_formats[i].wBitsPerSample);
stream_write_UINT16(s, audin->context.server_formats[i].cbSize);
if (audin->context.server_formats[i].cbSize)
{
stream_check_size(s, audin->context.server_formats[i].cbSize);
stream_write(s, audin->context.server_formats[i].data,
audin->context.server_formats[i].cbSize);
}
}
WTSVirtualChannelWrite(audin->audin_channel, stream_get_head(s), stream_get_length(s), NULL);
}
BOOL drive_file_query_information(DRIVE_FILE* file, UINT32 FsInformationClass, STREAM* output)
{
struct STAT st;
if (STAT(file->fullpath, &st) != 0)
{
stream_write_UINT32(output, 0); /* Length */
return FALSE;
}
switch (FsInformationClass)
{
case FileBasicInformation:
/* http://msdn.microsoft.com/en-us/library/cc232094.aspx */
stream_write_UINT32(output, 36); /* Length */
stream_check_size(output, 36);
stream_write_UINT64(output, FILE_TIME_SYSTEM_TO_RDP(st.st_mtime)); /* CreationTime */
stream_write_UINT64(output, FILE_TIME_SYSTEM_TO_RDP(st.st_atime)); /* LastAccessTime */
stream_write_UINT64(output, FILE_TIME_SYSTEM_TO_RDP(st.st_mtime)); /* LastWriteTime */
stream_write_UINT64(output, FILE_TIME_SYSTEM_TO_RDP(st.st_ctime)); /* ChangeTime */
stream_write_UINT32(output, FILE_ATTR_SYSTEM_TO_RDP(file, st)); /* FileAttributes */
/* Reserved(4), MUST NOT be added! */
break;
case FileStandardInformation:
/* http://msdn.microsoft.com/en-us/library/cc232088.aspx */
stream_write_UINT32(output, 22); /* Length */
stream_check_size(output, 22);
stream_write_UINT64(output, st.st_size); /* AllocationSize */
stream_write_UINT64(output, st.st_size); /* EndOfFile */
stream_write_UINT32(output, st.st_nlink); /* NumberOfLinks */
stream_write_BYTE(output, file->delete_pending ? 1 : 0); /* DeletePending */
stream_write_BYTE(output, file->is_dir ? 1 : 0); /* Directory */
/* Reserved(2), MUST NOT be added! */
break;
case FileAttributeTagInformation:
/* http://msdn.microsoft.com/en-us/library/cc232093.aspx */
stream_write_UINT32(output, 8); /* Length */
stream_check_size(output, 8);
stream_write_UINT32(output, FILE_ATTR_SYSTEM_TO_RDP(file, st)); /* FileAttributes */
stream_write_UINT32(output, 0); /* ReparseTag */
break;
default:
stream_write_UINT32(output, 0); /* Length */
DEBUG_WARN("invalid FsInformationClass %d", FsInformationClass);
return FALSE;
}
return TRUE;
}
void test_stream(void)
{
STREAM * stream;
int pos;
uint32 n;
uint64 n64;
stream = stream_new(1);
pos = stream_get_pos(stream);
stream_write_uint8(stream, 0xFE);
stream_check_size(stream, 14);
stream_write_uint16(stream, 0x0102);
stream_write_uint32(stream, 0x03040506);
stream_write_uint64(stream, 0x0708091011121314LL);
/* freerdp_hexdump(stream->buffer, 15); */
stream_set_pos(stream, pos);
stream_seek(stream, 3);
stream_read_uint32(stream, n);
stream_read_uint64(stream, n64);
CU_ASSERT(n == 0x03040506);
CU_ASSERT(n64 == 0x0708091011121314LL);
stream_free(stream);
}
STREAM* transport_recv_stream_init(rdpTransport* transport, int size)
{
STREAM* s = transport->ReceiveStream;
stream_check_size(s, size);
stream_set_pos(s, 0);
return s;
}
STREAM* transport_send_stream_init(rdpTransport* transport, int size)
{
STREAM* s = transport->send_stream;
stream_check_size(s, size);
stream_set_pos(s, 0);
return s;
}
static void WTSProcessChannelData(rdpPeerChannel* channel, int channelId, BYTE* data, int size, int flags, int total_size)
{
if (flags & CHANNEL_FLAG_FIRST)
{
stream_set_pos(channel->receive_data, 0);
}
stream_check_size(channel->receive_data, size);
stream_write(channel->receive_data, data, size);
if (flags & CHANNEL_FLAG_LAST)
{
if (stream_get_length(channel->receive_data) != total_size)
{
fprintf(stderr, "WTSProcessChannelData: read error\n");
}
if (channel == channel->vcm->drdynvc_channel)
{
wts_read_drdynvc_pdu(channel);
}
else
{
wts_queue_receive_data(channel, stream_get_head(channel->receive_data), stream_get_length(channel->receive_data));
}
stream_set_pos(channel->receive_data, 0);
}
}
static void rfx_compose_message_region(RFX_CONTEXT* context, STREAM* s,
const RFX_RECT* rects, int num_rects)
{
int size;
int i;
size = 15 + num_rects * 8;
stream_check_size(s, size);
stream_write_UINT16(s, WBT_REGION); /* CodecChannelT.blockType */
stream_write_UINT32(s, size); /* set CodecChannelT.blockLen later */
stream_write_BYTE(s, 1); /* CodecChannelT.codecId */
stream_write_BYTE(s, 0); /* CodecChannelT.channelId */
stream_write_BYTE(s, 1); /* regionFlags */
stream_write_UINT16(s, num_rects); /* numRects */
for (i = 0; i < num_rects; i++)
{
stream_write_UINT16(s, rects[i].x);
stream_write_UINT16(s, rects[i].y);
stream_write_UINT16(s, rects[i].width);
stream_write_UINT16(s, rects[i].height);
}
stream_write_UINT16(s, CBT_REGION); /* regionType */
stream_write_UINT16(s, 1); /* numTilesets */
}
static void svc_plugin_process_received(rdpSvcPlugin* plugin, void* pData, uint32 dataLength,
uint32 totalLength, uint32 dataFlags)
{
STREAM* data_in;
if (dataFlags & CHANNEL_FLAG_FIRST)
{
if (plugin->priv->data_in != NULL)
stream_free(plugin->priv->data_in);
plugin->priv->data_in = stream_new(totalLength);
}
data_in = plugin->priv->data_in;
stream_check_size(data_in, dataLength);
stream_write(data_in, pData, dataLength);
if (dataFlags & CHANNEL_FLAG_LAST)
{
if (stream_get_size(data_in) != stream_get_length(data_in))
{
printf("svc_plugin_process_received: read error\n");
}
/* the stream ownership is passed to the callback who is responsible for freeing it. */
plugin->priv->data_in = NULL;
stream_set_pos(data_in, 0);
plugin->receive_callback(plugin, data_in);
}
}
void rail_write_unicode_string_value(wStream* s, RAIL_UNICODE_STRING* unicode_string)
{
if (unicode_string->length > 0)
{
stream_check_size(s, unicode_string->length);
stream_write(s, unicode_string->string, unicode_string->length); /* string */
}
}
BOOL freerdp_channel_send(rdpRdp* rdp, UINT16 channel_id, BYTE* data, int size)
{
STREAM* s;
UINT32 flags;
int i, left;
int chunk_size;
rdpChannel* channel = NULL;
for (i = 0; i < rdp->settings->ChannelCount; i++)
{
if (rdp->settings->ChannelDefArray[i].ChannelId == channel_id)
{
channel = &rdp->settings->ChannelDefArray[i];
break;
}
}
if (channel == NULL)
{
printf("freerdp_channel_send: unknown channel_id %d\n", channel_id);
return FALSE;
}
flags = CHANNEL_FLAG_FIRST;
left = size;
while (left > 0)
{
s = rdp_send_stream_init(rdp);
if (left > (int) rdp->settings->VirtualChannelChunkSize)
{
chunk_size = rdp->settings->VirtualChannelChunkSize;
}
else
{
chunk_size = left;
flags |= CHANNEL_FLAG_LAST;
}
if ((channel->options & CHANNEL_OPTION_SHOW_PROTOCOL))
{
flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
}
stream_write_UINT32(s, size);
stream_write_UINT32(s, flags);
stream_check_size(s, chunk_size);
stream_write(s, data, chunk_size);
rdp_send(rdp, s, channel_id);
data += chunk_size;
left -= chunk_size;
flags = 0;
}
return TRUE;
}
void update_write_surfcmd_frame_marker(STREAM* s, UINT16 frameAction, UINT32 frameId)
{
stream_check_size(s, SURFCMD_FRAME_MARKER_LENGTH);
stream_write_UINT16(s, CMDTYPE_FRAME_MARKER);
stream_write_UINT16(s, frameAction);
stream_write_UINT32(s, frameId);
}
boolean vchan_send(rdpVchan* vchan, uint16 channel_id, uint8* data, int size)
{
STREAM* s;
uint32 flags;
rdpChan* channel = NULL;
int i;
int chunk_size;
int left;
for (i = 0; i < vchan->instance->settings->num_channels; i++)
{
if (vchan->instance->settings->channels[i].chan_id == channel_id)
{
channel = &vchan->instance->settings->channels[i];
break;
}
}
if (channel == NULL)
{
printf("vchan_send: unknown channel_id %d\n", channel_id);
return False;
}
flags = CHANNEL_FLAG_FIRST;
left = size;
while (left > 0)
{
s = rdp_send_stream_init(vchan->instance->rdp);
if (left > (int) vchan->instance->settings->vc_chunk_size)
{
chunk_size = vchan->instance->settings->vc_chunk_size;
}
else
{
chunk_size = left;
flags |= CHANNEL_FLAG_LAST;
}
if ((channel->options & CHANNEL_OPTION_SHOW_PROTOCOL))
{
flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
}
stream_write_uint32(s, size);
stream_write_uint32(s, flags);
stream_check_size(s, chunk_size);
stream_write(s, data, chunk_size);
rdp_send(vchan->instance->rdp, s, channel_id);
data += chunk_size;
left -= chunk_size;
flags = 0;
}
return True;
}
boolean freerdp_channel_send(rdpRdp* rdp, uint16 channel_id, uint8* data, int size)
{
STREAM* s;
uint32 flags;
int i, left;
int chunk_size;
rdpChannel* channel = NULL;
for (i = 0; i < rdp->settings->num_channels; i++)
{
if (rdp->settings->channels[i].channel_id == channel_id)
{
channel = &rdp->settings->channels[i];
break;
}
}
if (channel == NULL)
{
printf("freerdp_channel_send: unknown channel_id %d\n", channel_id);
return false;
}
flags = CHANNEL_FLAG_FIRST;
left = size;
while (left > 0)
{
s = rdp_send_stream_init(rdp);
if (left > (int) rdp->settings->vc_chunk_size)
{
chunk_size = rdp->settings->vc_chunk_size;
}
else
{
chunk_size = left;
flags |= CHANNEL_FLAG_LAST;
}
if ((channel->options & CHANNEL_OPTION_SHOW_PROTOCOL))
{
flags |= CHANNEL_FLAG_SHOW_PROTOCOL;
}
stream_write_uint32(s, size);
stream_write_uint32(s, flags);
stream_check_size(s, chunk_size);
stream_write(s, data, chunk_size);
rdp_send(rdp, s, channel_id);
data += chunk_size;
left -= chunk_size;
flags = 0;
}
return true;
}
static void rfx_compose_message_frame_end(RFX_CONTEXT* context, STREAM* s)
{
stream_check_size(s, 8);
stream_write_UINT16(s, WBT_FRAME_END); /* CodecChannelT.blockType */
stream_write_UINT32(s, 8); /* CodecChannelT.blockLen */
stream_write_BYTE(s, 1); /* CodecChannelT.codecId */
stream_write_BYTE(s, 0); /* CodecChannelT.channelId */
}
static void wts_write_drdynvc_create_request(wStream *s, UINT32 ChannelId, const char *ChannelName)
{
UINT32 len;
wts_write_drdynvc_header(s, CREATE_REQUEST_PDU, ChannelId);
len = strlen(ChannelName) + 1;
stream_check_size(s, (int) len);
stream_write(s, ChannelName, len);
}
static void drive_process_irp_read(DRIVE_DEVICE* disk, IRP* irp)
{
DRIVE_FILE* file;
UINT32 Length;
UINT64 Offset;
BYTE* buffer = NULL;
stream_read_UINT32(irp->input, Length);
stream_read_UINT64(irp->input, Offset);
file = drive_get_file_by_id(disk, irp->FileId);
if (file == NULL)
{
irp->IoStatus = STATUS_UNSUCCESSFUL;
Length = 0;
DEBUG_WARN("FileId %d not valid.", irp->FileId);
}
else if (!drive_file_seek(file, Offset))
{
irp->IoStatus = STATUS_UNSUCCESSFUL;
Length = 0;
DEBUG_WARN("seek %s(%d) failed.", file->fullpath, file->id);
}
else
{
buffer = (BYTE*) malloc(Length);
if (!drive_file_read(file, buffer, &Length))
{
irp->IoStatus = STATUS_UNSUCCESSFUL;
free(buffer);
buffer = NULL;
Length = 0;
DEBUG_WARN("read %s(%d) failed.", file->fullpath, file->id);
}
else
{
DEBUG_SVC("read %llu-%llu from %s(%d).", Offset, Offset + Length, file->fullpath, file->id);
}
}
stream_write_UINT32(irp->output, Length);
if (Length > 0)
{
stream_check_size(irp->output, (int) Length);
stream_write(irp->output, buffer, Length);
}
free(buffer);
irp->Complete(irp);
}
static void update_send_surface_command(rdpContext* context, STREAM* s)
{
STREAM* update;
rdpRdp* rdp = context->rdp;
update = fastpath_update_pdu_init(rdp->fastpath);
stream_check_size(update, stream_get_length(s));
stream_write(update, stream_get_head(s), stream_get_length(s));
fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, update);
}
static void* tf_debug_channel_thread_func(void* arg)
{
void* fd;
STREAM* s;
void* buffer;
UINT32 bytes_returned = 0;
testPeerContext* context = (testPeerContext*) arg;
freerdp_thread* thread = context->debug_channel_thread;
if (WTSVirtualChannelQuery(context->debug_channel, WTSVirtualFileHandle, &buffer, &bytes_returned) == TRUE)
{
fd = *((void**) buffer);
WTSFreeMemory(buffer);
thread->signals[thread->num_signals++] = CreateFileDescriptorEvent(NULL, TRUE, FALSE, ((int) (long) fd));
}
s = stream_new(4096);
WTSVirtualChannelWrite(context->debug_channel, (BYTE*) "test1", 5, NULL);
while (1)
{
freerdp_thread_wait(thread);
if (freerdp_thread_is_stopped(thread))
break;
stream_set_pos(s, 0);
if (WTSVirtualChannelRead(context->debug_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == FALSE)
{
if (bytes_returned == 0)
break;
stream_check_size(s, bytes_returned);
if (WTSVirtualChannelRead(context->debug_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == FALSE)
{
/* should not happen */
break;
}
}
stream_set_pos(s, bytes_returned);
printf("got %d bytes\n", bytes_returned);
}
stream_free(s);
freerdp_thread_quit(thread);
return 0;
}
void rfx_compose_message_header(RFX_CONTEXT* context, STREAM* s)
{
stream_check_size(s, 12 + 10 + 12 + 13);
rfx_compose_message_sync(context, s);
rfx_compose_message_context(context, s);
rfx_compose_message_codec_versions(context, s);
rfx_compose_message_channels(context, s);
context->header_processed = TRUE;
}
static void update_send_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surface_bits_command)
{
STREAM* s;
rdpRdp* rdp = context->rdp;
s = fastpath_update_pdu_init(rdp->fastpath);
stream_check_size(s, SURFCMD_SURFACE_BITS_HEADER_LENGTH + (int) surface_bits_command->bitmapDataLength);
update_write_surfcmd_surface_bits_header(s, surface_bits_command);
stream_write(s, surface_bits_command->bitmapData, surface_bits_command->bitmapDataLength);
fastpath_send_update_pdu(rdp->fastpath, FASTPATH_UPDATETYPE_SURFCMDS, s);
}
static void serial_process_irp_read(SERIAL_DEVICE* serial, IRP* irp)
{
SERIAL_TTY* tty;
UINT32 Length;
UINT64 Offset;
BYTE* buffer = NULL;
stream_read_UINT32(irp->input, Length);
stream_read_UINT64(irp->input, Offset);
DEBUG_SVC("length %u offset %llu", Length, Offset);
tty = serial->tty;
if (tty == NULL)
{
irp->IoStatus = STATUS_UNSUCCESSFUL;
Length = 0;
DEBUG_WARN("tty not valid.");
}
else
{
buffer = (BYTE*) malloc(Length);
if (!serial_tty_read(tty, buffer, &Length))
{
irp->IoStatus = STATUS_UNSUCCESSFUL;
free(buffer);
buffer = NULL;
Length = 0;
DEBUG_WARN("read %s(%d) failed.", serial->path, tty->id);
}
else
{
DEBUG_SVC("read %llu-%llu from %d", Offset, Offset + Length, tty->id);
}
}
stream_write_UINT32(irp->output, Length);
if (Length > 0)
{
stream_check_size(irp->output, Length);
stream_write(irp->output, buffer, Length);
}
free(buffer);
irp->Complete(irp);
}
static void rfx_compose_message_frame_begin(RFX_CONTEXT* context, STREAM* s)
{
stream_check_size(s, 14);
stream_write_UINT16(s, WBT_FRAME_BEGIN); /* CodecChannelT.blockType */
stream_write_UINT32(s, 14); /* CodecChannelT.blockLen */
stream_write_BYTE(s, 1); /* CodecChannelT.codecId */
stream_write_BYTE(s, 0); /* CodecChannelT.channelId */
stream_write_UINT32(s, context->frame_idx); /* frameIdx */
stream_write_UINT16(s, 1); /* numRegions */
context->frame_idx++;
}
static int transport_read_nonblocking(rdpTransport* transport)
{
int status;
stream_check_size(transport->recv_buffer, 4096);
status = transport_read(transport, transport->recv_buffer);
if (status <= 0)
return status;
stream_seek(transport->recv_buffer, status);
return status;
}
static void* tf_debug_channel_thread_func(void* arg)
{
void* fd;
STREAM* s;
void* buffer;
uint32 bytes_returned = 0;
testPeerContext* context = (testPeerContext*) arg;
freerdp_thread* thread = context->debug_channel_thread;
if (WTSVirtualChannelQuery(context->debug_channel, WTSVirtualFileHandle, &buffer, &bytes_returned) == true)
{
fd = *((void**)buffer);
WTSFreeMemory(buffer);
thread->signals[thread->num_signals++] = wait_obj_new_with_fd(fd);
}
s = stream_new(4096);
WTSVirtualChannelWrite(context->debug_channel, (uint8*) "test1", 5, NULL);
while (1)
{
freerdp_thread_wait(thread);
if (freerdp_thread_is_stopped(thread))
break;
stream_set_pos(s, 0);
if (WTSVirtualChannelRead(context->debug_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == false)
{
if (bytes_returned == 0)
break;
stream_check_size(s, bytes_returned);
if (WTSVirtualChannelRead(context->debug_channel, 0, stream_get_head(s),
stream_get_size(s), &bytes_returned) == false)
{
/* should not happen */
break;
}
}
stream_set_pos(s, bytes_returned);
printf("got %d bytes\n", bytes_returned);
}
stream_free(s);
freerdp_thread_quit(thread);
return 0;
}
static int transport_read_nonblocking(rdpTransport* transport)
{
int status;
stream_check_size(transport->ReceiveBuffer, 32 * 1024);
status = transport_read(transport, transport->ReceiveBuffer);
if (status <= 0)
return status;
stream_seek(transport->ReceiveBuffer, status);
return status;
}
static void wts_read_drdynvc_data_first(rdpPeerChannel* channel, STREAM* s, int cbLen, uint32 length)
{
int value;
value = wts_read_variable_uint(s, cbLen, &channel->dvc_total_length);
if (value == 0)
return;
length -= value;
if (length > channel->dvc_total_length)
return;
stream_set_pos(channel->receive_data, 0);
stream_check_size(channel->receive_data, (int) channel->dvc_total_length);
stream_write(channel->receive_data, stream_get_tail(s), length);
}
void update_write_surfcmd_surface_bits_header(STREAM* s, SURFACE_BITS_COMMAND* cmd)
{
stream_check_size(s, SURFCMD_SURFACE_BITS_HEADER_LENGTH);
stream_write_UINT16(s, CMDTYPE_STREAM_SURFACE_BITS);
stream_write_UINT16(s, cmd->destLeft);
stream_write_UINT16(s, cmd->destTop);
stream_write_UINT16(s, cmd->destRight);
stream_write_UINT16(s, cmd->destBottom);
stream_write_BYTE(s, cmd->bpp);
stream_write_UINT16(s, 0); /* reserved1, reserved2 */
stream_write_BYTE(s, cmd->codecID);
stream_write_UINT16(s, cmd->width);
stream_write_UINT16(s, cmd->height);
stream_write_UINT32(s, cmd->bitmapDataLength);
}
static void svc_plugin_process_received(rdpSvcPlugin* plugin, void* pData, uint32 dataLength,
uint32 totalLength, uint32 dataFlags)
{
STREAM* data_in;
svc_data_in_item* item;
if ( (dataFlags & CHANNEL_FLAG_SUSPEND) || (dataFlags & CHANNEL_FLAG_RESUME))
{
/* According to MS-RDPBCGR 2.2.6.1, "All virtual channel traffic MUST be suspended.
This flag is only valid in server-to-client virtual channel traffic. It MUST be
ignored in client-to-server data." Thus it would be best practice to cease data
transmission. However, simply returing here avoids a crash. */
return;
}
if (dataFlags & CHANNEL_FLAG_FIRST)
{
if (plugin->priv->data_in != NULL)
stream_free(plugin->priv->data_in);
plugin->priv->data_in = stream_new(totalLength);
}
data_in = plugin->priv->data_in;
stream_check_size(data_in, (int) dataLength);
stream_write(data_in, pData, dataLength);
if (dataFlags & CHANNEL_FLAG_LAST)
{
if (stream_get_size(data_in) != stream_get_length(data_in))
{
printf("svc_plugin_process_received: read error\n");
}
plugin->priv->data_in = NULL;
stream_set_pos(data_in, 0);
item = xnew(svc_data_in_item);
item->data_in = data_in;
freerdp_thread_lock(plugin->priv->thread);
list_enqueue(plugin->priv->data_in_list, item);
freerdp_thread_unlock(plugin->priv->thread);
freerdp_thread_signal(plugin->priv->thread);
}
}
static void update_write_pointer_color(STREAM* s, POINTER_COLOR_UPDATE* pointer_color)
{
stream_check_size(s, 15 + (int) pointer_color->lengthAndMask + (int) pointer_color->lengthXorMask);
stream_write_UINT16(s, pointer_color->cacheIndex);
stream_write_UINT16(s, pointer_color->xPos);
stream_write_UINT16(s, pointer_color->yPos);
stream_write_UINT16(s, pointer_color->width);
stream_write_UINT16(s, pointer_color->height);
stream_write_UINT16(s, pointer_color->lengthAndMask);
stream_write_UINT16(s, pointer_color->lengthXorMask);
if (pointer_color->lengthXorMask > 0)
stream_write(s, pointer_color->xorMaskData, pointer_color->lengthXorMask);
if (pointer_color->lengthAndMask > 0)
stream_write(s, pointer_color->andMaskData, pointer_color->lengthAndMask);
stream_write_BYTE(s, 0); /* pad (1 byte) */
}
static void rfx_compose_message_tile(RFX_CONTEXT* context, STREAM* s,
BYTE* tile_data, int tile_width, int tile_height, int rowstride,
const UINT32* quantVals, int quantIdxY, int quantIdxCb, int quantIdxCr,
int xIdx, int yIdx)
{
int YLen = 0;
int CbLen = 0;
int CrLen = 0;
int start_pos, end_pos;
stream_check_size(s, 19);
start_pos = stream_get_pos(s);
stream_write_UINT16(s, CBT_TILE); /* BlockT.blockType */
stream_seek_UINT32(s); /* set BlockT.blockLen later */
stream_write_BYTE(s, quantIdxY);
stream_write_BYTE(s, quantIdxCb);
stream_write_BYTE(s, quantIdxCr);
stream_write_UINT16(s, xIdx);
stream_write_UINT16(s, yIdx);
stream_seek(s, 6); /* YLen, CbLen, CrLen */
rfx_encode_rgb(context, tile_data, tile_width, tile_height, rowstride,
quantVals + quantIdxY * 10, quantVals + quantIdxCb * 10, quantVals + quantIdxCr * 10,
s, &YLen, &CbLen, &CrLen);
DEBUG_RFX("xIdx=%d yIdx=%d width=%d height=%d YLen=%d CbLen=%d CrLen=%d",
xIdx, yIdx, tile_width, tile_height, YLen, CbLen, CrLen);
end_pos = stream_get_pos(s);
stream_set_pos(s, start_pos + 2);
stream_write_UINT32(s, 19 + YLen + CbLen + CrLen); /* BlockT.blockLen */
stream_set_pos(s, start_pos + 13);
stream_write_UINT16(s, YLen);
stream_write_UINT16(s, CbLen);
stream_write_UINT16(s, CrLen);
stream_set_pos(s, end_pos);
}