WordPress.org

Make WordPress Core

Ticket #6821: 6821.9.2.diff

File 6821.9.2.diff, 55.8 KB (added by DH-Shredder, 19 months ago)

Fix Warning for files with no extension, and use trailingslashit. Props markoheijnen.

  • wp-admin/includes/image-edit.php

    diff --git wp-admin/includes/image-edit.php wp-admin/includes/image-edit.php
    index 8185c20..75b6834 100644
    function wp_image_editor($post_id, $msg = false) { 
    197197<?php 
    198198} 
    199199 
    200 function wp_stream_image($image, $mime_type, $post_id) { 
    201         $image = apply_filters('image_save_pre', $image, $post_id); 
    202  
    203         switch ( $mime_type ) { 
    204                 case 'image/jpeg': 
    205                         header('Content-Type: image/jpeg'); 
    206                         return imagejpeg($image, null, 90); 
    207                 case 'image/png': 
    208                         header('Content-Type: image/png'); 
    209                         return imagepng($image); 
    210                 case 'image/gif': 
    211                         header('Content-Type: image/gif'); 
    212                         return imagegif($image); 
    213                 default: 
     200/** 
     201 * Streams image in WP_Image_Editor to browser. 
     202 * Provided for backcompat reasons 
     203 * 
     204 * @param WP_Image_Editor $image 
     205 * @param string $mime_type 
     206 * @param int $post_id 
     207 * @return boolean 
     208 */ 
     209function wp_stream_image( $image, $mime_type, $post_id ) { 
     210        if ( $image instanceof WP_Image_Editor ) { 
     211                $image = apply_filters('image_editor_save_pre', $image, $post_id); 
     212 
     213                if ( is_wp_error( $image->stream( $mime_type ) ) ) 
    214214                        return false; 
     215 
     216                return true; 
     217 
     218    } else { 
     219                _deprecated_argument( __FUNCTION__, '3.5', __( '$image needs to be an WP_Image_Editor object' ) ); 
     220 
     221                $image = apply_filters('image_save_pre', $image, $post_id); 
     222 
     223                switch ( $mime_type ) { 
     224                        case 'image/jpeg': 
     225                                header( 'Content-Type: image/jpeg' ); 
     226                                return imagejpeg( $image, null, 90 ); 
     227                        case 'image/png': 
     228                                header( 'Content-Type: image/png' ); 
     229                                return imagepng( $image ); 
     230                        case 'image/gif': 
     231                                header( 'Content-Type: image/gif' ); 
     232                                return imagegif( $image ); 
     233                        default: 
     234                                return false; 
     235                } 
    215236        } 
    216237} 
    217238 
    218 function wp_save_image_file($filename, $image, $mime_type, $post_id) { 
    219         $image = apply_filters('image_save_pre', $image, $post_id); 
    220         $saved = apply_filters('wp_save_image_file', null, $filename, $image, $mime_type, $post_id); 
    221         if ( null !== $saved ) 
    222                 return $saved; 
    223  
    224         switch ( $mime_type ) { 
    225                 case 'image/jpeg': 
    226                         return imagejpeg( $image, $filename, apply_filters( 'jpeg_quality', 90, 'edit_image' ) ); 
    227                 case 'image/png': 
    228                         return imagepng($image, $filename); 
    229                 case 'image/gif': 
    230                         return imagegif($image, $filename); 
    231                 default: 
    232                         return false; 
     239/** 
     240 * Saves Image to File 
     241 * @TODO: Add mime_type support to WP_Image_Editor 
     242 * 
     243 * @param string $filename 
     244 * @param WP_Image_Editor $image 
     245 * @param string $mime_type 
     246 * @param int $post_id 
     247 * @return boolean 
     248 */ 
     249function wp_save_image_file( $filename, $image, $mime_type, $post_id ) { 
     250        if ( $image instanceof WP_Image_Editor ) { 
     251                $image = apply_filters('image_editor_save_pre', $image, $post_id); 
     252                $saved = apply_filters('wp_save_image_editor_file', null, $filename, $image, $mime_type, $post_id); 
     253 
     254                if ( null !== $saved ) 
     255                        return $saved; 
     256 
     257                return $image->save( $filename, $mime_type ); 
     258        } else { 
     259                _deprecated_argument( __FUNCTION__, '3.5', __( '$image needs to be an WP_Image_Editor object' ) ); 
     260 
     261                $image = apply_filters('image_save_pre', $image, $post_id); 
     262                $saved = apply_filters('wp_save_image_file', null, $filename, $image, $mime_type, $post_id); 
     263 
     264                if ( null !== $saved ) 
     265                        return $saved; 
     266 
     267                switch ( $mime_type ) { 
     268                        case 'image/jpeg': 
     269                                return imagejpeg( $image, $filename, apply_filters( 'jpeg_quality', 90, 'edit_image' ) ); 
     270                        case 'image/png': 
     271                                return imagepng( $image, $filename ); 
     272                        case 'image/gif': 
     273                                return imagegif( $image, $filename ); 
     274                        default: 
     275                                return false; 
     276                } 
    233277        } 
    234278} 
    235279 
    function _image_get_preview_ratio($w, $h) { 
    238282        return $max > 400 ? (400 / $max) : 1; 
    239283} 
    240284 
     285// @TODO: Returns GD resource, but is NOT public 
    241286function _rotate_image_resource($img, $angle) { 
     287        _deprecated_function( __FUNCTION__, '3.5', __( 'Use WP_Image_Editor::rotate' ) ); 
    242288        if ( function_exists('imagerotate') ) { 
    243289                $rotated = imagerotate($img, $angle, 0); 
    244290                if ( is_resource($rotated) ) { 
    function _rotate_image_resource($img, $angle) { 
    249295        return $img; 
    250296} 
    251297 
     298/** 
     299 * @TODO: Only used within image_edit_apply_changes 
     300 *                and receives/returns GD Resource. 
     301 *                Consider removal. 
     302 * 
     303 * @param GD_Resource $img 
     304 * @param boolean $horz 
     305 * @param boolean $vert 
     306 * @return GD_Resource 
     307 */ 
    252308function _flip_image_resource($img, $horz, $vert) { 
     309        _deprecated_function( __FUNCTION__, '3.5', __( 'Use WP_Image_Editor::flip' ) ); 
    253310        $w = imagesx($img); 
    254311        $h = imagesy($img); 
    255312        $dst = wp_imagecreatetruecolor($w, $h); 
    function _flip_image_resource($img, $horz, $vert) { 
    267324        return $img; 
    268325} 
    269326 
     327/** 
     328 * @TODO: Only used within image_edit_apply_changes 
     329 *                and receives/returns GD Resource. 
     330 *                Consider removal. 
     331 * 
     332 * @param GD_Resource $img 
     333 * @param float $x 
     334 * @param float $y 
     335 * @param float $w 
     336 * @param float $h 
     337 * @return GD_Resource 
     338 */ 
    270339function _crop_image_resource($img, $x, $y, $w, $h) { 
    271340        $dst = wp_imagecreatetruecolor($w, $h); 
    272341        if ( is_resource($dst) ) { 
    function _crop_image_resource($img, $x, $y, $w, $h) { 
    278347        return $img; 
    279348} 
    280349 
    281 function image_edit_apply_changes($img, $changes) { 
     350/** 
     351 * Performs group of changes on Editor specified. 
     352 * 
     353 * @param WP_Image_Editor $image 
     354 * @param type $changes 
     355 * @return WP_Image_Editor 
     356 */ 
     357function image_edit_apply_changes( $image, $changes ) { 
     358        if ( is_resource( $image ) ) 
     359                _deprecated_argument( __FUNCTION__, '3.5', __( '$image needs to be an WP_Image_Editor object' ) ); 
    282360 
    283361        if ( !is_array($changes) ) 
    284                 return $img; 
     362                return $image; 
    285363 
    286364        // expand change operations 
    287365        foreach ( $changes as $key => $obj ) { 
    function image_edit_apply_changes($img, $changes) { 
    326404        } 
    327405 
    328406        // image resource before applying the changes 
    329         $img = apply_filters('image_edit_before_change', $img, $changes); 
     407        if ( $image instanceof WP_Image_Editor ) 
     408                $image = apply_filters('wp_image_editor_before_change', $image, $changes); 
     409        elseif ( is_resource( $image ) ) 
     410                $image = apply_filters('image_edit_before_change', $image, $changes); 
    330411 
    331412        foreach ( $changes as $operation ) { 
    332413                switch ( $operation->type ) { 
    333414                        case 'rotate': 
    334                                 if ( $operation->angle != 0 ) 
    335                                         $img = _rotate_image_resource($img, $operation->angle); 
     415                                if ( $operation->angle != 0 ) { 
     416                                        if ( $image instanceof WP_Image_Editor ) 
     417                                                $image->rotate( $operation->angle ); 
     418                                        else 
     419                                                $image = _rotate_image_resource( $image, $operation->angle ); 
     420                                } 
    336421                                break; 
    337422                        case 'flip': 
    338423                                if ( $operation->axis != 0 ) 
    339                                         $img = _flip_image_resource($img, ($operation->axis & 1) != 0, ($operation->axis & 2) != 0); 
     424                                        if ( $image instanceof WP_Image_Editor ) 
     425                                                $image->flip( ($operation->axis & 1) != 0, ($operation->axis & 2) != 0 ); 
     426                                        else 
     427                                                $image = _flip_image_resource( $image, ( $operation->axis & 1 ) != 0, ( $operation->axis & 2 ) != 0 ); 
    340428                                break; 
    341429                        case 'crop': 
    342430                                $sel = $operation->sel; 
    343                                 $scale = 1 / _image_get_preview_ratio( imagesx($img), imagesy($img) ); // discard preview scaling 
    344                                 $img = _crop_image_resource($img, $sel->x * $scale, $sel->y * $scale, $sel->w * $scale, $sel->h * $scale); 
     431 
     432                                if ( $image instanceof WP_Image_Editor ) { 
     433                                        $size = $image->get_size(); 
     434                                        $w = $size['width']; 
     435                                        $h = $size['height']; 
     436 
     437                                        $scale = 1 / _image_get_preview_ratio( $w, $h ); // discard preview scaling 
     438                                        $image->crop( $sel->x * $scale, $sel->y * $scale, $sel->w * $scale, $sel->h * $scale ); 
     439                                } else { 
     440                                        $scale = 1 / _image_get_preview_ratio( imagesx( $image ), imagesy( $image ) ); // discard preview scaling 
     441                                        $image = _crop_image_resource( $image, $sel->x * $scale, $sel->y * $scale, $sel->w * $scale, $sel->h * $scale ); 
     442                                } 
    345443                                break; 
    346444                } 
    347445        } 
    348446 
    349         return $img; 
     447        return $image; 
    350448} 
    351449 
    352 function stream_preview_image($post_id) { 
    353         $post = get_post($post_id); 
     450 
     451/** 
     452 * Streams image in post to browser, along with enqueued changes 
     453 * in $_REQUEST['history'] 
     454 * 
     455 * @param int $post_id 
     456 * @return boolean 
     457 */ 
     458function stream_preview_image( $post_id ) { 
     459        $post = get_post( $post_id ); 
    354460        @ini_set( 'memory_limit', apply_filters( 'admin_memory_limit', WP_MAX_MEMORY_LIMIT ) ); 
    355         $img = load_image_to_edit( $post_id, $post->post_mime_type, array(400, 400) ); 
    356461 
    357         if ( !is_resource($img) ) 
    358                 return false; 
     462        $img = WP_Image_Editor::get_instance( _load_image_to_edit_path( $post_id ) ); 
     463 
     464    if ( is_wp_error( $img ) ) 
     465        return false; 
    359466 
    360467        $changes = !empty($_REQUEST['history']) ? json_decode( stripslashes($_REQUEST['history']) ) : null; 
    361468        if ( $changes ) 
    362                 $img = image_edit_apply_changes($img, $changes); 
     469                $img = image_edit_apply_changes( $img, $changes ); 
    363470 
    364471        // scale the image 
    365         $w = imagesx($img); 
    366         $h = imagesy($img); 
    367         $ratio = _image_get_preview_ratio($w, $h); 
     472        $size = $img->get_size(); 
     473        $w = $size['width']; 
     474        $h = $size['height']; 
     475 
     476        $ratio = _image_get_preview_ratio( $w, $h ); 
    368477        $w2 = $w * $ratio; 
    369478        $h2 = $h * $ratio; 
    370479 
    371         $preview = wp_imagecreatetruecolor($w2, $h2); 
    372         imagecopyresampled( $preview, $img, 0, 0, 0, 0, $w2, $h2, $w, $h ); 
    373         wp_stream_image($preview, $post->post_mime_type, $post_id); 
     480        if ( is_wp_error( $img->resize( $w2, $h2 ) ) ) 
     481                return false; 
    374482 
    375         imagedestroy($preview); 
    376         imagedestroy($img); 
    377         return true; 
     483        return wp_stream_image( $img, $post->post_mime_type, $post_id ); 
    378484} 
    379485 
    380486function wp_restore_image($post_id) { 
    function wp_restore_image($post_id) { 
    450556        return $msg; 
    451557} 
    452558 
    453 function wp_save_image($post_id) { 
     559/** 
     560 * Saves image to post along with enqueued changes 
     561 * in $_REQUEST['history'] 
     562 * 
     563 * @param int $post_id 
     564 * @return \stdClass 
     565 */ 
     566function wp_save_image( $post_id ) { 
    454567        $return = new stdClass; 
    455568        $success = $delete = $scaled = $nocrop = false; 
    456         $post = get_post($post_id); 
    457         @ini_set( 'memory_limit', apply_filters( 'admin_memory_limit', WP_MAX_MEMORY_LIMIT ) ); 
    458         $img = load_image_to_edit($post_id, $post->post_mime_type); 
     569        $post = get_post( $post_id ); 
    459570 
    460         if ( !is_resource($img) ) { 
     571        $img = WP_Image_Editor::get_instance( _load_image_to_edit_path( $post_id, 'full' ) ); 
     572        if ( !$img ) { 
    461573                $return->error = esc_js( __('Unable to create new image.') ); 
    462574                return $return; 
    463575        } 
    function wp_save_image($post_id) { 
    468580        $scale = !empty($_REQUEST['do']) && 'scale' == $_REQUEST['do']; 
    469581 
    470582        if ( $scale && $fwidth > 0 && $fheight > 0 ) { 
    471                 $sX = imagesx($img); 
    472                 $sY = imagesy($img); 
     583                $size = $img->get_size(); 
     584                $sX = $size['width']; 
     585                $sY = $size['height']; 
    473586 
    474587                // check if it has roughly the same w / h ratio 
    475588                $diff = round($sX / $sY, 2) - round($fwidth / $fheight, 2); 
    476589                if ( -0.1 < $diff && $diff < 0.1 ) { 
    477590                        // scale the full size image 
    478                         $dst = wp_imagecreatetruecolor($fwidth, $fheight); 
    479                         if ( imagecopyresampled( $dst, $img, 0, 0, 0, 0, $fwidth, $fheight, $sX, $sY ) ) { 
    480                                 imagedestroy($img); 
    481                                 $img = $dst; 
     591                        if ( $img->resize( $fwidth, $fheight ) ) 
    482592                                $scaled = true; 
    483                         } 
    484593                } 
    485594 
    486595                if ( !$scaled ) { 
    function wp_save_image($post_id) { 
    551660                if ( $tag ) 
    552661                        $backup_sizes[$tag] = array('width' => $meta['width'], 'height' => $meta['height'], 'file' => $path_parts['basename']); 
    553662 
    554                 $success = update_attached_file($post_id, $new_path); 
     663                $success = update_attached_file( $post_id, $new_path ); 
     664 
     665                $meta['file'] = _wp_relative_upload_path( $new_path ); 
    555666 
    556                 $meta['file'] = _wp_relative_upload_path($new_path); 
    557                 $meta['width'] = imagesx($img); 
    558                 $meta['height'] = imagesy($img); 
     667                $size = $img->get_size(); 
     668                $meta['width'] = $size['width']; 
     669                $meta['height'] = $size['height']; 
    559670 
    560671                if ( $success && ('nothumb' == $target || 'all' == $target) ) { 
    561672                        $sizes = get_intermediate_image_sizes(); 
    function wp_save_image($post_id) { 
    570681                $success = $delete = $nocrop = true; 
    571682        } 
    572683 
    573         if ( isset($sizes) ) { 
     684        if ( isset( $sizes ) ) { 
     685                $_sizes = array(); 
     686 
    574687                foreach ( $sizes as $size ) { 
    575688                        $tag = false; 
    576                         if ( isset($meta['sizes'][$size]) ) { 
     689                        if ( isset( $meta['sizes'][$size] ) ) { 
    577690                                if ( isset($backup_sizes["$size-orig"]) ) { 
    578691                                        if ( ( !defined('IMAGE_EDIT_OVERWRITE') || !IMAGE_EDIT_OVERWRITE ) && $backup_sizes["$size-orig"]['file'] != $meta['sizes'][$size]['file'] ) 
    579692                                                $tag = "$size-$suffix"; 
    function wp_save_image($post_id) { 
    586699                        } 
    587700 
    588701                        $crop = $nocrop ? false : get_option("{$size}_crop"); 
    589                         $resized = image_make_intermediate_size($new_path, get_option("{$size}_size_w"), get_option("{$size}_size_h"), $crop ); 
    590  
    591                         if ( $resized ) 
    592                                 $meta['sizes'][$size] = $resized; 
    593                         else 
    594                                 unset($meta['sizes'][$size]); 
     702                        $_sizes[ $size ] = array( 'width' => get_option("{$size}_size_w"), 'height' => get_option("{$size}_size_h"), 'crop' => $crop ); 
    595703                } 
     704 
     705                $meta['sizes'] = $img->multi_resize( $_sizes ); 
    596706        } 
    597707 
     708        unset( $img ); 
     709 
    598710        if ( $success ) { 
    599                 wp_update_attachment_metadata($post_id, $meta); 
     711                wp_update_attachment_metadata( $post_id, $meta ); 
    600712                update_post_meta( $post_id, '_wp_attachment_backup_sizes', $backup_sizes); 
    601713 
    602714                if ( $target == 'thumbnail' || $target == 'all' || $target == 'full' ) { 
    function wp_save_image($post_id) { 
    612724 
    613725        if ( $delete ) { 
    614726                $delpath = apply_filters('wp_delete_file', $new_path); 
    615                 @unlink($delpath); 
     727                @unlink( $delpath ); 
    616728        } 
    617729 
    618         imagedestroy($img); 
    619  
    620730        $return->msg = esc_js( __('Image saved') ); 
    621731        return $return; 
    622732} 
  • wp-admin/includes/image.php

    diff --git wp-admin/includes/image.php wp-admin/includes/image.php
    index c7638cd..2a5123e 100644
     
    2222 * @param string $dst_file Optional. The destination file to write to. 
    2323 * @return string|WP_Error|false New filepath on success, WP_Error or false on failure. 
    2424 */ 
    25 function wp_crop_image( $src, $src_x, $src_y, $src_w, $src_h, $dst_w, $dst_h, $src_abs = false, $dst_file = false ) { 
    26         if ( is_numeric( $src ) ) { // Handle int as attachment ID 
    27                 $src_file = get_attached_file( $src ); 
     25function wp_crop_image( $src_file, $src_x, $src_y, $src_w, $src_h, $dst_w, $dst_h, $src_abs = false, $dst_file = false ) { 
     26        if ( is_numeric( $src_file ) ) { // Handle int as attachment ID 
     27                $src_file = get_attached_file( $src_file ); 
    2828                if ( ! file_exists( $src_file ) ) { 
    2929                        // If the file doesn't exist, attempt a url fopen on the src link. 
    3030                        // This can occur with certain file replication plugins. 
    31                         $post = get_post( $src ); 
    32                         $image_type = $post->post_mime_type; 
    33                         $src = load_image_to_edit( $src, $post->post_mime_type, 'full' ); 
    34                 } else { 
    35                         $size = @getimagesize( $src_file ); 
    36                         $image_type = ( $size ) ? $size['mime'] : ''; 
    37                         $src = wp_load_image( $src_file ); 
     31                        $src_file = _load_image_to_edit_path( $src_file, 'full' ); 
    3832                } 
    39         } else { 
    40                 $size = @getimagesize( $src ); 
    41                 $image_type = ( $size ) ? $size['mime'] : ''; 
    42                 $src = wp_load_image( $src ); 
    43         } 
    44  
    45         if ( ! is_resource( $src ) ) 
    46                 return new WP_Error( 'error_loading_image', $src, $src_file ); 
    47  
    48         $dst = wp_imagecreatetruecolor( $dst_w, $dst_h ); 
    49  
    50         if ( $src_abs ) { 
    51                 $src_w -= $src_x; 
    52                 $src_h -= $src_y; 
    5333        } 
    5434 
    55         if ( function_exists( 'imageantialias' ) ) 
    56                 imageantialias( $dst, true ); 
    57  
    58         imagecopyresampled( $dst, $src, 0, 0, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h ); 
     35        $editor = WP_Image_Editor::get_instance( $src_file ); 
     36        $src = $editor->crop( $src_x, $src_y, $src_w, $src_h, $dst_w, $dst_h, $src_abs ); 
    5937 
    60         imagedestroy( $src ); // Free up memory 
     38        if ( is_wp_error( $src ) ) 
     39                return $src; 
    6140 
    6241        if ( ! $dst_file ) 
    6342                $dst_file = str_replace( basename( $src_file ), 'cropped-' . basename( $src_file ), $src_file ); 
    6443 
    65         if ( 'image/png' != $image_type ) 
    66                 $dst_file = preg_replace( '/\\.[^\\.]+$/', '.jpg', $dst_file ); 
    67  
    6844        // The directory containing the original file may no longer exist when 
    6945        // using a replication plugin. 
    7046        wp_mkdir_p( dirname( $dst_file ) ); 
    7147 
    7248        $dst_file = dirname( $dst_file ) . '/' . wp_unique_filename( dirname( $dst_file ), basename( $dst_file ) ); 
    7349 
    74         if ( 'image/png' == $image_type && imagepng( $dst, $dst_file ) ) 
    75                 return $dst_file; 
    76         elseif ( imagejpeg( $dst, $dst_file, apply_filters( 'jpeg_quality', 90, 'wp_crop_image' ) ) ) 
    77                 return $dst_file; 
    78         else 
    79                 return false; 
     50        $result = $editor->save( $dst_file ); 
     51        return $dst_file; 
    8052} 
    8153 
    8254/** 
    function wp_generate_attachment_metadata( $attachment_id, $file ) { 
    12193 
    12294                $sizes = apply_filters( 'intermediate_image_sizes_advanced', $sizes ); 
    12395 
    124                 foreach ($sizes as $size => $size_data ) { 
    125                         $resized = image_make_intermediate_size( $file, $size_data['width'], $size_data['height'], $size_data['crop'] ); 
    126                         if ( $resized ) 
    127                                 $metadata['sizes'][$size] = $resized; 
    128                 } 
     96                $editor = WP_Image_Editor::get_instance( $file ); 
     97                $metadata['sizes'] = $editor->multi_resize( $sizes ); 
    12998 
    13099                // fetch additional metadata from exif/iptc 
    131100                $image_meta = wp_read_image_metadata( $file ); 
  • new file wp-includes/class-wp-image-editor-gd.php

    diff --git wp-includes/class-wp-image-editor-gd.php wp-includes/class-wp-image-editor-gd.php
    new file mode 100644
    index 0000000..dcfdaae
    - +  
     1<?php 
     2 
     3class WP_Image_Editor_GD extends WP_Image_Editor { 
     4        protected $image = false; // GD Resource 
     5 
     6        function __destruct() { 
     7                if ( $this->image ) { 
     8                        // we don't need the original in memory anymore 
     9                        imagedestroy( $this->image ); 
     10                } 
     11        } 
     12 
     13        /** 
     14         * Checks to see if GD is available. 
     15         * 
     16         * @since 3.5 
     17         * @access protected 
     18         * 
     19         * @return boolean 
     20         */ 
     21        public static function test() { 
     22                if ( ! extension_loaded('gd') || ! function_exists('gd_info') ) 
     23                        return false; 
     24 
     25                return true; 
     26        } 
     27 
     28        /** 
     29         * Loads image from $this->file into GD Resource 
     30         * 
     31         * @since 3.5 
     32         * @access protected 
     33         * 
     34         * @return boolean|\WP_Error 
     35         */ 
     36        protected function load() { 
     37                if ( $this->image ) 
     38                        return true; 
     39 
     40                if ( ! file_exists( $this->file ) ) 
     41                        return new WP_Error( 'error_loading_image', __('File doesn&#8217;t exist?'), $this->file ); 
     42 
     43                // Set artificially high because GD uses uncompressed images in memory 
     44                @ini_set( 'memory_limit', apply_filters( 'image_memory_limit', WP_MAX_MEMORY_LIMIT ) ); 
     45                $this->image = @imagecreatefromstring( file_get_contents( $this->file ) ); 
     46 
     47                if ( ! is_resource( $this->image ) ) 
     48                        return new WP_Error( 'invalid_image', __('File is not an image.'), $this->file ); 
     49 
     50                $size = @getimagesize( $this->file ); 
     51                if ( ! $size ) 
     52                        return new WP_Error( 'invalid_image', __('Could not read image size.'), $this->file ); 
     53 
     54                $this->update_size( $size[0], $size[1] ); 
     55                $this->mime_type = $size['mime']; 
     56 
     57                return true; 
     58        } 
     59 
     60        /** 
     61         * Sets or updates current image size 
     62         * 
     63         * @since 3.5.0 
     64         * @access protected 
     65         * 
     66         * @param int $width 
     67         * @param int $height 
     68         */ 
     69        protected function update_size( $width = false, $height = false ) { 
     70                if ( ! $width ) 
     71                        $width = imagesx( $this->image ); 
     72 
     73                if ( ! $height ) 
     74                        $height = imagesy( $this->image ); 
     75 
     76                return parent::update_size( $width, $height ); 
     77        } 
     78 
     79        /** 
     80         * Checks to see if editor supports mime-type specified 
     81         * 
     82         * @since 3.5.0 
     83         * @access public 
     84         * 
     85         * @param string $mime_type 
     86         * @return boolean 
     87         */ 
     88        public static function supports_mime_type( $mime_type ) { 
     89                $allowed_mime_types = array( 'image/gif', 'image/png', 'image/jpeg' ); 
     90 
     91                return in_array( $mime_type, $allowed_mime_types ); 
     92        } 
     93 
     94        /** 
     95         * Resizes current image. 
     96         * Wrapper around _resize, since _resize returns a GD Resource 
     97         * 
     98         * @param int $max_w 
     99         * @param int $max_h 
     100         * @param boolean $crop 
     101         * @return boolean|WP_Error 
     102         */ 
     103        public function resize( $max_w, $max_h, $crop = false ) { 
     104                if ( ( $this->size['width'] == $max_w ) && ( $this->size['height'] == $max_h ) ) 
     105                        return true; 
     106 
     107                $resized = $this->_resize( $max_w, $max_h, $crop ); 
     108 
     109                if ( is_resource( $resized ) ) { 
     110                        imagedestroy( $this->image ); 
     111                        $this->image = $resized; 
     112                        return true; 
     113 
     114                } elseif ( is_wp_error( $resized ) ) 
     115                        return $resized; 
     116 
     117                return new WP_Error( 'image_resize_error', __('Image resize failed.'), $this->file ); 
     118        } 
     119 
     120        protected function _resize( $max_w, $max_h, $crop = false ) { 
     121                $dims = image_resize_dimensions( $this->size['width'], $this->size['height'], $max_w, $max_h, $crop ); 
     122                if ( ! $dims ) { 
     123                        return new WP_Error( 'error_getting_dimensions', __('Could not calculate resized image dimensions'), $this->file ); 
     124                } 
     125                list( $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h ) = $dims; 
     126 
     127                $resized = wp_imagecreatetruecolor( $dst_w, $dst_h ); 
     128                imagecopyresampled( $resized, $this->image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h ); 
     129 
     130                if ( is_resource( $resized ) ) { 
     131                        $this->update_size( $dst_w, $dst_h ); 
     132                        return $resized; 
     133                } 
     134 
     135                return WP_Error( 'image_resize_error', __('Image resize failed.'), $this->file ); 
     136        } 
     137 
     138        /** 
     139         * Processes current image and saves to disk 
     140         * multiple sizes from single source. 
     141         * 
     142         * @param array $sizes { {width, height}, ... } 
     143         * @return array 
     144         */ 
     145        public function multi_resize( $sizes ) { 
     146                $metadata = array(); 
     147                $orig_size = $this->size; 
     148 
     149                foreach ( $sizes as $size => $size_data ) { 
     150                        $image = $this->_resize( $size_data['width'], $size_data['height'], $size_data['crop'] ); 
     151 
     152                        if( ! is_wp_error( $image ) ) { 
     153                                $resized = $this->_save( $image ); 
     154 
     155                                imagedestroy( $image ); 
     156                                unset( $resized['path'] ); 
     157 
     158                                if ( ! is_wp_error( $resized ) && $resized ) 
     159                                        $metadata[$size] = $resized; 
     160                        } 
     161 
     162                        $this->size = $orig_size; 
     163                } 
     164 
     165                return $metadata; 
     166        } 
     167 
     168        /** 
     169         * Crops Image. 
     170         * 
     171         * @param float $x 
     172         * @param float $y 
     173         * @param float $w 
     174         * @param float $h 
     175         * @return boolean 
     176         */ 
     177        public function crop( $src_x, $src_y, $src_w, $src_h, $dst_w = null, $dst_h = null, $src_abs = false ) { 
     178                // If destination width/height isn't specified, use same as 
     179                // width/height from source. 
     180                if ( ! $dst_w ) 
     181                        $dst_w = $src_w; 
     182                if ( ! $dst_h ) 
     183                        $dst_h = $src_h; 
     184 
     185                $dst = wp_imagecreatetruecolor( $dst_w, $dst_h ); 
     186 
     187                if ( $src_abs ) { 
     188                        $src_w -= $src_x; 
     189                        $src_h -= $src_y; 
     190                } 
     191 
     192                if ( function_exists( 'imageantialias' ) ) 
     193                        imageantialias( $dst, true ); 
     194 
     195                imagecopyresampled( $dst, $this->image, 0, 0, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h ); 
     196 
     197                if ( is_resource( $dst ) ) { 
     198                        imagedestroy( $this->image ); 
     199                        $this->image = $dst; 
     200                        $this->update_size( $dst_w, $dst_h ); 
     201                        return true; 
     202                } 
     203 
     204                return WP_Error( 'image_crop_error', __('Image crop failed.'), $this->file ); 
     205        } 
     206 
     207        /** 
     208         * Rotates current image counter-clockwise by $angle. 
     209         * Ported from image-edit.php 
     210         * 
     211         * @since 3.5.0 
     212         * @access public 
     213         * 
     214         * @param float $angle 
     215         * @return boolean|WP_Error 
     216         */ 
     217        public function rotate( $angle ) { 
     218                if ( function_exists('imagerotate') ) { 
     219                        $rotated = imagerotate( $this->image, $angle, 0 ); 
     220 
     221                        if ( is_resource( $rotated ) ) { 
     222                                imagedestroy( $this->image ); 
     223                                $this->image = $rotated; 
     224                                $this->update_size(); 
     225                                return true; 
     226                        } 
     227                } 
     228                return WP_Error( 'image_rotate_error', __('Image rotate failed.'), $this->file ); 
     229        } 
     230 
     231        /** 
     232         * Flips current image 
     233         * 
     234         * @param boolean $horz Horizonal Flip 
     235         * @param boolean $vert Vertical Flip 
     236         * @returns boolean|WP_Error 
     237         */ 
     238        public function flip( $horz, $vert ) { 
     239                $w = $this->size['width']; 
     240                $h = $this->size['height']; 
     241                $dst = wp_imagecreatetruecolor( $w, $h ); 
     242 
     243                if ( is_resource( $dst ) ) { 
     244                        $sx = $vert ? ($w - 1) : 0; 
     245                        $sy = $horz ? ($h - 1) : 0; 
     246                        $sw = $vert ? -$w : $w; 
     247                        $sh = $horz ? -$h : $h; 
     248 
     249                        if ( imagecopyresampled( $dst, $this->image, 0, 0, $sx, $sy, $w, $h, $sw, $sh ) ) { 
     250                                imagedestroy( $this->image ); 
     251                                $this->image = $dst; 
     252                                return true; 
     253                        } 
     254                } 
     255                return WP_Error( 'image_flip_error', __('Image flip failed.'), $this->file ); 
     256        } 
     257 
     258        /** 
     259         * Saves current in-memory image to file 
     260         * 
     261         * @param string $destfilename 
     262         * @param string $mime_type 
     263         * @return array|WP_Error {'path'=>string, 'file'=>string, 'width'=>int, 'height'=>int, 'mime-type'=>string} 
     264         */ 
     265        public function save( $filename = null, $mime_type = null ) { 
     266                $saved = $this->_save( $this->image, $filename, $mime_type ); 
     267 
     268                if ( ! is_wp_error( $saved ) ) { 
     269                        $this->file = $saved['path']; 
     270                        $this->mime_type = $saved['mime-type']; 
     271                } 
     272 
     273                return $saved; 
     274        } 
     275 
     276        protected function _save( $image, $filename = null, $mime_type = null ) { 
     277                list( $filename, $extension, $mime_type ) = $this->get_output_format( $filename, $mime_type ); 
     278 
     279                if ( ! $filename ) 
     280                        $filename = $this->generate_filename( null, null, $extension ); 
     281 
     282                if ( 'image/gif' == $mime_type ) { 
     283                        if ( ! $this->make_image( $filename, 'imagegif', array( $image, $filename ) ) ) 
     284                                return new WP_Error( 'image_save_error', __('Image Editor Save Failed') ); 
     285                } 
     286                elseif ( 'image/png' == $mime_type ) { 
     287                        // convert from full colors to index colors, like original PNG. 
     288                        if ( function_exists('imageistruecolor') && ! imageistruecolor( $image ) ) 
     289                                imagetruecolortopalette( $image, false, imagecolorstotal( $image ) ); 
     290 
     291                        if ( ! $this->make_image( $filename, 'imagepng', array( $image, $filename ) ) ) 
     292                                return new WP_Error( 'image_save_error', __('Image Editor Save Failed') ); 
     293                } 
     294                elseif ( 'image/jpeg' == $mime_type ) { 
     295                        if ( ! $this->make_image( $filename, 'imagejpeg', array( $image, $filename, apply_filters( 'jpeg_quality', $this->quality, 'image_resize' ) ) ) ) 
     296                                return new WP_Error( 'image_save_error', __('Image Editor Save Failed') ); 
     297                } 
     298                else { 
     299                        return new WP_Error( 'image_save_error', __('Image Editor Save Failed') ); 
     300                } 
     301 
     302                // Set correct file permissions 
     303                $stat = stat( dirname( $filename ) ); 
     304                $perms = $stat['mode'] & 0000666; //same permissions as parent folder, strip off the executable bits 
     305                @ chmod( $filename, $perms ); 
     306 
     307                return array( 
     308                        'path' => $filename, 
     309                        'file' => wp_basename( apply_filters( 'image_make_intermediate_size', $filename ) ), 
     310                        'width' => $this->size['width'], 
     311                        'height' => $this->size['height'], 
     312                        'mime-type'=> $mime_type, 
     313                ); 
     314        } 
     315 
     316        /** 
     317         * Returns stream of current image 
     318         * 
     319         * @param string $mime_type 
     320         */ 
     321        public function stream( $mime_type = null ) { 
     322                list( $filename, $extension, $mime_type ) = $this->get_output_format( null, $mime_type ); 
     323 
     324                switch ( $mime_type ) { 
     325                        case 'image/png': 
     326                                header( 'Content-Type: image/png' ); 
     327                                return imagepng( $this->image ); 
     328                        case 'image/gif': 
     329                                header( 'Content-Type: image/gif' ); 
     330                                return imagegif( $this->image ); 
     331                        default: 
     332                                header( 'Content-Type: image/jpeg' ); 
     333                                return imagejpeg( $this->image, null, $this->quality ); 
     334                } 
     335        } 
     336} 
     337 No newline at end of file 
  • new file wp-includes/class-wp-image-editor-imagick.php

    diff --git wp-includes/class-wp-image-editor-imagick.php wp-includes/class-wp-image-editor-imagick.php
    new file mode 100644
    index 0000000..cd69608
    - +  
     1<?php 
     2 
     3class WP_Image_Editor_Imagick extends WP_Image_Editor { 
     4        protected $image = null; // Imagick Object 
     5 
     6        function __destruct() { 
     7                if ( $this->image ) { 
     8                        // we don't need the original in memory anymore 
     9                        $this->image->clear(); 
     10                        $this->image->destroy(); 
     11                } 
     12        } 
     13 
     14        /** 
     15         * Checks to see if current environment supports Imagick 
     16         * 
     17         * @since 3.5.0 
     18         * @access protected 
     19         * 
     20         * @return boolean 
     21         */ 
     22        public static function test() { 
     23                if ( ! extension_loaded( 'imagick' ) ) 
     24                        return false; 
     25 
     26                return true; 
     27        } 
     28 
     29        /** 
     30         * Load image in $this->file into new Imagick Object 
     31         * 
     32         * @since 3.5.0 
     33         * @access protected 
     34         * 
     35         * @return boolean|WP_Error True if loaded; WP_Error on failure. 
     36         */ 
     37        protected function load() { 
     38                if ( $this->image ) 
     39                        return true; 
     40 
     41                if ( ! file_exists( $this->file ) ) 
     42                        return new WP_Error( 'error_loading_image', __('File doesn&#8217;t exist?'), $this->file ); 
     43 
     44                try { 
     45                        $this->image = new Imagick( $this->file ); 
     46 
     47                        if( ! $this->image->valid() ) 
     48                                return new WP_Error( 'invalid_image', __('File is not an image.'), $this->file); 
     49 
     50                        // Select the first frame to handle animated GIFs properly 
     51                        $this->image->setIteratorIndex(0); 
     52                        $this->mime_type = $this->get_mime_type( $this->image->getImageFormat() ); 
     53                } 
     54                catch ( Exception $e ) { 
     55                        return new WP_Error( 'invalid_image', $e->getMessage(), $this->file ); 
     56                } 
     57 
     58                $updated_size = $this->update_size(); 
     59                if ( is_wp_error( $updated_size ) ) 
     60                                return $updated_size; 
     61 
     62                return $this->set_quality(); 
     63        } 
     64 
     65        /** 
     66         * Sets Image Compression quality on a 1-100% scale. 
     67         * 
     68         * @since 3.5.0 
     69         * @access public 
     70         * 
     71         * @param int $quality Compression Quality. Range: [1,100] 
     72         * @return boolean|WP_Error 
     73         */ 
     74        public function set_quality( $quality = null ) { 
     75                if ( !$quality ) 
     76                        $quality = $this->quality; 
     77 
     78                try { 
     79                        if( 'image/jpeg' == $this->mime_type ) { 
     80                                $this->image->setImageCompressionQuality( apply_filters( 'jpeg_quality', $quality, 'image_resize' ) ); 
     81                                $this->image->setImageCompression( imagick::COMPRESSION_JPEG ); 
     82                        } 
     83                        else { 
     84                                $this->image->setImageCompressionQuality( $quality ); 
     85                        } 
     86                } 
     87                catch ( Exception $e ) { 
     88                        return new WP_Error( 'image_quality_error', $e->getMessage() ); 
     89                } 
     90 
     91                return parent::set_quality( $quality ); 
     92        } 
     93 
     94        /** 
     95         * Sets or updates current image size 
     96         * 
     97         * @since 3.5.0 
     98         * @access protected 
     99         * 
     100         * @param int $width 
     101         * @param int $height 
     102         */ 
     103        protected function update_size( $width = null, $height = null ) { 
     104                $size = null; 
     105                if ( !$width || !$height ) { 
     106                        try { 
     107                                $size = $this->image->getImageGeometry(); 
     108                        } 
     109                        catch ( Exception $e ) { 
     110                                return new WP_Error( 'invalid_image', __('Could not read image size'), $this->file ); 
     111                        } 
     112                } 
     113 
     114                if ( ! $width ) 
     115                        $width = $size['width']; 
     116 
     117                if ( ! $height ) 
     118                        $height = $size['height']; 
     119 
     120                return parent::update_size( $width, $height ); 
     121        } 
     122 
     123        /** 
     124         * Checks to see if editor supports mime-type specified 
     125         * 
     126         * @since 3.5.0 
     127         * @access public 
     128         * 
     129         * @param string $mime_type 
     130         * @return boolean 
     131         */ 
     132        public static function supports_mime_type( $mime_type = null ) { 
     133                if ( ! $mime_type ) 
     134                        return false; 
     135 
     136                $imagick_extension = strtoupper( self::get_extension( $mime_type ) ); 
     137 
     138                try { 
     139                        return ( (bool) Imagick::queryFormats( $imagick_extension ) ); 
     140                } 
     141                catch ( Exception $e ) { 
     142                        return false; 
     143                } 
     144        } 
     145 
     146        /** 
     147         * Resizes current image. 
     148         * 
     149         * @param int $max_w 
     150         * @param int $max_h 
     151         * @param boolean $crop 
     152         * @return boolean|WP_Error 
     153         */ 
     154        public function resize( $max_w, $max_h, $crop = false ) { 
     155                if ( ( $this->size['width'] == $max_w ) && ( $this->size['height'] == $max_h ) ) 
     156                        return true; 
     157 
     158                $dims = image_resize_dimensions( $this->size['width'], $this->size['height'], $max_w, $max_h, $crop ); 
     159                if ( ! $dims ) 
     160                        return new WP_Error( 'error_getting_dimensions', __('Could not calculate resized image dimensions') ); 
     161                list( $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h ) = $dims; 
     162 
     163                if ( $crop ) { 
     164                        return $this->crop( $src_x, $src_y, $src_w, $src_h, $dst_w, $dst_h ); 
     165                } 
     166 
     167                try { 
     168                        /** 
     169                         * @TODO: Thumbnail is more efficient, given a newer version of Imagemagick. 
     170                         * $this->image->thumbnailImage( $dst_w, $dst_h ); 
     171                         */ 
     172                        $this->image->scaleImage( $dst_w, $dst_h ); 
     173                } 
     174                catch ( Exception $e ) { 
     175                        return new WP_Error( 'image_resize_error', $e->getMessage() ); 
     176                } 
     177 
     178                return $this->update_size( $dst_w, $dst_h ); 
     179        } 
     180 
     181        /** 
     182         * Processes current image and saves to disk 
     183         * multiple sizes from single source. 
     184         * 
     185         * @param array $sizes 
     186         * @return array 
     187         */ 
     188        public function multi_resize( $sizes ) { 
     189                $metadata = array(); 
     190                $orig_size = $this->size; 
     191                $orig_image = $this->image->getImage(); 
     192 
     193                foreach ( $sizes as $size => $size_data ) { 
     194                        if ( ! $this->image ) 
     195                                $this->image = $orig_image->getImage(); 
     196 
     197                        $resize_result = $this->resize( $size_data['width'], $size_data['height'], $size_data['crop'] ); 
     198 
     199                        if( ! is_wp_error( $resize_result ) ) { 
     200                                $resized = $this->_save( $this->image ); 
     201 
     202                                $this->image->clear(); 
     203                                $this->image->destroy(); 
     204                                $this->image = null; 
     205                                unset( $resized['path'] ); 
     206 
     207                                if ( ! is_wp_error( $resized ) && $resized ) 
     208                                        $metadata[$size] = $resized; 
     209                        } 
     210 
     211                        $this->size = $orig_size; 
     212                } 
     213 
     214                $this->image = $orig_image; 
     215 
     216                return $metadata; 
     217        } 
     218 
     219        /** 
     220         * Crops image. 
     221         * 
     222         * @param float $x 
     223         * @param float $y 
     224         * @param float $w 
     225         * @param float $h 
     226         * @return boolean 
     227         */ 
     228        public function crop( $src_x, $src_y, $src_w, $src_h, $dst_w = null, $dst_h = null, $src_abs = false ) { 
     229                // Not sure this is compatible. 
     230                if ( $src_abs ) { 
     231                        $src_w -= $src_x; 
     232                        $src_h -= $src_y; 
     233                } 
     234 
     235                try { 
     236                        $this->image->cropImage( $src_w, $src_h, $src_x, $src_y ); 
     237                        $this->image->setImagePage( $src_w, $src_h, 0, 0); 
     238 
     239                        if ( $dst_w || $dst_h ) { 
     240                                // If destination width/height isn't specified, use same as 
     241                                // width/height from source. 
     242                                if ( ! $dst_w ) 
     243                                        $dst_w = $src_w; 
     244                                if ( ! $dst_h ) 
     245                                        $dst_h = $src_h; 
     246 
     247                                $this->image->scaleImage( $dst_w, $dst_h ); 
     248                                return $this->update_size( $dst_w, $dst_h ); 
     249                        } 
     250                } 
     251                catch ( Exception $e ) { 
     252                        return new WP_Error( 'image_crop_error', $e->getMessage() ); 
     253                } 
     254                return $this->update_size( $src_w, $src_h ); 
     255        } 
     256 
     257        /** 
     258         * Rotates current image counter-clockwise by $angle. 
     259         * 
     260         * @since 3.5.0 
     261         * @access public 
     262         * 
     263         * @param float $angle 
     264         * @return boolean|WP_Error 
     265         */ 
     266        public function rotate( $angle ) { 
     267                /** 
     268                 * $angle is 360-$angle because Imagick rotates clockwise 
     269                 * (GD rotates counter-clockwise) 
     270                 */ 
     271                try { 
     272                        $this->image->rotateImage( new ImagickPixel('none'), 360-$angle ); 
     273                } 
     274                catch ( Exception $e ) { 
     275                        return new WP_Error( 'image_rotate_error', $e->getMessage() ); 
     276                } 
     277                return $this->update_size(); 
     278        } 
     279 
     280        /** 
     281         * Flips current image 
     282         * 
     283         * @since 3.5.0 
     284         * @access public 
     285         * 
     286         * @param boolean $horz Horizontal Flip 
     287         * @param boolean $vert Vertical Flip 
     288         * @returns boolean 
     289         */ 
     290        public function flip( $horz, $vert ) { 
     291                try { 
     292                        if ( $horz ) 
     293                                $this->image->flipImage(); 
     294 
     295                        if ( $vert ) 
     296                                $this->image->flopImage(); 
     297                } 
     298                catch ( Exception $e ) { 
     299                        return new WP_Error( 'image_flip_error', $e->getMessage() ); 
     300                } 
     301                return true; 
     302        } 
     303 
     304        /** 
     305         * Saves current image to file 
     306         * 
     307         * @param string $destfilename 
     308         * @param string $mime_type 
     309         * @return array|WP_Error {'path'=>string, 'file'=>string, 'width'=>int, 'height'=>int, 'mime-type'=>string} 
     310         */ 
     311        public function save( $destfilename = null, $mime_type = null ) { 
     312                $saved = $this->_save( $this->image, $destfilename, $mime_type ); 
     313 
     314                if ( ! is_wp_error( $saved ) ) { 
     315                        $this->file = $saved['path']; 
     316                        $this->mime_type = $saved['mime-type']; 
     317 
     318                        try { 
     319                                $this->image->setImageFormat( strtoupper( $this->get_extension( $this->mime_type ) ) ); 
     320                        } 
     321                        catch ( Exception $e ) { 
     322                                return new WP_Error( 'image_save_error', $e->getMessage(), $this->file ); 
     323                        } 
     324                } 
     325 
     326                return $saved; 
     327        } 
     328 
     329        protected function _save( $image, $filename = null, $mime_type = null ) { 
     330                list( $filename, $extension, $mime_type ) = $this->get_output_format( $filename, $mime_type ); 
     331 
     332                if ( ! $filename ) 
     333                        $filename = $this->generate_filename( null, null, $extension ); 
     334 
     335                try { 
     336                        // Store initial Format 
     337                        $orig_format = $this->image->getImageFormat(); 
     338 
     339                        $this->image->setImageFormat( strtoupper( $this->get_extension( $mime_type ) ) ); 
     340                        $this->make_image( $filename, array( $image, 'writeImage' ), array( $filename ) ); 
     341 
     342                        // Reset original Format 
     343                        $this->image->setImageFormat( $orig_format ); 
     344                } 
     345                catch ( Exception $e ) { 
     346                        return new WP_Error( 'image_save_error', $e->getMessage(), $filename ); 
     347                } 
     348 
     349                // Set correct file permissions 
     350                $stat = stat( dirname( $filename ) ); 
     351                $perms = $stat['mode'] & 0000666; //same permissions as parent folder, strip off the executable bits 
     352                @ chmod( $filename, $perms ); 
     353 
     354                return array( 
     355                        'path' => $filename, 
     356                        'file' => wp_basename( apply_filters( 'image_make_intermediate_size', $filename ) ), 
     357                        'width' => $this->size['width'], 
     358                        'height' => $this->size['height'], 
     359                        'mime-type' => $mime_type, 
     360                ); 
     361        } 
     362 
     363        /** 
     364         * Streams current image to browser 
     365         * 
     366         * @param string $mime_type 
     367         * @return boolean|WP_Error 
     368         */ 
     369        public function stream( $mime_type = null ) { 
     370                list( $filename, $extension, $mime_type ) = $this->get_output_format( null, $mime_type ); 
     371 
     372                try { 
     373                        // Temporarily change format for stream 
     374                        $this->image->setImageFormat( strtoupper( $extension ) ); 
     375 
     376                        // Output stream of image content 
     377                        header( "Content-Type: $mime_type" ); 
     378                        print $this->image->getImageBlob(); 
     379 
     380                        // Reset Image to original Format 
     381                        $this->image->setImageFormat( $this->get_extension( $this->mime_type ) ); 
     382                } 
     383                catch ( Exception $e ) { 
     384                        return new WP_Error( 'image_stream_error', $e->getMessage() ); 
     385                } 
     386 
     387                return true; 
     388        } 
     389} 
     390 No newline at end of file 
  • new file wp-includes/class-wp-image-editor.php

    diff --git wp-includes/class-wp-image-editor.php wp-includes/class-wp-image-editor.php
    new file mode 100644
    index 0000000..515b45e
    - +  
     1<?php 
     2 
     3abstract class WP_Image_Editor { 
     4        protected $file = null; 
     5        protected $size = null; 
     6        protected $mime_type  = null; 
     7        protected $default_mime_type = 'image/jpeg'; 
     8        protected $quality = 90; 
     9        private static $implementation; 
     10 
     11        protected function __construct( $filename ) { 
     12                $this->file = $filename; 
     13        } 
     14 
     15        /** 
     16         * Returns a WP_Image_Editor instance and loads file into it. 
     17         * 
     18         * @since 3.5.0 
     19         * @access public 
     20         * 
     21         * @param string $path Path to File to Load 
     22         * @return WP_Image_Editor|WP_Error|boolean 
     23         */ 
     24        public final static function get_instance( $path = null ) { 
     25                $implementation = apply_filters( 'image_editor_class', self::choose_implementation(), $path ); 
     26 
     27                if ( $implementation ) { 
     28                        $editor = new $implementation( $path ); 
     29                        $loaded = $editor->load(); 
     30 
     31                        if ( is_wp_error ( $loaded ) ) 
     32                                return $loaded; 
     33 
     34                        return $editor; 
     35                } 
     36 
     37                return false; 
     38        } 
     39 
     40        /** 
     41         * Tests which editors are capable of supporting the request. 
     42         * 
     43         * @since 3.5.0 
     44         * @access private 
     45         * 
     46         * @return string|bool Class name for the first editor that claims to support the request. False if no editor claims to support the request. 
     47         */ 
     48        private final static function choose_implementation() { 
     49 
     50                if ( null === self::$implementation ) { 
     51                        $request_order = apply_filters( 'wp_editors', array( 'imagick', 'gd' ) ); 
     52 
     53                        // Loop over each editor on each request looking for one which will serve this request's needs 
     54                        foreach ( $request_order as $editor ) { 
     55                                $class = 'WP_Image_Editor_' . $editor; 
     56 
     57                                // Check to see if this editor is a possibility, calls the editor statically 
     58                                if ( ! call_user_func( array( $class, 'test' ) ) ) 
     59                                        continue; 
     60 
     61                                self::$implementation = $class; 
     62                                break; 
     63                        } 
     64                } 
     65                return self::$implementation; 
     66        } 
     67 
     68        abstract public static function test(); // returns bool 
     69        abstract protected function load(); // returns bool|WP_Error 
     70        abstract public static function supports_mime_type( $mime_type ); // returns bool 
     71        abstract public function resize( $max_w, $max_h, $crop = false ); 
     72        abstract public function multi_resize( $sizes ); 
     73        abstract public function crop( $src_x, $src_y, $src_w, $src_h, $dst_w = null, $dst_h = null, $src_abs = false ); 
     74        abstract public function rotate( $angle ); 
     75        abstract public function flip( $horz, $vert ); 
     76        abstract public function save( $destfilename = null, $mime_type = null ); 
     77        abstract public function stream( $mime_type = null ); 
     78 
     79        /** 
     80         * Gets dimensions of image 
     81         * 
     82         * @since 3.5.0 
     83         * @access public 
     84         * 
     85         * @return array {'width'=>int, 'height'=>int} 
     86         */ 
     87        public function get_size() { 
     88                return $this->size; 
     89        } 
     90 
     91        /** 
     92         * Sets current image size 
     93         * 
     94         * @since 3.5.0 
     95         * @access protected 
     96         * 
     97         * @param int $width 
     98         * @param int $height 
     99         */ 
     100        protected function update_size( $width = null, $height = null ) { 
     101                $this->size = array( 
     102                        'width' => $width, 
     103                        'height' => $height 
     104                ); 
     105                return true; 
     106        } 
     107 
     108        /** 
     109         * Sets Image Compression quality on a 1-100% scale. 
     110         * 
     111         * @since 3.5.0 
     112         * @access public 
     113         * 
     114         * @param int $quality Compression Quality. Range: [1,100] 
     115         * @return boolean 
     116         */ 
     117        public function set_quality( $quality ) { 
     118                $this->quality = apply_filters( 'wp_editor_set_quality', $quality ); 
     119 
     120                return ( (bool) $this->quality ); 
     121        } 
     122 
     123        /** 
     124         * Returns preferred mime-type and extension based on provided 
     125         * file's extension and mime, or current file's extension and mime. 
     126         * 
     127         * Will default to $this->default_mime_type if requested is not supported. 
     128         * 
     129         * Provides corrected filename only if filename is provided. 
     130         * 
     131         * @since 3.5.0 
     132         * @access protected 
     133         * 
     134         * @param string $filename 
     135         * @param type $mime_type 
     136         * @return array { filename|null, extension, mime-type } 
     137         */ 
     138        protected function get_output_format( $filename = null, $mime_type = null ) { 
     139                $new_ext = $file_ext = null; 
     140                $file_mime = null; 
     141 
     142                // By default, assume specified type takes priority 
     143                if ( $mime_type ) { 
     144                        $new_ext = $this->get_extension( $mime_type ); 
     145                } 
     146 
     147                if ( $filename ) { 
     148                        $file_ext = strtolower( pathinfo( $filename, PATHINFO_EXTENSION ) ); 
     149                        $file_mime = $this->get_mime_type( $file_ext ); 
     150                } 
     151                else { 
     152                        // If no file specified, grab editor's current extension and mime-type. 
     153                        $file_ext = strtolower( pathinfo( $this->file, PATHINFO_EXTENSION ) ); 
     154                        $file_mime = $this->mime_type; 
     155                } 
     156 
     157                // Check to see if specified mime-type is the same as type implied by 
     158                // file extension.  If so, prefer extension from file. 
     159                if ( ! $mime_type || ( $file_mime == $mime_type ) ) { 
     160                        $mime_type = $file_mime; 
     161                        $new_ext = $file_ext; 
     162                } 
     163 
     164                // Double-check that the mime-type selected is supported by the editor. 
     165                // If not, choose a default instead. 
     166                if ( ! $this->supports_mime_type( $mime_type ) ) { 
     167                        $mime_type = apply_filters( 'image_editor_default_mime_type', $this->default_mime_type ); 
     168                        $new_ext = $this->get_extension( $mime_type ); 
     169                } 
     170 
     171                if ( $filename ) { 
     172                        $ext = ''; 
     173                        $info = pathinfo( $filename ); 
     174                        $dir  = $info['dirname']; 
     175 
     176                        if( isset( $info['extension'] ) ) 
     177                                $ext = $info['extension']; 
     178 
     179                        $filename = trailingslashit( $dir ) . wp_basename( $filename, ".$ext" ) . ".{$new_ext}"; 
     180                } 
     181 
     182                return array( $filename, $new_ext, $mime_type ); 
     183        } 
     184 
     185        /** 
     186         * Builds an output filename based on current file, and adding proper suffix 
     187         * 
     188         * @since 3.5.0 
     189         * @access public 
     190         * 
     191         * @param string $suffix 
     192         * @param string $dest_path 
     193         * @param string $extension 
     194         * @return string filename 
     195         */ 
     196        public function generate_filename( $suffix = null, $dest_path = null, $extension = null ) { 
     197                // $suffix will be appended to the destination filename, just before the extension 
     198                if ( ! $suffix ) 
     199                        $suffix = $this->get_suffix(); 
     200 
     201                $info = pathinfo( $this->file ); 
     202                $dir  = $info['dirname']; 
     203                $ext  = $info['extension']; 
     204 
     205                $name = wp_basename( $this->file, ".$ext" ); 
     206                $new_ext = strtolower( $extension ? $extension : $ext ); 
     207 
     208                if ( ! is_null( $dest_path ) && $_dest_path = realpath( $dest_path ) ) 
     209                        $dir = $_dest_path; 
     210 
     211                return trailingslashit( $dir ) . "{$name}-{$suffix}.{$new_ext}"; 
     212        } 
     213 
     214        /** 
     215         * Builds and returns proper suffix for file based on height and width. 
     216         * 
     217         * @since 3.5.0 
     218         * @access public 
     219         * 
     220         * @return string suffix 
     221         */ 
     222        public function get_suffix() { 
     223                if ( ! $this->get_size() ) 
     224                        return false; 
     225 
     226                return "{$this->size['width']}x{$this->size['height']}"; 
     227        } 
     228 
     229        /** 
     230         * Either calls editor's save function or handles file as a stream. 
     231         * 
     232         * @since 3.5.0 
     233         * @access protected 
     234         * 
     235         * @param string|stream $filename 
     236         * @param callable $function 
     237         * @param array $arguments 
     238         * @return boolean 
     239         */ 
     240        protected function make_image( $filename, $function, $arguments ) { 
     241                $dst_file = $filename; 
     242 
     243                if ( $stream = wp_is_stream( $filename ) ) { 
     244                        $filename = null; 
     245                        ob_start(); 
     246                } 
     247 
     248                $result = call_user_func_array( $function, $arguments ); 
     249 
     250                if( $result && $stream ) { 
     251                        $contents = ob_get_contents(); 
     252 
     253                        $fp = fopen( $dst_file, 'w' ); 
     254 
     255                        if( ! $fp ) 
     256                                return false; 
     257 
     258                        fwrite( $fp, $contents ); 
     259                        fclose( $fp ); 
     260                } 
     261 
     262                if( $stream ) { 
     263                        ob_end_clean(); 
     264                } 
     265 
     266                return $result; 
     267        } 
     268 
     269        /** 
     270         * Returns first matched mime-type from extension, 
     271         * as mapped from wp_get_mime_types() 
     272         * 
     273         * @since 3.5.0 
     274         * @access protected 
     275         * 
     276         * @param string $extension 
     277         * @return string|boolean 
     278         */ 
     279        protected static function get_mime_type( $extension = null ) { 
     280                if ( ! $extension ) 
     281                        return false; 
     282 
     283                $mime_types = wp_get_mime_types(); 
     284                $extensions = array_keys( $mime_types ); 
     285 
     286                foreach( $extensions as $_extension ) { 
     287                        if( preg_match("/{$extension}/i", $_extension ) ) { 
     288                                return $mime_types[ $_extension ]; 
     289                        } 
     290                } 
     291 
     292                return false; 
     293        } 
     294 
     295        /** 
     296         * Returns first matched extension from Mime-type, 
     297         * as mapped from wp_get_mime_types() 
     298         * 
     299         * @since 3.5.0 
     300         * @access protected 
     301         * 
     302         * @param string $mime_type 
     303         * @return string|boolean 
     304         */ 
     305        protected static function get_extension( $mime_type = null ) { 
     306                $extensions = explode( '|', array_search( $mime_type, wp_get_mime_types() ) ); 
     307 
     308                if ( empty( $extensions[0] ) ) 
     309                        return false; 
     310 
     311                return $extensions[0]; 
     312        } 
     313} 
     314 No newline at end of file 
  • wp-includes/deprecated.php

    diff --git wp-includes/deprecated.php wp-includes/deprecated.php
    index f589017..a9744e8 100644
    function _get_post_ancestors( &$post ) { 
    32063206} 
    32073207 
    32083208/** 
     3209 * Load an image from a string, if PHP supports it. 
     3210 * 
     3211 * @since 2.1.0 
     3212 * @deprecated 3.5.0 
     3213 * @see WP_Image_Editor 
     3214 * 
     3215 * @param string $file Filename of the image to load. 
     3216 * @return resource The resulting image resource on success, Error string on failure. 
     3217 */ 
     3218function wp_load_image( $file ) { 
     3219        _deprecated_function( __FUNCTION__, '3.5', 'WP_Image_Editor' ); 
     3220 
     3221        if ( is_numeric( $file ) ) 
     3222                $file = get_attached_file( $file ); 
     3223 
     3224        if ( ! file_exists( $file ) ) 
     3225                return sprintf(__('File &#8220;%s&#8221; doesn&#8217;t exist?'), $file); 
     3226 
     3227        if ( ! function_exists('imagecreatefromstring') ) 
     3228                return __('The GD image library is not installed.'); 
     3229 
     3230        // Set artificially high because GD uses uncompressed images in memory 
     3231        @ini_set( 'memory_limit', apply_filters( 'image_memory_limit', WP_MAX_MEMORY_LIMIT ) ); 
     3232        $image = imagecreatefromstring( file_get_contents( $file ) ); 
     3233 
     3234        if ( !is_resource( $image ) ) 
     3235                return sprintf(__('File &#8220;%s&#8221; is not an image.'), $file); 
     3236 
     3237        return $image; 
     3238} 
     3239 
     3240/** 
     3241 * Scale down an image to fit a particular size and save a new copy of the image. 
     3242 * 
     3243 * The PNG transparency will be preserved using the function, as well as the 
     3244 * image type. If the file going in is PNG, then the resized image is going to 
     3245 * be PNG. The only supported image types are PNG, GIF, and JPEG. 
     3246 * 
     3247 * Some functionality requires API to exist, so some PHP version may lose out 
     3248 * support. This is not the fault of WordPress (where functionality is 
     3249 * downgraded, not actual defects), but of your PHP version. 
     3250 * 
     3251 * @since 2.5.0 
     3252 * @deprecated 3.5.0 
     3253 * @see WP_Image_Editor 
     3254 * 
     3255 * @param string $file Image file path. 
     3256 * @param int $max_w Maximum width to resize to. 
     3257 * @param int $max_h Maximum height to resize to. 
     3258 * @param bool $crop Optional. Whether to crop image or resize. 
     3259 * @param string $suffix Optional. File suffix. 
     3260 * @param string $dest_path Optional. New image file path. 
     3261 * @param int $jpeg_quality Optional, default is 90. Image quality percentage. 
     3262 * @return mixed WP_Error on failure. String with new destination path. 
     3263 */ 
     3264function image_resize( $file, $max_w, $max_h, $crop = false, $suffix = null, $dest_path = null, $jpeg_quality = 90 ) { 
     3265        _deprecated_function( __FUNCTION__, '3.5', 'WP_Image_Editor' ); 
     3266 
     3267        $editor = WP_Image_Editor::get_instance( $file ); 
     3268        if ( is_wp_error( $editor ) ) 
     3269                return $editor; 
     3270        $editor->set_quality( $jpeg_quality ); 
     3271 
     3272        $resized = $editor->resize( $max_w, $max_h, $crop ); 
     3273        if ( is_wp_error( $resized ) ) 
     3274                return $resized; 
     3275 
     3276        $dest_file = $editor->generate_filename( $suffix, $dest_path ); 
     3277        $saved = $editor->save( $dest_file ); 
     3278 
     3279        if ( is_wp_error( $saved ) ) 
     3280                return $saved; 
     3281 
     3282        return $dest_file; 
     3283} 
     3284 
     3285/** 
    32093286 * Retrieve a single post, based on post ID. 
    32103287 * 
    32113288 * Has categories in 'post_category' property or key. Has tags in 'tags_input' 
  • wp-includes/functions.php

    diff --git wp-includes/functions.php wp-includes/functions.php
    index e51c155..104e89a 100644
    function wp_get_original_referer() { 
    12951295 * @return bool Whether the path was created. True if path already exists. 
    12961296 */ 
    12971297function wp_mkdir_p( $target ) { 
     1298        $wrapper = null; 
     1299 
     1300        // strip the protocol 
     1301        if( wp_is_stream( $target ) ) { 
     1302                list( $wrapper, $target ) = explode( '://', $target, 2 ); 
     1303        } 
     1304 
    12981305        // from php.net/mkdir user contributed notes 
    12991306        $target = str_replace( '//', '/', $target ); 
    13001307 
     1308        // put the wrapper back on the target 
     1309        if( $wrapper !== null ) { 
     1310                $target = $wrapper . '://' . $target; 
     1311        } 
     1312 
    13011313        // safe mode fails with a trailing slash under certain PHP versions. 
    13021314        $target = rtrim($target, '/'); // Use rtrim() instead of untrailingslashit to avoid formatting.php dependency. 
    13031315        if ( empty($target) ) 
    function _device_can_upload() { 
    37413753} 
    37423754 
    37433755/** 
     3756 * Test if a given path is a stream URL 
     3757 * 
     3758 * @param string $path The resource path or URL 
     3759 * @return bool True if the path is a stream URL 
     3760 */ 
     3761function wp_is_stream( $path ) { 
     3762        $wrappers = stream_get_wrappers(); 
     3763        $wrappers_re = '(' . join('|', $wrappers) . ')'; 
     3764 
     3765        return preg_match( "!^$wrappers_re://!", $path ) === 1; 
     3766} 
     3767 
     3768/** 
    37443769 * Test if the supplied date is valid for the Gregorian calendar 
    37453770 * 
    37463771 * @since 3.5.0 
  • wp-includes/media.php

    diff --git wp-includes/media.php wp-includes/media.php
    index 662678a..2e13035 100644
    function get_image_tag($id, $alt, $title, $align, $size='medium') { 
    236236} 
    237237 
    238238/** 
    239  * Load an image from a string, if PHP supports it. 
    240  * 
    241  * @since 2.1.0 
    242  * 
    243  * @param string $file Filename of the image to load. 
    244  * @return resource The resulting image resource on success, Error string on failure. 
    245  */ 
    246 function wp_load_image( $file ) { 
    247         if ( is_numeric( $file ) ) 
    248                 $file = get_attached_file( $file ); 
    249  
    250         if ( ! file_exists( $file ) ) 
    251                 return sprintf(__('File &#8220;%s&#8221; doesn&#8217;t exist?'), $file); 
    252  
    253         if ( ! function_exists('imagecreatefromstring') ) 
    254                 return __('The GD image library is not installed.'); 
    255  
    256         // Set artificially high because GD uses uncompressed images in memory 
    257         @ini_set( 'memory_limit', apply_filters( 'image_memory_limit', WP_MAX_MEMORY_LIMIT ) ); 
    258         $image = imagecreatefromstring( file_get_contents( $file ) ); 
    259  
    260         if ( !is_resource( $image ) ) 
    261                 return sprintf(__('File &#8220;%s&#8221; is not an image.'), $file); 
    262  
    263         return $image; 
    264 } 
    265  
    266 /** 
    267239 * Calculates the new dimensions for a downsampled image. 
    268240 * 
    269241 * If either width or height are empty, no constraint is applied on 
    function image_resize_dimensions($orig_w, $orig_h, $dest_w, $dest_h, $crop = fal 
    393365} 
    394366 
    395367/** 
    396  * Scale down an image to fit a particular size and save a new copy of the image. 
    397  * 
    398  * The PNG transparency will be preserved using the function, as well as the 
    399  * image type. If the file going in is PNG, then the resized image is going to 
    400  * be PNG. The only supported image types are PNG, GIF, and JPEG. 
    401  * 
    402  * Some functionality requires API to exist, so some PHP version may lose out 
    403  * support. This is not the fault of WordPress (where functionality is 
    404  * downgraded, not actual defects), but of your PHP version. 
    405  * 
    406  * @since 2.5.0 
    407  * 
    408  * @param string $file Image file path. 
    409  * @param int $max_w Maximum width to resize to. 
    410  * @param int $max_h Maximum height to resize to. 
    411  * @param bool $crop Optional. Whether to crop image or resize. 
    412  * @param string $suffix Optional. File suffix. 
    413  * @param string $dest_path Optional. New image file path. 
    414  * @param int $jpeg_quality Optional, default is 90. Image quality percentage. 
    415  * @return mixed WP_Error on failure. String with new destination path. 
    416  */ 
    417 function image_resize( $file, $max_w, $max_h, $crop = false, $suffix = null, $dest_path = null, $jpeg_quality = 90 ) { 
    418  
    419         $image = wp_load_image( $file ); 
    420         if ( !is_resource( $image ) ) 
    421                 return new WP_Error( 'error_loading_image', $image, $file ); 
    422  
    423         $size = @getimagesize( $file ); 
    424         if ( !$size ) 
    425                 return new WP_Error('invalid_image', __('Could not read image size'), $file); 
    426         list($orig_w, $orig_h, $orig_type) = $size; 
    427  
    428         $dims = image_resize_dimensions($orig_w, $orig_h, $max_w, $max_h, $crop); 
    429         if ( !$dims ) 
    430                 return new WP_Error( 'error_getting_dimensions', __('Could not calculate resized image dimensions') ); 
    431         list($dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h) = $dims; 
    432  
    433         $newimage = wp_imagecreatetruecolor( $dst_w, $dst_h ); 
    434  
    435         imagecopyresampled( $newimage, $image, $dst_x, $dst_y, $src_x, $src_y, $dst_w, $dst_h, $src_w, $src_h); 
    436  
    437         // convert from full colors to index colors, like original PNG. 
    438         if ( IMAGETYPE_PNG == $orig_type && function_exists('imageistruecolor') && !imageistruecolor( $image ) ) 
    439                 imagetruecolortopalette( $newimage, false, imagecolorstotal( $image ) ); 
    440  
    441         // we don't need the original in memory anymore 
    442         imagedestroy( $image ); 
    443  
    444         // $suffix will be appended to the destination filename, just before the extension 
    445         if ( !$suffix ) 
    446                 $suffix = "{$dst_w}x{$dst_h}"; 
    447  
    448         $info = pathinfo($file); 
    449         $dir = $info['dirname']; 
    450         $ext = $info['extension']; 
    451         $name = wp_basename($file, ".$ext"); 
    452  
    453         if ( !is_null($dest_path) and $_dest_path = realpath($dest_path) ) 
    454                 $dir = $_dest_path; 
    455         $destfilename = "{$dir}/{$name}-{$suffix}.{$ext}"; 
    456  
    457         if ( IMAGETYPE_GIF == $orig_type ) { 
    458                 if ( !imagegif( $newimage, $destfilename ) ) 
    459                         return new WP_Error('resize_path_invalid', __( 'Resize path invalid' )); 
    460         } elseif ( IMAGETYPE_PNG == $orig_type ) { 
    461                 if ( !imagepng( $newimage, $destfilename ) ) 
    462                         return new WP_Error('resize_path_invalid', __( 'Resize path invalid' )); 
    463         } else { 
    464                 // all other formats are converted to jpg 
    465                 if ( 'jpg' != $ext && 'jpeg' != $ext ) 
    466                         $destfilename = "{$dir}/{$name}-{$suffix}.jpg"; 
    467                 if ( !imagejpeg( $newimage, $destfilename, apply_filters( 'jpeg_quality', $jpeg_quality, 'image_resize' ) ) ) 
    468                         return new WP_Error('resize_path_invalid', __( 'Resize path invalid' )); 
    469         } 
    470  
    471         imagedestroy( $newimage ); 
    472  
    473         // Set correct file permissions 
    474         $stat = stat( dirname( $destfilename )); 
    475         $perms = $stat['mode'] & 0000666; //same permissions as parent folder, strip off the executable bits 
    476         @ chmod( $destfilename, $perms ); 
    477  
    478         return $destfilename; 
    479 } 
    480  
    481 /** 
    482368 * Resize an image to make a thumbnail or intermediate size. 
    483369 * 
    484370 * The returned array has the file size, the image width, and image height. The 
    function image_resize( $file, $max_w, $max_h, $crop = false, $suffix = null, $de 
    493379 * @param bool $crop Optional, default is false. Whether to crop image to specified height and width or resize. 
    494380 * @return bool|array False, if no image was created. Metadata array on success. 
    495381 */ 
    496 function image_make_intermediate_size($file, $width, $height, $crop=false) { 
     382function image_make_intermediate_size( $file, $width, $height, $crop = false ) { 
    497383        if ( $width || $height ) { 
    498                 $resized_file = image_resize($file, $width, $height, $crop); 
    499                 if ( !is_wp_error($resized_file) && $resized_file && $info = getimagesize($resized_file) ) { 
    500                         $resized_file = apply_filters('image_make_intermediate_size', $resized_file); 
    501                         return array( 
    502                                 'file' => wp_basename( $resized_file ), 
    503                                 'width' => $info[0], 
    504                                 'height' => $info[1], 
    505                         ); 
     384                $editor = WP_Image_Editor::get_instance( $file ); 
     385 
     386                if ( is_wp_error( $editor->resize( $width, $height, $crop ) ) ); 
     387                        return false; 
     388 
     389                $resized_file = $editor->save(); 
     390 
     391                if ( ! is_wp_error( $resized_file ) && $resized_file ) { 
     392                        unset( $resized_file['path'] ); 
     393                        return $resized_file; 
    506394                } 
    507395        } 
    508396        return false; 
    function gd_edit_image_support($mime_type) { 
    1047935 
    1048936/** 
    1049937 * Create new GD image resource with transparency support 
     938 * @TODO: Deprecate if possible. 
    1050939 * 
    1051940 * @since 2.9.0 
    1052941 * 
  • wp-settings.php

    diff --git wp-settings.php wp-settings.php
    index 0b81e4d..470ed9a 100644
    require( ABSPATH . WPINC . '/nav-menu.php' ); 
    143143require( ABSPATH . WPINC . '/nav-menu-template.php' ); 
    144144require( ABSPATH . WPINC . '/admin-bar.php' ); 
    145145 
     146require( ABSPATH . WPINC . '/class-wp-image-editor.php' ); 
     147require( ABSPATH . WPINC . '/class-wp-image-editor-gd.php' ); 
     148require( ABSPATH . WPINC . '/class-wp-image-editor-imagick.php' ); 
     149 
    146150// Load multisite-specific files. 
    147151if ( is_multisite() ) { 
    148152        require( ABSPATH . WPINC . '/ms-functions.php' );