Revert of Remove deprected functions from EncodedImageCallback and RtpRtcp

webrtc/api/android/jni/androidmediaencoder_jni.cc

 /*
  *  Copyright 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 245 matching lines @@
   };
   std::list<InputFrameInfo> input_frame_infos_;
   int32_t output_timestamp_;      // Last output frame timestamp from
                                   // |input_frame_infos_|.
   int64_t output_render_time_ms_; // Last output frame render time from
                                   // |input_frame_infos_|.
   webrtc::VideoRotation output_rotation_;  // Last output frame rotation from
                                            // |input_frame_infos_|.
   // Frame size in bytes fed to MediaCodec.
   int yuv_size_;
-  // True only when between a callback_->OnEncodedImage() call return a positive
-  // value and the next Encode() call being ignored.
+  // True only when between a callback_->Encoded() call return a positive value
+  // and the next Encode() call being ignored.
   bool drop_next_input_frame_;
   // Global references; must be deleted in Release().
   std::vector<jobject> input_buffers_;
   QualityScaler quality_scaler_;
   // Dynamic resolution change, off by default.
   bool scale_;
 
   // H264 bitstream parser, used to extract QP from encoded bitstreams.
   webrtc::H264BitstreamParser h264_bitstream_parser_;
 
@@ skipping 778 matching lines @@
     size_t payload_size = jni->GetDirectBufferCapacity(j_output_buffer);
     uint8_t* payload = reinterpret_cast<uint8_t*>(
         jni->GetDirectBufferAddress(j_output_buffer));
     if (CheckException(jni)) {
       ALOGE << "Exception in get direct buffer address.";
       ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
 
     // Callback - return encoded frame.
-    webrtc::EncodedImageCallback::Result callback_result(
-        webrtc::EncodedImageCallback::Result::OK);
+    int32_t callback_status = 0;
     if (callback_) {
       std::unique_ptr<webrtc::EncodedImage> image(
           new webrtc::EncodedImage(payload, payload_size, payload_size));
       image->_encodedWidth = width_;
       image->_encodedHeight = height_;
       image->_timeStamp = output_timestamp_;
       image->capture_time_ms_ = output_render_time_ms_;
       image->rotation_ = output_rotation_;
       image->_frameType =
           (key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta);
@@ skipping 90 matching lines @@
         header.VerifyAndAllocateFragmentationHeader(scPositionsLength);
         for (size_t i = 0; i < scPositionsLength; i++) {
           header.fragmentationOffset[i] = scPositions[i] + H264_SC_LENGTH;
           header.fragmentationLength[i] =
               scPositions[i + 1] - header.fragmentationOffset[i];
           header.fragmentationPlType[i] = 0;
           header.fragmentationTimeDiff[i] = 0;
         }
       }
 
-      callback_result = callback_->OnEncodedImage(*image, &info, &header);
+      callback_status = callback_->Encoded(*image, &info, &header);
     }
 
     // Return output buffer back to the encoder.
     bool success = jni->CallBooleanMethod(*j_media_codec_video_encoder_,
                                           j_release_output_buffer_method_,
                                           output_buffer_index);
     if (CheckException(jni) || !success) {
       ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
       return false;
     }
@@ skipping 13 matching lines @@
           ". EncTime: " << frame_encoding_time_ms;
     }
 
     // Calculate and print encoding statistics - every 3 seconds.
     frames_encoded_++;
     current_frames_++;
     current_bytes_ += payload_size;
     current_encoding_time_ms_ += frame_encoding_time_ms;
     LogStatistics(false);
 
-    // Errors in callback_result are currently ignored.
-    if (callback_result.drop_next_frame)
+    if (callback_status > 0) {
       drop_next_input_frame_ = true;
+      // Theoretically could handle callback_status<0 here, but unclear what
+      // that would mean for us.
+    }
   }
   return true;
 }
 
 void MediaCodecVideoEncoder::LogStatistics(bool force_log) {
   int statistic_time_ms = rtc::TimeMillis() - stat_start_time_ms_;
   if ((statistic_time_ms >= kMediaCodecStatisticsIntervalMs || force_log)
       && statistic_time_ms > 0) {
     // Prevent division by zero.
     int current_frames_divider = current_frames_ != 0 ? current_frames_ : 1;
@@ skipping 145 matching lines @@
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni