forked from AuroraMiddleware/gtk
1000 lines
21 KiB
C
1000 lines
21 KiB
C
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <arpa/inet.h>
|
|
#include <zlib.h>
|
|
|
|
#include "broadway.h"
|
|
|
|
/************************************************************************
|
|
* Basic helpers *
|
|
************************************************************************/
|
|
|
|
#define TRUE 1
|
|
#define FALSE 0
|
|
|
|
typedef unsigned char uchar;
|
|
typedef int boolean;
|
|
|
|
static void *
|
|
bw_malloc(size_t size)
|
|
{
|
|
void *ptr;
|
|
|
|
ptr = malloc(size);
|
|
if (ptr == NULL)
|
|
exit(1);
|
|
|
|
return ptr;
|
|
}
|
|
|
|
static void *
|
|
bw_malloc0(size_t size)
|
|
{
|
|
void *ptr;
|
|
|
|
ptr = calloc(size, 1);
|
|
if (ptr == NULL)
|
|
exit(1);
|
|
|
|
return ptr;
|
|
}
|
|
|
|
#define bw_new(struct_type, n_structs) (bw_malloc(sizeof(struct_type) * (n_structs)))
|
|
#define bw_new0(struct_type, n_structs) (bw_malloc0(sizeof(struct_type) * (n_structs)))
|
|
|
|
/************************************************************************
|
|
* Base64 implementation, from glib *
|
|
************************************************************************/
|
|
|
|
static const char base64_alphabet[] =
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
|
static size_t
|
|
bw_base64_encode_step (const uchar *in,
|
|
size_t len,
|
|
boolean break_lines,
|
|
char *out,
|
|
int *state,
|
|
int *save)
|
|
{
|
|
char *outptr;
|
|
const uchar *inptr;
|
|
|
|
if (len <= 0)
|
|
return 0;
|
|
|
|
inptr = in;
|
|
outptr = out;
|
|
|
|
if (len + ((char *) save) [0] > 2)
|
|
{
|
|
const uchar *inend = in+len-2;
|
|
int c1, c2, c3;
|
|
int already;
|
|
|
|
already = *state;
|
|
|
|
switch (((char *) save) [0])
|
|
{
|
|
case 1:
|
|
c1 = ((unsigned char *) save) [1];
|
|
goto skip1;
|
|
case 2:
|
|
c1 = ((unsigned char *) save) [1];
|
|
c2 = ((unsigned char *) save) [2];
|
|
goto skip2;
|
|
}
|
|
|
|
/*
|
|
* yes, we jump into the loop, no i'm not going to change it,
|
|
* it's beautiful!
|
|
*/
|
|
while (inptr < inend)
|
|
{
|
|
c1 = *inptr++;
|
|
skip1:
|
|
c2 = *inptr++;
|
|
skip2:
|
|
c3 = *inptr++;
|
|
*outptr++ = base64_alphabet [ c1 >> 2 ];
|
|
*outptr++ = base64_alphabet [ c2 >> 4 |
|
|
((c1&0x3) << 4) ];
|
|
*outptr++ = base64_alphabet [ ((c2 &0x0f) << 2) |
|
|
(c3 >> 6) ];
|
|
*outptr++ = base64_alphabet [ c3 & 0x3f ];
|
|
/* this is a bit ugly ... */
|
|
if (break_lines && (++already) >= 19)
|
|
{
|
|
*outptr++ = '\n';
|
|
already = 0;
|
|
}
|
|
}
|
|
|
|
((char *)save)[0] = 0;
|
|
len = 2 - (inptr - inend);
|
|
*state = already;
|
|
}
|
|
|
|
if (len>0)
|
|
{
|
|
char *saveout;
|
|
|
|
/* points to the slot for the next char to save */
|
|
saveout = & (((char *)save)[1]) + ((char *)save)[0];
|
|
|
|
/* len can only be 0 1 or 2 */
|
|
switch(len)
|
|
{
|
|
case 2: *saveout++ = *inptr++;
|
|
case 1: *saveout++ = *inptr++;
|
|
}
|
|
((char *)save)[0] += len;
|
|
}
|
|
|
|
return outptr - out;
|
|
}
|
|
|
|
static size_t
|
|
bw_base64_encode_close (boolean break_lines,
|
|
char *out,
|
|
int *state,
|
|
int *save)
|
|
{
|
|
int c1, c2;
|
|
char *outptr = out;
|
|
|
|
c1 = ((unsigned char *) save) [1];
|
|
c2 = ((unsigned char *) save) [2];
|
|
|
|
switch (((char *) save) [0])
|
|
{
|
|
case 2:
|
|
outptr [2] = base64_alphabet[ ( (c2 &0x0f) << 2 ) ];
|
|
assert (outptr [2] != 0);
|
|
goto skip;
|
|
case 1:
|
|
outptr[2] = '=';
|
|
skip:
|
|
outptr [0] = base64_alphabet [ c1 >> 2 ];
|
|
outptr [1] = base64_alphabet [ c2 >> 4 | ( (c1&0x3) << 4 )];
|
|
outptr [3] = '=';
|
|
outptr += 4;
|
|
break;
|
|
}
|
|
if (break_lines)
|
|
*outptr++ = '\n';
|
|
|
|
*save = 0;
|
|
*state = 0;
|
|
|
|
return outptr - out;
|
|
}
|
|
|
|
#if 0
|
|
static void
|
|
base64_uint8 (uint8_t v, char *c)
|
|
{
|
|
c[0] = base64_alphabet[(v >> 0) & 0x3f];
|
|
c[1] = base64_alphabet[(v >> 6) & 0x3];
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
base64_uint16 (uint32_t v, char *c)
|
|
{
|
|
c[0] = base64_alphabet[(v >> 0) & 0x3f];
|
|
c[1] = base64_alphabet[(v >> 6) & 0x3f];
|
|
c[2] = base64_alphabet[(v >> 12) & 0xf];
|
|
}
|
|
|
|
#if 0
|
|
static void
|
|
base64_uint24 (uint32_t v, char *c)
|
|
{
|
|
c[0] = base64_alphabet[(v >> 0) & 0x3f];
|
|
c[1] = base64_alphabet[(v >> 6) & 0x3f];
|
|
c[2] = base64_alphabet[(v >> 12) & 0x3f];
|
|
c[3] = base64_alphabet[(v >> 18) & 0x3f];
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
base64_uint32 (uint32_t v, char *c)
|
|
{
|
|
c[0] = base64_alphabet[(v >> 0) & 0x3f];
|
|
c[1] = base64_alphabet[(v >> 6) & 0x3f];
|
|
c[2] = base64_alphabet[(v >> 12) & 0x3f];
|
|
c[3] = base64_alphabet[(v >> 18) & 0x3f];
|
|
c[4] = base64_alphabet[(v >> 24) & 0x3f];
|
|
c[5] = base64_alphabet[(v >> 30) & 0x2];
|
|
}
|
|
|
|
/************************************************************************
|
|
* conversion of raw image data to uncompressed png data: uris *
|
|
************************************************************************/
|
|
|
|
/* Table of CRCs of all 8-bit messages. */
|
|
static unsigned long crc_table[256];
|
|
|
|
/* Flag: has the table been computed? Initially false. */
|
|
static int crc_table_computed = 0;
|
|
|
|
/* Make the table for a fast CRC. */
|
|
static void
|
|
make_crc_table(void)
|
|
{
|
|
unsigned long c;
|
|
int n, k;
|
|
|
|
for (n = 0; n < 256; n++) {
|
|
c = (unsigned long) n;
|
|
for (k = 0; k < 8; k++) {
|
|
if (c & 1)
|
|
c = 0xedb88320L ^ (c >> 1);
|
|
else
|
|
c = c >> 1;
|
|
}
|
|
crc_table[n] = c;
|
|
}
|
|
crc_table_computed = 1;
|
|
}
|
|
|
|
static unsigned long
|
|
update_crc(unsigned long crc, unsigned char *buf, int len)
|
|
{
|
|
unsigned long c = crc;
|
|
int n;
|
|
|
|
if (!crc_table_computed)
|
|
make_crc_table();
|
|
for (n = 0; n < len; n++) {
|
|
c = crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
static unsigned long
|
|
crc(unsigned char *buf, int len)
|
|
{
|
|
return update_crc(0xffffffffL, buf, len) ^ 0xffffffffL;
|
|
}
|
|
|
|
#define BASE 65521 /* largest prime smaller than 65536 */
|
|
static unsigned long
|
|
update_adler32(unsigned long adler, unsigned char *buf, int len)
|
|
{
|
|
unsigned long s1 = adler & 0xffff;
|
|
unsigned long s2 = (adler >> 16) & 0xffff;
|
|
int n;
|
|
|
|
for (n = 0; n < len; n++) {
|
|
s1 = (s1 + buf[n]) % BASE;
|
|
s2 = (s2 + s1) % BASE;
|
|
}
|
|
return (s2 << 16) + s1;
|
|
}
|
|
|
|
static char *
|
|
to_png_rgb (int w, int h, int byte_stride, uint32_t *data)
|
|
{
|
|
uchar header[] = {137, 80, 78, 71, 13, 10, 26, 10};
|
|
uchar ihdr[13+12] = {0, 0, 0, 13, 'I', 'H', 'D', 'R',
|
|
/* w: */ 0, 0, 0, 0, /* h: */ 0,0,0,0,
|
|
/* bpp: */ 8, /* color type: */ 2,
|
|
0, 0, 0};
|
|
uchar idat_start[8] = { /* len: */0, 0, 0, 0, 'I', 'D', 'A', 'T' };
|
|
uchar iend[12] = {0, 0, 0, 0, 'I', 'E', 'N', 'D', 0xae, 0x42, 0x60, 0x82};
|
|
size_t data_size, row_size;
|
|
char row_header[6];
|
|
uint8_t *png, *p, *p_row, *p_idat;
|
|
uint32_t *row;
|
|
unsigned long adler;
|
|
uint32_t pixel;
|
|
size_t png_size;
|
|
int x, y;
|
|
char *url, *url_base64;
|
|
int state = 0, outlen;
|
|
int save = 0;
|
|
|
|
*(uint32_t *)&ihdr[8] = htonl(w);
|
|
*(uint32_t *)&ihdr[12] = htonl(h);
|
|
*(uint32_t *)&ihdr[21] = htonl(crc(&ihdr[4], 13 + 4));
|
|
|
|
row_size = 1 + w * 3;
|
|
row_header[0] = 0;
|
|
row_header[1] = row_size & 0xff;
|
|
row_header[2] = (row_size >> 8) & 0xff;
|
|
row_header[3] = ~row_header[1];
|
|
row_header[4] = ~row_header[2];
|
|
row_header[5] = 0;
|
|
|
|
data_size = 2 + (6 + w * 3) * h + 4;
|
|
|
|
*(uint32_t *)&idat_start[0] = htonl(data_size);
|
|
|
|
png_size = sizeof(header) + sizeof(ihdr) + 12 + data_size + sizeof(iend);
|
|
png = bw_malloc (png_size);
|
|
|
|
p = png;
|
|
memcpy (p, header, sizeof(header));
|
|
p += sizeof(header);
|
|
memcpy (p, ihdr, sizeof(ihdr));
|
|
p += sizeof(ihdr);
|
|
memcpy (p, idat_start, sizeof(idat_start));
|
|
p += sizeof(idat_start);
|
|
|
|
/* IDAT data:
|
|
|
|
zlib header: 0x78, 0x01 ,
|
|
h * scanline: row_header[] + width * r,g,b
|
|
checksum: adler32
|
|
*/
|
|
|
|
p_idat = p - 4;
|
|
|
|
/* zlib header */
|
|
*p++ = 0x78;
|
|
*p++ = 0x01;
|
|
|
|
adler = 1;
|
|
|
|
/* scanline data */
|
|
for (y = 0; y < h; y++) {
|
|
if (y == h - 1)
|
|
row_header[0] = 1; /* final block */
|
|
memcpy (p, row_header, sizeof(row_header));
|
|
p += sizeof(row_header);
|
|
p_row = p - 1;
|
|
row = data;
|
|
data += byte_stride / 4;
|
|
for (x = 0; x < w; x++) {
|
|
pixel = *row++;
|
|
*p++ = (pixel >> 16) & 0xff; /* red */
|
|
*p++ = (pixel >> 8) & 0xff; /* green */
|
|
*p++ = (pixel >> 0) & 0xff; /* blue */
|
|
}
|
|
adler = update_adler32(adler, p_row, p - p_row);
|
|
}
|
|
|
|
/* adler32 */
|
|
*(uint32_t *)p = htonl(adler);
|
|
p += 4;
|
|
*(uint32_t *)p = htonl(crc(p_idat, p - p_idat));
|
|
p += 4;
|
|
|
|
memcpy (p, iend, sizeof(iend));
|
|
p += sizeof(iend);
|
|
|
|
assert(p - png == png_size);
|
|
|
|
url = bw_malloc (strlen("data:image/png;base64,") +
|
|
((png_size / 3 + 1) * 4 + 4) + 1);
|
|
strcpy (url, "data:image/png;base64,");
|
|
|
|
url_base64 = url + strlen("data:image/png;base64,");
|
|
outlen = bw_base64_encode_step (png, png_size, FALSE, url_base64, &state, &save);
|
|
outlen += bw_base64_encode_close (FALSE, url_base64 + outlen, &state, &save);
|
|
url_base64[outlen] = 0;
|
|
|
|
free (png);
|
|
|
|
return url;
|
|
}
|
|
|
|
static char *
|
|
to_png_rgba (int w, int h, int byte_stride, uint32_t *data)
|
|
{
|
|
uchar header[] = {137, 80, 78, 71, 13, 10, 26, 10};
|
|
uchar ihdr[13+12] = {0, 0, 0, 13, 'I', 'H', 'D', 'R',
|
|
/* w: */ 0, 0, 0, 0, /* h: */ 0,0,0,0,
|
|
/* bpp: */ 8, /* color type: */ 6,
|
|
0, 0, 0};
|
|
uchar idat_start[8] = { /* len: */0, 0, 0, 0, 'I', 'D', 'A', 'T' };
|
|
uchar iend[12] = {0, 0, 0, 0, 'I', 'E', 'N', 'D', 0xae, 0x42, 0x60, 0x82};
|
|
size_t data_size, row_size;
|
|
char row_header[6];
|
|
uint8_t *png, *p, *p_row, *p_idat;
|
|
uint32_t *row;
|
|
unsigned long adler;
|
|
uint32_t pixel;
|
|
size_t png_size;
|
|
int x, y;
|
|
char *url, *url_base64;
|
|
int state = 0, outlen;
|
|
int save = 0;
|
|
|
|
*(uint32_t *)&ihdr[8] = htonl(w);
|
|
*(uint32_t *)&ihdr[12] = htonl(h);
|
|
*(uint32_t *)&ihdr[21] = htonl(crc(&ihdr[4], 13 + 4));
|
|
|
|
row_size = 1 + w * 4;
|
|
row_header[0] = 0;
|
|
row_header[1] = row_size & 0xff;
|
|
row_header[2] = (row_size >> 8) & 0xff;
|
|
row_header[3] = ~row_header[1];
|
|
row_header[4] = ~row_header[2];
|
|
row_header[5] = 0;
|
|
|
|
data_size = 2 + (6 + w * 4) * h + 4;
|
|
|
|
*(uint32_t *)&idat_start[0] = htonl(data_size);
|
|
|
|
png_size = sizeof(header) + sizeof(ihdr) + 12 + data_size + sizeof(iend);
|
|
png = bw_malloc (png_size);
|
|
|
|
p = png;
|
|
memcpy (p, header, sizeof(header));
|
|
p += sizeof(header);
|
|
memcpy (p, ihdr, sizeof(ihdr));
|
|
p += sizeof(ihdr);
|
|
memcpy (p, idat_start, sizeof(idat_start));
|
|
p += sizeof(idat_start);
|
|
|
|
/* IDAT data:
|
|
|
|
zlib header: 0x78, 0x01 ,
|
|
h * scanline: row_header[] + width * r,g,b,a
|
|
checksum: adler32
|
|
*/
|
|
|
|
p_idat = p - 4;
|
|
|
|
/* zlib header */
|
|
*p++ = 0x78;
|
|
*p++ = 0x01;
|
|
|
|
adler = 1;
|
|
|
|
/* scanline data */
|
|
for (y = 0; y < h; y++) {
|
|
if (y == h - 1)
|
|
row_header[0] = 1; /* final block */
|
|
memcpy (p, row_header, sizeof(row_header));
|
|
p += sizeof(row_header);
|
|
p_row = p - 1;
|
|
row = data;
|
|
data += byte_stride / 4;
|
|
for (x = 0; x < w; x++) {
|
|
pixel = *row++;
|
|
*p++ = (pixel >> 16) & 0xff; /* red */
|
|
*p++ = (pixel >> 8) & 0xff; /* green */
|
|
*p++ = (pixel >> 0) & 0xff; /* blue */
|
|
*p++ = (pixel >> 24) & 0xff; /* alpha */
|
|
}
|
|
adler = update_adler32(adler, p_row, p - p_row);
|
|
}
|
|
|
|
/* adler32 */
|
|
*(uint32_t *)p = htonl(adler);
|
|
p += 4;
|
|
*(uint32_t *)p = htonl(crc(p_idat, p - p_idat));
|
|
p += 4;
|
|
|
|
memcpy (p, iend, sizeof(iend));
|
|
p += sizeof(iend);
|
|
|
|
assert(p - png == png_size);
|
|
|
|
url = bw_malloc (strlen("data:image/png;base64,") +
|
|
((png_size / 3 + 1) * 4 + 4) + 1);
|
|
strcpy (url, "data:image/png;base64,");
|
|
|
|
url_base64 = url + strlen("data:image/png;base64,");
|
|
outlen = bw_base64_encode_step (png, png_size, FALSE, url_base64, &state, &save);
|
|
outlen += bw_base64_encode_close (FALSE, url_base64 + outlen, &state, &save);
|
|
url_base64[outlen] = 0;
|
|
|
|
free (png);
|
|
|
|
return url;
|
|
}
|
|
|
|
#if 0
|
|
static char *
|
|
to_png_a (int w, int h, int byte_stride, uint8_t *data)
|
|
{
|
|
uchar header[] = {137, 80, 78, 71, 13, 10, 26, 10};
|
|
uchar ihdr[13+12] = {0, 0, 0, 13, 'I', 'H', 'D', 'R',
|
|
/* w: */ 0, 0, 0, 0, /* h: */ 0,0,0,0,
|
|
/* bpp: */ 8, /* color type: */ 4,
|
|
0, 0, 0};
|
|
uchar idat_start[8] = { /* len: */0, 0, 0, 0, 'I', 'D', 'A', 'T' };
|
|
uchar iend[12] = {0, 0, 0, 0, 'I', 'E', 'N', 'D', 0xae, 0x42, 0x60, 0x82};
|
|
size_t data_size, row_size;
|
|
char row_header[6];
|
|
uint8_t *png, *p, *p_row, *p_idat;
|
|
uint8_t *row;
|
|
unsigned long adler;
|
|
uint32_t pixel;
|
|
size_t png_size;
|
|
int x, y;
|
|
char *url, *url_base64;
|
|
int state = 0, outlen;
|
|
int save = 0;
|
|
|
|
*(uint32_t *)&ihdr[8] = htonl(w);
|
|
*(uint32_t *)&ihdr[12] = htonl(h);
|
|
*(uint32_t *)&ihdr[21] = htonl(crc(&ihdr[4], 13 + 4));
|
|
|
|
row_size = 1 + w * 2;
|
|
row_header[0] = 0;
|
|
row_header[1] = row_size & 0xff;
|
|
row_header[2] = (row_size >> 8) & 0xff;
|
|
row_header[3] = ~row_header[1];
|
|
row_header[4] = ~row_header[2];
|
|
row_header[5] = 0;
|
|
|
|
data_size = 2 + (6 + w * 2) * h + 4;
|
|
|
|
*(uint32_t *)&idat_start[0] = htonl(data_size);
|
|
|
|
png_size = sizeof(header) + sizeof(ihdr) + 12 + data_size + sizeof(iend);
|
|
png = bw_malloc (png_size);
|
|
|
|
p = png;
|
|
memcpy (p, header, sizeof(header));
|
|
p += sizeof(header);
|
|
memcpy (p, ihdr, sizeof(ihdr));
|
|
p += sizeof(ihdr);
|
|
memcpy (p, idat_start, sizeof(idat_start));
|
|
p += sizeof(idat_start);
|
|
|
|
/* IDAT data:
|
|
|
|
zlib header: 0x78, 0x01 ,
|
|
h * scanline: row_header[] + width * r,g,b,a
|
|
checksum: adler32
|
|
*/
|
|
|
|
p_idat = p - 4;
|
|
|
|
/* zlib header */
|
|
*p++ = 0x78;
|
|
*p++ = 0x01;
|
|
|
|
adler = 1;
|
|
|
|
/* scanline data */
|
|
for (y = 0; y < h; y++) {
|
|
if (y == h - 1)
|
|
row_header[0] = 1; /* final block */
|
|
memcpy (p, row_header, sizeof(row_header));
|
|
p += sizeof(row_header);
|
|
p_row = p - 1;
|
|
row = data;
|
|
data += byte_stride / 4;
|
|
for (x = 0; x < w; x++) {
|
|
pixel = *row++;
|
|
*p++ = 0x00; /* gray */
|
|
*p++ = pixel; /* alpha */
|
|
}
|
|
adler = update_adler32(adler, p_row, p - p_row);
|
|
}
|
|
|
|
/* adler32 */
|
|
*(uint32_t *)p = htonl(adler);
|
|
p += 4;
|
|
*(uint32_t *)p = htonl(crc(p_idat, p - p_idat));
|
|
p += 4;
|
|
|
|
memcpy (p, iend, sizeof(iend));
|
|
p += sizeof(iend);
|
|
|
|
assert(p - png == png_size);
|
|
|
|
url = bw_malloc (strlen("data:image/png;base64,") +
|
|
((png_size / 3 + 1) * 4 + 4) + 1);
|
|
strcpy (url, "data:image/png;base64,");
|
|
|
|
url_base64 = url + strlen("data:image/png;base64,");
|
|
outlen = bw_base64_encode_step (png, png_size, FALSE, url_base64, &state, &save);
|
|
outlen += bw_base64_encode_close (FALSE, url_base64 + outlen, &state, &save);
|
|
url_base64[outlen] = 0;
|
|
|
|
free (png);
|
|
|
|
return url;
|
|
}
|
|
#endif
|
|
|
|
/************************************************************************
|
|
* Basic I/O primitives *
|
|
************************************************************************/
|
|
|
|
struct BroadwayClient {
|
|
int fd;
|
|
gzFile *zfd;
|
|
} ;
|
|
|
|
static void
|
|
broadway_client_write_raw (BroadwayClient *client,
|
|
const void *buf, size_t count)
|
|
{
|
|
ssize_t res;
|
|
int errsave;
|
|
const char *ptr = (const char *)buf;
|
|
|
|
while (count > 0)
|
|
{
|
|
res = write(client->fd, ptr, count);
|
|
if (res == -1)
|
|
{
|
|
errsave = errno;
|
|
if (errsave == EINTR)
|
|
continue;
|
|
fprintf(stderr, "Error on write_raw to client %d\n", errsave);
|
|
exit(1);
|
|
}
|
|
if (res == 0)
|
|
{
|
|
fprintf(stderr, "Short write_raw to client\n");
|
|
exit(1);
|
|
}
|
|
count -= res;
|
|
ptr += res;
|
|
}
|
|
}
|
|
|
|
static void
|
|
broadway_client_write (BroadwayClient *client,
|
|
const void *buf, size_t count)
|
|
{
|
|
ssize_t res;
|
|
const char *ptr = (const char *)buf;
|
|
|
|
while (count > 0)
|
|
{
|
|
res = gzwrite(client->zfd, ptr, count);
|
|
if (res == -1)
|
|
{
|
|
fprintf(stderr, "Error on write to client\n");
|
|
exit(1);
|
|
}
|
|
if (res == 0)
|
|
{
|
|
fprintf(stderr, "Short write to client\n");
|
|
exit(1);
|
|
}
|
|
count -= res;
|
|
ptr += res;
|
|
}
|
|
}
|
|
|
|
static void
|
|
broadway_client_write_header (BroadwayClient *client)
|
|
{
|
|
char *header;
|
|
|
|
header =
|
|
"HTTP/1.1 200 OK\r\n"
|
|
"Content-type: multipart/x-mixed-replace;boundary=x\r\n"
|
|
"Content-Encoding: gzip\r\n"
|
|
"\r\n";
|
|
broadway_client_write_raw (client,
|
|
header, strlen (header));
|
|
}
|
|
|
|
static void
|
|
send_boundary (BroadwayClient *client)
|
|
{
|
|
char *boundary =
|
|
"--x\r\n"
|
|
"\r\n";
|
|
|
|
broadway_client_write (client, boundary, strlen (boundary));
|
|
}
|
|
|
|
BroadwayClient *
|
|
broadway_client_new(int fd)
|
|
{
|
|
BroadwayClient *client;
|
|
|
|
client = bw_new0 (BroadwayClient, 1);
|
|
|
|
client->fd = fd;
|
|
|
|
broadway_client_write_header (client);
|
|
|
|
client->zfd = gzdopen(fd, "wb");
|
|
|
|
/* Need an initial multipart boundary */
|
|
send_boundary (client);
|
|
|
|
return client;
|
|
}
|
|
|
|
void
|
|
broadway_client_flush (BroadwayClient *client)
|
|
{
|
|
send_boundary (client);
|
|
gzflush (client->zfd, Z_SYNC_FLUSH);
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
* Core rendering operations *
|
|
************************************************************************/
|
|
|
|
void
|
|
broadway_client_copy_rectangles (BroadwayClient *client, int id,
|
|
BroadwayRect *rects, int n_rects,
|
|
int dx, int dy)
|
|
{
|
|
char *buf;
|
|
int len, i, p;
|
|
|
|
len = 1 + 3 + 3 + 3*4*n_rects + 3 + 3;
|
|
|
|
buf = bw_malloc (len);
|
|
p = 0;
|
|
buf[p++] = 'b';
|
|
base64_uint16(id, &buf[p]); p +=3;
|
|
base64_uint16(n_rects, &buf[p]); p +=3;
|
|
for (i = 0; i < n_rects; i++)
|
|
{
|
|
base64_uint16(rects[i].x, &buf[p]); p +=3;
|
|
base64_uint16(rects[i].y, &buf[p]); p +=3;
|
|
base64_uint16(rects[i].width, &buf[p]); p +=3;
|
|
base64_uint16(rects[i].height, &buf[p]); p +=3;
|
|
}
|
|
base64_uint16(dx, &buf[p]); p +=3;
|
|
base64_uint16(dy, &buf[p]); p +=3;
|
|
|
|
broadway_client_write (client, buf, len);
|
|
free (buf);
|
|
}
|
|
|
|
void
|
|
broadway_client_new_surface(BroadwayClient *client, int id, int x, int y, int w, int h)
|
|
{
|
|
char buf[16];
|
|
|
|
buf[0] = 's';
|
|
base64_uint16(id, &buf[1]);
|
|
base64_uint16(x, &buf[4]);
|
|
base64_uint16(y, &buf[7]);
|
|
base64_uint16(w, &buf[10]);
|
|
base64_uint16(h, &buf[13]);
|
|
|
|
broadway_client_write (client, buf, 16);
|
|
}
|
|
|
|
void
|
|
broadway_client_show_surface(BroadwayClient *client, int id)
|
|
{
|
|
char buf[4];
|
|
|
|
buf[0] = 'S';
|
|
base64_uint16(id, &buf[1]);
|
|
|
|
broadway_client_write (client, buf, 4);
|
|
}
|
|
|
|
void
|
|
broadway_client_hide_surface(BroadwayClient *client, int id)
|
|
{
|
|
char buf[4];
|
|
|
|
buf[0] = 'H';
|
|
base64_uint16(id, &buf[1]);
|
|
|
|
broadway_client_write (client, buf, 4);
|
|
}
|
|
|
|
void
|
|
broadway_client_destroy_surface(BroadwayClient *client, int id)
|
|
{
|
|
char buf[4];
|
|
|
|
buf[0] = 'd';
|
|
base64_uint16(id, &buf[1]);
|
|
|
|
broadway_client_write (client, buf, 4);
|
|
}
|
|
|
|
void
|
|
broadway_client_move_surface(BroadwayClient *client, int id, int x, int y)
|
|
{
|
|
char buf[10];
|
|
|
|
buf[0] = 'm';
|
|
base64_uint16(id, &buf[1]);
|
|
base64_uint16(x, &buf[4]);
|
|
base64_uint16(y, &buf[7]);
|
|
|
|
broadway_client_write (client, buf, 10);
|
|
}
|
|
|
|
void
|
|
broadway_client_put_rgb (BroadwayClient *client, int id, int x, int y,
|
|
int w, int h, int byte_stride, void *data)
|
|
{
|
|
char buf[16];
|
|
size_t len;
|
|
char *url;
|
|
|
|
buf[0] = 'i';
|
|
base64_uint16(id, &buf[1]);
|
|
base64_uint16(x, &buf[4]);
|
|
base64_uint16(y, &buf[7]);
|
|
|
|
url = to_png_rgb (w, h, byte_stride, (uint32_t*)data);
|
|
len = strlen (url);
|
|
base64_uint32(len, &buf[10]);
|
|
|
|
broadway_client_write (client, buf, 16);
|
|
|
|
broadway_client_write (client, url, len);
|
|
|
|
free (url);
|
|
}
|
|
|
|
static void
|
|
rgba_autocrop (unsigned char *data,
|
|
int byte_stride,
|
|
int *x_arg, int *y_arg,
|
|
int *w_arg, int *h_arg)
|
|
{
|
|
uint32_t *line;
|
|
int w, h;
|
|
int x, y, xx, yy;
|
|
boolean non_zero;
|
|
|
|
x = *x_arg;
|
|
y = *y_arg;
|
|
w = *w_arg;
|
|
h = *h_arg;
|
|
|
|
while (h > 0)
|
|
{
|
|
line = (uint32_t *)(data + y * byte_stride + x * 4);
|
|
|
|
non_zero = FALSE;
|
|
for (xx = 0; xx < w; xx++)
|
|
{
|
|
if (*line != 0) {
|
|
non_zero = TRUE;
|
|
break;
|
|
}
|
|
line++;
|
|
}
|
|
|
|
if (non_zero)
|
|
break;
|
|
|
|
y++;
|
|
h--;
|
|
}
|
|
|
|
while (h > 0)
|
|
{
|
|
line = (uint32_t *)(data + (y + h - 1) * byte_stride + x * 4);
|
|
|
|
non_zero = FALSE;
|
|
for (xx = 0; xx < w; xx++)
|
|
{
|
|
if (*line != 0) {
|
|
non_zero = TRUE;
|
|
break;
|
|
}
|
|
line++;
|
|
}
|
|
|
|
if (non_zero)
|
|
break;
|
|
h--;
|
|
}
|
|
|
|
while (w > 0)
|
|
{
|
|
line = (uint32_t *)(data + y * byte_stride + x * 4);
|
|
|
|
non_zero = FALSE;
|
|
for (yy = 0; yy < h; yy++)
|
|
{
|
|
if (*line != 0) {
|
|
non_zero = TRUE;
|
|
break;
|
|
}
|
|
line += byte_stride / 4;
|
|
}
|
|
|
|
if (non_zero)
|
|
break;
|
|
|
|
x++;
|
|
w--;
|
|
}
|
|
|
|
while (w > 0)
|
|
{
|
|
line = (uint32_t *)(data + y * byte_stride + (x + w - 1) * 4);
|
|
|
|
non_zero = FALSE;
|
|
for (yy = 0; yy < h; yy++)
|
|
{
|
|
if (*line != 0) {
|
|
non_zero = TRUE;
|
|
break;
|
|
}
|
|
line += byte_stride / 4;
|
|
}
|
|
|
|
if (non_zero)
|
|
break;
|
|
w--;
|
|
}
|
|
|
|
*x_arg = x;
|
|
*y_arg = y;
|
|
*w_arg = w;
|
|
*h_arg = h;
|
|
}
|
|
|
|
void
|
|
broadway_client_put_rgba (BroadwayClient *client, int id, int x, int y,
|
|
int w, int h, int byte_stride, void *data)
|
|
{
|
|
char buf[16];
|
|
size_t len;
|
|
char *url;
|
|
int crop_x, crop_y;
|
|
|
|
crop_x = 0;
|
|
crop_y = 0;
|
|
|
|
rgba_autocrop (data,
|
|
byte_stride,
|
|
&crop_x, &crop_y, &w, &h);
|
|
|
|
if (w == 0 || h == 0)
|
|
return;
|
|
|
|
data = (uint8_t *)data + crop_x * 4 + crop_y * byte_stride;
|
|
|
|
buf[0] = 'i';
|
|
base64_uint16(id, &buf[1]);
|
|
base64_uint16(x + crop_x, &buf[4]);
|
|
base64_uint16(y + crop_y, &buf[7]);
|
|
|
|
url = to_png_rgba (w, h, byte_stride, (uint32_t*)data);
|
|
len = strlen (url);
|
|
base64_uint32(len, &buf[10]);
|
|
|
|
broadway_client_write (client, buf, 16);
|
|
|
|
broadway_client_write (client, url, len);
|
|
|
|
free (url);
|
|
}
|
|
|
|
#if 0
|
|
static void
|
|
send_image_a (BroadwayClient *client, int id, int x, int y,
|
|
int w, int h, int byte_stride, uint8_t *data)
|
|
{
|
|
char buf[16];
|
|
size_t len;
|
|
char *url;
|
|
|
|
buf[0] = 'i';
|
|
base64_uint16(id, &buf[1]);
|
|
base64_uint16(x, &buf[4]);
|
|
base64_uint16(y, &buf[7]);
|
|
|
|
url = to_png_a (w, h, byte_stride, data);
|
|
len = strlen (url);
|
|
base64_uint32(len, &buf[10]);
|
|
|
|
broadway_client_write (client, buf, 16);
|
|
|
|
broadway_client_write (client, url, len);
|
|
|
|
free (url);
|
|
}
|
|
#endif
|