Support allowSRGBInputs on Vulkan (via secondary texture views)

src/gpu/vk/GrVkPipelineState.cpp

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrVkPipelineState.h"
 
 #include "GrPipeline.h"
@@ skipping 185 matching lines @@
         append_texture_bindings(processor, &textureBindings);
     }
 
     fXferProcessor->setData(fDataManager, pipeline.getXferProcessor());
     append_texture_bindings(pipeline.getXferProcessor(), &textureBindings);
 
     // Get new descriptor sets
     if (fNumSamplers) {
         fSamplerPoolManager.getNewDescriptorSet(gpu,
                                              &fDescriptorSets[GrVkUniformHandler::kSamplerDescSet]);
-        this->writeSamplers(gpu, textureBindings);
+        this->writeSamplers(gpu, textureBindings, pipeline.getAllowSRGBInputs());
     }
 
     if (fVertexUniformBuffer.get() || fFragmentUniformBuffer.get()) {
         if (fDataManager.uploadUniformBuffers(gpu, fVertexUniformBuffer, fFragmentUniformBuffer) ||
             VK_NULL_HANDLE == fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet]) {
             const GrVkDescriptorPool* pool;
             int uniformDSIdx = GrVkUniformHandler::kUniformBufferDescSet;
             gpu->resourceProvider().getUniformDescriptorSet(&fDescriptorSets[uniformDSIdx],
                                                             &pool);
             if (pool != fCurrentUniformDescPool) {
@@ skipping 62 matching lines @@
 
     if (uniformBindingUpdateCount) {
         GR_VK_CALL(gpu->vkInterface(), UpdateDescriptorSets(gpu->device(),
                                                             uniformBindingUpdateCount,
                                                             &descriptorWrites[firstUniformWrite],
                                                             0, nullptr));
     }
 }
 
 void GrVkPipelineState::writeSamplers(GrVkGpu* gpu,
-                                      const SkTArray<const GrTextureAccess*>& textureBindings) {
+                                      const SkTArray<const GrTextureAccess*>& textureBindings,
+                                      bool allowSRGBInputs) {
     SkASSERT(fNumSamplers == textureBindings.count());
 
     for (int i = 0; i < textureBindings.count(); ++i) {
         const GrTextureParams& params = textureBindings[i]->getParams();
 
         GrVkTexture* texture = static_cast<GrVkTexture*>(textureBindings[i]->getTexture());
         if (GrTextureParams::kMipMap_FilterMode == params.filterMode()) {
             if (texture->texturePriv().mipMapsAreDirty()) {
                 gpu->generateMipmap(texture);
                 texture->texturePriv().dirtyMipMaps(false);
             }
         }
 
         fSamplers.push(gpu->resourceProvider().findOrCreateCompatibleSampler(params,
                                                           texture->texturePriv().maxMipMapLevel()));
 
         const GrVkImage::Resource* textureResource = texture->resource();
         textureResource->ref();
         fTextures.push(textureResource);
 
-        const GrVkImageView* textureView = texture->textureView();
+        const GrVkImageView* textureView = texture->textureView(allowSRGBInputs);
         textureView->ref();
         fTextureViews.push(textureView);
 
         // Change texture layout so it can be read in shader
         texture->setImageLayout(gpu,
                                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
                                 VK_ACCESS_SHADER_READ_BIT,
                                 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
                                 false);
 
         VkDescriptorImageInfo imageInfo;
         memset(&imageInfo, 0, sizeof(VkDescriptorImageInfo));
         imageInfo.sampler = fSamplers[i]->sampler();
-        imageInfo.imageView = texture->textureView()->imageView();
+        imageInfo.imageView = textureView->imageView();
         imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
         VkWriteDescriptorSet writeInfo;
         memset(&writeInfo, 0, sizeof(VkWriteDescriptorSet));
         writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
         writeInfo.pNext = nullptr;
         writeInfo.dstSet = fDescriptorSets[GrVkUniformHandler::kSamplerDescSet];
         writeInfo.dstBinding = i;
         writeInfo.dstArrayElement = 0;
         writeInfo.descriptorCount = 1;
@@ skipping 168 matching lines @@
 
     b.add32(get_blend_info_key(pipeline));
 
     b.add32(primitiveType);
 
     // Set key length
     int keyLength = key->count();
     SkASSERT(0 == (keyLength % 4));
     *reinterpret_cast<uint32_t*>(key->begin()) = SkToU32(keyLength);
 }