diff --git a/smartcameralib/build.gradle b/smartcameralib/build.gradle
index 7bd00e6..ac76586 100644
--- a/smartcameralib/build.gradle
+++ b/smartcameralib/build.gradle
@@ -8,8 +8,8 @@ android {
     defaultConfig {
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 7
-        versionName "1.2.1"
+        versionCode 8
+        versionName "1.3.0"
 
         externalNativeBuild {
             cmake {
diff --git a/smartcameralib/src/main/java/me/pqpo/smartcameralib/SmartCameraView.java b/smartcameralib/src/main/java/me/pqpo/smartcameralib/SmartCameraView.java
index ed80820..e1be445 100644
--- a/smartcameralib/src/main/java/me/pqpo/smartcameralib/SmartCameraView.java
+++ b/smartcameralib/src/main/java/me/pqpo/smartcameralib/SmartCameraView.java
@@ -3,6 +3,7 @@
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
+import android.graphics.Matrix;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import android.os.Handler;
@@ -15,6 +16,8 @@
 import com.google.android.cameraview.CameraView;
 import com.google.android.cameraview.base.Size;
 
+import me.pqpo.smartcameralib.utils.BitmapUtil;
+
 /**
  * Created by pqpo on 2018/8/15.
  */
@@ -153,10 +156,17 @@ public void cropJpegImage(final byte[] data, final CropCallback cropCallback) {
             @Override
             public void run() {
                 super.run();
-                Rect revisedMaskRect = getAdjustPictureMaskRect();
                 Bitmap bitmapSrc = BitmapFactory.decodeByteArray(data, 0, data.length);
+                int rotation = BitmapUtil.getOrientation(data);
+                if (rotation != 0) {
+                    Matrix m = new Matrix();
+                    m.setRotate(rotation);
+                    bitmapSrc = Bitmap.createBitmap(bitmapSrc, 0, 0, bitmapSrc.getWidth(), bitmapSrc.getHeight(), m, true);
+                }
+                Rect revisedMaskRect = getAdjustPictureMaskRect();
                 if (revisedMaskRect != null) {
-                    final Bitmap bitmap = Bitmap.createBitmap(bitmapSrc, revisedMaskRect.left, revisedMaskRect.top, revisedMaskRect.width(), revisedMaskRect.height());
+                    final Bitmap bitmap = Bitmap.createBitmap(bitmapSrc, revisedMaskRect.left, revisedMaskRect.top,
+                            revisedMaskRect.width(), revisedMaskRect.height());
                     bitmapSrc.recycle();
                     post(new Runnable() {
                         @Override
diff --git a/smartcameralib/src/main/java/me/pqpo/smartcameralib/utils/BitmapUtil.java b/smartcameralib/src/main/java/me/pqpo/smartcameralib/utils/BitmapUtil.java
new file mode 100644
index 0000000..430310d
--- /dev/null
+++ b/smartcameralib/src/main/java/me/pqpo/smartcameralib/utils/BitmapUtil.java
@@ -0,0 +1,127 @@
+package me.pqpo.smartcameralib.utils;
+
+import android.util.Log;
+
+
+/**
+ * Created by pqpo on 2018/9/29.
+ */
+public class BitmapUtil {
+
+    private static final String TAG = "BitmapUtil";
+
+    // 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;
+    }
+
+}