Add support for multiple frames in SkCodec

gm/animatedGif.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 "gm.h"
 #include "SkAnimTimer.h"
 #include "SkCanvas.h"
@@ skipping 15 matching lines @@
         SkPaint paint;
         SkRect bounds;
         paint.measureText(errorText.c_str(), errorText.size(), &bounds);
         canvas->drawText(errorText.c_str(), errorText.size(), kOffset, bounds.height() + kOffset,
                          paint);
     }
 }
 
 class AnimatedGifGM : public skiagm::GM {
 private:
-    std::unique_ptr<SkCodec>    fCodec;
-    size_t                      fFrame;
-    double                      fNextUpdate;
-    size_t                      fTotalFrames;
-    std::vector<SkBitmap>       fFrames;
+    std::unique_ptr<SkCodec>        fCodec;
+    size_t                          fFrame;
+    double                          fNextUpdate;
+    size_t                          fTotalFrames;
+    std::vector<SkCodec::FrameInfo> fFrameInfos;
+    std::vector<SkBitmap>           fFrames;
 
     void drawBounds(SkCanvas* canvas) {
         if (!fCodec) {
             return;
         }
         const SkIRect bounds = fCodec->getInfo().bounds().makeOutset(1, 1);
         SkPaint boundsPaint;
         boundsPaint.setStyle(SkPaint::kStroke_Style);
         canvas->drawIRect(bounds, boundsPaint);
     }
 
     void drawFrame(SkCanvas* canvas, int frameIndex) {
         // FIXME: Create from an Image/ImageGenerator?
         if (frameIndex >= (int) fFrames.size()) {
             fFrames.resize(frameIndex + 1);
         }
         SkBitmap& bm = fFrames[frameIndex];
         if (!bm.getPixels()) {
             const SkImageInfo info = fCodec->getInfo().makeColorType(kN32_SkColorType);
             bm.allocPixels(info);
 
             SkCodec::MultiFrameOptions multiOpts;
             multiOpts.fIndex = frameIndex;
             multiOpts.fHasPriorFrame = false;
-            const size_t requiredFrame = fCodec->getRequiredFrame(frameIndex);
+            const size_t requiredFrame = fFrameInfos[frameIndex].fRequiredFrame;
             if (requiredFrame != SkCodec::kIndependentFrame) {
                 SkASSERT(requiredFrame < fFrames.size());
                 SkBitmap& requiredBitmap = fFrames[requiredFrame];
                 // For simplicity, do not try to cache old frames
                 if (requiredBitmap.getPixels() && requiredBitmap.copyTo(&bm)) {
                     multiOpts.fHasPriorFrame = true;
                 }
             }
 
             SkCodec::Options opts;
@@ skipping 17 matching lines @@
 
 private:
     SkString onShortName() override {
         return SkString("animatedGif");
     }
 
     SkISize onISize() override {
         if (this->initCodec()) {
             SkISize dim = fCodec->getInfo().dimensions();
             // Wide enough to display all the frames.
-            dim.fWidth *= fCodec->getFrameCount();
+            dim.fWidth *= fTotalFrames;
             // Tall enough to show the row of frames plus an animating version.
             dim.fHeight *= 2;
             return dim;
         }
         return SkISize::Make(640, 480);
     }
 
     void onDrawBackground(SkCanvas* canvas) override {
         if (this->initCodec()) {
             SkAutoCanvasRestore acr(canvas, true);
@@ skipping 21 matching lines @@
             return false;
         }
 
         fCodec.reset(SkCodec::NewFromStream(stream.release()));
         if (!fCodec) {
             SkDebugf("Could create codec from %s", FLAGS_animatedGif[0]);
             return false;
         }
 
         fFrame = 0;
-        fTotalFrames = fCodec->getFrameCount();
+        fFrameInfos = fCodec->getFrameInfo();
+        fTotalFrames = fFrameInfos.size();
         return true;
     }
 
     void onDraw(SkCanvas* canvas) {
         if (!fCodec) {
             SkString errorText = SkStringPrintf("Nothing to draw; %s", FLAGS_animatedGif[0]);
             error(canvas, errorText);
             return;
         }
 
         // Now draw it animated.
         SkAutoCanvasRestore acr(canvas, true);
         canvas->translate(0, fCodec->getInfo().height());
         this->drawBounds(canvas);
         this->drawFrame(canvas, fFrame);
     }
 
     bool onAnimate(const SkAnimTimer& timer) override {
         if (!fCodec || fTotalFrames == 1) {
             return false;
         }
 
         double secs = timer.msec() * .1;
         if (fNextUpdate < double(0)) {
             // This is a sentinel that we have not done any updates yet.
             // I'm assuming this gets called *after* onOnceBeforeDraw, so our first frame should
             // already have been retrieved.
             SkASSERT(fFrame == 0);
-            fNextUpdate = secs + fCodec->getFrameDuration(fFrame);
+            fNextUpdate = secs + fFrameInfos[fFrame].fDuration;
 
             return true;
         }
 
         if (secs < fNextUpdate) {
             return true;
         }
 
         while (secs >= fNextUpdate) {
             // Retrieve the next frame.
             fFrame++;
             if (fFrame == fTotalFrames) {
                 fFrame = 0;
             }
 
             // Note that we loop here. This is not safe if we need to draw the intermediate frame
             // in order to draw correctly.
-            fNextUpdate += fCodec->getFrameDuration(fFrame);
+            fNextUpdate += fFrameInfos[fFrame].fDuration;
         }
 
         return true;
     }
 };
 
 DEF_GM(return new AnimatedGifGM);