Revert of Stop using hardcoded payload types for video codecs

webrtc/api/android/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 12 matching lines @@
 #include "webrtc/api/android/jni/classreferenceholder.h"
 #include "webrtc/api/android/jni/native_handle_impl.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/h264/h264_bitstream_parser.h"
-#include "webrtc/media/engine/internalencoderfactory.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/utility/quality_scaler.h"
 #include "webrtc/modules/video_coding/utility/vp8_header_parser.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/logcat_trace_context.h"
 
 using rtc::Bind;
 using rtc::Thread;
 using rtc::ThreadManager;
 
@@ skipping 46 matching lines @@
 // 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 is created, operated, and destroyed on a single
 // thread, currently the libjingle Worker thread.
 class MediaCodecVideoEncoder : public webrtc::VideoEncoder,
                                public rtc::MessageHandler {
  public:
   virtual ~MediaCodecVideoEncoder();
   MediaCodecVideoEncoder(JNIEnv* jni,
-                         const cricket::VideoCodec& codec,
+                         VideoCodecType codecType,
                          jobject egl_context);
 
   // webrtc::VideoEncoder implementation.  Everything trampolines to
   // |codec_thread_| for execution.
   int32_t InitEncode(const webrtc::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;
@@ skipping 69 matching lines @@
   // true on success.
   bool DeliverPendingOutputs(JNIEnv* jni);
 
   // Search for H.264 start codes.
   int32_t NextNaluPosition(uint8_t *buffer, size_t buffer_size);
 
   // Displays encoder statistics.
   void LogStatistics(bool force_log);
 
   // Type of video codec.
-  const cricket::VideoCodec codec_;
+  VideoCodecType codecType_;
 
   // Valid all the time since RegisterEncodeCompleteCallback() Invoke()s to
   // |codec_thread_| synchronously.
   webrtc::EncodedImageCallback* callback_;
 
   // 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.
   rtc::ThreadChecker codec_thread_checker_;
@@ skipping 95 matching lines @@
 
   bool sw_fallback_required_;
 };
 
 MediaCodecVideoEncoder::~MediaCodecVideoEncoder() {
   // Call Release() to ensure no more callbacks to us after we are deleted.
   Release();
 }
 
 MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni,
-                                               const cricket::VideoCodec& codec,
+                                               VideoCodecType codecType,
                                                jobject egl_context)
