H.264 video codec support using OpenH264/FFmpeg

webrtc/modules/video_coding/codecs/h264/h264.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/modules/video_coding/codecs/h264/include/h264.h"
 
+#if defined(WEBRTC_OPENH264)
+#include "webrtc/modules/video_coding/codecs/h264/h264_encoder_impl.h"
+#include "webrtc/modules/video_coding/codecs/h264/h264_decoder_impl.h"
+#endif
 #if defined(WEBRTC_IOS)
 #include "webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_decoder.h"
 #include "webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.h"
 #endif
 
 #include "webrtc/base/checks.h"
 
 namespace webrtc {
 
 // We need this file to be C++ only so it will compile properly for all
 // platforms. In order to write ObjC specific implementations we use private
 // externs. This function is defined in h264.mm.
 #if defined(WEBRTC_IOS)
 extern bool IsH264CodecSupportedObjC();
 #endif
 
+// If any H.264 codec is supported (iOS HW or OpenH264).
 bool IsH264CodecSupported() {
 #if defined(WEBRTC_IOS)
-  return IsH264CodecSupportedObjC();
+  if (IsH264CodecSupportedObjC()) {
+    return true;
+  }
+#endif
+#if defined(WEBRTC_OPENH264)
+  return true;
 #else
   return false;
 #endif
+}
+
+// If H.264 codec is supported and OpenH264 is the implementation used, meaning
+// H264EncoderImpl and H264DecoderImpl.
+bool IsOpenH264CodecSupported() {
+#if defined(WEBRTC_OPENH264)
+  #if defined(WEBRTC_IOS)
+    // If on iOS and we have HW H.264 support we will prefer that over OpenH264
+    // and say that OpenH264 is not supported (even though some H264 is).
+    return !IsH264CodecSupportedObjC();

[stefan-webrtc, 2015/09/28 11:19:01]

This seems a bit strange to me. Shouldn't we always first check if H264 HW is
supported, and if not, check if OpenH264 is supported? We shouldn't say OpenH264
isn't supported just because we have HW. For instance, we might want to fall
back to OpenH264 if the HW fails.

[hbos, 2015/09/30 15:35:18]

You're right. If we are able to support both HW and SW it should be possible to
control and support both in code.

Right now there's just a pair of H264[En/De]coder::Create functions and no
concept of choosing between multiple different implementations of the same
codec. It's implementation-agnostic and I'm not sure how easy/hard it is to fix
this (where to decide/prioritize?).

Can I add a TODO and address this in a separate CL?

[stefan-webrtc, 2015/10/01 08:19:30]

But what I'm opposed to is that IsOpenH264CodecSupported() depends on if
IsH264CodecSupportedObjC() is supported. That shouldn't matter. If
IsH264CodecSupportedObjC() returns true we should never go into this method
anyway based on H264Encoder::Create().

[hbos, 2015/10/01 12:19:45]

Poor name choice. It wasn't "do we support the OpenH264 impl?" but rather "will
Create() create the OpenH264 impl?". Anyway, this function is no longer needed
so I removed it.
I also removed the TODO about controlling which impl Create() should create
because I'm not sure we need that. If we want to know about specific
implementations we can easily add IsBlablaImplSupported/CreateBlablaImpl when
that is needed.

+  #else
+    return true;
+  #endif
+#else
+  return false;
+#endif
 }
 
 H264Encoder* H264Encoder::Create() {
   DCHECK(H264Encoder::IsSupported());
 #if defined(WEBRTC_IOS) && defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)
-  return new H264VideoToolboxEncoder();
-#else
+  if (IsH264CodecSupportedObjC()) {
+    return new H264VideoToolboxEncoder();
+  }
+#endif
+#if defined(WEBRTC_OPENH264)
+  if (IsOpenH264CodecSupported()) {
+    return new H264EncoderImpl();
+  }
+#endif
   RTC_NOTREACHED();
   return nullptr;
-#endif
 }
 
 bool H264Encoder::IsSupported() {
   return IsH264CodecSupported();
 }
 
+bool H264Encoder::IsSupportedOpenH264() {
+  return IsOpenH264CodecSupported();
+}
+
 H264Decoder* H264Decoder::Create() {
   DCHECK(H264Decoder::IsSupported());
 #if defined(WEBRTC_IOS) && defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)
-  return new H264VideoToolboxDecoder();
-#else
+  if (IsH264CodecSupportedObjC()) {
+    return new H264VideoToolboxDecoder();
+  }
+#endif
+#if defined(WEBRTC_OPENH264)
+  if (IsOpenH264CodecSupported()) {
+    return new H264DecoderImpl();
+  }
+#endif
   RTC_NOTREACHED();
   return nullptr;
-#endif
 }
 
 bool H264Decoder::IsSupported() {
   return IsH264CodecSupported();
 }
 
+bool H264Decoder::IsSupportedOpenH264() {
+  return IsOpenH264CodecSupported();
+}
+
 }  // namespace webrtc