Update I420Buffer to new VideoFrameBuffer interface

webrtc/common_video/libyuv/webrtc_libyuv.cc

 /*
  *  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.
  */
 
@@ skipping 52 matching lines @@
                       int stride,
                       FILE* file) {
   for (int i = 0; i < height; i++, buf += stride) {
     if (fwrite(buf, 1, width, file) != static_cast<unsigned int>(width))
       return -1;
   }
   return 0;
 }
 
 // TODO(nisse): Belongs with the test code?
-int PrintVideoFrame(const VideoFrameBuffer& frame, FILE* file) {
+int PrintVideoFrame(const I420BufferInterface& frame, FILE* file) {
   int width = frame.width();
   int height = frame.height();
-  int chroma_width = (width + 1) / 2;
-  int chroma_height = (height + 1) / 2;
+  int chroma_width = frame.ChromaWidth();
+  int chroma_height = frame.ChromaHeight();
 
   if (PrintPlane(frame.DataY(), width, height,
                  frame.StrideY(), file) < 0) {
     return -1;
   }
   if (PrintPlane(frame.DataU(),
                  chroma_width, chroma_height,
                  frame.StrideU(), file) < 0) {
     return -1;
   }
   if (PrintPlane(frame.DataV(),
                  chroma_width, chroma_height,
                  frame.StrideV(), file) < 0) {
     return -1;
   }
   return 0;
 }
 
 int PrintVideoFrame(const VideoFrame& frame, FILE* file) {
-  return PrintVideoFrame(*frame.video_frame_buffer(), file);
+  return PrintVideoFrame(*frame.video_frame_buffer()->ToI420(), file);
 }
 
-int ExtractBuffer(const rtc::scoped_refptr<VideoFrameBuffer>& input_frame,
+int ExtractBuffer(const rtc::scoped_refptr<I420BufferInterface>& input_frame,
                   size_t size,
                   uint8_t* buffer) {
   RTC_DCHECK(buffer);
   if (!input_frame)
     return -1;
   int width = input_frame->width();
   int height = input_frame->height();
   size_t length = CalcBufferSize(VideoType::kI420, width, height);
   if (size < length) {
      return -1;
   }
 
-  int chroma_width = (width + 1) / 2;
-  int chroma_height = (height + 1) / 2;
+  int chroma_width = input_frame->ChromaWidth();
+  int chroma_height = input_frame->ChromaHeight();
 
   libyuv::I420Copy(input_frame->DataY(),
                    input_frame->StrideY(),
                    input_frame->DataU(),
                    input_frame->StrideU(),
                    input_frame->DataV(),
                    input_frame->StrideV(),
                    buffer, width,
                    buffer + width*height, chroma_width,
                    buffer + width*height + chroma_width*chroma_height,
                    chroma_width,
                    width, height);
 
   return static_cast<int>(length);
 }
 
 int ExtractBuffer(const VideoFrame& input_frame, size_t size, uint8_t* buffer) {
-  return ExtractBuffer(input_frame.video_frame_buffer(), size, buffer);
+  return ExtractBuffer(input_frame.video_frame_buffer()->ToI420(), size,
+                       buffer);
 }
 
 int ConvertNV12ToRGB565(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* uvInterlaced = src_frame + (width * abs_height);
 
   return libyuv::NV12ToRGB565(yplane, width,
@@ skipping 90 matching lines @@
       src_width, src_height,
       dst_width, dst_height,
       ConvertRotationMode(rotation),
       ConvertVideoType(src_video_type));
 }
 
 int ConvertFromI420(const VideoFrame& src_frame,
                     VideoType dst_video_type,
                     int dst_sample_size,
                     uint8_t* dst_frame) {
+  rtc::scoped_refptr<I420BufferInterface> i420_buffer =
+      src_frame.video_frame_buffer()->ToI420();
   return libyuv::ConvertFromI420(
-      src_frame.video_frame_buffer()->DataY(),
-      src_frame.video_frame_buffer()->StrideY(),
-      src_frame.video_frame_buffer()->DataU(),
-      src_frame.video_frame_buffer()->StrideU(),
-      src_frame.video_frame_buffer()->DataV(),
-      src_frame.video_frame_buffer()->StrideV(),
-      dst_frame, dst_sample_size,
-      src_frame.width(), src_frame.height(),
+      i420_buffer->DataY(), i420_buffer->StrideY(), i420_buffer->DataU(),
+      i420_buffer->StrideU(), i420_buffer->DataV(), i420_buffer->StrideV(),
+      dst_frame, dst_sample_size, src_frame.width(), src_frame.height(),
       ConvertVideoType(dst_video_type));
 }
 
 // Compute PSNR for an I420 frame (all planes). Can upscale test frame.
-double I420PSNR(const VideoFrameBuffer& ref_buffer,
-                const VideoFrameBuffer& test_buffer) {
+double I420PSNR(const I420BufferInterface& ref_buffer,
+                const I420BufferInterface& test_buffer) {
   RTC_DCHECK_GE(ref_buffer.width(), test_buffer.width());
   RTC_DCHECK_GE(ref_buffer.height(), test_buffer.height());
   if ((ref_buffer.width() != test_buffer.width()) ||
       (ref_buffer.height() != test_buffer.height())) {
     rtc::scoped_refptr<I420Buffer> scaled_buffer =
         I420Buffer::Create(ref_buffer.width(), ref_buffer.height());
     scaled_buffer->ScaleFrom(test_buffer);
     return I420PSNR(ref_buffer, *scaled_buffer);
   }
   double psnr = libyuv::I420Psnr(
       ref_buffer.DataY(), ref_buffer.StrideY(), ref_buffer.DataU(),
       ref_buffer.StrideU(), ref_buffer.DataV(), ref_buffer.StrideV(),
       test_buffer.DataY(), test_buffer.StrideY(), test_buffer.DataU(),
       test_buffer.StrideU(), test_buffer.DataV(), test_buffer.StrideV(),
       test_buffer.width(), test_buffer.height());
   // LibYuv sets the max psnr value to 128, we restrict it here.
   // In case of 0 mse in one frame, 128 can skew the results significantly.
   return (psnr > kPerfectPSNR) ? kPerfectPSNR : psnr;
 }
 
 // Compute PSNR for an I420 frame (all planes)
 double I420PSNR(const VideoFrame* ref_frame, const VideoFrame* test_frame) {
   if (!ref_frame || !test_frame)
     return -1;
-  return I420PSNR(*ref_frame->video_frame_buffer(),
-                  *test_frame->video_frame_buffer());
+  return I420PSNR(*ref_frame->video_frame_buffer()->ToI420(),
+                  *test_frame->video_frame_buffer()->ToI420());
 }
 
 // Compute SSIM for an I420 frame (all planes). Can upscale test_buffer.
-double I420SSIM(const VideoFrameBuffer& ref_buffer,
-                const VideoFrameBuffer& test_buffer) {
+double I420SSIM(const I420BufferInterface& ref_buffer,
+                const I420BufferInterface& test_buffer) {
   RTC_DCHECK_GE(ref_buffer.width(), test_buffer.width());
   RTC_DCHECK_GE(ref_buffer.height(), test_buffer.height());
   if ((ref_buffer.width() != test_buffer.width()) ||
       (ref_buffer.height() != test_buffer.height())) {
     rtc::scoped_refptr<I420Buffer> scaled_buffer =
         I420Buffer::Create(ref_buffer.width(), ref_buffer.height());
     scaled_buffer->ScaleFrom(test_buffer);
     return I420SSIM(ref_buffer, *scaled_buffer);
   }
   return libyuv::I420Ssim(
       ref_buffer.DataY(), ref_buffer.StrideY(), ref_buffer.DataU(),
       ref_buffer.StrideU(), ref_buffer.DataV(), ref_buffer.StrideV(),
       test_buffer.DataY(), test_buffer.StrideY(), test_buffer.DataU(),
       test_buffer.StrideU(), test_buffer.DataV(), test_buffer.StrideV(),
       test_buffer.width(), test_buffer.height());
 }
 double I420SSIM(const VideoFrame* ref_frame, const VideoFrame* test_frame) {
   if (!ref_frame || !test_frame)
     return -1;
-  return I420SSIM(*ref_frame->video_frame_buffer(),
-                  *test_frame->video_frame_buffer());
+  return I420SSIM(*ref_frame->video_frame_buffer()->ToI420(),
+                  *test_frame->video_frame_buffer()->ToI420());
 }
 
 void NV12Scale(std::vector<uint8_t>* tmp_buffer,
                const uint8_t* src_y, int src_stride_y,
                const uint8_t* src_uv, int src_stride_uv,
                int src_width, int src_height,
                uint8_t* dst_y, int dst_stride_y,
                uint8_t* dst_uv, int dst_stride_uv,
                int dst_width, int dst_height) {
   const int src_chroma_width = (src_width + 1) / 2;
@@ skipping 93 matching lines @@
                     src_v, src_uv_width,
                     src_width, src_height,
                     dst_y, dst_stride_y,
                     dst_u, dst_stride_u,
                     dst_v, dst_stride_v,
                     dst_width, dst_height,
                     libyuv::kFilterBox);
 }
 
 }  // namespace webrtc