YUV software decode path stride fixes.

cc/texture_uploader.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/texture_uploader.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/debug/alias.h"
@@ skipping 211 matching lines @@
     base::debug::Alias(&image_rect_height);
     base::debug::Alias(&dest_offset_x);
     base::debug::Alias(&dest_offset_y);
     TRACE_EVENT0("cc", "TextureUploader::uploadWithTexSubImage");
 
     // Offset from image-rect to source-rect.
     gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
 
     const uint8* pixel_source;
     unsigned int bytes_per_pixel = Resource::bytesPerPixel(format);
+    // Use 4-byte row alignment (OpenGL default) for upload performance.
+    unsigned int upload_image_stride =
+        (bytes_per_pixel * source_rect.width() + 3) & ~0x3;

[danakj, 2012/11/19 22:57:00]

Oh, I see. This is ((image_stride + 3) / 4) * 4. Can you just write it like
that?

[danakj, 2012/11/19 22:58:11]

Or, make a nice descriptively named static function to do this. That'd be quite
nice.

+    m_context->pixelStorei(GL_UNPACK_ALIGNMENT, 4);
 
-    if (image_rect.width() == source_rect.width() && !offset.x()) {
-        pixel_source = &image[bytes_per_pixel * offset.y() * image_rect.width()];
+    if (upload_image_stride == image_rect.width() * bytes_per_pixel && !offset.x()) {
+        pixel_source = &image[image_rect.width() * bytes_per_pixel * offset.y()];
     } else {
-        size_t needed_size = source_rect.width() * source_rect.height() * bytes_per_pixel;
+        size_t needed_size = upload_image_stride * source_rect.height();
         if (m_subImageSize < needed_size) {
             m_subImage.reset(new uint8[needed_size]);
             m_subImageSize = needed_size;
         }
         // Strides not equal, so do a row-by-row memcpy from the
         // paint results into a temp buffer for uploading.
         for (int row = 0; row < source_rect.height(); ++row)
-            memcpy(&m_subImage[source_rect.width() * bytes_per_pixel * row],
+            memcpy(&m_subImage[upload_image_stride * row],
                    &image[bytes_per_pixel * (offset.x() +
                           (offset.y() + row) * image_rect.width())],
                    source_rect.width() * bytes_per_pixel);
 
         pixel_source = &m_subImage[0];
     }
 
     m_context->texSubImage2D(GL_TEXTURE_2D,
                              0,
                              dest_offset.x(),
@@ skipping 32 matching lines @@
     base::debug::Alias(&image_rect_width);
     base::debug::Alias(&image_rect_height);
     base::debug::Alias(&dest_offset_x);
     base::debug::Alias(&dest_offset_y);
 
     TRACE_EVENT0("cc", "TextureUploader::uploadWithMapTexSubImage");
 
     // Offset from image-rect to source-rect.
     gfx::Vector2d offset(source_rect.origin() - image_rect.origin());
 
+    unsigned int bytes_per_pixel = Resource::bytesPerPixel(format);
+    // Use 4-byte row alignment (OpenGL default) for upload performance.
+    unsigned int upload_image_stride =
+        (bytes_per_pixel * source_rect.width() + 3) & ~0x3;
+    m_context->pixelStorei(GL_UNPACK_ALIGNMENT, 4);
+
     // Upload tile data via a mapped transfer buffer
     uint8* pixel_dest = static_cast<uint8*>(
         m_context->mapTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
                                             0,
                                             dest_offset.x(),
                                             dest_offset.y(),
                                             source_rect.width(),
                                             source_rect.height(),
                                             format,
                                             GL_UNSIGNED_BYTE,
                                             GL_WRITE_ONLY));
 
     if (!pixel_dest) {
         uploadWithTexSubImage(
             image, image_rect, source_rect, dest_offset, format);
         return;
     }
 
-    unsigned int bytes_per_pixel = Resource::bytesPerPixel(format);
-
-    if (image_rect.width() == source_rect.width() && !offset.x()) {
+    if (upload_image_stride == image_rect.width() * bytes_per_pixel && !offset.x()) {
         memcpy(pixel_dest,
-               &image[offset.y() * image_rect.width() * bytes_per_pixel],
-               image_rect.width() * source_rect.height() * bytes_per_pixel);
+               &image[image_rect.width() * bytes_per_pixel * offset.y()],
+               source_rect.height() * image_rect.width() * bytes_per_pixel);
     } else {
         // Strides not equal, so do a row-by-row memcpy from the
         // paint results into the pixelDest
         for (int row = 0; row < source_rect.height(); ++row)
-            memcpy(&pixel_dest[source_rect.width() * row * bytes_per_pixel],
+            memcpy(&pixel_dest[upload_image_stride * row],
                    &image[bytes_per_pixel * (offset.x() +
                           (offset.y() + row) * image_rect.width())],
                    source_rect.width() * bytes_per_pixel);
     }
 
     m_context->unmapTexSubImage2DCHROMIUM(pixel_dest);
 }
 
 void TextureUploader::processQueries()
 {
@@ skipping 13 matching lines @@
             m_texturesPerSecondHistory.erase(m_texturesPerSecondHistory.begin());
             m_texturesPerSecondHistory.erase(--m_texturesPerSecondHistory.end());
         }
         m_texturesPerSecondHistory.insert(texturesPerSecond);
 
         m_availableQueries.append(m_pendingQueries.takeFirst());
     }
 }
 
 }  // namespace cc