Change capture time format to nanoseconds in EncodedImage.

webrtc/sdk/android/src/jni/videodecoderwrapper.cc

 /*
  *  Copyright 2017 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.
  */
 
 #include "webrtc/sdk/android/src/jni/videodecoderwrapper.h"
 
 #include "webrtc/api/video/video_frame.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/utility/vp8_header_parser.h"
 #include "webrtc/modules/video_coding/utility/vp9_uncompressed_header_parser.h"
 #include "webrtc/rtc_base/logging.h"
+#include "webrtc/rtc_base/timeutils.h"
 #include "webrtc/sdk/android/src/jni/classreferenceholder.h"
 
 namespace webrtc {
 namespace jni {
 
 VideoDecoderWrapper::VideoDecoderWrapper(JNIEnv* jni, jobject decoder)
     : android_video_buffer_factory_(jni),
       decoder_(jni, decoder),
       encoded_image_class_(jni, FindClass(jni, "org/webrtc/EncodedImage")),
       frame_type_class_(jni,
@@ skipping 92 matching lines @@
     int64_t render_time_ms) {
   if (!initialized_) {
     // Most likely initializing the codec failed.
     return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   }
 
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   FrameExtraInfo frame_extra_info;
-  frame_extra_info.capture_time_ms = input_image.capture_time_ms_;
+  frame_extra_info.capture_time_ns =
+      input_image.capture_time_ms_ * rtc::kNumNanosecsPerMillisec;
   frame_extra_info.timestamp_rtp = input_image._timeStamp;
   frame_extra_info.qp =
       qp_parsing_enabled_ ? ParseQP(input_image) : rtc::Optional<uint8_t>();
   frame_extra_infos_.push_back(frame_extra_info);
 
   jobject jinput_image =
       ConvertEncodedImageToJavaEncodedImage(jni, input_image);
   jobject ret =
       jni->CallObjectMethod(*decoder_, decode_method_, jinput_image, nullptr);
   return HandleReturnCode(jni, ret);
@@ skipping 26 matching lines @@
       jni->CallObjectMethod(*decoder_, get_implementation_name_method_));
   return JavaToStdString(jni, jname).c_str();
 }
 
 void VideoDecoderWrapper::OnDecodedFrame(JNIEnv* jni,
                                          jobject jframe,
                                          jobject jdecode_time_ms,
                                          jobject jqp) {
   const jlong capture_time_ns =
       jni->CallLongMethod(jframe, video_frame_get_timestamp_ns_method_);
-  const uint32_t capture_time_ms = capture_time_ns / 1000 / 1000;
   FrameExtraInfo frame_extra_info;
   do {
     if (frame_extra_infos_.empty()) {
       LOG(LS_WARNING) << "Java decoder produced an unexpected frame.";
       return;
     }
 
     frame_extra_info = frame_extra_infos_.front();
     frame_extra_infos_.pop_front();
     // If the decoder might drop frames so iterate through the queue until we
     // find a matching timestamp.
-  } while (frame_extra_info.capture_time_ms != capture_time_ms);
+  } while (frame_extra_info.capture_time_ns != capture_time_ns);
 
   VideoFrame frame = android_video_buffer_factory_.CreateFrame(
       jni, jframe, frame_extra_info.timestamp_rtp);
 
   rtc::Optional<int32_t> decoding_time_ms;
   if (jdecode_time_ms != nullptr) {
     decoding_time_ms = rtc::Optional<int32_t>(
         jni->CallIntMethod(jdecode_time_ms, int_value_method_));
   }
 
@@ skipping 30 matching lines @@
     default:
       RTC_NOTREACHED();
       return nullptr;
   }
   jobject frame_type =
       jni->GetStaticObjectField(*frame_type_class_, frame_type_field);
   jobject qp = nullptr;
   if (image.qp_ != -1) {
     qp = jni->NewObject(*integer_class_, integer_constructor_, image.qp_);
   }
-  return jni->NewObject(*encoded_image_class_, encoded_image_constructor_,
-                        buffer, static_cast<jint>(image._encodedWidth),
-                        static_cast<jint>(image._encodedHeight),
-                        static_cast<jlong>(image.capture_time_ms_), frame_type,
-                        static_cast<jint>(image.rotation_),
-                        image._completeFrame, qp);
+  return jni->NewObject(
+      *encoded_image_class_, encoded_image_constructor_, buffer,
+      static_cast<jint>(image._encodedWidth),
+      static_cast<jint>(image._encodedHeight),
+      static_cast<jlong>(image.capture_time_ms_ * rtc::kNumNanosecsPerMillisec),
+      frame_type, static_cast<jint>(image.rotation_), image._completeFrame, qp);
 }
 
 int32_t VideoDecoderWrapper::HandleReturnCode(JNIEnv* jni, jobject code) {
   int32_t value = jni->CallIntMethod(code, get_number_method_);
   if (value < 0) {  // Any errors are represented by negative values.
     // Reset the codec.
     if (Release() == WEBRTC_VIDEO_CODEC_OK) {
       InitDecodeInternal(jni);
     }
 
@@ skipping 49 matching lines @@
                          jobject jframe,
                          jobject jdecode_time_ms,
                          jobject jqp) {
   VideoDecoderWrapper* native_decoder =
       reinterpret_cast<VideoDecoderWrapper*>(jnative_decoder);
   native_decoder->OnDecodedFrame(jni, jframe, jdecode_time_ms, jqp);
 }
 
 }  // namespace jni
 }  // namespace webrtc