1 /* 2 * libjingle 3 * Copyright 2004 Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #ifndef TALK_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_ 29 #define TALK_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_ 30 31 #include <string> 32 33 #include "libyuv/convert.h" 34 #include "libyuv/convert_from.h" 35 #include "libyuv/format_conversion.h" 36 #include "libyuv/planar_functions.h" 37 #include "libyuv/rotate.h" 38 #include "talk/media/base/testutils.h" 39 #include "talk/media/base/videocommon.h" 40 #include "talk/media/base/videoframe.h" 41 #include "webrtc/base/gunit.h" 42 #include "webrtc/base/pathutils.h" 43 #include "webrtc/base/stream.h" 44 #include "webrtc/base/stringutils.h" 45 46 #if defined(_MSC_VER) 47 #define ALIGN16(var) __declspec(align(16)) var 48 #else 49 #define ALIGN16(var) var __attribute__((aligned(16))) 50 #endif 51 52 #define kImageFilename "faces.1280x720_P420.yuv" 53 #define kJpeg420Filename "faces_I420.jpg" 54 #define kJpeg422Filename "faces_I422.jpg" 55 #define kJpeg444Filename "faces_I444.jpg" 56 #define kJpeg411Filename "faces_I411.jpg" 57 #define kJpeg400Filename "faces_I400.jpg" 58 59 // Generic test class for testing various video frame implementations. 60 template <class T> 61 class VideoFrameTest : public testing::Test { 62 public: 63 VideoFrameTest() : repeat_(1) {} 64 65 protected: 66 static const int kWidth = 1280; 67 static const int kHeight = 720; 68 static const int kAlignment = 16; 69 static const int kMinWidthAll = 1; // Constants for ConstructYUY2AllSizes. 70 static const int kMinHeightAll = 1; 71 static const int kMaxWidthAll = 17; 72 static const int kMaxHeightAll = 23; 73 74 // Load a video frame from disk. 75 bool LoadFrameNoRepeat(T* frame) { 76 int save_repeat = repeat_; // This LoadFrame disables repeat. 77 repeat_ = 1; 78 bool success = LoadFrame(kImageFilename, cricket::FOURCC_I420, 79 kWidth, kHeight, frame); 80 repeat_ = save_repeat; 81 return success; 82 } 83 84 bool LoadFrame(const std::string& filename, uint32 format, 85 int32 width, int32 height, T* frame) { 86 return LoadFrame(filename, format, width, height, 87 width, abs(height), 0, frame); 88 } 89 bool LoadFrame(const std::string& filename, uint32 format, 90 int32 width, int32 height, int dw, int dh, int rotation, 91 T* frame) { 92 rtc::scoped_ptr<rtc::MemoryStream> ms(LoadSample(filename)); 93 return LoadFrame(ms.get(), format, width, height, dw, dh, rotation, frame); 94 } 95 // Load a video frame from a memory stream. 96 bool LoadFrame(rtc::MemoryStream* ms, uint32 format, 97 int32 width, int32 height, T* frame) { 98 return LoadFrame(ms, format, width, height, 99 width, abs(height), 0, frame); 100 } 101 bool LoadFrame(rtc::MemoryStream* ms, uint32 format, 102 int32 width, int32 height, int dw, int dh, int rotation, 103 T* frame) { 104 if (!ms) { 105 return false; 106 } 107 size_t data_size; 108 bool ret = ms->GetSize(&data_size); 109 EXPECT_TRUE(ret); 110 if (ret) { 111 ret = LoadFrame(reinterpret_cast<uint8*>(ms->GetBuffer()), data_size, 112 format, width, height, dw, dh, rotation, frame); 113 } 114 return ret; 115 } 116 // Load a frame from a raw buffer. 117 bool LoadFrame(uint8* sample, size_t sample_size, uint32 format, 118 int32 width, int32 height, T* frame) { 119 return LoadFrame(sample, sample_size, format, width, height, 120 width, abs(height), 0, frame); 121 } 122 bool LoadFrame(uint8* sample, size_t sample_size, uint32 format, 123 int32 width, int32 height, int dw, int dh, int rotation, 124 T* frame) { 125 bool ret = false; 126 for (int i = 0; i < repeat_; ++i) { 127 ret = frame->Init(format, width, height, dw, dh, 128 sample, sample_size, 1, 1, 0, 0, rotation); 129 } 130 return ret; 131 } 132 133 rtc::MemoryStream* LoadSample(const std::string& filename) { 134 rtc::Pathname path(cricket::GetTestFilePath(filename)); 135 rtc::scoped_ptr<rtc::FileStream> fs( 136 rtc::Filesystem::OpenFile(path, "rb")); 137 if (!fs.get()) { 138 LOG(LS_ERROR) << "Could not open test file path: " << path.pathname() 139 << " from current dir " 140 << rtc::Filesystem::GetCurrentDirectory().pathname(); 141 return NULL; 142 } 143 144 char buf[4096]; 145 rtc::scoped_ptr<rtc::MemoryStream> ms( 146 new rtc::MemoryStream()); 147 rtc::StreamResult res = Flow(fs.get(), buf, sizeof(buf), ms.get()); 148 if (res != rtc::SR_SUCCESS) { 149 LOG(LS_ERROR) << "Could not load test file path: " << path.pathname(); 150 return NULL; 151 } 152 153 return ms.release(); 154 } 155 156 // Write an I420 frame out to disk. 157 bool DumpFrame(const std::string& prefix, 158 const cricket::VideoFrame& frame) { 159 char filename[256]; 160 rtc::sprintfn(filename, sizeof(filename), "%s.%dx%d_P420.yuv", 161 prefix.c_str(), frame.GetWidth(), frame.GetHeight()); 162 size_t out_size = cricket::VideoFrame::SizeOf(frame.GetWidth(), 163 frame.GetHeight()); 164 rtc::scoped_ptr<uint8[]> out(new uint8[out_size]); 165 frame.CopyToBuffer(out.get(), out_size); 166 return DumpSample(filename, out.get(), out_size); 167 } 168 169 bool DumpSample(const std::string& filename, const void* buffer, int size) { 170 rtc::Pathname path(filename); 171 rtc::scoped_ptr<rtc::FileStream> fs( 172 rtc::Filesystem::OpenFile(path, "wb")); 173 if (!fs.get()) { 174 return false; 175 } 176 177 return (fs->Write(buffer, size, NULL, NULL) == rtc::SR_SUCCESS); 178 } 179 180 // Create a test image in the desired color space. 181 // The image is a checkerboard pattern with 63x63 squares, which allows 182 // I420 chroma artifacts to easily be seen on the square boundaries. 183 // The pattern is { { green, orange }, { blue, purple } } 184 // There is also a gradient within each square to ensure that the luma 185 // values are handled properly. 186 rtc::MemoryStream* CreateYuv422Sample(uint32 fourcc, 187 uint32 width, uint32 height) { 188 int y1_pos, y2_pos, u_pos, v_pos; 189 if (!GetYuv422Packing(fourcc, &y1_pos, &y2_pos, &u_pos, &v_pos)) { 190 return NULL; 191 } 192 193 rtc::scoped_ptr<rtc::MemoryStream> ms( 194 new rtc::MemoryStream); 195 int awidth = (width + 1) & ~1; 196 int size = awidth * 2 * height; 197 if (!ms->ReserveSize(size)) { 198 return NULL; 199 } 200 for (uint32 y = 0; y < height; ++y) { 201 for (int x = 0; x < awidth; x += 2) { 202 uint8 quad[4]; 203 quad[y1_pos] = (x % 63 + y % 63) + 64; 204 quad[y2_pos] = ((x + 1) % 63 + y % 63) + 64; 205 quad[u_pos] = ((x / 63) & 1) ? 192 : 64; 206 quad[v_pos] = ((y / 63) & 1) ? 192 : 64; 207 ms->Write(quad, sizeof(quad), NULL, NULL); 208 } 209 } 210 return ms.release(); 211 } 212 213 // Create a test image for YUV 420 formats with 12 bits per pixel. 214 rtc::MemoryStream* CreateYuvSample(uint32 width, uint32 height, 215 uint32 bpp) { 216 rtc::scoped_ptr<rtc::MemoryStream> ms( 217 new rtc::MemoryStream); 218 if (!ms->ReserveSize(width * height * bpp / 8)) { 219 return NULL; 220 } 221 222 for (uint32 i = 0; i < width * height * bpp / 8; ++i) { 223 char value = ((i / 63) & 1) ? 192 : 64; 224 ms->Write(&value, sizeof(value), NULL, NULL); 225 } 226 return ms.release(); 227 } 228 229 rtc::MemoryStream* CreateRgbSample(uint32 fourcc, 230 uint32 width, uint32 height) { 231 int r_pos, g_pos, b_pos, bytes; 232 if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) { 233 return NULL; 234 } 235 236 rtc::scoped_ptr<rtc::MemoryStream> ms( 237 new rtc::MemoryStream); 238 if (!ms->ReserveSize(width * height * bytes)) { 239 return NULL; 240 } 241 242 for (uint32 y = 0; y < height; ++y) { 243 for (uint32 x = 0; x < width; ++x) { 244 uint8 rgb[4] = { 255, 255, 255, 255 }; 245 rgb[r_pos] = ((x / 63) & 1) ? 224 : 32; 246 rgb[g_pos] = (x % 63 + y % 63) + 96; 247 rgb[b_pos] = ((y / 63) & 1) ? 224 : 32; 248 ms->Write(rgb, bytes, NULL, NULL); 249 } 250 } 251 return ms.release(); 252 } 253 254 // Simple conversion routines to verify the optimized VideoFrame routines. 255 // Converts from the specified colorspace to I420. 256 bool ConvertYuv422(const rtc::MemoryStream* ms, 257 uint32 fourcc, uint32 width, uint32 height, 258 T* frame) { 259 int y1_pos, y2_pos, u_pos, v_pos; 260 if (!GetYuv422Packing(fourcc, &y1_pos, &y2_pos, &u_pos, &v_pos)) { 261 return false; 262 } 263 264 const uint8* start = reinterpret_cast<const uint8*>(ms->GetBuffer()); 265 int awidth = (width + 1) & ~1; 266 frame->InitToBlack(width, height, 1, 1, 0, 0); 267 int stride_y = frame->GetYPitch(); 268 int stride_u = frame->GetUPitch(); 269 int stride_v = frame->GetVPitch(); 270 for (uint32 y = 0; y < height; ++y) { 271 for (uint32 x = 0; x < width; x += 2) { 272 const uint8* quad1 = start + (y * awidth + x) * 2; 273 frame->GetYPlane()[stride_y * y + x] = quad1[y1_pos]; 274 if ((x + 1) < width) { 275 frame->GetYPlane()[stride_y * y + x + 1] = quad1[y2_pos]; 276 } 277 if ((y & 1) == 0) { 278 const uint8* quad2 = quad1 + awidth * 2; 279 if ((y + 1) >= height) { 280 quad2 = quad1; 281 } 282 frame->GetUPlane()[stride_u * (y / 2) + x / 2] = 283 (quad1[u_pos] + quad2[u_pos] + 1) / 2; 284 frame->GetVPlane()[stride_v * (y / 2) + x / 2] = 285 (quad1[v_pos] + quad2[v_pos] + 1) / 2; 286 } 287 } 288 } 289 return true; 290 } 291 292 // Convert RGB to 420. 293 // A negative height inverts the image. 294 bool ConvertRgb(const rtc::MemoryStream* ms, 295 uint32 fourcc, int32 width, int32 height, 296 T* frame) { 297 int r_pos, g_pos, b_pos, bytes; 298 if (!GetRgbPacking(fourcc, &r_pos, &g_pos, &b_pos, &bytes)) { 299 return false; 300 } 301 int pitch = width * bytes; 302 const uint8* start = reinterpret_cast<const uint8*>(ms->GetBuffer()); 303 if (height < 0) { 304 height = -height; 305 start = start + pitch * (height - 1); 306 pitch = -pitch; 307 } 308 frame->InitToBlack(width, height, 1, 1, 0, 0); 309 int stride_y = frame->GetYPitch(); 310 int stride_u = frame->GetUPitch(); 311 int stride_v = frame->GetVPitch(); 312 for (int32 y = 0; y < height; y += 2) { 313 for (int32 x = 0; x < width; x += 2) { 314 const uint8* rgb[4]; 315 uint8 yuv[4][3]; 316 rgb[0] = start + y * pitch + x * bytes; 317 rgb[1] = rgb[0] + ((x + 1) < width ? bytes : 0); 318 rgb[2] = rgb[0] + ((y + 1) < height ? pitch : 0); 319 rgb[3] = rgb[2] + ((x + 1) < width ? bytes : 0); 320 for (size_t i = 0; i < 4; ++i) { 321 ConvertRgbPixel(rgb[i][r_pos], rgb[i][g_pos], rgb[i][b_pos], 322 &yuv[i][0], &yuv[i][1], &yuv[i][2]); 323 } 324 frame->GetYPlane()[stride_y * y + x] = yuv[0][0]; 325 if ((x + 1) < width) { 326 frame->GetYPlane()[stride_y * y + x + 1] = yuv[1][0]; 327 } 328 if ((y + 1) < height) { 329 frame->GetYPlane()[stride_y * (y + 1) + x] = yuv[2][0]; 330 if ((x + 1) < width) { 331 frame->GetYPlane()[stride_y * (y + 1) + x + 1] = yuv[3][0]; 332 } 333 } 334 frame->GetUPlane()[stride_u * (y / 2) + x / 2] = 335 (yuv[0][1] + yuv[1][1] + yuv[2][1] + yuv[3][1] + 2) / 4; 336 frame->GetVPlane()[stride_v * (y / 2) + x / 2] = 337 (yuv[0][2] + yuv[1][2] + yuv[2][2] + yuv[3][2] + 2) / 4; 338 } 339 } 340 return true; 341 } 342 343 // Simple and slow RGB->YUV conversion. From NTSC standard, c/o Wikipedia. 344 void ConvertRgbPixel(uint8 r, uint8 g, uint8 b, 345 uint8* y, uint8* u, uint8* v) { 346 *y = static_cast<int>(.257 * r + .504 * g + .098 * b) + 16; 347 *u = static_cast<int>(-.148 * r - .291 * g + .439 * b) + 128; 348 *v = static_cast<int>(.439 * r - .368 * g - .071 * b) + 128; 349 } 350 351 bool GetYuv422Packing(uint32 fourcc, 352 int* y1_pos, int* y2_pos, int* u_pos, int* v_pos) { 353 if (fourcc == cricket::FOURCC_YUY2) { 354 *y1_pos = 0; *u_pos = 1; *y2_pos = 2; *v_pos = 3; 355 } else if (fourcc == cricket::FOURCC_UYVY) { 356 *u_pos = 0; *y1_pos = 1; *v_pos = 2; *y2_pos = 3; 357 } else { 358 return false; 359 } 360 return true; 361 } 362 363 bool GetRgbPacking(uint32 fourcc, 364 int* r_pos, int* g_pos, int* b_pos, int* bytes) { 365 if (fourcc == cricket::FOURCC_RAW) { 366 *r_pos = 0; *g_pos = 1; *b_pos = 2; *bytes = 3; // RGB in memory. 367 } else if (fourcc == cricket::FOURCC_24BG) { 368 *r_pos = 2; *g_pos = 1; *b_pos = 0; *bytes = 3; // BGR in memory. 369 } else if (fourcc == cricket::FOURCC_ABGR) { 370 *r_pos = 0; *g_pos = 1; *b_pos = 2; *bytes = 4; // RGBA in memory. 371 } else if (fourcc == cricket::FOURCC_BGRA) { 372 *r_pos = 1; *g_pos = 2; *b_pos = 3; *bytes = 4; // ARGB in memory. 373 } else if (fourcc == cricket::FOURCC_ARGB) { 374 *r_pos = 2; *g_pos = 1; *b_pos = 0; *bytes = 4; // BGRA in memory. 375 } else { 376 return false; 377 } 378 return true; 379 } 380 381 // Comparison functions for testing. 382 static bool IsNull(const cricket::VideoFrame& frame) { 383 return !frame.GetYPlane(); 384 } 385 386 static bool IsSize(const cricket::VideoFrame& frame, 387 uint32 width, uint32 height) { 388 return !IsNull(frame) && 389 frame.GetYPitch() >= static_cast<int32>(width) && 390 frame.GetUPitch() >= static_cast<int32>(width) / 2 && 391 frame.GetVPitch() >= static_cast<int32>(width) / 2 && 392 frame.GetWidth() == width && frame.GetHeight() == height; 393 } 394 395 static bool IsPlaneEqual(const std::string& name, 396 const uint8* plane1, uint32 pitch1, 397 const uint8* plane2, uint32 pitch2, 398 uint32 width, uint32 height, 399 int max_error) { 400 const uint8* r1 = plane1; 401 const uint8* r2 = plane2; 402 for (uint32 y = 0; y < height; ++y) { 403 for (uint32 x = 0; x < width; ++x) { 404 if (abs(static_cast<int>(r1[x] - r2[x])) > max_error) { 405 LOG(LS_INFO) << "IsPlaneEqual(" << name << "): pixel[" 406 << x << "," << y << "] differs: " 407 << static_cast<int>(r1[x]) << " vs " 408 << static_cast<int>(r2[x]); 409 return false; 410 } 411 } 412 r1 += pitch1; 413 r2 += pitch2; 414 } 415 return true; 416 } 417 418 static bool IsEqual(const cricket::VideoFrame& frame, 419 size_t width, size_t height, 420 size_t pixel_width, size_t pixel_height, 421 int64 elapsed_time, int64 time_stamp, 422 const uint8* y, uint32 ypitch, 423 const uint8* u, uint32 upitch, 424 const uint8* v, uint32 vpitch, 425 int max_error) { 426 return IsSize(frame, 427 static_cast<uint32>(width), 428 static_cast<uint32>(height)) && 429 frame.GetPixelWidth() == pixel_width && 430 frame.GetPixelHeight() == pixel_height && 431 frame.GetElapsedTime() == elapsed_time && 432 frame.GetTimeStamp() == time_stamp && 433 IsPlaneEqual("y", frame.GetYPlane(), frame.GetYPitch(), y, ypitch, 434 static_cast<uint32>(width), 435 static_cast<uint32>(height), max_error) && 436 IsPlaneEqual("u", frame.GetUPlane(), frame.GetUPitch(), u, upitch, 437 static_cast<uint32>((width + 1) / 2), 438 static_cast<uint32>((height + 1) / 2), max_error) && 439 IsPlaneEqual("v", frame.GetVPlane(), frame.GetVPitch(), v, vpitch, 440 static_cast<uint32>((width + 1) / 2), 441 static_cast<uint32>((height + 1) / 2), max_error); 442 } 443 444 static bool IsEqual(const cricket::VideoFrame& frame1, 445 const cricket::VideoFrame& frame2, 446 int max_error) { 447 return IsEqual(frame1, 448 frame2.GetWidth(), frame2.GetHeight(), 449 frame2.GetPixelWidth(), frame2.GetPixelHeight(), 450 frame2.GetElapsedTime(), frame2.GetTimeStamp(), 451 frame2.GetYPlane(), frame2.GetYPitch(), 452 frame2.GetUPlane(), frame2.GetUPitch(), 453 frame2.GetVPlane(), frame2.GetVPitch(), 454 max_error); 455 } 456 457 static bool IsEqualWithCrop(const cricket::VideoFrame& frame1, 458 const cricket::VideoFrame& frame2, 459 int hcrop, int vcrop, int max_error) { 460 return frame1.GetWidth() <= frame2.GetWidth() && 461 frame1.GetHeight() <= frame2.GetHeight() && 462 IsEqual(frame1, 463 frame2.GetWidth() - hcrop * 2, 464 frame2.GetHeight() - vcrop * 2, 465 frame2.GetPixelWidth(), frame2.GetPixelHeight(), 466 frame2.GetElapsedTime(), frame2.GetTimeStamp(), 467 frame2.GetYPlane() + vcrop * frame2.GetYPitch() 468 + hcrop, 469 frame2.GetYPitch(), 470 frame2.GetUPlane() + vcrop * frame2.GetUPitch() / 2 471 + hcrop / 2, 472 frame2.GetUPitch(), 473 frame2.GetVPlane() + vcrop * frame2.GetVPitch() / 2 474 + hcrop / 2, 475 frame2.GetVPitch(), 476 max_error); 477 } 478 479 static bool IsBlack(const cricket::VideoFrame& frame) { 480 return !IsNull(frame) && 481 *frame.GetYPlane() == 16 && 482 *frame.GetUPlane() == 128 && 483 *frame.GetVPlane() == 128; 484 } 485 486 //////////////////////// 487 // Construction tests // 488 //////////////////////// 489 490 // Test constructing an image from a I420 buffer. 491 void ConstructI420() { 492 T frame; 493 EXPECT_TRUE(IsNull(frame)); 494 rtc::scoped_ptr<rtc::MemoryStream> ms( 495 CreateYuvSample(kWidth, kHeight, 12)); 496 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420, 497 kWidth, kHeight, &frame)); 498 499 const uint8* y = reinterpret_cast<uint8*>(ms.get()->GetBuffer()); 500 const uint8* u = y + kWidth * kHeight; 501 const uint8* v = u + kWidth * kHeight / 4; 502 EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 1, 1, 0, 0, 503 y, kWidth, u, kWidth / 2, v, kWidth / 2, 0)); 504 } 505 506 // Test constructing an image from a YV12 buffer. 507 void ConstructYV12() { 508 T frame; 509 rtc::scoped_ptr<rtc::MemoryStream> ms( 510 CreateYuvSample(kWidth, kHeight, 12)); 511 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YV12, 512 kWidth, kHeight, &frame)); 513 514 const uint8* y = reinterpret_cast<uint8*>(ms.get()->GetBuffer()); 515 const uint8* v = y + kWidth * kHeight; 516 const uint8* u = v + kWidth * kHeight / 4; 517 EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 1, 1, 0, 0, 518 y, kWidth, u, kWidth / 2, v, kWidth / 2, 0)); 519 } 520 521 // Test constructing an image from a I422 buffer. 522 void ConstructI422() { 523 T frame1, frame2; 524 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 525 size_t buf_size = kWidth * kHeight * 2; 526 rtc::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment]); 527 uint8* y = ALIGNP(buf.get(), kAlignment); 528 uint8* u = y + kWidth * kHeight; 529 uint8* v = u + (kWidth / 2) * kHeight; 530 EXPECT_EQ(0, libyuv::I420ToI422(frame1.GetYPlane(), frame1.GetYPitch(), 531 frame1.GetUPlane(), frame1.GetUPitch(), 532 frame1.GetVPlane(), frame1.GetVPitch(), 533 y, kWidth, 534 u, kWidth / 2, 535 v, kWidth / 2, 536 kWidth, kHeight)); 537 EXPECT_TRUE(LoadFrame(y, buf_size, cricket::FOURCC_I422, 538 kWidth, kHeight, &frame2)); 539 EXPECT_TRUE(IsEqual(frame1, frame2, 1)); 540 } 541 542 // Test constructing an image from a YUY2 buffer. 543 void ConstructYuy2() { 544 T frame1, frame2; 545 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 546 size_t buf_size = kWidth * kHeight * 2; 547 rtc::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment]); 548 uint8* yuy2 = ALIGNP(buf.get(), kAlignment); 549 EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.GetYPlane(), frame1.GetYPitch(), 550 frame1.GetUPlane(), frame1.GetUPitch(), 551 frame1.GetVPlane(), frame1.GetVPitch(), 552 yuy2, kWidth * 2, 553 kWidth, kHeight)); 554 EXPECT_TRUE(LoadFrame(yuy2, buf_size, cricket::FOURCC_YUY2, 555 kWidth, kHeight, &frame2)); 556 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 557 } 558 559 // Test constructing an image from a YUY2 buffer with buffer unaligned. 560 void ConstructYuy2Unaligned() { 561 T frame1, frame2; 562 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 563 size_t buf_size = kWidth * kHeight * 2; 564 rtc::scoped_ptr<uint8[]> buf(new uint8[buf_size + kAlignment + 1]); 565 uint8* yuy2 = ALIGNP(buf.get(), kAlignment) + 1; 566 EXPECT_EQ(0, libyuv::I420ToYUY2(frame1.GetYPlane(), frame1.GetYPitch(), 567 frame1.GetUPlane(), frame1.GetUPitch(), 568 frame1.GetVPlane(), frame1.GetVPitch(), 569 yuy2, kWidth * 2, 570 kWidth, kHeight)); 571 EXPECT_TRUE(LoadFrame(yuy2, buf_size, cricket::FOURCC_YUY2, 572 kWidth, kHeight, &frame2)); 573 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 574 } 575 576 // Test constructing an image from a wide YUY2 buffer. 577 // Normal is 1280x720. Wide is 12800x72 578 void ConstructYuy2Wide() { 579 T frame1, frame2; 580 rtc::scoped_ptr<rtc::MemoryStream> ms( 581 CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth * 10, kHeight / 10)); 582 ASSERT_TRUE(ms.get() != NULL); 583 EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2, 584 kWidth * 10, kHeight / 10, 585 &frame1)); 586 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, 587 kWidth * 10, kHeight / 10, &frame2)); 588 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 589 } 590 591 // Test constructing an image from a UYVY buffer. 592 void ConstructUyvy() { 593 T frame1, frame2; 594 rtc::scoped_ptr<rtc::MemoryStream> ms( 595 CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight)); 596 ASSERT_TRUE(ms.get() != NULL); 597 EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_UYVY, kWidth, kHeight, 598 &frame1)); 599 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY, 600 kWidth, kHeight, &frame2)); 601 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 602 } 603 604 // Test constructing an image from a random buffer. 605 // We are merely verifying that the code succeeds and is free of crashes. 606 void ConstructM420() { 607 T frame; 608 rtc::scoped_ptr<rtc::MemoryStream> ms( 609 CreateYuvSample(kWidth, kHeight, 12)); 610 ASSERT_TRUE(ms.get() != NULL); 611 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_M420, 612 kWidth, kHeight, &frame)); 613 } 614 615 void ConstructQ420() { 616 T frame; 617 rtc::scoped_ptr<rtc::MemoryStream> ms( 618 CreateYuvSample(kWidth, kHeight, 12)); 619 ASSERT_TRUE(ms.get() != NULL); 620 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_Q420, 621 kWidth, kHeight, &frame)); 622 } 623 624 void ConstructNV21() { 625 T frame; 626 rtc::scoped_ptr<rtc::MemoryStream> ms( 627 CreateYuvSample(kWidth, kHeight, 12)); 628 ASSERT_TRUE(ms.get() != NULL); 629 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_NV21, 630 kWidth, kHeight, &frame)); 631 } 632 633 void ConstructNV12() { 634 T frame; 635 rtc::scoped_ptr<rtc::MemoryStream> ms( 636 CreateYuvSample(kWidth, kHeight, 12)); 637 ASSERT_TRUE(ms.get() != NULL); 638 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_NV12, 639 kWidth, kHeight, &frame)); 640 } 641 642 // Test constructing an image from a ABGR buffer 643 // Due to rounding, some pixels may differ slightly from the VideoFrame impl. 644 void ConstructABGR() { 645 T frame1, frame2; 646 rtc::scoped_ptr<rtc::MemoryStream> ms( 647 CreateRgbSample(cricket::FOURCC_ABGR, kWidth, kHeight)); 648 ASSERT_TRUE(ms.get() != NULL); 649 EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ABGR, kWidth, kHeight, 650 &frame1)); 651 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ABGR, 652 kWidth, kHeight, &frame2)); 653 EXPECT_TRUE(IsEqual(frame1, frame2, 2)); 654 } 655 656 // Test constructing an image from a ARGB buffer 657 // Due to rounding, some pixels may differ slightly from the VideoFrame impl. 658 void ConstructARGB() { 659 T frame1, frame2; 660 rtc::scoped_ptr<rtc::MemoryStream> ms( 661 CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); 662 ASSERT_TRUE(ms.get() != NULL); 663 EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight, 664 &frame1)); 665 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB, 666 kWidth, kHeight, &frame2)); 667 EXPECT_TRUE(IsEqual(frame1, frame2, 2)); 668 } 669 670 // Test constructing an image from a wide ARGB buffer 671 // Normal is 1280x720. Wide is 12800x72 672 void ConstructARGBWide() { 673 T frame1, frame2; 674 rtc::scoped_ptr<rtc::MemoryStream> ms( 675 CreateRgbSample(cricket::FOURCC_ARGB, kWidth * 10, kHeight / 10)); 676 ASSERT_TRUE(ms.get() != NULL); 677 EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, 678 kWidth * 10, kHeight / 10, &frame1)); 679 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB, 680 kWidth * 10, kHeight / 10, &frame2)); 681 EXPECT_TRUE(IsEqual(frame1, frame2, 2)); 682 } 683 684 // Test constructing an image from an BGRA buffer. 685 // Due to rounding, some pixels may differ slightly from the VideoFrame impl. 686 void ConstructBGRA() { 687 T frame1, frame2; 688 rtc::scoped_ptr<rtc::MemoryStream> ms( 689 CreateRgbSample(cricket::FOURCC_BGRA, kWidth, kHeight)); 690 ASSERT_TRUE(ms.get() != NULL); 691 EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_BGRA, kWidth, kHeight, 692 &frame1)); 693 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_BGRA, 694 kWidth, kHeight, &frame2)); 695 EXPECT_TRUE(IsEqual(frame1, frame2, 2)); 696 } 697 698 // Test constructing an image from a 24BG buffer. 699 // Due to rounding, some pixels may differ slightly from the VideoFrame impl. 700 void Construct24BG() { 701 T frame1, frame2; 702 rtc::scoped_ptr<rtc::MemoryStream> ms( 703 CreateRgbSample(cricket::FOURCC_24BG, kWidth, kHeight)); 704 ASSERT_TRUE(ms.get() != NULL); 705 EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_24BG, kWidth, kHeight, 706 &frame1)); 707 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_24BG, 708 kWidth, kHeight, &frame2)); 709 EXPECT_TRUE(IsEqual(frame1, frame2, 2)); 710 } 711 712 // Test constructing an image from a raw RGB buffer. 713 // Due to rounding, some pixels may differ slightly from the VideoFrame impl. 714 void ConstructRaw() { 715 T frame1, frame2; 716 rtc::scoped_ptr<rtc::MemoryStream> ms( 717 CreateRgbSample(cricket::FOURCC_RAW, kWidth, kHeight)); 718 ASSERT_TRUE(ms.get() != NULL); 719 EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_RAW, kWidth, kHeight, 720 &frame1)); 721 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_RAW, 722 kWidth, kHeight, &frame2)); 723 EXPECT_TRUE(IsEqual(frame1, frame2, 2)); 724 } 725 726 // Test constructing an image from a RGB565 buffer 727 void ConstructRGB565() { 728 T frame1, frame2; 729 size_t out_size = kWidth * kHeight * 2; 730 rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]); 731 uint8* out = ALIGNP(outbuf.get(), kAlignment); 732 T frame; 733 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 734 EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(cricket::FOURCC_RGBP, 735 out, 736 out_size, kWidth * 2)); 737 EXPECT_TRUE(LoadFrame(out, out_size, cricket::FOURCC_RGBP, 738 kWidth, kHeight, &frame2)); 739 EXPECT_TRUE(IsEqual(frame1, frame2, 20)); 740 } 741 742 // Test constructing an image from a ARGB1555 buffer 743 void ConstructARGB1555() { 744 T frame1, frame2; 745 size_t out_size = kWidth * kHeight * 2; 746 rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]); 747 uint8* out = ALIGNP(outbuf.get(), kAlignment); 748 T frame; 749 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 750 EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(cricket::FOURCC_RGBO, 751 out, 752 out_size, kWidth * 2)); 753 EXPECT_TRUE(LoadFrame(out, out_size, cricket::FOURCC_RGBO, 754 kWidth, kHeight, &frame2)); 755 EXPECT_TRUE(IsEqual(frame1, frame2, 20)); 756 } 757 758 // Test constructing an image from a ARGB4444 buffer 759 void ConstructARGB4444() { 760 T frame1, frame2; 761 size_t out_size = kWidth * kHeight * 2; 762 rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]); 763 uint8* out = ALIGNP(outbuf.get(), kAlignment); 764 T frame; 765 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 766 EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(cricket::FOURCC_R444, 767 out, 768 out_size, kWidth * 2)); 769 EXPECT_TRUE(LoadFrame(out, out_size, cricket::FOURCC_R444, 770 kWidth, kHeight, &frame2)); 771 EXPECT_TRUE(IsEqual(frame1, frame2, 20)); 772 } 773 774 // Macro to help test different Bayer formats. 775 // Error threshold of 60 allows for Bayer format subsampling. 776 // TODO(fbarchard): Refactor this test to go from Bayer to I420 and 777 // back to bayer, which would be less lossy. 778 #define TEST_BYR(NAME, BAYER) \ 779 void NAME() { \ 780 size_t bayer_size = kWidth * kHeight; \ 781 rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[ \ 782 bayer_size + kAlignment]); \ 783 uint8* bayer = ALIGNP(bayerbuf.get(), kAlignment); \ 784 T frame1, frame2; \ 785 rtc::scoped_ptr<rtc::MemoryStream> ms( \ 786 CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \ 787 ASSERT_TRUE(ms.get() != NULL); \ 788 libyuv::ARGBToBayer##BAYER(reinterpret_cast<uint8* >(ms->GetBuffer()), \ 789 kWidth * 4, \ 790 bayer, kWidth, \ 791 kWidth, kHeight); \ 792 EXPECT_TRUE(LoadFrame(bayer, bayer_size, cricket::FOURCC_##BAYER, \ 793 kWidth, kHeight, &frame1)); \ 794 EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight, \ 795 &frame2)); \ 796 EXPECT_TRUE(IsEqual(frame1, frame2, 60)); \ 797 } 798 799 // Test constructing an image from Bayer formats. 800 TEST_BYR(ConstructBayerGRBG, GRBG) 801 TEST_BYR(ConstructBayerGBRG, GBRG) 802 TEST_BYR(ConstructBayerBGGR, BGGR) 803 TEST_BYR(ConstructBayerRGGB, RGGB) 804 805 806 // Macro to help test different rotations 807 #define TEST_MIRROR(FOURCC, BPP) \ 808 void Construct##FOURCC##Mirror() { \ 809 T frame1, frame2, frame3; \ 810 rtc::scoped_ptr<rtc::MemoryStream> ms( \ 811 CreateYuvSample(kWidth, kHeight, BPP)); \ 812 ASSERT_TRUE(ms.get() != NULL); \ 813 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC, \ 814 kWidth, -kHeight, kWidth, kHeight, \ 815 cricket::ROTATION_180, &frame1)); \ 816 size_t data_size; \ 817 bool ret = ms->GetSize(&data_size); \ 818 EXPECT_TRUE(ret); \ 819 EXPECT_TRUE(frame2.Init(cricket::FOURCC_##FOURCC, \ 820 kWidth, kHeight, kWidth, kHeight, \ 821 reinterpret_cast<uint8*>(ms->GetBuffer()), \ 822 data_size, \ 823 1, 1, 0, 0, 0)); \ 824 int width_rotate = static_cast<int>(frame1.GetWidth()); \ 825 int height_rotate = static_cast<int>(frame1.GetHeight()); \ 826 EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 1, 1, 0, 0)); \ 827 libyuv::I420Mirror(frame2.GetYPlane(), frame2.GetYPitch(), \ 828 frame2.GetUPlane(), frame2.GetUPitch(), \ 829 frame2.GetVPlane(), frame2.GetVPitch(), \ 830 frame3.GetYPlane(), frame3.GetYPitch(), \ 831 frame3.GetUPlane(), frame3.GetUPitch(), \ 832 frame3.GetVPlane(), frame3.GetVPitch(), \ 833 kWidth, kHeight); \ 834 EXPECT_TRUE(IsEqual(frame1, frame3, 0)); \ 835 } 836 837 TEST_MIRROR(I420, 420) 838 839 // Macro to help test different rotations 840 #define TEST_ROTATE(FOURCC, BPP, ROTATE) \ 841 void Construct##FOURCC##Rotate##ROTATE() { \ 842 T frame1, frame2, frame3; \ 843 rtc::scoped_ptr<rtc::MemoryStream> ms( \ 844 CreateYuvSample(kWidth, kHeight, BPP)); \ 845 ASSERT_TRUE(ms.get() != NULL); \ 846 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_##FOURCC, \ 847 kWidth, kHeight, kWidth, kHeight, \ 848 cricket::ROTATION_##ROTATE, &frame1)); \ 849 size_t data_size; \ 850 bool ret = ms->GetSize(&data_size); \ 851 EXPECT_TRUE(ret); \ 852 EXPECT_TRUE(frame2.Init(cricket::FOURCC_##FOURCC, \ 853 kWidth, kHeight, kWidth, kHeight, \ 854 reinterpret_cast<uint8*>(ms->GetBuffer()), \ 855 data_size, \ 856 1, 1, 0, 0, 0)); \ 857 int width_rotate = static_cast<int>(frame1.GetWidth()); \ 858 int height_rotate = static_cast<int>(frame1.GetHeight()); \ 859 EXPECT_TRUE(frame3.InitToBlack(width_rotate, height_rotate, 1, 1, 0, 0)); \ 860 libyuv::I420Rotate(frame2.GetYPlane(), frame2.GetYPitch(), \ 861 frame2.GetUPlane(), frame2.GetUPitch(), \ 862 frame2.GetVPlane(), frame2.GetVPitch(), \ 863 frame3.GetYPlane(), frame3.GetYPitch(), \ 864 frame3.GetUPlane(), frame3.GetUPitch(), \ 865 frame3.GetVPlane(), frame3.GetVPitch(), \ 866 kWidth, kHeight, libyuv::kRotate##ROTATE); \ 867 EXPECT_TRUE(IsEqual(frame1, frame3, 0)); \ 868 } 869 870 // Test constructing an image with rotation. 871 TEST_ROTATE(I420, 12, 0) 872 TEST_ROTATE(I420, 12, 90) 873 TEST_ROTATE(I420, 12, 180) 874 TEST_ROTATE(I420, 12, 270) 875 TEST_ROTATE(YV12, 12, 0) 876 TEST_ROTATE(YV12, 12, 90) 877 TEST_ROTATE(YV12, 12, 180) 878 TEST_ROTATE(YV12, 12, 270) 879 TEST_ROTATE(NV12, 12, 0) 880 TEST_ROTATE(NV12, 12, 90) 881 TEST_ROTATE(NV12, 12, 180) 882 TEST_ROTATE(NV12, 12, 270) 883 TEST_ROTATE(NV21, 12, 0) 884 TEST_ROTATE(NV21, 12, 90) 885 TEST_ROTATE(NV21, 12, 180) 886 TEST_ROTATE(NV21, 12, 270) 887 TEST_ROTATE(UYVY, 16, 0) 888 TEST_ROTATE(UYVY, 16, 90) 889 TEST_ROTATE(UYVY, 16, 180) 890 TEST_ROTATE(UYVY, 16, 270) 891 TEST_ROTATE(YUY2, 16, 0) 892 TEST_ROTATE(YUY2, 16, 90) 893 TEST_ROTATE(YUY2, 16, 180) 894 TEST_ROTATE(YUY2, 16, 270) 895 896 // Test constructing an image from a UYVY buffer rotated 90 degrees. 897 void ConstructUyvyRotate90() { 898 T frame2; 899 rtc::scoped_ptr<rtc::MemoryStream> ms( 900 CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight)); 901 ASSERT_TRUE(ms.get() != NULL); 902 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY, 903 kWidth, kHeight, kWidth, kHeight, 904 cricket::ROTATION_90, &frame2)); 905 } 906 907 // Test constructing an image from a UYVY buffer rotated 180 degrees. 908 void ConstructUyvyRotate180() { 909 T frame2; 910 rtc::scoped_ptr<rtc::MemoryStream> ms( 911 CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight)); 912 ASSERT_TRUE(ms.get() != NULL); 913 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY, 914 kWidth, kHeight, kWidth, kHeight, 915 cricket::ROTATION_180, &frame2)); 916 } 917 918 // Test constructing an image from a UYVY buffer rotated 270 degrees. 919 void ConstructUyvyRotate270() { 920 T frame2; 921 rtc::scoped_ptr<rtc::MemoryStream> ms( 922 CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight)); 923 ASSERT_TRUE(ms.get() != NULL); 924 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY, 925 kWidth, kHeight, kWidth, kHeight, 926 cricket::ROTATION_270, &frame2)); 927 } 928 929 // Test constructing an image from a YUY2 buffer rotated 90 degrees. 930 void ConstructYuy2Rotate90() { 931 T frame2; 932 rtc::scoped_ptr<rtc::MemoryStream> ms( 933 CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight)); 934 ASSERT_TRUE(ms.get() != NULL); 935 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, 936 kWidth, kHeight, kWidth, kHeight, 937 cricket::ROTATION_90, &frame2)); 938 } 939 940 // Test constructing an image from a YUY2 buffer rotated 180 degrees. 941 void ConstructYuy2Rotate180() { 942 T frame2; 943 rtc::scoped_ptr<rtc::MemoryStream> ms( 944 CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight)); 945 ASSERT_TRUE(ms.get() != NULL); 946 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, 947 kWidth, kHeight, kWidth, kHeight, 948 cricket::ROTATION_180, &frame2)); 949 } 950 951 // Test constructing an image from a YUY2 buffer rotated 270 degrees. 952 void ConstructYuy2Rotate270() { 953 T frame2; 954 rtc::scoped_ptr<rtc::MemoryStream> ms( 955 CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight)); 956 ASSERT_TRUE(ms.get() != NULL); 957 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, 958 kWidth, kHeight, kWidth, kHeight, 959 cricket::ROTATION_270, &frame2)); 960 } 961 962 // Test 1 pixel edge case image I420 buffer. 963 void ConstructI4201Pixel() { 964 T frame; 965 uint8 pixel[3] = { 1, 2, 3 }; 966 for (int i = 0; i < repeat_; ++i) { 967 EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 1, 1, 1, 1, 968 pixel, sizeof(pixel), 969 1, 1, 0, 0, 0)); 970 } 971 const uint8* y = pixel; 972 const uint8* u = y + 1; 973 const uint8* v = u + 1; 974 EXPECT_TRUE(IsEqual(frame, 1, 1, 1, 1, 0, 0, 975 y, 1, u, 1, v, 1, 0)); 976 } 977 978 // Test 5 pixel edge case image I420 buffer rounds down to 4. 979 void ConstructI4205Pixel() { 980 T frame; 981 uint8 pixels5x5[5 * 5 + ((5 + 1) / 2 * (5 + 1) / 2) * 2]; 982 memset(pixels5x5, 1, 5 * 5 + ((5 + 1) / 2 * (5 + 1) / 2) * 2); 983 for (int i = 0; i < repeat_; ++i) { 984 EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 5, 5, 5, 5, 985 pixels5x5, sizeof(pixels5x5), 986 1, 1, 0, 0, 0)); 987 } 988 EXPECT_EQ(4u, frame.GetWidth()); 989 EXPECT_EQ(4u, frame.GetHeight()); 990 EXPECT_EQ(4, frame.GetYPitch()); 991 EXPECT_EQ(2, frame.GetUPitch()); 992 EXPECT_EQ(2, frame.GetVPitch()); 993 } 994 995 // Test 1 pixel edge case image ARGB buffer. 996 void ConstructARGB1Pixel() { 997 T frame; 998 uint8 pixel[4] = { 64, 128, 192, 255 }; 999 for (int i = 0; i < repeat_; ++i) { 1000 EXPECT_TRUE(frame.Init(cricket::FOURCC_ARGB, 1, 1, 1, 1, 1001 pixel, sizeof(pixel), 1002 1, 1, 0, 0, 0)); 1003 } 1004 // Convert back to ARGB. 1005 size_t out_size = 4; 1006 rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]); 1007 uint8* out = ALIGNP(outbuf.get(), kAlignment); 1008 1009 EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB, 1010 out, 1011 out_size, // buffer size 1012 out_size)); // stride 1013 #ifdef USE_LMI_CONVERT 1014 // TODO(fbarchard): Expected to fail, but not crash. 1015 EXPECT_FALSE(IsPlaneEqual("argb", pixel, 4, out, 4, 3, 1, 2)); 1016 #else 1017 // TODO(fbarchard): Check for overwrite. 1018 EXPECT_TRUE(IsPlaneEqual("argb", pixel, 4, out, 4, 3, 1, 2)); 1019 #endif 1020 } 1021 1022 // Test Black, White and Grey pixels. 1023 void ConstructARGBBlackWhitePixel() { 1024 T frame; 1025 uint8 pixel[10 * 4] = { 0, 0, 0, 255, // Black. 1026 0, 0, 0, 255, 1027 64, 64, 64, 255, // Dark Grey. 1028 64, 64, 64, 255, 1029 128, 128, 128, 255, // Grey. 1030 128, 128, 128, 255, 1031 196, 196, 196, 255, // Light Grey. 1032 196, 196, 196, 255, 1033 255, 255, 255, 255, // White. 1034 255, 255, 255, 255 }; 1035 1036 for (int i = 0; i < repeat_; ++i) { 1037 EXPECT_TRUE(frame.Init(cricket::FOURCC_ARGB, 10, 1, 10, 1, 1038 pixel, sizeof(pixel), 1039 1, 1, 0, 0, 0)); 1040 } 1041 // Convert back to ARGB 1042 size_t out_size = 10 * 4; 1043 rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment]); 1044 uint8* out = ALIGNP(outbuf.get(), kAlignment); 1045 1046 EXPECT_EQ(out_size, frame.ConvertToRgbBuffer(cricket::FOURCC_ARGB, 1047 out, 1048 out_size, // buffer size. 1049 out_size)); // stride. 1050 EXPECT_TRUE(IsPlaneEqual("argb", pixel, out_size, 1051 out, out_size, 1052 out_size, 1, 2)); 1053 } 1054 1055 // Test constructing an image from an I420 buffer with horizontal cropping. 1056 void ConstructI420CropHorizontal() { 1057 T frame1, frame2; 1058 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1059 ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_I420, kWidth, kHeight, 1060 kWidth * 3 / 4, kHeight, 0, &frame2)); 1061 EXPECT_TRUE(IsEqualWithCrop(frame2, frame1, kWidth / 8, 0, 0)); 1062 } 1063 1064 // Test constructing an image from a YUY2 buffer with horizontal cropping. 1065 void ConstructYuy2CropHorizontal() { 1066 T frame1, frame2; 1067 rtc::scoped_ptr<rtc::MemoryStream> ms( 1068 CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight)); 1069 ASSERT_TRUE(ms.get() != NULL); 1070 EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight, 1071 &frame1)); 1072 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight, 1073 kWidth * 3 / 4, kHeight, 0, &frame2)); 1074 EXPECT_TRUE(IsEqualWithCrop(frame2, frame1, kWidth / 8, 0, 0)); 1075 } 1076 1077 // Test constructing an image from an ARGB buffer with horizontal cropping. 1078 void ConstructARGBCropHorizontal() { 1079 T frame1, frame2; 1080 rtc::scoped_ptr<rtc::MemoryStream> ms( 1081 CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); 1082 ASSERT_TRUE(ms.get() != NULL); 1083 EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight, 1084 &frame1)); 1085 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB, kWidth, kHeight, 1086 kWidth * 3 / 4, kHeight, 0, &frame2)); 1087 EXPECT_TRUE(IsEqualWithCrop(frame2, frame1, kWidth / 8, 0, 2)); 1088 } 1089 1090 // Test constructing an image from an I420 buffer, cropping top and bottom. 1091 void ConstructI420CropVertical() { 1092 T frame1, frame2; 1093 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1094 ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_I420, kWidth, kHeight, 1095 kWidth, kHeight * 3 / 4, 0, &frame2)); 1096 EXPECT_TRUE(IsEqualWithCrop(frame2, frame1, 0, kHeight / 8, 0)); 1097 } 1098 1099 // Test constructing an image from I420 synonymous formats. 1100 void ConstructI420Aliases() { 1101 T frame1, frame2, frame3; 1102 ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_I420, kWidth, kHeight, 1103 &frame1)); 1104 ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_IYUV, kWidth, kHeight, 1105 &frame2)); 1106 ASSERT_TRUE(LoadFrame(kImageFilename, cricket::FOURCC_YU12, kWidth, kHeight, 1107 &frame3)); 1108 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 1109 EXPECT_TRUE(IsEqual(frame1, frame3, 0)); 1110 } 1111 1112 // Test constructing an image from an I420 MJPG buffer. 1113 void ConstructMjpgI420() { 1114 T frame1, frame2; 1115 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1116 ASSERT_TRUE(LoadFrame(kJpeg420Filename, 1117 cricket::FOURCC_MJPG, kWidth, kHeight, &frame2)); 1118 EXPECT_TRUE(IsEqual(frame1, frame2, 32)); 1119 } 1120 1121 // Test constructing an image from an I422 MJPG buffer. 1122 void ConstructMjpgI422() { 1123 T frame1, frame2; 1124 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1125 ASSERT_TRUE(LoadFrame(kJpeg422Filename, 1126 cricket::FOURCC_MJPG, kWidth, kHeight, &frame2)); 1127 EXPECT_TRUE(IsEqual(frame1, frame2, 32)); 1128 } 1129 1130 // Test constructing an image from an I444 MJPG buffer. 1131 void ConstructMjpgI444() { 1132 T frame1, frame2; 1133 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1134 ASSERT_TRUE(LoadFrame(kJpeg444Filename, 1135 cricket::FOURCC_MJPG, kWidth, kHeight, &frame2)); 1136 EXPECT_TRUE(IsEqual(frame1, frame2, 32)); 1137 } 1138 1139 // Test constructing an image from an I444 MJPG buffer. 1140 void ConstructMjpgI411() { 1141 T frame1, frame2; 1142 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1143 ASSERT_TRUE(LoadFrame(kJpeg411Filename, 1144 cricket::FOURCC_MJPG, kWidth, kHeight, &frame2)); 1145 EXPECT_TRUE(IsEqual(frame1, frame2, 32)); 1146 } 1147 1148 // Test constructing an image from an I400 MJPG buffer. 1149 // TODO(fbarchard): Stronger compare on chroma. Compare agaisnt a grey image. 1150 void ConstructMjpgI400() { 1151 T frame1, frame2; 1152 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1153 ASSERT_TRUE(LoadFrame(kJpeg400Filename, 1154 cricket::FOURCC_MJPG, kWidth, kHeight, &frame2)); 1155 EXPECT_TRUE(IsPlaneEqual("y", frame1.GetYPlane(), frame1.GetYPitch(), 1156 frame2.GetYPlane(), frame2.GetYPitch(), 1157 kWidth, kHeight, 32)); 1158 EXPECT_TRUE(IsEqual(frame1, frame2, 128)); 1159 } 1160 1161 // Test constructing an image from an I420 MJPG buffer. 1162 void ValidateFrame(const char* name, uint32 fourcc, int data_adjust, 1163 int size_adjust, bool expected_result) { 1164 T frame; 1165 rtc::scoped_ptr<rtc::MemoryStream> ms(LoadSample(name)); 1166 ASSERT_TRUE(ms.get() != NULL); 1167 const uint8* sample = reinterpret_cast<const uint8*>(ms.get()->GetBuffer()); 1168 size_t sample_size; 1169 ms->GetSize(&sample_size); 1170 // Optional adjust size to test invalid size. 1171 size_t data_size = sample_size + data_adjust; 1172 1173 // Allocate a buffer with end page aligned. 1174 const int kPadToHeapSized = 16 * 1024 * 1024; 1175 rtc::scoped_ptr<uint8[]> page_buffer( 1176 new uint8[((data_size + kPadToHeapSized + 4095) & ~4095)]); 1177 uint8* data_ptr = page_buffer.get(); 1178 if (!data_ptr) { 1179 LOG(LS_WARNING) << "Failed to allocate memory for ValidateFrame test."; 1180 EXPECT_FALSE(expected_result); // NULL is okay if failure was expected. 1181 return; 1182 } 1183 data_ptr += kPadToHeapSized + (-(static_cast<int>(data_size)) & 4095); 1184 memcpy(data_ptr, sample, rtc::_min(data_size, sample_size)); 1185 for (int i = 0; i < repeat_; ++i) { 1186 EXPECT_EQ(expected_result, frame.Validate(fourcc, kWidth, kHeight, 1187 data_ptr, 1188 sample_size + size_adjust)); 1189 } 1190 } 1191 1192 // Test validate for I420 MJPG buffer. 1193 void ValidateMjpgI420() { 1194 ValidateFrame(kJpeg420Filename, cricket::FOURCC_MJPG, 0, 0, true); 1195 } 1196 1197 // Test validate for I422 MJPG buffer. 1198 void ValidateMjpgI422() { 1199 ValidateFrame(kJpeg422Filename, cricket::FOURCC_MJPG, 0, 0, true); 1200 } 1201 1202 // Test validate for I444 MJPG buffer. 1203 void ValidateMjpgI444() { 1204 ValidateFrame(kJpeg444Filename, cricket::FOURCC_MJPG, 0, 0, true); 1205 } 1206 1207 // Test validate for I411 MJPG buffer. 1208 void ValidateMjpgI411() { 1209 ValidateFrame(kJpeg411Filename, cricket::FOURCC_MJPG, 0, 0, true); 1210 } 1211 1212 // Test validate for I400 MJPG buffer. 1213 void ValidateMjpgI400() { 1214 ValidateFrame(kJpeg400Filename, cricket::FOURCC_MJPG, 0, 0, true); 1215 } 1216 1217 // Test validate for I420 buffer. 1218 void ValidateI420() { 1219 ValidateFrame(kImageFilename, cricket::FOURCC_I420, 0, 0, true); 1220 } 1221 1222 // Test validate for I420 buffer where size is too small 1223 void ValidateI420SmallSize() { 1224 ValidateFrame(kImageFilename, cricket::FOURCC_I420, 0, -16384, false); 1225 } 1226 1227 // Test validate for I420 buffer where size is too large (16 MB) 1228 // Will produce warning but pass. 1229 void ValidateI420LargeSize() { 1230 ValidateFrame(kImageFilename, cricket::FOURCC_I420, 16000000, 16000000, 1231 true); 1232 } 1233 1234 // Test validate for I420 buffer where size is 1 GB (not reasonable). 1235 void ValidateI420HugeSize() { 1236 #ifndef WIN32 // TODO(fbarchard): Reenable when fixing bug 9603762. 1237 ValidateFrame(kImageFilename, cricket::FOURCC_I420, 1000000000u, 1238 1000000000u, false); 1239 #endif 1240 } 1241 1242 // The following test that Validate crashes if the size is greater than the 1243 // actual buffer size. 1244 // TODO(fbarchard): Consider moving a filter into the capturer/plugin. 1245 #if defined(_MSC_VER) && defined(_DEBUG) 1246 int ExceptionFilter(unsigned int code, struct _EXCEPTION_POINTERS *ep) { 1247 if (code == EXCEPTION_ACCESS_VIOLATION) { 1248 LOG(LS_INFO) << "Caught EXCEPTION_ACCESS_VIOLATION as expected."; 1249 return EXCEPTION_EXECUTE_HANDLER; 1250 } else { 1251 LOG(LS_INFO) << "Did not catch EXCEPTION_ACCESS_VIOLATION. Unexpected."; 1252 return EXCEPTION_CONTINUE_SEARCH; 1253 } 1254 } 1255 1256 // Test validate fails for truncated MJPG data buffer. If ValidateFrame 1257 // crashes the exception handler will return and unittest passes with OK. 1258 void ValidateMjpgI420InvalidSize() { 1259 __try { 1260 ValidateFrame(kJpeg420Filename, cricket::FOURCC_MJPG, -16384, 0, false); 1261 FAIL() << "Validate was expected to cause EXCEPTION_ACCESS_VIOLATION."; 1262 } __except(ExceptionFilter(GetExceptionCode(), GetExceptionInformation())) { 1263 return; // Successfully crashed in ValidateFrame. 1264 } 1265 } 1266 1267 // Test validate fails for truncated I420 buffer. 1268 void ValidateI420InvalidSize() { 1269 __try { 1270 ValidateFrame(kImageFilename, cricket::FOURCC_I420, -16384, 0, false); 1271 FAIL() << "Validate was expected to cause EXCEPTION_ACCESS_VIOLATION."; 1272 } __except(ExceptionFilter(GetExceptionCode(), GetExceptionInformation())) { 1273 return; // Successfully crashed in ValidateFrame. 1274 } 1275 } 1276 #endif 1277 1278 // Test constructing an image from a YUY2 buffer (and synonymous formats). 1279 void ConstructYuy2Aliases() { 1280 T frame1, frame2, frame3, frame4; 1281 rtc::scoped_ptr<rtc::MemoryStream> ms( 1282 CreateYuv422Sample(cricket::FOURCC_YUY2, kWidth, kHeight)); 1283 ASSERT_TRUE(ms.get() != NULL); 1284 EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2, kWidth, kHeight, 1285 &frame1)); 1286 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, 1287 kWidth, kHeight, &frame2)); 1288 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUVS, 1289 kWidth, kHeight, &frame3)); 1290 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUYV, 1291 kWidth, kHeight, &frame4)); 1292 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 1293 EXPECT_TRUE(IsEqual(frame1, frame3, 0)); 1294 EXPECT_TRUE(IsEqual(frame1, frame4, 0)); 1295 } 1296 1297 // Test constructing an image from a UYVY buffer (and synonymous formats). 1298 void ConstructUyvyAliases() { 1299 T frame1, frame2, frame3, frame4; 1300 rtc::scoped_ptr<rtc::MemoryStream> ms( 1301 CreateYuv422Sample(cricket::FOURCC_UYVY, kWidth, kHeight)); 1302 ASSERT_TRUE(ms.get() != NULL); 1303 EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_UYVY, kWidth, kHeight, 1304 &frame1)); 1305 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_UYVY, 1306 kWidth, kHeight, &frame2)); 1307 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_2VUY, 1308 kWidth, kHeight, &frame3)); 1309 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_HDYC, 1310 kWidth, kHeight, &frame4)); 1311 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 1312 EXPECT_TRUE(IsEqual(frame1, frame3, 0)); 1313 EXPECT_TRUE(IsEqual(frame1, frame4, 0)); 1314 } 1315 1316 // Test creating a copy. 1317 void ConstructCopy() { 1318 T frame1, frame2; 1319 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1320 for (int i = 0; i < repeat_; ++i) { 1321 EXPECT_TRUE(frame2.Init(frame1)); 1322 } 1323 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 1324 } 1325 1326 // Test creating a copy and check that it just increments the refcount. 1327 void ConstructCopyIsRef() { 1328 T frame1, frame2; 1329 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1330 for (int i = 0; i < repeat_; ++i) { 1331 EXPECT_TRUE(frame2.Init(frame1)); 1332 } 1333 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 1334 EXPECT_EQ(frame1.GetYPlane(), frame2.GetYPlane()); 1335 EXPECT_EQ(frame1.GetUPlane(), frame2.GetUPlane()); 1336 EXPECT_EQ(frame1.GetVPlane(), frame2.GetVPlane()); 1337 } 1338 1339 // Test creating an empty image and initing it to black. 1340 void ConstructBlack() { 1341 T frame; 1342 for (int i = 0; i < repeat_; ++i) { 1343 EXPECT_TRUE(frame.InitToBlack(kWidth, kHeight, 1, 1, 0, 0)); 1344 } 1345 EXPECT_TRUE(IsSize(frame, kWidth, kHeight)); 1346 EXPECT_TRUE(IsBlack(frame)); 1347 } 1348 1349 // Test constructing an image from a YUY2 buffer with a range of sizes. 1350 // Only tests that conversion does not crash or corrupt heap. 1351 void ConstructYuy2AllSizes() { 1352 T frame1, frame2; 1353 for (int height = kMinHeightAll; height <= kMaxHeightAll; ++height) { 1354 for (int width = kMinWidthAll; width <= kMaxWidthAll; ++width) { 1355 rtc::scoped_ptr<rtc::MemoryStream> ms( 1356 CreateYuv422Sample(cricket::FOURCC_YUY2, width, height)); 1357 ASSERT_TRUE(ms.get() != NULL); 1358 EXPECT_TRUE(ConvertYuv422(ms.get(), cricket::FOURCC_YUY2, width, height, 1359 &frame1)); 1360 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_YUY2, 1361 width, height, &frame2)); 1362 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 1363 } 1364 } 1365 } 1366 1367 // Test constructing an image from a ARGB buffer with a range of sizes. 1368 // Only tests that conversion does not crash or corrupt heap. 1369 void ConstructARGBAllSizes() { 1370 T frame1, frame2; 1371 for (int height = kMinHeightAll; height <= kMaxHeightAll; ++height) { 1372 for (int width = kMinWidthAll; width <= kMaxWidthAll; ++width) { 1373 rtc::scoped_ptr<rtc::MemoryStream> ms( 1374 CreateRgbSample(cricket::FOURCC_ARGB, width, height)); 1375 ASSERT_TRUE(ms.get() != NULL); 1376 EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, width, height, 1377 &frame1)); 1378 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB, 1379 width, height, &frame2)); 1380 EXPECT_TRUE(IsEqual(frame1, frame2, 64)); 1381 } 1382 } 1383 // Test a practical window size for screencasting usecase. 1384 const int kOddWidth = 1228; 1385 const int kOddHeight = 260; 1386 for (int j = 0; j < 2; ++j) { 1387 for (int i = 0; i < 2; ++i) { 1388 rtc::scoped_ptr<rtc::MemoryStream> ms( 1389 CreateRgbSample(cricket::FOURCC_ARGB, kOddWidth + i, kOddHeight + j)); 1390 ASSERT_TRUE(ms.get() != NULL); 1391 EXPECT_TRUE(ConvertRgb(ms.get(), cricket::FOURCC_ARGB, 1392 kOddWidth + i, kOddHeight + j, 1393 &frame1)); 1394 EXPECT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_ARGB, 1395 kOddWidth + i, kOddHeight + j, &frame2)); 1396 EXPECT_TRUE(IsEqual(frame1, frame2, 64)); 1397 } 1398 } 1399 } 1400 1401 // Tests re-initing an existing image. 1402 void Reset() { 1403 T frame1, frame2; 1404 rtc::scoped_ptr<rtc::MemoryStream> ms( 1405 LoadSample(kImageFilename)); 1406 ASSERT_TRUE(ms.get() != NULL); 1407 size_t data_size; 1408 ms->GetSize(&data_size); 1409 EXPECT_TRUE(frame1.InitToBlack(kWidth, kHeight, 1, 1, 0, 0)); 1410 EXPECT_TRUE(frame2.InitToBlack(kWidth, kHeight, 1, 1, 0, 0)); 1411 EXPECT_TRUE(IsBlack(frame1)); 1412 EXPECT_TRUE(IsEqual(frame1, frame2, 0)); 1413 EXPECT_TRUE(frame1.Reset(cricket::FOURCC_I420, 1414 kWidth, kHeight, kWidth, kHeight, 1415 reinterpret_cast<uint8*>(ms->GetBuffer()), 1416 data_size, 1, 1, 0, 0, 0)); 1417 EXPECT_FALSE(IsBlack(frame1)); 1418 EXPECT_FALSE(IsEqual(frame1, frame2, 0)); 1419 } 1420 1421 ////////////////////// 1422 // Conversion tests // 1423 ////////////////////// 1424 1425 enum ToFrom { TO, FROM }; 1426 1427 // Helper function for test converting from I420 to packed formats. 1428 inline void ConvertToBuffer(int bpp, int rowpad, bool invert, ToFrom to_from, 1429 int error, uint32 fourcc, 1430 int (*RGBToI420)(const uint8* src_frame, int src_stride_frame, 1431 uint8* dst_y, int dst_stride_y, 1432 uint8* dst_u, int dst_stride_u, 1433 uint8* dst_v, int dst_stride_v, 1434 int width, int height)) { 1435 T frame1, frame2; 1436 int repeat_to = (to_from == TO) ? repeat_ : 1; 1437 int repeat_from = (to_from == FROM) ? repeat_ : 1; 1438 1439 int astride = kWidth * bpp + rowpad; 1440 size_t out_size = astride * kHeight; 1441 rtc::scoped_ptr<uint8[]> outbuf(new uint8[out_size + kAlignment + 1]); 1442 memset(outbuf.get(), 0, out_size + kAlignment + 1); 1443 uint8* outtop = ALIGNP(outbuf.get(), kAlignment); 1444 uint8* out = outtop; 1445 int stride = astride; 1446 if (invert) { 1447 out += (kHeight - 1) * stride; // Point to last row. 1448 stride = -stride; 1449 } 1450 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1451 1452 for (int i = 0; i < repeat_to; ++i) { 1453 EXPECT_EQ(out_size, frame1.ConvertToRgbBuffer(fourcc, 1454 out, 1455 out_size, stride)); 1456 } 1457 EXPECT_TRUE(frame2.InitToBlack(kWidth, kHeight, 1, 1, 0, 0)); 1458 for (int i = 0; i < repeat_from; ++i) { 1459 EXPECT_EQ(0, RGBToI420(out, stride, 1460 frame2.GetYPlane(), frame2.GetYPitch(), 1461 frame2.GetUPlane(), frame2.GetUPitch(), 1462 frame2.GetVPlane(), frame2.GetVPitch(), 1463 kWidth, kHeight)); 1464 } 1465 if (rowpad) { 1466 EXPECT_EQ(0, outtop[kWidth * bpp]); // Ensure stride skipped end of row. 1467 EXPECT_NE(0, outtop[astride]); // Ensure pixel at start of 2nd row. 1468 } else { 1469 EXPECT_NE(0, outtop[kWidth * bpp]); // Expect something to be here. 1470 } 1471 EXPECT_EQ(0, outtop[out_size]); // Ensure no overrun. 1472 EXPECT_TRUE(IsEqual(frame1, frame2, error)); 1473 } 1474 1475 static const int kError = 20; 1476 static const int kErrorHigh = 40; 1477 static const int kOddStride = 23; 1478 1479 // Tests ConvertToRGBBuffer formats. 1480 void ConvertToARGBBuffer() { 1481 ConvertToBuffer(4, 0, false, TO, kError, 1482 cricket::FOURCC_ARGB, libyuv::ARGBToI420); 1483 } 1484 void ConvertToBGRABuffer() { 1485 ConvertToBuffer(4, 0, false, TO, kError, 1486 cricket::FOURCC_BGRA, libyuv::BGRAToI420); 1487 } 1488 void ConvertToABGRBuffer() { 1489 ConvertToBuffer(4, 0, false, TO, kError, 1490 cricket::FOURCC_ABGR, libyuv::ABGRToI420); 1491 } 1492 void ConvertToRGB24Buffer() { 1493 ConvertToBuffer(3, 0, false, TO, kError, 1494 cricket::FOURCC_24BG, libyuv::RGB24ToI420); 1495 } 1496 void ConvertToRAWBuffer() { 1497 ConvertToBuffer(3, 0, false, TO, kError, 1498 cricket::FOURCC_RAW, libyuv::RAWToI420); 1499 } 1500 void ConvertToRGB565Buffer() { 1501 ConvertToBuffer(2, 0, false, TO, kError, 1502 cricket::FOURCC_RGBP, libyuv::RGB565ToI420); 1503 } 1504 void ConvertToARGB1555Buffer() { 1505 ConvertToBuffer(2, 0, false, TO, kError, 1506 cricket::FOURCC_RGBO, libyuv::ARGB1555ToI420); 1507 } 1508 void ConvertToARGB4444Buffer() { 1509 ConvertToBuffer(2, 0, false, TO, kError, 1510 cricket::FOURCC_R444, libyuv::ARGB4444ToI420); 1511 } 1512 void ConvertToBayerBGGRBuffer() { 1513 ConvertToBuffer(1, 0, false, TO, kErrorHigh, 1514 cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420); 1515 } 1516 void ConvertToBayerGBRGBuffer() { 1517 ConvertToBuffer(1, 0, false, TO, kErrorHigh, 1518 cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420); 1519 } 1520 void ConvertToBayerGRBGBuffer() { 1521 ConvertToBuffer(1, 0, false, TO, kErrorHigh, 1522 cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420); 1523 } 1524 void ConvertToBayerRGGBBuffer() { 1525 ConvertToBuffer(1, 0, false, TO, kErrorHigh, 1526 cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420); 1527 } 1528 void ConvertToI400Buffer() { 1529 ConvertToBuffer(1, 0, false, TO, 128, 1530 cricket::FOURCC_I400, libyuv::I400ToI420); 1531 } 1532 void ConvertToYUY2Buffer() { 1533 ConvertToBuffer(2, 0, false, TO, kError, 1534 cricket::FOURCC_YUY2, libyuv::YUY2ToI420); 1535 } 1536 void ConvertToUYVYBuffer() { 1537 ConvertToBuffer(2, 0, false, TO, kError, 1538 cricket::FOURCC_UYVY, libyuv::UYVYToI420); 1539 } 1540 1541 // Tests ConvertToRGBBuffer formats with odd stride. 1542 void ConvertToARGBBufferStride() { 1543 ConvertToBuffer(4, kOddStride, false, TO, kError, 1544 cricket::FOURCC_ARGB, libyuv::ARGBToI420); 1545 } 1546 void ConvertToBGRABufferStride() { 1547 ConvertToBuffer(4, kOddStride, false, TO, kError, 1548 cricket::FOURCC_BGRA, libyuv::BGRAToI420); 1549 } 1550 void ConvertToABGRBufferStride() { 1551 ConvertToBuffer(4, kOddStride, false, TO, kError, 1552 cricket::FOURCC_ABGR, libyuv::ABGRToI420); 1553 } 1554 void ConvertToRGB24BufferStride() { 1555 ConvertToBuffer(3, kOddStride, false, TO, kError, 1556 cricket::FOURCC_24BG, libyuv::RGB24ToI420); 1557 } 1558 void ConvertToRAWBufferStride() { 1559 ConvertToBuffer(3, kOddStride, false, TO, kError, 1560 cricket::FOURCC_RAW, libyuv::RAWToI420); 1561 } 1562 void ConvertToRGB565BufferStride() { 1563 ConvertToBuffer(2, kOddStride, false, TO, kError, 1564 cricket::FOURCC_RGBP, libyuv::RGB565ToI420); 1565 } 1566 void ConvertToARGB1555BufferStride() { 1567 ConvertToBuffer(2, kOddStride, false, TO, kError, 1568 cricket::FOURCC_RGBO, libyuv::ARGB1555ToI420); 1569 } 1570 void ConvertToARGB4444BufferStride() { 1571 ConvertToBuffer(2, kOddStride, false, TO, kError, 1572 cricket::FOURCC_R444, libyuv::ARGB4444ToI420); 1573 } 1574 void ConvertToBayerBGGRBufferStride() { 1575 ConvertToBuffer(1, kOddStride, false, TO, kErrorHigh, 1576 cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420); 1577 } 1578 void ConvertToBayerGBRGBufferStride() { 1579 ConvertToBuffer(1, kOddStride, false, TO, kErrorHigh, 1580 cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420); 1581 } 1582 void ConvertToBayerGRBGBufferStride() { 1583 ConvertToBuffer(1, kOddStride, false, TO, kErrorHigh, 1584 cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420); 1585 } 1586 void ConvertToBayerRGGBBufferStride() { 1587 ConvertToBuffer(1, kOddStride, false, TO, kErrorHigh, 1588 cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420); 1589 } 1590 void ConvertToI400BufferStride() { 1591 ConvertToBuffer(1, kOddStride, false, TO, 128, 1592 cricket::FOURCC_I400, libyuv::I400ToI420); 1593 } 1594 void ConvertToYUY2BufferStride() { 1595 ConvertToBuffer(2, kOddStride, false, TO, kError, 1596 cricket::FOURCC_YUY2, libyuv::YUY2ToI420); 1597 } 1598 void ConvertToUYVYBufferStride() { 1599 ConvertToBuffer(2, kOddStride, false, TO, kError, 1600 cricket::FOURCC_UYVY, libyuv::UYVYToI420); 1601 } 1602 1603 // Tests ConvertToRGBBuffer formats with negative stride to invert image. 1604 void ConvertToARGBBufferInverted() { 1605 ConvertToBuffer(4, 0, true, TO, kError, 1606 cricket::FOURCC_ARGB, libyuv::ARGBToI420); 1607 } 1608 void ConvertToBGRABufferInverted() { 1609 ConvertToBuffer(4, 0, true, TO, kError, 1610 cricket::FOURCC_BGRA, libyuv::BGRAToI420); 1611 } 1612 void ConvertToABGRBufferInverted() { 1613 ConvertToBuffer(4, 0, true, TO, kError, 1614 cricket::FOURCC_ABGR, libyuv::ABGRToI420); 1615 } 1616 void ConvertToRGB24BufferInverted() { 1617 ConvertToBuffer(3, 0, true, TO, kError, 1618 cricket::FOURCC_24BG, libyuv::RGB24ToI420); 1619 } 1620 void ConvertToRAWBufferInverted() { 1621 ConvertToBuffer(3, 0, true, TO, kError, 1622 cricket::FOURCC_RAW, libyuv::RAWToI420); 1623 } 1624 void ConvertToRGB565BufferInverted() { 1625 ConvertToBuffer(2, 0, true, TO, kError, 1626 cricket::FOURCC_RGBP, libyuv::RGB565ToI420); 1627 } 1628 void ConvertToARGB1555BufferInverted() { 1629 ConvertToBuffer(2, 0, true, TO, kError, 1630 cricket::FOURCC_RGBO, libyuv::ARGB1555ToI420); 1631 } 1632 void ConvertToARGB4444BufferInverted() { 1633 ConvertToBuffer(2, 0, true, TO, kError, 1634 cricket::FOURCC_R444, libyuv::ARGB4444ToI420); 1635 } 1636 void ConvertToBayerBGGRBufferInverted() { 1637 ConvertToBuffer(1, 0, true, TO, kErrorHigh, 1638 cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420); 1639 } 1640 void ConvertToBayerGBRGBufferInverted() { 1641 ConvertToBuffer(1, 0, true, TO, kErrorHigh, 1642 cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420); 1643 } 1644 void ConvertToBayerGRBGBufferInverted() { 1645 ConvertToBuffer(1, 0, true, TO, kErrorHigh, 1646 cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420); 1647 } 1648 void ConvertToBayerRGGBBufferInverted() { 1649 ConvertToBuffer(1, 0, true, TO, kErrorHigh, 1650 cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420); 1651 } 1652 void ConvertToI400BufferInverted() { 1653 ConvertToBuffer(1, 0, true, TO, 128, 1654 cricket::FOURCC_I400, libyuv::I400ToI420); 1655 } 1656 void ConvertToYUY2BufferInverted() { 1657 ConvertToBuffer(2, 0, true, TO, kError, 1658 cricket::FOURCC_YUY2, libyuv::YUY2ToI420); 1659 } 1660 void ConvertToUYVYBufferInverted() { 1661 ConvertToBuffer(2, 0, true, TO, kError, 1662 cricket::FOURCC_UYVY, libyuv::UYVYToI420); 1663 } 1664 1665 // Tests ConvertFrom formats. 1666 void ConvertFromARGBBuffer() { 1667 ConvertToBuffer(4, 0, false, FROM, kError, 1668 cricket::FOURCC_ARGB, libyuv::ARGBToI420); 1669 } 1670 void ConvertFromBGRABuffer() { 1671 ConvertToBuffer(4, 0, false, FROM, kError, 1672 cricket::FOURCC_BGRA, libyuv::BGRAToI420); 1673 } 1674 void ConvertFromABGRBuffer() { 1675 ConvertToBuffer(4, 0, false, FROM, kError, 1676 cricket::FOURCC_ABGR, libyuv::ABGRToI420); 1677 } 1678 void ConvertFromRGB24Buffer() { 1679 ConvertToBuffer(3, 0, false, FROM, kError, 1680 cricket::FOURCC_24BG, libyuv::RGB24ToI420); 1681 } 1682 void ConvertFromRAWBuffer() { 1683 ConvertToBuffer(3, 0, false, FROM, kError, 1684 cricket::FOURCC_RAW, libyuv::RAWToI420); 1685 } 1686 void ConvertFromRGB565Buffer() { 1687 ConvertToBuffer(2, 0, false, FROM, kError, 1688 cricket::FOURCC_RGBP, libyuv::RGB565ToI420); 1689 } 1690 void ConvertFromARGB1555Buffer() { 1691 ConvertToBuffer(2, 0, false, FROM, kError, 1692 cricket::FOURCC_RGBO, libyuv::ARGB1555ToI420); 1693 } 1694 void ConvertFromARGB4444Buffer() { 1695 ConvertToBuffer(2, 0, false, FROM, kError, 1696 cricket::FOURCC_R444, libyuv::ARGB4444ToI420); 1697 } 1698 void ConvertFromBayerBGGRBuffer() { 1699 ConvertToBuffer(1, 0, false, FROM, kErrorHigh, 1700 cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420); 1701 } 1702 void ConvertFromBayerGBRGBuffer() { 1703 ConvertToBuffer(1, 0, false, FROM, kErrorHigh, 1704 cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420); 1705 } 1706 void ConvertFromBayerGRBGBuffer() { 1707 ConvertToBuffer(1, 0, false, FROM, kErrorHigh, 1708 cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420); 1709 } 1710 void ConvertFromBayerRGGBBuffer() { 1711 ConvertToBuffer(1, 0, false, FROM, kErrorHigh, 1712 cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420); 1713 } 1714 void ConvertFromI400Buffer() { 1715 ConvertToBuffer(1, 0, false, FROM, 128, 1716 cricket::FOURCC_I400, libyuv::I400ToI420); 1717 } 1718 void ConvertFromYUY2Buffer() { 1719 ConvertToBuffer(2, 0, false, FROM, kError, 1720 cricket::FOURCC_YUY2, libyuv::YUY2ToI420); 1721 } 1722 void ConvertFromUYVYBuffer() { 1723 ConvertToBuffer(2, 0, false, FROM, kError, 1724 cricket::FOURCC_UYVY, libyuv::UYVYToI420); 1725 } 1726 1727 // Tests ConvertFrom formats with odd stride. 1728 void ConvertFromARGBBufferStride() { 1729 ConvertToBuffer(4, kOddStride, false, FROM, kError, 1730 cricket::FOURCC_ARGB, libyuv::ARGBToI420); 1731 } 1732 void ConvertFromBGRABufferStride() { 1733 ConvertToBuffer(4, kOddStride, false, FROM, kError, 1734 cricket::FOURCC_BGRA, libyuv::BGRAToI420); 1735 } 1736 void ConvertFromABGRBufferStride() { 1737 ConvertToBuffer(4, kOddStride, false, FROM, kError, 1738 cricket::FOURCC_ABGR, libyuv::ABGRToI420); 1739 } 1740 void ConvertFromRGB24BufferStride() { 1741 ConvertToBuffer(3, kOddStride, false, FROM, kError, 1742 cricket::FOURCC_24BG, libyuv::RGB24ToI420); 1743 } 1744 void ConvertFromRAWBufferStride() { 1745 ConvertToBuffer(3, kOddStride, false, FROM, kError, 1746 cricket::FOURCC_RAW, libyuv::RAWToI420); 1747 } 1748 void ConvertFromRGB565BufferStride() { 1749 ConvertToBuffer(2, kOddStride, false, FROM, kError, 1750 cricket::FOURCC_RGBP, libyuv::RGB565ToI420); 1751 } 1752 void ConvertFromARGB1555BufferStride() { 1753 ConvertToBuffer(2, kOddStride, false, FROM, kError, 1754 cricket::FOURCC_RGBO, libyuv::ARGB1555ToI420); 1755 } 1756 void ConvertFromARGB4444BufferStride() { 1757 ConvertToBuffer(2, kOddStride, false, FROM, kError, 1758 cricket::FOURCC_R444, libyuv::ARGB4444ToI420); 1759 } 1760 void ConvertFromBayerBGGRBufferStride() { 1761 ConvertToBuffer(1, kOddStride, false, FROM, kErrorHigh, 1762 cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420); 1763 } 1764 void ConvertFromBayerGBRGBufferStride() { 1765 ConvertToBuffer(1, kOddStride, false, FROM, kErrorHigh, 1766 cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420); 1767 } 1768 void ConvertFromBayerGRBGBufferStride() { 1769 ConvertToBuffer(1, kOddStride, false, FROM, kErrorHigh, 1770 cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420); 1771 } 1772 void ConvertFromBayerRGGBBufferStride() { 1773 ConvertToBuffer(1, kOddStride, false, FROM, kErrorHigh, 1774 cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420); 1775 } 1776 void ConvertFromI400BufferStride() { 1777 ConvertToBuffer(1, kOddStride, false, FROM, 128, 1778 cricket::FOURCC_I400, libyuv::I400ToI420); 1779 } 1780 void ConvertFromYUY2BufferStride() { 1781 ConvertToBuffer(2, kOddStride, false, FROM, kError, 1782 cricket::FOURCC_YUY2, libyuv::YUY2ToI420); 1783 } 1784 void ConvertFromUYVYBufferStride() { 1785 ConvertToBuffer(2, kOddStride, false, FROM, kError, 1786 cricket::FOURCC_UYVY, libyuv::UYVYToI420); 1787 } 1788 1789 // Tests ConvertFrom formats with negative stride to invert image. 1790 void ConvertFromARGBBufferInverted() { 1791 ConvertToBuffer(4, 0, true, FROM, kError, 1792 cricket::FOURCC_ARGB, libyuv::ARGBToI420); 1793 } 1794 void ConvertFromBGRABufferInverted() { 1795 ConvertToBuffer(4, 0, true, FROM, kError, 1796 cricket::FOURCC_BGRA, libyuv::BGRAToI420); 1797 } 1798 void ConvertFromABGRBufferInverted() { 1799 ConvertToBuffer(4, 0, true, FROM, kError, 1800 cricket::FOURCC_ABGR, libyuv::ABGRToI420); 1801 } 1802 void ConvertFromRGB24BufferInverted() { 1803 ConvertToBuffer(3, 0, true, FROM, kError, 1804 cricket::FOURCC_24BG, libyuv::RGB24ToI420); 1805 } 1806 void ConvertFromRAWBufferInverted() { 1807 ConvertToBuffer(3, 0, true, FROM, kError, 1808 cricket::FOURCC_RAW, libyuv::RAWToI420); 1809 } 1810 void ConvertFromRGB565BufferInverted() { 1811 ConvertToBuffer(2, 0, true, FROM, kError, 1812 cricket::FOURCC_RGBP, libyuv::RGB565ToI420); 1813 } 1814 void ConvertFromARGB1555BufferInverted() { 1815 ConvertToBuffer(2, 0, true, FROM, kError, 1816 cricket::FOURCC_RGBO, libyuv::ARGB1555ToI420); 1817 } 1818 void ConvertFromARGB4444BufferInverted() { 1819 ConvertToBuffer(2, 0, true, FROM, kError, 1820 cricket::FOURCC_R444, libyuv::ARGB4444ToI420); 1821 } 1822 void ConvertFromBayerBGGRBufferInverted() { 1823 ConvertToBuffer(1, 0, true, FROM, kErrorHigh, 1824 cricket::FOURCC_BGGR, libyuv::BayerBGGRToI420); 1825 } 1826 void ConvertFromBayerGBRGBufferInverted() { 1827 ConvertToBuffer(1, 0, true, FROM, kErrorHigh, 1828 cricket::FOURCC_GBRG, libyuv::BayerGBRGToI420); 1829 } 1830 void ConvertFromBayerGRBGBufferInverted() { 1831 ConvertToBuffer(1, 0, true, FROM, kErrorHigh, 1832 cricket::FOURCC_GRBG, libyuv::BayerGRBGToI420); 1833 } 1834 void ConvertFromBayerRGGBBufferInverted() { 1835 ConvertToBuffer(1, 0, true, FROM, kErrorHigh, 1836 cricket::FOURCC_RGGB, libyuv::BayerRGGBToI420); 1837 } 1838 void ConvertFromI400BufferInverted() { 1839 ConvertToBuffer(1, 0, true, FROM, 128, 1840 cricket::FOURCC_I400, libyuv::I400ToI420); 1841 } 1842 void ConvertFromYUY2BufferInverted() { 1843 ConvertToBuffer(2, 0, true, FROM, kError, 1844 cricket::FOURCC_YUY2, libyuv::YUY2ToI420); 1845 } 1846 void ConvertFromUYVYBufferInverted() { 1847 ConvertToBuffer(2, 0, true, FROM, kError, 1848 cricket::FOURCC_UYVY, libyuv::UYVYToI420); 1849 } 1850 1851 // Test converting from I420 to I422. 1852 void ConvertToI422Buffer() { 1853 T frame1, frame2; 1854 size_t out_size = kWidth * kHeight * 2; 1855 rtc::scoped_ptr<uint8[]> buf(new uint8[out_size + kAlignment]); 1856 uint8* y = ALIGNP(buf.get(), kAlignment); 1857 uint8* u = y + kWidth * kHeight; 1858 uint8* v = u + (kWidth / 2) * kHeight; 1859 ASSERT_TRUE(LoadFrameNoRepeat(&frame1)); 1860 for (int i = 0; i < repeat_; ++i) { 1861 EXPECT_EQ(0, libyuv::I420ToI422(frame1.GetYPlane(), frame1.GetYPitch(), 1862 frame1.GetUPlane(), frame1.GetUPitch(), 1863 frame1.GetVPlane(), frame1.GetVPitch(), 1864 y, kWidth, 1865 u, kWidth / 2, 1866 v, kWidth / 2, 1867 kWidth, kHeight)); 1868 } 1869 EXPECT_TRUE(frame2.Init(cricket::FOURCC_I422, 1870 kWidth, kHeight, kWidth, kHeight, 1871 y, 1872 out_size, 1, 1, 0, 0, cricket::ROTATION_0)); 1873 EXPECT_TRUE(IsEqual(frame1, frame2, 1)); 1874 } 1875 1876 #define TEST_TOBYR(NAME, BAYER) \ 1877 void NAME() { \ 1878 size_t bayer_size = kWidth * kHeight; \ 1879 rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[ \ 1880 bayer_size + kAlignment]); \ 1881 uint8* bayer = ALIGNP(bayerbuf.get(), kAlignment); \ 1882 T frame; \ 1883 rtc::scoped_ptr<rtc::MemoryStream> ms( \ 1884 CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \ 1885 ASSERT_TRUE(ms.get() != NULL); \ 1886 for (int i = 0; i < repeat_; ++i) { \ 1887 libyuv::ARGBToBayer##BAYER(reinterpret_cast<uint8*>(ms->GetBuffer()), \ 1888 kWidth * 4, \ 1889 bayer, kWidth, \ 1890 kWidth, kHeight); \ 1891 } \ 1892 rtc::scoped_ptr<rtc::MemoryStream> ms2( \ 1893 CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \ 1894 size_t data_size; \ 1895 bool ret = ms2->GetSize(&data_size); \ 1896 EXPECT_TRUE(ret); \ 1897 libyuv::Bayer##BAYER##ToARGB(bayer, kWidth, \ 1898 reinterpret_cast<uint8*>(ms2->GetBuffer()), \ 1899 kWidth * 4, \ 1900 kWidth, kHeight); \ 1901 EXPECT_TRUE(IsPlaneEqual("argb", \ 1902 reinterpret_cast<uint8*>(ms->GetBuffer()), kWidth * 4, \ 1903 reinterpret_cast<uint8*>(ms2->GetBuffer()), kWidth * 4, \ 1904 kWidth * 4, kHeight, 240)); \ 1905 } \ 1906 void NAME##Unaligned() { \ 1907 size_t bayer_size = kWidth * kHeight; \ 1908 rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[ \ 1909 bayer_size + 1 + kAlignment]); \ 1910 uint8* bayer = ALIGNP(bayerbuf.get(), kAlignment) + 1; \ 1911 T frame; \ 1912 rtc::scoped_ptr<rtc::MemoryStream> ms( \ 1913 CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \ 1914 ASSERT_TRUE(ms.get() != NULL); \ 1915 for (int i = 0; i < repeat_; ++i) { \ 1916 libyuv::ARGBToBayer##BAYER(reinterpret_cast<uint8*>(ms->GetBuffer()), \ 1917 kWidth * 4, \ 1918 bayer, kWidth, \ 1919 kWidth, kHeight); \ 1920 } \ 1921 rtc::scoped_ptr<rtc::MemoryStream> ms2( \ 1922 CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \ 1923 size_t data_size; \ 1924 bool ret = ms2->GetSize(&data_size); \ 1925 EXPECT_TRUE(ret); \ 1926 libyuv::Bayer##BAYER##ToARGB(bayer, kWidth, \ 1927 reinterpret_cast<uint8*>(ms2->GetBuffer()), \ 1928 kWidth * 4, \ 1929 kWidth, kHeight); \ 1930 EXPECT_TRUE(IsPlaneEqual("argb", \ 1931 reinterpret_cast<uint8*>(ms->GetBuffer()), kWidth * 4, \ 1932 reinterpret_cast<uint8*>(ms2->GetBuffer()), kWidth * 4, \ 1933 kWidth * 4, kHeight, 240)); \ 1934 } 1935 1936 // Tests ARGB to Bayer formats. 1937 TEST_TOBYR(ConvertARGBToBayerGRBG, GRBG) 1938 TEST_TOBYR(ConvertARGBToBayerGBRG, GBRG) 1939 TEST_TOBYR(ConvertARGBToBayerBGGR, BGGR) 1940 TEST_TOBYR(ConvertARGBToBayerRGGB, RGGB) 1941 1942 #define TEST_BYRTORGB(NAME, BAYER) \ 1943 void NAME() { \ 1944 size_t bayer_size = kWidth * kHeight; \ 1945 rtc::scoped_ptr<uint8[]> bayerbuf(new uint8[ \ 1946 bayer_size + kAlignment]); \ 1947 uint8* bayer1 = ALIGNP(bayerbuf.get(), kAlignment); \ 1948 for (int i = 0; i < kWidth * kHeight; ++i) { \ 1949 bayer1[i] = static_cast<uint8>(i * 33u + 183u); \ 1950 } \ 1951 T frame; \ 1952 rtc::scoped_ptr<rtc::MemoryStream> ms( \ 1953 CreateRgbSample(cricket::FOURCC_ARGB, kWidth, kHeight)); \ 1954 ASSERT_TRUE(ms.get() != NULL); \ 1955 for (int i = 0; i < repeat_; ++i) { \ 1956 libyuv::Bayer##BAYER##ToARGB(bayer1, kWidth, \ 1957 reinterpret_cast<uint8*>(ms->GetBuffer()), \ 1958 kWidth * 4, \ 1959 kWidth, kHeight); \ 1960 } \ 1961 rtc::scoped_ptr<uint8[]> bayer2buf(new uint8[ \ 1962 bayer_size + kAlignment]); \ 1963 uint8* bayer2 = ALIGNP(bayer2buf.get(), kAlignment); \ 1964 libyuv::ARGBToBayer##BAYER(reinterpret_cast<uint8*>(ms->GetBuffer()), \ 1965 kWidth * 4, \ 1966 bayer2, kWidth, \ 1967 kWidth, kHeight); \ 1968 EXPECT_TRUE(IsPlaneEqual("bayer", \ 1969 bayer1, kWidth, \ 1970 bayer2, kWidth, \ 1971 kWidth, kHeight, 0)); \ 1972 } 1973 1974 // Tests Bayer formats to ARGB. 1975 TEST_BYRTORGB(ConvertBayerGRBGToARGB, GRBG) 1976 TEST_BYRTORGB(ConvertBayerGBRGToARGB, GBRG) 1977 TEST_BYRTORGB(ConvertBayerBGGRToARGB, BGGR) 1978 TEST_BYRTORGB(ConvertBayerRGGBToARGB, RGGB) 1979 1980 /////////////////// 1981 // General tests // 1982 /////////////////// 1983 1984 void Copy() { 1985 rtc::scoped_ptr<T> source(new T); 1986 rtc::scoped_ptr<cricket::VideoFrame> target; 1987 ASSERT_TRUE(LoadFrameNoRepeat(source.get())); 1988 target.reset(source->Copy()); 1989 EXPECT_TRUE(IsEqual(*source, *target, 0)); 1990 source.reset(); 1991 EXPECT_TRUE(target->GetYPlane() != NULL); 1992 } 1993 1994 void CopyIsRef() { 1995 rtc::scoped_ptr<T> source(new T); 1996 rtc::scoped_ptr<cricket::VideoFrame> target; 1997 ASSERT_TRUE(LoadFrameNoRepeat(source.get())); 1998 target.reset(source->Copy()); 1999 EXPECT_TRUE(IsEqual(*source, *target, 0)); 2000 EXPECT_EQ(source->GetYPlane(), target->GetYPlane()); 2001 EXPECT_EQ(source->GetUPlane(), target->GetUPlane()); 2002 EXPECT_EQ(source->GetVPlane(), target->GetVPlane()); 2003 } 2004 2005 void MakeExclusive() { 2006 rtc::scoped_ptr<T> source(new T); 2007 rtc::scoped_ptr<cricket::VideoFrame> target; 2008 ASSERT_TRUE(LoadFrameNoRepeat(source.get())); 2009 target.reset(source->Copy()); 2010 EXPECT_TRUE(target->MakeExclusive()); 2011 EXPECT_TRUE(IsEqual(*source, *target, 0)); 2012 EXPECT_NE(target->GetYPlane(), source->GetYPlane()); 2013 EXPECT_NE(target->GetUPlane(), source->GetUPlane()); 2014 EXPECT_NE(target->GetVPlane(), source->GetVPlane()); 2015 } 2016 2017 void CopyToBuffer() { 2018 T frame; 2019 rtc::scoped_ptr<rtc::MemoryStream> ms( 2020 LoadSample(kImageFilename)); 2021 ASSERT_TRUE(ms.get() != NULL); 2022 ASSERT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420, kWidth, kHeight, 2023 &frame)); 2024 size_t out_size = kWidth * kHeight * 3 / 2; 2025 rtc::scoped_ptr<uint8[]> out(new uint8[out_size]); 2026 for (int i = 0; i < repeat_; ++i) { 2027 EXPECT_EQ(out_size, frame.CopyToBuffer(out.get(), out_size)); 2028 } 2029 EXPECT_EQ(0, memcmp(out.get(), ms->GetBuffer(), out_size)); 2030 } 2031 2032 void CopyToFrame() { 2033 T source; 2034 rtc::scoped_ptr<rtc::MemoryStream> ms( 2035 LoadSample(kImageFilename)); 2036 ASSERT_TRUE(ms.get() != NULL); 2037 ASSERT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420, kWidth, kHeight, 2038 &source)); 2039 2040 // Create the target frame by loading from a file. 2041 T target; 2042 ASSERT_TRUE(LoadFrameNoRepeat(&target)); 2043 EXPECT_FALSE(IsBlack(target)); 2044 2045 // Stretch and check if the stretched target is black. 2046 source.CopyToFrame(&target); 2047 2048 EXPECT_TRUE(IsEqual(source, target, 0)); 2049 } 2050 2051 void Write() { 2052 T frame; 2053 rtc::scoped_ptr<rtc::MemoryStream> ms( 2054 LoadSample(kImageFilename)); 2055 ASSERT_TRUE(ms.get() != NULL); 2056 rtc::MemoryStream ms2; 2057 size_t size; 2058 ASSERT_TRUE(ms->GetSize(&size)); 2059 ASSERT_TRUE(ms2.ReserveSize(size)); 2060 ASSERT_TRUE(LoadFrame(ms.get(), cricket::FOURCC_I420, kWidth, kHeight, 2061 &frame)); 2062 for (int i = 0; i < repeat_; ++i) { 2063 ms2.SetPosition(0u); // Useful when repeat_ > 1. 2064 int error; 2065 EXPECT_EQ(rtc::SR_SUCCESS, frame.Write(&ms2, &error)); 2066 } 2067 size_t out_size = cricket::VideoFrame::SizeOf(kWidth, kHeight); 2068 EXPECT_EQ(0, memcmp(ms2.GetBuffer(), ms->GetBuffer(), out_size)); 2069 } 2070 2071 void CopyToBuffer1Pixel() { 2072 size_t out_size = 3; 2073 rtc::scoped_ptr<uint8[]> out(new uint8[out_size + 1]); 2074 memset(out.get(), 0xfb, out_size + 1); // Fill buffer 2075 uint8 pixel[3] = { 1, 2, 3 }; 2076 T frame; 2077 EXPECT_TRUE(frame.Init(cricket::FOURCC_I420, 1, 1, 1, 1, 2078 pixel, sizeof(pixel), 2079 1, 1, 0, 0, 0)); 2080 for (int i = 0; i < repeat_; ++i) { 2081 EXPECT_EQ(out_size, frame.CopyToBuffer(out.get(), out_size)); 2082 } 2083 EXPECT_EQ(1, out.get()[0]); // Check Y. Should be 1. 2084 EXPECT_EQ(2, out.get()[1]); // Check U. Should be 2. 2085 EXPECT_EQ(3, out.get()[2]); // Check V. Should be 3. 2086 EXPECT_EQ(0xfb, out.get()[3]); // Check sentinel is still intact. 2087 } 2088 2089 void StretchToFrame() { 2090 // Create the source frame as a black frame. 2091 T source; 2092 EXPECT_TRUE(source.InitToBlack(kWidth * 2, kHeight * 2, 1, 1, 0, 0)); 2093 EXPECT_TRUE(IsSize(source, kWidth * 2, kHeight * 2)); 2094 2095 // Create the target frame by loading from a file. 2096 T target1; 2097 ASSERT_TRUE(LoadFrameNoRepeat(&target1)); 2098 EXPECT_FALSE(IsBlack(target1)); 2099 2100 // Stretch and check if the stretched target is black. 2101 source.StretchToFrame(&target1, true, false); 2102 EXPECT_TRUE(IsBlack(target1)); 2103 2104 // Crop and stretch and check if the stretched target is black. 2105 T target2; 2106 ASSERT_TRUE(LoadFrameNoRepeat(&target2)); 2107 source.StretchToFrame(&target2, true, true); 2108 EXPECT_TRUE(IsBlack(target2)); 2109 EXPECT_EQ(source.GetElapsedTime(), target2.GetElapsedTime()); 2110 EXPECT_EQ(source.GetTimeStamp(), target2.GetTimeStamp()); 2111 } 2112 2113 int repeat_; 2114 }; 2115 2116 #endif // TALK_MEDIA_BASE_VIDEOFRAME_UNITTEST_H_ 2117
