Add EncodedImageCallback::OnEncodedImage().

webrtc/modules/video_coding/codecs/vp8/vp8_sequence_coder.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.
  */
 
 #include <memory>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/common_video/include/video_image.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/metrics/video_metrics.h"
 #include "webrtc/tools/simple_command_line_parser.h"
 #include "webrtc/video_frame.h"
 
 class Vp8SequenceCoderEncodeCallback : public webrtc::EncodedImageCallback {
  public:
   explicit Vp8SequenceCoderEncodeCallback(FILE* encoded_file)
       : encoded_file_(encoded_file), encoded_bytes_(0) {}
   ~Vp8SequenceCoderEncodeCallback();
-  int Encoded(const webrtc::EncodedImage& encoded_image,
-              const webrtc::CodecSpecificInfo* codecSpecificInfo,
-              const webrtc::RTPFragmentationHeader*);
+  Result OnEncodedImage(const webrtc::EncodedImage& encoded_image,
+                        const webrtc::CodecSpecificInfo* codec_specific_info,
+                        const webrtc::RTPFragmentationHeader*);
   // Returns the encoded image.
   webrtc::EncodedImage encoded_image() { return encoded_image_; }
   size_t encoded_bytes() { return encoded_bytes_; }
 
  private:
   webrtc::EncodedImage encoded_image_;
   FILE* encoded_file_;
   size_t encoded_bytes_;
 };
 
 Vp8SequenceCoderEncodeCallback::~Vp8SequenceCoderEncodeCallback() {
   delete[] encoded_image_._buffer;
   encoded_image_._buffer = NULL;
 }
-int Vp8SequenceCoderEncodeCallback::Encoded(
+
+webrtc::EncodedImageCallback::Result
+Vp8SequenceCoderEncodeCallback::OnEncodedImage(
     const webrtc::EncodedImage& encoded_image,
     const webrtc::CodecSpecificInfo* codecSpecificInfo,
     const webrtc::RTPFragmentationHeader* fragmentation) {
   if (encoded_image_._size < encoded_image._size) {
     delete[] encoded_image_._buffer;
     encoded_image_._buffer = NULL;
     encoded_image_._buffer = new uint8_t[encoded_image._size];
     encoded_image_._size = encoded_image._size;
   }
   memcpy(encoded_image_._buffer, encoded_image._buffer, encoded_image._size);
   encoded_image_._length = encoded_image._length;
   if (encoded_file_ != NULL) {
     if (fwrite(encoded_image._buffer, 1, encoded_image._length,
                encoded_file_) != encoded_image._length) {
-      return -1;
+      return Result(Result::ERROR_SEND_FAILED, 0);
     }
   }
   encoded_bytes_ += encoded_image_._length;
-  return 0;
+  return Result(Result::OK, 0);
 }
 
 // TODO(mikhal): Add support for varying the frame size.
 class Vp8SequenceCoderDecodeCallback : public webrtc::DecodedImageCallback {
  public:
   explicit Vp8SequenceCoderDecodeCallback(FILE* decoded_file)
       : decoded_file_(decoded_file) {}
   int32_t Decoded(webrtc::VideoFrame& frame) override;
   int32_t Decoded(webrtc::VideoFrame& frame, int64_t decode_time_ms) override {
     RTC_NOTREACHED();
@@ skipping 161 matching lines @@
 
   parser.ProcessFlags();
   if (parser.GetFlag("help") == "true") {
     parser.PrintUsageMessage();
     exit(EXIT_SUCCESS);
   }
   parser.PrintEnteredFlags();
 
   return SequenceCoder(&parser);
 }