Merge pull request #402 from CyberDomovoy/Imagick

Imagick

include/Photo.php

@@ -4,6 +4,12 @@ if(! class_exists("Photo")) {
 class Photo {
 
     private $image;
+    private $ext;
+
+    /**
+     * Put back gd stuff, not everybody have Imagick
+     */
+    private $imagick;
     private $width;
     private $height;
     private $valid;
@@ -14,14 +20,37 @@ class Photo {
      * supported mimetypes and corresponding file extensions
      */
     static function supportedTypes() {
+        if(class_exists('Imagick')) {
+            /**
+             * Imagick::queryFormats won't help us a lot there...
+             * At least, not yet, other parts of friendica uses this array
+             */
+            $t = array(
+                'image/jpeg' => 'jpg',
+                'image/png' => 'png',
+                'image/gif' => 'gif'
+            );
+        } else {
             $t = array();
             $t['image/jpeg'] ='jpg';
             if (imagetypes() & IMG_PNG) $t['image/png'] = 'png';
+        }
+
         return $t;
     }
 
-	public function __construct($data, $type="image/jpeg") {
+    public function __construct($data, $type=null) {
+        $this->imagick = class_exists('Imagick');
 
+        if($this->is_imagick()) {
+            $this->image = new Imagick();
+            $this->image->readImageBlob($data);
+
+            // If it is a gif, it may be animated, get it ready for any future operations
+            if($this->image->getFormat() !== "GIF") $this->image = $this->image->coalesceImages();
+
+            $this->ext = strtolower($this->image->getImageFormat());
+        } else {
             $this->types = $this->supportedTypes();
             if (!array_key_exists($type,$this->types)){
                 $type='image/jpeg';
@@ -37,36 +66,95 @@ class Photo {
                 imagesavealpha($this->image, true);
             }
         }
+    }
 
     public function __destruct() {
-		if($this->image)
+        if($this->image) {
+            if($this->is_imagick()) {
+                $this->image->clear();
+                $this->image->destroy();
+                return;
+            }
             imagedestroy($this->image);
         }
+    }
+
+    public function is_imagick() {
+        return $this->imagick;
+    }
 
     public function is_valid() {
+        if($this->is_imagick())
+            return ($this->image !== FALSE);
         return $this->valid;
     }
 
     public function getWidth() {
+        if(!$this->is_valid())
+            return FALSE;
+
+        if($this->is_imagick())
+            return $this->image->getImageWidth();
         return $this->width;
     }
 
     public function getHeight() {
+        if(!$this->is_valid())
+            return FALSE;
+
+        if($this->is_imagick())
+            return $this->image->getImageHeight();
         return $this->height;
     }
 
     public function getImage() {
+        if(!$this->is_valid())
+            return FALSE;
+
+        /* Clean it */
+        if($this->is_imagick()) {
+            $this->image = $this->image->deconstructImages();
+            return $this->image;
+        }
         return $this->image;
     }
 
     public function getType() {
+        if(!$this->is_valid())
+            return FALSE;
+
+        if($this->is_imagick()) {
+            // This should do the trick (see supportedTypes above)
+            return 'image/'. $this->getExt();
+        }
         return $this->type;
     }
+
     public function getExt() {
+        if(!$this->is_valid())
+            return FALSE;
+
+        if($this->is_imagick())
+            return $this->ext;
         return $this->types[$this->type];
     }
 
     public function scaleImage($max) {
+        if(!$this->is_valid())
+            return FALSE;
+
+        if($this->is_imagick()) {
+            /**
+             * If it is not animated, there will be only one iteration here,
+             * so don't bother checking
+             */
+            // Don't forget to go back to the first frame for any further operation
+            $this->image->setFirstIterator();
+            do {
+                $this->image->resizeImage($max, $max, imagick::FILTER_LANCZOS, 1, true);
+            } while ($this->image->nextImage());
+            return;
+        }
 
         $width = $this->width;
         $height = $this->height;
@@ -114,16 +202,38 @@ class Photo {
         $this->image = $dest;
         $this->width  = imagesx($this->image);
         $this->height = imagesy($this->image);
-
     }
 
     public function rotate($degrees) {
+        if(!$this->is_valid())
+            return FALSE;
+
+        if($this->is_imagick()) {
+            $this->image->setFirstIterator();
+            do {
+                $this->image->rotateImage(new ImagickPixel(), $degrees);
+            } while ($this->image->nextImage());
+            return;
+        }
+
         $this->image  = imagerotate($this->image,$degrees,0);
         $this->width  = imagesx($this->image);
         $this->height = imagesy($this->image);
     }
 
     public function flip($horiz = true, $vert = false) {
+        if(!$this->is_valid())
+            return FALSE;
+
+        if($this->is_imagick()) {
+            $this->image->setFirstIterator();
+            do {
+                if($horiz) $this->image->flipImage();
+                if($vert) $this->image->flopImage();
+            } while ($this->image->nextImage());
+            return;
+        }
+
         $w = imagesx($this->image);
         $h = imagesy($this->image);
         $flipped = imagecreate($w, $h);
@@ -143,6 +253,9 @@ class Photo {
     public function orient($filename) {
         // based off comment on http://php.net/manual/en/function.imagerotate.php
 
+        if(!$this->is_valid())
+            return FALSE;
+
         if( (! function_exists('exif_read_data')) || ($this->getType() !== 'image/jpeg') )
             return;
 
@@ -189,6 +302,11 @@ class Photo {
 
 
     public function scaleImageUp($min) {
+        if(!$this->is_valid())
+            return FALSE;
+
+        if($this->is_imagick())
+            return $this->scaleImage($min);
 
         $width = $this->width;
         $height = $this->height;
@@ -236,12 +354,21 @@ class Photo {
         $this->image = $dest;
         $this->width  = imagesx($this->image);
         $this->height = imagesy($this->image);
-
     }
 
 
 
     public function scaleImageSquare($dim) {
+        if(!$this->is_valid())
+            return FALSE;
+
+        if($this->is_imagick()) {
+            $this->image->setFirstIterator();
+            do {
+                $this->image->resizeImage($max, $max, imagick::FILTER_LANCZOS, 1, false);
+            } while ($this->image->nextImage());
+            return;
+        }
 
         $dest = imagecreatetruecolor( $dim, $dim );
         imagealphablending($dest, false);
@@ -257,6 +384,23 @@ class Photo {
 
 
     public function cropImage($max,$x,$y,$w,$h) {
+        if(!$this->is_valid())
+            return FALSE;
+
+        if($this->is_imagick()) {
+            $this->image->setFirstIterator();
+            do {
+                $this->image->cropImage($w, $h, $x, $y);
+                /**
+                 * We need to remove the canva,
+                 * or the image is not resized to the crop:
+                 * http://php.net/manual/en/imagick.cropimage.php#97232
+                 */
+                $this->image->setImagePage(0, 0, 0, 0);
+            } while ($this->image->nextImage());
+            return $this->scaleImage($max);
+        }
+
         $dest = imagecreatetruecolor( $max, $max );
         imagealphablending($dest, false);
         imagesavealpha($dest, true);
@@ -270,41 +414,72 @@ class Photo {
     }
 
     public function saveImage($path) {
-		switch($this->type){
+        if(!$this->is_valid())
-			case "image/png":
+            return FALSE;
-				$quality = get_config('system','png_quality');
-				if((! $quality) || ($quality > 9))
-					$quality = PNG_QUALITY;
-				imagepng($this->image, $path, $quality);
-				break;
-			default:
-				$quality = get_config('system','jpeg_quality');
-				if((! $quality) || ($quality > 100))
-					$quality = JPEG_QUALITY;
-				imagejpeg($this->image,$path,$quality);
-		}
 
+        $string = $this->imageString();
+        file_put_contents($path, $string);
     }
 
     public function imageString() {
-		ob_start();
+        if(!$this->is_valid())
-		switch($this->type){
+            return FALSE;
+
+        $quality = FALSE;
+
+        /**
+         * Hmmm, for Imagick
+         * we should do the conversion/compression at the initialisation i think
+         * This method may be called several times,
+         * and there is no need to do that more than once
+         */
+
+        if(!$this->is_imagick()) ob_start();
+
+        switch($this->getType()){
             case "image/png":
                 $quality = get_config('system','png_quality');
                 if((! $quality) || ($quality > 9))
                     $quality = PNG_QUALITY;
-				imagepng($this->image,NULL, $quality);
+                if($this->is_imagick()) {
+                    /**
+                     * From http://www.imagemagick.org/script/command-line-options.php#quality:
+                     *
+                     * 'For the MNG and PNG image formats, the quality value sets
+                     * the zlib compression level (quality / 10) and filter-type (quality % 10).
+                     * The default PNG "quality" is 75, which means compression level 7 with adaptive PNG filtering,
+                     * unless the image has a color map, in which case it means compression level 7 with no PNG filtering'
+                     */
+                    $quality = $quality * 10;
+                } else imagepng($this->image,NULL, $quality);
+                break;
+            case "image/gif":
+                // We change nothing here, do we?
                 break;
             default:
+                // Convert to jpeg by default
                 $quality = get_config('system','jpeg_quality');
                 if((! $quality) || ($quality > 100))
                     $quality = JPEG_QUALITY;
-
+                if($this->is_imagick())
-				imagejpeg($this->image,NULL,$quality);
+                    $this->image->setImageFormat('jpeg');
+                else imagejpeg($this->image,NULL,$quality);
         }
-		$s = ob_get_contents();
+
+        if($this->is_imagick()) {
+            if($quality !== FALSE) {
+            // Do we need to iterate for animations?
+            $this->image->setImageCompressionQuality($quality);
+            $this->image->stripImage();
+            }
+
+            $string = $this->image->getImagesBlob();
+        } else {
+            $string = ob_get_contents();
             ob_end_clean();
-		return $s;
+        }
+
+        return $string;
     }
 
 
@@ -354,10 +529,10 @@ class Photo {
                 dbesc(datetime_convert()),
                 dbesc(datetime_convert()),
                 dbesc(basename($filename)),
-				dbesc($this->type),
+                dbesc($this->getType()),
                 dbesc($album),
-				intval($this->height),
+                intval($this->getHeight()),
-				intval($this->width),
+                intval($this->getWidth()),
                 dbesc($this->imageString()),
                 intval($scale),
                 intval($profile),
@@ -379,10 +554,10 @@ class Photo {
                 dbesc(datetime_convert()),
                 dbesc(datetime_convert()),
                 dbesc(basename($filename)),
-				dbesc($this->type),
+                dbesc($this->getType()),
                 dbesc($album),
-				intval($this->height),
+                intval($this->getHeight()),
-				intval($this->width),
+                intval($this->getWidth()),
                 dbesc($this->imageString()),
                 intval($scale),
                 intval($profile),
@@ -418,13 +593,23 @@ function guess_image_type($filename, $fromcurl=false) {
             $type = $headers['Content-Type'];
     }
     if (is_null($type)){
+        // Guessing from extension? Isn't that... dangerous?
+        if($this->is_imagick()) {
+            /**
+             * Well, this not much better,
+             * but at least it comes from the data inside the image,
+             * we won't be tricked by a manipulated extension
+             */
+            $image = new Imagick($filename);
+            $type = 'image/'. strtolower($image->getImageFormat());
+        } else {
             $ext = pathinfo($filename, PATHINFO_EXTENSION);
             $types = Photo::supportedTypes();
             $type = "image/jpeg";
             foreach ($types as $m=>$e){
                 if ($ext==$e) $type = $m;
             }
-
+        }
     }
     logger('Photo: guess_image_type: type='.$type, LOGGER_DEBUG);
     return $type;
@@ -451,10 +636,11 @@ function import_profile_photo($photo,$uid,$cid) {
     $filename = basename($photo);
     $img_str = fetch_url($photo,true);
 
+    if($this->is_imagick()) $type = null;
+    else {
         // guess mimetype from headers or filename
         $type = guess_image_type($photo,true);
-
+    }
-	
     $img = new Photo($img_str, $type);
     if($img->is_valid()) {