Changeset 13061 in josm for trunk/src/com/drew/metadata/exif/ExifDescriptorBase.java

Timestamp:

2017-10-30T22:46:09+01:00 (8 years ago)

Author:

Don-vip

Message:

fix #15505 - update to metadata-extractor 2.10.1

File:

• trunk/src/com/drew/metadata/exif/ExifDescriptorBase.java (modified) (12 diffs)

trunk/src/com/drew/metadata/exif/ExifDescriptorBase.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -26 +26 @@
 import com.drew.lang.annotations.NotNull;
 import com.drew.lang.annotations.Nullable;
+import com.drew.lang.ByteArrayReader;
 import com.drew.metadata.Directory;
 import com.drew.metadata.TagDescriptor;
 
+import java.io.IOException;
 import java.io.UnsupportedEncodingException;
-import java.math.RoundingMode;
 import java.text.DecimalFormat;
 import java.util.HashMap;
@@ -42 +43 @@
  * @author Drew Noakes https://drewnoakes.com
  */
+@SuppressWarnings("WeakerAccess")
 public abstract class ExifDescriptorBase<T extends Directory> extends TagDescriptor<T>
 {
@@ -49 +51 @@
      */
     private final boolean _allowDecimalRepresentationOfRationals = true;
-
-    @NotNull
-    private static final java.text.DecimalFormat SimpleDecimalFormatter = new DecimalFormat("0.#");
 
     // Note for the potential addition of brightness presentation in eV:
@@ -123 +122 @@
             case TAG_FILL_ORDER:
                 return getFillOrderDescription();
+            case TAG_CFA_PATTERN_2:
+                return getCfaPattern2Description();
             case TAG_EXPOSURE_TIME:
                 return getExposureTimeDescription();
@@ -167 +168 @@
             case TAG_SCENE_TYPE:
                 return getSceneTypeDescription();
+            case TAG_CFA_PATTERN:
+                return getCfaPatternDescription();
             case TAG_COMPONENTS_CONFIGURATION:
                 return getComponentConfigurationDescription();
@@ -234 +237 @@
     public String getReferenceBlackWhiteDescription()
     {
+        // For some reason, sometimes this is read as a long[] and
+        // getIntArray isn't able to deal with it
         int[] ints = _directory.getIntArray(TAG_REFERENCE_BLACK_WHITE);
         if (ints==null || ints.length < 6)
-            return null;
+        {
+            Object o = _directory.getObject(TAG_REFERENCE_BLACK_WHITE);
+            if (o != null && (o instanceof long[]))
+            {
+                long[] longs = (long[])o;
+                if (longs.length < 6)
+                    return null;
+
+                ints = new int[longs.length];
+                for (int i = 0; i < longs.length; i++)
+                    ints[i] = (int)longs[i];
+            }
+            else
+                return null;
+        }
+
         int blackR = ints[0];
         int whiteR = ints[1];
@@ -279 +299 @@
     public String getOrientationDescription()
     {
-        return getIndexedDescription(TAG_ORIENTATION, 1,
-            "Top, left side (Horizontal / normal)",
-            "Top, right side (Mirror horizontal)",
-            "Bottom, right side (Rotate 180)",
-            "Bottom, left side (Mirror vertical)",
-            "Left side, top (Mirror horizontal and rotate 270 CW)",
-            "Right side, top (Rotate 90 CW)",
-            "Right side, bottom (Mirror horizontal and rotate 90 CW)",
-            "Left side, bottom (Rotate 270 CW)");
+        return super.getOrientationDescription(TAG_ORIENTATION);
     }
 
@@ -443 +455 @@
     public String getNewSubfileTypeDescription()
     {
-        return getIndexedDescription(TAG_NEW_SUBFILE_TYPE, 1,
+        return getIndexedDescription(TAG_NEW_SUBFILE_TYPE, 0,
             "Full-resolution image",
             "Reduced-resolution image",
+            "Single page of multi-page image",
             "Single page of multi-page reduced-resolution image",
             "Transparency mask",
@@ -587 +600 @@
             : value.getNumerator() == 0
                 ? "Digital zoom not used"
-                : SimpleDecimalFormatter.format(value.doubleValue());
+                : new DecimalFormat("0.#").format(value.doubleValue());
     }
 
@@ -689 +702 @@
             "Directly photographed image"
         );
+    }
+
+    /// <summary>
+    /// String description of CFA Pattern
+    /// </summary>
+    /// <remarks>
+    /// Converted from Exiftool version 10.33 created by Phil Harvey
+    /// http://www.sno.phy.queensu.ca/~phil/exiftool/
+    /// lib\Image\ExifTool\Exif.pm
+    ///
+    /// Indicates the color filter array (CFA) geometric pattern of the image sensor when a one-chip color area sensor is used.
+    /// It does not apply to all sensing methods.
+    /// </remarks>
+    @Nullable
+    public String getCfaPatternDescription()
+    {
+        return formatCFAPattern(decodeCfaPattern(TAG_CFA_PATTERN));
+    }
+
+    /// <summary>
+    /// String description of CFA Pattern
+    /// </summary>
+    /// <remarks>
+    /// Indicates the color filter array (CFA) geometric pattern of the image sensor when a one-chip color area sensor is used.
+    /// It does not apply to all sensing methods.
+    ///
+    /// ExifDirectoryBase.TAG_CFA_PATTERN_2 holds only the pixel pattern. ExifDirectoryBase.TAG_CFA_REPEAT_PATTERN_DIM is expected to exist and pass
+    /// some conditional tests.
+    /// </remarks>
+    @Nullable
+    public String getCfaPattern2Description()
+    {
+        byte[] values = _directory.getByteArray(TAG_CFA_PATTERN_2);
+        if (values == null)
+            return null;
+
+        int[] repeatPattern = _directory.getIntArray(TAG_CFA_REPEAT_PATTERN_DIM);
+        if (repeatPattern == null)
+            return String.format("Repeat Pattern not found for CFAPattern (%s)", super.getDescription(TAG_CFA_PATTERN_2));
+
+        if (repeatPattern.length == 2 && values.length == (repeatPattern[0] * repeatPattern[1]))
+        {
+            int[] intpattern = new int[2 + values.length];
+            intpattern[0] = repeatPattern[0];
+            intpattern[1] = repeatPattern[1];
+
+            for (int i = 0; i < values.length; i++)
+                intpattern[i + 2] = values[i] & 0xFF;   // convert the values[i] byte to unsigned
+
+            return formatCFAPattern(intpattern);
+        }
+
+        return String.format("Unknown Pattern (%s)", super.getDescription(TAG_CFA_PATTERN_2));
+    }
+
+    @Nullable
+    private static String formatCFAPattern(@Nullable int[] pattern)
+    {
+        if (pattern == null)
+            return null;
+        if (pattern.length < 2)
+            return "<truncated data>";
+        if (pattern[0] == 0 && pattern[1] == 0)
+            return "<zero pattern size>";
+
+        int end = 2 + pattern[0] * pattern[1];
+        if (end > pattern.length)
+            return "<invalid pattern size>";
+
+        String[] cfaColors = { "Red", "Green", "Blue", "Cyan", "Magenta", "Yellow", "White" };
+
+        StringBuilder ret = new StringBuilder();
+        ret.append("[");
+        for (int pos = 2; pos < end; pos++)
+        {
+            if (pattern[pos] <= cfaColors.length - 1)
+                ret.append(cfaColors[pattern[pos]]);
+            else
+                ret.append("Unknown");      // indicated pattern position is outside the array bounds
+
+            if ((pos - 2) % pattern[1] == 0)
+                ret.append(",");
+            else if(pos != end - 1)
+                ret.append("][");
+        }
+        ret.append("]");
+
+        return ret.toString();
+    }
+
+    /// <summary>
+    /// Decode raw CFAPattern value
+    /// </summary>
+    /// <remarks>
+    /// Converted from Exiftool version 10.33 created by Phil Harvey
+    /// http://www.sno.phy.queensu.ca/~phil/exiftool/
+    /// lib\Image\ExifTool\Exif.pm
+    ///
+    /// The value consists of:
+    /// - Two short, being the grid width and height of the repeated pattern.
+    /// - Next, for every pixel in that pattern, an identification code.
+    /// </remarks>
+    @Nullable
+    private int[] decodeCfaPattern(int tagType)
+    {
+        int[] ret;
+
+        byte[] values = _directory.getByteArray(tagType);
+        if (values == null)
+            return null;
+
+        if (values.length < 4)
+        {
+            ret = new int[values.length];
+            for (int i = 0; i < values.length; i++)
+                ret[i] = values[i];
+            return ret;
+        }
+
+        ret = new int[values.length - 2];
+
+        try {
+            ByteArrayReader reader = new ByteArrayReader(values);
+
+            // first two values should be read as 16-bits (2 bytes)
+            short item0 = reader.getInt16(0);
+            short item1 = reader.getInt16(2);
+
+            Boolean copyArray = false;
+            int end = 2 + item0 * item1;
+            if (end > values.length) // sanity check in case of byte order problems; calculated 'end' should be <= length of the values
+            {
+                // try swapping byte order (I have seen this order different than in EXIF)
+                reader.setMotorolaByteOrder(!reader.isMotorolaByteOrder());
+                item0 = reader.getInt16(0);
+                item1 = reader.getInt16(2);
+
+                if (values.length >= (2 + item0 * item1))
+                    copyArray = true;
+            }
+            else
+                copyArray = true;
+
+            if(copyArray)
+            {
+                ret[0] = item0;
+                ret[1] = item1;
+
+                for (int i = 4; i < values.length; i++)
+                    ret[i - 2] = reader.getInt8(i);
+            }
+        } catch (IOException ex) {
+            _directory.addError("IO exception processing data: " + ex.getMessage());
+        }
+
+        return ret;
     }
 
@@ -1002 +1171 @@
     public String getShutterSpeedDescription()
     {
-        // I believe this method to now be stable, but am leaving some alternative snippets of
-        // code in here, to assist anyone who's looking into this (given that I don't have a public CVS).
-
-//        float apexValue = _directory.getFloat(ExifSubIFDDirectory.TAG_SHUTTER_SPEED);
-//        int apexPower = (int)Math.pow(2.0, apexValue);
-//        return "1/" + apexPower + " sec";
-        // TODO test this method
-        // thanks to Mark Edwards for spotting and patching a bug in the calculation of this
-        // description (spotted bug using a Canon EOS 300D)
-        // thanks also to Gli Blr for spotting this bug
-        Float apexValue = _directory.getFloatObject(TAG_SHUTTER_SPEED);
-        if (apexValue == null)
-            return null;
-        if (apexValue <= 1) {
-            float apexPower = (float)(1 / (Math.exp(apexValue * Math.log(2))));
-            long apexPower10 = Math.round((double)apexPower * 10.0);
-            float fApexPower = (float)apexPower10 / 10.0f;
-            DecimalFormat format = new DecimalFormat("0.##");
-            format.setRoundingMode(RoundingMode.HALF_UP);
-            return format.format(fApexPower) + " sec";
-        } else {
-            int apexPower = (int)((Math.exp(apexValue * Math.log(2))));
-            return "1/" + apexPower + " sec";
-        }
-
-/*
-        // This alternative implementation offered by Bill Richards
-        // TODO determine which is the correct / more-correct implementation
-        double apexValue = _directory.getDouble(ExifSubIFDDirectory.TAG_SHUTTER_SPEED);
-        double apexPower = Math.pow(2.0, apexValue);
-
-        StringBuffer sb = new StringBuffer();
-        if (apexPower > 1)
-            apexPower = Math.floor(apexPower);
-
-        if (apexPower < 1) {
-            sb.append((int)Math.round(1/apexPower));
-        } else {
-            sb.append("1/");
-            sb.append((int)apexPower);
-        }
-        sb.append(" sec");
-        return sb.toString();
-*/
+        return super.getShutterSpeedDescription(TAG_SHUTTER_SPEED);
     }