Configuration de l'environnement

Pour manipuler les fichiers HEIC, la bibliothèque libheif doit être installée. Sur les systèmes basés sur Debian ou Ubuntu, utilisez le gestionnaire de paquets. Pour macOS, Homebrew est recommandé. Sous Windows, il faut compiler les sources ou utiliser des binaires précompilés.

# Installation sur Debian/Ubuntu
sudo apt-get install libheif-dev

# Installation via Homebrew sur macOS
brew install libheif

# Compilation depuis les sources (méthode universelle)
git clone https://github.com/strukturag/libheif.git
cd libheif
./autogen.sh && make && sudo make install

Conversion d'un fichier unique

Exemple d'implémentation en C pour convertir un fichier HEIC en JPEG, en préservant les métadonnées EXIF. Le code suivant utilise l'API de libheif pour décodage et encodage.

#include <libheif/heif.h>
#include <stdio.h>

void convert_heic_to_jpeg(const char* source_path, const char* dest_path) {
    struct heif_context* context = heif_context_alloc();
    heif_context_read_from_file(context, source_path, NULL);

    struct heif_image_handle* image_handle;
    heif_context_get_primary_image_handle(context, &image_handle);

    struct heif_image* image_data;
    heif_decode_image(image_handle, &image_data, heif_colorspace_YCbCr, heif_chroma_420, NULL);

    struct heif_error err = heif_image_write_to_file(image_data, dest_path,
        heif_image_handle_get_metadata_type(image_handle),
        heif_image_handle_get_metadata_content_type(image_handle));

    heif_image_release(image_data);
    heif_image_handle_release(image_handle);
    heif_context_free(context);
}

Traitement par lots optimisé

Pour accélérer la conversion de multiples fichiers, une approche avec thread pool est recommandée. Le code Python ci-dessous utilise pyheif et Pillow, avec un pool de threads configurable.

import os
from concurrent.futures import ThreadPoolExecutor
import pyheif
from PIL import Image

def transform_heic_to_jpeg(src_path, dst_path):
    heif_data = pyheif.read(src_path)
    pil_image = Image.frombytes(
        heif_data.mode,
        heif_data.size,
        heif_data.data,
        "raw",
        heif_data.mode,
        heif_data.stride
    )
    pil_image.save(dst_path, "JPEG", exif=heif_data.metadata)

def batch_process(src_dir, dst_dir, num_threads=8):
    os.makedirs(dst_dir, exist_ok=True)
    with ThreadPoolExecutor(max_workers=num_threads) as pool:
        for entry in os.listdir(src_dir):
            if entry.lower().endswith('.heic'):
                input_file = os.path.join(src_dir, entry)
                output_file = os.path.join(dst_dir, f"{os.path.splitext(entry)[0]}.jpg")
                pool.submit(transform_heic_to_jpeg, input_file, output_file)

Ajustements des performances

Pour les systèmes à stockage SSD, augmenter la taille du tampon d'entrée/sortie peut améliorer le débit. Configurer le décodeur avec des paramètres adaptés :

// Réglage du décodeur (en kilo-octets)
heif_decoder_set_strict_decoding(decoder, false);
heif_decoder_set_maximum_image_size_limit(decoder, 8192);  // Limite à 8 Mo

Vérification des métadonnées EXIF

Utilisez l'outil exiftool pour inspecter les métadonnées préservées après conversion :

exiftool -all image_convertie.jpg

Gestion des erreurs

Intégrez des fonctions de rappel pour gérer les fichiers corrompus ou les erreurs de décodage. Exemple avec libheif :

struct heif_error err;
err = heif_image_write_to_file(image_data, dest_path, ...);
if (err.code != heif_error_Ok) {
    fprintf(stderr, "Erreur lors de l'écriture : %s\n", err.message);
}