How to Convert HEIF Images to JPG or PNG on Linux

Convert HEIF Images to JPG or PNG on Linux

Have you ever received photos from an iPhone user only to discover they’re in a strange format you can’t open? Or perhaps you’ve switched from iOS to Linux and found your image library suddenly incompatible? The culprit is likely the HEIF format (with the .HEIC extension), which has become Apple’s default image format in recent years. While this format offers excellent compression and quality benefits, Linux systems don’t always play nicely with it out of the box. This comprehensive guide will walk you through various methods to convert HEIF/HEIC images to more universally compatible formats like JPG and PNG on your Linux system.

Table of Contents

Understanding HEIF and HEIC Formats

What is HEIF/HEIC?

HEIF (High-Efficiency Image Format) is a modern image container format designed to store images and image sequences more efficiently than traditional formats. HEIC (High-Efficiency Image Container) files are the most common implementation of the HEIF standard, predominantly used by Apple devices since iOS 11.

Benefits of HEIF

The primary advantage of HEIF is its superior compression algorithm, which can reduce file sizes by up to 50% compared to JPEG while maintaining similar or better image quality. This efficiency makes it ideal for mobile devices where storage space is limited. Additionally, HEIF supports features like transparency, 16-bit color depth, and the ability to store multiple images in a single file.

Why Compatibility is an Issue

Despite its technical advantages, HEIF’s adoption has been limited outside the Apple ecosystem. Linux systems, along with many other platforms, lack native support for this format. This compatibility challenge creates the need for conversion tools to transform HEIF/HEIC files into more universally supported formats like JPG or PNG.

Prerequisites for HEIF Conversion on Linux

Before diving into conversion methods, you’ll need to install some essential packages to handle HEIF files on your Linux system. These libraries provide the necessary functionality to decode HEIF files.

Installing Required Packages

The most critical package for working with HEIF files on Linux is libheif, which provides the core functionality for processing these files. Additionally, you’ll need libheif-examples, which includes the useful heif-convert utility.

For Ubuntu/Debian-based distributions:

sudo apt update
sudo apt install libheif-examples

For Fedora:

sudo dnf install libheif libheif-tools

For Arch Linux:

sudo pacman -S libheif

For RHEL/CentOS:

sudo yum install libheif libheif-tools

For openSUSE:

sudo zypper install libheif libheif-tools

Verifying Installation

After installation, you can verify that the packages were installed correctly by checking the version of heif-convert:

heif-convert --version

If you see a version number rather than an error message, the installation was successful.

Command-Line Method Using heif-convert

The heif-convert utility is a powerful command-line tool for converting HEIF images to more common formats. It’s straightforward to use and offers various options for customization.

Basic Conversion Syntax

The basic syntax for converting a single HEIF file to JPG is:

heif-convert input.heic output.jpg

Similarly, for PNG:

heif-convert input.heic output.png

Adjusting Output Quality

One of the advantages of heif-convert is the ability to control the quality of the output image using the -q option, which accepts values from 0 to 100 (where higher values indicate better quality):

heif-convert -q 85 input.heic output.jpg

A value of 85-95 typically offers a good balance between quality and file size. Using 100 provides maximum quality but results in larger files, while lower values like 70-80 can significantly reduce file size with only minor visible quality loss.

Real-World Example

Let’s say you have a photo from an iPhone named IMG_1234.HEIC and want to convert it to a high-quality JPG:

heif-convert -q 95 IMG_1234.HEIC IMG_1234.jpg

This command will create a new file called IMG_1234.jpg with 95% quality, which should be virtually indistinguishable from the original to the naked eye while maintaining a reasonable file size.

Batch Conversion of Multiple HEIF Files

When dealing with numerous HEIF files, converting them one by one would be tedious. Fortunately, there are several methods for batch conversion.

Using Bash Loops for Files in a Single Directory

To convert all HEIC files in the current directory to JPG format, you can use a simple bash loop:

for file in *.heic; do 
    heif-convert -q 90 "$file" "${file%.heic}.jpg"
done

This loop iterates through all files with the .heic extension in the current directory and converts each one to JPG with 90% quality. The ${file%.heic} part removes the .heic extension from the original filename.

For case-insensitive matching (to catch both .heic and .HEIC files), use:

for file in *.{heic,HEIC}; do
    [ -f "$file" ] || continue
    heif-convert -q 90 "$file" "${file%.*}.jpg"
