Fix incorrect VideoFrame::row_bytes() for RGB. Add tests.

media/base/video_util.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 "media/base/video_util.h"
 
 #include "base/logging.h"
 #include "media/base/video_frame.h"
 
 namespace media {
 
-static void CopyPlane(size_t plane, const uint8* source, int stride, int rows,
-                      VideoFrame* frame) {
+static void CopyPlane(size_t plane, const uint8* source, size_t stride,
+                      size_t rows, VideoFrame* frame) {

[Ami GONE FROM CHROMIUM, 2012/03/21 04:33:44]

Are you worried about an image w/ over 2 billion in any dimension?

(never use unsigned types in C++ just because the data you expect them to hold
is always >=0; there be monsters in manipulating unsigned types, which is why in
general we only use them for things that actually *require* unsignedness, such
as: system APIs requiring size_t and bit vectors)

[DaleCurtis, 2012/03/22 01:24:43]

I just flipped these to make them consistent with width and height which were
already size_t. As well as keeping me from having to add casts to every
ASSERT_EQ(<value>, RoundUp(...)). Which if I switch to just using the values
will no longer be necessary. Since you're concerned, I'll flip them back in any
case.

   uint8* dest = frame->data(plane);
-  int dest_stride = frame->stride(plane);
+  size_t dest_stride = frame->stride(plane);
 
   // Clamp in case source frame has smaller stride.
-  int bytes_to_copy_per_row = std::min(frame->row_bytes(plane), stride);
+  size_t bytes_to_copy_per_row = std::min(frame->row_bytes(plane), stride);
 
   // Clamp in case source frame has smaller height.
-  int rows_to_copy = std::min(frame->rows(plane), rows);
+  size_t rows_to_copy = std::min(frame->rows(plane), rows);
 
   // Copy!
-  for (int row = 0; row < rows_to_copy; ++row) {
+  for (size_t row = 0; row < rows_to_copy; ++row) {
     memcpy(dest, source, bytes_to_copy_per_row);
     source += stride;
     dest += dest_stride;
   }
 }
 
-void CopyYPlane(const uint8* source, int stride, int rows, VideoFrame* frame) {
+void CopyYPlane(const uint8* source, size_t stride, size_t rows,
+                VideoFrame* frame) {
   CopyPlane(VideoFrame::kYPlane, source, stride, rows, frame);
 }
 
-void CopyUPlane(const uint8* source, int stride, int rows, VideoFrame* frame) {
+void CopyUPlane(const uint8* source, size_t stride, size_t rows,
+                VideoFrame* frame) {
   CopyPlane(VideoFrame::kUPlane, source, stride, rows, frame);
 }
 
-void CopyVPlane(const uint8* source, int stride, int rows, VideoFrame* frame) {
+void CopyVPlane(const uint8* source, size_t stride, size_t rows,
+                VideoFrame* frame) {
   CopyPlane(VideoFrame::kVPlane, source, stride, rows, frame);
 }
 
 void FillYUV(VideoFrame* frame, uint8 y, uint8 u, uint8 v) {
   // Fill the Y plane.
   uint8* y_plane = frame->data(VideoFrame::kYPlane);
   int y_rows = frame->rows(VideoFrame::kYPlane);
   int y_row_bytes = frame->row_bytes(VideoFrame::kYPlane);
   for (int i = 0; i < y_rows; ++i) {
     memset(y_plane, y, y_row_bytes);
     y_plane += frame->stride(VideoFrame::kYPlane);
   }
 
   // Fill the U and V planes.
   uint8* u_plane = frame->data(VideoFrame::kUPlane);
   uint8* v_plane = frame->data(VideoFrame::kVPlane);
   int uv_rows = frame->rows(VideoFrame::kUPlane);
   int u_row_bytes = frame->row_bytes(VideoFrame::kUPlane);
   int v_row_bytes = frame->row_bytes(VideoFrame::kVPlane);
   for (int i = 0; i < uv_rows; ++i) {
     memset(u_plane, u, u_row_bytes);
     memset(v_plane, v, v_row_bytes);
     u_plane += frame->stride(VideoFrame::kUPlane);
     v_plane += frame->stride(VideoFrame::kVPlane);
   }
 }
 
 }  // namespace media