Revert of Delete webrtc::VideoFrame methods buffer and stride.

webrtc/common_video/video_frame.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 51 matching lines @@
   // Creating empty frame - reset all values.
   timestamp_ = 0;
   ntp_time_ms_ = 0;
   render_time_ms_ = 0;
   rotation_ = kVideoRotation_0;
 
   // Check if it's safe to reuse allocation.
   if (video_frame_buffer_ && video_frame_buffer_->IsMutable() &&
       !video_frame_buffer_->native_handle() &&
       width == video_frame_buffer_->width() &&
-      height == video_frame_buffer_->height() &&
-      stride_y == video_frame_buffer_->StrideY() &&
-      stride_u == video_frame_buffer_->StrideU() &&
-      stride_v == video_frame_buffer_->StrideV()) {
+      height == video_frame_buffer_->height() && stride_y == stride(kYPlane) &&
+      stride_u == stride(kUPlane) && stride_v == stride(kVPlane)) {
     return;
   }
 
   // Need to allocate new buffer.
   video_frame_buffer_ = new rtc::RefCountedObject<I420Buffer>(
       width, height, stride_y, stride_u, stride_v);
 }
 
 void VideoFrame::CreateFrame(const uint8_t* buffer_y,
                              const uint8_t* buffer_u,
                              const uint8_t* buffer_v,
                              int width,
                              int height,
                              int stride_y,
                              int stride_u,
                              int stride_v,
                              VideoRotation rotation) {
   const int half_height = (height + 1) / 2;
   const int expected_size_y = height * stride_y;
   const int expected_size_u = half_height * stride_u;
   const int expected_size_v = half_height * stride_v;
   CreateEmptyFrame(width, height, stride_y, stride_u, stride_v);
-  memcpy(video_frame_buffer_->MutableDataY(), buffer_y, expected_size_y);
-  memcpy(video_frame_buffer_->MutableDataU(), buffer_u, expected_size_u);
-  memcpy(video_frame_buffer_->MutableDataV(), buffer_v, expected_size_v);
+  memcpy(buffer(kYPlane), buffer_y, expected_size_y);
+  memcpy(buffer(kUPlane), buffer_u, expected_size_u);
+  memcpy(buffer(kVPlane), buffer_v, expected_size_v);
   rotation_ = rotation;
 }
 
 void VideoFrame::CreateFrame(const uint8_t* buffer,
                              int width,
                              int height,
                              VideoRotation rotation) {
   const int stride_y = width;
   const int stride_uv = (width + 1) / 2;
 
@@ skipping 14 matching lines @@
 }
 
 void VideoFrame::ShallowCopy(const VideoFrame& videoFrame) {
   video_frame_buffer_ = videoFrame.video_frame_buffer();
   timestamp_ = videoFrame.timestamp_;
   ntp_time_ms_ = videoFrame.ntp_time_ms_;
   render_time_ms_ = videoFrame.render_time_ms_;
   rotation_ = videoFrame.rotation_;
 }
 
-// TODO(nisse): Delete. Besides test code, only one use, in
-// webrtcvideoengine2.cc:CreateBlackFrame.
+uint8_t* VideoFrame::buffer(PlaneType type) {
+  return video_frame_buffer_ ? video_frame_buffer_->MutableData(type)
+                             : nullptr;
+}
+
+const uint8_t* VideoFrame::buffer(PlaneType type) const {
+  return video_frame_buffer_ ? video_frame_buffer_->data(type) : nullptr;
+}
+
 int VideoFrame::allocated_size(PlaneType type) const {
   const int plane_height = (type == kYPlane) ? height() : (height() + 1) / 2;
-  int stride;
-  switch (type) {
-    case kYPlane:
-      stride = video_frame_buffer_->StrideY();
-      break;
-    case kUPlane:
-      stride = video_frame_buffer_->StrideU();
-      break;
-    case kVPlane:
-      stride = video_frame_buffer_->StrideV();
-      break;
-    default:
-      RTC_NOTREACHED();
-      return 0;
-  }
-  return plane_height * stride;
+  return plane_height * stride(type);
+}
+
+int VideoFrame::stride(PlaneType type) const {
+  return video_frame_buffer_ ? video_frame_buffer_->stride(type) : 0;
 }
 
 int VideoFrame::width() const {
   return video_frame_buffer_ ? video_frame_buffer_->width() : 0;
 }
 
 int VideoFrame::height() const {
   return video_frame_buffer_ ? video_frame_buffer_->height() : 0;
 }
 
 bool VideoFrame::IsZeroSize() const {
   return !video_frame_buffer_;
 }
 
-const rtc::scoped_refptr<VideoFrameBuffer>& VideoFrame::video_frame_buffer()
-    const {
+rtc::scoped_refptr<VideoFrameBuffer> VideoFrame::video_frame_buffer() const {
   return video_frame_buffer_;
 }
 
 void VideoFrame::set_video_frame_buffer(
     const rtc::scoped_refptr<webrtc::VideoFrameBuffer>& buffer) {
   video_frame_buffer_ = buffer;
 }
 
 VideoFrame VideoFrame::ConvertNativeToI420Frame() const {
   RTC_DCHECK(video_frame_buffer_->native_handle());
@@ skipping 15 matching lines @@
     case kVideoCodecULPFEC:
     case kVideoCodecGeneric:
     case kVideoCodecUnknown:
       return 0;
   }
   RTC_NOTREACHED();
   return 0;
 }
 
 }  // namespace webrtc