done

Handling Files in Subdirectories

If your HEIF files are scattered across multiple directories, you can use the find command to locate and process them recursively:

find . -iname "*.heic" -exec bash -c 'heif-convert -q 90 "$1" "${1%.*}.jpg"' _ {} \;

This command searches for all files with .heic extension (case-insensitive) in the current directory and all its subdirectories, then converts each one to a JPG file in the same location as the original.

Creating Organized Output

You might want to organize your converted files by moving them to a separate directory. Here’s how to do that:

# Create a directory for converted files
mkdir -p converted

# Convert and move files
for file in *.heic; do
    heif-convert -q 90 "$file" "converted/${file%.heic}.jpg"
done

This approach keeps your original HEIC files untouched while placing all converted JPGs in a separate converted directory.

Using Python for HEIF Conversion

For those who prefer Python or need more customization options, there are Python-based solutions for converting HEIF files.

Required Python Libraries

To convert HEIF files using Python, you’ll need to install the following libraries:

pip install pillow pyheif

Pillow is a powerful image processing library for Python, while pyheif provides the capability to read HEIF files.

Basic Python Script for Single File Conversion

Here’s a simple Python script to convert a single HEIF file to JPG:

import pyheif
from PIL import Image
import sys

def convert_heif_to_jpg(heif_path, jpg_path):
    # Read the HEIF file
    heif_file = pyheif.read(heif_path)
    
    # Convert to PIL Image
    image = Image.frombytes(
        heif_file.mode, 
        heif_file.size, 
        heif_file.data,
        "raw",
        heif_file.mode,
        heif_file.stride,
    )
    
    # Save as JPG
    image.save(jpg_path, "JPEG", quality=90)
    print(f"Converted {heif_path} to {jpg_path}")

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: python convert.py input.heic output.jpg")
        sys.exit(1)
        
    convert_heif_to_jpg(sys.argv[1], sys.argv[2])

Save this script as convert.py and run it with:

python convert.py input.heic output.jpg

Advanced Python Script for Batch Processing

Here’s a more advanced script for batch processing that can handle multiple files and includes error handling:

import os
import pyheif
from PIL import Image
import argparse
import sys

def convert_heif_to_jpg(heif_path, jpg_path, quality=90):
    try:
        # Read the HEIF file
        heif_file = pyheif.read(heif_path)
        
        # Convert to PIL Image
        image = Image.frombytes(
            heif_file.mode, 
            heif_file.size, 
            heif_file.data,
            "raw",
            heif_file.mode,
            heif_file.stride,
        )
        
        # Extract EXIF data if present
        metadata = None
        for metadata in heif_file.metadata or []:
            if metadata['type'] == 'Exif':
                exif_data = metadata['data']
                break
        
        # Save as JPG with EXIF data if available
        if metadata:
            image.save(jpg_path, "JPEG", quality=quality, exif=exif_data)
        else:
            image.save(jpg_path, "JPEG", quality=quality)
            
        print(f"Converted {heif_path} to {jpg_path}")
        return True
    except Exception as e:
        print(f"Error converting {heif_path}: {e}")
        return False

def batch_convert(input_dir, output_dir=None, quality=90, recursive=False):
    # Create output directory if specified and doesn't exist
    if output_dir and not os.path.exists(output_dir):
        os.makedirs(output_dir)
    
    success_count = 0
    failure_count = 0
    
    # Find all HEIF files
    if recursive:
        all_files = []
        for root, _, files in os.walk(input_dir):
            for file in files:
                if file.lower().endswith(('.heic', '.heif')):
                    all_files.append(os.path.join(root, file))
    else:
        all_files = [os.path.join(input_dir, f) for f in os.listdir(input_dir) 
                    if os.path.isfile(os.path.join(input_dir, f)) 
                    and f.lower().endswith(('.heic', '.heif'))]
    
    # Process each file
    for heif_path in all_files:
        if output_dir:
            # Determine output path in the specified output directory
            base_name = os.path.basename(heif_path)
            jpg_name = os.path.splitext(base_name)[0] + '.jpg'
            jpg_path = os.path.join(output_dir, jpg_name)
        else:
            # Replace extension in the same directory
            jpg_path = os.path.splitext(heif_path)[0] + '.jpg'
        
        # Convert the file
        if convert_heif_to_jpg(heif_path, jpg_path, quality):
            success_count += 1
        else:
            failure_count += 1
    
    print(f"\nConversion complete: {success_count} succeeded, {failure_count} failed")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Convert HEIF images to JPG')
    parser.add_argument('input', help='Input file or directory')
    parser.add_argument('-o', '--output', help='Output file or directory (optional)')
    parser.add_argument('-q', '--quality', type=int, default=90, help='Output quality (1-100, default: 90)')
    parser.add_argument('-r', '--recursive', action='store_true', help='Process directories recursively')
    
    args = parser.parse_args()
    
    if os.path.isfile(args.input):
        # Single file mode
        if not args.input.lower().endswith(('.heic', '.heif')):
            print("Input file is not a HEIF/HEIC file.")
            sys.exit(1)
        
        output_path = args.output if args.output else os.path.splitext(args.input)[0] + '.jpg'
        convert_heif_to_jpg(args.input, output_path, args.quality)
    else:
        # Directory mode
        batch_convert(args.input, args.output, args.quality, args.recursive)

