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

webrtc/modules/video_coding/codecs/h264/h264_decoder_impl.cc

 /*
  *  Copyright (c) 2015 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 111 matching lines @@
   }
 
   // The video frame is stored in |video_frame|. |av_frame| is FFmpeg's version
   // of a video frame and will be set up to reference |video_frame|'s buffers.
   VideoFrame* video_frame = new VideoFrame();
   // FFmpeg expects the initial allocation to be zero-initialized according to
   // http://crbug.com/390941. Our pool is set up to zero-initialize new buffers.
   video_frame->set_video_frame_buffer(
       decoder->pool_.CreateBuffer(width, height));
   // DCHECK that we have a continuous buffer as is required.
-  RTC_DCHECK_EQ(video_frame->video_frame_buffer()->DataU(),
-                video_frame->video_frame_buffer()->DataY() +
-                video_frame->allocated_size(kYPlane));
-  RTC_DCHECK_EQ(video_frame->video_frame_buffer()->DataV(),
-                video_frame->video_frame_buffer()->DataU() +
-                video_frame->allocated_size(kUPlane));
+  RTC_DCHECK_EQ(video_frame->buffer(kUPlane),
+      video_frame->buffer(kYPlane) + video_frame->allocated_size(kYPlane));
+  RTC_DCHECK_EQ(video_frame->buffer(kVPlane),
+      video_frame->buffer(kUPlane) + video_frame->allocated_size(kUPlane));
   int total_size = video_frame->allocated_size(kYPlane) +
                    video_frame->allocated_size(kUPlane) +
                    video_frame->allocated_size(kVPlane);
 
   av_frame->format = context->pix_fmt;
   av_frame->reordered_opaque = context->reordered_opaque;
 
   // Set |av_frame| members as required by FFmpeg.
-  av_frame->data[kYPlaneIndex] =
-      video_frame->video_frame_buffer()->MutableDataY();
-  av_frame->linesize[kYPlaneIndex] =
-      video_frame->video_frame_buffer()->StrideY();
-  av_frame->data[kUPlaneIndex] =
-      video_frame->video_frame_buffer()->MutableDataU();
-  av_frame->linesize[kUPlaneIndex] =
-      video_frame->video_frame_buffer()->StrideU();
-  av_frame->data[kVPlaneIndex] =
-      video_frame->video_frame_buffer()->MutableDataV();
-  av_frame->linesize[kVPlaneIndex] =
-      video_frame->video_frame_buffer()->StrideV();
+  av_frame->data[kYPlaneIndex] = video_frame->buffer(kYPlane);
+  av_frame->linesize[kYPlaneIndex] = video_frame->stride(kYPlane);
+  av_frame->data[kUPlaneIndex] = video_frame->buffer(kUPlane);
+  av_frame->linesize[kUPlaneIndex] = video_frame->stride(kUPlane);
+  av_frame->data[kVPlaneIndex] = video_frame->buffer(kVPlane);
+  av_frame->linesize[kVPlaneIndex] = video_frame->stride(kVPlane);
   RTC_DCHECK_EQ(av_frame->extended_data, av_frame->data);
 
   av_frame->buf[0] = av_buffer_create(av_frame->data[kYPlaneIndex],
                                       total_size,
                                       AVFreeBuffer2,
                                       static_cast<void*>(video_frame),
                                       0);
   RTC_CHECK(av_frame->buf[0]);
   return 0;
 }
@@ skipping 172 matching lines @@
   if (!frame_decoded) {
     LOG(LS_WARNING) << "avcodec_decode_video2 successful but no frame was "
         "decoded.";
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   // Obtain the |video_frame| containing the decoded image.
   VideoFrame* video_frame = static_cast<VideoFrame*>(
       av_buffer_get_opaque(av_frame_->buf[0]));
   RTC_DCHECK(video_frame);
-  RTC_CHECK_EQ(av_frame_->data[kYPlane],
-               video_frame->video_frame_buffer()->DataY());
-  RTC_CHECK_EQ(av_frame_->data[kUPlane],
-               video_frame->video_frame_buffer()->DataU());
-  RTC_CHECK_EQ(av_frame_->data[kVPlane],
-               video_frame->video_frame_buffer()->DataV());
+  RTC_CHECK_EQ(av_frame_->data[kYPlane], video_frame->buffer(kYPlane));
+  RTC_CHECK_EQ(av_frame_->data[kUPlane], video_frame->buffer(kUPlane));
+  RTC_CHECK_EQ(av_frame_->data[kVPlane], video_frame->buffer(kVPlane));
   video_frame->set_timestamp(input_image._timeStamp);
 
   // The decoded image may be larger than what is supposed to be visible, see
   // |AVGetBuffer2|'s use of |avcodec_align_dimensions|. This crops the image
   // without copying the underlying buffer.
   rtc::scoped_refptr<VideoFrameBuffer> buf = video_frame->video_frame_buffer();
   if (av_frame_->width != buf->width() || av_frame_->height != buf->height()) {
     video_frame->set_video_frame_buffer(
         new rtc::RefCountedObject<WrappedI420Buffer>(
             av_frame_->width, av_frame_->height,
-            buf->DataY(), buf->StrideY(),
-            buf->DataU(), buf->StrideU(),
-            buf->DataV(), buf->StrideV(),
+            buf->data(kYPlane), buf->stride(kYPlane),
+            buf->data(kUPlane), buf->stride(kUPlane),
+            buf->data(kVPlane), buf->stride(kVPlane),
             rtc::KeepRefUntilDone(buf)));
   }
 
   // Return decoded frame.
   int32_t ret = decoded_image_callback_->Decoded(*video_frame);
   // Stop referencing it, possibly freeing |video_frame|.
   av_frame_unref(av_frame_.get());
   video_frame = nullptr;
 
   if (ret) {
@@ skipping 19 matching lines @@
 void H264DecoderImpl::ReportError() {
   if (has_reported_error_)
     return;
   RTC_HISTOGRAM_ENUMERATION("WebRTC.Video.H264DecoderImpl.Event",
                             kH264DecoderEventError,
                             kH264DecoderEventMax);
   has_reported_error_ = true;
 }
 
 }  // namespace webrtc