1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
import os, sys, array, json, math, StringIO
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import subresource
class Image:
"""This class partially implements the interface of the PIL.Image.Image.
One day in the future WPT might support the PIL module or another imaging
library, so this hacky BMP implementation will no longer be required.
"""
def __init__(self, width, height):
self.width = width
self.height = height
self.img = bytearray([0 for i in range(3 * width * height)])
@staticmethod
def new(mode, size, color=0):
return Image(size[0], size[1])
def _int_to_bytes(self, number):
packed_bytes = [0, 0, 0, 0]
for i in range(4):
packed_bytes[i] = number & 0xFF
number >>= 8
return packed_bytes
def putdata(self, color_data):
for y in range(self.height):
for x in range(self.width):
i = x + y * self.width
if i > len(color_data) - 1:
return
self.img[i * 3: i * 3 + 3] = color_data[i][::-1]
def save(self, f, type):
assert type == "BMP"
# 54 bytes of preambule + image color data.
filesize = 54 + 3 * self.width * self.height;
# 14 bytes of header.
bmpfileheader = bytearray(['B', 'M'] + self._int_to_bytes(filesize) +
[0, 0, 0, 0, 54, 0, 0, 0])
# 40 bytes of info.
bmpinfoheader = bytearray([40, 0, 0, 0] +
self._int_to_bytes(self.width) +
self._int_to_bytes(self.height) +
[1, 0, 24] + (25 * [0]))
padlength = (4 - (self.width * 3) % 4) % 4
bmppad = bytearray([0, 0, 0]);
padding = bmppad[0 : padlength]
f.write(bmpfileheader)
f.write(bmpinfoheader)
for i in range(self.height):
offset = self.width * (self.height - i - 1) * 3
f.write(self.img[offset : offset + 3 * self.width])
f.write(padding)
def encode_string_as_bmp_image(string_data):
data_bytes = array.array("B", string_data)
num_bytes = len(data_bytes)
# Convert data bytes to color data (RGB).
color_data = []
num_components = 3
rgb = [0] * num_components
i = 0
for byte in data_bytes:
component_index = i % num_components
rgb[component_index] = byte
if component_index == (num_components - 1) or i == (num_bytes - 1):
color_data.append(tuple(rgb))
rgb = [0] * num_components
i += 1
# Render image.
num_pixels = len(color_data)
sqrt = int(math.ceil(math.sqrt(num_pixels)))
img = Image.new("RGB", (sqrt, sqrt), "black")
img.putdata(color_data)
# Flush image to string.
f = StringIO.StringIO()
img.save(f, "BMP")
f.seek(0)
return f.read()
def generate_payload(server_data):
data = ('{"headers": %(headers)s}') % server_data
return encode_string_as_bmp_image(data)
def main(request, response):
subresource.respond(request,
response,
payload_generator = generate_payload,
content_type = "image/bmp",
access_control_allow_origin = "*")
|