Save this script as batch_convert.py and use it like this:

# Convert a single file
python batch_convert.py input.heic -o output.jpg -q 95

# Convert all HEIF files in a directory
python batch_convert.py input_directory -o output_directory -q 90

# Recursively convert files in a directory tree
python batch_convert.py input_directory -o output_directory -r

Using the Python heif-convert Package

There’s also a dedicated Python package called heif-convert that provides a simpler interface for HEIF conversion.

Installation

Install the package using pip:

pip install heif-convert

Basic Usage

Once installed, you can use the heif-convert command directly from the terminal:

heif-convert input.heic

This will convert the file to JPG with the default settings. The command offers several options for customization:

heif-convert -o output.jpg -f jpg -q 90 input.heic

Where:

-o specifies the output filename
-f sets the output format (jpg, png, webp, gif, tiff, bmp, or ico)
-q controls the quality (0-100)

Batch Processing with the Package

For batch processing, you can specify multiple input files:

heif-convert *.heic

Or use more advanced options:

heif-convert -f png -q 95 -p "converted/" *.heic

This will convert all HEIC files to PNG format with 95% quality and place them in a folder called “converted”.

Docker Implementation

The heif-convert Python package also offers a Docker image for containerized usage:

docker pull nevermendel/heif-convert
docker run -v "$(pwd)":/usr/app/out --rm nevermendel/heif-convert input.heic

This approach is particularly useful in environments where installing dependencies might be challenging.

GUI Solutions for HEIF Conversion

For users who prefer graphical interfaces over command-line tools, there are several GUI applications that can handle HEIF files on Linux.

Image Editors with HEIF Support

Both GIMP and Krita, popular image editors for Linux, can open HEIF files and export them to other formats:

Install GIMP or Krita from your distribution’s package manager
Open the HEIC file in the editor
Use the “Export As” or “Save As” option from the File menu
Choose JPG or PNG format and adjust quality settings as needed
Save the converted file

Setting Up System-Wide HEIF Support

To enable HEIF support in file managers and image viewers, you can install the heif-gdk-pixbuf package:

sudo apt install heif-gdk-pixbuf

This will enable HEIC support in applications that use the GDK-PixBuf library, including:

XViewer (default in Linux Mint)
Eye of GNOME (GNOME’s image viewer)
Nemo File Manager
PCMan File Manager
And many others

After installation, you’ll need to select the default application for opening HEIC files and possibly log out and back in for the changes to take effect.

Automating HEIF Conversion

For users who regularly deal with HEIF files, automating the conversion process can save significant time.

Creating System Services

You can create a systemd service to watch for new HEIC files and automatically convert them:

1. Create a script for conversion:

#!/bin/bash
# Save as ~/bin/convert-heic.sh

INPUT_DIR="$HOME/Pictures/HEIC"
OUTPUT_DIR="$HOME/Pictures/Converted"

mkdir -p "$OUTPUT_DIR"

inotifywait -m -r -e close_write --format '%w%f' "$INPUT_DIR" | while read FILE
do
    if [[ "$FILE" =~ .*\.(heic|HEIC)$ ]]; then
        BASENAME=$(basename "$FILE")
        FILENAME="${BASENAME%.*}"
        heif-convert -q 90 "$FILE" "$OUTPUT_DIR/$FILENAME.jpg"
        echo "Converted $FILE to $OUTPUT_DIR/$FILENAME.jpg"
    fi
done

2. Make the script executable:

chmod +x ~/bin/convert-heic.sh

3. Create a systemd service file:

[Unit]
Description=HEIC Auto Converter
After=network.target

[Service]
Type=simple
ExecStart=/home/yourusername/bin/convert-heic.sh
Restart=on-failure

[Install]
WantedBy=multi-user.target

4. Save this file as ~/.config/systemd/user/heic-converter.service

5. Enable and start the service:

systemctl --user enable heic-converter.service
systemctl --user start heic-converter.service

Integration with File Managers

You can also add a custom action to your file manager for right-click conversion:

For Nautilus (GNOME Files):

Install nautilus-actions or filemanager-actions
Create a new action with the command:
```
heif-convert -q 90 %f %f.jpg
```
Set it to appear for HEIC/HEIF file types only

For Nemo (Cinnamon):

Create a script in ~/.local/share/nemo/actions/convert-heic.nemo_action:

[Nemo Action]
Name=Convert to JPG
Comment=Convert HEIC image to JPG
Exec=heif-convert -q 90 %F %F.jpg
Icon-Name=image
Selection=s
Extensions=heic;HEIC;heif;HEIF;

Make the script executable and restart Nemo

Performance Considerations

When converting HEIF images, several factors can affect performance and output quality.

Speed vs. Quality Trade-offs

Generally, higher quality settings result in longer conversion times. For batch processing of many files, you might want to use a lower quality setting (like 80-85) to speed up the process.

Here’s a rough comparison based on a test with a 12-megapixel image:

Quality 100: ~3MB file size, slowest conversion
Quality 90: ~1.2MB file size, good balance
Quality 75: ~700KB file size, fastest conversion

Resource Usage

HEIF conversion can be CPU-intensive, especially for high-resolution images. For large batch operations, consider:

Using the -q option to reduce quality and speed up processing
Processing files in smaller batches to avoid memory issues
Running conversions during periods of low system usage

Multithreading Options

For Python-based solutions, you can implement multithreading to take advantage of multiple CPU cores:

import concurrent.futures

# Inside your batch processing function:
with concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count()) as executor:
    futures = [executor.submit(convert_heif_to_jpg, file, output_path, quality) 
              for file in heif_files]
    
    for future in concurrent.futures.as_completed(futures):
        try:
            future.result()
        except Exception as e:
            print(f"Conversion failed: {e}")

Troubleshooting Common Issues

Despite the straightforward nature of these conversion tools, you might encounter some issues during the process.

Missing Dependencies

If you get an error like “Command not found” when trying to use heif-convert, make sure you’ve installed the necessary packages:

sudo apt install libheif-examples

For Python-based solutions, ensure you have all required libraries:

pip install pillow pyheif

Permission Problems

If you encounter permission errors:

1. Check file permissions:

ls -l input.heic

2. Ensure you have read permission on the source files and write permission in the target directory:

chmod 644 input.heic
chmod 755 target_directory

Quality and Orientation Issues

Some versions of heif-convert have bugs with image orientation. If your converted images appear rotated:

Try using the Python-based conversion with EXIF preservation
Use an image editor like GIMP to manually correct the orientation
Update to the latest version of libheif and libheif-examples

Metadata Preservation

If maintaining EXIF data is important:

Use the Python script provided earlier, which includes EXIF preservation
For command-line tools, check if your version of heif-convert supports metadata preservation options

Comparison of Conversion Methods

Each conversion method has its advantages and limitations. Here’s a comparison to help you choose the right approach for your needs:

Command-Line Method (heif-convert):

Pros: Fast, lightweight, easy for automation
Cons: Limited options, potential metadata loss
Best for: Quick conversions, batch processing, scripts

Python Scripts:

Pros: Highly customizable, metadata preservation, error handling
Cons: Requires Python knowledge, more dependencies
Best for: Complex workflows, custom requirements

Python heif-convert Package:

Pros: Simple interface, good documentation, Docker support
Cons: Additional dependency via pip
Best for: Users familiar with Python ecosystems

GUI Solutions:

Pros: User-friendly, no command-line knowledge required
Cons: Less suitable for automation, potentially slower
Best for: Casual users, occasional conversions

VPS Manage Service Offer

If you don’t have time to do all of this stuff, or if this is not your area of expertise, we offer a service to do “VPS Manage Service Offer”, starting from $10 (Paypal payment). Please contact us to get the best deal!

r00t