Revert of Move video_encoder.h and video_decoder.h to /api and create GN targets for them

webrtc/sdk/android/src/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.
  */
 
 // NOTICE: androidmediaencoder_jni.h must be included before
 // androidmediacodeccommon.h to avoid build errors.
 #include "webrtc/sdk/android/src/jni/androidmediaencoder_jni.h"
 
 #include <algorithm>
+#include <memory>
 #include <list>
-#include <memory>
-#include <string>
-#include <utility>
 
 #include "third_party/libyuv/include/libyuv/convert.h"
 #include "third_party/libyuv/include/libyuv/convert_from.h"
 #include "third_party/libyuv/include/libyuv/video_common.h"
-#include "webrtc/api/video_codecs/video_encoder.h"
+#include "webrtc/sdk/android/src/jni/androidmediacodeccommon.h"
+#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
+#include "webrtc/sdk/android/src/jni/native_handle_impl.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/sequenced_task_checker.h"
 #include "webrtc/base/task_queue.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/weak_ptr.h"
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/h264/h264_bitstream_parser.h"
 #include "webrtc/common_video/h264/h264_common.h"
 #include "webrtc/common_video/h264/profile_level_id.h"
 #include "webrtc/media/engine/internalencoderfactory.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/utility/quality_scaler.h"
 #include "webrtc/modules/video_coding/utility/vp8_header_parser.h"
-#include "webrtc/sdk/android/src/jni/androidmediacodeccommon.h"
-#include "webrtc/sdk/android/src/jni/classreferenceholder.h"
-#include "webrtc/sdk/android/src/jni/native_handle_impl.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/logcat_trace_context.h"
+#include "webrtc/video_encoder.h"
 
 using rtc::Bind;
 using rtc::Thread;
 using rtc::ThreadManager;
 
 using webrtc::CodecSpecificInfo;
 using webrtc::EncodedImage;
 using webrtc::VideoFrame;
 using webrtc::RTPFragmentationHeader;
 using webrtc::VideoCodec;
@@ skipping 62 matching lines @@
                                int64_t /* rtt */) override;
   int32_t SetRateAllocation(const webrtc::BitrateAllocation& rate_allocation,
                             uint32_t frame_rate) override;
 
   bool SupportsNativeHandle() const override { return egl_context_ != nullptr; }
   const char* ImplementationName() const override;
 
  private:
   class EncodeTask : public rtc::QueuedTask {
    public:
-    explicit EncodeTask(rtc::WeakPtr<MediaCodecVideoEncoder> encoder);
+    EncodeTask(rtc::WeakPtr<MediaCodecVideoEncoder> encoder);
     bool Run() override;
 
    private:
     rtc::WeakPtr<MediaCodecVideoEncoder> encoder_;
   };
 
   // ResetCodec() calls Release() and InitEncodeInternal() in an attempt to
   // restore the codec to an operable state. Necessary after all manner of
   // OMX-layer errors. Returns true if the codec was reset successfully.
   bool ResetCodec();
@@ skipping 90 matching lines @@
   int last_set_fps_;  // Last-requested frame rate.
   int64_t current_timestamp_us_;  // Current frame timestamps in us.
   int frames_received_;  // Number of frames received by encoder.
   int frames_encoded_;  // Number of frames encoded by encoder.
   int frames_dropped_media_encoder_;  // Number of frames dropped by encoder.
   // Number of dropped frames caused by full queue.
   int consecutive_full_queue_frame_drops_;
   int64_t stat_start_time_ms_;  // Start time for statistics.
   int current_frames_;  // Number of frames in the current statistics interval.
   int current_bytes_;  // Encoded bytes in the current statistics interval.
-  int current_acc_qp_;  // Accumulated QP in the current statistics interval.
+  int current_acc_qp_; // Accumulated QP in the current statistics interval.
   int current_encoding_time_ms_;  // Overall encoding time in the current second
   int64_t last_input_timestamp_ms_;  // Timestamp of last received yuv frame.
   int64_t last_output_timestamp_ms_;  // Timestamp of last encoded frame.
   // Holds the task while the polling loop is paused.
   std::unique_ptr<rtc::QueuedTask> encode_task_;
 
   struct InputFrameInfo {
     InputFrameInfo(int64_t encode_start_time,
                    int32_t frame_timestamp,
                    int64_t frame_render_time_ms,
                    webrtc::VideoRotation rotation)
         : encode_start_time(encode_start_time),
           frame_timestamp(frame_timestamp),
           frame_render_time_ms(frame_render_time_ms),
           rotation(rotation) {}
     // Time when video frame is sent to encoder input.
     const int64_t encode_start_time;
 
     // Input frame information.
     const int32_t frame_timestamp;
     const int64_t frame_render_time_ms;
     const webrtc::VideoRotation rotation;
   };
   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_|.
+  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.
   bool drop_next_input_frame_;
   bool scale_;
   // Global references; must be deleted in Release().
   std::vector<jobject> input_buffers_;
   webrtc::H264BitstreamParser h264_bitstream_parser_;
 
   // VP9 variables to populate codec specific structure.
-  webrtc::GofInfoVP9 gof_;  // Contains each frame's temporal information for
-                            // non-flexible VP9 mode.
+  webrtc::GofInfoVP9 gof_; // Contains each frame's temporal information for
+                           // non-flexible VP9 mode.
   uint8_t tl0_pic_idx_;
   size_t gof_idx_;
 
   // EGL context - owned by factory, should not be allocated/destroyed
   // by MediaCodecVideoEncoder.
   jobject egl_context_;
 
   // Temporary fix for VP8.
   // Sends a key frame if frames are largely spaced apart (possibly
   // corresponding to a large image change).
@@ skipping 221 matching lines @@
                                                    bool use_surface) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (sw_fallback_required_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   RTC_CHECK(!use_surface || egl_context_ != nullptr) << "EGL context not set.";
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   const VideoCodecType codec_type = GetCodecType();
-  ALOGD << "InitEncodeInternal Type: " << static_cast<int>(codec_type) << ", "
-        << width << " x " << height << ". Bitrate: " << kbps
-        << " kbps. Fps: " << fps;
+  ALOGD << "InitEncodeInternal Type: " << (int)codec_type << ", " << width
+        << " x " << height << ". Bitrate: " << kbps << " kbps. Fps: " << fps;
   if (kbps == 0) {
     kbps = last_set_bitrate_kbps_;
   }
   if (fps == 0) {
     fps = MAX_VIDEO_FPS;
   }
 
   width_ = width;
   height_ = height;
   last_set_bitrate_kbps_ = kbps;
   last_set_fps_ = (fps < MAX_VIDEO_FPS) ? fps : MAX_VIDEO_FPS;
   yuv_size_ = width_ * height_ * 3 / 2;
   frames_received_ = 0;
   frames_encoded_ = 0;
   frames_dropped_media_encoder_ = 0;
   consecutive_full_queue_frame_drops_ = 0;
   current_timestamp_us_ = 0;
   stat_start_time_ms_ = rtc::TimeMillis();
   current_frames_ = 0;
   current_bytes_ = 0;
   current_acc_qp_ = 0;
   current_encoding_time_ms_ = 0;
   last_input_timestamp_ms_ = -1;
   last_output_timestamp_ms_ = -1;
   output_timestamp_ = 0;
   output_render_time_ms_ = 0;
   input_frame_infos_.clear();
   drop_next_input_frame_ = false;
   use_surface_ = use_surface;
-  // TODO(ilnik): Use rand_r() instead to avoid LINT warnings below.
-  picture_id_ = static_cast<uint16_t>(rand()) & 0x7FFF;  // NOLINT
+  picture_id_ = static_cast<uint16_t>(rand()) & 0x7FFF;
   gof_.SetGofInfoVP9(webrtc::TemporalStructureMode::kTemporalStructureMode1);
-  tl0_pic_idx_ = static_cast<uint8_t>(rand());  // NOLINT
+  tl0_pic_idx_ = static_cast<uint8_t>(rand());
   gof_idx_ = 0;
   last_frame_received_ms_ = -1;
   frames_received_since_last_key_ = kMinKeyFrameInterval;
 
   // We enforce no extra stride/padding in the format creation step.
   jobject j_video_codec_enum = JavaEnumFromIndexAndClassName(
       jni, "MediaCodecVideoEncoder$VideoCodecType", codec_type);
   const bool encode_status = jni->CallBooleanMethod(
       *j_media_codec_video_encoder_, j_init_encode_method_,
       j_video_codec_enum, width, height, kbps, fps,
@@ skipping 103 matching lines @@
 
   frames_received_++;
   if (!DeliverPendingOutputs(jni)) {
     if (!ProcessHWError(true /* reset_if_fallback_unavailable */)) {
       return sw_fallback_required_ ? WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE
                                    : WEBRTC_VIDEO_CODEC_ERROR;
     }
   }
   if (frames_encoded_ < kMaxEncodedLogFrames) {
     ALOGD << "Encoder frame in # " << (frames_received_ - 1)
-          << ". TS: " << static_cast<int>(current_timestamp_us_ / 1000)
+          << ". TS: " << (int)(current_timestamp_us_ / 1000)
           << ". Q: " << input_frame_infos_.size() << ". Fps: " << last_set_fps_
           << ". Kbps: " << last_set_bitrate_kbps_;
   }
 
   if (drop_next_input_frame_) {
     ALOGW << "Encoder drop frame - failed callback.";
     drop_next_input_frame_ = false;
     current_timestamp_us_ += rtc::kNumMicrosecsPerSec / last_set_fps_;
     frames_dropped_media_encoder_++;
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   RTC_CHECK(frame_types->size() == 1) << "Unexpected stream count";
 
   // Check if we accumulated too many frames in encoder input buffers and drop
   // frame if so.
   if (input_frame_infos_.size() > MAX_ENCODER_Q_SIZE) {
     ALOGD << "Already " << input_frame_infos_.size()
           << " frames in the queue, dropping"
-          << ". TS: " << static_cast<int>(current_timestamp_us_ / 1000)
+          << ". TS: " << (int)(current_timestamp_us_ / 1000)
           << ". Fps: " << last_set_fps_
           << ". Consecutive drops: " << consecutive_full_queue_frame_drops_;
     current_timestamp_us_ += rtc::kNumMicrosecsPerSec / last_set_fps_;
     consecutive_full_queue_frame_drops_++;
     if (consecutive_full_queue_frame_drops_ >=
         ENCODER_STALL_FRAMEDROP_THRESHOLD) {
       ALOGE << "Encoder got stuck.";
       return ProcessHWErrorOnEncode();
     }
     frames_dropped_media_encoder_++;
@@ skipping 422 matching lines @@
     if (CheckException(jni) || !success) {
       ProcessHWError(true /* reset_if_fallback_unavailable */);
       return false;
     }
 
     // Print per frame statistics.
     if (encoding_start_time_ms > 0) {
       frame_encoding_time_ms = rtc::TimeMillis() - encoding_start_time_ms;
     }
     if (frames_encoded_ < kMaxEncodedLogFrames) {
-      int current_latency = static_cast<int>(last_input_timestamp_ms_ -
-                                             last_output_timestamp_ms_);
-      ALOGD << "Encoder frame out # " << frames_encoded_
-            << ". Key: " << key_frame << ". Size: " << payload_size
-            << ". TS: " << static_cast<int>(last_output_timestamp_ms_)
-            << ". Latency: " << current_latency
-            << ". EncTime: " << frame_encoding_time_ms;
+      int current_latency =
+          (int)(last_input_timestamp_ms_ - last_output_timestamp_ms_);
+      ALOGD << "Encoder frame out # " << frames_encoded_ <<
+          ". Key: " << key_frame <<
+          ". Size: " << payload_size <<
+          ". TS: " << (int)last_output_timestamp_ms_ <<
+          ". Latency: " << current_latency <<
+          ". 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.
@@ skipping 182 matching lines @@
   }
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni