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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
|
# This file is part of Image Preview Gajim Plugin.
#
# Image Preview Gajim Plugin is free software;
# you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published
# by the Free Software Foundation; version 3 only.
#
# Image Preview Gajim Plugin is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Image Preview Gajim Plugin.
# If not, see <http://www.gnu.org/licenses/>.
import math
import logging
import binascii
import hashlib
from io import BytesIO
from collections import namedtuple
from pathlib import Path
from urllib.parse import urlparse
from urllib.parse import unquote
from gi.repository import GdkPixbuf
from gi.repository import GLib
from PIL import Image
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.ciphers import Cipher
from cryptography.hazmat.primitives.ciphers import algorithms
from cryptography.hazmat.primitives.ciphers.modes import GCM
log = logging.getLogger('gajim.p.preview.utils')
Coords = namedtuple('Coords', 'location lat lon')
def resize_gif(image, output_file, resize_to):
frames, result = extract_and_resize_frames(image, resize_to)
frames[0].save(output_file,
format='GIF',
optimize=True,
save_all=True,
append_images=frames[1:],
duration=result['duration'],
loop=1000)
def analyse_image(image):
'''
Pre-process pass over the image to determine the mode (full or additive).
Necessary as assessing single frames isn't reliable. Need to know the mode
before processing all frames.
'''
result = {
'size': image.size,
'mode': 'full',
'duration': image.info.get('duration', 0)
}
try:
while True:
if image.tile:
tile = image.tile[0]
update_region = tile[1]
update_region_dimensions = update_region[2:]
if update_region_dimensions != image.size:
result['mode'] = 'partial'
break
image.seek(image.tell() + 1)
except EOFError:
image.seek(0)
return image, result
def extract_and_resize_frames(image, resize_to):
image, result = analyse_image(image)
i = 0
palette = image.getpalette()
last_frame = image.convert('RGBA')
frames = []
try:
while True:
'''
If the GIF uses local colour tables,
each frame will have its own palette.
If not, we need to apply the global palette to the new frame.
'''
if not image.getpalette():
image.putpalette(palette)
new_frame = Image.new('RGBA', image.size)
'''
Is this file a "partial"-mode GIF where frames update a region
of a different size to the entire image?
If so, we need to construct the new frame by
pasting it on top of the preceding frames.
'''
if result['mode'] == 'partial':
new_frame.paste(last_frame)
new_frame.paste(image, (0, 0), image.convert('RGBA'))
# This method preservs aspect ratio
new_frame.thumbnail(resize_to, Image.ANTIALIAS)
frames.append(new_frame)
i += 1
last_frame = new_frame
image.seek(image.tell() + 1)
except EOFError:
pass
return frames, result
def create_thumbnail(data, size):
thumbnail = create_thumbnail_with_pil(data, size)
if thumbnail is not None:
return thumbnail
return create_thumbnail_with_pixbuf(data, size)
def create_thumbnail_with_pixbuf(data, size):
loader = GdkPixbuf.PixbufLoader()
try:
loader.write(data)
except GLib.Error as error:
log.warning('making pixbuf failed: %s', error)
return None
loader.close()
pixbuf = loader.get_pixbuf()
if size > pixbuf.get_width() and size > pixbuf.get_height():
return data
width, height = get_thumbnail_size(pixbuf, size)
thumbnail = pixbuf.scale_simple(width,
height,
GdkPixbuf.InterpType.BILINEAR)
has_error, bytes_ = thumbnail.save_to_bufferv('png', [], [])
if has_error:
log.warning('saving pixbuf to buffer failed')
return None
return bytes_
def create_thumbnail_with_pil(data, size):
input_file = BytesIO(data)
output_file = BytesIO()
try:
image = Image.open(input_file)
except OSError as error:
log.warning('making pil thumbnail failed: %s', error)
log.warning('fallback to pixbuf')
input_file.close()
output_file.close()
return
image_width, image_height = image.size
if size > image_width and size > image_height:
image.close()
input_file.close()
output_file.close()
return data
if image.format == 'GIF' and image.n_frames > 1:
resize_gif(image, output_file, (size, size))
else:
image.thumbnail((size, size))
image.save(output_file,
format=image.format,
exif=image.info.get('exif', b''),
optimize=True)
bytes_ = output_file.getvalue()
image.close()
input_file.close()
output_file.close()
return bytes_
def get_thumbnail_size(pixbuf, size):
# Calculates the new thumbnail size while preserving the aspect ratio
image_width = pixbuf.get_width()
image_height = pixbuf.get_height()
if image_width > image_height:
if image_width > size:
image_height = math.ceil((size / float(image_width) * image_height))
image_width = int(size)
else:
if image_height > size:
image_width = math.ceil((size / float(image_height) * image_width))
image_height = int(size)
return image_width, image_height
def pixbuf_from_data(data):
loader = GdkPixbuf.PixbufLoader()
try:
loader.write(data)
loader.close()
except GLib.Error:
# Fallback to Pillow
input_file = BytesIO(data)
image = Image.open(BytesIO(data)).convert('RGBA')
array = GLib.Bytes.new(image.tobytes())
width, height = image.size
pixbuf = GdkPixbuf.Pixbuf.new_from_bytes(array,
GdkPixbuf.Colorspace.RGB,
True,
8,
width,
height,
width * 4)
image.close()
input_file.close()
return pixbuf
return loader.get_pixbuf().apply_embedded_orientation()
def parse_fragment(fragment):
if not fragment:
raise ValueError('Invalid fragment')
fragment = binascii.unhexlify(fragment)
size = len(fragment)
# Clients started out with using a 16 byte IV but long term
# want to swtich to the more performant 12 byte IV
# We have to support both
if size == 48:
key = fragment[16:]
iv = fragment[:16]
elif size == 44:
key = fragment[12:]
iv = fragment[:12]
else:
raise ValueError('Invalid fragment size: %s' % size)
return key, iv
def get_image_paths(uri, urlparts, size, orig_dir, thumb_dir):
path = Path(unquote(urlparts.path))
web_stem = path.stem
extension = path.suffix
if len(web_stem) > 90:
# Many Filesystems have a limit on filename length
# Most have 255, some encrypted ones only 143
# We add around 50 chars for the hash,
# so the filename should not exceed 90
web_stem = web_stem[:90]
name_hash = hashlib.sha1(str(uri).encode()).hexdigest()
orig_filename = '%s_%s%s' % (web_stem, name_hash, extension)
thumb_filename = '%s_%s_thumb_%s%s' % (web_stem,
name_hash,
size,
extension)
orig_path = orig_dir / orig_filename
thumb_path = thumb_dir / thumb_filename
return orig_path, thumb_path
def split_geo_uri(uri):
# Example:
# geo:37.786971,-122.399677,122.3;CRS=epsg:32718;U=20;mapcolors=abc
# Assumption is all coordinates are CRS=WGS-84
# Remove "geo:"
coords = uri[4:]
# Remove arguments
if ';' in coords:
coords, _ = coords.split(';', maxsplit=1)
# Split coords
coords = coords.split(',')
if len(coords) not in (2, 3):
raise ValueError('Invalid geo uri: invalid coord count')
# Remoove coord-c (altitude)
if len(coords) == 3:
coords.pop(2)
lat, lon = coords
if float(lat) < -90 or float(lat) > 90:
raise ValueError('Invalid geo_uri: invalid latitude %s' % lat)
if float(lon) < -180 or float(lon) > 180:
raise ValueError('Invalid geo_uri: invalid longitude %s' % lon)
location = ','.join(coords)
return Coords(location=location, lat=lat, lon=lon)
def filename_from_uri(uri):
urlparts = urlparse(unquote(uri))
path = Path(urlparts.path)
return path.name
def aes_decrypt(preview, payload):
# Use AES128 GCM with the given key and iv to decrypt the payload
data = payload[:-16]
tag = payload[-16:]
decryptor = Cipher(
algorithms.AES(preview.key),
GCM(preview.iv, tag=tag),
backend=default_backend()).decryptor()
return decryptor.update(data) + decryptor.finalize()
|