Add EncodedImageCallback::OnEncodedImage().

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 43 matching lines @@
   Vp8TestEncodedImageCallback() : picture_id_(-1) {
     memset(temporal_layer_, -1, sizeof(temporal_layer_));
     memset(layer_sync_, false, sizeof(layer_sync_));
   }
 
   ~Vp8TestEncodedImageCallback() {
     delete[] encoded_key_frame_._buffer;
     delete[] encoded_frame_._buffer;
   }
 
-  virtual int32_t Encoded(const EncodedImage& encoded_image,
-                          const CodecSpecificInfo* codec_specific_info,
-                          const RTPFragmentationHeader* fragmentation) {
+  virtual Result OnEncodedImage(const EncodedImage& encoded_image,
+                                const CodecSpecificInfo* codec_specific_info,
+                                const RTPFragmentationHeader* fragmentation) {
     // Only store the base layer.
     if (codec_specific_info->codecSpecific.VP8.simulcastIdx == 0) {
       if (encoded_image._frameType == kVideoFrameKey) {
         delete[] encoded_key_frame_._buffer;
         encoded_key_frame_._buffer = new uint8_t[encoded_image._size];
         encoded_key_frame_._size = encoded_image._size;
         encoded_key_frame_._length = encoded_image._length;
         encoded_key_frame_._frameType = kVideoFrameKey;
         encoded_key_frame_._completeFrame = encoded_image._completeFrame;
         memcpy(encoded_key_frame_._buffer, encoded_image._buffer,
                encoded_image._length);
       } else {
         delete[] encoded_frame_._buffer;
         encoded_frame_._buffer = new uint8_t[encoded_image._size];
         encoded_frame_._size = encoded_image._size;
         encoded_frame_._length = encoded_image._length;
         memcpy(encoded_frame_._buffer, encoded_image._buffer,
                encoded_image._length);
       }
     }
     picture_id_ = codec_specific_info->codecSpecific.VP8.pictureId;
     layer_sync_[codec_specific_info->codecSpecific.VP8.simulcastIdx] =
         codec_specific_info->codecSpecific.VP8.layerSync;
     temporal_layer_[codec_specific_info->codecSpecific.VP8.simulcastIdx] =
         codec_specific_info->codecSpecific.VP8.temporalIdx;
-    return 0;
+    return Result(Result::OK, picture_id_);

[stefan-webrtc, 2016/07/18 16:51:27]

Seems a bit surprising that we return picture_id_ here and not the timestamp?

[Sergey Ulanov, 2016/07/21 00:09:39]

Changed it to return timetstamp_, but I don't think it actually matters for this
test.

   }
   void GetLastEncodedFrameInfo(int* picture_id,
                                int* temporal_layer,
                                bool* layer_sync,
                                int stream) {
     *picture_id = picture_id_;
     *temporal_layer = temporal_layer_[stream];
     *layer_sync = layer_sync_[stream];
   }
   void GetLastEncodedKeyFrame(EncodedImage* encoded_key_frame) {
@@ skipping 228 matching lines @@
     encoder_->Release();
     decoder_->Release();
   }
 
   void ExpectStreams(FrameType frame_type, int expected_video_streams) {
     ASSERT_GE(expected_video_streams, 0);
     ASSERT_LE(expected_video_streams, kNumberOfSimulcastStreams);
     if (expected_video_streams >= 1) {
       EXPECT_CALL(
           encoder_callback_,
-          Encoded(
+          OnEncodedImage(
               AllOf(Field(&EncodedImage::_frameType, frame_type),
                     Field(&EncodedImage::_encodedWidth, kDefaultWidth / 4),
                     Field(&EncodedImage::_encodedHeight, kDefaultHeight / 4)),
               _, _))
           .Times(1)
-          .WillRepeatedly(Return(0));
+          .WillRepeatedly(Return(EncodedImageCallback::Result(
+              EncodedImageCallback::Result::OK, 0)));
     }
     if (expected_video_streams >= 2) {
       EXPECT_CALL(
           encoder_callback_,
-          Encoded(
+          OnEncodedImage(
               AllOf(Field(&EncodedImage::_frameType, frame_type),
                     Field(&EncodedImage::_encodedWidth, kDefaultWidth / 2),
                     Field(&EncodedImage::_encodedHeight, kDefaultHeight / 2)),
               _, _))
           .Times(1)
-          .WillRepeatedly(Return(0));
+          .WillRepeatedly(Return(EncodedImageCallback::Result(
+              EncodedImageCallback::Result::OK, 0)));
     }
     if (expected_video_streams >= 3) {
       EXPECT_CALL(
           encoder_callback_,
-          Encoded(AllOf(Field(&EncodedImage::_frameType, frame_type),
-                        Field(&EncodedImage::_encodedWidth, kDefaultWidth),
-                        Field(&EncodedImage::_encodedHeight, kDefaultHeight)),
-                  _, _))
+          OnEncodedImage(
+              AllOf(Field(&EncodedImage::_frameType, frame_type),
+                    Field(&EncodedImage::_encodedWidth, kDefaultWidth),
+                    Field(&EncodedImage::_encodedHeight, kDefaultHeight)),
+              _, _))
           .Times(1)
-          .WillRepeatedly(Return(0));
+          .WillRepeatedly(Return(EncodedImageCallback::Result(
+              EncodedImageCallback::Result::OK, 0)));
     }
   }
 
   void VerifyTemporalIdxAndSyncForAllSpatialLayers(
       Vp8TestEncodedImageCallback* encoder_callback,
       const int* expected_temporal_idx,
       const bool* expected_layer_sync,
       int num_spatial_layers) {
     int picture_id = -1;
     int temporal_layer = -1;
@@ skipping 204 matching lines @@
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1].width =
         settings_.width;
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1].height =
         settings_.height;
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
 
     // Encode one frame and verify.
     encoder_->SetRates(kMaxBitrates[0] + kMaxBitrates[1], 30);
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
-    EXPECT_CALL(encoder_callback_,
-                Encoded(AllOf(Field(&EncodedImage::_frameType, kVideoFrameKey),
-                              Field(&EncodedImage::_encodedWidth, width),
-                              Field(&EncodedImage::_encodedHeight, height)),
-                        _, _))
+    EXPECT_CALL(
+        encoder_callback_,
+        OnEncodedImage(AllOf(Field(&EncodedImage::_frameType, kVideoFrameKey),
+                             Field(&EncodedImage::_encodedWidth, width),
+                             Field(&EncodedImage::_encodedHeight, height)),
+                       _, _))
         .Times(1)
-        .WillRepeatedly(Return(0));
+        .WillRepeatedly(Return(
+            EncodedImageCallback::Result(EncodedImageCallback::Result::OK, 0)));
     EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
 
     // Switch back.
     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.
@@ skipping 352 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_