Optimize the SkRawStream when the input is an asset stream

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 146 matching lines @@
     }
 };
 
 }  // namespace
 
 // Note: this class could throw exception if it is used as dng_stream.
 class SkRawStream : public ::piex::StreamInterface {
 public:
     // Note that this call will take the ownership of stream.
     explicit SkRawStream(SkStream* stream)
-        : fStream(stream), fWholeStreamRead(false) {}
+        : fStream(stream)
+        , fWholeStreamRead(false)
+        , fIsSeekable(fStream->peekData() != nullptr) {}

[msarett, 2016/02/01 16:23:43]

I think maybe this is a mix of two suggestions.

I believe that "hasPosition()" is a good way to check if the stream is seekable.

"peekData()" is maybe a good way to get the memory base?  Though I can't find
peekData() in anywhere in Skia right now so I'm a little confused.

Regardless, it looks like this CL still optimizes for a memory base.

[scroggo, 2016/02/01 16:40:18]

That is correct.
Not yet checked in, but it's under review at crrev.com/1642943002

 
     ~SkRawStream() override {}
 
     /*
      * Creates an SkMemoryStream from the offset with size.
      * Note: for performance reason, this function is destructive to the SkRawStream. One should
      *       abandon current object after the function call.
      */
     SkMemoryStream* transferBuffer(size_t offset, size_t size) {
+        if (fIsSeekable) {
+            size_t sum;
+            if (!safe_add_to_size_t(offset, size, &sum)) {
+                return nullptr;
+            }
+            SkAutoTUnref<SkData> data(SkData::NewWithCopy(
+                static_cast<const uint8_t*>(fStream->peekData()->data()) + offset, size));
+            fStream.free();
+            return new SkMemoryStream(data);
+        }
+
         SkAutoTUnref<SkData> data(SkData::NewUninitialized(size));
         if (offset > fStreamBuffer.bytesWritten()) {
             // If the offset is not buffered, read from fStream directly and skip the buffering.
             const size_t skipLength = offset - fStreamBuffer.bytesWritten();
             if (fStream->skip(skipLength) != skipLength) {
                 return nullptr;
             }
             const size_t bytesRead = fStream->read(data->writable_data(), size);
             if (bytesRead < size) {
                 data.reset(SkData::NewSubset(data.get(), 0, bytesRead));
@@ skipping 17 matching lines @@
                     data.reset(SkData::NewSubset(data.get(), 0, newSize));
                 }
             }
         }
         return new SkMemoryStream(data);
     }
 
     // For PIEX
     ::piex::Error GetData(const size_t offset, const size_t length,
                           uint8* data) override {
-        if (offset == 0 && length == 0) {
-            return ::piex::Error::kOk;
-        }
-        size_t sum;
-        if (!safe_add_to_size_t(offset, length, &sum) || !this->bufferMoreData(sum)) {
-            return ::piex::Error::kFail;
-        }
-        if (!fStreamBuffer.read(data, offset, length)) {
-            return ::piex::Error::kFail;
-        }
-        return ::piex::Error::kOk;
+        return read(offset, length, static_cast<void*>(data)) ?
+            ::piex::Error::kOk : ::piex::Error::kFail;
     }
 
     // For dng_stream
     uint64 getLength() {
-        if (!this->bufferMoreData(kReadToEnd)) {  // read whole stream
-            ThrowReadFile();
+        if (fIsSeekable) {
+            return fStream->getLength();
+        } else {
+            if (!this->bufferMoreData(kReadToEnd)) {  // read whole stream
+                ThrowReadFile();
+            }
+            return fStreamBuffer.bytesWritten();
         }
-        return fStreamBuffer.bytesWritten();
     }
 
     // For dng_stream
-    void read(void* data, uint32 count, uint64 offset) {
-        if (count == 0 && offset == 0) {
-            return;
-        }
+    void dngRead(void* data, uint32 count, uint64 offset) {
         size_t sum;
         if (!safe_add_to_size_t(static_cast<uint64>(count), offset, &sum) ||
-            !this->bufferMoreData(sum)) {
-            ThrowReadFile();
-        }
-
-        if (!fStreamBuffer.read(data, static_cast<size_t>(offset), count)) {
+            !read(static_cast<size_t>(offset), static_cast<size_t>(count), data)) {
             ThrowReadFile();
         }
     }
 
 private:
+    bool read(size_t offset, size_t length, void* data) {
+        if (offset == 0 && length == 0) {
+            return true;
+        }
+
+        size_t sum;
+        if (!safe_add_to_size_t(offset, length, &sum)) {
+            return false;
+        }
+
+        if (fIsSeekable) {
+            if (sum > fStream->getLength()) {
+              return false;
+            }
+
+            return fStream->seek(offset) &&
+                (fStream->read(data, length) == length);
+        } else {
+            return this->bufferMoreData(sum) && fStreamBuffer.read(data, offset, length);
+        }
+    }
+
     // Note: if the newSize == kReadToEnd (0), this function will read to the end of stream.
     bool bufferMoreData(size_t newSize) {
+        SkASSERT(!fIsSeekable);
+
         if (newSize == kReadToEnd) {
             if (fWholeStreamRead) {  // already read-to-end.
                 return true;
             }
 
             // TODO: optimize for the special case when the input is SkMemoryStream.
             return SkStreamCopy(&fStreamBuffer, fStream.get());
         }
 
         if (newSize <= fStreamBuffer.bytesWritten()) {  // already buffered to newSize
             return true;
         }
         if (fWholeStreamRead) {  // newSize is larger than the whole stream.
             return false;
         }
 
         const size_t sizeToRead = newSize - fStreamBuffer.bytesWritten();
         SkAutoTMalloc<uint8> tempBuffer(sizeToRead);
         const size_t bytesRead = fStream->read(tempBuffer.get(), sizeToRead);
         if (bytesRead != sizeToRead) {
             return false;
         }
         return fStreamBuffer.write(tempBuffer.get(), bytesRead);
     }
 
     SkAutoTDelete<SkStream> fStream;
     bool fWholeStreamRead;
+    bool fIsSeekable;
 
     SkDynamicMemoryWStream fStreamBuffer;
 
     const size_t kReadToEnd = 0;
 };
 
 class SkDngStream : public dng_stream {
 public:
     SkDngStream(SkRawStream* rawStream) : fRawStream(rawStream) {}
 
     uint64 DoGetLength() override { return fRawStream->getLength(); }
 
     void DoRead(void* data, uint32 count, uint64 offset) override {
-        fRawStream->read(data, count, offset);
+        fRawStream->dngRead(data, count, offset);
     }
 
 private:
     SkRawStream* fRawStream;
 };
 
 class SkDngImage {
 public:
     static SkDngImage* NewFromStream(SkRawStream* stream) {
         SkAutoTDelete<SkDngImage> dngImage(new SkDngImage(stream));
@@ skipping 254 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) {}