Enable RAW codec for Windows

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 133 matching lines @@
     void read(void* data, uint32 count, uint64 offset) {
         if (count == 0 && offset == 0) {
             return;
         }
         size_t sum;
         if (!safe_add_to_size_t(static_cast<uint64>(count), offset, &sum) ||
             !this->bufferMoreData(sum)) {
             ThrowReadFile();
         }
 
-        if (!fStreamBuffer.read(data, offset, count)) {
+        if (!fStreamBuffer.read(data, static_cast<size_t>(offset), count)) {
             ThrowReadFile();
         }
     }
 
 private:
     // Note: if the newSize == kReadToEnd (0), this function will read to the end of stream.
     bool bufferMoreData(size_t newSize) {
         if (newSize == kReadToEnd) {
             if (fWholeStreamRead) {  // already read-to-end.
                 return true;
@@ skipping 132 matching lines @@
             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(fNegative->DefaultCropSizeH().As_real64(),
-                                           fNegative->DefaultCropSizeV().As_real64(),
-                                           kN32_SkColorType, kOpaque_SkAlphaType);
+            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;
             return true;
         } catch (...) {
@@ skipping 114 matching lines @@
 }
 
 SkISize SkRawCodec::onGetScaledDimensions(float desiredScale) const {
     SkASSERT(desiredScale <= 1.f);
     const SkISize dim = this->getInfo().dimensions();
     if (!fDngImage->isScalable()) {
         return dim;
     }
 
     // Limits the minimum size to be 80 on the short edge.
-    const float shortEdge = SkTMin(dim.fWidth, dim.fHeight);
+    const float shortEdge = static_cast<float>(SkTMin(dim.fWidth, dim.fHeight));
     if (desiredScale < 80.f / shortEdge) {
         desiredScale = 80.f / shortEdge;
     }
 
     // For Xtrans images, the integer-factor scaling does not support the half-size scaling case
     // (stronger downscalings are fine). In this case, returns the factor "3" scaling instead.
     if (fDngImage->isXtransImage() && desiredScale > 1.f / 3.f && desiredScale < 1.f) {
         desiredScale = 1.f / 3.f;
     }
 
     // Round to integer-factors.
     const float finalScale = std::floor(1.f/ desiredScale);
-    return SkISize::Make(std::floor(dim.fWidth / finalScale),
-                         std::floor(dim.fHeight / finalScale));
+    return SkISize::Make(static_cast<int32_t>(std::floor(dim.fWidth / finalScale)),
+                         static_cast<int32_t>(std::floor(dim.fHeight / finalScale)));
 }
 
 bool SkRawCodec::onDimensionsSupported(const SkISize& dim) {
     const SkISize fullDim = this->getInfo().dimensions();
-    const float fullShortEdge = SkTMin(fullDim.fWidth, fullDim.fHeight);
-    const float shortEdge = SkTMin(dim.fWidth, dim.fHeight);
+    const float fullShortEdge = static_cast<float>(SkTMin(fullDim.fWidth, fullDim.fHeight));
+    const float shortEdge = static_cast<float>(SkTMin(dim.fWidth, dim.fHeight));
 
     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) {}