Make MediaCodecEncoder fallback to a software encoder on failure.

webrtc/video/video_encoder.cc

Index: webrtc/video/video_encoder.cc
diff --git a/webrtc/video/video_encoder.cc b/webrtc/video/video_encoder.cc
index 1534a97fdf486bc1c36b672590c9bf896f40c117..d2733e1fd2358ec5f690ec6782f64233ee53de25 100644
--- a/webrtc/video/video_encoder.cc
+++ b/webrtc/video/video_encoder.cc
@@ -18,14 +18,13 @@
 
 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();
@@ -35,6 +34,22 @@ VideoEncoder* VideoEncoder::Create(VideoEncoder::EncoderType codec_type) {
   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:
@@ -58,8 +73,11 @@ VideoEncoderSoftwareFallbackWrapper::VideoEncoderSoftwareFallbackWrapper(
       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_) !=
@@ -145,6 +163,13 @@ int32_t VideoEncoderSoftwareFallbackWrapper::Encode(
   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);
   }