|
0
|
1 <?php
|
|
|
2
|
|
|
3 /**
|
|
|
4 +-----------------------------------------------------------------------+
|
|
|
5 | This file is part of the Roundcube Webmail client |
|
|
|
6 | Copyright (C) 2005-2012, The Roundcube Dev Team |
|
|
|
7 | Copyright (C) 2011-2012, Kolab Systems AG |
|
|
|
8 | |
|
|
|
9 | Licensed under the GNU General Public License version 3 or |
|
|
|
10 | any later version with exceptions for skins & plugins. |
|
|
|
11 | See the README file for a full license statement. |
|
|
|
12 | |
|
|
|
13 | PURPOSE: |
|
|
|
14 | Image resizer and converter |
|
|
|
15 +-----------------------------------------------------------------------+
|
|
|
16 | Author: Thomas Bruederli <roundcube@gmail.com> |
|
|
|
17 | Author: Aleksander Machniak <alec@alec.pl> |
|
|
|
18 +-----------------------------------------------------------------------+
|
|
|
19 */
|
|
|
20
|
|
|
21 /**
|
|
|
22 * Image resizer and converter
|
|
|
23 *
|
|
|
24 * @package Framework
|
|
|
25 * @subpackage Utils
|
|
|
26 */
|
|
|
27 class rcube_image
|
|
|
28 {
|
|
|
29 private $image_file;
|
|
|
30
|
|
|
31 const TYPE_GIF = 1;
|
|
|
32 const TYPE_JPG = 2;
|
|
|
33 const TYPE_PNG = 3;
|
|
|
34 const TYPE_TIF = 4;
|
|
|
35
|
|
|
36 public static $extensions = array(
|
|
|
37 self::TYPE_GIF => 'gif',
|
|
|
38 self::TYPE_JPG => 'jpg',
|
|
|
39 self::TYPE_PNG => 'png',
|
|
|
40 self::TYPE_TIF => 'tif',
|
|
|
41 );
|
|
|
42
|
|
|
43
|
|
|
44 /**
|
|
|
45 * Class constructor
|
|
|
46 *
|
|
|
47 * @param string $filename Image file name/path
|
|
|
48 */
|
|
|
49 function __construct($filename)
|
|
|
50 {
|
|
|
51 $this->image_file = $filename;
|
|
|
52 }
|
|
|
53
|
|
|
54 /**
|
|
|
55 * Get image properties.
|
|
|
56 *
|
|
|
57 * @return mixed Hash array with image props like type, width, height
|
|
|
58 */
|
|
|
59 public function props()
|
|
|
60 {
|
|
|
61 // use GD extension
|
|
|
62 if (function_exists('getimagesize') && ($imsize = @getimagesize($this->image_file))) {
|
|
|
63 $width = $imsize[0];
|
|
|
64 $height = $imsize[1];
|
|
|
65 $gd_type = $imsize[2];
|
|
|
66 $type = image_type_to_extension($gd_type, false);
|
|
|
67 $channels = $imsize['channels'];
|
|
|
68 }
|
|
|
69
|
|
|
70 // use ImageMagick
|
|
|
71 if (!$type && ($data = $this->identify())) {
|
|
|
72 list($type, $width, $height) = $data;
|
|
|
73 $channels = null;
|
|
|
74 }
|
|
|
75
|
|
|
76 if ($type) {
|
|
|
77 return array(
|
|
|
78 'type' => $type,
|
|
|
79 'gd_type' => $gd_type,
|
|
|
80 'width' => $width,
|
|
|
81 'height' => $height,
|
|
|
82 'channels' => $channels,
|
|
|
83 );
|
|
|
84 }
|
|
|
85
|
|
|
86 return null;
|
|
|
87 }
|
|
|
88
|
|
|
89 /**
|
|
|
90 * Resize image to a given size. Use only to shrink an image.
|
|
|
91 * If an image is smaller than specified size it will be not resized.
|
|
|
92 *
|
|
|
93 * @param int $size Max width/height size
|
|
|
94 * @param string $filename Output filename
|
|
|
95 * @param boolean $browser_compat Convert to image type displayable by any browser
|
|
|
96 *
|
|
|
97 * @return mixed Output type on success, False on failure
|
|
|
98 */
|
|
|
99 public function resize($size, $filename = null, $browser_compat = false)
|
|
|
100 {
|
|
|
101 $result = false;
|
|
|
102 $rcube = rcube::get_instance();
|
|
|
103 $convert = $rcube->config->get('im_convert_path', false);
|
|
|
104 $props = $this->props();
|
|
|
105
|
|
|
106 if (empty($props)) {
|
|
|
107 return false;
|
|
|
108 }
|
|
|
109
|
|
|
110 if (!$filename) {
|
|
|
111 $filename = $this->image_file;
|
|
|
112 }
|
|
|
113
|
|
|
114 // use Imagemagick
|
|
|
115 if ($convert || class_exists('Imagick', false)) {
|
|
|
116 $p['out'] = $filename;
|
|
|
117 $p['in'] = $this->image_file;
|
|
|
118 $type = $props['type'];
|
|
|
119
|
|
|
120 if (!$type && ($data = $this->identify())) {
|
|
|
121 $type = $data[0];
|
|
|
122 }
|
|
|
123
|
|
|
124 $type = strtr($type, array("jpeg" => "jpg", "tiff" => "tif", "ps" => "eps", "ept" => "eps"));
|
|
|
125 $p['intype'] = $type;
|
|
|
126
|
|
|
127 // convert to an image format every browser can display
|
|
|
128 if ($browser_compat && !in_array($type, array('jpg','gif','png'))) {
|
|
|
129 $type = 'jpg';
|
|
|
130 }
|
|
|
131
|
|
|
132 // If only one dimension is greater than the limit convert doesn't
|
|
|
133 // work as expected, we need to calculate new dimensions
|
|
|
134 $scale = $size / max($props['width'], $props['height']);
|
|
|
135
|
|
|
136 // if file is smaller than the limit, we do nothing
|
|
|
137 // but copy original file to destination file
|
|
|
138 if ($scale >= 1 && $p['intype'] == $type) {
|
|
|
139 $result = ($this->image_file == $filename || copy($this->image_file, $filename)) ? '' : false;
|
|
|
140 }
|
|
|
141 else {
|
|
|
142 $valid_types = "bmp,eps,gif,jp2,jpg,png,svg,tif";
|
|
|
143
|
|
|
144 if (in_array($type, explode(',', $valid_types))) { // Valid type?
|
|
|
145 if ($scale >= 1) {
|
|
|
146 $width = $props['width'];
|
|
|
147 $height = $props['height'];
|
|
|
148 }
|
|
|
149 else {
|
|
|
150 $width = intval($props['width'] * $scale);
|
|
|
151 $height = intval($props['height'] * $scale);
|
|
|
152 }
|
|
|
153
|
|
|
154 // use ImageMagick in command line
|
|
|
155 if ($convert) {
|
|
|
156 $p += array(
|
|
|
157 'type' => $type,
|
|
|
158 'quality' => 75,
|
|
|
159 'size' => $width . 'x' . $height,
|
|
|
160 );
|
|
|
161
|
|
|
162 $result = rcube::exec($convert . ' 2>&1 -flatten -auto-orient -colorspace sRGB -strip'
|
|
|
163 . ' -quality {quality} -resize {size} {intype}:{in} {type}:{out}', $p);
|
|
|
164 }
|
|
|
165 // use PHP's Imagick class
|
|
|
166 else {
|
|
|
167 try {
|
|
|
168 $image = new Imagick($this->image_file);
|
|
|
169
|
|
|
170 try {
|
|
|
171 // it throws exception on formats not supporting these features
|
|
|
172 $image->setImageBackgroundColor('white');
|
|
|
173 $image->setImageAlphaChannel(11);
|
|
|
174 $image->mergeImageLayers(Imagick::LAYERMETHOD_FLATTEN);
|
|
|
175 }
|
|
|
176 catch (Exception $e) {
|
|
|
177 // ignore errors
|
|
|
178 }
|
|
|
179
|
|
|
180 $image->setImageColorspace(Imagick::COLORSPACE_SRGB);
|
|
|
181 $image->setImageCompressionQuality(75);
|
|
|
182 $image->setImageFormat($type);
|
|
|
183 $image->stripImage();
|
|
|
184 $image->scaleImage($width, $height);
|
|
|
185
|
|
|
186 if ($image->writeImage($filename)) {
|
|
|
187 $result = '';
|
|
|
188 }
|
|
|
189 }
|
|
|
190 catch (Exception $e) {
|
|
|
191 rcube::raise_error($e, true, false);
|
|
|
192 }
|
|
|
193 }
|
|
|
194 }
|
|
|
195 }
|
|
|
196
|
|
|
197 if ($result === '') {
|
|
|
198 @chmod($filename, 0600);
|
|
|
199 return $type;
|
|
|
200 }
|
|
|
201 }
|
|
|
202
|
|
|
203 // do we have enough memory? (#1489937)
|
|
|
204 if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN' && !$this->mem_check($props)) {
|
|
|
205 return false;
|
|
|
206 }
|
|
|
207
|
|
|
208 // use GD extension
|
|
|
209 if ($props['gd_type']) {
|
|
|
210 if ($props['gd_type'] == IMAGETYPE_JPEG && function_exists('imagecreatefromjpeg')) {
|
|
|
211 $image = imagecreatefromjpeg($this->image_file);
|
|
|
212 $type = 'jpg';
|
|
|
213 }
|
|
|
214 else if ($props['gd_type'] == IMAGETYPE_GIF && function_exists('imagecreatefromgif')) {
|
|
|
215 $image = imagecreatefromgif($this->image_file);
|
|
|
216 $type = 'gif';
|
|
|
217 }
|
|
|
218 else if ($props['gd_type'] == IMAGETYPE_PNG && function_exists('imagecreatefrompng')) {
|
|
|
219 $image = imagecreatefrompng($this->image_file);
|
|
|
220 $type = 'png';
|
|
|
221 }
|
|
|
222 else {
|
|
|
223 // @TODO: print error to the log?
|
|
|
224 return false;
|
|
|
225 }
|
|
|
226
|
|
|
227 if ($image === false) {
|
|
|
228 return false;
|
|
|
229 }
|
|
|
230
|
|
|
231 $scale = $size / max($props['width'], $props['height']);
|
|
|
232
|
|
|
233 // Imagemagick resize is implemented in shrinking mode (see -resize argument above)
|
|
|
234 // we do the same here, if an image is smaller than specified size
|
|
|
235 // we do nothing but copy original file to destination file
|
|
|
236 if ($scale >= 1) {
|
|
|
237 $result = $this->image_file == $filename || copy($this->image_file, $filename);
|
|
|
238 }
|
|
|
239 else {
|
|
|
240 $width = intval($props['width'] * $scale);
|
|
|
241 $height = intval($props['height'] * $scale);
|
|
|
242 $new_image = imagecreatetruecolor($width, $height);
|
|
|
243
|
|
|
244 if ($new_image === false) {
|
|
|
245 return false;
|
|
|
246 }
|
|
|
247
|
|
|
248 // Fix transparency of gif/png image
|
|
|
249 if ($props['gd_type'] != IMAGETYPE_JPEG) {
|
|
|
250 imagealphablending($new_image, false);
|
|
|
251 imagesavealpha($new_image, true);
|
|
|
252 $transparent = imagecolorallocatealpha($new_image, 255, 255, 255, 127);
|
|
|
253 imagefilledrectangle($new_image, 0, 0, $width, $height, $transparent);
|
|
|
254 }
|
|
|
255
|
|
|
256 imagecopyresampled($new_image, $image, 0, 0, 0, 0, $width, $height, $props['width'], $props['height']);
|
|
|
257 $image = $new_image;
|
|
|
258
|
|
|
259 // fix rotation of image if EXIF data exists and specifies rotation (GD strips the EXIF data)
|
|
|
260 if ($this->image_file && $type == 'jpg' && function_exists('exif_read_data')) {
|
|
|
261 $exif = exif_read_data($this->image_file);
|
|
|
262 if ($exif && $exif['Orientation']) {
|
|
|
263 switch ($exif['Orientation']) {
|
|
|
264 case 3:
|
|
|
265 $image = imagerotate($image, 180, 0);
|
|
|
266 break;
|
|
|
267 case 6:
|
|
|
268 $image = imagerotate($image, -90, 0);
|
|
|
269 break;
|
|
|
270 case 8:
|
|
|
271 $image = imagerotate($image, 90, 0);
|
|
|
272 break;
|
|
|
273 }
|
|
|
274 }
|
|
|
275 }
|
|
|
276
|
|
|
277 if ($props['gd_type'] == IMAGETYPE_JPEG) {
|
|
|
278 $result = imagejpeg($image, $filename, 75);
|
|
|
279 }
|
|
|
280 elseif($props['gd_type'] == IMAGETYPE_GIF) {
|
|
|
281 $result = imagegif($image, $filename);
|
|
|
282 }
|
|
|
283 elseif($props['gd_type'] == IMAGETYPE_PNG) {
|
|
|
284 $result = imagepng($image, $filename, 6, PNG_ALL_FILTERS);
|
|
|
285 }
|
|
|
286 }
|
|
|
287
|
|
|
288 if ($result) {
|
|
|
289 @chmod($filename, 0600);
|
|
|
290 return $type;
|
|
|
291 }
|
|
|
292 }
|
|
|
293
|
|
|
294 // @TODO: print error to the log?
|
|
|
295 return false;
|
|
|
296 }
|
|
|
297
|
|
|
298 /**
|
|
|
299 * Convert image to a given type
|
|
|
300 *
|
|
|
301 * @param int $type Destination file type (see class constants)
|
|
|
302 * @param string $filename Output filename (if empty, original file will be used
|
|
|
303 * and filename extension will be modified)
|
|
|
304 *
|
|
|
305 * @return bool True on success, False on failure
|
|
|
306 */
|
|
|
307 public function convert($type, $filename = null)
|
|
|
308 {
|
|
|
309 $rcube = rcube::get_instance();
|
|
|
310 $convert = $rcube->config->get('im_convert_path', false);
|
|
|
311
|
|
|
312 if (!$filename) {
|
|
|
313 $filename = $this->image_file;
|
|
|
314
|
|
|
315 // modify extension
|
|
|
316 if ($extension = self::$extensions[$type]) {
|
|
|
317 $filename = preg_replace('/\.[^.]+$/', '', $filename) . '.' . $extension;
|
|
|
318 }
|
|
|
319 }
|
|
|
320
|
|
|
321 // use ImageMagick in command line
|
|
|
322 if ($convert) {
|
|
|
323 $p['in'] = $this->image_file;
|
|
|
324 $p['out'] = $filename;
|
|
|
325 $p['type'] = self::$extensions[$type];
|
|
|
326
|
|
|
327 $result = rcube::exec($convert . ' 2>&1 -colorspace sRGB -strip -quality 75 {in} {type}:{out}', $p);
|
|
|
328
|
|
|
329 if ($result === '') {
|
|
|
330 chmod($filename, 0600);
|
|
|
331 return true;
|
|
|
332 }
|
|
|
333 }
|
|
|
334
|
|
|
335 // use PHP's Imagick class
|
|
|
336 if (class_exists('Imagick', false)) {
|
|
|
337 try {
|
|
|
338 $image = new Imagick($this->image_file);
|
|
|
339
|
|
|
340 $image->setImageColorspace(Imagick::COLORSPACE_SRGB);
|
|
|
341 $image->setImageCompressionQuality(75);
|
|
|
342 $image->setImageFormat(self::$extensions[$type]);
|
|
|
343 $image->stripImage();
|
|
|
344
|
|
|
345 if ($image->writeImage($filename)) {
|
|
|
346 @chmod($filename, 0600);
|
|
|
347 return true;
|
|
|
348 }
|
|
|
349 }
|
|
|
350 catch (Exception $e) {
|
|
|
351 rcube::raise_error($e, true, false);
|
|
|
352 }
|
|
|
353 }
|
|
|
354
|
|
|
355 // use GD extension (TIFF isn't supported)
|
|
|
356 $props = $this->props();
|
|
|
357
|
|
|
358 // do we have enough memory? (#1489937)
|
|
|
359 if (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN' && !$this->mem_check($props)) {
|
|
|
360 return false;
|
|
|
361 }
|
|
|
362
|
|
|
363 if ($props['gd_type']) {
|
|
|
364 if ($props['gd_type'] == IMAGETYPE_JPEG && function_exists('imagecreatefromjpeg')) {
|
|
|
365 $image = imagecreatefromjpeg($this->image_file);
|
|
|
366 }
|
|
|
367 else if ($props['gd_type'] == IMAGETYPE_GIF && function_exists('imagecreatefromgif')) {
|
|
|
368 $image = imagecreatefromgif($this->image_file);
|
|
|
369 }
|
|
|
370 else if ($props['gd_type'] == IMAGETYPE_PNG && function_exists('imagecreatefrompng')) {
|
|
|
371 $image = imagecreatefrompng($this->image_file);
|
|
|
372 }
|
|
|
373 else {
|
|
|
374 // @TODO: print error to the log?
|
|
|
375 return false;
|
|
|
376 }
|
|
|
377
|
|
|
378 if ($type == self::TYPE_JPG) {
|
|
|
379 $result = imagejpeg($image, $filename, 75);
|
|
|
380 }
|
|
|
381 else if ($type == self::TYPE_GIF) {
|
|
|
382 $result = imagegif($image, $filename);
|
|
|
383 }
|
|
|
384 else if ($type == self::TYPE_PNG) {
|
|
|
385 $result = imagepng($image, $filename, 6, PNG_ALL_FILTERS);
|
|
|
386 }
|
|
|
387
|
|
|
388 if ($result) {
|
|
|
389 @chmod($filename, 0600);
|
|
|
390 return true;
|
|
|
391 }
|
|
|
392 }
|
|
|
393
|
|
|
394 // @TODO: print error to the log?
|
|
|
395 return false;
|
|
|
396 }
|
|
|
397
|
|
|
398 /**
|
|
|
399 * Checks if image format conversion is supported
|
|
|
400 *
|
|
|
401 * @return boolean True if specified format can be converted to another format
|
|
|
402 */
|
|
|
403 public static function is_convertable($mimetype = null)
|
|
|
404 {
|
|
|
405 $rcube = rcube::get_instance();
|
|
|
406
|
|
|
407 // @TODO: check if specified mimetype is really supported
|
|
|
408 return class_exists('Imagick', false) || $rcube->config->get('im_convert_path');
|
|
|
409 }
|
|
|
410
|
|
|
411 /**
|
|
|
412 * ImageMagick based image properties read.
|
|
|
413 */
|
|
|
414 private function identify()
|
|
|
415 {
|
|
|
416 $rcube = rcube::get_instance();
|
|
|
417
|
|
|
418 // use ImageMagick in command line
|
|
|
419 if ($cmd = $rcube->config->get('im_identify_path')) {
|
|
|
420 $args = array('in' => $this->image_file, 'format' => "%m %[fx:w] %[fx:h]");
|
|
|
421 $id = rcube::exec($cmd. ' 2>/dev/null -format {format} {in}', $args);
|
|
|
422
|
|
|
423 if ($id) {
|
|
|
424 return explode(' ', strtolower($id));
|
|
|
425 }
|
|
|
426 }
|
|
|
427
|
|
|
428 // use PHP's Imagick class
|
|
|
429 if (class_exists('Imagick', false)) {
|
|
|
430 try {
|
|
|
431 $image = new Imagick($this->image_file);
|
|
|
432
|
|
|
433 return array(
|
|
|
434 strtolower($image->getImageFormat()),
|
|
|
435 $image->getImageWidth(),
|
|
|
436 $image->getImageHeight(),
|
|
|
437 );
|
|
|
438 }
|
|
|
439 catch (Exception $e) {}
|
|
|
440 }
|
|
|
441 }
|
|
|
442
|
|
|
443 /**
|
|
|
444 * Check if we have enough memory to load specified image
|
|
|
445 */
|
|
|
446 private function mem_check($props)
|
|
|
447 {
|
|
|
448 // image size is unknown, we can't calculate required memory
|
|
|
449 if (!$props['width']) {
|
|
|
450 return true;
|
|
|
451 }
|
|
|
452
|
|
|
453 // channels: CMYK - 4, RGB - 3
|
|
|
454 $multip = ($props['channels'] ?: 3) + 1;
|
|
|
455
|
|
|
456 // calculate image size in memory (in bytes)
|
|
|
457 $size = $props['width'] * $props['height'] * $multip;
|
|
|
458 return rcube_utils::mem_check($size);
|
|
|
459 }
|
|
|
460 }
|
