Android: Replace webrtc_jni namespace with nested jni namespace

webrtc/sdk/android/src/jni/androidmediadecoder_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 21 matching lines @@
 #include "webrtc/rtc_base/timeutils.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/sdk/android/src/jni/surfacetexturehelper_jni.h"
 
 using rtc::Bind;
 using rtc::Thread;
 using rtc::ThreadManager;
 
-using webrtc::CodecSpecificInfo;
-using webrtc::DecodedImageCallback;
-using webrtc::EncodedImage;
-using webrtc::VideoFrame;
-using webrtc::RTPFragmentationHeader;
-using webrtc::VideoCodec;
-using webrtc::VideoCodecType;
-using webrtc::kVideoCodecH264;
-using webrtc::kVideoCodecVP8;
-using webrtc::kVideoCodecVP9;
-
-namespace webrtc_jni {
+namespace webrtc {
+namespace jni {
 
 // Logging macros.
 #define TAG_DECODER "MediaCodecVideoDecoder"
 #ifdef TRACK_BUFFER_TIMING
 #define ALOGV(...) \
   __android_log_print(ANDROID_LOG_VERBOSE, TAG_DECODER, __VA_ARGS__)
 #else
 #define ALOGV(...)
 #endif
 #define ALOGD LOG_TAG(rtc::LS_INFO, TAG_DECODER)
 #define ALOGW LOG_TAG(rtc::LS_WARNING, TAG_DECODER)
 #define ALOGE LOG_TAG(rtc::LS_ERROR, TAG_DECODER)
 
 enum { kMaxWarningLogFrames = 2 };
 
-class MediaCodecVideoDecoder : public webrtc::VideoDecoder,
-                               public rtc::MessageHandler {
+class MediaCodecVideoDecoder : public VideoDecoder, public rtc::MessageHandler {
  public:
   explicit MediaCodecVideoDecoder(
       JNIEnv* jni, VideoCodecType codecType, jobject render_egl_context);
   virtual ~MediaCodecVideoDecoder();
 
   int32_t InitDecode(const VideoCodec* codecSettings, int32_t numberOfCores)
       override;
 
   int32_t Decode(
       const EncodedImage& inputImage, bool missingFrames,
@@ skipping 33 matching lines @@
 
   // Render EGL context - owned by factory, should not be allocated/destroyed
   // by VideoDecoder.
   jobject render_egl_context_;
 
   bool key_frame_required_;
   bool inited_;
   bool sw_fallback_required_;
   bool use_surface_;
   VideoCodec codec_;
-  webrtc::I420BufferPool decoded_frame_pool_;
+  I420BufferPool decoded_frame_pool_;
   rtc::scoped_refptr<SurfaceTextureHelper> surface_texture_helper_;
   DecodedImageCallback* callback_;
   int frames_received_;  // Number of frames received by decoder.
   int frames_decoded_;  // Number of frames decoded by decoder.
   // Number of decoded frames for which log information is displayed.
   int frames_decoded_logged_;
   int64_t 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_decoding_time_ms_;  // Overall decoding time in the current second
   int current_delay_time_ms_;  // Overall delay time in the current second.
   uint32_t max_pending_frames_;  // Maximum number of pending input frames.
-  webrtc::H264BitstreamParser h264_bitstream_parser_;
+  H264BitstreamParser h264_bitstream_parser_;
   std::deque<rtc::Optional<uint8_t>> pending_frame_qps_;
 
   // State that is constant for the lifetime of this object once the ctor
   // returns.
   std::unique_ptr<Thread>
       codec_thread_;  // Thread on which to operate MediaCodec.
   ScopedGlobalRef<jclass> j_media_codec_video_decoder_class_;
   ScopedGlobalRef<jobject> j_media_codec_video_decoder_;
   jmethodID j_init_decode_method_;
   jmethodID j_reset_method_;
@@ skipping 406 matching lines @@
     }
     if (ret < 0) {
       ALOGE << "InitDecode failure: " << ret << " - fallback to SW codec";
       sw_fallback_required_ = true;
       return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
     }
   }
 
   // Always start with a complete key frame.
   if (key_frame_required_) {
-    if (inputImage._frameType != webrtc::kVideoFrameKey) {
+    if (inputImage._frameType != kVideoFrameKey) {
       ALOGE << "Decode() - key frame is required";
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
     if (!inputImage._completeFrame) {
       ALOGE << "Decode() - complete frame is required";
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
     key_frame_required_ = false;
   }
   if (inputImage._length == 0) {
@@ skipping 79 matching lines @@
         ". TS: " << presentation_timestamp_us / 1000 <<
         ". Size: " << inputImage._length;
   }
 
   // Save input image timestamps for later output.
   frames_received_++;
   current_bytes_ += inputImage._length;
   rtc::Optional<uint8_t> qp;
   if (codecType_ == kVideoCodecVP8) {
     int qp_int;
-    if (webrtc::vp8::GetQp(inputImage._buffer, inputImage._length, &qp_int)) {
+    if (vp8::GetQp(inputImage._buffer, inputImage._length, &qp_int)) {
       qp = rtc::Optional<uint8_t>(qp_int);
     }
   } else if (codecType_ == kVideoCodecH264) {
     h264_bitstream_parser_.ParseBitstream(inputImage._buffer,
                                           inputImage._length);
     int qp_int;
     if (h264_bitstream_parser_.GetLastSliceQp(&qp_int)) {
       qp = rtc::Optional<uint8_t>(qp_int);
     }
   }
@@ skipping 44 matching lines @@
     // No decoded frame ready.
     return true;
   }
 
   // Get decoded video frame properties.
   int color_format = GetIntField(jni, *j_media_codec_video_decoder_,
       j_color_format_field_);
   int width = GetIntField(jni, *j_media_codec_video_decoder_, j_width_field_);
   int height = GetIntField(jni, *j_media_codec_video_decoder_, j_height_field_);
 
-  rtc::scoped_refptr<webrtc::VideoFrameBuffer> frame_buffer;
+  rtc::scoped_refptr<VideoFrameBuffer> frame_buffer;
   int64_t presentation_timestamps_ms = 0;
   int64_t output_timestamps_ms = 0;
   int64_t output_ntp_timestamps_ms = 0;
   int decode_time_ms = 0;
   int64_t frame_delayed_ms = 0;
   if (use_surface_) {
     // Extract data from Java DecodedTextureBuffer.
     presentation_timestamps_ms = GetLongField(
         jni, j_decoder_output_buffer,
         j_texture_presentation_timestamp_ms_field_);
     output_timestamps_ms = GetLongField(
         jni, j_decoder_output_buffer, j_texture_timestamp_ms_field_);
     output_ntp_timestamps_ms = GetLongField(
         jni, j_decoder_output_buffer, j_texture_ntp_timestamp_ms_field_);
     decode_time_ms = GetLongField(
         jni, j_decoder_output_buffer, j_texture_decode_time_ms_field_);
 
     const int texture_id =
         GetIntField(jni, j_decoder_output_buffer, j_texture_id_field_);
     if (texture_id != 0) {  // |texture_id| == 0 represents a dropped frame.
       const jfloatArray j_transform_matrix =
           reinterpret_cast<jfloatArray>(GetObjectField(
               jni, j_decoder_output_buffer, j_transform_matrix_field_));
       frame_delayed_ms = GetLongField(
           jni, j_decoder_output_buffer, j_texture_frame_delay_ms_field_);
 
-      // Create webrtc::VideoFrameBuffer with native texture handle.
+      // Create VideoFrameBuffer with native texture handle.
       frame_buffer = surface_texture_helper_->CreateTextureFrame(
           width, height, NativeHandleImpl(jni, texture_id, j_transform_matrix));
     } else {
       EnableFrameLogOnWarning();
     }
   } else {
     // Extract data from Java ByteBuffer and create output yuv420 frame -
     // for non surface decoding only.
     int stride =
         GetIntField(jni, *j_media_codec_video_decoder_, j_stride_field_);
@@ skipping 31 matching lines @@
     jobject output_buffer =
         jni->GetObjectArrayElement(output_buffers, output_buffer_index);
     uint8_t* payload = reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(
         output_buffer));
     if (CheckException(jni)) {
       return false;
     }
     payload += output_buffer_offset;
 
     // Create yuv420 frame.
-    rtc::scoped_refptr<webrtc::I420Buffer> i420_buffer =
+    rtc::scoped_refptr<I420Buffer> i420_buffer =
         decoded_frame_pool_.CreateBuffer(width, height);
     if (color_format == COLOR_FormatYUV420Planar) {
       RTC_CHECK_EQ(0, stride % 2);
       const int uv_stride = stride / 2;
       const uint8_t* y_ptr = payload;
       const uint8_t* u_ptr = y_ptr + stride * slice_height;
 
       // Note that the case with odd |slice_height| is handled in a special way.
       // The chroma height contained in the payload is rounded down instead of
       // up, making it one row less than what we expect in WebRTC. Therefore, we
@@ skipping 77 matching lines @@
         " for last " << statistic_time_ms << " ms.";
     start_time_ms_ = rtc::TimeMillis();
     current_frames_ = 0;
     current_bytes_ = 0;
     current_decoding_time_ms_ = 0;
     current_delay_time_ms_ = 0;
   }
 
   // If the frame was dropped, frame_buffer is left as nullptr.
   if (frame_buffer) {
-    VideoFrame decoded_frame(frame_buffer, 0, 0, webrtc::kVideoRotation_0);
+    VideoFrame decoded_frame(frame_buffer, 0, 0, kVideoRotation_0);
     decoded_frame.set_timestamp(output_timestamps_ms);
     decoded_frame.set_ntp_time_ms(output_ntp_timestamps_ms);
 
     rtc::Optional<uint8_t> qp = pending_frame_qps_.front();
     pending_frame_qps_.pop_front();
     callback_->Decoded(decoded_frame, rtc::Optional<int32_t>(decode_time_ms),
                        qp);
   }
   return true;
 }
@@ skipping 80 matching lines @@
   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::VideoDecoder* MediaCodecVideoDecoderFactory::CreateVideoDecoder(
+VideoDecoder* MediaCodecVideoDecoderFactory::CreateVideoDecoder(
     VideoCodecType type) {
   if (supported_codec_types_.empty()) {
     ALOGW << "No HW video decoder for type " << (int)type;
     return nullptr;
   }
   for (VideoCodecType codec_type : supported_codec_types_) {
     if (codec_type == type) {
       ALOGD << "Create HW video decoder for type " << (int)type;
       JNIEnv* jni = AttachCurrentThreadIfNeeded();
       ScopedLocalRefFrame local_ref_frame(jni);
       return new MediaCodecVideoDecoder(jni, type, egl_context_);
     }
   }
   ALOGW << "Can not find HW video decoder for type " << (int)type;
   return nullptr;
 }
 
-void MediaCodecVideoDecoderFactory::DestroyVideoDecoder(
-    webrtc::VideoDecoder* decoder) {
+void MediaCodecVideoDecoderFactory::DestroyVideoDecoder(VideoDecoder* decoder) {
   ALOGD << "Destroy video decoder.";
   delete decoder;
 }
 
 const char* MediaCodecVideoDecoder::ImplementationName() const {
   return "MediaCodec";
 }
 
-}  // namespace webrtc_jni
+}  // namespace jni
+}  // namespace webrtc