Tile Compression

cc/resources/tile_task_worker_pool.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/tile_task_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/simple_thread.h"
 #include "cc/base/scoped_ptr_deque.h"
 #include "cc/resources/raster_source.h"
+#include "cc/resources/texture_compress/texture_compress.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
 namespace cc {
 namespace {
 
 class TileTaskGraphRunner : public TaskGraphRunner,
                             public base::DelegateSimpleThread::Delegate {
  public:
@@ skipping 163 matching lines @@
       InsertNodeForTask(graph, decode_task, priority, 0u);
 
     graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
   }
 
   InsertNodeForTask(graph, raster_task, priority, dependencies);
 }
 
 static bool IsSupportedPlaybackToMemoryFormat(ResourceFormat format) {
   switch (format) {
+    case ATC:
+    case ATC_IA:
+    case DXT1:
+    case DXT5:
+    case ETC1:
     case RGBA_4444:
     case RGBA_8888:
     case BGRA_8888:
       return true;
     case ALPHA_8:
     case LUMINANCE_8:
     case RGB_565:
-    case ETC1:
     case RED_8:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 // static
 void TileTaskWorkerPool::PlaybackToMemory(void* memory,
                                           ResourceFormat format,
                                           const gfx::Size& size,
                                           int stride,
                                           const RasterSource* raster_source,
                                           const gfx::Rect& rect,
                                           float scale) {
   DCHECK(IsSupportedPlaybackToMemoryFormat(format)) << format;
 
+  if (IsFormatCompressed(format)) {
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(size.width(), size.height());
+
+    SkCanvas canvas(bitmap);
+    raster_source->PlaybackToCanvas(&canvas, rect, scale);
+
+    switch (format) {
+      case ATC:
+        texture_compress::CompressATC(
+            reinterpret_cast<const uint8_t*>(bitmap.getPixels()),
+            reinterpret_cast<uint8_t*>(memory), bitmap.width(),
+            bitmap.height());
+        break;
+      case ATC_IA:
+        texture_compress::CompressATCIA(
+            reinterpret_cast<const uint8_t*>(bitmap.getPixels()),
+            reinterpret_cast<uint8_t*>(memory), bitmap.width(),
+            bitmap.height());
+        break;
+      case DXT1:
+        texture_compress::CompressDXT1(
+            reinterpret_cast<const uint8_t*>(bitmap.getPixels()),
+            reinterpret_cast<uint8_t*>(memory), bitmap.width(),
+            bitmap.height());
+        break;
+      case DXT5:
+        texture_compress::CompressDXT5(
+            reinterpret_cast<const uint8_t*>(bitmap.getPixels()),
+            reinterpret_cast<uint8_t*>(memory), bitmap.width(),
+            bitmap.height());
+        break;
+      case ETC1:
+        texture_compress::CompressETC1(
+            reinterpret_cast<const uint8_t*>(bitmap.getPixels()),
+            reinterpret_cast<uint8_t*>(memory), bitmap.width(),
+            bitmap.height());
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+    return;
+  }
+
   // Uses kPremul_SkAlphaType since the result is not known to be opaque.
   SkImageInfo info =
       SkImageInfo::MakeN32(size.width(), size.height(), kPremul_SkAlphaType);
   SkColorType buffer_color_type = ResourceFormatToSkColorType(format);
   bool needs_copy = buffer_color_type != info.colorType();
 
   // Use unknown pixel geometry to disable LCD text.
   SkSurfaceProps surface_props(0, kUnknown_SkPixelGeometry);
   if (raster_source->CanUseLCDText()) {
     // LegacyFontHost will get LCD text and skia figures out what type to use.
@@ skipping 21 matching lines @@
   // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
   // bitmap data. There will be no need to call SkAlign4 once crbug.com/293728
   // is fixed.
   const size_t dst_row_bytes = SkAlign4(dst_info.minRowBytes());
   DCHECK_EQ(0u, dst_row_bytes % 4);
   bool success = canvas->readPixels(dst_info, memory, dst_row_bytes, 0, 0);
   DCHECK_EQ(true, success);
 }
 
 }  // namespace cc