Compresión Automática de Imágenes en WordPress con el Plugin Compress Uploaded Images

La optimización de imágenes es una de las prácticas más efectivas para mejorar el rendimiento de un sitio web. En entornos WordPress, donde cada imagen subida puede generar múltiples miniaturas, aplicar compresión de forma automática se vuelve una necesidad. Este artículo presenta el funcionamiento técnico del plugin personalizado Compress Uploaded Images, que comprime imágenes JPEG, PNG y WebP justo después de su carga, incluyendo las miniaturas generadas.

<?php
/**
 * Plugin Name: Compress Uploaded Images
 * Description: Comprime automáticamente imágenes JPEG, PNG y WebP al subirlas, incluyendo miniaturas.
 * Version: 1.2
 * Author: Juan Jose Fernandez Duran
 */

define('CALIDAD_IMAGEN', 80); // Calidad de 0 a 100, afecta JPG, PNG y WebP

add_filter('wp_generate_attachment_metadata', 'compress_all_uploaded_images', 10, 2);

function compress_all_uploaded_images($metadata, $attachment_id) {
    $upload_dir = wp_upload_dir();
    $base_dir = trailingslashit($upload_dir['basedir']);

    // Comprimir imagen original
    $original_file = get_attached_file($attachment_id);
    compress_image($original_file);

    // Comprimir miniaturas
    if (!empty($metadata['sizes'])) {
        foreach ($metadata['sizes'] as $size) {
            $thumbnail_path = $base_dir . $size['file'];
            $thumb_dir = dirname($original_file);

            if (!file_exists($thumbnail_path) && file_exists($thumb_dir . '/' . $size['file'])) {
                $thumbnail_path = $thumb_dir . '/' . $size['file'];
            }

            if (file_exists($thumbnail_path)) {
                compress_image($thumbnail_path);
            }
        }
    }

    return $metadata;
}

function compress_image($file_path) {
    $ext = strtolower(pathinfo($file_path, PATHINFO_EXTENSION));
    if (!in_array($ext, ['jpg', 'jpeg', 'png', 'webp'])) return;

    $img = false;
    switch ($ext) {
        case 'jpg':
        case 'jpeg':
            $img = @imagecreatefromjpeg($file_path);
            break;
        case 'png':
            $img = @imagecreatefrompng($file_path);
            imagepalettetotruecolor($img);
            imagealphablending($img, true);
            imagesavealpha($img, true);
            break;
        case 'webp':
            $img = @imagecreatefromwebp($file_path);
            break;
    }

    if (!$img) return;

    $tmp_file = $file_path . '.tmp';

    switch ($ext) {
        case 'jpg':
        case 'jpeg':
            imagejpeg($img, $tmp_file, CALIDAD_IMAGEN);
            break;
        case 'png':
            $png_compression = 9 - round(CALIDAD_IMAGEN / 11.111); // 0–100 → 0–9
            imagepng($img, $tmp_file, $png_compression);
            break;
        case 'webp':
            imagewebp($img, $tmp_file, CALIDAD_IMAGEN);
            break;
    }

    imagedestroy($img);

    if (file_exists($tmp_file)) {
        rename($tmp_file, $file_path);
    }
}

Descripción General del Plugin

Nombre del plugin: Compress Uploaded Images
Versión: 1.2
Autor: Juan José Fernández Durán
Descripción: Comprime automáticamente imágenes JPEG, PNG y WebP al subirlas, incluyendo miniaturas.

Este plugin intercepta el proceso de carga de imágenes en WordPress y aplica compresión sin intervención del usuario. Está diseñado para ser simple, eficiente y totalmente automático.

¿Cómo Funciona?

El núcleo del plugin gira en torno al uso del hook wp_generate_attachment_metadata, que se ejecuta justo después de que WordPress genera los metadatos y miniaturas de una imagen subida.

add_filter('wp_generate_attachment_metadata', 'compress_all_uploaded_images', 10, 2);

1. Compresión de la imagen original

Se obtiene la ruta del archivo original mediante get_attached_file() y se pasa a la función compress_image():

$original_file = get_attached_file($attachment_id);
compress_image($original_file);

2. Compresión de miniaturas

A continuación, el plugin itera sobre las miniaturas generadas en $metadata['sizes']. Intenta localizar cada archivo y comprimirlo también.

foreach ($metadata['sizes'] as $size) {
    $thumbnail_path = $base_dir . $size['file'];
    ...
    compress_image($thumbnail_path);
}

Lógica de Compresión

La función compress_image() detecta la extensión del archivo (jpg, jpeg, png o webp) y utiliza las funciones de la librería GD (imagecreatefromjpeg, imagecreatefrompng, etc.) para cargar la imagen en memoria y luego reescribirla con un grado de compresión definido por la constante CALIDAD_IMAGEN.

define('CALIDAD_IMAGEN', 80); // Calidad de compresión configurable

Compresión específica por formato:

JPEG/JPG:
Se reescribe con imagejpeg() utilizando el nivel de calidad configurado (0-100).
PNG:
WordPress usa calidad 0–100, pero la función imagepng() espera un valor de compresión entre 0 (sin compresión) y 9 (máxima compresión). Se hace una conversión proporcional: $png_compression = 9 - round(CALIDAD_IMAGEN / 11.111);
WebP:
Se reescribe usando imagewebp() con la calidad deseada.

Finalmente, la imagen resultante se guarda en un archivo temporal, que luego reemplaza al original si el proceso fue exitoso.

if (file_exists($tmp_file)) {
    rename($tmp_file, $file_path);
}

Ventajas del Plugin

Automatización total: No requiere intervención del usuario.
Soporte para múltiples formatos: JPEG, PNG y WebP.
Compresión también de miniaturas: Algo que no muchos plugins manejan.
Ligero y sin dependencias externas: Ideal para entornos con pocos recursos.

Consideraciones

Requiere que la extensión GD esté habilitada en PHP.
No realiza compresión con pérdida avanzada (como JPEG optimizado con MozJPEG o PNG con optipng), lo que puede ser una oportunidad para extenderlo con herramientas CLI o servicios externos.
No incorpora interfaz de usuario para configurar la calidad de compresión (actualmente es fija con CALIDAD_IMAGEN).

Conclusión

El plugin Compress Uploaded Images es una solución sencilla pero potente para mantener optimizadas las imágenes en una instalación de WordPress sin necesidad de plugins de terceros complejos o pesados. Su implementación directa y eficiente lo convierte en una buena base para desarrollos personalizados que requieran control sobre la compresión en servidores con recursos limitados.