Commit 5ef114ba authored by Alexander Larsson's avatar Alexander Larsson

Switch from sending png frames to our own encoding

This is based on the rolling hashes code from
http://cgit.freedesktop.org/~krh/weston/log/?h=remote

It works by incrementally calculating hashes for every 32x32 block
in each frame sent, and then refering back to such blocks when
encoding the next frame. This means we detect when a block matches
an existing block in the previous frame in a different position.
This is great for detecting scrolling, which we need now that
the gdk level scrolling is neutered.
parent bbfe7e0e
......@@ -83,6 +83,8 @@ broadwayd_SOURCES = \
broadwayd.c \
broadway-server.h \
broadway-server.c \
broadway-buffer.c \
broadway-buffer.h \
broadway-output.h \
broadway-output.c
......
#include "config.h"
#include "broadway-buffer.h"
#include <string.h>
/* This code is based on some code from weston with this license:
*
* Copyright © 2012 Intel Corporation
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of the copyright holders not be used in
* advertising or publicity pertaining to distribution of the software
* without specific, written prior permission. The copyright holders make
* no representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
struct entry {
int count;
int matches;
guint32 hash;
int x, y;
int index;
};
struct _BroadwayBuffer {
guint8 *data;
struct entry *table;
int width, height, stride;
int encoded;
int block_stride, length, block_count, shift;
int stats[5];
int clashes;
};
static const guint32 prime = 0x1f821e2d;
static const guint32 end_prime = 0xf907ec81; /* prime^block_size */
#if 0
static const guint32 vprime = 0x0137b89d;
static const guint32 end_vprime = 0xaea9a281; /* vprime^block_size */
#else
static const guint32 vprime = 0xf907ec81;
static const guint32 end_vprime = 0xcdb99001; /* vprime^block_size */
#endif
static const guint32 step = 0x0ac93019;
static const int block_size = 32, block_mask = 31;
static gboolean
verify_block_match (BroadwayBuffer *buffer, int x, int y,
BroadwayBuffer *prev, struct entry *entry)
{
int i;
void *old, *match;
int w1, w2, h1, h2;
w1 = block_size;
if (x + block_size > buffer->width)
w1 = buffer->width - x;
h1 = block_size;
if (y + block_size > buffer->height)
h1 = buffer->height - y;
w2 = block_size;
if (entry->x + block_size > prev->width)
w2 = prev->width - entry->x;
h2 = block_size;
if (entry->y + block_size > prev->height)
h2 = prev->height - entry->y;
if (w1 != w2 || h1 != h2)
return FALSE;
for (i = 0; i < h1; i++)
{
match = buffer->data + (y + i) * buffer->stride + x * 4;
old = prev->data + (entry->y + i) * prev->stride + entry->x * 4;
if (memcmp (match, old, w1 * 4) != 0)
{
buffer->clashes++;
return FALSE;
}
}
return TRUE;
}
static void
insert_block (BroadwayBuffer *buffer, guint32 h, int x, int y)
{
struct entry *entry;
int i;
guint32 collision = 0;
entry = &buffer->table[h >> buffer->shift];
for (i = step; entry->count > 0 && entry->hash != h; i += step)
{
entry = &buffer->table[(h + i) >> buffer->shift];
collision++;
}
entry->hash = h;
entry->count++;
entry->x = x;
entry->y = y;
entry->index = (buffer->block_stride * y + x) / block_size;
if (collision > G_N_ELEMENTS (buffer->stats) - 1)
collision = G_N_ELEMENTS (buffer->stats) - 1;
buffer->stats[collision]++;
}
static struct entry *
lookup_block (BroadwayBuffer *prev, guint32 h)
{
guint32 i;
struct entry *entry;
int shift = prev->shift;
for (i = h;
entry = &prev->table[i >> shift], entry->count > 0;
i += step)
{
if (entry->hash == h)
return entry;
}
return NULL;
}
struct encoder {
guint32 color;
guint32 color_run;
guint32 delta;
guint32 delta_run;
GString *dest;
int bytes;
};
/* Encoding:
*
* - all 1 pixel colors are encoded literally
*
* - We don't need to support colors with alpha 0 and non-zero
* color components, as they mean the same on the canvas anyway.
* So we use these as special codes:
*
* - 0x00 00 00 00 : one alpha 0 pixel
* - 0xaa rr gg bb : one color pixel, alpha > 0
* - 0x00 1x xx xx : delta 0 run, x is length, (20 bits)
* - 0x00 2x xx xx 0x xxxx yyyy: block ref, block number x (20 bits) at x, y
* - 0x00 3x xx xx 0xaarrggbb : solid color run, length x
* - 0x00 4x xx xx 0xaarrggbb : delta run, length x
*
*/
static void
emit (struct encoder *encoder, guint32 symbol)
{
g_string_append_len (encoder->dest, (char *)&symbol, sizeof (guint32));
encoder->bytes += sizeof (guint32);
}
static void
encode_run (struct encoder *encoder)
{
if (encoder->color_run == 0 && encoder->delta_run == 0)
return;
if (encoder->color_run >= encoder->delta_run)
{
if (encoder->color_run == 1)
emit (encoder, encoder->color);
else
{
emit (encoder, 0x00300000 | encoder->color_run);
emit (encoder, encoder->color);
}
}
else
{
if (encoder->delta == 0)
emit(encoder, 0x00100000 | encoder->delta_run);
else
{
emit(encoder, 0x00400000 | encoder->delta_run);
emit(encoder, encoder->delta);
}
}
}
static void
encode_pixel (struct encoder *encoder, guint32 color, guint32 prev_color)
{
guint32 delta = 0;
guint32 a, r, g, b;
if (color == prev_color)
delta = 0;
else if (prev_color == 0)
delta = color;
else
{
a = ((color & 0xff000000) - (prev_color & 0xff000000)) & 0xff000000;
r = ((color & 0x00ff0000) - (prev_color & 0x00ff0000)) & 0x00ff0000;
g = ((color & 0x0000ff00) - (prev_color & 0x0000ff00)) & 0x0000ff00;
b = ((color & 0x000000ff) - (prev_color & 0x000000ff)) & 0x000000ff;
delta = a | r | g | b;
}
if ((encoder->color != color &&
encoder->color_run > encoder->delta_run) ||
(encoder->delta != delta &&
encoder->delta_run > encoder->color_run) ||
(encoder->delta != delta && encoder->color != color))
{
encode_run (encoder);
encoder->color_run = 1;
encoder->color = color;
encoder->delta_run = 1;
encoder->delta = delta;
return;
}
if (encoder->color == color)
encoder->color_run++;
else
{
encoder->color_run = 1;
encoder->color = color;
}
if (encoder->delta == delta)
encoder->delta_run++;
else
{
encoder->delta_run = 1;
encoder->delta = delta;
}
}
void
encoder_flush (struct encoder *encoder)
{
encode_run (encoder);
}
static void
encode_block (struct encoder *encoder, struct entry *entry, int x, int y)
{
/* 0x00 2x xx xx 0x xxxx yyyy:
* block ref, block number x (20 bits) at x, y */
/* FIXME: Maybe don't encode pixels under blocks and just emit
* blocks at their position within the stream. */
emit (encoder, 0x00200000 | entry->index);
emit (encoder, (x << 16) | y);
}
void
broadway_buffer_destroy (BroadwayBuffer *buffer)
{
g_free (buffer->data);
g_free (buffer->table);
g_free (buffer);
}
int
broadway_buffer_get_width (BroadwayBuffer *buffer)
{
return buffer->width;
}
int
broadway_buffer_get_height (BroadwayBuffer *buffer)
{
return buffer->height;
}
static void
unpremultiply_line (void *destp, void *srcp, int width)
{
guint32 *src = srcp;
guint32 *dest = destp;
guint32 *end = src + width;
while (src < end)
{
guint32 pixel;
guint8 alpha, r, g, b;
pixel = *src++;
alpha = (pixel & 0xff000000) >> 24;
if (alpha == 0xff)
*dest++ = pixel;
else if (alpha == 0)
*dest++ = 0;
else
{
r = (((pixel & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
g = (((pixel & 0x00ff00) >> 8) * 255 + alpha / 2) / alpha;
b = (((pixel & 0x0000ff) >> 0) * 255 + alpha / 2) / alpha;
*dest++ = (guint32)alpha << 24 | (guint32)r << 16 | (guint32)g << 8 | (guint32)b;
}
}
}
BroadwayBuffer *
broadway_buffer_create (int width, int height, guint8 *data, int stride)
{
BroadwayBuffer *buffer;
int y, bits_required;
buffer = g_new0 (BroadwayBuffer, 1);
buffer->width = width;
buffer->stride = width * 4;
buffer->height = height;
buffer->block_stride = (width + block_size - 1) / block_size;
buffer->block_count =
buffer->block_stride * ((height + block_size - 1) / block_size);
bits_required = g_bit_storage (buffer->block_count * 4);
buffer->shift = 32 - bits_required;
buffer->length = 1 << bits_required;
buffer->table = g_malloc0 (buffer->length * sizeof buffer->table[0]);
memset (buffer->stats, 0, sizeof buffer->stats);
buffer->clashes = 0;
buffer->data = g_malloc (buffer->stride * height);
for (y = 0; y < height; y++)
unpremultiply_line (buffer->data + y * buffer->stride, data + y * stride, width);
return buffer;
}
void
broadway_buffer_encode (BroadwayBuffer *buffer, BroadwayBuffer *prev, GString *dest)
{
struct entry *entry;
int i, j, k;
int x0, x1, y0, y1;
guint32 *block_hashes;
guint32 hash, bottom_hash, h, *line, *bottom, *prev_line;
int width, height;
struct encoder encoder = { 0 };
int *skyline, skyline_pixels;
int matches;
width = buffer->width;
height = buffer->height;
x0 = 0;
x1 = width;
y0 = 0;
y1 = height;
skyline = g_malloc0 ((width + block_size) * sizeof skyline[0]);
block_hashes = g_malloc0 (width * sizeof block_hashes[0]);
matches = 0;
encoder.dest = dest;
// Calculate the block hashes for the first row
for (i = y0; i < MIN(y1, y0 + block_size); i++)
{
line = (guint32 *)(buffer->data + i * buffer->stride);
hash = 0;
for (j = x0; j < MIN(x1, x0 + block_size); j++)
hash = hash * prime + line[j];
for (j = j; j < x0 + block_size; j++)
hash = hash * prime;
for (j = x0; j < x1; j++)
{
block_hashes[j] = block_hashes[j] * vprime + hash;
hash = hash * prime - line[j] * end_prime;
if (j + block_size < width)
hash += line[j + block_size];
}
}
// Do the last rows if height < block_size
for (i = i; i < y0 + block_size; i++)
{
for (j = x0; j < x1; j++)
block_hashes[j] = block_hashes[j] * vprime;
}
for (i = y0; i < y1; i++)
{
line = (guint32 *) (buffer->data + i * buffer->stride);
bottom = (guint32 *) (buffer->data + (i + block_size) * buffer->stride);
bottom_hash = 0;
hash = 0;
skyline_pixels = 0;
if (prev && i < prev->height)
prev_line = (guint32 *) (prev->data + i * prev->stride);
else
prev_line = NULL;
for (j = x0; j < x0 + block_size; j++)
{
hash = hash * prime;
if (j < width)
hash += line[j];
if (i + block_size < height)
{
bottom_hash = bottom_hash * prime;
if (j < width)
bottom_hash += bottom[j];
}
if (i < skyline[j])
skyline_pixels = 0;
else
skyline_pixels++;
}
for (j = x0; j < x1; j++)
{
if (i < skyline[j])
encode_pixel (&encoder, line[j], line[j]);
else if (prev)
{
/* FIXME: Add back overlap exception
* for consecutive blocks */
h = block_hashes[j];
entry = lookup_block (prev, h);
if (entry && entry->count < 2 &&
skyline_pixels >= block_size &&
verify_block_match (buffer, j, i, prev, entry) &&
(entry->x != j || entry->y != i))
{
matches++;
encode_block (&encoder, entry, j, i);
for (k = 0; k < block_size; k++)
skyline[j + k] = i + block_size;
encode_pixel (&encoder, line[j], line[j]);
}
else
{
if (prev_line && j < prev->width)
encode_pixel (&encoder, line[j],
prev_line[j]);
else
encode_pixel (&encoder, line[j], 0);
}
}
else
encode_pixel (&encoder, line[j], 0);
if (i < skyline[j + block_size])
skyline_pixels = 0;
else
skyline_pixels++;
/* Insert block in hash table if we're on a
* grid point. */
if (((i | j) & block_mask) == 0 && !buffer->encoded)
insert_block (buffer, block_hashes[j], j, i);
/* Update sliding block hash */
block_hashes[j] =
block_hashes[j] * vprime + bottom_hash -
hash * end_vprime;
if (i + block_size < height)
{
bottom_hash = bottom_hash * prime - bottom[j] * end_prime;
if (j + block_size < width)
bottom_hash += bottom[j + block_size];
}
hash = hash * prime - line[j] * end_prime;
if (j + block_size < width)
hash += line[j + block_size] ;
}
}
encoder_flush (&encoder);
#if 0
fprintf(stderr, "collision stats:");
for (i = 0; i < (int) G_N_ELEMENTS(buffer->stats); i++)
fprintf(stderr, "%c%d", i == 0 ? ' ' : '/', buffer->stats[i]);
fprintf(stderr, "\n");
fprintf(stderr, "%d / %d blocks (%d%%) matched, %d clashes\n",
matches, buffer->block_count,
100 * matches / buffer->block_count, buffer->clashes);
fprintf(stderr, "output stream %d bytes, raw buffer %d bytes (%d%%)\n",
encoder.bytes, height * buffer->stride,
100 * encoder.bytes / (height * buffer->stride));
#endif
g_free (skyline);
g_free (block_hashes);
buffer->encoded = TRUE;
}
#ifndef __BROADWAY_BUFFER__
#define __BROADWAY_BUFFER__
#include "broadway-protocol.h"
#include <glib-object.h>
typedef struct _BroadwayBuffer BroadwayBuffer;
BroadwayBuffer *broadway_buffer_create (int width,
int height,
guint8 *data,
int stride);
void broadway_buffer_destroy (BroadwayBuffer *buffer);
void broadway_buffer_encode (BroadwayBuffer *buffer,
BroadwayBuffer *prev,
GString *dest);
int broadway_buffer_get_width (BroadwayBuffer *buffer);
int broadway_buffer_get_height (BroadwayBuffer *buffer);
#endif /* __BROADWAY_BUFFER__ */
......@@ -7,42 +7,6 @@
#include "broadway-output.h"
static cairo_status_t
write_png_data (void *closure,
const unsigned char *data,
unsigned int data_len)
{
GString *buf = closure;
g_string_append_len (buf, (char *)data, data_len);
return CAIRO_STATUS_SUCCESS;
}
static void
to_png_rgb (GString *buf, int w, int h, int byte_stride, guint32 *data)
{
cairo_surface_t *surface;
surface = cairo_image_surface_create_for_data ((guchar *)data,
CAIRO_FORMAT_RGB24, w, h, byte_stride);
cairo_surface_write_to_png_stream (surface, write_png_data, buf);
cairo_surface_destroy (surface);
}
static void
to_png_rgba (GString *buf, int w, int h, int byte_stride, guint32 *data)
{
cairo_surface_t *surface;
surface = cairo_image_surface_create_for_data ((guchar *)data,
CAIRO_FORMAT_ARGB32, w, h, byte_stride);
cairo_surface_write_to_png_stream (surface, write_png_data, buf);
cairo_surface_destroy (surface);
}
/************************************************************************
* Basic I/O primitives *
************************************************************************/
......@@ -313,294 +277,30 @@ broadway_output_set_transient_for (BroadwayOutput *output,
append_uint16 (output, parent_id);
}
void
broadway_output_put_rgb (BroadwayOutput *output, int id, int x, int y,
int w, int h, int byte_stride, void *data)
broadway_output_put_buffer (BroadwayOutput *output,
int id,
BroadwayBuffer *prev_buffer,
BroadwayBuffer *buffer)
{
gsize size_start, image_start, len;
int w, h;
write_header (output, BROADWAY_OP_PUT_BUFFER);
write_header (output, BROADWAY_OP_PUT_RGB);
w = broadway_buffer_get_width (buffer);
h = broadway_buffer_get_height (buffer);
append_uint16 (output, id);
append_uint16 (output, x);
append_uint16 (output, y);
append_uint16 (output, w);
append_uint16 (output, h);
size_start = output->buf->len;
append_uint32 (output, 0);
image_start = output->buf->len;
to_png_rgb (output->buf, w, h, byte_stride, (guint32*)data);
broadway_buffer_encode (buffer, prev_buffer, output->buf);
len = output->buf->len - image_start;
overwrite_uint32 (output, size_start, len);
}
typedef struct {
int x1, y1;
int x2, y2;
} BroadwayBox;
static int
is_any_x_set (unsigned char *data,
int box_x1, int box_x2,
int x1, int x2, int y, int *x_set,
int byte_stride)
{
int w ;
guint32 *ptr;
if (x1 < box_x1)
x1 = box_x1;
if (x2 > box_x2)
x2 = box_x2;
w = x2 - x1;
if (w > 0)
{
ptr = (guint32 *)(data + y * byte_stride + x1 * 4);
while (w-- > 0)
{
if (*ptr != 0)
{
if (x_set)
*x_set = x1;
return 1;
}
ptr++;
x1++;
}
}
return 0;
}