DM: Draw image frames in a grid

dm/DMSrcSink.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 "DMSrcSink.h"
 #include "Resources.h"
 #include "SkAndroidCodec.h"
@@ skipping 20 matching lines @@
 #include "SkPictureRecorder.h"
 #include "SkPipe.h"
 #include "SkRandom.h"
 #include "SkRecordDraw.h"
 #include "SkRecorder.h"
 #include "SkSVGCanvas.h"
 #include "SkStream.h"
 #include "SkTLogic.h"
 #include "SkSwizzler.h"
 #include <functional>
+#include <cmath>
 
 #if defined(SK_BUILD_FOR_WIN)
     #include "SkAutoCoInitialize.h"
 #endif
 
 #if defined(SK_TEST_QCMS)
     #include "qcms.h"
 #endif
 
 #if defined(SK_XML)
@@ skipping 375 matching lines @@
         bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
     }
 
     switch (fMode) {
         case kAnimated_Mode: {
             std::vector<SkCodec::FrameInfo> frameInfos = codec->getFrameInfo();
             if (frameInfos.size() <= 1) {
                 return SkStringPrintf("%s is not an animated image.", fPath.c_str());
             }
 
-            SkAutoCanvasRestore acr(canvas, true);
+            // As in CodecSrc::size(), compute a roughly square grid to draw the frames
+            // into. "factor" is the number of frames to draw on one row. There will be
+            // up to "factor" rows as well.
+            const float root = sqrt((float) frameInfos.size());
+            const int factor = sk_float_ceil2int(root);
+
             // Used to cache a frame that future frames will depend on.
             SkAutoMalloc priorFramePixels;
             size_t cachedFrame = SkCodec::kNone;
             for (size_t i = 0; i < frameInfos.size(); i++) {
                 options.fFrameIndex = i;
                 // Check for a prior frame
                 const size_t reqFrame = frameInfos[i].fRequiredFrame;
                 if (reqFrame != SkCodec::kNone && reqFrame == cachedFrame
                         && priorFramePixels.get()) {
                     // Copy into pixels
                     memcpy(pixels.get(), priorFramePixels.get(), safeSize);
                     options.fHasPriorFrame = true;
                 } else {
                     options.fHasPriorFrame = false;
                 }
                 const SkCodec::Result result = codec->getPixels(decodeInfo, pixels.get(),
                                                                 rowBytes, &options,
                                                                 colorPtr, &colorCount);
                 switch (result) {
                     case SkCodec::kSuccess:
-                    case SkCodec::kIncompleteInput:
+                    case SkCodec::kIncompleteInput: {
+                        SkAutoCanvasRestore acr(canvas, true);
+                        const int xTranslate = (i % factor) * decodeInfo.width();
+                        const int yTranslate = (i / factor) * decodeInfo.height();
+                        canvas->translate(SkIntToScalar(xTranslate), SkIntToScalar(yTranslate));
                         draw_to_canvas(canvas, bitmapInfo, pixels.get(), rowBytes,
                                        colorPtr, colorCount, fDstColorType);
                         if (result == SkCodec::kIncompleteInput) {
                             return "";
                         }
                         break;
+                    }
                     default:
                         return SkStringPrintf("Couldn't getPixels for frame %i in %s.",
                                               i, fPath.c_str());
                 }
 
                 // If a future frame depends on this one, store it in priorFrame.
                 // (Note that if i+1 does *not* depend on i, then no future frame can.)
                 if (i+1 < frameInfos.size() && frameInfos[i+1].fRequiredFrame == i) {
                     memcpy(priorFramePixels.reset(safeSize), pixels.get(), safeSize);
                     cachedFrame = i;
                 }
-
-                canvas->translate(SkIntToScalar(0), SkIntToScalar(decodeInfo.height()));
             }
             break;
         }
         case kCodecZeroInit_Mode:
         case kCodec_Mode: {
             switch (codec->getPixels(decodeInfo, pixels.get(), rowBytes, &options,
                     colorPtr, &colorCount)) {
                 case SkCodec::kSuccess:
                     // We consider incomplete to be valid, since we should still decode what is
                     // available.
@@ skipping 218 matching lines @@
 
 SkISize CodecSrc::size() const {
     sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
     if (nullptr == codec) {
         return SkISize::Make(0, 0);
     }
 
     auto imageSize = codec->getScaledDimensions(fScale);
     if (fMode == kAnimated_Mode) {
-        // We'll draw one of each frame, so make it big enough to hold them all.
+        // We'll draw one of each frame, so make it big enough to hold them all
+        // in a grid. The grid will be roughly square, with "factor" frames per
+        // row and up to "factor" rows.
         const size_t count = codec->getFrameInfo().size();
-        imageSize.fHeight = imageSize.fHeight * count;
+        const float root = sqrt((float) count);
+        const int factor = sk_float_ceil2int(root);
+        imageSize.fWidth  = imageSize.fWidth  * factor;
+        imageSize.fHeight = imageSize.fHeight * sk_float_ceil2int((float) count / (float) factor);
     }
     return imageSize;
 }
 
 Name CodecSrc::name() const {
     if (1.0f == fScale) {
         Name name = SkOSPath::Basename(fPath.c_str());
         if (fMode == kAnimated_Mode) {
             name.append("_animated");
         }
@@ skipping 1044 matching lines @@
         Error err = src.draw(&rec);
         if (!err.isEmpty()) {
             return err;
         }
         dl->draw(canvas);
         return check_against_reference(bitmap, src, fSink);
     });
 }
 
 }  // namespace DM