webrtc/common_video/libyuv/libyuv_unittest.cc - src - Git at Google

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */

 #include <math.h>
 #include <string.h>

 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common_video/interface/i420_video_frame.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/system_wrappers/interface/tick_util.h"
 #include "webrtc/test/testsupport/fileutils.h"

 namespace webrtc {

 int PrintBuffer(const uint8_t* buffer, int width, int height, int stride) {
   if (buffer == NULL)
     return -1;
   int k;
   const uint8_t* tmp_buffer = buffer;
   for (int i = 0; i < height; i++) {
     k = 0;
     for (int j = 0; j < width; j++) {
       printf("%d ", tmp_buffer[k++]);
     }
     tmp_buffer += stride;
     printf(" \n");
   }
   printf(" \n");
   return 0;
 }


 int PrintFrame(const I420VideoFrame* frame, const char* str) {
   if (frame == NULL)
      return -1;
   printf("%s %dx%d \n", str, frame->width(), frame->height());

   int ret = 0;
   for (int plane_num = 0; plane_num < kNumOfPlanes; ++plane_num) {
     PlaneType plane_type = static_cast<PlaneType>(plane_num);
     int width = (plane_num ? (frame->width() + 1) / 2 : frame->width());
     int height = (plane_num ? (frame->height() + 1) / 2 : frame->height());
     ret += PrintBuffer(frame->buffer(plane_type), width, height,
                        frame->stride(plane_type));
   }
   return ret;
 }


 // Create an image from on a YUV frame. Every plane value starts with a start
 // value, and will be set to increasing values.
 void CreateImage(I420VideoFrame* frame, int plane_offset[kNumOfPlanes]) {
   if (frame == NULL)
     return;
   for (int plane_num = 0; plane_num < kNumOfPlanes; ++plane_num) {
     int width = (plane_num != kYPlane ? (frame->width() + 1) / 2 :
       frame->width());
     int height = (plane_num != kYPlane ? (frame->height() + 1) / 2 :
       frame->height());
     PlaneType plane_type = static_cast<PlaneType>(plane_num);
     uint8_t *data = frame->buffer(plane_type);
     for (int i = 0; i < height; i++) {
       for (int j = 0; j < width; j++) {
         data[j] = static_cast<uint8_t>(i + plane_offset[plane_num] + j);
       }
       data += frame->stride(plane_type);
     }
   }
 }

 class TestLibYuv : public ::testing::Test {
  protected:
   TestLibYuv();
   virtual void SetUp();
   virtual void TearDown();

   FILE* source_file_;
   I420VideoFrame orig_frame_;
   rtc::scoped_ptr<uint8_t[]> orig_buffer_;
   const int width_;
   const int height_;
   const int size_y_;
   const int size_uv_;
   const size_t frame_length_;
 };

 TestLibYuv::TestLibYuv()
     : source_file_(NULL),
       orig_frame_(),
       width_(352),
       height_(288),
       size_y_(width_ * height_),
       size_uv_(((width_ + 1 ) / 2) * ((height_ + 1) / 2)),
       frame_length_(CalcBufferSize(kI420, 352, 288)) {
   orig_buffer_.reset(new uint8_t[frame_length_]);
 }

 void TestLibYuv::SetUp() {
   const std::string input_file_name = webrtc::test::ProjectRootPath() +
                                       "resources/foreman_cif.yuv";
   source_file_  = fopen(input_file_name.c_str(), "rb");
   ASSERT_TRUE(source_file_ != NULL) << "Cannot read file: "<<
                                        input_file_name << "\n";

   EXPECT_EQ(frame_length_,
             fread(orig_buffer_.get(), 1, frame_length_, source_file_));
   EXPECT_EQ(0, orig_frame_.CreateFrame(size_y_, orig_buffer_.get(),
                                        size_uv_, orig_buffer_.get() + size_y_,
                                        size_uv_, orig_buffer_.get() +
                                        size_y_ + size_uv_,
                                        width_, height_,
                                        width_, (width_ + 1) / 2,
                                        (width_ + 1) / 2));
 }

 void TestLibYuv::TearDown() {
   if (source_file_ != NULL) {
     ASSERT_EQ(0, fclose(source_file_));
   }
   source_file_ = NULL;
 }

 TEST_F(TestLibYuv, ConvertSanityTest) {
   // TODO(mikhal)
 }

 TEST_F(TestLibYuv, ConvertTest) {
   // Reading YUV frame - testing on the first frame of the foreman sequence
   int j = 0;
   std::string output_file_name = webrtc::test::OutputPath() +
                                  "LibYuvTest_conversion.yuv";
   FILE*  output_file = fopen(output_file_name.c_str(), "wb");
   ASSERT_TRUE(output_file != NULL);

   double psnr = 0.0;

   I420VideoFrame res_i420_frame;
   EXPECT_EQ(0,res_i420_frame.CreateEmptyFrame(width_, height_, width_,
                                               (width_ + 1) / 2,
                                               (width_ + 1) / 2));
   printf("\nConvert #%d I420 <-> I420 \n", j);
   rtc::scoped_ptr<uint8_t[]> out_i420_buffer(new uint8_t[frame_length_]);
   EXPECT_EQ(0, ConvertFromI420(orig_frame_, kI420, 0,
                                out_i420_buffer.get()));
   EXPECT_EQ(0, ConvertToI420(kI420, out_i420_buffer.get(), 0, 0,
                              width_, height_,
                              0, kRotateNone, &res_i420_frame));

   if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
     return;
   }
   psnr = I420PSNR(&orig_frame_, &res_i420_frame);
   EXPECT_EQ(48.0, psnr);
   j++;

   printf("\nConvert #%d I420 <-> RGB24\n", j);
   rtc::scoped_ptr<uint8_t[]> res_rgb_buffer2(new uint8_t[width_ * height_ * 3]);
   // Align the stride values for the output frame.
   int stride_y = 0;
   int stride_uv = 0;
   Calc16ByteAlignedStride(width_, &stride_y, &stride_uv);
   res_i420_frame.CreateEmptyFrame(width_, height_, stride_y,
                                   stride_uv, stride_uv);
   EXPECT_EQ(0, ConvertFromI420(orig_frame_, kRGB24, 0, res_rgb_buffer2.get()));

   EXPECT_EQ(0, ConvertToI420(kRGB24, res_rgb_buffer2.get(), 0, 0, width_,
                              height_, 0, kRotateNone, &res_i420_frame));

   if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
     return;
   }
   psnr = I420PSNR(&orig_frame_, &res_i420_frame);

   // Optimization Speed- quality trade-off => 45 dB only (platform dependant).
   EXPECT_GT(ceil(psnr), 44);
   j++;

   printf("\nConvert #%d I420 <-> UYVY\n", j);
   rtc::scoped_ptr<uint8_t[]> out_uyvy_buffer(new uint8_t[width_ * height_ * 2]);
   EXPECT_EQ(0, ConvertFromI420(orig_frame_,  kUYVY, 0, out_uyvy_buffer.get()));
   EXPECT_EQ(0, ConvertToI420(kUYVY, out_uyvy_buffer.get(), 0, 0, width_,
                              height_, 0, kRotateNone, &res_i420_frame));
   psnr = I420PSNR(&orig_frame_, &res_i420_frame);
   EXPECT_EQ(48.0, psnr);
   if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
     return;
   }
   j++;

   printf("\nConvert #%d I420 <-> YV12\n", j);
   rtc::scoped_ptr<uint8_t[]> outYV120Buffer(new uint8_t[frame_length_]);
   rtc::scoped_ptr<uint8_t[]> res_i420_buffer(new uint8_t[frame_length_]);
   I420VideoFrame yv12_frame;
   EXPECT_EQ(0, ConvertFromI420(orig_frame_, kYV12, 0, outYV120Buffer.get()));
   yv12_frame.CreateFrame(size_y_, outYV120Buffer.get(),
                          size_uv_, outYV120Buffer.get() + size_y_,
                          size_uv_, outYV120Buffer.get() + size_y_ + size_uv_,
                          width_, height_,
                          width_, (width_ + 1) / 2, (width_ + 1) / 2);
   EXPECT_EQ(0, ConvertFromYV12(yv12_frame, kI420, 0, res_i420_buffer.get()));
   if (fwrite(res_i420_buffer.get(), 1, frame_length_, output_file) !=
       frame_length_) {
     return;
   }

   ConvertToI420(kI420, res_i420_buffer.get(), 0, 0,
       width_, height_, 0, kRotateNone, &res_i420_frame);
   psnr = I420PSNR(&orig_frame_, &res_i420_frame);
   EXPECT_EQ(48.0, psnr);
   j++;

   printf("\nConvert #%d I420 <-> YUY2\n", j);
   rtc::scoped_ptr<uint8_t[]> out_yuy2_buffer(new uint8_t[width_ * height_ * 2]);
   EXPECT_EQ(0, ConvertFromI420(orig_frame_,  kYUY2, 0, out_yuy2_buffer.get()));

   EXPECT_EQ(0, ConvertToI420(kYUY2, out_yuy2_buffer.get(), 0, 0, width_,
                              height_, 0, kRotateNone, &res_i420_frame));

   if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
     return;
   }

   psnr = I420PSNR(&orig_frame_, &res_i420_frame);
   EXPECT_EQ(48.0, psnr);
   printf("\nConvert #%d I420 <-> RGB565\n", j);
   rtc::scoped_ptr<uint8_t[]> out_rgb565_buffer(
       new uint8_t[width_ * height_ * 2]);
   EXPECT_EQ(0, ConvertFromI420(orig_frame_, kRGB565, 0,
                                out_rgb565_buffer.get()));

   EXPECT_EQ(0, ConvertToI420(kRGB565, out_rgb565_buffer.get(), 0, 0, width_,
                              height_, 0, kRotateNone, &res_i420_frame));

   if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
     return;
   }
   j++;

   psnr = I420PSNR(&orig_frame_, &res_i420_frame);
   // TODO(leozwang) Investigate the right psnr should be set for I420ToRGB565,
   // Another example is I420ToRGB24, the psnr is 44
   // TODO(mikhal): Add psnr for RGB565, 1555, 4444, convert to ARGB.
   EXPECT_GT(ceil(psnr), 40);

   printf("\nConvert #%d I420 <-> ARGB8888\n", j);
   rtc::scoped_ptr<uint8_t[]> out_argb8888_buffer(
       new uint8_t[width_ * height_ * 4]);
   EXPECT_EQ(0, ConvertFromI420(orig_frame_, kARGB, 0,
                                out_argb8888_buffer.get()));

   EXPECT_EQ(0, ConvertToI420(kARGB, out_argb8888_buffer.get(), 0, 0, width_,
                              height_, 0, kRotateNone, &res_i420_frame));

   if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
     return;
   }

   psnr = I420PSNR(&orig_frame_, &res_i420_frame);
   // TODO(leozwang) Investigate the right psnr should be set for I420ToARGB8888,
   EXPECT_GT(ceil(psnr), 42);

   ASSERT_EQ(0, fclose(output_file));
 }

 TEST_F(TestLibYuv, ConvertAlignedFrame) {
   // Reading YUV frame - testing on the first frame of the foreman sequence
   std::string output_file_name = webrtc::test::OutputPath() +
                                  "LibYuvTest_conversion.yuv";
   FILE*  output_file = fopen(output_file_name.c_str(), "wb");
   ASSERT_TRUE(output_file != NULL);

   double psnr = 0.0;

   I420VideoFrame res_i420_frame;
   int stride_y = 0;
   int stride_uv = 0;
   Calc16ByteAlignedStride(width_, &stride_y, &stride_uv);
   EXPECT_EQ(0,res_i420_frame.CreateEmptyFrame(width_, height_,
                                               stride_y, stride_uv, stride_uv));
   rtc::scoped_ptr<uint8_t[]> out_i420_buffer(new uint8_t[frame_length_]);
   EXPECT_EQ(0, ConvertFromI420(orig_frame_, kI420, 0,
                                out_i420_buffer.get()));
   EXPECT_EQ(0, ConvertToI420(kI420, out_i420_buffer.get(), 0, 0,
                              width_, height_,
                              0, kRotateNone, &res_i420_frame));

   if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
     return;
   }
   psnr = I420PSNR(&orig_frame_, &res_i420_frame);
   EXPECT_EQ(48.0, psnr);
 }


 TEST_F(TestLibYuv, RotateTest) {
   // Use ConvertToI420 for multiple roatations - see that nothing breaks, all
   // memory is properly allocated and end result is equal to the starting point.
   I420VideoFrame rotated_res_i420_frame;
   int rotated_width = height_;
   int rotated_height = width_;
   int stride_y ;
   int stride_uv;
   Calc16ByteAlignedStride(rotated_width, &stride_y, &stride_uv);
   EXPECT_EQ(0,rotated_res_i420_frame.CreateEmptyFrame(rotated_width,
                                                       rotated_height,
                                                       stride_y,
                                                       stride_uv,
                                                       stride_uv));
   EXPECT_EQ(0, ConvertToI420(kI420, orig_buffer_.get(), 0, 0,
                              width_, height_,
                              0, kRotate90, &rotated_res_i420_frame));
   EXPECT_EQ(0, ConvertToI420(kI420, orig_buffer_.get(), 0, 0,
                              width_, height_,
                              0, kRotate270, &rotated_res_i420_frame));
   EXPECT_EQ(0,rotated_res_i420_frame.CreateEmptyFrame(width_, height_,
                                                       width_, (width_ + 1) / 2,
                                                       (width_ + 1) / 2));
   EXPECT_EQ(0, ConvertToI420(kI420, orig_buffer_.get(), 0, 0,
                              width_, height_,
                              0, kRotate180, &rotated_res_i420_frame));
 }

 TEST_F(TestLibYuv, alignment) {
   int value = 0x3FF; // 1023
   EXPECT_EQ(0x400, AlignInt(value, 128));  // Low 7 bits are zero.
   EXPECT_EQ(0x400, AlignInt(value, 64));  // Low 6 bits are zero.
   EXPECT_EQ(0x400, AlignInt(value, 32));  // Low 5 bits are zero.
 }

 TEST_F(TestLibYuv, StrideAlignment) {
   int stride_y = 0;
   int stride_uv = 0;
   int width = 52;
   Calc16ByteAlignedStride(width, &stride_y, &stride_uv);
   EXPECT_EQ(64, stride_y);
   EXPECT_EQ(32, stride_uv);
   width = 128;
   Calc16ByteAlignedStride(width, &stride_y, &stride_uv);
   EXPECT_EQ(128, stride_y);
   EXPECT_EQ(64, stride_uv);
   width = 127;
   Calc16ByteAlignedStride(width, &stride_y, &stride_uv);
   EXPECT_EQ(128, stride_y);
   EXPECT_EQ(64, stride_uv);
 }

 }  // namespace
	/*
	* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/

	#include <math.h>
	#include <string.h>

	#include "testing/gtest/include/gtest/gtest.h"
	#include "webrtc/base/scoped_ptr.h"
	#include "webrtc/common_video/interface/i420_video_frame.h"
	#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
	#include "webrtc/system_wrappers/interface/tick_util.h"
	#include "webrtc/test/testsupport/fileutils.h"

	namespace webrtc {

	int PrintBuffer(const uint8_t* buffer, int width, int height, int stride) {
	if (buffer == NULL)
	return -1;
	int k;
	const uint8_t* tmp_buffer = buffer;
	for (int i = 0; i < height; i++) {
	k = 0;
	for (int j = 0; j < width; j++) {
	printf("%d ", tmp_buffer[k++]);
	}
	tmp_buffer += stride;
	printf(" \n");
	}
	printf(" \n");
	return 0;
	}


	int PrintFrame(const I420VideoFrame* frame, const char* str) {
	if (frame == NULL)
	return -1;
	printf("%s %dx%d \n", str, frame->width(), frame->height());

	int ret = 0;
	for (int plane_num = 0; plane_num < kNumOfPlanes; ++plane_num) {
	PlaneType plane_type = static_cast<PlaneType>(plane_num);
	int width = (plane_num ? (frame->width() + 1) / 2 : frame->width());
	int height = (plane_num ? (frame->height() + 1) / 2 : frame->height());
	ret += PrintBuffer(frame->buffer(plane_type), width, height,
	frame->stride(plane_type));
	}
	return ret;
	}


	// Create an image from on a YUV frame. Every plane value starts with a start
	// value, and will be set to increasing values.
	void CreateImage(I420VideoFrame* frame, int plane_offset[kNumOfPlanes]) {
	if (frame == NULL)
	return;
	for (int plane_num = 0; plane_num < kNumOfPlanes; ++plane_num) {
	int width = (plane_num != kYPlane ? (frame->width() + 1) / 2 :
	frame->width());
	int height = (plane_num != kYPlane ? (frame->height() + 1) / 2 :
	frame->height());
	PlaneType plane_type = static_cast<PlaneType>(plane_num);
	uint8_t *data = frame->buffer(plane_type);
	for (int i = 0; i < height; i++) {
	for (int j = 0; j < width; j++) {
	data[j] = static_cast<uint8_t>(i + plane_offset[plane_num] + j);
	}
	data += frame->stride(plane_type);
	}
	}
	}

	class TestLibYuv : public ::testing::Test {
	protected:
	TestLibYuv();
	virtual void SetUp();
	virtual void TearDown();

	FILE* source_file_;
	I420VideoFrame orig_frame_;
	rtc::scoped_ptr<uint8_t[]> orig_buffer_;
	const int width_;
	const int height_;
	const int size_y_;
	const int size_uv_;
	const size_t frame_length_;
	};

	TestLibYuv::TestLibYuv()
	: source_file_(NULL),
	orig_frame_(),
	width_(352),
	height_(288),
	size_y_(width_ * height_),
	size_uv_(((width_ + 1 ) / 2) * ((height_ + 1) / 2)),
	frame_length_(CalcBufferSize(kI420, 352, 288)) {
	orig_buffer_.reset(new uint8_t[frame_length_]);
	}

	void TestLibYuv::SetUp() {
	const std::string input_file_name = webrtc::test::ProjectRootPath() +
	"resources/foreman_cif.yuv";
	source_file_ = fopen(input_file_name.c_str(), "rb");
	ASSERT_TRUE(source_file_ != NULL) << "Cannot read file: "<<
	input_file_name << "\n";

	EXPECT_EQ(frame_length_,
	fread(orig_buffer_.get(), 1, frame_length_, source_file_));
	EXPECT_EQ(0, orig_frame_.CreateFrame(size_y_, orig_buffer_.get(),
	size_uv_, orig_buffer_.get() + size_y_,
	size_uv_, orig_buffer_.get() +
	size_y_ + size_uv_,
	width_, height_,
	width_, (width_ + 1) / 2,
	(width_ + 1) / 2));
	}

	void TestLibYuv::TearDown() {
	if (source_file_ != NULL) {
	ASSERT_EQ(0, fclose(source_file_));
	}
	source_file_ = NULL;
	}

	TEST_F(TestLibYuv, ConvertSanityTest) {
	// TODO(mikhal)
	}

	TEST_F(TestLibYuv, ConvertTest) {
	// Reading YUV frame - testing on the first frame of the foreman sequence
	int j = 0;
	std::string output_file_name = webrtc::test::OutputPath() +
	"LibYuvTest_conversion.yuv";
	FILE* output_file = fopen(output_file_name.c_str(), "wb");
	ASSERT_TRUE(output_file != NULL);

	double psnr = 0.0;

	I420VideoFrame res_i420_frame;
	EXPECT_EQ(0,res_i420_frame.CreateEmptyFrame(width_, height_, width_,
	(width_ + 1) / 2,
	(width_ + 1) / 2));
	printf("\nConvert #%d I420 <-> I420 \n", j);
	rtc::scoped_ptr<uint8_t[]> out_i420_buffer(new uint8_t[frame_length_]);
	EXPECT_EQ(0, ConvertFromI420(orig_frame_, kI420, 0,
	out_i420_buffer.get()));
	EXPECT_EQ(0, ConvertToI420(kI420, out_i420_buffer.get(), 0, 0,
	width_, height_,
	0, kRotateNone, &res_i420_frame));

	if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
	return;
	}
	psnr = I420PSNR(&orig_frame_, &res_i420_frame);
	EXPECT_EQ(48.0, psnr);
	j++;

	printf("\nConvert #%d I420 <-> RGB24\n", j);
	rtc::scoped_ptr<uint8_t[]> res_rgb_buffer2(new uint8_t[width_ * height_ * 3]);
	// Align the stride values for the output frame.
	int stride_y = 0;
	int stride_uv = 0;
	Calc16ByteAlignedStride(width_, &stride_y, &stride_uv);
	res_i420_frame.CreateEmptyFrame(width_, height_, stride_y,
	stride_uv, stride_uv);
	EXPECT_EQ(0, ConvertFromI420(orig_frame_, kRGB24, 0, res_rgb_buffer2.get()));

	EXPECT_EQ(0, ConvertToI420(kRGB24, res_rgb_buffer2.get(), 0, 0, width_,
	height_, 0, kRotateNone, &res_i420_frame));

	if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
	return;
	}
	psnr = I420PSNR(&orig_frame_, &res_i420_frame);

	// Optimization Speed- quality trade-off => 45 dB only (platform dependant).
	EXPECT_GT(ceil(psnr), 44);
	j++;

	printf("\nConvert #%d I420 <-> UYVY\n", j);
	rtc::scoped_ptr<uint8_t[]> out_uyvy_buffer(new uint8_t[width_ * height_ * 2]);
	EXPECT_EQ(0, ConvertFromI420(orig_frame_, kUYVY, 0, out_uyvy_buffer.get()));
	EXPECT_EQ(0, ConvertToI420(kUYVY, out_uyvy_buffer.get(), 0, 0, width_,
	height_, 0, kRotateNone, &res_i420_frame));
	psnr = I420PSNR(&orig_frame_, &res_i420_frame);
	EXPECT_EQ(48.0, psnr);
	if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
	return;
	}
	j++;

	printf("\nConvert #%d I420 <-> YV12\n", j);
	rtc::scoped_ptr<uint8_t[]> outYV120Buffer(new uint8_t[frame_length_]);
	rtc::scoped_ptr<uint8_t[]> res_i420_buffer(new uint8_t[frame_length_]);
	I420VideoFrame yv12_frame;
	EXPECT_EQ(0, ConvertFromI420(orig_frame_, kYV12, 0, outYV120Buffer.get()));
	yv12_frame.CreateFrame(size_y_, outYV120Buffer.get(),
	size_uv_, outYV120Buffer.get() + size_y_,
	size_uv_, outYV120Buffer.get() + size_y_ + size_uv_,
	width_, height_,
	width_, (width_ + 1) / 2, (width_ + 1) / 2);
	EXPECT_EQ(0, ConvertFromYV12(yv12_frame, kI420, 0, res_i420_buffer.get()));
	if (fwrite(res_i420_buffer.get(), 1, frame_length_, output_file) !=
	frame_length_) {
	return;
	}

	ConvertToI420(kI420, res_i420_buffer.get(), 0, 0,
	width_, height_, 0, kRotateNone, &res_i420_frame);
	psnr = I420PSNR(&orig_frame_, &res_i420_frame);
	EXPECT_EQ(48.0, psnr);
	j++;

	printf("\nConvert #%d I420 <-> YUY2\n", j);
	rtc::scoped_ptr<uint8_t[]> out_yuy2_buffer(new uint8_t[width_ * height_ * 2]);
	EXPECT_EQ(0, ConvertFromI420(orig_frame_, kYUY2, 0, out_yuy2_buffer.get()));

	EXPECT_EQ(0, ConvertToI420(kYUY2, out_yuy2_buffer.get(), 0, 0, width_,
	height_, 0, kRotateNone, &res_i420_frame));

	if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
	return;
	}

	psnr = I420PSNR(&orig_frame_, &res_i420_frame);
	EXPECT_EQ(48.0, psnr);
	printf("\nConvert #%d I420 <-> RGB565\n", j);
	rtc::scoped_ptr<uint8_t[]> out_rgb565_buffer(
	new uint8_t[width_ * height_ * 2]);
	EXPECT_EQ(0, ConvertFromI420(orig_frame_, kRGB565, 0,
	out_rgb565_buffer.get()));

	EXPECT_EQ(0, ConvertToI420(kRGB565, out_rgb565_buffer.get(), 0, 0, width_,
	height_, 0, kRotateNone, &res_i420_frame));

	if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
	return;
	}
	j++;

	psnr = I420PSNR(&orig_frame_, &res_i420_frame);
	// TODO(leozwang) Investigate the right psnr should be set for I420ToRGB565,
	// Another example is I420ToRGB24, the psnr is 44
	// TODO(mikhal): Add psnr for RGB565, 1555, 4444, convert to ARGB.
	EXPECT_GT(ceil(psnr), 40);

	printf("\nConvert #%d I420 <-> ARGB8888\n", j);
	rtc::scoped_ptr<uint8_t[]> out_argb8888_buffer(
	new uint8_t[width_ * height_ * 4]);
	EXPECT_EQ(0, ConvertFromI420(orig_frame_, kARGB, 0,
	out_argb8888_buffer.get()));

	EXPECT_EQ(0, ConvertToI420(kARGB, out_argb8888_buffer.get(), 0, 0, width_,
	height_, 0, kRotateNone, &res_i420_frame));

	if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
	return;
	}

	psnr = I420PSNR(&orig_frame_, &res_i420_frame);
	// TODO(leozwang) Investigate the right psnr should be set for I420ToARGB8888,
	EXPECT_GT(ceil(psnr), 42);

	ASSERT_EQ(0, fclose(output_file));
	}

	TEST_F(TestLibYuv, ConvertAlignedFrame) {
	// Reading YUV frame - testing on the first frame of the foreman sequence
	std::string output_file_name = webrtc::test::OutputPath() +
	"LibYuvTest_conversion.yuv";
	FILE* output_file = fopen(output_file_name.c_str(), "wb");
	ASSERT_TRUE(output_file != NULL);

	double psnr = 0.0;

	I420VideoFrame res_i420_frame;
	int stride_y = 0;
	int stride_uv = 0;
	Calc16ByteAlignedStride(width_, &stride_y, &stride_uv);
	EXPECT_EQ(0,res_i420_frame.CreateEmptyFrame(width_, height_,
	stride_y, stride_uv, stride_uv));
	rtc::scoped_ptr<uint8_t[]> out_i420_buffer(new uint8_t[frame_length_]);
	EXPECT_EQ(0, ConvertFromI420(orig_frame_, kI420, 0,
	out_i420_buffer.get()));
	EXPECT_EQ(0, ConvertToI420(kI420, out_i420_buffer.get(), 0, 0,
	width_, height_,
	0, kRotateNone, &res_i420_frame));

	if (PrintI420VideoFrame(res_i420_frame, output_file) < 0) {
	return;
	}
	psnr = I420PSNR(&orig_frame_, &res_i420_frame);
	EXPECT_EQ(48.0, psnr);
	}


	TEST_F(TestLibYuv, RotateTest) {
	// Use ConvertToI420 for multiple roatations - see that nothing breaks, all
	// memory is properly allocated and end result is equal to the starting point.
	I420VideoFrame rotated_res_i420_frame;
	int rotated_width = height_;
	int rotated_height = width_;
	int stride_y ;
	int stride_uv;
	Calc16ByteAlignedStride(rotated_width, &stride_y, &stride_uv);
	EXPECT_EQ(0,rotated_res_i420_frame.CreateEmptyFrame(rotated_width,
	rotated_height,
	stride_y,
	stride_uv,
	stride_uv));
	EXPECT_EQ(0, ConvertToI420(kI420, orig_buffer_.get(), 0, 0,
	width_, height_,
	0, kRotate90, &rotated_res_i420_frame));
	EXPECT_EQ(0, ConvertToI420(kI420, orig_buffer_.get(), 0, 0,
	width_, height_,
	0, kRotate270, &rotated_res_i420_frame));
	EXPECT_EQ(0,rotated_res_i420_frame.CreateEmptyFrame(width_, height_,
	width_, (width_ + 1) / 2,
	(width_ + 1) / 2));
	EXPECT_EQ(0, ConvertToI420(kI420, orig_buffer_.get(), 0, 0,
	width_, height_,
	0, kRotate180, &rotated_res_i420_frame));
	}

	TEST_F(TestLibYuv, alignment) {
	int value = 0x3FF; // 1023
	EXPECT_EQ(0x400, AlignInt(value, 128)); // Low 7 bits are zero.
	EXPECT_EQ(0x400, AlignInt(value, 64)); // Low 6 bits are zero.
	EXPECT_EQ(0x400, AlignInt(value, 32)); // Low 5 bits are zero.
	}

	TEST_F(TestLibYuv, StrideAlignment) {
	int stride_y = 0;
	int stride_uv = 0;
	int width = 52;
	Calc16ByteAlignedStride(width, &stride_y, &stride_uv);
	EXPECT_EQ(64, stride_y);
	EXPECT_EQ(32, stride_uv);
	width = 128;
	Calc16ByteAlignedStride(width, &stride_y, &stride_uv);
	EXPECT_EQ(128, stride_y);
	EXPECT_EQ(64, stride_uv);
	width = 127;
	Calc16ByteAlignedStride(width, &stride_y, &stride_uv);
	EXPECT_EQ(128, stride_y);
	EXPECT_EQ(64, stride_uv);
	}

	} // namespace