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 285 matching lines @@
     void DoRead(void* data, uint32 count, uint64 offset) override {
         fRawStream->read(data, count, offset);
     }
 
 private:
     SkRawStream* fRawStream;
 };
 
 class SkDngImage {
 public:
+    /*
+     * 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 CFA pattern.

[scroggo, 2016/02/03 15:56:02]

Should there be a comment somewhere describing what a "CFA pattern" is?

(Maybe it's common enough. When I looked up "demosaicing" (which always trips me
up until I interpret it as "de-mosaicing" (both are acceptable, according to
Wikipedia)), I see the following from Wikipedia:

A demosaicing (also de-mosaicing, demosaicking or debayering) algorithm is a
digital image process used to reconstruct a full color image from the incomplete
color samples output from an image sensor overlaid with a color filter array
(CFA). It is also known as CFA interpolation or color reconstruction.)

[ebrauer, 2016/02/04 15:17:08]

Done.

+     */
     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 int cfaPatternSize) {
+        fImageInfo = SkImageInfo::Make(width, height, kN32_SkColorType, kOpaque_SkAlphaType);
+
+        // The DNG SDK scales only for at demosaicing, so only when a mosaic info is available also

[scroggo, 2016/02/03 15:56:02]

I don't follow this sentence. I think you mean something like:

// The DNG SDK only scales during demosaicing, so scaling is only possible when
a mosaic info is available

[ebrauer, 2016/02/04 15:17:08]

Done.

+        // scale is available.
+        fIsScalable = cfaPatternSize != 0;
+        fIsXtransImage = fIsScalable ? cfaPatternSize == 36 : false;

[msarett, 2016/02/03 16:21:49]

This seems like a possible behavior change to me?

Is it possible for CFAPatternSize.v to be 3 and CFAPatternSize.h to be 12?  Is
this also an XtransImage?

[ebrauer, 2016/02/04 15:17:08]

The pattern size is either 0, 2x2 or 6x6, but theoretically it is possible to
have arbitrary patterns. I'll change this to something more robust.

+    }
+
+    bool initFromPiex() {
+        ::piex::PreviewImageData imageData;
+        if (::piex::IsRaw(fStream.get())

[scroggo, 2016/02/03 15:56:02]

These two methods have already been called by SkRawCodec::NewFromStream, down
below. Maybe SkRawStream should have a method that calls this and caches the
interesting information. (On the other hand, maybe these methods are cheap, and
it's simpler to call them again than to cache the values? It just seems weird
that we need to call them twice.)

[ebrauer, 2016/02/04 15:17:07]

Yes, they are pretty cheap that is why we try to use them instead of the DNG SDK
methods.

+            && ::piex::GetPreviewImageData(fStream.get(), &imageData) == ::piex::Error::kOk) {

[scroggo, 2016/02/03 15:56:02]

nit: Easier to follow along if you put the brace on the next line (since the if
condition is two lines)

[ebrauer, 2016/02/04 15:17:08]

Done.

+            init(static_cast<int>(imageData.full_width), static_cast<int>(imageData.full_height),

[scroggo, 2016/02/03 15:56:02]

this->init

[ebrauer, 2016/02/04 15:17:08]

Done.

+                imageData.cfa_pattern_dim[0] * imageData.cfa_pattern_dim[1]);

[scroggo, 2016/02/03 15:56:02]

nit: This should either be indented 8 spaces, or to line up with static_cast,
above.

[ebrauer, 2016/02/04 15:17:08]

Done.

+            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()),
+            dng_point cfaPattern(0, 0);

[scroggo, 2016/02/03 15:56:02]

Nit: it appears that a more accurate name for this is cfaPatternSize?

[ebrauer, 2016/02/04 15:17:08]

Done.

+            if (fNegative->GetMosaicInfo() != nullptr) {
+                cfaPattern = fNegative->GetMosaicInfo()->fCFAPatternSize;
+            }
+            init(static_cast<int>(fNegative->DefaultCropSizeH().As_real64()),

[scroggo, 2016/02/03 15:56:02]

this->init

[ebrauer, 2016/02/04 15:17:08]

Done.

                 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;
+                cfaPattern.v * cfaPattern.h);
             return true;
         } catch (...) {
-            fNegative.reset(nullptr);

[scroggo, 2016/02/03 15:56:02]

Why is this no longer necessary?

[ebrauer, 2016/02/04 15:17:08]

This is unrelated to the cl, but it is somehow misleading to reset only
fNegative and not all the other members. However, it is not necessary at all.
The new code is easier to read.

             return false;
         }
     }
 
     SkDngImage(SkRawStream* stream)
         : fStream(stream) {}
 
     SkDngMemoryAllocator fAllocator;
     SkAutoTDelete<SkRawStream> fStream;
     SkAutoTDelete<dng_host> fHost;
@@ skipping 132 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) {}