Workaround UNPACK_ROW_LENGTH driver bugs.

gpu/command_buffer/service/texture_manager.cc

 // Copyright (c) 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 "gpu/command_buffer/service/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 2314 matching lines @@
     memset(zero.get(), 0, args.pixels_size);
     for (GLenum face : undefined_faces) {
       new_args.target = face;
       new_args.pixels = zero.get();
       DoTexImage(texture_state, state, framebuffer_state,
                  function_name, texture_ref, new_args);
       texture->MarkLevelAsInternalWorkaround(face, args.level);
     }
   }
 
-  if (texture_state->unpack_alignment_workaround_with_unpack_buffer && buffer) {
+  if (texture_state->unpack_parameters_workaround_with_unpack_buffer &&
+      buffer) {
     uint32_t buffer_size = static_cast<uint32_t>(buffer->size());
-    if (buffer_size - args.pixels_size - ToGLuint(args.pixels) < args.padding) {
+    if (buffer_size - args.pixels_size - ToGLuint(args.pixels) < args.padding ||
+        (state->unpack_row_length != 0 &&
+         state->unpack_row_length != args.width)) {
       // In ValidateTexImage(), we already made sure buffer size is no less
       // than offset + pixels_size.
       glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
       state->SetBoundBuffer(GL_PIXEL_UNPACK_BUFFER, nullptr);
       DoTexImageArguments new_args = args;
       new_args.pixels = nullptr;
       // pixels_size might be incorrect, but it's not used in this case.
       DoTexImage(texture_state, state, framebuffer_state, function_name,
                  texture_ref, new_args);
       glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer->service_id());
       state->SetBoundBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
 
       DoTexSubImageArguments sub_args = {
           args.target, args.level, 0, 0, 0, args.width, args.height, args.depth,
           args.format, args.type, args.pixels, args.pixels_size, args.padding,
           args.command_type == DoTexImageArguments::kTexImage3D ?
               DoTexSubImageArguments::kTexSubImage3D :
               DoTexSubImageArguments::kTexSubImage2D};
-      DoTexSubImageWithAlignmentWorkaround(texture_state, state, sub_args);
+      DoTexSubImageWithUnpackParamsWorkaround(texture_state, state, sub_args);
 
       SetLevelCleared(texture_ref, args.target, args.level, true);
       return;
     }
   }
   DoTexImage(texture_state, state, framebuffer_state,
              function_name, texture_ref, args);
 }
 
 bool TextureManager::ValidateTexSubImage(ContextState* state,
@@ skipping 134 matching lines @@
         return;
       }
     }
     full_image = false;
   } else {
     SetLevelCleared(texture_ref, args.target, args.level, true);
     full_image = true;
   }
 
   Buffer* buffer = state->bound_pixel_unpack_buffer.get();
-  if (texture_state->unpack_alignment_workaround_with_unpack_buffer && buffer) {
+  if (texture_state->unpack_parameters_workaround_with_unpack_buffer &&
+      buffer) {
     uint32_t buffer_size = static_cast<uint32_t>(buffer->size());
-    if (buffer_size - args.pixels_size - ToGLuint(args.pixels) < args.padding) {
-      DoTexSubImageWithAlignmentWorkaround(texture_state, state, args);
+    if (buffer_size - args.pixels_size - ToGLuint(args.pixels) < args.padding ||
+        (state->unpack_row_length != 0 &&
+         state->unpack_row_length != args.width)) {
+      DoTexSubImageWithUnpackParamsWorkaround(texture_state, state, args);
       return;
     }
   }
 
   if (full_image && !texture_state->texsubimage_faster_than_teximage &&
       !texture->IsImmutable() && !texture->HasImages()) {
     ScopedTextureUploadTimer timer(texture_state);
     GLenum internal_format;
     GLenum tex_type;
     texture->GetLevelType(args.target, args.level, &tex_type, &internal_format);
@@ skipping 16 matching lines @@
                       args.zoffset, args.width, args.height, args.depth,
                       AdjustTexFormat(args.format), args.type, args.pixels);
     } else {
       glTexSubImage2D(args.target, args.level, args.xoffset, args.yoffset,
                       args.width, args.height, AdjustTexFormat(args.format),
                       args.type, args.pixels);
     }
   }
 }
 
-void TextureManager::DoTexSubImageWithAlignmentWorkaround(
+void TextureManager::DoTexSubImageWithUnpackParamsWorkaround(
     DecoderTextureState* texture_state,
     ContextState* state,
     const DoTexSubImageArguments& args) {
   DCHECK(state->bound_pixel_unpack_buffer.get());
   DCHECK(args.width > 0 && args.height > 0 && args.depth > 0);
 
   ScopedTextureUploadTimer timer(texture_state);
   uint32_t offset = ToGLuint(args.pixels);
   if (args.command_type == DoTexSubImageArguments::kTexSubImage2D) {
     PixelStoreParams params = state->GetUnpackParams(ContextState::k2D);
     if (args.height > 1) {
       glTexSubImage2D(args.target, args.level, args.xoffset, args.yoffset,
                       args.width, args.height - 1,
                       AdjustTexFormat(args.format), args.type, args.pixels);
       GLint actual_width = state->unpack_row_length > 0 ?
           state->unpack_row_length : args.width;
       uint32_t size;
       uint32_t padding;
       // No need to worry about integer overflow here.
       GLES2Util::ComputeImageDataSizesES3(actual_width, args.height - 1, 1,
                                           args.format, args.type,
                                           params,
                                           &size,
                                           nullptr, nullptr, nullptr,
                                           &padding);
       DCHECK_EQ(args.padding, padding);
       // Last row should be padded, not unpadded.
       offset += size + padding;
     }
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    if (state->unpack_alignment != 1) {
+      glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    }
+    if (state->unpack_row_length != 0 &&
+        state->unpack_row_length != args.width) {
+      glPixelStorei(GL_UNPACK_ROW_LENGTH, args.width);
+    }
     glTexSubImage2D(args.target, args.level, args.xoffset,
                     args.yoffset + args.height - 1,
                     args.width, 1, AdjustTexFormat(args.format), args.type,
                     reinterpret_cast<const void *>(offset));
-    glPixelStorei(GL_UNPACK_ALIGNMENT, state->unpack_alignment);
+    if (state->unpack_alignment != 1) {
+      glPixelStorei(GL_UNPACK_ALIGNMENT, state->unpack_alignment);
+    }
+    if (state->unpack_row_length != 0 &&
+        state->unpack_row_length != args.width) {
+      glPixelStorei(GL_UNPACK_ROW_LENGTH, state->unpack_row_length);
+    }
     {
       uint32_t size;
       GLES2Util::ComputeImageDataSizesES3(args.width, 1, 1,
                                           args.format, args.type,
                                           params,
                                           &size,
                                           nullptr, nullptr, nullptr, nullptr);
       offset += size;
     }
   } else {  // kTexSubImage3D
@@ skipping 31 matching lines @@
       GLES2Util::ComputeImageDataSizesES3(actual_width, args.height - 1, 1,
                                           args.format, args.type,
                                           params,
                                           &size,
                                           nullptr, nullptr, nullptr,
                                           &padding);
       DCHECK_EQ(args.padding, padding);
       // Last row should be padded, not unpadded.
       offset += size + padding;
     }
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    if (state->unpack_alignment != 1) {
+      glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    }
+    if (state->unpack_row_length != 0 &&
+        state->unpack_row_length != args.width) {
+      glPixelStorei(GL_UNPACK_ROW_LENGTH, args.width);
+    }
     glTexSubImage3D(args.target, args.level, args.xoffset,
                     args.yoffset + args.height - 1,
                     args.zoffset + args.depth - 1,
                     args.width, 1, 1, AdjustTexFormat(args.format), args.type,
                     reinterpret_cast<const void *>(offset));
-    glPixelStorei(GL_UNPACK_ALIGNMENT, state->unpack_alignment);
+    if (state->unpack_alignment != 1) {
+      glPixelStorei(GL_UNPACK_ALIGNMENT, state->unpack_alignment);
+    }
+    if (state->unpack_row_length != 0 &&
+        state->unpack_row_length != args.width) {
+      glPixelStorei(GL_UNPACK_ROW_LENGTH, state->unpack_row_length);
+    }
     {
       uint32_t size;
       GLES2Util::ComputeImageDataSizesES3(args.width, 1, 1,
                                           args.format, args.type,
                                           params,
                                           &size,
                                           nullptr, nullptr, nullptr, nullptr);
       offset += size;
     }
   }
@@ skipping 479 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu