Add a quick check to the TIFF header of DNG image

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 197 matching lines @@
         if (!safe_add_to_size_t(this->bytesWritten(), size, &newSize) ||
             newSize > kMaxStreamSize)
         {
             SkCodecPrintf("Error: Stream size exceeds the limit.\n");
             return false;
         }
         return this->INHERITED::write(buffer, size);
     }
 
 private:
+    // Most of valid RAW images will not be larger than 100MB. This limit is helpful to avoid
+    // streaming too large data chunk. We can always adjust the limit here if we need.
     const size_t kMaxStreamSize = 100 * 1024 * 1024;  // 100MB
 
     typedef SkDynamicMemoryWStream INHERITED;
 };
 
 // Note: the maximum buffer size is 100MB (limited by SkRawLimitedDynamicMemoryWStream).
 class SkRawBufferedStream : public SkRawStream {
 public:
     // Will take the ownership of the stream.
     explicit SkRawBufferedStream(SkStream* stream)
@@ skipping 210 matching lines @@
 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 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->isTiffHeaderValid()) {

[msarett, 2016/03/10 13:51:56]

Just to make sure I understand:

All dngs should have a TIFF header.  So we fail immediately if there is no TIFF
header.  Otherwise, we go ahead and check PIEX/dng_sdk as usual.

This should stop us from buffering video streams etc. because they likely won't
match the TIFF header.

[yujieqin, 2016/03/10 13:56:03]

Yes, DNG image is basically an extended TIFF. It should always contain the
standard TIFF header. This check should block out most of the non-TIFF data
(e.g. video), so that we don't even need to try to buffer the up-to-100MB data.

+            return nullptr;
+        }
+
         if (!dngImage->initFromPiex()) {
             if (!dngImage->readDng()) {
                 return nullptr;
             }
         }
 
         return dngImage.release();
     }
 
     /*
@@ skipping 57 matching lines @@
 
     bool isScalable() const {
         return fIsScalable;
     }
 
     bool isXtransImage() const {
         return fIsXtransImage;
     }
 
 private:
+    // Quick check if the image contains a valid TIFF header as requested by DNG format.
+    bool isTiffHeaderValid() const {
+        const size_t kHeaderSize = 4;
+        SkAutoSTMalloc<kHeaderSize, unsigned char> header(kHeaderSize);
+        if (!fStream->read(header.get(), 0 /* offset */, kHeaderSize)) {
+            return false;
+        }
+
+        // Check if the header is valid (endian info and magic number "42").
+        return
+            (header[0] == 0x49 && header[1] == 0x49 && header[2] == 0x2A && header[3] == 0x00) ||
+            (header[0] == 0x4D && header[1] == 0x4D && header[2] == 0x00 && header[3] == 0x2A);
+    }
+
     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() {
@@ skipping 197 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) {}