Use nearest neighbor filtering for non-translated quads

cc/resource_provider.cc

 // Copyright 2012 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/resource_provider.h"
 
 #include <limits.h>
 
 #include "base/debug/alias.h"
 #include "base/hash_tables.h"
@@ skipping 42 matching lines @@
     , pixels(0)
     , pixelBuffer(0)
     , pool(0)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , size()
     , format(0)
+    , filter(0)
     , type(static_cast<ResourceType>(0))
 {
 }
 
-ResourceProvider::Resource::Resource(unsigned textureId, int pool, const gfx::Size& size, GLenum format)
+ResourceProvider::Resource::Resource(unsigned textureId, int pool, const gfx::Size& size, GLenum format, GLenum filter)
     : glId(textureId)
     , glPixelBufferId(0)
     , pixels(0)
     , pixelBuffer(0)
     , pool(pool)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , size(size)
     , format(format)
+    , filter(filter)
     , type(GLTexture)
 {
 }
 
-ResourceProvider::Resource::Resource(uint8_t* pixels, int pool, const gfx::Size& size, GLenum format)
+ResourceProvider::Resource::Resource(uint8_t* pixels, int pool, const gfx::Size& size, GLenum format, GLenum filter)
     : glId(0)
     , glPixelBufferId(0)
     , pixels(pixels)
     , pixelBuffer(0)
     , pool(pool)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , size(size)
     , format(format)
+    , filter(filter)
     , type(Bitmap)
 {
 }
 
 ResourceProvider::Child::Child()
 {
 }
 
 ResourceProvider::Child::~Child()
 {
@@ skipping 63 matching lines @@
 
     if (m_useTextureUsageHint && hint == TextureUsageFramebuffer)
         GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE));
     if (m_useTextureStorageExt && isTextureFormatSupportedForStorage(format)) {
         GLenum storageFormat = textureToStorageFormat(format);
         GLC(context3d, context3d->texStorage2DEXT(GL_TEXTURE_2D, 1, storageFormat, size.width(), size.height()));
     } else
         GLC(context3d, context3d->texImage2D(GL_TEXTURE_2D, 0, format, size.width(), size.height(), 0, format, GL_UNSIGNED_BYTE, 0));
 
     ResourceId id = m_nextId++;
-    Resource resource(textureId, pool, size, format);
+    Resource resource(textureId, pool, size, format, GL_LINEAR);
     m_resources[id] = resource;
     return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::createBitmap(int pool, const gfx::Size& size)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
 
     uint8_t* pixels = new uint8_t[size.width() * size.height() * 4];
 
     ResourceId id = m_nextId++;
-    Resource resource(pixels, pool, size, GL_RGBA);
+    Resource resource(pixels, pool, size, GL_RGBA, GL_LINEAR);
     m_resources[id] = resource;
     return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::createResourceFromExternalTexture(unsigned textureId)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
 
     WebGraphicsContext3D* context3d = m_context->context3D();
     DCHECK(context3d);
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, textureId));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 
     ResourceId id = m_nextId++;
-    Resource resource(textureId, 0, gfx::Size(), 0);
+    Resource resource(textureId, 0, gfx::Size(), 0, GL_LINEAR);
     resource.external = true;
     m_resources[id] = resource;
     return id;
 }
 
 void ResourceProvider::deleteResource(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
@@ skipping 196 matching lines @@
     , m_textureId(resourceProvider->lockForRead(resourceId)->glId)
 {
     DCHECK(m_textureId);
 }
 
 ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL()
 {
     m_resourceProvider->unlockForRead(m_resourceId);
 }
 
+ResourceProvider::ScopedSamplerGL::ScopedSamplerGL(ResourceProvider* resourceProvider, ResourceProvider::ResourceId resourceId, GLenum target, GLenum filter)
+    : ScopedReadLockGL(resourceProvider, resourceId)
+{
+    resourceProvider->bindForSampling(resourceId, target, filter);
+}
+
 ResourceProvider::ScopedWriteLockGL::ScopedWriteLockGL(ResourceProvider* resourceProvider, ResourceProvider::ResourceId resourceId)
     : m_resourceProvider(resourceProvider)
     , m_resourceId(resourceId)
     , m_textureId(resourceProvider->lockForWrite(resourceId)->glId)
 {
     DCHECK(m_textureId);
 }
 
 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL()
 {
@@ skipping 172 matching lines @@
         // (and is simpler) to wait.
         GLC(context3d, context3d->waitSyncPoint(resources.sync_point));
     }
     Child& childInfo = m_children.find(child)->second;
     for (TransferableResourceArray::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         unsigned textureId;
         GLC(context3d, textureId = context3d->createTexture());
         GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, textureId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, it->mailbox.name));
         ResourceId id = m_nextId++;
-        Resource resource(textureId, childInfo.pool, it->size, it->format);
+        Resource resource(textureId, childInfo.pool, it->size, it->format, it->filter);
         resource.mailbox.setName(it->mailbox.name);
         m_resources[id] = resource;
         childInfo.parentToChildMap[id] = it->id;
         childInfo.childToParentMap[it->id] = id;
     }
 }
 
 void ResourceProvider::receiveFromParent(const TransferableResourceList& resources)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
@@ skipping 25 matching lines @@
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* source = &it->second;
     DCHECK(!source->lockedForWrite);
     DCHECK(!source->lockForReadCount);
     DCHECK(!source->external);
     if (source->exported)
         return false;
     resource->id = id;
     resource->format = source->format;
+    resource->filter = source->filter;
     resource->size = source->size;
 
     if (source->mailbox.isZero()) {
       GLbyte name[GL_MAILBOX_SIZE_CHROMIUM];
       GLC(context3d, context3d->genMailboxCHROMIUM(name));
       source->mailbox.setName(name);
     }
 
     resource->mailbox = source->mailbox;
     GLC(context, context->bindTexture(GL_TEXTURE_2D, source->glId));
@@ skipping 153 matching lines @@
                       resource->size.width(),
                       resource->size.height());
         src.setPixels(resource->pixelBuffer);
 
         ScopedWriteLockSoftware lock(this, id);
         SkCanvas* dest = lock.skCanvas();
         dest->writePixels(src, 0, 0);
     }
 }
 
+void ResourceProvider::bindForSampling(ResourceProvider::ResourceId resourceId, GLenum target, GLenum filter)
+{
+    DCHECK(m_threadChecker.CalledOnValidThread());
+    WebGraphicsContext3D* context3d = m_context->context3D();
+    ResourceMap::iterator it = m_resources.find(resourceId);
+    CHECK(it != m_resources.end());

[jamesr, 2012/12/01 01:50:22]

why not DCHECK() ?

[Sami, 2012/12/03 11:59:21]

Most of the other methods here CHECK() for a valid resource id so I did that
too. However it is a little redundant here because we are assuming that the
resource was already locked for reading and hence the CHECK() was already done
in lockForRead(). I'll make this a DCHECK().

+    Resource* resource = &it->second;
+    DCHECK(resource->lockForReadCount);
+    DCHECK(!resource->lockedForWrite);
+
+    GLC(context3d, context3d->bindTexture(target, resource->glId));
+    if (filter != resource->filter) {
+        GLC(context3d, context3d->texParameteri(target, GL_TEXTURE_MIN_FILTER, filter));
+        GLC(context3d, context3d->texParameteri(target, GL_TEXTURE_MAG_FILTER, filter));
+        resource->filter = filter;
+    }
+}
+
 }  // namespace cc