Merge pull request #1 from tmickel/exif-camera-rotation

Rotate Android photos to account for JPEG/EXIF rotation

android/ScratchJr/app/src/main/java/org/scratchjr/android/CameraExif.java

@@ -0,0 +1,137 @@
+package org.scratchjr.android;
+
+import android.util.Log;
+
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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.
+*/
+
+public class CameraExif {
+    private static final String TAG = "CameraExif";
+
+    // Returns the degrees in clockwise. Values are 0, 90, 180, or 270.
+    public static int getOrientation(byte[] jpeg) {
+        if (jpeg == null) {
+            return 0;
+        }
+
+        int offset = 0;
+        int length = 0;
+
+        // ISO/IEC 10918-1:1993(E)
+        while (offset + 3 < jpeg.length && (jpeg[offset++] & 0xFF) == 0xFF) {
+            int marker = jpeg[offset] & 0xFF;
+
+            // Check if the marker is a padding.
+            if (marker == 0xFF) {
+                continue;
+            }
+            offset++;
+
+            // Check if the marker is SOI or TEM.
+            if (marker == 0xD8 || marker == 0x01) {
+                continue;
+            }
+            // Check if the marker is EOI or SOS.
+            if (marker == 0xD9 || marker == 0xDA) {
+                break;
+            }
+
+            // Get the length and check if it is reasonable.
+            length = pack(jpeg, offset, 2, false);
+            if (length < 2 || offset + length > jpeg.length) {
+                Log.e(TAG, "Invalid length");
+                return 0;
+            }
+
+            // Break if the marker is EXIF in APP1.
+            if (marker == 0xE1 && length >= 8 &&
+                    pack(jpeg, offset + 2, 4, false) == 0x45786966 &&
+                    pack(jpeg, offset + 6, 2, false) == 0) {
+                offset += 8;
+                length -= 8;
+                break;
+            }
+
+            // Skip other markers.
+            offset += length;
+            length = 0;
+        }
+
+        // JEITA CP-3451 Exif Version 2.2
+        if (length > 8) {
+            // Identify the byte order.
+            int tag = pack(jpeg, offset, 4, false);
+            if (tag != 0x49492A00 && tag != 0x4D4D002A) {
+                Log.e(TAG, "Invalid byte order");
+                return 0;
+            }
+            boolean littleEndian = (tag == 0x49492A00);
+
+            // Get the offset and check if it is reasonable.
+            int count = pack(jpeg, offset + 4, 4, littleEndian) + 2;
+            if (count < 10 || count > length) {
+                Log.e(TAG, "Invalid offset");
+                return 0;
+            }
+            offset += count;
+            length -= count;
+
+            // Get the count and go through all the elements.
+            count = pack(jpeg, offset - 2, 2, littleEndian);
+            while (count-- > 0 && length >= 12) {
+                // Get the tag and check if it is orientation.
+                tag = pack(jpeg, offset, 2, littleEndian);
+                if (tag == 0x0112) {
+                    // We do not really care about type and count, do we?
+                    int orientation = pack(jpeg, offset + 8, 2, littleEndian);
+                    switch (orientation) {
+                        case 1:
+                            return 0;
+                        case 3:
+                            return 180;
+                        case 6:
+                            return 90;
+                        case 8:
+                            return 270;
+                    }
+                    Log.i(TAG, "Unsupported orientation");
+                    return 0;
+                }
+                offset += 12;
+                length -= 12;
+            }
+        }
+
+        Log.i(TAG, "Orientation not found");
+        return 0;
+    }
+
+    private static int pack(byte[] bytes, int offset, int length,
+                            boolean littleEndian) {
+        int step = 1;
+        if (littleEndian) {
+            offset += length - 1;
+            step = -1;
+        }
+
+        int value = 0;
+        while (length-- > 0) {
+            value = (value << 8) | (bytes[offset] & 0xFF);
+            offset += step;
+        }
+        return value;
+    }
+}

android/ScratchJr/app/src/main/java/org/scratchjr/android/CameraView.java

@@ -179,12 +179,12 @@ public class CameraView
 
     /**
      * Take the given bitmap image from the camera and transform it to the correct
-     * aspect ratio and size.
+     * aspect ratio, size, and rotation.
      *
      * @return jpeg-encoded data of the transformed image.
      */
-    public byte[] getTransformedImage(Bitmap originalImage) {
-        Bitmap cropped = cropAndResize(originalImage);
+    public byte[] getTransformedImage(Bitmap originalImage, int exifRotation) {
+        Bitmap cropped = cropResizeAndRotate(originalImage, exifRotation);
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         cropped.compress(CompressFormat.JPEG, 90, bos);
         try {
@@ -202,7 +202,7 @@ public class CameraView
      *
      * If the image was front-facing, also mirror horizontally.
      */
-    private Bitmap cropAndResize(Bitmap image) {
+    private Bitmap cropResizeAndRotate(Bitmap image, int exifRotation) {
         int imageWidth = image.getWidth();
         int imageHeight = image.getHeight();
         float rectWidth = _rect.width();
@@ -220,6 +220,8 @@ public class CameraView
         }
         
         Matrix m = new Matrix();
+        // Adjust the image to undo rotation done by JPEG generator
+        m.postRotate(-1.0f * exifRotation);
         if (_currentFacingFront) {
             // flip bitmap horizontally since front-facing camera is mirrored
             m.preScale(-1.0f, 1.0f);

android/ScratchJr/app/src/main/java/org/scratchjr/android/JavaScriptDirectInterface.java

@@ -476,7 +476,9 @@ public class JavaScriptDirectInterface {
     private void sendBase64Image(String onCameraCaptureComplete, byte[] jpegData) {
         Bitmap bitmap = BitmapFactory.decodeByteArray(jpegData, 0, jpegData.length);
         Log.i(LOG_TAG, "Picture size: " + bitmap.getWidth() + " x " + bitmap.getHeight());
-        byte[] translatedJpegData = _cameraView.getTransformedImage(bitmap);
+        int exifRotation = CameraExif.getOrientation(jpegData);
+        Log.i(LOG_TAG, "Picture rotation: " + exifRotation);
+        byte[] translatedJpegData = _cameraView.getTransformedImage(bitmap, exifRotation);
         String base64Data = Base64.encodeToString(translatedJpegData, Base64.NO_WRAP);
         closeFeed();
         _activity.runJavaScript(onCameraCaptureComplete + "('" + base64Data + "');");