Delete webrtc::VideoFrame methods buffer and stride.

webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h

 /*
  *  Copyright (c) 2014 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 101 matching lines @@
   int picture_id_;
   int temporal_layer_[kNumberOfSimulcastStreams];
   bool layer_sync_[kNumberOfSimulcastStreams];
 };
 
 class Vp8TestDecodedImageCallback : public DecodedImageCallback {
  public:
   Vp8TestDecodedImageCallback() : decoded_frames_(0) {}
   int32_t Decoded(VideoFrame& decoded_image) override {
     for (int i = 0; i < decoded_image.width(); ++i) {
-      EXPECT_NEAR(kColorY, decoded_image.buffer(kYPlane)[i], 1);
+      EXPECT_NEAR(kColorY, decoded_image.video_frame_buffer()->DataY()[i], 1);
     }
 
     // TODO(mikhal): Verify the difference between U,V and the original.
     for (int i = 0; i < ((decoded_image.width() + 1) / 2); ++i) {
-      EXPECT_NEAR(kColorU, decoded_image.buffer(kUPlane)[i], 4);
-      EXPECT_NEAR(kColorV, decoded_image.buffer(kVPlane)[i], 4);
+      EXPECT_NEAR(kColorU, decoded_image.video_frame_buffer()->DataU()[i], 4);
+      EXPECT_NEAR(kColorV, decoded_image.video_frame_buffer()->DataV()[i], 4);
     }
     decoded_frames_++;
     return 0;
   }
   int32_t Decoded(VideoFrame& decoded_image, int64_t decode_time_ms) override {
     RTC_NOTREACHED();
     return -1;
   }
   int DecodedFrames() { return decoded_frames_; }
 
@@ skipping 76 matching lines @@
 
     mutable std::vector<TemporalLayers*> spying_layers_;
   };
 };
 
 class TestVp8Simulcast : public ::testing::Test {
  public:
   TestVp8Simulcast(VP8Encoder* encoder, VP8Decoder* decoder)
       : encoder_(encoder), decoder_(decoder) {}
 
-  // Creates an VideoFrame from |plane_colors|.
-  static void CreateImage(VideoFrame* frame, int plane_colors[kNumOfPlanes]) {
-    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);
+  static void SetPlane(uint8_t* data,
+                       uint8_t value,
+                       int width,
+                       int height,
+                       int stride) {
+    for (int i = 0; i < height; i++, data += stride) {
       // Setting allocated area to zero - setting only image size to
       // requested values - will make it easier to distinguish between image
       // size and frame size (accounting for stride).
-      memset(frame->buffer(plane_type), 0, frame->allocated_size(plane_type));
-      for (int i = 0; i < height; i++) {
-        memset(data, plane_colors[plane_num], width);
-        data += frame->stride(plane_type);
-      }
+      memset(data, value, width);
+      memset(data + width, 0, stride - width);
     }
   }
 
+  // Fills in an VideoFrameBuffer from |plane_colors|.
+  static void CreateImage(const rtc::scoped_refptr<VideoFrameBuffer>& buffer,
+                          int plane_colors[kNumOfPlanes]) {
+    int width = buffer->width();
+    int height = buffer->height();
+    int chroma_width = (width + 1) / 2;
+    int chroma_height = (height + 1) / 2;
+
+    SetPlane(buffer->MutableDataY(), plane_colors[0],
+             width, height, buffer->StrideY());
+
+    SetPlane(buffer->MutableDataU(), plane_colors[1],
+             chroma_width, chroma_height,
+             buffer->StrideU());
+
+    SetPlane(buffer->MutableDataV(), plane_colors[2],
+             chroma_width, chroma_height,
+             buffer->StrideV());
+  }
+
   static void DefaultSettings(VideoCodec* settings,
                               const int* temporal_layer_profile) {
     assert(settings);
     memset(settings, 0, sizeof(VideoCodec));
     strncpy(settings->plName, "VP8", 4);
     settings->codecType = kVideoCodecVP8;
     // 96 to 127 dynamic payload types for video codecs
     settings->plType = 120;
     settings->startBitrate = 300;
     settings->minBitrate = 30;
@@ skipping 43 matching lines @@
 
   virtual void SetUpCodec(const int* temporal_layer_profile) {
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback_);
     decoder_->RegisterDecodeCompleteCallback(&decoder_callback_);
     DefaultSettings(&settings_, temporal_layer_profile);
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
     EXPECT_EQ(0, decoder_->InitDecode(&settings_, 1));
     int half_width = (kDefaultWidth + 1) / 2;
     input_frame_.CreateEmptyFrame(kDefaultWidth, kDefaultHeight, kDefaultWidth,
                                   half_width, half_width);
-    memset(input_frame_.buffer(kYPlane), 0,
+    memset(input_frame_.video_frame_buffer()->MutableDataY(), 0,
            input_frame_.allocated_size(kYPlane));
-    memset(input_frame_.buffer(kUPlane), 0,
+    memset(input_frame_.video_frame_buffer()->MutableDataU(), 0,
            input_frame_.allocated_size(kUPlane));
-    memset(input_frame_.buffer(kVPlane), 0,
+    memset(input_frame_.video_frame_buffer()->MutableDataV(), 0,
            input_frame_.allocated_size(kVPlane));
   }
 
   virtual void TearDown() {
     encoder_->Release();
     decoder_->Release();
   }
 
   void ExpectStreams(FrameType frame_type, int expected_video_streams) {
     ASSERT_GE(expected_video_streams, 0);
@@ skipping 225 matching lines @@
     settings_.height = height;
     for (int i = 0; i < settings_.numberOfSimulcastStreams - 1; ++i) {
       settings_.simulcastStream[i].maxBitrate = 0;
       settings_.simulcastStream[i].width = settings_.width;
       settings_.simulcastStream[i].height = settings_.height;
     }
     // Setting input image to new resolution.
     int half_width = (settings_.width + 1) / 2;
     input_frame_.CreateEmptyFrame(settings_.width, settings_.height,
                                   settings_.width, half_width, half_width);
-    memset(input_frame_.buffer(kYPlane), 0,
+    memset(input_frame_.video_frame_buffer()->MutableDataY(), 0,
            input_frame_.allocated_size(kYPlane));
-    memset(input_frame_.buffer(kUPlane), 0,
+    memset(input_frame_.video_frame_buffer()->MutableDataU(), 0,
            input_frame_.allocated_size(kUPlane));
-    memset(input_frame_.buffer(kVPlane), 0,
+    memset(input_frame_.video_frame_buffer()->MutableDataV(), 0,
            input_frame_.allocated_size(kVPlane));
 
     // The for loop above did not set the bitrate of the highest layer.
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1]
         .maxBitrate = 0;
     // The highest layer has to correspond to the non-simulcast resolution.
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1].width =
         settings_.width;
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1].height =
         settings_.height;
@@ skipping 16 matching lines @@
     DefaultSettings(&settings_, kDefaultTemporalLayerProfile);
     // Start at the lowest bitrate for enabling base stream.
     settings_.startBitrate = kMinBitrates[0];
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
     encoder_->SetRates(settings_.startBitrate, 30);
     ExpectStreams(kVideoFrameKey, 1);
     // Resize |input_frame_| to the new resolution.
     half_width = (settings_.width + 1) / 2;
     input_frame_.CreateEmptyFrame(settings_.width, settings_.height,
                                   settings_.width, half_width, half_width);
-    memset(input_frame_.buffer(kYPlane), 0,
+    memset(input_frame_.video_frame_buffer()->MutableDataY(), 0,
            input_frame_.allocated_size(kYPlane));
-    memset(input_frame_.buffer(kUPlane), 0,
+    memset(input_frame_.video_frame_buffer()->MutableDataU(), 0,
            input_frame_.allocated_size(kUPlane));
-    memset(input_frame_.buffer(kVPlane), 0,
+    memset(input_frame_.video_frame_buffer()->MutableDataV(), 0,
            input_frame_.allocated_size(kVPlane));
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
   }
 
   void TestSwitchingToOneStream() { SwitchingToOneStream(1024, 768); }
 
   void TestSwitchingToOneOddStream() { SwitchingToOneStream(1023, 769); }
 
   void TestSwitchingToOneSmallStream() { SwitchingToOneStream(4, 4); }
 
@@ skipping 70 matching lines @@
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
     decoder_->RegisterDecodeCompleteCallback(&decoder_callback);
 
     encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
 
     // Set color.
     int plane_offset[kNumOfPlanes];
     plane_offset[kYPlane] = kColorY;
     plane_offset[kUPlane] = kColorU;
     plane_offset[kVPlane] = kColorV;
-    CreateImage(&input_frame_, plane_offset);
+    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
 
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
     int picture_id = -1;
     int temporal_layer = -1;
     bool layer_sync = false;
     encoder_callback.GetLastEncodedFrameInfo(&picture_id, &temporal_layer,
                                              &layer_sync, 0);
     EXPECT_EQ(0, temporal_layer);
     EXPECT_TRUE(layer_sync);
     int key_frame_picture_id = picture_id;
 
     // Change color.
     plane_offset[kYPlane] += 1;
     plane_offset[kUPlane] += 1;
     plane_offset[kVPlane] += 1;
-    CreateImage(&input_frame_, plane_offset);
+    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
 
     // Change color.
     plane_offset[kYPlane] += 1;
     plane_offset[kUPlane] += 1;
     plane_offset[kVPlane] += 1;
-    CreateImage(&input_frame_, plane_offset);
+    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
 
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
 
     // Change color.
     plane_offset[kYPlane] += 1;
     plane_offset[kUPlane] += 1;
     plane_offset[kVPlane] += 1;
-    CreateImage(&input_frame_, plane_offset);
+    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
 
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
 
     CodecSpecificInfo codec_specific;
     codec_specific.codecType = kVideoCodecVP8;
     codec_specific.codecSpecific.VP8.hasReceivedRPSI = true;
     // Must match last key frame to trigger.
     codec_specific.codecSpecific.VP8.pictureIdRPSI = key_frame_picture_id;
 
     // Change color back to original.
     plane_offset[kYPlane] = kColorY;
     plane_offset[kUPlane] = kColorU;
     plane_offset[kVPlane] = kColorV;
-    CreateImage(&input_frame_, plane_offset);
+    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
 
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, &codec_specific, NULL));
 
     EncodedImage encoded_frame;
     encoder_callback.GetLastEncodedKeyFrame(&encoded_frame);
     decoder_->Decode(encoded_frame, false, NULL);
     encoder_callback.GetLastEncodedFrame(&encoded_frame);
     decoder_->Decode(encoded_frame, false, NULL);
     EXPECT_EQ(2, decoder_callback.DecodedFrames());
@@ skipping 138 matching lines @@
     // 1. stride > width 2. stride_y != stride_uv/2
     int stride_y = kDefaultWidth + 20;
     int stride_uv = ((kDefaultWidth + 1) / 2) + 5;
     input_frame_.CreateEmptyFrame(kDefaultWidth, kDefaultHeight, stride_y,
                                   stride_uv, stride_uv);
     // Set color.
     int plane_offset[kNumOfPlanes];
     plane_offset[kYPlane] = kColorY;
     plane_offset[kUPlane] = kColorU;
     plane_offset[kVPlane] = kColorV;
-    CreateImage(&input_frame_, plane_offset);
+    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
 
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
 
     // Change color.
     plane_offset[kYPlane] += 1;
     plane_offset[kUPlane] += 1;
     plane_offset[kVPlane] += 1;
-    CreateImage(&input_frame_, plane_offset);
+    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
     input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
 
     EncodedImage encoded_frame;
     // Only encoding one frame - so will be a key frame.
     encoder_callback.GetLastEncodedKeyFrame(&encoded_frame);
     EXPECT_EQ(0, decoder_->Decode(encoded_frame, false, NULL));
     encoder_callback.GetLastEncodedFrame(&encoded_frame);
     decoder_->Decode(encoded_frame, false, NULL);
     EXPECT_EQ(2, decoder_callback.DecodedFrames());
@@ skipping 28 matching lines @@
   std::unique_ptr<VP8Decoder> decoder_;
   MockDecodedImageCallback decoder_callback_;
   VideoCodec settings_;
   VideoFrame input_frame_;
 };
 
 }  // namespace testing
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_