Resubmit - Use SSE2 block differ for chromoting

remoting/host/differ.cc

 // Copyright (c) 2010 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 "remoting/host/differ.h"
 
 #include "base/logging.h"
+#include "remoting/host/differ_block.h"
 
 namespace remoting {
 
 Differ::Differ(int width, int height, int bpp, int stride) {
   // Dimensions of screen.
   width_ = width;
   height_ = height;
   bytes_per_pixel_ = bpp;
   bytes_per_row_ = stride;
 
@@ skipping 47 matching lines @@
   const uint8* prev_block_row_start = static_cast<const uint8*>(prev_buffer);
   const uint8* curr_block_row_start = static_cast<const uint8*>(curr_buffer);
   uint8* diff_info_row_start = static_cast<uint8*>(diff_info_.get());
 
   for (int y = 0; y < y_full_blocks; y++) {
     const uint8* prev_block = prev_block_row_start;
     const uint8* curr_block = curr_block_row_start;
     uint8* diff_info = diff_info_row_start;
 
     for (int x = 0; x < x_full_blocks; x++) {
-      DiffInfo diff = DiffBlock(prev_block, curr_block, bytes_per_row_);
+      DiffInfo diff = BlockDifference(prev_block, curr_block, bytes_per_row_);
       if (diff != 0) {
         // Mark this block as being modified so that it gets incorporated into
         // a dirty rect.
         *diff_info = diff;
       }
       prev_block += block_x_offset;
       curr_block += block_x_offset;
       diff_info += sizeof(DiffInfo);
     }
 
     // If there is a partial column at the end, handle it.
     if (partial_column_width != 0) {
       // TODO(garykac): Handle last partial column.
     }
 
     // Update pointers for next row.
     prev_block_row_start += block_y_stride;
     curr_block_row_start += block_y_stride;
     diff_info_row_start += diff_info_stride;
   }
   if (partial_row_height != 0) {
     // TODO(garykac): Handle last partial row.
   }
 }
 
-DiffInfo Differ::DiffBlock(const uint8* prev_buffer, const uint8* curr_buffer,
-                           int stride) {
-  const uint8* prev_row_start = prev_buffer;
-  const uint8* curr_row_start = curr_buffer;
-
-  // Number of uint64s in each row of the block.
-  // This must be an integral number.
-  int int64s_per_row = (kBlockSize * bytes_per_pixel_) / sizeof(uint64);
-  DCHECK(((kBlockSize * bytes_per_pixel_) % sizeof(uint64)) == 0);
-
-  for (int y = 0; y < kBlockSize; y++) {
-    const uint64* prev = reinterpret_cast<const uint64*>(prev_row_start);
-    const uint64* curr = reinterpret_cast<const uint64*>(curr_row_start);
-
-    // Check each row in uint64-sized chunks.
-    // Note that this check may straddle multiple pixels. This is OK because
-    // we're interested in identifying whether or not there was change - we
-    // don't care what the actual change is.
-    for (int x = 0; x < int64s_per_row; x++) {
-      if (*prev++ != *curr++) {
-        return 1;
-      }
-    }
-    prev_row_start += stride;
-    curr_row_start += stride;
-  }
-  return 0;
-}
-
 DiffInfo Differ::DiffPartialBlock(const uint8* prev_buffer,
                                   const uint8* curr_buffer,
                                   int stride, int width, int height) {
   const uint8* prev_row_start = prev_buffer;
   const uint8* curr_row_start = curr_buffer;
 
   for (int y = 0; y < height; y++) {
     const uint8* prev = prev_row_start;
     const uint8* curr = curr_row_start;
     for (int x = 0; x < width; x++) {
@@ skipping 79 matching lines @@
       // Increment to next block in this row.
       diff_info++;
     }
 
     // Go to start of next row.
     diff_info_row_start += diff_info_stride;
   }
 }
 
 }  // namespace remoting