Remove RGB32 from VideoFrame::Format.

media/base/video_frame_unittest.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_frame.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
+#include "base/memory/aligned_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "media/base/buffers.h"
 #include "media/base/yuv_convert.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 using base::MD5DigestToBase16;
 
@@ skipping 19 matching lines @@
     v_plane += frame->stride(VideoFrame::kVPlane);
   }
 }
 
 // Given a |yv12_frame| this method converts the YV12 frame to RGBA and
 // makes sure that all the pixels of the RBG frame equal |expect_rgb_color|.
 void ExpectFrameColor(media::VideoFrame* yv12_frame, uint32 expect_rgb_color) {
   ASSERT_EQ(VideoFrame::YV12, yv12_frame->format());
   ASSERT_EQ(yv12_frame->stride(VideoFrame::kUPlane),
             yv12_frame->stride(VideoFrame::kVPlane));
+  ASSERT_EQ(
+      yv12_frame->coded_size().width() & (VideoFrame::kFrameSizeAlignment - 1),
+      0);
+  ASSERT_EQ(
+      yv12_frame->coded_size().height() & (VideoFrame::kFrameSizeAlignment - 1),
+      0);
 
-  scoped_refptr<media::VideoFrame> rgb_frame;
-  rgb_frame = media::VideoFrame::CreateFrame(VideoFrame::RGB32,
-                                             yv12_frame->coded_size(),
-                                             yv12_frame->visible_rect(),
-                                             yv12_frame->natural_size(),
-                                             yv12_frame->GetTimestamp());
-
-  ASSERT_EQ(yv12_frame->coded_size().width(),
-      rgb_frame->coded_size().width());
-  ASSERT_EQ(yv12_frame->coded_size().height(),
-      rgb_frame->coded_size().height());
+  size_t bytes_per_row = yv12_frame->coded_size().width() * 4u;
+  uint8* rgb_data = reinterpret_cast<uint8*>(
+      base::AlignedAlloc(bytes_per_row * yv12_frame->coded_size().height() +
+                             VideoFrame::kFrameSizePadding,
+                         VideoFrame::kFrameAddressAlignment));
 
   media::ConvertYUVToRGB32(yv12_frame->data(VideoFrame::kYPlane),
                            yv12_frame->data(VideoFrame::kUPlane),
                            yv12_frame->data(VideoFrame::kVPlane),
-                           rgb_frame->data(VideoFrame::kRGBPlane),
-                           rgb_frame->coded_size().width(),
-                           rgb_frame->coded_size().height(),
+                           rgb_data,
+                           yv12_frame->coded_size().width(),
+                           yv12_frame->coded_size().height(),
                            yv12_frame->stride(VideoFrame::kYPlane),
                            yv12_frame->stride(VideoFrame::kUPlane),
-                           rgb_frame->stride(VideoFrame::kRGBPlane),
+                           bytes_per_row,
                            media::YV12);
 
-  for (int row = 0; row < rgb_frame->coded_size().height(); ++row) {
+  for (int row = 0; row < yv12_frame->coded_size().height(); ++row) {
     uint32* rgb_row_data = reinterpret_cast<uint32*>(
-        rgb_frame->data(VideoFrame::kRGBPlane) +
-        (rgb_frame->stride(VideoFrame::kRGBPlane) * row));
-    for (int col = 0; col < rgb_frame->coded_size().width(); ++col) {
+        rgb_data + (bytes_per_row * row));
+    for (int col = 0; col < yv12_frame->coded_size().width(); ++col) {
       SCOPED_TRACE(
           base::StringPrintf("Checking (%d, %d)", row, col));
       EXPECT_EQ(expect_rgb_color, rgb_row_data[col]);
     }
   }
+
+  base::AlignedFree(rgb_data);
 }
 
 // Fill each plane to its reported extents and verify accessors report non
 // zero values.  Additionally, for the first plane verify the rows and
 // row_bytes values are correct.
 void ExpectFrameExtents(VideoFrame::Format format, int planes,
                         int bytes_per_pixel, const char* expected_hash) {
   const unsigned char kFillByte = 0x80;
   const int kWidth = 61;
   const int kHeight = 31;
@@ skipping 104 matching lines @@
   }
 }
 
 // Ensure each frame is properly sized and allocated.  Will trigger OOB reads
 // and writes as well as incorrect frame hashes otherwise.
 TEST(VideoFrame, CheckFrameExtents) {
   // Each call consists of a VideoFrame::Format, # of planes, bytes per pixel,
   // and the expected hash of all planes if filled with kFillByte (defined in
   // ExpectFrameExtents).
   ExpectFrameExtents(
-      VideoFrame::RGB32,  1, 4, "de6d3d567e282f6a38d478f04fc81fb0");
-  ExpectFrameExtents(
       VideoFrame::YV12,   3, 1, "71113bdfd4c0de6cf62f48fb74f7a0b1");
   ExpectFrameExtents(
       VideoFrame::YV16,   3, 1, "9bb99ac3ff350644ebff4d28dc01b461");
 }
 
 static void TextureCallback(uint32* called_sync_point, uint32 sync_point) {
   *called_sync_point = sync_point;
 }
 
 // Verify the TextureNoLongerNeededCallback is called when VideoFrame is
@@ skipping 197 matching lines @@
 
     EXPECT_EQ(0u, called_sync_point);
 
     // Don't use the mailbox at all and drop our ref on it.
   }
   // The VideoFrame is destroyed, it should call the callback.
   EXPECT_EQ(sync_point, called_sync_point);
 }
 
 }  // namespace media