-    : codec_(codec),
+    : codecType_(codecType),
       callback_(NULL),
       codec_thread_(new Thread()),
       j_media_codec_video_encoder_class_(
           jni,
           FindClass(jni, "org/webrtc/MediaCodecVideoEncoder")),
       j_media_codec_video_encoder_(
           jni,
           jni->NewObject(*j_media_codec_video_encoder_class_,
                          GetMethodID(jni,
                                      *j_media_codec_video_encoder_class_,
@@ skipping 67 matching lines @@
 
 int32_t MediaCodecVideoEncoder::InitEncode(
     const webrtc::VideoCodec* codec_settings,
     int32_t /* number_of_cores */,
     size_t /* max_payload_size */) {
   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 = cricket::CodecTypeFromName(codec_.name);
-  RTC_CHECK(codec_settings->codecType == codec_type)
+  RTC_CHECK(codec_settings->codecType == codecType_)
       << "Unsupported codec " << codec_settings->codecType << " for "
-      << codec_type;
+      << codecType_;
   if (sw_fallback_required_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   codec_mode_ = codec_settings->mode;
   int init_width = codec_settings->width;
   int init_height = codec_settings->height;
   // Scaling is disabled for VP9, but optionally enabled for VP8.
   // TODO(pbos): Extract automaticResizeOn out of VP8 settings.
   scale_ = false;
-  if (codec_type == kVideoCodecVP8) {
+  if (codecType_ == kVideoCodecVP8) {
     scale_ = codec_settings->VP8().automaticResizeOn;
-  } else if (codec_type != kVideoCodecVP9) {
+  } else if (codecType_ != kVideoCodecVP9) {
     scale_ = true;
   }
 
   ALOGD << "InitEncode request: " << init_width << " x " << init_height;
   ALOGD << "Encoder automatic resize " << (scale_ ? "enabled" : "disabled");
 
   if (scale_) {
-    if (codec_type == kVideoCodecVP8 || codec_type == kVideoCodecH264) {
-      quality_scaler_.Init(codec_type, codec_settings->startBitrate,
+    if (codecType_ == kVideoCodecVP8 || codecType_ == kVideoCodecH264) {
+      quality_scaler_.Init(codecType_, codec_settings->startBitrate,
                            codec_settings->width, codec_settings->height,
                            codec_settings->maxFramerate);
     } else {
       // When adding codec support to additional hardware codecs, also configure
       // their QP thresholds for scaling.
       RTC_NOTREACHED() << "Unsupported codec without configured QP thresholds.";
       scale_ = false;
     }
     QualityScaler::Resolution res = quality_scaler_.GetScaledResolution();
     init_width = res.width;
@@ skipping 86 matching lines @@
       WEBRTC_VIDEO_CODEC_OK) {
     ALOGE << "Initializing encoder failed during reset.";
     return false;
   }
   return true;
 }
 
 bool MediaCodecVideoEncoder::ProcessHWErrorOnCodecThread(
     bool reset_if_fallback_unavailable) {
   ALOGE << "ProcessHWErrorOnCodecThread";
-  if (FindMatchingCodec(
-          cricket::InternalEncoderFactory::GetInstance().supported_codecs(),
-          codec_)) {
+  if (VideoEncoder::IsSupportedSoftware(
+          VideoEncoder::CodecToEncoderType(codecType_))) {
     ALOGE << "Fallback to SW encoder.";
     sw_fallback_required_ = true;
     return false;
   } else if (reset_if_fallback_unavailable) {
     ALOGE << "Reset encoder.";
     return ResetCodecOnCodecThread();
   }
   return false;
 }
 
 int32_t MediaCodecVideoEncoder::ProcessHWErrorOnEncodeOnCodecThread() {
   ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
   return sw_fallback_required_ ? WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE
                                : WEBRTC_VIDEO_CODEC_ERROR;
 }
 
 int32_t MediaCodecVideoEncoder::InitEncodeOnCodecThread(
     int width, int height, int kbps, int fps, bool use_surface) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
   if (sw_fallback_required_) {
     return WEBRTC_VIDEO_CODEC_OK;
   }
   RTC_CHECK(!use_surface || egl_context_ != nullptr) << "EGL context not set.";
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
-  const VideoCodecType codec_type = cricket::CodecTypeFromName(codec_.name);
-  ALOGD << "InitEncodeOnCodecThread Type: " << (int)codec_type << ", " << width
-        << " x " << height << ". Bitrate: " << kbps << " kbps. Fps: " << 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 = MAX_VIDEO_FPS;
   }
 
   width_ = width;
   height_ = height;
   last_set_bitrate_kbps_ = kbps;
@@ skipping 18 matching lines @@
   use_surface_ = use_surface;
   picture_id_ = static_cast<uint16_t>(rand()) & 0x7FFF;
   gof_.SetGofInfoVP9(webrtc::TemporalStructureMode::kTemporalStructureMode1);
   tl0_pic_idx_ = static_cast<uint8_t>(rand());
   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);
+      jni, "MediaCodecVideoEncoder$VideoCodecType", codecType_);
   const bool encode_status = jni->CallBooleanMethod(
       *j_media_codec_video_encoder_, j_init_encode_method_,
       j_video_codec_enum, width, height, kbps, fps,
       (use_surface ? egl_context_ : nullptr));
   if (!encode_status) {
     ALOGE << "Failed to configure encoder.";
     ProcessHWErrorOnCodecThread(false /* reset_if_fallback_unavailable */);
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   if (CheckException(jni)) {
@@ skipping 453 matching lines @@
     size_t payload_size = jni->GetDirectBufferCapacity(j_output_buffer);
     uint8_t* payload = reinterpret_cast<uint8_t*>(
         jni->GetDirectBufferAddress(j_output_buffer));
     if (CheckException(jni)) {
       ALOGE << "Exception in get direct buffer address.";
       ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
 
     // Callback - return encoded frame.
-    const VideoCodecType codec_type = cricket::CodecTypeFromName(codec_.name);
     webrtc::EncodedImageCallback::Result callback_result(
         webrtc::EncodedImageCallback::Result::OK);
     if (callback_) {
       std::unique_ptr<webrtc::EncodedImage> image(
           new webrtc::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->_frameType =
           (key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta);
       image->_completeFrame = true;
       image->adapt_reason_.quality_resolution_downscales =
           scale_ ? quality_scaler_.downscale_shift() : -1;
 
       webrtc::CodecSpecificInfo info;
       memset(&info, 0, sizeof(info));
-      info.codecType = codec_type;
-      if (codec_type == kVideoCodecVP8) {
+      info.codecType = codecType_;
+      if (codecType_ == 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.layerSync = false;
         info.codecSpecific.VP8.tl0PicIdx = webrtc::kNoTl0PicIdx;
         info.codecSpecific.VP8.keyIdx = webrtc::kNoKeyIdx;
-      } else if (codec_type == kVideoCodecVP9) {
+      } else if (codecType_ == 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_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;
       memset(&header, 0, sizeof(header));
-      if (codec_type == kVideoCodecVP8 || codec_type == kVideoCodecVP9) {
+      if (codecType_ == kVideoCodecVP8 || codecType_ == 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 && scale_) {
+        if (codecType_ == kVideoCodecVP8 && scale_) {
           int qp;
           if (webrtc::vp8::GetQp(payload, payload_size, &qp)) {
             current_acc_qp_ += qp;
             quality_scaler_.ReportQP(qp);
             image->qp_ = qp;
           }
         }
-      } else if (codec_type == kVideoCodecH264) {
+      } else if (codecType_ == kVideoCodecH264) {
         if (scale_) {
           h264_bitstream_parser_.ParseBitstream(payload, payload_size);
           int qp;
           if (h264_bitstream_parser_.GetLastSliceQp(&qp)) {
             current_acc_qp_ += qp;
             quality_scaler_.ReportQP(qp);
           }
         }
         // For H.264 search for start codes.
         int32_t scPositions[MAX_NALUS_PERFRAME + 1] = {};
@@ skipping 203 matching lines @@
 }
 
 webrtc::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;
-    return new MediaCodecVideoEncoder(AttachCurrentThreadIfNeeded(), codec,
+    const VideoCodecType type = cricket::CodecTypeFromName(codec.name);
+    return new MediaCodecVideoEncoder(AttachCurrentThreadIfNeeded(), type,
                                       egl_context_);
   }
   ALOGW << "Can not find HW video encoder for type " << codec.name;
   return nullptr;
 }
 
 const std::vector<cricket::VideoCodec>&
 MediaCodecVideoEncoderFactory::supported_codecs() const {
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni