Add SkCodec, including PNG implementation.

src/codec/SkCodec.cpp

+/*
+ * Copyright 2015 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 "SkData.h"
+#include "SkCodec_libpng.h"
+#include "SkStream.h"
+
+SkCodec* SkCodec::NewFromStream(SkStream* stream) {
+    if (!stream) {
+        return NULL;
+    }
+    SkAutoTDelete<SkStream> streamDeleter(stream);
+    const bool isPng = SkPngCodec::IsPng(stream);
+    if (!stream->rewind()) {

[djsollen, 2015/02/25 16:02:19]

why do we have to be able to rewind the stream?  At the least it seems like
there needs to be a TODO here to implement a stream class that wraps this stream
to allow for temporary rewinding.

I imagine something like...

SkCodecStream tmp(stream);
const bool isPng = SkPngCodec::IsPng(tmp);
tmp.rewind();  // will always return true since it has buffered the contents
read in so far
... // check other codecs if needed
tmp.rewind(); // final rewind
tmp.stopBuffering(); // stops the tmp stream from buffering contents so rewind
may return false if underlying stream doesn't support it.

[scroggo, 2015/02/25 18:00:54]

I added a TODO, but have not specified the solution.

I definitely want to explore ways to avoid rewinding. That said, this seemed to
be the simplest way to get things started.

The thing I don't like about wrapping the stream with some kind of buffer is
that if the input stream could have rewound, we have unnecessarily paid the cost
of the extra buffer. Maybe we'll time it and decide the cost is negligible.

As implemented here, we can pass an SkFrontBufferedStream and everything will
work (the fragility there, present in the old system, is that
SkFrontBufferedStream has to know the size to buffer). It also works for the
streams we use in testing (typically an SkMemoryStream). So I think this
implementation is good enough for now.

[djsollen, 2015/02/25 20:52:15]

I'm fine with it just having a TODO, but think we should have a solution for
this to avoid having clients (i.e. Android APIs) require that streams are
rewindable.  In my suggested stream impl you could check to see if the stream is
rewindable and if so not bother to front buffer.

[scroggo, 2015/02/25 21:33:52]

We already have a solution: SkFrontBufferedStream. When Android has a stream
which it suspects is not rewindable, it wraps it with an SkFrontBufferedStream.
I don't think it's the best solution, but we can do it if we must.
SkStream does not have a method for checking whether rewind is supported.

+        return NULL;
+    }
+    if (isPng) {
+        streamDeleter.detach();
+        return SkPngCodec::NewFromStream(stream);
+    }
+    // TODO: Check other image types.
+    return NULL;
+}
+
+SkCodec* SkCodec::NewFromData(SkData* data) {
+    if (!data) {
+        return NULL;
+    }
+    return NewFromStream(SkNEW_ARGS(SkMemoryStream, (data)));
+}
+
+SkCodec::SkCodec(const SkImageInfo& info, SkStream* stream)
+    : fInfo(info)
+    , fStream(stream)
+    , fNeedsRewind(false)
+{}
+
+bool SkCodec::couldRewindIfNeeded() {
+    // Store the value of fNeedsRewind so we can update it. Next read will
+    // require a rewind.
+    const bool neededRewind = fNeedsRewind;
+    fNeedsRewind = true;
+    return !neededRewind || fStream->rewind();
+}