Add an Option for orientation on JPEG encodes

Move Origin to its own header so that SkPixmap and SkJpegEncoder need
not depend on SkCodec.

Add libexif, which is already used by Android, and use it to write the
orientation. Write a makefile based on the Android.bp in Android, minus
warnings. (libexif has an LGPL license.)

Add a test that verifies all the orientations work.

Optionally enable writing the orientation (and therefore including
libexif). Chromium does not currently need it, and Android does not
expose an API that would allow using it. Disable on Windows, where we
still have build errors to fix.

Bug: skia:7138
Change-Id: Iaeff44c36aebe0e639666979dc00e1b7594bbeb1
Reviewed-on: https://skia-review.googlesource.com/60721
Commit-Queue: Leon Scroggins <scroggo@google.com>
Reviewed-by: Mike Klein <mtklein@chromium.org>
Reviewed-by: Mike Reed <reed@google.com>

6 files changed, 65 insertions, 25 deletions

diff --git a/src/codec/SkCodec.cpp b/src/codec/SkCodec.cpp
index c3d99f2793..59978c6fdf 100644
--- a/src/codec/SkCodec.cpp
+++ b/src/codec/SkCodec.cpp
@@ -128,7 +128,7 @@ std::unique_ptr<SkCodec> SkCodec::MakeFromData(sk_sp<SkData> data, SkPngChunkRea
 
 SkCodec::SkCodec(int width, int height, const SkEncodedInfo& info,
         XformFormat srcFormat, std::unique_ptr<SkStream> stream,
-        sk_sp<SkColorSpace> colorSpace, Origin origin)
+        sk_sp<SkColorSpace> colorSpace, SkEncodedOrigin origin)
     : fEncodedInfo(info)
     , fSrcInfo(info.makeImageInfo(width, height, std::move(colorSpace)))
     , fSrcXformFormat(srcFormat)
@@ -142,7 +142,8 @@ SkCodec::SkCodec(int width, int height, const SkEncodedInfo& info,
 {}
 
 SkCodec::SkCodec(const SkEncodedInfo& info, const SkImageInfo& imageInfo,
-        XformFormat srcFormat, std::unique_ptr<SkStream> stream, Origin origin)
+        XformFormat srcFormat, std::unique_ptr<SkStream> stream,
+        SkEncodedOrigin origin)
     : fEncodedInfo(info)
     , fSrcInfo(imageInfo)
     , fSrcXformFormat(srcFormat)
diff --git a/src/codec/SkCodecImageGenerator.cpp b/src/codec/SkCodecImageGenerator.cpp
index e8d7d3038a..741c8e393d 100644
--- a/src/codec/SkCodecImageGenerator.cpp
+++ b/src/codec/SkCodecImageGenerator.cpp
@@ -15,23 +15,23 @@
 #define kSwapXY     SkPixmapPriv::kSwapXY
 
 const uint8_t gOrientationFlags[] = {
-    0,                              // kTopLeft_Origin
-    kMirrorX,                       // kTopRight_Origin
-    kMirrorX | kMirrorY,            // kBottomRight_Origin
-               kMirrorY,            // kBottomLeft_Origin
-                          kSwapXY,  // kLeftTop_Origin
-    kMirrorX            | kSwapXY,  // kRightTop_Origin
-    kMirrorX | kMirrorY | kSwapXY,  // kRightBottom_Origin
-               kMirrorY | kSwapXY,  // kLeftBottom_Origin
+    0,                              // kTopLeft_SkEncodedOrigin
+    kMirrorX,                       // kTopRight_SkEncodedOrigin
+    kMirrorX | kMirrorY,            // kBottomRight_SkEncodedOrigin
+               kMirrorY,            // kBottomLeft_SkEncodedOrigin
+                          kSwapXY,  // kLeftTop_SkEncodedOrigin
+    kMirrorX            | kSwapXY,  // kRightTop_SkEncodedOrigin
+    kMirrorX | kMirrorY | kSwapXY,  // kRightBottom_SkEncodedOrigin
+               kMirrorY | kSwapXY,  // kLeftBottom_SkEncodedOrigin
 };
 
-SkPixmapPriv::OrientFlags SkPixmapPriv::OriginToOrient(SkCodec::Origin o) {
+SkPixmapPriv::OrientFlags SkPixmapPriv::OriginToOrient(SkEncodedOrigin o) {
     unsigned io = static_cast<int>(o) - 1;
     SkASSERT(io < SK_ARRAY_COUNT(gOrientationFlags));
     return static_cast<SkPixmapPriv::OrientFlags>(gOrientationFlags[io]);
 }
 
-static bool should_swap_width_height(SkCodec::Origin o) {
+static bool should_swap_width_height(SkEncodedOrigin o) {
     return SkToBool(SkPixmapPriv::OriginToOrient(o) & kSwapXY);
 }
 
@@ -73,12 +73,12 @@ SkData* SkCodecImageGenerator::onRefEncodedData() {
 
 bool SkCodecImageGenerator::onGetPixels(const SkImageInfo& requestInfo, void* requestPixels,
                                         size_t requestRowBytes, const Options& opts) {
-    const SkCodec::Origin origin = fCodec->getOrigin();
+    const auto origin = fCodec->getOrigin();
     const SkPixmap request(requestInfo, requestPixels, requestRowBytes);
     const SkPixmap* codecMap = &request;
     SkAutoPixmapStorage storage;    // used if we have to post-orient the output from the codec
 
-    if (origin != SkCodec::kTopLeft_Origin) {
+    if (origin != kTopLeft_SkEncodedOrigin) {
         SkImageInfo info = requestInfo;
         if (should_swap_width_height(origin)) {
             info = swap_width_height(info);
diff --git a/src/codec/SkJpegCodec.cpp b/src/codec/SkJpegCodec.cpp
index be5c9f7942..062f05bd01 100644
--- a/src/codec/SkJpegCodec.cpp
+++ b/src/codec/SkJpegCodec.cpp
@@ -45,7 +45,7 @@ static uint32_t get_endian_int(const uint8_t* data, bool littleEndian) {
 const uint32_t kExifHeaderSize = 14;
 const uint32_t kExifMarker = JPEG_APP0 + 1;
 
-static bool is_orientation_marker(jpeg_marker_struct* marker, SkCodec::Origin* orientation) {
+static bool is_orientation_marker(jpeg_marker_struct* marker, SkEncodedOrigin* orientation) {
     if (kExifMarker != marker->marker || marker->data_length < kExifHeaderSize) {
         return false;
     }
@@ -87,8 +87,8 @@ static bool is_orientation_marker(jpeg_marker_struct* marker, SkCodec::Origin* o
         uint32_t count = get_endian_int(data + 4, littleEndian);
         if (kOriginTag == tag && kOriginType == type && 1 == count) {
             uint16_t val = get_endian_short(data + 8, littleEndian);
-            if (0 < val && val <= SkCodec::kLast_Origin) {
-                *orientation = (SkCodec::Origin) val;
+            if (0 < val && val <= kLast_SkEncodedOrigin) {
+                *orientation = (SkEncodedOrigin) val;
                 return true;
             }
         }
@@ -97,15 +97,15 @@ static bool is_orientation_marker(jpeg_marker_struct* marker, SkCodec::Origin* o
     return false;
 }
 
-static SkCodec::Origin get_exif_orientation(jpeg_decompress_struct* dinfo) {
-    SkCodec::Origin orientation;
+static SkEncodedOrigin get_exif_orientation(jpeg_decompress_struct* dinfo) {
+    SkEncodedOrigin orientation;
     for (jpeg_marker_struct* marker = dinfo->marker_list; marker; marker = marker->next) {
         if (is_orientation_marker(marker, &orientation)) {
             return orientation;
         }
     }
 
-    return SkCodec::kDefault_Origin;
+    return kDefault_SkEncodedOrigin;
 }
 
 static bool is_icc_marker(jpeg_marker_struct* marker) {
@@ -227,7 +227,7 @@ SkCodec::Result SkJpegCodec::ReadHeader(SkStream* stream, SkCodec** codecOut,
         // Create image info object and the codec
         SkEncodedInfo info = SkEncodedInfo::Make(color, SkEncodedInfo::kOpaque_Alpha, 8);
 
-        Origin orientation = get_exif_orientation(decoderMgr->dinfo());
+        SkEncodedOrigin orientation = get_exif_orientation(decoderMgr->dinfo());
         sk_sp<SkData> iccData = get_icc_profile(decoderMgr->dinfo());
         sk_sp<SkColorSpace> colorSpace = nullptr;
         if (iccData) {
@@ -284,7 +284,7 @@ std::unique_ptr<SkCodec> SkJpegCodec::MakeFromStream(std::unique_ptr<SkStream> s
 
 SkJpegCodec::SkJpegCodec(int width, int height, const SkEncodedInfo& info,
                          std::unique_ptr<SkStream> stream, JpegDecoderMgr* decoderMgr,
-                         sk_sp<SkColorSpace> colorSpace, Origin origin)
+                         sk_sp<SkColorSpace> colorSpace, SkEncodedOrigin origin)
     : INHERITED(width, height, info, SkColorSpaceXform::kRGBA_8888_ColorFormat, std::move(stream),
                 std::move(colorSpace), origin)
     , fDecoderMgr(decoderMgr)
diff --git a/src/codec/SkJpegCodec.h b/src/codec/SkJpegCodec.h
index fd8ee63d6c..41814d2ead 100644
--- a/src/codec/SkJpegCodec.h
+++ b/src/codec/SkJpegCodec.h
@@ -107,7 +107,7 @@ private:
      *                   takes ownership
      */
     SkJpegCodec(int width, int height, const SkEncodedInfo& info, std::unique_ptr<SkStream> stream,
-            JpegDecoderMgr* decoderMgr, sk_sp<SkColorSpace> colorSpace, Origin origin);
+            JpegDecoderMgr* decoderMgr, sk_sp<SkColorSpace> colorSpace, SkEncodedOrigin origin);
 
     /*
      * Checks if the conversion between the input image and the requested output
diff --git a/src/core/SkPixmapPriv.h b/src/core/SkPixmapPriv.h
index dfc9ce2dd0..1d677fdc46 100644
--- a/src/core/SkPixmapPriv.h
+++ b/src/core/SkPixmapPriv.h
@@ -9,7 +9,7 @@
 #define SkPixmapPriv_DEFINED
 
 #include "SkPixmap.h"
-#include "SkCodec.h"
+#include "SkEncodedOrigin.h"
 
 class SkPixmapPriv {
 public:
@@ -20,7 +20,7 @@ public:
         kSwapXY  = 1 << 2,
     };
 
-    static OrientFlags OriginToOrient(SkCodec::Origin);
+    static OrientFlags OriginToOrient(SkEncodedOrigin);
 
     /**
      *  Copy the pixels in this pixmap into dst, applying the orientation transformations specified
diff --git a/src/images/SkJpegEncoder.cpp b/src/images/SkJpegEncoder.cpp
index 9fade2449a..3f818286a1 100644
--- a/src/images/SkJpegEncoder.cpp
+++ b/src/images/SkJpegEncoder.cpp
@@ -11,6 +11,7 @@
 
 #include "SkColorData.h"
 #include "SkColorSpace_Base.h"
+#include "SkEncodedOrigin.h"
 #include "SkImageEncoderFns.h"
 #include "SkImageInfoPriv.h"
 #include "SkJpegEncoder.h"
@@ -18,6 +19,12 @@
 #include "SkStream.h"
 #include "SkTemplates.h"
 
+#ifdef SK_HAS_EXIF_LIBRARY
+#include "libexif/exif-byte-order.h"
+#include "libexif/exif-data.h"
+#include "libexif/exif-format.h"
+#endif
+
 #include <stdio.h>
 
 extern "C" {
@@ -213,6 +220,38 @@ std::unique_ptr<SkEncoder> SkJpegEncoder::Make(SkWStream* dst, const SkPixmap& s
         jpeg_write_marker(encoderMgr->cinfo(), kICCMarker, markerData->bytes(), markerData->size());
     }
 
+#ifdef SK_HAS_EXIF_LIBRARY
+    if (options.fOrigin != kDefault_SkEncodedOrigin) {
+        // Create ExifData.
+        const auto kByteOrder = EXIF_BYTE_ORDER_INTEL;
+        SkAutoTCallVProc<ExifData, exif_data_unref> exif(exif_data_new());
+        exif_data_set_option(exif.get(), EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
+        exif_data_set_data_type(exif.get(), EXIF_DATA_TYPE_COMPRESSED);
+        exif_data_set_byte_order(exif.get(), kByteOrder);
+        exif_data_fix(exif.get());
+
+        // Create entry for rotation.
+        SkAutoTCallVProc<ExifMem, exif_mem_unref> mem(exif_mem_new_default());
+        SkAutoTCallVProc<ExifEntry, exif_entry_unref> entry(exif_entry_new_mem(mem));
+        size_t size = exif_format_get_size(EXIF_FORMAT_SHORT);
+        entry->data = reinterpret_cast<unsigned char*>(exif_mem_alloc(mem, size));
+        entry->size = size;
+        entry->tag = EXIF_TAG_ORIENTATION;
+        entry->components = 1;
+        entry->format = EXIF_FORMAT_SHORT;
+        exif_content_add_entry(exif->ifd[EXIF_IFD_0], entry);
+        exif_set_short(entry->data, kByteOrder, (ExifShort) options.fOrigin);
+
+        // Serialize the data.
+        unsigned char* exif_data;
+        unsigned int exif_data_len;
+        exif_data_save_data(exif.get(), &exif_data, &exif_data_len);
+        const uint32_t kExifMarker = JPEG_APP0 + 1;
+        jpeg_write_marker(encoderMgr->cinfo(), kExifMarker, exif_data, exif_data_len);
+        sk_free(exif_data);
+    }
+#endif
+
     return std::unique_ptr<SkJpegEncoder>(new SkJpegEncoder(std::move(encoderMgr), src));
 }