Use WebRTC logging in MediaCodec JNI code.

talk/app/webrtc/java/jni/androidmediaencoder_jni.cc

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 269 matching lines @@
 }
 
 int32_t MediaCodecVideoEncoder::InitEncode(
     const webrtc::VideoCodec* codec_settings,
     int32_t /* number_of_cores */,
     size_t /* max_payload_size */) {
   const int kMinWidth = 320;
   const int kMinHeight = 180;
   const int kLowQpThresholdDenominator = 3;
   if (codec_settings == NULL) {
-    ALOGE("NULL VideoCodec instance");
+    ALOGE << "NULL VideoCodec instance";
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // Factory should guard against other codecs being used with us.
   RTC_CHECK(codec_settings->codecType == codecType_)
       << "Unsupported codec " << codec_settings->codecType << " for "
       << codecType_;
 
-  ALOGD("InitEncode request");
+  ALOGD << "InitEncode request";
   scale_ = webrtc::field_trial::FindFullName(
       "WebRTC-MediaCodecVideoEncoder-AutomaticResize") == "Enabled";
-  ALOGD("Automatic resize: %s", scale_ ? "enabled" : "disabled");
+  ALOGD << "Encoder automatic resize " << (scale_ ? "enabled" : "disabled");
   if (scale_) {
     if (codecType_ == kVideoCodecVP8) {
       // QP is obtained from VP8-bitstream for HW, so the QP corresponds to the
       // (internal) range: [0, 127]. And we cannot change QP_max in HW, so it is
       // always = 127. Note that in SW, QP is that of the user-level range [0,
       // 63].
       const int kMaxQp = 127;
       // TODO(pbos): Investigate whether high-QP thresholds make sense for VP8.
       // This effectively disables high QP as VP8 QP can't go above this
       // threshold.
@@ skipping 33 matching lines @@
 
 int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback(
     webrtc::EncodedImageCallback* callback) {
   return codec_thread_->Invoke<int32_t>(
       Bind(&MediaCodecVideoEncoder::RegisterEncodeCompleteCallbackOnCodecThread,
            this,
            callback));
 }
 
 int32_t MediaCodecVideoEncoder::Release() {
-  ALOGD("EncoderRelease request");
+  ALOGD << "EncoderRelease request";
   return codec_thread_->Invoke<int32_t>(
       Bind(&MediaCodecVideoEncoder::ReleaseOnCodecThread, this));
 }
 
 int32_t MediaCodecVideoEncoder::SetChannelParameters(uint32_t /* packet_loss */,
                                                      int64_t /* rtt */) {
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::SetRates(uint32_t new_bit_rate,
@@ skipping 27 matching lines @@
   DeliverPendingOutputs(jni);
   codec_thread_->PostDelayed(kMediaCodecPollMs, this);
 }
 
 void MediaCodecVideoEncoder::CheckOnCodecThread() {
   RTC_CHECK(codec_thread_ == ThreadManager::Instance()->CurrentThread())
       << "Running on wrong thread!";
 }
 
 void MediaCodecVideoEncoder::ResetCodec() {
-  ALOGE("ResetCodec");
+  ALOGE << "ResetCodec";
   if (Release() != WEBRTC_VIDEO_CODEC_OK ||
       codec_thread_->Invoke<int32_t>(Bind(
           &MediaCodecVideoEncoder::InitEncodeOnCodecThread, this,
           width_, height_, 0, 0)) != WEBRTC_VIDEO_CODEC_OK) {
     // TODO(fischman): wouldn't it be nice if there was a way to gracefully
     // degrade to a SW encoder at this point?  There isn't one AFAICT :(
     // https://code.google.com/p/webrtc/issues/detail?id=2920
   }
 }
 
 int32_t MediaCodecVideoEncoder::InitEncodeOnCodecThread(
     int width, int height, int kbps, int fps) {
   CheckOnCodecThread();
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
-  ALOGD("InitEncodeOnCodecThread Type: %d. %d x %d. Bitrate: %d kbps. Fps: %d",
-      (int)codecType_, width, height, kbps, fps);
+  ALOGD << "InitEncodeOnCodecThread Type: " <<  (int)codecType_ << ", " <<
+      width << " x " << height << ". Bitrate: " << kbps <<
+      " kbps. Fps: " << fps;
   if (kbps == 0) {
     kbps = last_set_bitrate_kbps_;
   }
   if (fps == 0) {
     fps = last_set_fps_;
   }
 
   width_ = width;
   height_ = height;
   last_set_bitrate_kbps_ = kbps;
@@ skipping 90 matching lines @@
 
   RTC_CHECK(frame_types->size() == 1) << "Unexpected stream count";
   // Check framerate before spatial resolution change.
   if (scale_)
     quality_scaler_.OnEncodeFrame(frame);
 
   const VideoFrame& input_frame =
       scale_ ? quality_scaler_.GetScaledFrame(frame) : frame;
 
   if (input_frame.width() != width_ || input_frame.height() != height_) {
-    ALOGD("Frame resolution change from %d x %d to %d x %d",
-          width_, height_, input_frame.width(), input_frame.height());
+    ALOGD << "Frame resolution change from " << width_ << " x " << height_ <<
+        " to " << input_frame.width() << " x " << input_frame.height();
     width_ = input_frame.width();
     height_ = input_frame.height();
     ResetCodec();
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   // Check if we accumulated too many frames in encoder input buffers
   // or the encoder latency exceeds 70 ms and drop frame if so.
   if (frames_in_queue_ > 0 && last_input_timestamp_ms_ >= 0) {
     int encoder_latency_ms = last_input_timestamp_ms_ -
         last_output_timestamp_ms_;
     if (frames_in_queue_ > 2 || encoder_latency_ms > 70) {
-      ALOGD("Drop frame - encoder is behind by %d ms. Q size: %d",
-          encoder_latency_ms, frames_in_queue_);
+      ALOGD << "Drop frame - encoder is behind by " << encoder_latency_ms <<
+          " ms. Q size: " << frames_in_queue_;
       frames_dropped_++;
       // Report dropped frame to quality_scaler_.
       OnDroppedFrame();
       return WEBRTC_VIDEO_CODEC_OK;
     }
   }
 
   int j_input_buffer_index = jni->CallIntMethod(*j_media_codec_video_encoder_,
                                                 j_dequeue_input_buffer_method_);
   CHECK_EXCEPTION(jni);
@@ skipping 58 matching lines @@
   callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::ReleaseOnCodecThread() {
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   CheckOnCodecThread();
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
-  ALOGD("EncoderReleaseOnCodecThread: Frames received: %d. Encoded: %d. "
-      "Dropped: %d.", frames_received_, frames_encoded_, frames_dropped_);
+  ALOGD << "EncoderReleaseOnCodecThread: Frames received: " <<
+      frames_received_ << ". Encoded: " << frames_encoded_ <<
+      ". Dropped: " << frames_dropped_;
   ScopedLocalRefFrame local_ref_frame(jni);
   for (size_t i = 0; i < input_buffers_.size(); ++i)
     jni->DeleteGlobalRef(input_buffers_[i]);
   input_buffers_.clear();
   jni->CallVoidMethod(*j_media_codec_video_encoder_, j_release_method_);
   CHECK_EXCEPTION(jni);
   rtc::MessageQueueManager::Clear(this);
   inited_ = false;
+  ALOGD << "EncoderReleaseOnCodecThread done.";
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::SetRatesOnCodecThread(uint32_t new_bit_rate,
                                                       uint32_t frame_rate) {
   CheckOnCodecThread();
   if (last_set_bitrate_kbps_ == new_bit_rate &&
       last_set_fps_ == frame_rate) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
@@ skipping 92 matching lines @@
         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;
     int statistic_time_ms = GetCurrentTimeMs() - start_time_ms_;
     if (statistic_time_ms >= kMediaCodecStatisticsIntervalMs &&
         current_frames_ > 0) {
-      ALOGD("Encoder bitrate: %d, target: %d kbps, fps: %d,"
-          " encTime: %d for last %d ms",
-          current_bytes_ * 8 / statistic_time_ms,
-          last_set_bitrate_kbps_,
-          (current_frames_ * 1000 + statistic_time_ms / 2) / statistic_time_ms,
-          current_encoding_time_ms_ / current_frames_, statistic_time_ms);
+      ALOGD << "Encoded frames: " << frames_encoded_ << ". Bitrate: " <<
+          (current_bytes_ * 8 / statistic_time_ms) <<
+          ", target: " << last_set_bitrate_kbps_ << " kbps, fps: " <<
+          ((current_frames_ * 1000 + statistic_time_ms / 2) / statistic_time_ms)
+          << ", encTime: " <<
+          (current_encoding_time_ms_ / current_frames_) << " for last " <<
+          statistic_time_ms << " ms.";
       start_time_ms_ = GetCurrentTimeMs();
       current_frames_ = 0;
       current_bytes_ = 0;
       current_encoding_time_ms_ = 0;
     }
 
     // Callback - return encoded frame.
     int32_t callback_status = 0;
     if (callback_) {
       scoped_ptr<webrtc::EncodedImage> image(
@@ skipping 45 matching lines @@
           int32_t naluPosition = NextNaluPosition(
               payload + scPosition, payload_size - scPosition);
           if (naluPosition < 0) {
             break;
           }
           scPosition += naluPosition;
           scPositions[scPositionsLength++] = scPosition;
           scPosition += H264_SC_LENGTH;
         }
         if (scPositionsLength == 0) {
-          ALOGE("Start code is not found!");
-          ALOGE("Data 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x",
-              image->_buffer[0], image->_buffer[1], image->_buffer[2],
-              image->_buffer[3], image->_buffer[4], image->_buffer[5]);
+          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];
           ResetCodec();
           return false;
         }
         scPositions[scPositionsLength] = payload_size;
         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;
@@ skipping 69 matching lines @@
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   jclass j_encoder_class = FindClass(jni, "org/webrtc/MediaCodecVideoEncoder");
   supported_codecs_.clear();
 
   bool is_vp8_hw_supported = jni->CallStaticBooleanMethod(
       j_encoder_class,
       GetStaticMethodID(jni, j_encoder_class, "isVp8HwSupported", "()Z"));
   CHECK_EXCEPTION(jni);
   if (is_vp8_hw_supported) {
-    ALOGD("VP8 HW Encoder supported.");
+    ALOGD << "VP8 HW Encoder supported.";
     supported_codecs_.push_back(VideoCodec(kVideoCodecVP8, "VP8",
         MAX_VIDEO_WIDTH, MAX_VIDEO_HEIGHT, MAX_VIDEO_FPS));
   }
 
   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.");
+    ALOGD << "H.264 HW Encoder supported.";
     supported_codecs_.push_back(VideoCodec(kVideoCodecH264, "H264",
         MAX_VIDEO_WIDTH, MAX_VIDEO_HEIGHT, MAX_VIDEO_FPS));
   }
 }
 
 MediaCodecVideoEncoderFactory::~MediaCodecVideoEncoderFactory() {}
 
 webrtc::VideoEncoder* MediaCodecVideoEncoderFactory::CreateVideoEncoder(
     VideoCodecType type) {
   if (supported_codecs_.empty()) {
     return NULL;
   }
   for (std::vector<VideoCodec>::const_iterator it = supported_codecs_.begin();
          it != supported_codecs_.end(); ++it) {
     if (it->type == type) {
-      ALOGD("Create HW video encoder for type %d (%s).",
-          (int)type, it->name.c_str());
+      ALOGD << "Create HW video encoder for type " << (int)type <<
+          " (" << it->name << ").";
       return new MediaCodecVideoEncoder(AttachCurrentThreadIfNeeded(), type);
     }
   }
   return NULL;
 }
 
 const std::vector<MediaCodecVideoEncoderFactory::VideoCodec>&
 MediaCodecVideoEncoderFactory::codecs() const {
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
-  ALOGD("Destroy video encoder.");
+  ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni