dm changes

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 "SamplePipeControllers.h"
 #include "SkCodec.h"
@@ skipping 123 matching lines @@
                     // We consider incomplete to be valid, since we should still decode what is
                     // available.
                 case SkImageGenerator::kIncompleteInput:
                     break;
                 case SkImageGenerator::kInvalidConversion:
                     return Error::Nonfatal("Incompatible colortype conversion");
                 default:
                     // Everything else is considered a failure.
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
             }
+            canvas->drawBitmap(bitmap, 0, 0);
             break;
         case kScanline_Mode: {
             SkScanlineDecoder* scanlineDecoder = codec->getScanlineDecoder(decodeInfo, NULL,
                     colorPtr, colorCountPtr);
             if (NULL == scanlineDecoder) {
                 return Error::Nonfatal("Cannot use scanline decoder for all images");
             }
             for (int y = 0; y < decodeInfo.height(); ++y) {
                 const SkImageGenerator::Result result = scanlineDecoder->getScanlines(
                         bitmap.getAddr(0, y), 1, 0);
                 switch (result) {
                     case SkImageGenerator::kSuccess:
                     case SkImageGenerator::kIncompleteInput:
                         break;
                     default:
                         return SkStringPrintf("%s failed after %d scanlines with error message %d",
                                               fPath.c_str(), y-1, (int) result);
                 }
             }
+            canvas->drawBitmap(bitmap, 0, 0);
+            break;
+        }
+        case kSubset_Mode: {
+            //this mode decodes the image in divisor*divisor subsets, using a scanline decoder  
+            const int divisor = 2;
+            SkScanlineDecoder* subsetScanlineDecoder = codec->getScanlineDecoder(decodeInfo, NULL,
+                    colorPtr, colorCountPtr);
+            if (NULL == subsetScanlineDecoder) {
+                return Error::Nonfatal("Cannot use scanline decoder for all images");
+            }
+            SkImageInfo subsetDecodeInfo = decodeInfo.makeWH(decodeInfo.width()/divisor, 
+                    decodeInfo.height()/divisor);
+            SkBitmap subsetBm;
+            if (!subsetBm.tryAllocPixels(subsetDecodeInfo, NULL, colorTable.get())) {
+                return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
+                        subsetDecodeInfo.width(), subsetDecodeInfo.height());
+            }
+            char* line = new char[decodeInfo.width()*decodeInfo.bytesPerPixel()];
+            SkAutoTDeleteArray<char> lineDeleter(line);
+            for (int subset = 0; subset < divisor*divisor; subset++) {
+                //reset scanline decoder for right half of image
+                if (0 == subset%divisor && 0 != subset) {

[scroggo, 2015/05/18 20:43:18]

Alternatively, you could remove the second half of this if statement and remove
the original call to getScanlineDecoder. You'd still need to handle subset 0
differently if null is returned, and it would mean we did extra work in the case
where the image does not support scanline decoding, so maybe this way is better.

+                    subsetScanlineDecoder = codec->getScanlineDecoder(decodeInfo, NULL,
+                            colorPtr, colorCountPtr);
+                }
+                int x;
+                int y;
+                //set drawing position based on subset number
+                if(subset == 0) {
+                    //first subset, draw to top left corner
+                    x = 0;
+                    y = 0;
+                } else if (0 == subset%divisor) {
+                    //new column, reset y, increment x by subset width
+                    x += subsetDecodeInfo.width();
+                    y = 0;
+                } else {
+                    //new row, increment y by subset height
+                    y += subsetDecodeInfo.height();
+                }
+                for (int y = 0; y < subsetDecodeInfo.height(); ++y) {
+                    const SkImageGenerator::Result subsetResult = 
+                            subsetScanlineDecoder->getScanlines(line, 1, 0); 
+                        //copy section of line based on x value
+                        memcpy(subsetBm.getAddr(0, y), line + x*subsetDecodeInfo.bytesPerPixel(), 
+                                subsetDecodeInfo.width()*subsetDecodeInfo.bytesPerPixel());  
+                    switch (subsetResult) {
+                        case SkImageGenerator::kSuccess:
+                        case SkImageGenerator::kIncompleteInput:
+                            break;
+                        default:
+                            return SkStringPrintf("%s failed after %d scanlines with error" 
+                                    "message %d", fPath.c_str(), y-1, (int) subsetResult);
+                    }
+                }
+                canvas->drawBitmap(subsetBm, x, y);
+            }  
             break;
         }
     }
-    canvas->drawBitmap(bitmap, 0, 0);
     return "";
 }
 
 SkISize CodecSrc::size() const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
     if (NULL != codec) {
         return codec->getInfo().dimensions();
     } else {
         return SkISize::Make(0, 0);
@@ skipping 603 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM