Android: Replace webrtc_jni namespace with nested jni namespace

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.
  */
 
@@ skipping 32 matching lines @@
 #include "webrtc/sdk/android/src/jni/androidmediacodeccommon.h"
 #include "webrtc/sdk/android/src/jni/classreferenceholder.h"
 #include "webrtc/sdk/android/src/jni/jni_helpers.h"
 #include "webrtc/sdk/android/src/jni/native_handle_impl.h"
 #include "webrtc/system_wrappers/include/field_trial.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;
-using webrtc::VideoCodecType;
-using webrtc::kVideoCodecH264;
-using webrtc::kVideoCodecVP8;
-using webrtc::kVideoCodecVP9;
-using webrtc::QualityScaler;
-
-namespace webrtc_jni {
+namespace webrtc {
+namespace jni {
 
 // Maximum supported HW video encoder fps.
 #define MAX_VIDEO_FPS 30
 // Maximum allowed fps value in SetRates() call.
 #define MAX_ALLOWED_VIDEO_FPS 60
 // Maximum allowed frames in encoder input queue.
 #define MAX_ENCODER_Q_SIZE 2
 // Maximum amount of dropped frames caused by full encoder queue - exceeding
 // this threshold means that encoder probably got stuck and need to be reset.
 #define ENCODER_STALL_FRAMEDROP_THRESHOLD 60
@@ skipping 11 matching lines @@
 #define ALOGE LOG_TAG(rtc::LS_ERROR, TAG_ENCODER)
 
 namespace {
 // Maximum time limit between incoming frames before requesting a key frame.
 const size_t kFrameDiffThresholdMs = 350;
 const int kMinKeyFrameInterval = 6;
 const char kH264HighProfileFieldTrial[] = "WebRTC-H264HighProfile";
 const char kCustomQPThresholdsFieldTrial[] = "WebRTC-CustomQPThresholds";
 }  // namespace
 
-// MediaCodecVideoEncoder is a webrtc::VideoEncoder implementation that uses
+// MediaCodecVideoEncoder is a VideoEncoder implementation that uses
 // Android's MediaCodec SDK API behind the scenes to implement (hopefully)
 // HW-backed video encode.  This C++ class is implemented as a very thin shim,
 // delegating all of the interesting work to org.webrtc.MediaCodecVideoEncoder.
 // MediaCodecVideoEncoder must be operated on a single task queue, currently
 // this is the encoder queue from ViE encoder.
-class MediaCodecVideoEncoder : public webrtc::VideoEncoder {
+class MediaCodecVideoEncoder : public VideoEncoder {
  public:
   virtual ~MediaCodecVideoEncoder();
   MediaCodecVideoEncoder(JNIEnv* jni,
                          const cricket::VideoCodec& codec,
                          jobject egl_context);
 
-  // webrtc::VideoEncoder implementation.
-  int32_t InitEncode(const webrtc::VideoCodec* codec_settings,
+  // VideoEncoder implementation.
+  int32_t InitEncode(const VideoCodec* codec_settings,
                      int32_t /* number_of_cores */,
                      size_t /* max_payload_size */) override;
-  int32_t Encode(const webrtc::VideoFrame& input_image,
-                 const webrtc::CodecSpecificInfo* /* codec_specific_info */,
-                 const std::vector<webrtc::FrameType>* frame_types) override;
+  int32_t Encode(const VideoFrame& input_image,
+                 const CodecSpecificInfo* /* codec_specific_info */,
+                 const std::vector<FrameType>* frame_types) override;
   int32_t RegisterEncodeCompleteCallback(
-      webrtc::EncodedImageCallback* callback) override;
+      EncodedImageCallback* callback) override;
   int32_t Release() override;
   int32_t SetChannelParameters(uint32_t /* packet_loss */,
                                int64_t /* rtt */) override;
-  int32_t SetRateAllocation(const webrtc::BitrateAllocation& rate_allocation,
+  int32_t SetRateAllocation(const BitrateAllocation& rate_allocation,
                             uint32_t frame_rate) override;
 
   bool SupportsNativeHandle() const override { return egl_context_ != nullptr; }
   const char* ImplementationName() const override;
 
   // Fills the input buffer with data from the buffers passed as parameters.
   bool FillInputBuffer(JNIEnv* jni,
                        int input_buffer_index,
                        uint8_t const* buffer_y,
                        int stride_y,
@@ skipping 31 matching lines @@
   // previously-current values are reused instead of the passed parameters
   // (makes it easier to reason about thread-safety).
   int32_t InitEncodeInternal(int width,
                              int height,
                              int kbps,
                              int fps,
                              bool use_surface);
   // Reconfigure to match |frame| in width, height. Also reconfigures the
   // encoder if |frame| is a texture/byte buffer and the encoder is initialized
   // for byte buffer/texture. Returns false if reconfiguring fails.
-  bool MaybeReconfigureEncoder(JNIEnv* jni, const webrtc::VideoFrame& frame);
+  bool MaybeReconfigureEncoder(JNIEnv* jni, const VideoFrame& frame);
 
   // Returns true if the frame is a texture frame and we should use surface
   // based encoding.
-  bool IsTextureFrame(JNIEnv* jni, const webrtc::VideoFrame& frame);
+  bool IsTextureFrame(JNIEnv* jni, const VideoFrame& frame);
 
   bool EncodeByteBuffer(JNIEnv* jni,
                         bool key_frame,
-                        const webrtc::VideoFrame& frame,
+                        const VideoFrame& frame,
                         int input_buffer_index);
-  bool EncodeTexture(JNIEnv* jni,
-                     bool key_frame,
-                     const webrtc::VideoFrame& frame);
+  bool EncodeTexture(JNIEnv* jni, bool key_frame, const VideoFrame& frame);
   // Encodes a new style org.webrtc.VideoFrame. Might be a I420 or a texture
   // frame.
   bool EncodeJavaFrame(JNIEnv* jni,
                        bool key_frame,
                        jobject frame,
                        int input_buffer_index);
 
   // Helper accessors for MediaCodecVideoEncoder$OutputBufferInfo members.
   int GetOutputBufferInfoIndex(JNIEnv* jni, jobject j_output_buffer_info);
   jobject GetOutputBufferInfoBuffer(JNIEnv* jni, jobject j_output_buffer_info);
@@ skipping 16 matching lines @@
   // Mutex for protecting inited_. It is only used for correctness checking on
   // debug build. It is used for checking that encoder has been released in the
   // destructor. Because this might happen on a different thread, we need a
   // mutex.
   rtc::CriticalSection inited_crit_;
 #endif
 
   // Type of video codec.
   const cricket::VideoCodec codec_;
 
-  webrtc::EncodedImageCallback* callback_;
+  EncodedImageCallback* callback_;
 
   // State that is constant for the lifetime of this object once the ctor
   // returns.
   rtc::SequencedTaskChecker encoder_queue_checker_;
   ScopedGlobalRef<jclass> j_media_codec_video_encoder_class_;
   ScopedGlobalRef<jobject> j_media_codec_video_encoder_;
   jmethodID j_init_encode_method_;
   jmethodID j_get_input_buffers_method_;
   jmethodID j_dequeue_input_buffer_method_;
   jmethodID j_encode_buffer_method_;
@@ skipping 33 matching lines @@
   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)
+                   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;
+    const 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_|.
-  webrtc::VideoRotation output_rotation_;  // Last output frame rotation from
-                                           // |input_frame_infos_|.
+  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_;
-  webrtc::H264::Profile profile_;
+  H264::Profile profile_;
   // Global references; must be deleted in Release().
   std::vector<jobject> input_buffers_;
-  webrtc::H264BitstreamParser h264_bitstream_parser_;
+  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.
+  GofInfoVP9 gof_;  // Contains each frame's temporal information for
+                    // non-flexible VP9 mode.
   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).
   int64_t last_frame_received_ms_;
   int frames_received_since_last_key_;
-  webrtc::VideoCodecMode codec_mode_;
+  VideoCodecMode codec_mode_;
 
   // RTP state.
   uint16_t picture_id_;
   uint8_t tl0_pic_idx_;
 
   bool sw_fallback_required_;
 
   // All other member variables should be before WeakPtrFactory. Valid only from
   // InitEncode to Release.
   std::unique_ptr<rtc::WeakPtrFactory<MediaCodecVideoEncoder>> weak_factory_;
@@ skipping 72 matching lines @@
       jni, j_output_buffer_info_class, "buffer", "Ljava/nio/ByteBuffer;");
   j_info_is_key_frame_field_ =
       GetFieldID(jni, j_output_buffer_info_class, "isKeyFrame", "Z");
   j_info_presentation_timestamp_us_field_ = GetFieldID(
       jni, j_output_buffer_info_class, "presentationTimestampUs", "J");
   if (CheckException(jni)) {
     ALOGW << "MediaCodecVideoEncoder ctor failed.";
     ProcessHWError(true /* reset_if_fallback_unavailable */);
   }
 
-  webrtc::Random random(rtc::TimeMicros());
+  Random random(rtc::TimeMicros());
   picture_id_ = random.Rand<uint16_t>() & 0x7FFF;
   tl0_pic_idx_ = random.Rand<uint8_t>();
 }
 
-int32_t MediaCodecVideoEncoder::InitEncode(
-    const webrtc::VideoCodec* codec_settings,
-    int32_t /* number_of_cores */,
-    size_t /* max_payload_size */) {
+int32_t MediaCodecVideoEncoder::InitEncode(const VideoCodec* codec_settings,
+                                           int32_t /* number_of_cores */,
+                                           size_t /* max_payload_size */) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (codec_settings == NULL) {
     ALOGE << "NULL VideoCodec instance";
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // Factory should guard against other codecs being used with us.
   const VideoCodecType codec_type = GetCodecType();
   RTC_CHECK(codec_settings->codecType == codec_type)
       << "Unsupported codec " << codec_settings->codecType << " for "
       << codec_type;
@@ skipping 11 matching lines @@
   } else if (codec_type == kVideoCodecVP9) {
     scale_ = codec_settings->VP9().automaticResizeOn;
   } else {
     scale_ = true;
   }
 
   ALOGD << "InitEncode request: " << init_width << " x " << init_height;
   ALOGD << "Encoder automatic resize " << (scale_ ? "enabled" : "disabled");
 
   // Check allowed H.264 profile
-  profile_ = webrtc::H264::Profile::kProfileBaseline;
+  profile_ = H264::Profile::kProfileBaseline;
   if (codec_type == kVideoCodecH264) {
-    const rtc::Optional<webrtc::H264::ProfileLevelId> profile_level_id =
-        webrtc::H264::ParseSdpProfileLevelId(codec_.params);
+    const rtc::Optional<H264::ProfileLevelId> profile_level_id =
+        H264::ParseSdpProfileLevelId(codec_.params);
     RTC_DCHECK(profile_level_id);
     profile_ = profile_level_id->profile;
     ALOGD << "H.264 profile: " << profile_;
   }
 
   return InitEncodeInternal(
       init_width, init_height, codec_settings->startBitrate,
       codec_settings->maxFramerate, codec_settings->expect_encode_from_texture);
 }
 
@@ skipping 77 matching lines @@
   return false;
 }
 
 int32_t MediaCodecVideoEncoder::ProcessHWErrorOnEncode() {
   ProcessHWError(true /* reset_if_fallback_unavailable */);
   return sw_fallback_required_ ? WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE
                                : WEBRTC_VIDEO_CODEC_ERROR;
 }
 
 VideoCodecType MediaCodecVideoEncoder::GetCodecType() const {
-  return webrtc::PayloadStringToCodecType(codec_.name);
+  return PayloadStringToCodecType(codec_.name);
 }
 
 int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width,
                                                    int height,
                                                    int kbps,
                                                    int fps,
                                                    bool use_surface) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (sw_fallback_required_) {
     return WEBRTC_VIDEO_CODEC_OK;
@@ skipping 28 matching lines @@
   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;
-  gof_.SetGofInfoVP9(webrtc::TemporalStructureMode::kTemporalStructureMode1);
+  gof_.SetGofInfoVP9(TemporalStructureMode::kTemporalStructureMode1);
   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,
       profile_, width, height, kbps, fps,
@@ skipping 63 matching lines @@
 #endif
     inited_ = true;
   }
   weak_factory_.reset(new rtc::WeakPtrFactory<MediaCodecVideoEncoder>(this));
   encode_task_.reset(new EncodeTask(weak_factory_->GetWeakPtr()));
 
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::Encode(
-    const webrtc::VideoFrame& frame,
-    const webrtc::CodecSpecificInfo* /* codec_specific_info */,
-    const std::vector<webrtc::FrameType>* frame_types) {
+    const VideoFrame& frame,
+    const CodecSpecificInfo* /* codec_specific_info */,
+    const std::vector<FrameType>* frame_types) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (sw_fallback_required_)
     return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   const int64_t frame_input_time_ms = rtc::TimeMillis();
 
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
 
   bool send_key_frame = false;
-  if (codec_mode_ == webrtc::kRealtimeVideo) {
+  if (codec_mode_ == kRealtimeVideo) {
     ++frames_received_since_last_key_;
     int64_t now_ms = rtc::TimeMillis();
     if (last_frame_received_ms_ != -1 &&
         (now_ms - last_frame_received_ms_) > kFrameDiffThresholdMs) {
       // Add limit to prevent triggering a key for every frame for very low
       // framerates (e.g. if frame diff > kFrameDiffThresholdMs).
       if (frames_received_since_last_key_ > kMinKeyFrameInterval) {
         ALOGD << "Send key, frame diff: " << (now_ms - last_frame_received_ms_);
         send_key_frame = true;
       }
@@ skipping 39 matching lines @@
     if (consecutive_full_queue_frame_drops_ >=
         ENCODER_STALL_FRAMEDROP_THRESHOLD) {
       ALOGE << "Encoder got stuck.";
       return ProcessHWErrorOnEncode();
     }
     frames_dropped_media_encoder_++;
     return WEBRTC_VIDEO_CODEC_OK;
   }
   consecutive_full_queue_frame_drops_ = 0;
 
-  rtc::scoped_refptr<webrtc::VideoFrameBuffer> input_buffer(
-      frame.video_frame_buffer());
+  rtc::scoped_refptr<VideoFrameBuffer> input_buffer(frame.video_frame_buffer());
 
   VideoFrame input_frame(input_buffer, frame.timestamp(),
                          frame.render_time_ms(), frame.rotation());
 
   if (!MaybeReconfigureEncoder(jni, input_frame)) {
     ALOGE << "Failed to reconfigure encoder.";
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   const bool key_frame =
-      frame_types->front() != webrtc::kVideoFrameDelta || send_key_frame;
+      frame_types->front() != kVideoFrameDelta || send_key_frame;
   bool encode_status = true;
 
   int j_input_buffer_index = -1;
   if (!use_surface_) {
     j_input_buffer_index = jni->CallIntMethod(*j_media_codec_video_encoder_,
                                               j_dequeue_input_buffer_method_);
     if (CheckException(jni)) {
       ALOGE << "Exception in dequeu input buffer.";
       return ProcessHWErrorOnEncode();
     }
     if (j_input_buffer_index == -1) {
       // Video codec falls behind - no input buffer available.
       ALOGW << "Encoder drop frame - no input buffers available";
       if (frames_received_ > 1) {
         current_timestamp_us_ += rtc::kNumMicrosecsPerSec / last_set_fps_;
         frames_dropped_media_encoder_++;
       } else {
         // Input buffers are not ready after codec initialization, HW is still
         // allocating thme - this is expected and should not result in drop
         // frame report.
         frames_received_ = 0;
       }
       return WEBRTC_VIDEO_CODEC_OK;  // TODO(fischman): see webrtc bug 2887.
     } else if (j_input_buffer_index == -2) {
       return ProcessHWErrorOnEncode();
     }
   }
 
   if (input_frame.video_frame_buffer()->type() !=
-      webrtc::VideoFrameBuffer::Type::kNative) {
+      VideoFrameBuffer::Type::kNative) {
     encode_status =
         EncodeByteBuffer(jni, key_frame, input_frame, j_input_buffer_index);
   } else {
     AndroidVideoFrameBuffer* android_buffer =
         static_cast<AndroidVideoFrameBuffer*>(
             input_frame.video_frame_buffer().get());
     switch (android_buffer->android_type()) {
       case AndroidVideoFrameBuffer::AndroidType::kTextureBuffer:
         encode_status = EncodeTexture(jni, key_frame, input_frame);
         break;
@@ skipping 28 matching lines @@
     rtc::TaskQueue::Current()->PostDelayedTask(std::move(encode_task_),
                                                kMediaCodecPollMs);
   }
 
   if (!DeliverPendingOutputs(jni)) {
     return ProcessHWErrorOnEncode();
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
-bool MediaCodecVideoEncoder::MaybeReconfigureEncoder(
-    JNIEnv* jni,
-    const webrtc::VideoFrame& frame) {
+bool MediaCodecVideoEncoder::MaybeReconfigureEncoder(JNIEnv* jni,
+                                                     const VideoFrame& frame) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
 
   bool is_texture = IsTextureFrame(jni, frame);
   const bool reconfigure_due_to_format = is_texture != use_surface_;
   const bool reconfigure_due_to_size =
       frame.width() != width_ || frame.height() != height_;
 
   if (reconfigure_due_to_format) {
       ALOGD << "Reconfigure encoder due to format change. "
             << (use_surface_ ?
@@ skipping 13 matching lines @@
   if (!reconfigure_due_to_format && !reconfigure_due_to_size)
     return true;
 
   Release();
 
   return InitEncodeInternal(width_, height_, 0, 0, is_texture) ==
          WEBRTC_VIDEO_CODEC_OK;
 }
 
 bool MediaCodecVideoEncoder::IsTextureFrame(JNIEnv* jni,
-                                            const webrtc::VideoFrame& frame) {
-  if (frame.video_frame_buffer()->type() !=
-      webrtc::VideoFrameBuffer::Type::kNative) {
+                                            const VideoFrame& frame) {
+  if (frame.video_frame_buffer()->type() != VideoFrameBuffer::Type::kNative) {
     return false;
   }
 
   AndroidVideoFrameBuffer* android_buffer =
       static_cast<AndroidVideoFrameBuffer*>(frame.video_frame_buffer().get());
   switch (android_buffer->android_type()) {
     case AndroidVideoFrameBuffer::AndroidType::kTextureBuffer:
       return true;
     case AndroidVideoFrameBuffer::AndroidType::kJavaBuffer:
       return jni->IsInstanceOf(static_cast<AndroidVideoBuffer*>(android_buffer)
                                    ->video_frame_buffer(),
                                *j_video_frame_texture_buffer_class_);
     default:
       RTC_NOTREACHED();
       return false;
   }
 }
 
 bool MediaCodecVideoEncoder::EncodeByteBuffer(JNIEnv* jni,
                                               bool key_frame,
-                                              const webrtc::VideoFrame& frame,
+                                              const VideoFrame& frame,
                                               int input_buffer_index) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   RTC_CHECK(!use_surface_);
 
-  rtc::scoped_refptr<webrtc::I420BufferInterface> i420_buffer =
+  rtc::scoped_refptr<I420BufferInterface> i420_buffer =
       frame.video_frame_buffer()->ToI420();
   if (!FillInputBuffer(jni, input_buffer_index, i420_buffer->DataY(),
                        i420_buffer->StrideY(), i420_buffer->DataU(),
                        i420_buffer->StrideU(), i420_buffer->DataV(),
                        i420_buffer->StrideV())) {
     return false;
   }
   bool encode_status = jni->CallBooleanMethod(
       *j_media_codec_video_encoder_, j_encode_buffer_method_, key_frame,
       input_buffer_index, yuv_size_, current_timestamp_us_);
@@ skipping 25 matching lines @@
 
   RTC_CHECK(!libyuv::ConvertFromI420(buffer_y, stride_y, buffer_u, stride_u,
                                      buffer_v, stride_v, yuv_buffer, width_,
                                      width_, height_, encoder_fourcc_))
       << "ConvertFromI420 failed";
   return true;
 }
 
 bool MediaCodecVideoEncoder::EncodeTexture(JNIEnv* jni,
                                            bool key_frame,
-                                           const webrtc::VideoFrame& frame) {
+                                           const VideoFrame& frame) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   RTC_CHECK(use_surface_);
   NativeHandleImpl handle =
       static_cast<AndroidTextureBuffer*>(frame.video_frame_buffer().get())
           ->native_handle_impl();
 
   jfloatArray sampling_matrix = handle.sampling_matrix.ToJava(jni);
   bool encode_status = jni->CallBooleanMethod(
       *j_media_codec_video_encoder_, j_encode_texture_method_, key_frame,
       handle.oes_texture_id, sampling_matrix, current_timestamp_us_);
@@ skipping 14 matching lines @@
       jlongFromPointer(this), key_frame, frame, input_buffer_index);
   if (CheckException(jni)) {
     ALOGE << "Exception in encode frame.";
     ProcessHWError(true /* reset_if_fallback_unavailable */);
     return false;
   }
   return encode_status;
 }
 
 int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback(
-    webrtc::EncodedImageCallback* callback) {
+    EncodedImageCallback* callback) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::Release() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   if (!inited_) {
@@ skipping 20 matching lines @@
     rtc::CritScope lock(&inited_crit_);
 #endif
     inited_ = false;
   }
   use_surface_ = false;
   ALOGD << "EncoderRelease done.";
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::SetRateAllocation(
-    const webrtc::BitrateAllocation& rate_allocation,
+    const BitrateAllocation& rate_allocation,
     uint32_t frame_rate) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
   const uint32_t new_bit_rate = rate_allocation.get_sum_kbps();
   if (sw_fallback_required_)
     return WEBRTC_VIDEO_CODEC_OK;
   frame_rate =
       (frame_rate < MAX_ALLOWED_VIDEO_FPS) ? frame_rate : MAX_ALLOWED_VIDEO_FPS;
   if (last_set_bitrate_kbps_ == new_bit_rate && last_set_fps_ == frame_rate) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
@@ skipping 88 matching lines @@
     uint8_t* payload = reinterpret_cast<uint8_t*>(
         jni->GetDirectBufferAddress(j_output_buffer));
     if (CheckException(jni)) {
       ALOGE << "Exception in get direct buffer address.";
       ProcessHWError(true /* reset_if_fallback_unavailable */);
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
 
     // Callback - return encoded frame.
     const VideoCodecType codec_type = GetCodecType();
-    webrtc::EncodedImageCallback::Result callback_result(
-        webrtc::EncodedImageCallback::Result::OK);
+    EncodedImageCallback::Result callback_result(
+        EncodedImageCallback::Result::OK);
     if (callback_) {
-      std::unique_ptr<webrtc::EncodedImage> image(
-          new webrtc::EncodedImage(payload, payload_size, payload_size));
+      std::unique_ptr<EncodedImage> image(
+          new 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->content_type_ =
-          (codec_mode_ == webrtc::VideoCodecMode::kScreensharing)
-              ? webrtc::VideoContentType::SCREENSHARE
-              : webrtc::VideoContentType::UNSPECIFIED;
-      image->timing_.flags = webrtc::TimingFrameFlags::kInvalid;
-      image->_frameType =
-          (key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta);
+      image->content_type_ = (codec_mode_ == VideoCodecMode::kScreensharing)
+                                 ? VideoContentType::SCREENSHARE
+                                 : VideoContentType::UNSPECIFIED;
+      image->timing_.flags = TimingFrameFlags::kInvalid;
+      image->_frameType = (key_frame ? kVideoFrameKey : kVideoFrameDelta);
       image->_completeFrame = true;
-      webrtc::CodecSpecificInfo info;
+      CodecSpecificInfo info;
       memset(&info, 0, sizeof(info));
       info.codecType = codec_type;
       if (codec_type == kVideoCodecVP8) {
         info.codecSpecific.VP8.pictureId = picture_id_;
         info.codecSpecific.VP8.nonReference = false;
         info.codecSpecific.VP8.simulcastIdx = 0;
-        info.codecSpecific.VP8.temporalIdx = webrtc::kNoTemporalIdx;
+        info.codecSpecific.VP8.temporalIdx = kNoTemporalIdx;
         info.codecSpecific.VP8.layerSync = false;
-        info.codecSpecific.VP8.tl0PicIdx = webrtc::kNoTl0PicIdx;
-        info.codecSpecific.VP8.keyIdx = webrtc::kNoKeyIdx;
+        info.codecSpecific.VP8.tl0PicIdx = kNoTl0PicIdx;
+        info.codecSpecific.VP8.keyIdx = kNoKeyIdx;
       } else if (codec_type == kVideoCodecVP9) {
         if (key_frame) {
           gof_idx_ = 0;
         }
         info.codecSpecific.VP9.picture_id = picture_id_;
         info.codecSpecific.VP9.inter_pic_predicted = key_frame ? false : true;
         info.codecSpecific.VP9.flexible_mode = false;
         info.codecSpecific.VP9.ss_data_available = key_frame ? true : false;
         info.codecSpecific.VP9.tl0_pic_idx = tl0_pic_idx_++;
-        info.codecSpecific.VP9.temporal_idx = webrtc::kNoTemporalIdx;
-        info.codecSpecific.VP9.spatial_idx = webrtc::kNoSpatialIdx;
+        info.codecSpecific.VP9.temporal_idx = kNoTemporalIdx;
+        info.codecSpecific.VP9.spatial_idx = kNoSpatialIdx;
         info.codecSpecific.VP9.temporal_up_switch = true;
         info.codecSpecific.VP9.inter_layer_predicted = false;
         info.codecSpecific.VP9.gof_idx =
             static_cast<uint8_t>(gof_idx_++ % gof_.num_frames_in_gof);
         info.codecSpecific.VP9.num_spatial_layers = 1;
         info.codecSpecific.VP9.spatial_layer_resolution_present = false;
         if (info.codecSpecific.VP9.ss_data_available) {
           info.codecSpecific.VP9.spatial_layer_resolution_present = true;
           info.codecSpecific.VP9.width[0] = width_;
           info.codecSpecific.VP9.height[0] = height_;
           info.codecSpecific.VP9.gof.CopyGofInfoVP9(gof_);
         }
       }
       picture_id_ = (picture_id_ + 1) & 0x7FFF;
 
       // Generate a header describing a single fragment.
-      webrtc::RTPFragmentationHeader header;
+      RTPFragmentationHeader header;
       memset(&header, 0, sizeof(header));
       if (codec_type == kVideoCodecVP8 || codec_type == kVideoCodecVP9) {
         header.VerifyAndAllocateFragmentationHeader(1);
         header.fragmentationOffset[0] = 0;
         header.fragmentationLength[0] = image->_length;
         header.fragmentationPlType[0] = 0;
         header.fragmentationTimeDiff[0] = 0;
         if (codec_type == kVideoCodecVP8) {
           int qp;
-          if (webrtc::vp8::GetQp(payload, payload_size, &qp)) {
+          if (vp8::GetQp(payload, payload_size, &qp)) {
             current_acc_qp_ += qp;
             image->qp_ = qp;
           }
         } else if (codec_type == kVideoCodecVP9) {
           int qp;
-          if (webrtc::vp9::GetQp(payload, payload_size, &qp)) {
+          if (vp9::GetQp(payload, payload_size, &qp)) {
             current_acc_qp_ += qp;
             image->qp_ = qp;
           }
         }
       } else if (codec_type == kVideoCodecH264) {
         h264_bitstream_parser_.ParseBitstream(payload, payload_size);
         int qp;
         if (h264_bitstream_parser_.GetLastSliceQp(&qp)) {
           current_acc_qp_ += qp;
           image->qp_ = qp;
         }
         // For H.264 search for start codes.
-        const std::vector<webrtc::H264::NaluIndex> nalu_idxs =
-            webrtc::H264::FindNaluIndices(payload, payload_size);
+        const std::vector<H264::NaluIndex> nalu_idxs =
+            H264::FindNaluIndices(payload, payload_size);
         if (nalu_idxs.empty()) {
           ALOGE << "Start code is not found!";
           ALOGE << "Data:" <<  image->_buffer[0] << " " << image->_buffer[1]
               << " " << image->_buffer[2] << " " << image->_buffer[3]
               << " " << image->_buffer[4] << " " << image->_buffer[5];
           ProcessHWError(true /* reset_if_fallback_unavailable */);
           return false;
         }
         header.VerifyAndAllocateFragmentationHeader(nalu_idxs.size());
         for (size_t i = 0; i < nalu_idxs.size(); i++) {
@@ skipping 62 matching lines @@
         ". QP: " << (current_acc_qp_ / current_frames_divider) <<
         " for last " << statistic_time_ms << " ms.";
     stat_start_time_ms_ = rtc::TimeMillis();
     current_frames_ = 0;
     current_bytes_ = 0;
     current_acc_qp_ = 0;
     current_encoding_time_ms_ = 0;
   }
 }
 
-webrtc::VideoEncoder::ScalingSettings
-MediaCodecVideoEncoder::GetScalingSettings() const {
-  if (webrtc::field_trial::IsEnabled(kCustomQPThresholdsFieldTrial)) {
+VideoEncoder::ScalingSettings MediaCodecVideoEncoder::GetScalingSettings()
+    const {
+  if (field_trial::IsEnabled(kCustomQPThresholdsFieldTrial)) {
     const VideoCodecType codec_type = GetCodecType();
     std::string experiment_string =
-        webrtc::field_trial::FindFullName(kCustomQPThresholdsFieldTrial);
+        field_trial::FindFullName(kCustomQPThresholdsFieldTrial);
     ALOGD << "QP custom thresholds: " << experiment_string << " for codec "
           << codec_type;
     int low_vp8_qp_threshold;
     int high_vp8_qp_threshold;
     int low_h264_qp_threshold;
     int high_h264_qp_threshold;
     int parsed_values = sscanf(experiment_string.c_str(), "Enabled-%u,%u,%u,%u",
                                &low_vp8_qp_threshold, &high_vp8_qp_threshold,
                                &low_h264_qp_threshold, &high_h264_qp_threshold);
     if (parsed_values == 4) {
@@ skipping 49 matching lines @@
   bool is_h264_high_profile_hw_supported = jni->CallStaticBooleanMethod(
       j_decoder_class,
       GetStaticMethodID(jni, j_decoder_class, "isH264HighProfileHwSupported",
                         "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_h264_high_profile_hw_supported) {
     ALOGD << "H.264 High Profile HW Encoder supported.";
     // TODO(magjed): Enumerate actual level instead of using hardcoded level
     // 3.1. Level 3.1 is 1280x720@30fps which is enough for now.
     cricket::VideoCodec constrained_high(cricket::kH264CodecName);
-    const webrtc::H264::ProfileLevelId constrained_high_profile(
-        webrtc::H264::kProfileConstrainedHigh, webrtc::H264::kLevel3_1);
+    const H264::ProfileLevelId constrained_high_profile(
+        H264::kProfileConstrainedHigh, H264::kLevel3_1);
     constrained_high.SetParam(
         cricket::kH264FmtpProfileLevelId,
-        *webrtc::H264::ProfileLevelIdToString(constrained_high_profile));
+        *H264::ProfileLevelIdToString(constrained_high_profile));
     constrained_high.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1");
     constrained_high.SetParam(cricket::kH264FmtpPacketizationMode, "1");
     supported_codecs_with_h264_hp_.push_back(constrained_high);
   }
 
   bool is_h264_hw_supported = jni->CallStaticBooleanMethod(
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isH264HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_h264_hw_supported) {
     ALOGD << "H.264 HW Encoder supported.";
     // TODO(magjed): Push Constrained High profile as well when negotiation is
     // ready, http://crbug/webrtc/6337. We can negotiate Constrained High
     // profile as long as we have decode support for it and still send Baseline
     // since Baseline is a subset of the High profile.
     cricket::VideoCodec constrained_baseline(cricket::kH264CodecName);
-    const webrtc::H264::ProfileLevelId constrained_baseline_profile(
-        webrtc::H264::kProfileConstrainedBaseline, webrtc::H264::kLevel3_1);
+    const H264::ProfileLevelId constrained_baseline_profile(
+        H264::kProfileConstrainedBaseline, H264::kLevel3_1);
     constrained_baseline.SetParam(
         cricket::kH264FmtpProfileLevelId,
-        *webrtc::H264::ProfileLevelIdToString(constrained_baseline_profile));
+        *H264::ProfileLevelIdToString(constrained_baseline_profile));
     constrained_baseline.SetParam(cricket::kH264FmtpLevelAsymmetryAllowed, "1");
     constrained_baseline.SetParam(cricket::kH264FmtpPacketizationMode, "1");
     supported_codecs_.push_back(constrained_baseline);
     supported_codecs_with_h264_hp_.push_back(constrained_baseline);
   }
 }
 
 MediaCodecVideoEncoderFactory::~MediaCodecVideoEncoderFactory() {
   ALOGD << "MediaCodecVideoEncoderFactory dtor";
   if (egl_context_) {
     JNIEnv* jni = AttachCurrentThreadIfNeeded();
     jni->DeleteGlobalRef(egl_context_);
   }
 }
 
 void MediaCodecVideoEncoderFactory::SetEGLContext(
     JNIEnv* jni, jobject egl_context) {
   ALOGD << "MediaCodecVideoEncoderFactory::SetEGLContext";
   if (egl_context_) {
     jni->DeleteGlobalRef(egl_context_);
     egl_context_ = nullptr;
   }
   egl_context_ = jni->NewGlobalRef(egl_context);
   if (CheckException(jni)) {
     ALOGE << "error calling NewGlobalRef for EGL Context.";
   }
 }
 
-webrtc::VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
+VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
     const cricket::VideoCodec& codec) {
   if (supported_codecs().empty()) {
     ALOGW << "No HW video encoder for codec " << codec.name;
     return nullptr;
   }
   if (FindMatchingCodec(supported_codecs(), codec)) {
     ALOGD << "Create HW video encoder for " << codec.name;
     JNIEnv* jni = AttachCurrentThreadIfNeeded();
     ScopedLocalRefFrame local_ref_frame(jni);
     return new MediaCodecVideoEncoder(jni, codec, egl_context_);
   }
   ALOGW << "Can not find HW video encoder for type " << codec.name;
   return nullptr;
 }
 
 const std::vector<cricket::VideoCodec>&
 MediaCodecVideoEncoderFactory::supported_codecs() const {
-  if (webrtc::field_trial::IsEnabled(kH264HighProfileFieldTrial)) {
+  if (field_trial::IsEnabled(kH264HighProfileFieldTrial)) {
     return supported_codecs_with_h264_hp_;
   } else {
     return supported_codecs_;
   }
 }
 
-void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
-    webrtc::VideoEncoder* encoder) {
+void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 JNI_FUNCTION_DECLARATION(void,
                          MediaCodecVideoEncoder_nativeFillBuffer,
                          JNIEnv* jni,
                          jclass,
                          jlong native_encoder,
                          jint input_buffer,
                          jobject j_buffer_y,
                          jint stride_y,
                          jobject j_buffer_u,
                          jint stride_u,
                          jobject j_buffer_v,
                          jint stride_v) {
   uint8_t* buffer_y =
       static_cast<uint8_t*>(jni->GetDirectBufferAddress(j_buffer_y));
   uint8_t* buffer_u =
       static_cast<uint8_t*>(jni->GetDirectBufferAddress(j_buffer_u));
   uint8_t* buffer_v =
       static_cast<uint8_t*>(jni->GetDirectBufferAddress(j_buffer_v));
 
   reinterpret_cast<MediaCodecVideoEncoder*>(native_encoder)
       ->FillInputBuffer(jni, input_buffer, buffer_y, stride_y, buffer_u,
                         stride_u, buffer_v, stride_v);
 }
 
-}  // namespace webrtc_jni
+}  // namespace jni
+}  // namespace webrtc