Make MediaCodecEncoder fallback to a software encoder on failure.

webrtc/video/video_encoder.cc

 /*
  *  Copyright (c) 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.
  */
 
 #include "webrtc/video_encoder.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 
 namespace webrtc {
 VideoEncoder* VideoEncoder::Create(VideoEncoder::EncoderType codec_type) {
+  RTC_DCHECK(IsSupported(codec_type));
   switch (codec_type) {
     case kH264:
-      RTC_DCHECK(H264Encoder::IsSupported());
       return H264Encoder::Create();
     case kVp8:
       return VP8Encoder::Create();
     case kVp9:
-      RTC_DCHECK(VP9Encoder::IsSupported());
       return VP9Encoder::Create();
     case kUnsupportedCodec:
       RTC_NOTREACHED();
       return nullptr;
   }
   RTC_NOTREACHED();
   return nullptr;
 }
 
+bool VideoEncoder::IsSupported(EncoderType codec_type) {
+  switch (codec_type) {
+    case kH264:
+      return H264Encoder::IsSupported();
+    case kVp8:
+      return true;
+    case kVp9:
+      return VP9Encoder::IsSupported();
+    case kUnsupportedCodec:
+      RTC_NOTREACHED();
+      return false;
+  }
+  RTC_NOTREACHED();
+  return false;
+}
+
 VideoEncoder::EncoderType CodecToEncoderType(VideoCodecType codec_type) {
   switch (codec_type) {
     case kVideoCodecH264:
       return VideoEncoder::kH264;
     case kVideoCodecVP8:
       return VideoEncoder::kVp8;
     case kVideoCodecVP9:
       return VideoEncoder::kVp9;
     default:
       return VideoEncoder::kUnsupportedCodec;
   }
 }
 
 VideoEncoderSoftwareFallbackWrapper::VideoEncoderSoftwareFallbackWrapper(
     VideoCodecType codec_type,
     webrtc::VideoEncoder* encoder)
     : rates_set_(false),
       channel_parameters_set_(false),
       encoder_type_(CodecToEncoderType(codec_type)),
       encoder_(encoder),
       callback_(nullptr) {}
 
 bool VideoEncoderSoftwareFallbackWrapper::InitFallbackEncoder() {
-  RTC_CHECK(encoder_type_ != kUnsupportedCodec)
-      << "Encoder requesting fallback to codec not supported in software.";
+  if (!VideoEncoder::IsSupported(encoder_type_)) {
+    LOG(LS_WARNING)
+        << "Encoder requesting fallback to codec not supported in software.";
+    return false;
+  }
   fallback_encoder_.reset(VideoEncoder::Create(encoder_type_));
   if (fallback_encoder_->InitEncode(&codec_settings_, number_of_cores_,
                                     max_payload_size_) !=
       WEBRTC_VIDEO_CODEC_OK) {
     LOG(LS_ERROR) << "Failed to initialize software-encoder fallback.";
     fallback_encoder_->Release();
     fallback_encoder_.reset();
     return false;
   }
   // Replay callback, rates, and channel parameters.
@@ skipping 65 matching lines @@
 
 int32_t VideoEncoderSoftwareFallbackWrapper::Encode(
     const VideoFrame& frame,
     const CodecSpecificInfo* codec_specific_info,
     const std::vector<FrameType>* frame_types) {
   if (fallback_encoder_)
     return fallback_encoder_->Encode(frame, codec_specific_info, frame_types);
   int32_t ret = encoder_->Encode(frame, codec_specific_info, frame_types);
   // If requested, try a software fallback.
   if (ret == WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE && InitFallbackEncoder()) {
+    if (frame.video_frame_buffer()->native_handle() &&
+        !fallback_encoder_->SupportsNativeHandle()) {
+      LOG(LS_WARNING) << "Fallback encoder doesn't support native frames, "

[magjed_webrtc, 2016/08/23 12:09:50]

So what will happen when the HW encoder fails on Android and we use native
frames from the camera? Who is responsible for calling NativeToI420?

[sakal, 2016/08/23 12:26:51]

When fallback_encoder_ is initialized, SupportsNativeHandle in this class will
start to forward the calls to the fallback encoder instead.

This causes VideoSender to start converting the frames for the encoder if the
fallback encoder doesn't support native frames.

[magjed_webrtc, 2016/08/23 14:28:08]

Acknowledged.

+                      << "dropping one frame.";
+      return WEBRTC_VIDEO_CODEC_ERROR;
+    }
+
     // Fallback was successful, so start using it with this frame.
     return fallback_encoder_->Encode(frame, codec_specific_info, frame_types);
   }
   return ret;
 }
 
 int32_t VideoEncoderSoftwareFallbackWrapper::SetChannelParameters(
     uint32_t packet_loss,
     int64_t rtt) {
   channel_parameters_set_ = true;
@@ skipping 28 matching lines @@
   return encoder_->SupportsNativeHandle();
 }
 
 const char* VideoEncoderSoftwareFallbackWrapper::ImplementationName() const {
   if (fallback_encoder_)
     return fallback_implementation_name_.c_str();
   return encoder_->ImplementationName();
 }
 
 }  // namespace webrtc