Restrict ETC1 power-of-two rounding to old IMG drivers.

chrome/browser/android/thumbnail/thumbnail_store.cc

 // Copyright 2014 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 "chrome/browser/android/thumbnail/thumbnail_store.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/big_endian.h"
@@ skipping 20 matching lines @@
 const float kApproximationScaleFactor = 4.f;
 const base::TimeDelta kCaptureMinRequestTimeMs(
     base::TimeDelta::FromMilliseconds(1000));
 
 const int kCompressedKey = 0xABABABAB;
 const int kCurrentExtraVersion = 1;
 
 // Indicates whether we prefer to have more free CPU memory over GPU memory.
 const bool kPreferCPUMemory = true;
 
-// TODO(): ETC1 texture sizes should be multiples of four, but some drivers only
-// allow power-of-two ETC1 textures.  Find better work around.
 size_t NextPowerOfTwo(size_t x) {
   --x;
   x |= x >> 1;
   x |= x >> 2;
   x |= x >> 4;
   x |= x >> 8;
   x |= x >> 16;
   return x + 1;
 }
 
-gfx::Size GetEncodedSize(const gfx::Size& bitmap_size) {
+size_t RoundUpMod4(size_t x) {

[David Trainor- moved to gerrit, 2014/08/21 22:15:00]

(x + 3) & ~3 (is what most ETC1 libs use).

[aelias_OOO_until_Jul13, 2014/08/21 22:56:12]

Done.

+  size_t mod = x % 4;
+  if (mod) {
+    x += 4 - mod;
+  }
+  return x;
+}
+
+gfx::Size GetEncodedSize(const gfx::Size& bitmap_size, bool supports_npot) {
   DCHECK(!bitmap_size.IsEmpty());
-  return gfx::Size(NextPowerOfTwo(bitmap_size.width()),
-                   NextPowerOfTwo(bitmap_size.height()));
+  if (!supports_npot)
+    return gfx::Size(NextPowerOfTwo(bitmap_size.width()),
+                     NextPowerOfTwo(bitmap_size.height()));
+  else
+    return gfx::Size(RoundUpMod4(bitmap_size.width()),
+                     RoundUpMod4(bitmap_size.height()));
 }
 
 template<typename T>
 bool ReadBigEndianFromFile(base::File& file, T* out) {
   char buffer[sizeof(T)];
   if (file.ReadAtCurrentPos(buffer, sizeof(T)) != sizeof(T))
     return false;
   base::ReadBigEndian(buffer, out);
   return true;
 }
@@ skipping 291 matching lines @@
 
   compression_tasks_count_++;
 
   base::Callback<void(skia::RefPtr<SkPixelRef>, const gfx::Size&)>
       post_compression_task = base::Bind(&ThumbnailStore::PostCompressionTask,
                                          weak_factory_.GetWeakPtr(),
                                          tab_id,
                                          time_stamp,
                                          scale);
 
-  base::WorkerPool::PostTask(
-      FROM_HERE,
-      base::Bind(
-          &ThumbnailStore::CompressionTask, bitmap, post_compression_task),
-      true);
+  gfx::Size raw_data_size(bitmap.width(), bitmap.height());
+  gfx::Size encoded_size = GetEncodedSize(
+      raw_data_size, ui_resource_provider_->SupportsETC1NonPowerOfTwo());
+
+  base::WorkerPool::PostTask(FROM_HERE,
+                             base::Bind(&ThumbnailStore::CompressionTask,
+                                        bitmap,
+                                        encoded_size,
+                                        post_compression_task),
+                             true);
 }
 
 void ThumbnailStore::ReadNextThumbnail() {
   if (read_queue_.empty() || read_in_progress_)
     return;
 
   TabId tab_id = read_queue_.front();
   read_in_progress_ = true;
 
   base::FilePath file_path = GetFilePath(tab_id);
@@ skipping 149 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE, post_write_task);
 }
 
 void ThumbnailStore::PostWriteTask() {
   write_tasks_count_--;
 }
 
 void ThumbnailStore::CompressionTask(
     SkBitmap raw_data,
+    gfx::Size encoded_size,
     const base::Callback<void(skia::RefPtr<SkPixelRef>, const gfx::Size&)>&
         post_compression_task) {
   skia::RefPtr<SkPixelRef> compressed_data;
   gfx::Size content_size;
 
   if (!raw_data.empty()) {
     SkAutoLockPixels raw_data_lock(raw_data);
     gfx::Size raw_data_size(raw_data.width(), raw_data.height());
     size_t pixel_size = 4;  // Pixel size is 4 bytes for kARGB_8888_Config.
     size_t stride = pixel_size * raw_data_size.width();
 
-    gfx::Size encoded_size = GetEncodedSize(raw_data_size);
     size_t encoded_bytes =
         etc1_get_encoded_data_size(encoded_size.width(), encoded_size.height());
     SkImageInfo info = {encoded_size.width(),
                         encoded_size.height(),
                         kUnknown_SkColorType,
                         kUnpremul_SkAlphaType};
     skia::RefPtr<SkData> etc1_pixel_data = skia::AdoptRef(
         SkData::NewFromMalloc(new uint8_t[encoded_bytes], encoded_bytes));
     skia::RefPtr<SkMallocPixelRef> etc1_pixel_ref = skia::AdoptRef(
         SkMallocPixelRef::NewWithData(info, 0, NULL, etc1_pixel_data.get()));
@@ skipping 266 matching lines @@
   dst_bitmap.eraseColor(0);
   SkAutoLockPixels dst_bitmap_lock(dst_bitmap);
 
   SkCanvas canvas(dst_bitmap);
   canvas.scale(new_scale, new_scale);
   canvas.drawBitmap(bitmap, 0, 0, NULL);
   dst_bitmap.setImmutable();
 
   return std::make_pair(dst_bitmap, new_scale * scale);
 }