Allowing YUV data to be retrieved from the JPEG Decoder.

Source/platform/image-decoders/jpeg/JPEGImageDecoderTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 29 matching lines @@
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/StringHasher.h"
 #include "wtf/Vector.h"
 
 #include <gtest/gtest.h>
 
 using namespace blink;
 using namespace blink;
 
+static const size_t LargeEnoughSize = 1000 * 1000;
+
 namespace {
 
 PassRefPtr<SharedBuffer> readFile(const char* fileName)
 {
     String filePath = Platform::current()->unitTestSupport()->webKitRootDir();
     filePath.append(fileName);
 
     return Platform::current()->unitTestSupport()->readFromFile(filePath);
 }
 
@@ skipping 12 matching lines @@
     OwnPtr<JPEGImageDecoder> decoder = createDecoder(maxDecodedBytes);
     decoder->setData(data.get(), true);
 
     ImageFrame* frame = decoder->frameBufferAtIndex(0);
     ASSERT_TRUE(frame);
     *outputWidth = frame->getSkBitmap().width();
     *outputHeight = frame->getSkBitmap().height();
     EXPECT_EQ(IntSize(*outputWidth, *outputHeight), decoder->decodedSize());
 }
 
+void readYUV(size_t maxDecodedBytes, unsigned* outputYWidth, unsigned* outputYHeight, unsigned* outputUVWidth, unsigned* outputUVHeight, const char* imageFilePath)
+{
+    RefPtr<SharedBuffer> data = readFile(imageFilePath);
+    ASSERT_TRUE(data.get());
+
+    OwnPtr<JPEGImageDecoder> decoder = createDecoder(maxDecodedBytes);
+    decoder->setData(data.get(), true);
+
+    OwnPtr<ImagePlanes> imagePlanes = adoptPtr(new ImagePlanes());
+    decoder->setImagePlanes(imagePlanes);
+    bool sizeIsAvailable = decoder->isSizeAvailable();
+    ASSERT_TRUE(sizeIsAvailable);
+
+    IntSize size = decoder->decodedSize();
+    IntSize ySize = decoder->decodedYUVSize(0);
+    IntSize uSize = decoder->decodedYUVSize(1);
+    IntSize vSize = decoder->decodedYUVSize(2);
+
+    ASSERT_TRUE(size.width() == ySize.width());
+    ASSERT_TRUE(size.height() == ySize.height());
+    ASSERT_TRUE(uSize.width() == vSize.width());
+    ASSERT_TRUE(uSize.height() == vSize.height());
+
+    *outputYWidth = ySize.width();
+    *outputYHeight = ySize.height();
+    *outputUVWidth = uSize.width();
+    *outputUVHeight = uSize.height();
+}
+
 // Tests failure on a too big image.
 TEST(JPEGImageDecoderTest, tooBig)
 {
     OwnPtr<JPEGImageDecoder> decoder = createDecoder(100);
     EXPECT_FALSE(decoder->setSize(10000, 10000));
     EXPECT_TRUE(decoder->failed());
 }
 
 // Tests that JPEG decoder can downsample image whose width and height are multiple of 8,
 // to ensure we compute the correct decodedSize and pass correct parameters to libjpeg to
@@ skipping 80 matching lines @@
     downsample(230 * 230 * 4, &outputWidth, &outputHeight, jpegFile);
     EXPECT_EQ(241u, outputWidth);
     EXPECT_EQ(182u, outputHeight);
 }
 
 // Tests that upsampling is not allowed.
 TEST(JPEGImageDecoderTest, upsample)
 {
     const char* jpegFile = "/LayoutTests/fast/images/resources/lenna.jpg"; // 256x256
     unsigned outputWidth, outputHeight;
-    downsample(1000 * 1000, &outputWidth, &outputHeight, jpegFile);
+    downsample(LargeEnoughSize, &outputWidth, &outputHeight, jpegFile);
     EXPECT_EQ(256u, outputWidth);
     EXPECT_EQ(256u, outputHeight);
 }
+
+TEST(JPEGImageDecoderTest, yuv)
+{
+    const char* jpegFile = "/LayoutTests/fast/images/resources/lenna.jpg"; // 256x256, YUV 4:2:0
+    unsigned outputYWidth, outputYHeight, outputUVWidth, outputUVHeight;
+    readYUV(LargeEnoughSize, &outputYWidth, &outputYHeight, &outputUVWidth, &outputUVHeight, jpegFile);
+    EXPECT_EQ(256u, outputYWidth);
+    EXPECT_EQ(256u, outputYHeight);
+    EXPECT_EQ(128u, outputUVWidth);
+    EXPECT_EQ(128u, outputUVHeight);
+}