src/common_video/libyuv/libyuv.cc - vendor/opensource/webrtc - Git at Google

 /*
  *  Copyright (c) 2011 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 "common_video/libyuv/include/libyuv.h"

 #include <assert.h>

 // LibYuv includes
 #ifdef WEBRTC_ANDROID
 #include "libyuv/files/include/libyuv.h"
 #else
 #include "third_party/libyuv/include/libyuv.h"
 #endif

 namespace webrtc {

 VideoType RawVideoTypeToCommonVideoVideoType(RawVideoType type) {
   switch (type) {
     case kVideoI420:
       return kI420;
     case kVideoIYUV:
       return kIYUV;
     case kVideoRGB24:
       return kRGB24;
     case kVideoARGB:
       return kARGB;
     case kVideoARGB4444:
       return kARGB4444;
     case kVideoRGB565:
       return kRGB565;
     case kVideoARGB1555:
       return kARGB1555;
     case kVideoYUY2:
       return kYUY2;
     case kVideoYV12:
       return kYV12;
     case kVideoUYVY:
       return kUYVY;
     case kVideoNV21:
       return kNV21;
     case kVideoNV12:
       return kNV12;
     case kVideoBGRA:
       return kBGRA;
     default:
       assert(false);
   }
   return kUnknown;
 }

 int CalcBufferSize(VideoType type, int width, int height) {
   int bits_per_pixel = 32;
   switch (type) {
     case kI420:
     case kNV12:
     case kNV21:
     case kIYUV:
     case kYV12:
       bits_per_pixel = 12;
       break;
     case kARGB4444:
     case kRGB565:
     case kARGB1555:
     case kYUY2:
     case kUYVY:
       bits_per_pixel = 16;
       break;
     case kRGB24:
       bits_per_pixel = 24;
       break;
     case kBGRA:
     case kARGB:
       bits_per_pixel = 32;
       break;
     default:
       assert(false);
       return -1;
   }
   return (width * height * bits_per_pixel) / 8;  // bytes
 }

 int CalcBufferSize(VideoType src_video_type,
                    VideoType dst_video_type,
                    int length) {
   int src_bits_per_pixel = 32;
   switch (src_video_type) {
     case kI420:
     case kNV12:
     case kNV21:
     case kIYUV:
     case kYV12:
       src_bits_per_pixel = 12;
       break;
     case kARGB4444:
     case kRGB565:
     case kARGB1555:
     case kYUY2:
     case kUYVY:
       src_bits_per_pixel = 16;
       break;
     case kRGB24:
       src_bits_per_pixel = 24;
       break;
     case kBGRA:
     case kARGB:
       src_bits_per_pixel = 32;
       break;
     default:
       assert(false);
       return -1;
   }

   int dst_bits_per_pixel = 32;
   switch (dst_video_type) {
     case kI420:
     case kIYUV:
     case kYV12:
       dst_bits_per_pixel = 12;
       break;
     case kARGB4444:
     case kRGB565:
     case kARGB1555:
     case kYUY2:
     case kUYVY:
       dst_bits_per_pixel = 16;
       break;
     case kRGB24:
       dst_bits_per_pixel = 24;
       break;
     case kBGRA:
     case kARGB:
       dst_bits_per_pixel = 32;
       break;
     default:
       assert(false);
       return -1;
   }
   return (length * dst_bits_per_pixel) / src_bits_per_pixel;
 }

 int ConvertI420ToARGB4444(const uint8_t* src_frame,
                           uint8_t* dst_frame,
                           int width, int height,
                           int dst_stride) {
   if (dst_stride == 0 || dst_stride == width)
     dst_stride = 2 * width;
   const uint8_t* yplane = src_frame;
   const uint8_t* uplane = src_frame + width * height;
   const uint8_t* vplane = uplane + (width * height / 4);

   return libyuv::I420ToARGB4444(yplane, width,
                                 uplane, width / 2,
                                 vplane, width / 2,
                                 dst_frame, dst_stride,
                                 width, height);
 }

 int ConvertI420ToRGB565(const uint8_t* src_frame,
                         uint8_t* dst_frame,
                         int width, int height) {
   int abs_height = (height < 0) ? -height : height;
   const uint8_t* yplane = src_frame;
   const uint8_t* uplane = src_frame + width * abs_height;
   const uint8_t* vplane = uplane + (width * abs_height / 4);

   return libyuv::I420ToRGB565(yplane, width,
                               uplane, width / 2,
                               vplane, width / 2,
                               dst_frame, width,
                               width, height);
 }

 int ConvertI420ToARGB1555(const uint8_t* src_frame,
                           uint8_t* dst_frame,
                           int width, int height,
                           int dst_stride) {
   if (dst_stride == 0 || dst_stride == width)
     dst_stride = 2 * width;
   else if (dst_stride < 2 * width)
     return -1;

   const uint8_t* yplane = src_frame;
   const uint8_t* uplane = src_frame + width * height;
   const uint8_t* vplane = uplane + (width * height / 4);

   return libyuv::I420ToARGB1555(yplane, width,
                                 uplane, width / 2,
                                 vplane, width / 2,
                                 dst_frame, dst_stride,
                                 width, height);
 }

 int ConvertNV12ToRGB565(const uint8_t* src_frame,
                         uint8_t* dst_frame,
                         int width, int height) {
   const uint8_t* yplane = src_frame;
   const uint8_t* uvInterlaced = src_frame + (width * height);

   return libyuv::NV12ToRGB565(yplane, width,
                               uvInterlaced, width / 2,
                               dst_frame, width,
                               width, height);
 }

 int ConvertRGB24ToARGB(const uint8_t* src_frame, uint8_t* dst_frame,
                        int width, int height, int dst_stride) {
   if (dst_stride == 0 || dst_stride == width)
     dst_stride = width;
   // Stride - currently webrtc style
   return libyuv::RGB24ToARGB(src_frame, width,
                              dst_frame, dst_stride,
                              width, height);
 }

 libyuv::RotationMode ConvertRotationMode(VideoRotationMode rotation) {
   switch(rotation) {
     case kRotateNone:
       return libyuv::kRotate0;
     case kRotate90:
       return libyuv::kRotate90;
     case kRotate180:
       return libyuv::kRotate180;
     case kRotate270:
       return libyuv::kRotate270;
     default:
       assert(false);
       return libyuv::kRotate0;
   }
 }

 int ConvertVideoType(VideoType video_type) {
   switch(video_type) {
     case kUnknown:
       return libyuv::FOURCC_ANY;
     case  kI420:
       return libyuv::FOURCC_I420;
     case kIYUV:  // same as KYV12
     case kYV12:
       return libyuv::FOURCC_YV12;
     case kRGB24:
       return libyuv::FOURCC_24BG;
     case kABGR:
       return libyuv::FOURCC_ABGR;
     case kARGB4444:
     case kRGB565:
     case kARGB1555:
       // TODO(mikhal): Not supported;
       assert(false);
       return libyuv::FOURCC_ANY;
     case kYUY2:
       return libyuv::FOURCC_YUY2;
     case kUYVY:
       return libyuv::FOURCC_UYVY;
     case kMJPG:
       return libyuv::FOURCC_MJPG;
     case kNV21:
       return libyuv::FOURCC_NV21;
     case kNV12:
       return libyuv::FOURCC_NV12;
     case kARGB:
       return libyuv::FOURCC_ARGB;
     case kBGRA:
       return libyuv::FOURCC_BGRA;
     default:
       assert(false);
       return libyuv::FOURCC_ANY;
   }
 }

 int ConvertToI420(VideoType src_video_type,
                   const uint8_t* src_frame,
                   int crop_x, int crop_y,
                   int src_width, int src_height,
                   int sample_size,
                   int dst_width, int dst_height, int dst_stride,
                   VideoRotationMode rotation,
                   uint8_t* dst_frame) {
   // All sanity tests are conducted within LibYuv.
   uint8_t* dst_yplane = dst_frame;
   uint8_t* dst_uplane = dst_yplane + dst_width * dst_height;
   uint8_t* dst_vplane = dst_uplane + (dst_width * dst_height / 4);
   return libyuv::ConvertToI420(src_frame, sample_size,
                                dst_yplane, dst_stride,
                                dst_uplane, (dst_stride + 1) / 2,
                                dst_vplane, (dst_stride + 1) / 2,
                                crop_x, crop_y,
                                src_width, src_height,
                                dst_width, dst_height,
                                ConvertRotationMode(rotation),
                                ConvertVideoType(src_video_type));
 }

 int ConvertFromI420(const uint8_t* src_frame, int src_stride,
                     VideoType dst_video_type, int dst_sample_size,
                     int width, int height,
                     uint8_t* dst_frame) {
   const uint8_t* src_yplane = src_frame;
   const uint8_t* src_uplane = src_yplane + width * height;
   const uint8_t* src_vplane = src_uplane + (width * height / 4);
   return libyuv::ConvertFromI420(src_yplane, src_stride,
                                  src_uplane, (src_stride + 1) / 2,
                                  src_vplane, (src_stride + 1) / 2,
                                  dst_frame, dst_sample_size,
                                  width, height,
                                  ConvertVideoType(dst_video_type));
 }

 int ConvertFromYV12(const uint8_t* src_frame, int src_stride,
                     VideoType dst_video_type, int dst_sample_size,
                     int width, int height,
                     uint8_t* dst_frame) {
   const uint8_t* src_yplane = src_frame;
   const uint8_t* src_uplane = src_yplane + width * height;
   const uint8_t* src_vplane = src_uplane + (width * height / 4);
   // YV12 = Y, V, U
   return libyuv::ConvertFromI420(src_yplane, src_stride,
                                  src_vplane, (src_stride + 1) / 2,
                                  src_uplane, (src_stride + 1) / 2,
                                  dst_frame, dst_sample_size,
                                  width, height,
                                  ConvertVideoType(dst_video_type));
 }

 int MirrorI420LeftRight(const uint8_t* src_frame,
                         uint8_t* dst_frame,
                         int width, int height) {
   const uint8_t* src_yplane = src_frame;
   const uint8_t* src_uplane = src_yplane + width * height;
   const uint8_t* src_vplane = src_uplane + (width * height / 4);
   uint8_t* dst_yplane = dst_frame;
   uint8_t* dst_uplane = dst_yplane + width * height;
   uint8_t* dst_vplane = dst_uplane + (width * height / 4);
   return libyuv::I420Mirror(src_yplane, width,
                             src_uplane, width / 2,
                             src_vplane, width / 2,
                             dst_yplane, width,
                             dst_uplane, width / 2,
                             dst_vplane, width / 2,
                             width, height);
 }

 int MirrorI420UpDown(const uint8_t* src_frame, uint8_t* dst_frame,
                      int width, int height) {
   const uint8_t* src_yplane = src_frame;
   const uint8_t* src_uplane = src_frame + width * height;
   const uint8_t* src_vplane = src_uplane + (width * height / 4);
   uint8_t* dst_yplane = dst_frame;
   uint8_t* dst_uplane = dst_frame + width * height;
   uint8_t* dst_vplane = dst_uplane + (width * height / 4);

   // Inserting negative height flips the frame.
   return libyuv::I420Copy(src_yplane, width,
                           src_uplane, width / 2,
                           src_vplane, width / 2,
                           dst_yplane, width,
                           dst_uplane, width / 2,
                           dst_vplane, width / 2,
                           width, -height);
 }

 int ConvertToI420AndMirrorUpDown(const uint8_t* src_frame,
                                  uint8_t* dst_frame,
                                  int src_width, int src_height,
                                  VideoType src_video_type) {
   if (src_video_type != kI420 && src_video_type != kYV12)
     return -1;
   // TODO(mikhal): Use a more general convert function - with negative height
   // Inserting negative height flips the frame.
   // Using I420Copy with a negative height.
   const uint8_t* src_yplane = src_frame;
   const uint8_t* src_uplane = src_frame + src_width * src_height;
   const uint8_t* src_vplane = src_uplane + (src_width * src_height / 4);
   uint8_t* dst_yplane = dst_frame;
   uint8_t* dst_uplane = dst_frame + src_width * src_height;
   uint8_t* dst_vplane = dst_uplane + (src_width * src_height / 4);
   if (src_video_type == kYV12) {
     // Switch U and V
     dst_vplane = dst_frame + src_width * src_height;
     dst_uplane = dst_vplane + (src_width * src_height / 4);
   }
   // Inserting negative height flips the frame.
   return libyuv::I420Copy(src_yplane, src_width,
                           src_uplane, src_width / 2,
                           src_vplane, src_width / 2,
                           dst_yplane, src_width,
                           dst_uplane, src_width / 2,
                           dst_vplane, src_width / 2,
                           src_width, -src_height);
 }

 // Compute PSNR for an I420 frame (all planes)
 double I420PSNR(const uint8_t* ref_frame,
                 const uint8_t* test_frame,
                 int width, int height) {
   if (!ref_frame || !test_frame)
     return -1;
   else if (height < 0 || width < 0)
     return -1;
   const uint8_t* src_y_a = ref_frame;
   const uint8_t* src_u_a = src_y_a + width * height;
   const uint8_t* src_v_a = src_u_a + (width * height / 4);
   const uint8_t* src_y_b = test_frame;
   const uint8_t* src_u_b = src_y_b + width * height;
   const uint8_t* src_v_b = src_u_b + (width * height / 4);
   int stride_y = width;
   int stride_uv = (width + 1) / 2;
   double psnr = libyuv::I420Psnr(src_y_a, stride_y,
                                  src_u_a, stride_uv,
                                  src_v_a, stride_uv,
                                  src_y_b, stride_y,
                                  src_u_b, stride_uv,
                                  src_v_b, stride_uv,
                                  width, height);
   // LibYuv sets the max psnr value to 128, we restrict it to 48.
   // In case of 0 mse in one frame, 128 can skew the results significantly.
   return (psnr > 48.0) ? 48.0 : psnr;
 }
 // Compute SSIM for an I420 frame (all planes)
 double I420SSIM(const uint8_t* ref_frame,
                 const uint8_t* test_frame,
                 int width, int height) {
   if (!ref_frame || !test_frame)
      return -1;
   else if (height < 0 || width < 0)
      return -1;
   const uint8_t* src_y_a = ref_frame;
   const uint8_t* src_u_a = src_y_a + width * height;
   const uint8_t* src_v_a = src_u_a + (width * height / 4);
   const uint8_t* src_y_b = test_frame;
   const uint8_t* src_u_b = src_y_b + width * height;
   const uint8_t* src_v_b = src_u_b + (width * height / 4);
   int stride_y = width;
   int stride_uv = (width + 1) / 2;
   return libyuv::I420Ssim(src_y_a, stride_y,
                           src_u_a, stride_uv,
                           src_v_a, stride_uv,
                           src_y_b, stride_y,
                           src_u_b, stride_uv,
                           src_v_b, stride_uv,
                           width, height);
 }

 }  // namespace webrtc
	/*
	* Copyright (c) 2011 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 "common_video/libyuv/include/libyuv.h"

	#include <assert.h>

	// LibYuv includes
	#ifdef WEBRTC_ANDROID
	#include "libyuv/files/include/libyuv.h"
	#else
	#include "third_party/libyuv/include/libyuv.h"
	#endif

	namespace webrtc {

	VideoType RawVideoTypeToCommonVideoVideoType(RawVideoType type) {
	switch (type) {
	case kVideoI420:
	return kI420;
	case kVideoIYUV:
	return kIYUV;
	case kVideoRGB24:
	return kRGB24;
	case kVideoARGB:
	return kARGB;
	case kVideoARGB4444:
	return kARGB4444;
	case kVideoRGB565:
	return kRGB565;
	case kVideoARGB1555:
	return kARGB1555;
	case kVideoYUY2:
	return kYUY2;
	case kVideoYV12:
	return kYV12;
	case kVideoUYVY:
	return kUYVY;
	case kVideoNV21:
	return kNV21;
	case kVideoNV12:
	return kNV12;
	case kVideoBGRA:
	return kBGRA;
	default:
	assert(false);
	}
	return kUnknown;
	}

	int CalcBufferSize(VideoType type, int width, int height) {
	int bits_per_pixel = 32;
	switch (type) {
	case kI420:
	case kNV12:
	case kNV21:
	case kIYUV:
	case kYV12:
	bits_per_pixel = 12;
	break;
	case kARGB4444:
	case kRGB565:
	case kARGB1555:
	case kYUY2:
	case kUYVY:
	bits_per_pixel = 16;
	break;
	case kRGB24:
	bits_per_pixel = 24;
	break;
	case kBGRA:
	case kARGB:
	bits_per_pixel = 32;
	break;
	default:
	assert(false);
	return -1;
	}
	return (width * height * bits_per_pixel) / 8; // bytes
	}

	int CalcBufferSize(VideoType src_video_type,
	VideoType dst_video_type,
	int length) {
	int src_bits_per_pixel = 32;
	switch (src_video_type) {
	case kI420:
	case kNV12:
	case kNV21:
	case kIYUV:
	case kYV12:
	src_bits_per_pixel = 12;
	break;
	case kARGB4444:
	case kRGB565:
	case kARGB1555:
	case kYUY2:
	case kUYVY:
	src_bits_per_pixel = 16;
	break;
	case kRGB24:
	src_bits_per_pixel = 24;
	break;
	case kBGRA:
	case kARGB:
	src_bits_per_pixel = 32;
	break;
	default:
	assert(false);
	return -1;
	}

	int dst_bits_per_pixel = 32;
	switch (dst_video_type) {
	case kI420:
	case kIYUV:
	case kYV12:
	dst_bits_per_pixel = 12;
	break;
	case kARGB4444:
	case kRGB565:
	case kARGB1555:
	case kYUY2:
	case kUYVY:
	dst_bits_per_pixel = 16;
	break;
	case kRGB24:
	dst_bits_per_pixel = 24;
	break;
	case kBGRA:
	case kARGB:
	dst_bits_per_pixel = 32;
	break;
	default:
	assert(false);
	return -1;
	}
	return (length * dst_bits_per_pixel) / src_bits_per_pixel;
	}

	int ConvertI420ToARGB4444(const uint8_t* src_frame,
	uint8_t* dst_frame,
	int width, int height,
	int dst_stride) {
	if (dst_stride == 0 \|\| dst_stride == width)
	dst_stride = 2 * width;
	const uint8_t* yplane = src_frame;
	const uint8_t* uplane = src_frame + width * height;
	const uint8_t* vplane = uplane + (width * height / 4);

	return libyuv::I420ToARGB4444(yplane, width,
	uplane, width / 2,
	vplane, width / 2,
	dst_frame, dst_stride,
	width, height);
	}

	int ConvertI420ToRGB565(const uint8_t* src_frame,
	uint8_t* dst_frame,
	int width, int height) {
	int abs_height = (height < 0) ? -height : height;
	const uint8_t* yplane = src_frame;
	const uint8_t* uplane = src_frame + width * abs_height;
	const uint8_t* vplane = uplane + (width * abs_height / 4);

	return libyuv::I420ToRGB565(yplane, width,
	uplane, width / 2,
	vplane, width / 2,
	dst_frame, width,
	width, height);
	}

	int ConvertI420ToARGB1555(const uint8_t* src_frame,
	uint8_t* dst_frame,
	int width, int height,
	int dst_stride) {
	if (dst_stride == 0 \|\| dst_stride == width)
	dst_stride = 2 * width;
	else if (dst_stride < 2 * width)
	return -1;

	const uint8_t* yplane = src_frame;
	const uint8_t* uplane = src_frame + width * height;
	const uint8_t* vplane = uplane + (width * height / 4);

	return libyuv::I420ToARGB1555(yplane, width,
	uplane, width / 2,
	vplane, width / 2,
	dst_frame, dst_stride,
	width, height);
	}

	int ConvertNV12ToRGB565(const uint8_t* src_frame,
	uint8_t* dst_frame,
	int width, int height) {
	const uint8_t* yplane = src_frame;
	const uint8_t* uvInterlaced = src_frame + (width * height);

	return libyuv::NV12ToRGB565(yplane, width,
	uvInterlaced, width / 2,
	dst_frame, width,
	width, height);
	}

	int ConvertRGB24ToARGB(const uint8_t* src_frame, uint8_t* dst_frame,
	int width, int height, int dst_stride) {
	if (dst_stride == 0 \|\| dst_stride == width)
	dst_stride = width;
	// Stride - currently webrtc style
	return libyuv::RGB24ToARGB(src_frame, width,
	dst_frame, dst_stride,
	width, height);
	}

	libyuv::RotationMode ConvertRotationMode(VideoRotationMode rotation) {
	switch(rotation) {
	case kRotateNone:
	return libyuv::kRotate0;
	case kRotate90:
	return libyuv::kRotate90;
	case kRotate180:
	return libyuv::kRotate180;
	case kRotate270:
	return libyuv::kRotate270;
	default:
	assert(false);
	return libyuv::kRotate0;
	}
	}

	int ConvertVideoType(VideoType video_type) {
	switch(video_type) {
	case kUnknown:
	return libyuv::FOURCC_ANY;
	case kI420:
	return libyuv::FOURCC_I420;
	case kIYUV: // same as KYV12
	case kYV12:
	return libyuv::FOURCC_YV12;
	case kRGB24:
	return libyuv::FOURCC_24BG;
	case kABGR:
	return libyuv::FOURCC_ABGR;
	case kARGB4444:
	case kRGB565:
	case kARGB1555:
	// TODO(mikhal): Not supported;
	assert(false);
	return libyuv::FOURCC_ANY;
	case kYUY2:
	return libyuv::FOURCC_YUY2;
	case kUYVY:
	return libyuv::FOURCC_UYVY;
	case kMJPG:
	return libyuv::FOURCC_MJPG;
	case kNV21:
	return libyuv::FOURCC_NV21;
	case kNV12:
	return libyuv::FOURCC_NV12;
	case kARGB:
	return libyuv::FOURCC_ARGB;
	case kBGRA:
	return libyuv::FOURCC_BGRA;
	default:
	assert(false);
	return libyuv::FOURCC_ANY;
	}
	}

	int ConvertToI420(VideoType src_video_type,
	const uint8_t* src_frame,
	int crop_x, int crop_y,
	int src_width, int src_height,
	int sample_size,
	int dst_width, int dst_height, int dst_stride,
	VideoRotationMode rotation,
	uint8_t* dst_frame) {
	// All sanity tests are conducted within LibYuv.
	uint8_t* dst_yplane = dst_frame;
	uint8_t* dst_uplane = dst_yplane + dst_width * dst_height;
	uint8_t* dst_vplane = dst_uplane + (dst_width * dst_height / 4);
	return libyuv::ConvertToI420(src_frame, sample_size,
	dst_yplane, dst_stride,
	dst_uplane, (dst_stride + 1) / 2,
	dst_vplane, (dst_stride + 1) / 2,
	crop_x, crop_y,
	src_width, src_height,
	dst_width, dst_height,
	ConvertRotationMode(rotation),
	ConvertVideoType(src_video_type));
	}

	int ConvertFromI420(const uint8_t* src_frame, int src_stride,
	VideoType dst_video_type, int dst_sample_size,
	int width, int height,
	uint8_t* dst_frame) {
	const uint8_t* src_yplane = src_frame;
	const uint8_t* src_uplane = src_yplane + width * height;
	const uint8_t* src_vplane = src_uplane + (width * height / 4);
	return libyuv::ConvertFromI420(src_yplane, src_stride,
	src_uplane, (src_stride + 1) / 2,
	src_vplane, (src_stride + 1) / 2,
	dst_frame, dst_sample_size,
	width, height,
	ConvertVideoType(dst_video_type));
	}

	int ConvertFromYV12(const uint8_t* src_frame, int src_stride,
	VideoType dst_video_type, int dst_sample_size,
	int width, int height,
	uint8_t* dst_frame) {
	const uint8_t* src_yplane = src_frame;
	const uint8_t* src_uplane = src_yplane + width * height;
	const uint8_t* src_vplane = src_uplane + (width * height / 4);
	// YV12 = Y, V, U
	return libyuv::ConvertFromI420(src_yplane, src_stride,
	src_vplane, (src_stride + 1) / 2,
	src_uplane, (src_stride + 1) / 2,
	dst_frame, dst_sample_size,
	width, height,
	ConvertVideoType(dst_video_type));
	}

	int MirrorI420LeftRight(const uint8_t* src_frame,
	uint8_t* dst_frame,
	int width, int height) {
	const uint8_t* src_yplane = src_frame;
	const uint8_t* src_uplane = src_yplane + width * height;
	const uint8_t* src_vplane = src_uplane + (width * height / 4);
	uint8_t* dst_yplane = dst_frame;
	uint8_t* dst_uplane = dst_yplane + width * height;
	uint8_t* dst_vplane = dst_uplane + (width * height / 4);
	return libyuv::I420Mirror(src_yplane, width,
	src_uplane, width / 2,
	src_vplane, width / 2,
	dst_yplane, width,
	dst_uplane, width / 2,
	dst_vplane, width / 2,
	width, height);
	}

	int MirrorI420UpDown(const uint8_t* src_frame, uint8_t* dst_frame,
	int width, int height) {
	const uint8_t* src_yplane = src_frame;
	const uint8_t* src_uplane = src_frame + width * height;
	const uint8_t* src_vplane = src_uplane + (width * height / 4);
	uint8_t* dst_yplane = dst_frame;
	uint8_t* dst_uplane = dst_frame + width * height;
	uint8_t* dst_vplane = dst_uplane + (width * height / 4);

	// Inserting negative height flips the frame.
	return libyuv::I420Copy(src_yplane, width,
	src_uplane, width / 2,
	src_vplane, width / 2,
	dst_yplane, width,
	dst_uplane, width / 2,
	dst_vplane, width / 2,
	width, -height);
	}

	int ConvertToI420AndMirrorUpDown(const uint8_t* src_frame,
	uint8_t* dst_frame,
	int src_width, int src_height,
	VideoType src_video_type) {
	if (src_video_type != kI420 && src_video_type != kYV12)
	return -1;
	// TODO(mikhal): Use a more general convert function - with negative height
	// Inserting negative height flips the frame.
	// Using I420Copy with a negative height.
	const uint8_t* src_yplane = src_frame;
	const uint8_t* src_uplane = src_frame + src_width * src_height;
	const uint8_t* src_vplane = src_uplane + (src_width * src_height / 4);
	uint8_t* dst_yplane = dst_frame;
	uint8_t* dst_uplane = dst_frame + src_width * src_height;
	uint8_t* dst_vplane = dst_uplane + (src_width * src_height / 4);
	if (src_video_type == kYV12) {
	// Switch U and V
	dst_vplane = dst_frame + src_width * src_height;
	dst_uplane = dst_vplane + (src_width * src_height / 4);
	}
	// Inserting negative height flips the frame.
	return libyuv::I420Copy(src_yplane, src_width,
	src_uplane, src_width / 2,
	src_vplane, src_width / 2,
	dst_yplane, src_width,
	dst_uplane, src_width / 2,
	dst_vplane, src_width / 2,
	src_width, -src_height);
	}

	// Compute PSNR for an I420 frame (all planes)
	double I420PSNR(const uint8_t* ref_frame,
	const uint8_t* test_frame,
	int width, int height) {
	if (!ref_frame \|\| !test_frame)
	return -1;
	else if (height < 0 \|\| width < 0)
	return -1;
	const uint8_t* src_y_a = ref_frame;
	const uint8_t* src_u_a = src_y_a + width * height;
	const uint8_t* src_v_a = src_u_a + (width * height / 4);
	const uint8_t* src_y_b = test_frame;
	const uint8_t* src_u_b = src_y_b + width * height;
	const uint8_t* src_v_b = src_u_b + (width * height / 4);
	int stride_y = width;
	int stride_uv = (width + 1) / 2;
	double psnr = libyuv::I420Psnr(src_y_a, stride_y,
	src_u_a, stride_uv,
	src_v_a, stride_uv,
	src_y_b, stride_y,
	src_u_b, stride_uv,
	src_v_b, stride_uv,
	width, height);
	// LibYuv sets the max psnr value to 128, we restrict it to 48.
	// In case of 0 mse in one frame, 128 can skew the results significantly.
	return (psnr > 48.0) ? 48.0 : psnr;
	}
	// Compute SSIM for an I420 frame (all planes)
	double I420SSIM(const uint8_t* ref_frame,
	const uint8_t* test_frame,
	int width, int height) {
	if (!ref_frame \|\| !test_frame)
	return -1;
	else if (height < 0 \|\| width < 0)
	return -1;
	const uint8_t* src_y_a = ref_frame;
	const uint8_t* src_u_a = src_y_a + width * height;
	const uint8_t* src_v_a = src_u_a + (width * height / 4);
	const uint8_t* src_y_b = test_frame;
	const uint8_t* src_u_b = src_y_b + width * height;
	const uint8_t* src_v_b = src_u_b + (width * height / 4);
	int stride_y = width;
	int stride_uv = (width + 1) / 2;
	return libyuv::I420Ssim(src_y_a, stride_y,
	src_u_a, stride_uv,
	src_v_a, stride_uv,
	src_y_b, stride_y,
	src_u_b, stride_uv,
	src_v_b, stride_uv,
	width, height);
	}

	} // namespace webrtc