Revert of Delete remnants of non-square pixel support from cricket::VideoFrame.

talk/media/base/videoframe_unittest.h

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 134 matching lines @@
                  uint32_t format,
                  int32_t width,
                  int32_t height,
                  int dw,
                  int dh,
                  webrtc::VideoRotation rotation,
                  T* frame) {
     bool ret = false;
     for (int i = 0; i < repeat_; ++i) {
       ret = frame->Init(format, width, height, dw, dh,
-                        sample, sample_size, 0, rotation);
+                        sample, sample_size, 1, 1, 0, rotation);
     }
     return ret;
   }
 
   rtc::MemoryStream* LoadSample(const std::string& filename) {
     rtc::Pathname path(cricket::GetTestFilePath(filename));
     rtc::scoped_ptr<rtc::FileStream> fs(
         rtc::Filesystem::OpenFile(path, "rb"));
     if (!fs.get()) {
       LOG(LS_ERROR) << "Could not open test file path: " << path.pathname()
@@ skipping 122 matching lines @@
                      uint32_t width,
                      uint32_t height,
                      T* frame) {
     int y1_pos, y2_pos, u_pos, v_pos;
     if (!GetYuv422Packing(fourcc, &y1_pos, &y2_pos, &u_pos, &v_pos)) {
       return false;
     }
 
     const uint8_t* start = reinterpret_cast<const uint8_t*>(ms->GetBuffer());
     int awidth = (width + 1) & ~1;
-    frame->InitToBlack(width, height, 0);
+    frame->InitToBlack(width, height, 1, 1, 0);
     int stride_y = frame->GetYPitch();
     int stride_u = frame->GetUPitch();
     int stride_v = frame->GetVPitch();
     for (uint32_t y = 0; y < height; ++y) {
       for (uint32_t x = 0; x < width; x += 2) {
         const uint8_t* quad1 = start + (y * awidth + x) * 2;
         frame->GetYPlane()[stride_y * y + x] = quad1[y1_pos];
         if ((x + 1) < width) {
           frame->GetYPlane()[stride_y * y + x + 1] = quad1[y2_pos];
         }
@@ skipping 23 matching lines @@
     if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) {
       return false;
     }
     int pitch = width * bytes;
     const uint8_t* start = reinterpret_cast<const uint8_t*>(ms->GetBuffer());
     if (height < 0) {
       height = -height;
       start = start + pitch * (height - 1);
       pitch = -pitch;
     }
-    frame->InitToBlack(width, height, 0);
+    frame->InitToBlack(width, height, 1, 1, 0);
     int stride_y = frame->GetYPitch();
     int stride_u = frame->GetUPitch();
     int stride_v = frame->GetVPitch();
     for (int32_t y = 0; y < height; y += 2) {
       for (int32_t x = 0; x < width; x += 2) {
         const uint8_t* rgb[4];
         uint8_t yuv[4][3];
         rgb[0] = start + y * pitch + x * bytes;
         rgb[1] = rgb[0] + ((x + 1) < width ? bytes : 0);
         rgb[2] = rgb[0] + ((y + 1) < height ? pitch : 0);
@@ skipping 105 matching lines @@
       }
       r1 += pitch1;
       r2 += pitch2;
     }
     return true;
   }
 
   static bool IsEqual(const cricket::VideoFrame& frame,
                       size_t width,
                       size_t height,
+                      size_t pixel_width,
+                      size_t pixel_height,
                       int64_t time_stamp,
                       const uint8_t* y,
                       uint32_t ypitch,
                       const uint8_t* u,
                       uint32_t upitch,
                       const uint8_t* v,
                       uint32_t vpitch,
                       int max_error) {
     return IsSize(frame, static_cast<uint32_t>(width),
                   static_cast<uint32_t>(height)) &&
+           frame.GetPixelWidth() == pixel_width &&
+           frame.GetPixelHeight() == pixel_height &&
            frame.GetTimeStamp() == time_stamp &&
            IsPlaneEqual("y", frame.GetYPlane(), frame.GetYPitch(), y, ypitch,
                         static_cast<uint32_t>(width),
                         static_cast<uint32_t>(height), max_error) &&
            IsPlaneEqual("u", frame.GetUPlane(), frame.GetUPitch(), u, upitch,
                         static_cast<uint32_t>((width + 1) / 2),
                         static_cast<uint32_t>((height + 1) / 2), max_error) &&
            IsPlaneEqual("v", frame.GetVPlane(), frame.GetVPitch(), v, vpitch,
                         static_cast<uint32_t>((width + 1) / 2),
                         static_cast<uint32_t>((height + 1) / 2), max_error);
   }
 
   static bool IsEqual(const cricket::VideoFrame& frame1,
                       const cricket::VideoFrame& frame2,
                       int max_error) {
     return IsEqual(frame1,
                    frame2.GetWidth(), frame2.GetHeight(),
+                   frame2.GetPixelWidth(), frame2.GetPixelHeight(),
                    frame2.GetTimeStamp(),
                    frame2.GetYPlane(), frame2.GetYPitch(),
                    frame2.GetUPlane(), frame2.GetUPitch(),
                    frame2.GetVPlane(), frame2.GetVPitch(),
                    max_error);
   }
 
   static bool IsEqualWithCrop(const cricket::VideoFrame& frame1,
                               const cricket::VideoFrame& frame2,
                               int hcrop, int vcrop, int max_error) {
     return frame1.GetWidth() <= frame2.GetWidth() &&
            frame1.GetHeight() <= frame2.GetHeight() &&
            IsEqual(frame1,
                    frame2.GetWidth() - hcrop * 2,
                    frame2.GetHeight() - vcrop * 2,
+                   frame2.GetPixelWidth(), frame2.GetPixelHeight(),
                    frame2.GetTimeStamp(),
                    frame2.GetYPlane() + vcrop * frame2.GetYPitch()
                        + hcrop,
                    frame2.GetYPitch(),
                    frame2.GetUPlane() + vcrop * frame2.GetUPitch() / 2
                        + hcrop / 2,
                    frame2.GetUPitch(),
                    frame2.GetVPlane() + vcrop * frame2.GetVPitch() / 2
                        + hcrop / 2,
                    frame2.GetVPitch(),
@@ skipping 16 matching lines @@
     T frame;
     EXPECT_TRUE(IsNull(frame));
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420,
                           kWidth, kHeight, &frame));
 
     const uint8_t* y = reinterpret_cast<uint8_t*>(ms.get()->GetBuffer());
     const uint8_t* u = y + kWidth * kHeight;
     const uint8_t* v = u + kWidth * kHeight / 4;
-    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 0, y, kWidth, u,
+    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 1, 1, 0, y, kWidth, u,
                         kWidth / 2, v, kWidth / 2, 0));
   }
 
   // Test constructing an image from a YV12 buffer.
   void ConstructYV12() {
     T frame;
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         CreateYuvSample(kWidth, kHeight, 12));
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YV12,
                           kWidth, kHeight, &frame));
 
     const uint8_t* y = reinterpret_cast<uint8_t*>(ms.get()->GetBuffer());
     const uint8_t* v = y + kWidth * kHeight;
     const uint8_t* u = v + kWidth * kHeight / 4;
-    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 0, y, kWidth, u,
+    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 1, 1, 0, y, kWidth, u,
                         kWidth / 2, v, kWidth / 2, 0));
   }
 
   // Test constructing an image from a I422 buffer.
   void ConstructI422() {
     T frame1, frame2;
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
     size_t buf_size = kWidth * kHeight * 2;
     rtc::scoped_ptr<uint8_t[]> buf(new uint8_t[buf_size + kAlignment]);
     uint8_t* y = ALIGNP(buf.get(), kAlignment);
@@ skipping 243 matching lines @@
     ASSERT_TRUE(ms.get() != NULL);                                             \
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC, kWidth,          \
                           -kHeight, kWidth, kHeight,                           \
                           webrtc::kVideoRotation_180, &frame1));               \
     size_t data_size;                                                          \
     bool ret = ms->GetSize(&data_size);                                        \
     EXPECT_TRUE(ret);                                                          \
     EXPECT_TRUE(frame2.Init(cricket::FOURCC_##FOURCC, kWidth, kHeight, kWidth, \
                             kHeight,                                           \
                             reinterpret_cast<uint8_t*>(ms->GetBuffer()),       \
-                            data_size, 0, webrtc::kVideoRotation_0));    \
+                            data_size, 1, 1, 0, webrtc::kVideoRotation_0));    \
     int width_rotate = static_cast<int>(frame1.GetWidth());                    \
     int height_rotate = static_cast<int>(frame1.GetHeight());                  \
-    EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 0));     \
+    EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 1, 1, 0));     \
     libyuv::I420Mirror(                                                        \
         frame2.GetYPlane(), frame2.GetYPitch(), frame2.GetUPlane(),            \
         frame2.GetUPitch(), frame2.GetVPlane(), frame2.GetVPitch(),            \
         frame3.GetYPlane(), frame3.GetYPitch(), frame3.GetUPlane(),            \
         frame3.GetUPitch(), frame3.GetVPlane(), frame3.GetVPitch(), kWidth,    \
         kHeight);                                                              \
     EXPECT_TRUE(IsEqual(frame1, frame3, 0));                                   \
   }
 
   TEST_MIRROR(I420, 420)
 
 // Macro to help test different rotations
 #define TEST_ROTATE(FOURCC, BPP, ROTATE)                                       \
   void Construct##FOURCC##Rotate##ROTATE() {                                   \
     T frame1, frame2, frame3;                                                  \
     rtc::scoped_ptr<rtc::MemoryStream> ms(                                     \
         CreateYuvSample(kWidth, kHeight, BPP));                                \
     ASSERT_TRUE(ms.get() != NULL);                                             \
     EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC, kWidth, kHeight, \
                           kWidth, kHeight, webrtc::kVideoRotation_##ROTATE,    \
                           &frame1));                                           \
     size_t data_size;                                                          \
     bool ret = ms->GetSize(&data_size);                                        \
     EXPECT_TRUE(ret);                                                          \
     EXPECT_TRUE(frame2.Init(cricket::FOURCC_##FOURCC, kWidth, kHeight, kWidth, \
                             kHeight,                                           \
                             reinterpret_cast<uint8_t*>(ms->GetBuffer()),       \
-                            data_size, 0, webrtc::kVideoRotation_0));    \
+                            data_size, 1, 1, 0, webrtc::kVideoRotation_0));    \
     int width_rotate = static_cast<int>(frame1.GetWidth());                    \
     int height_rotate = static_cast<int>(frame1.GetHeight());                  \
-    EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 0));     \
+    EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 1, 1, 0));     \
     libyuv::I420Rotate(                                                        \
         frame2.GetYPlane(), frame2.GetYPitch(), frame2.GetUPlane(),            \
         frame2.GetUPitch(), frame2.GetVPlane(), frame2.GetVPitch(),            \
         frame3.GetYPlane(), frame3.GetYPitch(), frame3.GetUPlane(),            \
         frame3.GetUPitch(), frame3.GetVPlane(), frame3.GetVPitch(), kWidth,    \
         kHeight, libyuv::kRotate##ROTATE);                                     \
     EXPECT_TRUE(IsEqual(frame1, frame3, 0));                                   \
   }
 
   // Test constructing an image with rotation.
@@ skipping 85 matching lines @@
                           kWidth, kHeight, webrtc::kVideoRotation_270,
                           &frame2));
   }
 
   // Test 1 pixel edge case image I420 buffer.
   void ConstructI4201Pixel() {
     T frame;
     uint8_t pixel[3] = {1, 2, 3};
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 1, 1, 1, 1, pixel,
-                             sizeof(pixel), 0, webrtc::kVideoRotation_0));
+                             sizeof(pixel), 1, 1, 0, webrtc::kVideoRotation_0));
     }
     const uint8_t* y = pixel;
     const uint8_t* u = y + 1;
     const uint8_t* v = u + 1;
-    EXPECT_TRUE(IsEqual(frame, 1, 1, 0, y, 1, u, 1, v, 1, 0));
+    EXPECT_TRUE(IsEqual(frame, 1, 1, 1, 1, 0, y, 1, u, 1, v, 1, 0));
   }
 
   // Test 5 pixel edge case image.
   void ConstructI4205Pixel() {
     T frame;
     uint8_t pixels5x5[5 * 5 + ((5 + 1) / 2 * (5 + 1) / 2) * 2];
     memset(pixels5x5, 1, 5 * 5 + ((5 + 1) / 2 * (5 + 1) / 2) *  2);
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 5, 5, 5, 5, pixels5x5,
-                             sizeof(pixels5x5), 0,
+                             sizeof(pixels5x5), 1, 1, 0,
                              webrtc::kVideoRotation_0));
     }
     EXPECT_EQ(5u, frame.GetWidth());
     EXPECT_EQ(5u, frame.GetHeight());
     EXPECT_EQ(5, frame.GetYPitch());
     EXPECT_EQ(3, frame.GetUPitch());
     EXPECT_EQ(3, frame.GetVPitch());
   }
 
   // Test 1 pixel edge case image ARGB buffer.
   void ConstructARGB1Pixel() {
     T frame;
     uint8_t pixel[4] = {64, 128, 192, 255};
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_TRUE(frame.Init(cricket::FOURCC_ARGB, 1, 1, 1, 1, pixel,
-                             sizeof(pixel), 0,
+                             sizeof(pixel), 1, 1, 0,
                              webrtc::kVideoRotation_0));
     }
     // Convert back to ARGB.
     size_t out_size = 4;
     rtc::scoped_ptr<uint8_t[]> outbuf(new uint8_t[out_size + kAlignment]);
     uint8_t* out = ALIGNP(outbuf.get(), kAlignment);
 
     EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB,
                                                  out,
                                                  out_size,    // buffer size
@@ skipping 329 matching lines @@
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
     EXPECT_EQ(frame1.GetYPlane(), frame2.GetYPlane());
     EXPECT_EQ(frame1.GetUPlane(), frame2.GetUPlane());
     EXPECT_EQ(frame1.GetVPlane(), frame2.GetVPlane());
   }
 
   // Test creating an empty image and initing it to black.
   void ConstructBlack() {
     T frame;
     for (int i = 0; i < repeat_; ++i) {
-      EXPECT_TRUE(frame.InitToBlack(kWidth, kHeight, 0));
+      EXPECT_TRUE(frame.InitToBlack(kWidth, kHeight, 1, 1, 0));
     }
     EXPECT_TRUE(IsSize(frame, kWidth, kHeight));
     EXPECT_TRUE(IsBlack(frame));
   }
 
   // Test constructing an image from a YUY2 buffer with a range of sizes.
   // Only tests that conversion does not crash or corrupt heap.
   void ConstructYuy2AllSizes() {
     T frame1, frame2;
     for (int height = kMinHeightAll; height <= kMaxHeightAll; ++height) {
@@ skipping 45 matching lines @@
   }
 
   // Tests re-initing an existing image.
   void Reset(webrtc::VideoRotation rotation, bool apply_rotation) {
     T frame1, frame2;
     rtc::scoped_ptr<rtc::MemoryStream> ms(
         LoadSample(kImageFilename));
     ASSERT_TRUE(ms.get() != NULL);
     size_t data_size;
     ms->GetSize(&data_size);
-    EXPECT_TRUE(frame1.InitToBlack(kWidth, kHeight, 0));
-    EXPECT_TRUE(frame2.InitToBlack(kWidth, kHeight, 0));
+    EXPECT_TRUE(frame1.InitToBlack(kWidth, kHeight, 1, 1, 0));
+    EXPECT_TRUE(frame2.InitToBlack(kWidth, kHeight, 1, 1, 0));
     EXPECT_TRUE(IsBlack(frame1));
     EXPECT_TRUE(IsEqual(frame1, frame2, 0));
     EXPECT_TRUE(frame1.Reset(cricket::FOURCC_I420, kWidth, kHeight, kWidth,
                              kHeight,
                              reinterpret_cast<uint8_t*>(ms->GetBuffer()),
-                             data_size, 0, rotation, apply_rotation));
+                             data_size, 1, 1, 0, rotation, apply_rotation));
     if (apply_rotation)
       EXPECT_EQ(webrtc::kVideoRotation_0, frame1.GetVideoRotation());
     else
       EXPECT_EQ(rotation, frame1.GetVideoRotation());
 
     // Swapp width and height if the frame is rotated 90 or 270 degrees.
     if (apply_rotation && (rotation == webrtc::kVideoRotation_90
         || rotation == webrtc::kVideoRotation_270)) {
       EXPECT_TRUE(kHeight == frame1.GetWidth());
       EXPECT_TRUE(kWidth == frame1.GetHeight());
@@ skipping 51 matching lines @@
       out += (kHeight - 1) * stride;  // Point to last row.
       stride = -stride;
     }
     ASSERT_TRUE(LoadFrameNoRepeat(&frame1));
 
     for (int i = 0; i < repeat_to; ++i) {
       EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(fourcc,
                                                     out,
                                                     out_size, stride));
     }
-    EXPECT_TRUE(frame2.InitToBlack(kWidth, kHeight, 0));
+    EXPECT_TRUE(frame2.InitToBlack(kWidth, kHeight, 1, 1, 0));
     for (int i = 0; i < repeat_from; ++i) {
       EXPECT_EQ(0, RGBToI420(out, stride,
                              frame2.GetYPlane(), frame2.GetYPitch(),
                              frame2.GetUPlane(), frame2.GetUPitch(),
                              frame2.GetVPlane(), frame2.GetVPitch(),
                              kWidth, kHeight));
     }
     if (rowpad) {
       EXPECT_EQ(0, outtop[kWidth * bpp]);  // Ensure stride skipped end of row.
       EXPECT_NE(0, outtop[astride]);       // Ensure pixel at start of 2nd row.
@@ skipping 400 matching lines @@
     EXPECT_EQ(0, memcmp(ms2.GetBuffer(), ms->GetBuffer(), out_size));
   }
 
   void CopyToBuffer1Pixel() {
     size_t out_size = 3;
     rtc::scoped_ptr<uint8_t[]> out(new uint8_t[out_size + 1]);
     memset(out.get(), 0xfb, out_size + 1);  // Fill buffer
     uint8_t pixel[3] = {1, 2, 3};
     T frame;
     EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 1, 1, 1, 1, pixel,
-                           sizeof(pixel), 0,
+                           sizeof(pixel), 1, 1, 0,
                            webrtc::kVideoRotation_0));
     for (int i = 0; i < repeat_; ++i) {
       EXPECT_EQ(out_size, frame.CopyToBuffer(out.get(), out_size));
     }
     EXPECT_EQ(1, out.get()[0]);  // Check Y.  Should be 1.
     EXPECT_EQ(2, out.get()[1]);  // Check U.  Should be 2.
     EXPECT_EQ(3, out.get()[2]);  // Check V.  Should be 3.
     EXPECT_EQ(0xfb, out.get()[3]);  // Check sentinel is still intact.
   }
 
   void StretchToFrame() {
     // Create the source frame as a black frame.
     T source;
-    EXPECT_TRUE(source.InitToBlack(kWidth * 2, kHeight * 2, 0));
+    EXPECT_TRUE(source.InitToBlack(kWidth * 2, kHeight * 2, 1, 1, 0));
     EXPECT_TRUE(IsSize(source, kWidth * 2, kHeight * 2));
 
     // Create the target frame by loading from a file.
     T target1;
     ASSERT_TRUE(LoadFrameNoRepeat(&target1));
     EXPECT_FALSE(IsBlack(target1));
 
     // Stretch and check if the stretched target is black.
     source.StretchToFrame(&target1, true, false);
     EXPECT_TRUE(IsBlack(target1));
 
     // Crop and stretch and check if the stretched target is black.
     T target2;
     ASSERT_TRUE(LoadFrameNoRepeat(&target2));
     source.StretchToFrame(&target2, true, true);
     EXPECT_TRUE(IsBlack(target2));
     EXPECT_EQ(source.GetTimeStamp(), target2.GetTimeStamp());
   }
 
   int repeat_;
 };
 
 #endif  // TALK_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_