Fixed invalid extraction of image dimensions for HEIF files w/ multiple images

Source/com/drew/metadata/heif/boxes/ImageRotationBox.java

@@ -22,6 +22,14 @@ public ImageRotationBox(SequentialReader reader, Box box) throws IOException
 
     public void addMetadata(HeifDirectory directory)
     {
+        // There may be several images in the HEIF file, what we'd like to return is the rotation
+        // of the "main" image. We assume that if there are several images, they all have the same
+        // rotation (and as such we can just take the first rotation that we encounter).
+        // That is a bold assumption, but should be right most of the time.
+        // In the wild, the rotation attribute is mainly used for efficiency on cameras, as it avoids
+        // having to rotate the whole framebuffer (the camera just records the wanted rotation). There
+        // is no reason a priori to expect the camera to not use this optimization for each image in the
+        // HEIF file.
         if (!directory.containsTag(HeifDirectory.TAG_IMAGE_ROTATION)) {
             directory.setInt(HeifDirectory.TAG_IMAGE_ROTATION, angle);
         }

Source/com/drew/metadata/heif/boxes/ImageSpatialExtentsProperty.java

@@ -21,6 +21,7 @@
 package com.drew.metadata.heif.boxes;
 
 import com.drew.lang.SequentialReader;
+import com.drew.metadata.MetadataException;
 import com.drew.metadata.heif.HeifDirectory;
 
 import java.io.IOException;
@@ -43,7 +44,28 @@ public ImageSpatialExtentsProperty(SequentialReader reader, Box box) throws IOEx
 
     public void addMetadata(HeifDirectory directory)
     {
-        if (!directory.containsTag(HeifDirectory.TAG_IMAGE_WIDTH) && !directory.containsTag(HeifDirectory.TAG_IMAGE_HEIGHT)) {
+        if (directory.containsTag(HeifDirectory.TAG_IMAGE_WIDTH) && directory.containsTag(HeifDirectory.TAG_IMAGE_HEIGHT)) {
+            // There may be several images in the HEIF file, what we'd like to return is the width and height
+            // of the "main" image.
+            // We assume that the main image is the biggest image, so we want to take the max width & height.
+            // While it is not guaranteed to be correct, this is a pretty safe bet and seems to be validated
+            // by actual images found in the wild (additional images in practice are often thumbnails or overlays,
+            // that are going to be smaller that the main image).
+            // Note that here we also assume that if width is bigger than the preexisting value, so is height.
+            try {
+                directory.setLong(
+                    HeifDirectory.TAG_IMAGE_WIDTH,
+                    Math.max(directory.getInt(HeifDirectory.TAG_IMAGE_WIDTH), width)
+                );
+                directory.setLong(
+                    HeifDirectory.TAG_IMAGE_HEIGHT,
+                    Math.max(directory.getInt(HeifDirectory.TAG_IMAGE_HEIGHT), height)
+                );
+            } catch(MetadataException ex) {
+                // We could not read width and height tags as int values (unexpected type ?).
+                // We just ignore this. It should never ever happen given that we always set those to int values.
+            }
+        } else {
             directory.setLong(HeifDirectory.TAG_IMAGE_WIDTH, width);
             directory.setLong(HeifDirectory.TAG_IMAGE_HEIGHT, height);
         }

Tests/com/drew/imaging/FileTypeTest.java

@@ -33,11 +33,14 @@ public void testExtensions()
     {
         assertEquals("jpg", FileType.Jpeg.getCommonExtension());
         assertEquals("bmp", FileType.Bmp.getCommonExtension());
+        assertEquals("heif", FileType.Heif.getCommonExtension());
 
         assertEquals("JPEG", FileType.Jpeg.getName());
         assertEquals("BMP", FileType.Bmp.getName());
+        assertEquals("HEIF", FileType.Heif.getName());
 
         assertArrayEquals(new String[]{"jpg", "jpeg", "jpe"}, FileType.Jpeg.getAllExtensions());
+        assertArrayEquals(new String[]{"heif", "heic"}, FileType.Heif.getAllExtensions());
 
         assertNull(FileType.Unknown.getCommonExtension());
     }

Tests/com/drew/imaging/heif/HeifMetadataReaderTest.java

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2002-2019 Drew Noakes and contributors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ *
+ * More information about this project is available at:
+ *
+ *    https://drewnoakes.com/code/exif/
+ *    https://github.com/drewnoakes/metadata-extractor
+ */
+package com.drew.imaging.heif;
+
+import com.drew.lang.annotations.NotNull;
+import com.drew.metadata.Directory;
+import com.drew.metadata.Metadata;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.heif.HeifDirectory;
+import org.junit.Test;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Collection;
+
+import static com.drew.metadata.heif.HeifDirectory.*;
+import static org.junit.Assert.*;
+
+public class HeifMetadataReaderTest
+{
+    @NotNull
+    private static Metadata processFile(@NotNull String filePath) throws IOException
+    {
+        FileInputStream inputStream = null;
+        try {
+            inputStream = new FileInputStream(filePath);
+            return HeifMetadataReader.readMetadata(inputStream);
+        } finally {
+            if (inputStream != null) {
+                inputStream.close();
+            }
+        }
+    }
+
+    private <D extends Directory> int getIntInAnyDir(Collection<D> directories, int tagType, int defaultValue) throws MetadataException {
+        for (D dir : directories) {
+            if (dir.containsTag(tagType)) {
+                return dir.getInt(tagType);
+            }
+        }
+        return defaultValue;
+    }
+
+    private void doTestImage(
+        @NotNull String filePath, int expectedWidth, int expectedHeight, int expectedRotation
+    ) throws Exception
+    {
+        Metadata metadata = processFile(filePath);
+        Collection<HeifDirectory> dirs = metadata.getDirectoriesOfType(HeifDirectory.class);
+
+        assertNotNull(dirs);
+        assertFalse(dirs.isEmpty());
+
+        assertEquals(expectedWidth, getIntInAnyDir(dirs, TAG_IMAGE_WIDTH, -1));
+        assertEquals(expectedHeight, getIntInAnyDir(dirs, TAG_IMAGE_HEIGHT, -1));
+        assertEquals(expectedRotation, getIntInAnyDir(dirs, TAG_IMAGE_ROTATION, -1));
+    }
+
+    @Test
+    public void testStillImage() throws Exception
+    {
+        doTestImage("Tests/Data/heif/still-images/autumn_1440x960.heic", 1440, 960, -1);
+    }
+
+    @Test
+    public void testDerivedImageGrid() throws Exception
+    {
+        doTestImage("Tests/Data/heif/image-derivations/grid_960x640.heic", 960, 640, -1);
+    }
+
+    @Test
+    public void testDerivedImageOverlay() throws Exception
+    {
+        doTestImage("Tests/Data/heif/image-derivations/overlay_1000x680.heic", 1000, 680, -1);
+    }
+
+    @Test
+    public void testImageCollection1() throws Exception
+    {
+        doTestImage("Tests/Data/heif/image-collections/random_collection_1440x960.heic", 1440, 960, -1);
+    }
+
+    @Test
+    public void testImageCollection2() throws Exception
+    {
+        doTestImage("Tests/Data/heif/image-collections/season_collection_1440x960.heic", 1440, 960, -1);
+    }
+
+    @Test
+    public void testImageSequence1() throws Exception
+    {
+        doTestImage("Tests/Data/heif/image-sequences/sea1_animation.heic", 256, 144, -1);
+    }
+
+    @Test
+    public void testImageSequence2() throws Exception
+    {
+        doTestImage("Tests/Data/heif/image-sequences/starfield_animation.heic", 256, 144, -1);
+    }
+
+    @Test
+    public void testAuxiliaryImageStorage() throws Exception
+    {
+        doTestImage("Tests/Data/heif/auxiliary-image-storage/alpha_1440x960.heic", 1440, 960, -1);
+    }
+
+    // Does not currently work
+    /*
+    @Test
+    public void testImageBurst1() throws Exception
+    {
+        doTestImage("Tests/Data/heif/image-bursts/bird_burst.heic", 640, 360, -1);
+    }
+
+    @Test
+    public void testImageBurst2() throws Exception
+    {
+        doTestImage("Tests/Data/heif/image-bursts/rally_burst.heic", 640, 360, -1);
+    }
+    */
+}