DM test for YUV

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 "SkAndroidCodec.h"
@@ skipping 222 matching lines @@
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 CodecSrc::CodecSrc(Path path, Mode mode, DstColorType dstColorType, float scale)
     : fPath(path)
     , fMode(mode)
     , fDstColorType(dstColorType)
     , fScale(scale)
 {}
 
 bool CodecSrc::veto(SinkFlags flags) const {
+    if (kYUV_Mode == fMode) {
+        // YUV mode does not support scaling or non-canvas color types.
+        if (CodecSrc::kGetFromCanvas_DstColorType != fDstColorType || 1.0f != fScale) {

[scroggo, 2016/01/13 21:04:54]

For the DstColorType, can we just limit creating CodecSrc to kGetFromCanvas?

For scale, I could imagine we just scale the canvas... maybe that's interesting
for comparison?

[msarett, 2016/01/15 18:57:34]

Done.
This test has become a test of SkCodecImageGenerator.  I think it makes sense to
add scaling tests when we add scaling support to SkCodecImageGenerator.

+            return true;
+        }
+
+        return flags.type != SinkFlags::kGPU;
+    }
+
     // No need to test decoding to non-raster or indirect backend.
-    // TODO: Once we implement GPU paths (e.g. JPEG YUV), we should use a deferred decode to
-    // let the GPU handle it.
     return flags.type != SinkFlags::kRaster
         || flags.approach != SinkFlags::kDirect;
 }
 
 bool get_decode_info(SkImageInfo* decodeInfo, const SkImageInfo& defaultInfo,
         SkColorType canvasColorType, CodecSrc::DstColorType dstColorType) {
     switch (dstColorType) {
         case CodecSrc::kIndex8_Always_DstColorType:
             if (kRGB_565_SkColorType == canvasColorType) {
                 return false;
@@ skipping 11 matching lines @@
             break;
     }
 
     // FIXME: Currently we cannot draw unpremultiplied sources.
     if (decodeInfo->alphaType() == kUnpremul_SkAlphaType) {
         *decodeInfo = decodeInfo->makeAlphaType(kPremul_SkAlphaType);
     }
     return true;
 }
 
+Error test_yuv(SkCanvas* canvas, SkCodec* codec) {
+    SkAutoTDelete<SkCodec> deleter(codec);
+
+    SkCodec::YUVPlanesSizes sizes;
+    SkCodec::YUVPlanesWidthBytes widthBytes;
+    SkYUVColorSpace colorSpace;
+    if (!codec->queryYUV8(&sizes, &widthBytes, &colorSpace)) {
+        return Error::Nonfatal("YUV not supported.");
+    }
+
+    const size_t totalBytes = sizes.YSize.height() * widthBytes.YWidthBytes +
+                              sizes.USize.height() * widthBytes.UWidthBytes +
+                              sizes.VSize.height() * widthBytes.VWidthBytes;
+    SkAutoMalloc storage(totalBytes);
+    void* planes[3];
+    planes[0] = storage.get();
+    planes[1] = SkTAddOffset<void>(planes[0], sizes.YSize.height() * widthBytes.YWidthBytes);
+    planes[2] = SkTAddOffset<void>(planes[1], sizes.USize.height() * widthBytes.UWidthBytes);
+
+    switch (codec->getYUV8Planes(&sizes, planes, &widthBytes)) {
+        case SkCodec::kSuccess:
+        case SkCodec::kIncompleteInput: {
+            /* How do we draw this to canvas? */
+            return "";
+        }
+        default:
+            return SkStringPrintf("Couldn't getYUV8Planes.");
+    }
+}
+
 Error CodecSrc::draw(SkCanvas* canvas) const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     if (!encoded) {
         return SkStringPrintf("Couldn't read %s.", fPath.c_str());
     }
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
     if (nullptr == codec.get()) {
         return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
     }
 
+    // The YUV test does not share much code with the other tests, so we will handle
+    // it in its own function.
+    if (kYUV_Mode == fMode) {
+        return test_yuv(canvas, codec.detach());

[scroggo, 2016/01/13 21:04:54]

Alternatively, you could let this method delete the codec (test_yuv will be
called before this method returns, so no need to pass ownership).

[msarett, 2016/01/15 18:57:35]

Done.

+    }
+
     SkImageInfo decodeInfo;
     if (!get_decode_info(&decodeInfo, codec->getInfo(), canvas->imageInfo().colorType(),
             fDstColorType)) {
         return Error::Nonfatal("Testing non-565 to 565 is uninteresting.");
     }
 
     // Try to scale the image if it is desired
     SkISize size = codec->getScaledDimensions(fScale);
     if (size == decodeInfo.dimensions() && 1.0f != fScale) {
         return Error::Nonfatal("Test without scaling is uninteresting.");
@@ skipping 197 matching lines @@
                     }
                     canvas->drawBitmap(subsetBm, SkIntToScalar(left), SkIntToScalar(top));
                     // translate by the scaled height.
                     top += decodeInfo.height();
                 }
                 // translate by the scaled width.
                 left += decodeInfo.width();
             }
             return "";
         }
+        default:
+            SkASSERT(false);
+            return "Invalid fMode";
     }
     return "";
 }
 
 SkISize CodecSrc::size() const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
     if (nullptr == codec) {
         return SkISize::Make(0, 0);
     }
@@ skipping 12 matching lines @@
 AndroidCodecSrc::AndroidCodecSrc(Path path, Mode mode, CodecSrc::DstColorType dstColorType,
         int sampleSize)
     : fPath(path)
     , fMode(mode)
     , fDstColorType(dstColorType)
     , fSampleSize(sampleSize)
 {}
 
 bool AndroidCodecSrc::veto(SinkFlags flags) const {
     // No need to test decoding to non-raster or indirect backend.
-    // TODO: Once we implement GPU paths (e.g. JPEG YUV), we should use a deferred decode to
-    // let the GPU handle it.
     return flags.type != SinkFlags::kRaster
         || flags.approach != SinkFlags::kDirect;
 }
 
 Error AndroidCodecSrc::draw(SkCanvas* canvas) const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     if (!encoded) {
         return SkStringPrintf("Couldn't read %s.", fPath.c_str());
     }
     SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded));
@@ skipping 716 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM