Implement QP parsing in VideoDecoderWrapper.

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/sdk/android/src/jni/classreferenceholder.h"
 
 namespace webrtc_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 38 matching lines @@
   get_implementation_name_method_ = jni->GetMethodID(
       decoder_class, "getImplementationName", "()Ljava/lang/String;");
 
   get_number_method_ =
       jni->GetMethodID(*video_codec_status_class_, "getNumber", "()I");
 
   integer_constructor_ = jni->GetMethodID(*integer_class_, "<init>", "(I)V");
   int_value_method_ = jni->GetMethodID(*integer_class_, "intValue", "()I");
 
   initialized_ = false;
+  // QP parsing starts enabled and we disable it if the decoder provides frames.
+  qp_parsing_enabled_ = true;
 }
 
 int32_t VideoDecoderWrapper::InitDecode(
     const webrtc::VideoCodec* codec_settings,
     int32_t number_of_cores) {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   codec_settings_ = *codec_settings;
   number_of_cores_ = number_of_cores;
@@ skipping 10 matching lines @@
   jmethodID callback_constructor =
       jni->GetMethodID(callback_class, "<init>", "(J)V");
   jobject callback = jni->NewObject(callback_class, callback_constructor,
                                     jlongFromPointer(this));
 
   jobject ret =
       jni->CallObjectMethod(*decoder_, init_decode_method_, settings, callback);
   if (jni->CallIntMethod(ret, get_number_method_) == WEBRTC_VIDEO_CODEC_OK) {
     initialized_ = true;
   }
+
+  // The decoder was reinitialized so re-enable the QP parsing in case it stops
+  // providing QP values.
+  qp_parsing_enabled_ = true;
+
   return HandleReturnCode(jni, ret);
 }
 
 int32_t VideoDecoderWrapper::Decode(
     const webrtc::EncodedImage& input_image,
     bool missing_frames,
     const webrtc::RTPFragmentationHeader* fragmentation,
     const webrtc::CodecSpecificInfo* codec_specific_info,
     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.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);
 }
 
 int32_t VideoDecoderWrapper::RegisterDecodeCompleteCallback(
@@ skipping 49 matching lines @@
 
   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_));
   }
 
   rtc::Optional<uint8_t> qp;
   if (jqp != nullptr) {
     qp = rtc::Optional<uint8_t>(jni->CallIntMethod(jqp, int_value_method_));
+    // The decoder provides QP values itself, no need to parse the bitstream.
+    qp_parsing_enabled_ = false;
+  } else {
+    qp = frame_extra_info.qp;
+    // The decoder doesn't provide QP values, ensure bitstream parsing is
+    // enabled.
+    qp_parsing_enabled_ = true;
   }
 
-  callback_->Decoded(frame, decoding_time_ms, rtc::Optional<uint8_t>());
+  callback_->Decoded(frame, decoding_time_ms, qp);
 }
 
 jobject VideoDecoderWrapper::ConvertEncodedImageToJavaEncodedImage(
     JNIEnv* jni,
     const webrtc::EncodedImage& image) {
   jobject buffer = jni->NewDirectByteBuffer(image._buffer, image._length);
   jfieldID frame_type_field;
   switch (image._frameType) {
     case webrtc::kEmptyFrame:
       frame_type_field = empty_frame_field_;
@@ skipping 30 matching lines @@
       InitDecodeInternal(jni);
     }
 
     LOG(LS_WARNING) << "Falling back to software decoder.";
     return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   } else {
     return value;
   }
 }
 
+rtc::Optional<uint8_t> VideoDecoderWrapper::ParseQP(
+    const webrtc::EncodedImage& input_image) {
+  if (input_image.qp_ != -1) {
+    return rtc::Optional<uint8_t>(input_image.qp_);
+  }
+
+  rtc::Optional<uint8_t> qp;
+  switch (codec_settings_.codecType) {
+    case webrtc::kVideoCodecVP8: {
+      int qp_int;
+      if (webrtc::vp8::GetQp(input_image._buffer, input_image._length,
+                             &qp_int)) {
+        qp = rtc::Optional<uint8_t>(qp_int);
+      }
+      break;
+    }
+    case webrtc::kVideoCodecVP9: {
+      int qp_int;
+      if (webrtc::vp9::GetQp(input_image._buffer, input_image._length,
+                             &qp_int)) {
+        qp = rtc::Optional<uint8_t>(qp_int);
+      }
+      break;
+    }
+    case webrtc::kVideoCodecH264: {
+      h264_bitstream_parser_.ParseBitstream(input_image._buffer,
+                                            input_image._length);
+      int qp_int;
+      if (h264_bitstream_parser_.GetLastSliceQp(&qp_int)) {
+        qp = rtc::Optional<uint8_t>(qp_int);
+      }
+      break;
+    }
+    default:
+      break;  // Default is to not provide QP.
+  }
+  return qp;
+}
+
 JOW(void, VideoDecoderWrapperCallback_nativeOnDecodedFrame)
 (JNIEnv* jni,
  jclass,
  jlong jnative_decoder,
  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 webrtc_jni