Updates Piex and uses it to obtain the DNG dimensions.

src/codec/SkRawCodec.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 380 matching lines @@
             ThrowReadFile();
         }
     }
 
 private:
     SkRawStream* fStream;
 };
 
 class SkDngImage {
 public:
-    // Will take the ownership of the stream.
+    /*
+     * Initializes the object with the information from Piex in a first attempt. This way it can
+     * save time and storage to obtain the DNG dimensions and color filter array (CFA) pattern
+     * which is essential for the demosaicing of the sensor image.
+     * Note: this will take the ownership of the stream.
+     */
     static SkDngImage* NewFromStream(SkRawStream* stream) {
         SkAutoTDelete<SkDngImage> dngImage(new SkDngImage(stream));
-        if (!dngImage->readDng()) {
-            return nullptr;
+        if (!dngImage->initFromPiex()) {
+            if (!dngImage->readDng()) {
+                return nullptr;
+            }
         }
 
-        SkASSERT(dngImage->fNegative);
         return dngImage.release();
     }
 
     /*
      * Renders the DNG image to the size. The DNG SDK only allows scaling close to integer factors
      * down to 80 pixels on the short edge. The rendered image will be close to the specified size,
      * but there is no guarantee that any of the edges will match the requested size. E.g.
      *   100% size:              4000 x 3000
      *   requested size:         1600 x 1200
      *   returned size could be: 2000 x 1500
@@ skipping 51 matching lines @@
 
     bool isScalable() const {
         return fIsScalable;
     }
 
     bool isXtransImage() const {
         return fIsXtransImage;
     }
 
 private:
+    void init(const int width, const int height, const dng_point& cfaPatternSize) {
+        fImageInfo = SkImageInfo::Make(width, height, kN32_SkColorType, kOpaque_SkAlphaType);
+
+        // The DNG SDK scales only during demosaicing, so scaling is only possible when
+        // a mosaic info is available.
+        fIsScalable = cfaPatternSize.v != 0 && cfaPatternSize.h != 0;
+        fIsXtransImage = fIsScalable ? (cfaPatternSize.v == 6 && cfaPatternSize.h == 6) : false;
+    }
+
+    bool initFromPiex() {
+        // Does not take the ownership of rawStream.
+        SkPiexStream piexStream(fStream.get());
+        ::piex::PreviewImageData imageData;
+        if (::piex::IsRaw(&piexStream)
+            && ::piex::GetPreviewImageData(&piexStream, &imageData) == ::piex::Error::kOk)
+        {
+            dng_point cfaPatternSize(imageData.cfa_pattern_dim[1], imageData.cfa_pattern_dim[0]);
+            this->init(static_cast<int>(imageData.full_width),
+                       static_cast<int>(imageData.full_height), cfaPatternSize);
+            return true;
+        }
+        return false;
+    }
+
     bool readDng() {
         // Due to the limit of DNG SDK, we need to reset host and info.
         fHost.reset(new SkDngHost(&fAllocator));
         fInfo.reset(new dng_info);
         fDngStream.reset(new SkDngStream(fStream));
         try {
             fHost->ValidateSizes();
             fInfo->Parse(*fHost, *fDngStream);
             fInfo->PostParse(*fHost);
             if (!fInfo->IsValidDNG()) {
                 return false;
             }
 
             fNegative.reset(fHost->Make_dng_negative());
             fNegative->Parse(*fHost, *fDngStream, *fInfo);
             fNegative->PostParse(*fHost, *fDngStream, *fInfo);
             fNegative->SynchronizeMetadata();
 
-            fImageInfo = SkImageInfo::Make(
-                static_cast<int>(fNegative->DefaultCropSizeH().As_real64()),
-                static_cast<int>(fNegative->DefaultCropSizeV().As_real64()),
-                kN32_SkColorType, kOpaque_SkAlphaType);
-
-            // The DNG SDK scales only for at demosaicing, so only when a mosaic info
-            // is available also scale is available.
-            fIsScalable = fNegative->GetMosaicInfo() != nullptr;
-            fIsXtransImage = fIsScalable
-                ? (fNegative->GetMosaicInfo()->fCFAPatternSize.v == 6
-                   && fNegative->GetMosaicInfo()->fCFAPatternSize.h == 6)
-                : false;
+            dng_point cfaPatternSize(0, 0);
+            if (fNegative->GetMosaicInfo() != nullptr) {
+                cfaPatternSize = fNegative->GetMosaicInfo()->fCFAPatternSize;
+            }
+            this->init(static_cast<int>(fNegative->DefaultCropSizeH().As_real64()),
+                       static_cast<int>(fNegative->DefaultCropSizeV().As_real64()),
+                       cfaPatternSize);
             return true;
         } catch (...) {
-            fNegative.reset(nullptr);
             return false;
         }
     }
 
     SkDngImage(SkRawStream* stream)
         : fStream(stream) {}
 
     SkDngMemoryAllocator fAllocator;
     SkAutoTDelete<SkRawStream> fStream;
     SkAutoTDelete<dng_host> fHost;
@@ skipping 141 matching lines @@
     SkISize sizeFloor = this->onGetScaledDimensions(1.f / std::floor(fullShortEdge / shortEdge));
     SkISize sizeCeil = this->onGetScaledDimensions(1.f / std::ceil(fullShortEdge / shortEdge));
     return sizeFloor == dim || sizeCeil == dim;
 }
 
 SkRawCodec::~SkRawCodec() {}
 
 SkRawCodec::SkRawCodec(SkDngImage* dngImage)
     : INHERITED(dngImage->getImageInfo(), nullptr)
     , fDngImage(dngImage) {}