webrtc.gni - platform/external/webrtc - Gitiles

 # Copyright (c) 2014 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.
 import("//build/config/arm.gni")
 import("//build/config/features.gni")
 import("//build/config/mips.gni")
 import("//build/config/sanitizers/sanitizers.gni")
 import("//build/config/ui.gni")
 import("//build_overrides/build.gni")

 if (!build_with_chromium && is_component_build) {
   print("The Gn argument `is_component_build` is currently " +
         "ignored for WebRTC builds.")
   print("Component builds are supported by Chromium and the argument " +
         "`is_component_build` makes it possible to create shared libraries " +
         "instead of static libraries.")
   print("If an app depends on WebRTC it makes sense to just depend on the " +
         "WebRTC static library, so there is no difference between " +
         "`is_component_build=true` and `is_component_build=false`.")
   print(
       "More info about component builds at: " + "https://chromium.googlesource.com/chromium/src/+/master/docs/component_build.md")
   assert(!is_component_build, "Component builds are not supported in WebRTC.")
 }

 if (is_ios) {
   import("//build/config/ios/rules.gni")
 }

 declare_args() {
   # Setting this to false will require the API user to pass in their own
   # SSLCertificateVerifier to verify the certificates presented from a
   # TLS-TURN server. In return disabling this saves around 100kb in the binary.
   rtc_builtin_ssl_root_certificates = true

   # Include the iLBC audio codec?
   rtc_include_ilbc = true

   # Disable this to avoid building the Opus audio codec.
   rtc_include_opus = true

   # Enable this if the Opus version upon which WebRTC is built supports direct
   # encoding of 120 ms packets.
   rtc_opus_support_120ms_ptime = true

   # Enable this to let the Opus audio codec change complexity on the fly.
   rtc_opus_variable_complexity = false

   # Used to specify an external Jsoncpp include path when not compiling the
   # library that comes with WebRTC (i.e. rtc_build_json == 0).
   rtc_jsoncpp_root = "//third_party/jsoncpp/source/include"

   # Used to specify an external OpenSSL include path when not compiling the
   # library that comes with WebRTC (i.e. rtc_build_ssl == 0).
   rtc_ssl_root = ""

   # Selects fixed-point code where possible.
   rtc_prefer_fixed_point = false

   # Disable the code for the intelligibility enhancer by default.
   rtc_enable_intelligibility_enhancer = false

   # Enable when an external authentication mechanism is used for performing
   # packet authentication for RTP packets instead of libsrtp.
   rtc_enable_external_auth = build_with_chromium

   # Selects whether debug dumps for the audio processing module
   # should be generated.
   apm_debug_dump = false

   # Set this to true to enable BWE test logging.
   rtc_enable_bwe_test_logging = false

   # Set this to false to skip building examples.
   rtc_build_examples = true

   # Set this to false to skip building tools.
   rtc_build_tools = true

   # Set this to false to skip building code that requires X11.
   rtc_use_x11 = use_x11

   # Enable to use the Mozilla internal settings.
   build_with_mozilla = false

   # Enable use of Android AAudio which requires Android SDK 26 or above and
   # NDK r16 or above.
   rtc_enable_android_aaudio = false

   # TODO(henrika): can this flag be removed?
   rtc_enable_android_opensl = false

   # Link-Time Optimizations.
   # Executes code generation at link-time instead of compile-time.
   # https://gcc.gnu.org/wiki/LinkTimeOptimization
   rtc_use_lto = false

   # Set to "func", "block", "edge" for coverage generation.
   # At unit test runtime set UBSAN_OPTIONS="coverage=1".
   # It is recommend to set include_examples=0.
   # Use llvm's sancov -html-report for human readable reports.
   # See http://clang.llvm.org/docs/SanitizerCoverage.html .
   rtc_sanitize_coverage = ""

   # Links a default implementation of task queues to targets
   # that depend on the target rtc_task_queue. Set to false to
   # use an external implementation.
   rtc_link_task_queue_impl = true

   if (current_cpu == "arm" || current_cpu == "arm64") {
     rtc_prefer_fixed_point = true
   }

   # Determines whether NEON code will be built.
   rtc_build_with_neon =
       (current_cpu == "arm" && arm_use_neon) || current_cpu == "arm64"

   # Enable this to build OpenH264 encoder/FFmpeg decoder. This is supported on
   # all platforms except Android and iOS. Because FFmpeg can be built
   # with/without H.264 support, |ffmpeg_branding| has to separately be set to a
   # value that includes H.264, for example "Chrome". If FFmpeg is built without
   # H.264, compilation succeeds but |H264DecoderImpl| fails to initialize. See
   # also: |rtc_initialize_ffmpeg|.
   # CHECK THE OPENH264, FFMPEG AND H.264 LICENSES/PATENTS BEFORE BUILDING.
   # http://www.openh264.org, https://www.ffmpeg.org/
   rtc_use_h264 = proprietary_codecs && !is_android && !is_ios

   # By default, use normal platform audio support or dummy audio, but don't
   # use file-based audio playout and record.
   rtc_use_dummy_audio_file_devices = false

   # When set to true, replace the audio output with a sinus tone at 440Hz.
   # The ADM will ask for audio data from WebRTC but instead of reading real
   # audio samples from NetEQ, a sinus tone will be generated and replace the
   # real audio samples.
   rtc_audio_device_plays_sinus_tone = false

   # When set to true, test targets will declare the files needed to run memcheck
   # as data dependencies. This is to enable memcheck execution on swarming bots.
   rtc_use_memcheck = false

   # FFmpeg must be initialized for |H264DecoderImpl| to work. This can be done
   # by WebRTC during |H264DecoderImpl::InitDecode| or externally. FFmpeg must
   # only be initialized once. Projects that initialize FFmpeg externally, such
   # as Chromium, must turn this flag off so that WebRTC does not also
   # initialize.
   rtc_initialize_ffmpeg = !build_with_chromium

   # Disable this to build without support for built-in software codecs.
   rtc_use_builtin_sw_codecs = true

   if (is_ios) {
     # Build broadcast extension in AppRTCMobile for iOS. This results in the
     # binary only running on iOS 11+, which is why it is disabled by default.
     rtc_apprtcmobile_broadcast_extension = false
   }
 }

 if (!build_with_mozilla) {
   import("//testing/test.gni")
 }

 # A second declare_args block, so that declarations within it can
 # depend on the possibly overridden variables in the first
 # declare_args block.
 declare_args() {
   # Enables the use of protocol buffers for debug recordings.
   rtc_enable_protobuf = !build_with_mozilla

   # Set this to disable building with support for SCTP data channels.
   rtc_enable_sctp = !build_with_mozilla

   # Disable these to not build components which can be externally provided.
   rtc_build_json = !build_with_mozilla
   rtc_build_libsrtp = !build_with_mozilla
   rtc_build_libvpx = !build_with_mozilla
   rtc_libvpx_build_vp9 = !build_with_mozilla
   rtc_build_opus = !build_with_mozilla
   rtc_build_ssl = !build_with_mozilla
   rtc_build_usrsctp = !build_with_mozilla

   # Enable libevent task queues on platforms that support it.
   # rtc_link_task_queue_impl must be set to true for this to
   # have an effect.
   if (is_win || is_mac || is_ios || is_nacl || is_fuchsia) {
     rtc_enable_libevent = false
     rtc_build_libevent = false
   } else {
     rtc_enable_libevent = true
     rtc_build_libevent = !build_with_mozilla
   }

   # Build sources requiring GTK. NOTICE: This is not present in Chrome OS
   # build environments, even if available for Chromium builds.
   rtc_use_gtk = !build_with_chromium && !build_with_mozilla

   # Excluded in Chromium since its prerequisites don't require Pulse Audio.
   rtc_include_pulse_audio = !build_with_chromium

   # Chromium uses its own IO handling, so the internal ADM is only built for
   # standalone WebRTC.
   rtc_include_internal_audio_device = !build_with_chromium

   # Include tests in standalone checkout.
   rtc_include_tests = !build_with_chromium && !build_with_mozilla
 }

 # Make it possible to provide custom locations for some libraries (move these
 # up into declare_args should we need to actually use them for the GN build).
 rtc_libvpx_dir = "//third_party/libvpx"
 rtc_opus_dir = "//third_party/opus"

 # Desktop capturer is supported only on Windows, OSX and Linux.
 rtc_desktop_capture_supported = is_win || is_mac || (is_linux && rtc_use_x11)

 ###############################################################################
 # Templates
 #

 # Points to // in webrtc stand-alone or to //third_party/webrtc/ in
 # chromium.
 # We need absolute paths for all configs in templates as they are shared in
 # different subdirectories.
 webrtc_root = get_path_info(".", "abspath")

 # Global configuration that should be applied to all WebRTC targets.
 # You normally shouldn't need to include this in your target as it's
 # automatically included when using the rtc_* templates.
 # It sets defines, include paths and compilation warnings accordingly,
 # both for WebRTC stand-alone builds and for the scenario when WebRTC
 # native code is built as part of Chromium.
 rtc_common_configs = [ webrtc_root + ":common_config" ]

 if (is_mac || is_ios) {
   rtc_common_configs += [ "//build/config/compiler:enable_arc" ]
 }

 # Global public configuration that should be applied to all WebRTC targets. You
 # normally shouldn't need to include this in your target as it's automatically
 # included when using the rtc_* templates. It set the defines, include paths and
 # compilation warnings that should be propagated to dependents of the targets
 # depending on the target having this config.
 rtc_common_inherited_config = webrtc_root + ":common_inherited_config"

 # Common configs to remove or add in all rtc targets.
 rtc_remove_configs = []
 rtc_add_configs = rtc_common_configs

 set_defaults("rtc_test") {
   configs = rtc_add_configs
   suppressed_configs = []
 }

 set_defaults("rtc_source_set") {
   configs = rtc_add_configs
   suppressed_configs = []
 }

 set_defaults("rtc_executable") {
   configs = rtc_add_configs
   suppressed_configs = []
 }

 set_defaults("rtc_static_library") {
   configs = rtc_add_configs
   suppressed_configs = []
 }

 set_defaults("rtc_shared_library") {
   configs = rtc_add_configs
   suppressed_configs = []
 }

 webrtc_default_visibility = [ webrtc_root + "/*" ]
 if (build_with_chromium) {
   # Allow Chromium's WebRTC overrides targets to bypass the regular
   # visibility restrictions.
   webrtc_default_visibility += [ webrtc_root + "/../webrtc_overrides/*" ]
 }

 # ---- Poisons ----
 #
 # The general idea is that some targets declare that they contain some
 # kind of poison, which makes it impossible for other targets to
 # depend on them (even transitively) unless they declare themselves
 # immune to that particular type of poison.
 #
 # Targets that *contain* poison of type foo should contain the line
 #
 #   poisonous = [ "foo" ]
 #
 # and targets that *are immune but arent't themselves poisonous*
 # should contain
 #
 #   allow_poison = [ "foo" ]
 #
 # This useful in cases where we have some large target or set of
 # targets and want to ensure that most other targets do not
 # transitively depend on them. For example, almost no high-level
 # target should depend on the audio codecs, since we want WebRTC users
 # to be able to inject any subset of them and actually end up with a
 # binary that doesn't include the codecs they didn't inject.
 #
 # Test-only targets (`testonly` set to true) and non-public targets
 # (`visibility` not containing "*") are automatically immune to all
 # types of poison.
 #
 # Here's the complete list of all types of poison. It must be kept in
 # 1:1 correspondence with the set of //:poison_* targets.
 #
 all_poison_types = [
   # Encoders and decoders for specific audio codecs such as Opus and iSAC.
   "audio_codecs",

   # Software video codecs (VP8 and VP9 through libvpx).
   "software_video_codecs",
 ]

 absl_include_config = "//third_party/abseil-cpp:absl_include_config"
 absl_define_config = "//third_party/abseil-cpp:absl_define_config"

 template("rtc_test") {
   test(target_name) {
     forward_variables_from(invoker,
                            "*",
                            [
                              "configs",
                              "public_configs",
                              "suppressed_configs",
                              "visibility",
                            ])

     # Always override to public because when target_os is Android the `test`
     # template can override it to [ "*" ] and we want to avoid conditional
     # visibility.
     visibility = [ "*" ]
     configs += invoker.configs
     configs -= rtc_remove_configs
     configs -= invoker.suppressed_configs
     public_configs = [
       rtc_common_inherited_config,
       absl_include_config,
       absl_define_config,
     ]
     if (defined(invoker.public_configs)) {
       public_configs += invoker.public_configs
     }
     if (!build_with_chromium && is_android) {
       android_manifest = webrtc_root + "test/android/AndroidManifest.xml"
       deps += [ webrtc_root + "test:native_test_java" ]
     }
   }
 }

 template("rtc_source_set") {
   source_set(target_name) {
     forward_variables_from(invoker,
                            "*",
                            [
                              "configs",
                              "public_configs",
                              "suppressed_configs",
                              "visibility",
                            ])
     forward_variables_from(invoker, [ "visibility" ])
     if (!defined(visibility)) {
       visibility = webrtc_default_visibility
     }

     # What's your poison?
     if (defined(testonly) && testonly) {
       assert(!defined(poisonous))
       assert(!defined(allow_poison))
     } else {
       if (!defined(poisonous)) {
         poisonous = []
       }
       if (!defined(allow_poison)) {
         allow_poison = []
       }
       if (!defined(assert_no_deps)) {
         assert_no_deps = []
       }
       if (!defined(deps)) {
         deps = []
       }
       foreach(p, poisonous) {
         deps += [ webrtc_root + ":poison_" + p ]
       }
       foreach(poison_type, all_poison_types) {
         allow_dep = true
         foreach(v, visibility) {
           if (v == "*") {
             allow_dep = false
           }
         }
         foreach(p, allow_poison + poisonous) {
           if (p == poison_type) {
             allow_dep = true
           }
         }
         if (!allow_dep) {
           assert_no_deps += [ webrtc_root + ":poison_" + poison_type ]
         }
       }
     }

     configs += invoker.configs
     configs -= rtc_remove_configs
     configs -= invoker.suppressed_configs
     public_configs = [
       rtc_common_inherited_config,
       absl_include_config,
       absl_define_config,
     ]
     if (defined(invoker.public_configs)) {
       public_configs += invoker.public_configs
     }
   }
 }

 template("rtc_executable") {
   executable(target_name) {
     forward_variables_from(invoker,
                            "*",
                            [
                              "deps",
                              "configs",
                              "public_configs",
                              "suppressed_configs",
                              "visibility",
                            ])
     forward_variables_from(invoker, [ "visibility" ])
     if (!defined(visibility)) {
       visibility = webrtc_default_visibility
     }
     configs += invoker.configs
     configs -= rtc_remove_configs
     configs -= invoker.suppressed_configs
     deps = [
       "//build/config:exe_and_shlib_deps",
     ]
     deps += invoker.deps

     public_configs = [
       rtc_common_inherited_config,
       absl_include_config,
       absl_define_config,
     ]
     if (defined(invoker.public_configs)) {
       public_configs += invoker.public_configs
     }
   }
 }

 template("rtc_static_library") {
   static_library(target_name) {
     forward_variables_from(invoker,
                            "*",
                            [
                              "configs",
                              "public_configs",
                              "suppressed_configs",
                              "visibility",
                            ])
     forward_variables_from(invoker, [ "visibility" ])
     if (!defined(visibility)) {
       visibility = webrtc_default_visibility
     }

     # What's your poison?
     if (defined(testonly) && testonly) {
       assert(!defined(poisonous))
       assert(!defined(allow_poison))
     } else {
       if (!defined(poisonous)) {
         poisonous = []
       }
       if (!defined(allow_poison)) {
         allow_poison = []
       }
       if (!defined(assert_no_deps)) {
         assert_no_deps = []
       }
       if (!defined(deps)) {
         deps = []
       }
       foreach(p, poisonous) {
         deps += [ webrtc_root + ":poison_" + p ]
       }
       foreach(poison_type, all_poison_types) {
         allow_dep = true
         foreach(v, visibility) {
           if (v == "*") {
             allow_dep = false
           }
         }
         foreach(p, allow_poison + poisonous) {
           if (p == poison_type) {
             allow_dep = true
           }
         }
         if (!allow_dep) {
           assert_no_deps += [ webrtc_root + ":poison_" + poison_type ]
         }
       }
     }

     configs += invoker.configs
     configs -= rtc_remove_configs
     configs -= invoker.suppressed_configs
     public_configs = [
       rtc_common_inherited_config,
       absl_include_config,
       absl_define_config,
     ]
     if (defined(invoker.public_configs)) {
       public_configs += invoker.public_configs
     }
   }
 }

 template("rtc_shared_library") {
   shared_library(target_name) {
     forward_variables_from(invoker,
                            "*",
                            [
                              "configs",
                              "public_configs",
                              "suppressed_configs",
                              "visibility",
                            ])
     forward_variables_from(invoker, [ "visibility" ])
     if (!defined(visibility)) {
       visibility = webrtc_default_visibility
     }

     # What's your poison?
     if (defined(testonly) && testonly) {
       assert(!defined(poisonous))
       assert(!defined(allow_poison))
     } else {
       if (!defined(poisonous)) {
         poisonous = []
       }
       if (!defined(allow_poison)) {
         allow_poison = []
       }
       if (!defined(assert_no_deps)) {
         assert_no_deps = []
       }
       if (!defined(deps)) {
         deps = []
       }
       foreach(p, poisonous) {
         deps += [ webrtc_root + ":poison_" + p ]
       }
       foreach(poison_type, all_poison_types) {
         allow_dep = true
         foreach(v, visibility) {
           if (v == "*") {
             allow_dep = false
           }
         }
         foreach(p, allow_poison + poisonous) {
           if (p == poison_type) {
             allow_dep = true
           }
         }
         if (!allow_dep) {
           assert_no_deps += [ webrtc_root + ":poison_" + poison_type ]
         }
       }
     }

     configs += invoker.configs
     configs -= rtc_remove_configs
     configs -= invoker.suppressed_configs
     public_configs = [
       rtc_common_inherited_config,
       absl_include_config,
       absl_define_config,
     ]
     if (defined(invoker.public_configs)) {
       public_configs += invoker.public_configs
     }
   }
 }

 if (is_ios) {
   set_defaults("rtc_ios_xctest_test") {
     configs = rtc_add_configs
     suppressed_configs = []
   }

   template("rtc_ios_xctest_test") {
     ios_xctest_test(target_name) {
       forward_variables_from(invoker,
                              "*",
                              [
                                "configs",
                                "public_configs",
                                "suppressed_configs",
                                "visibility",
                              ])
       forward_variables_from(invoker, [ "visibility" ])
       if (!defined(visibility)) {
         visibility = webrtc_default_visibility
       }
       configs += invoker.configs
       configs -= rtc_remove_configs
       configs -= invoker.suppressed_configs
       public_configs = [ rtc_common_inherited_config ]
       if (defined(invoker.public_configs)) {
         public_configs += invoker.public_configs
       }
     }
   }

   template("ios_framework_bundle_with_umbrella_header") {
     forward_variables_from(invoker, [ "output_name" ])
     umbrella_header_path =
         "$target_gen_dir/$output_name.framework/Headers/$output_name.h"

     ios_framework_bundle(target_name) {
       forward_variables_from(invoker, "*", [])

       deps += [ ":copy_umbrella_header_$target_name" ]
     }

     action("umbrella_header_$target_name") {
       forward_variables_from(invoker, [ "public_headers" ])

       script = "//tools_webrtc/ios/generate_umbrella_header.py"

       outputs = [
         umbrella_header_path,
       ]
       args = [
                "--out",
                rebase_path(umbrella_header_path, root_build_dir),
                "--sources",
              ] + rebase_path(public_headers, "objc/Framework/Headers/")
     }

     copy("copy_umbrella_header_$target_name") {
       sources = [
         umbrella_header_path,
       ]
       outputs = [
         "$root_out_dir/$output_name.framework/Headers/$output_name.h",
       ]

       deps = [
         ":umbrella_header_$target_name",
       ]
     }
   }

   set_defaults("ios_framework_bundle_with_umbrella_header") {
     configs = default_shared_library_configs
   }
 }

 if (is_android) {
   template("rtc_android_library") {
     android_library(target_name) {
       forward_variables_from(invoker,
                              "*",
                              [
                                "configs",
                                "public_configs",
                                "suppressed_configs",
                                "visibility",
                              ])

       javac_args = []

       # Treat warnings as errors.
       javac_args += [ "-Werror" ]

       # TODO(crbug.com/824679): Find out why this fails in Chromium
       if (!build_with_chromium) {
         javac_args += [
           "-Xep:ParameterNotNullable:ERROR",
           "-Xep:FieldMissingNullable:ERROR",
           "-Xep:ReturnMissingNullable:ERROR",
         ]
       }

       # Add any arguments defined by the invoker.
       if (defined(invoker.javac_args)) {
         javac_args += invoker.javac_args
       }

       if (!defined(deps)) {
         deps = []
       }
       deps += [ "//third_party/jsr-305:jsr_305_javalib" ]

       no_build_hooks = true
     }
   }

   template("rtc_android_apk") {
     android_apk(target_name) {
       forward_variables_from(invoker,
                              "*",
                              [
                                "configs",
                                "public_configs",
                                "suppressed_configs",
                                "visibility",
                              ])

       # Treat warnings as errors.
       javac_args = [ "-Werror" ]

       # TODO(crbug.com/824679): Find out why this fails in Chromium
       if (!build_with_chromium) {
         javac_args += [
           "-Xep:ParameterNotNullable:ERROR",
           "-Xep:FieldMissingNullable:ERROR",
           "-Xep:ReturnMissingNullable:ERROR",
         ]
       }

       if (!defined(deps)) {
         deps = []
       }
       deps += [ "//third_party/jsr-305:jsr_305_javalib" ]

       no_build_hooks = true
     }
   }

   template("rtc_instrumentation_test_apk") {
     instrumentation_test_apk(target_name) {
       forward_variables_from(invoker,
                              "*",
                              [
                                "configs",
                                "public_configs",
                                "suppressed_configs",
                                "visibility",
                              ])

       # Treat warnings as errors.
       javac_args = [ "-Werror" ]

       # TODO(crbug.com/824679): Find out why this fails in Chromium
       if (!build_with_chromium) {
         javac_args += [
           "-Xep:ParameterNotNullable:ERROR",
           "-Xep:FieldMissingNullable:ERROR",
           "-Xep:ReturnMissingNullable:ERROR",
         ]
       }

       if (!defined(deps)) {
         deps = []
       }
       deps += [ "//third_party/jsr-305:jsr_305_javalib" ]

       no_build_hooks = true
     }
   }
 }
	# Copyright (c) 2014 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.
	import("//build/config/arm.gni")
	import("//build/config/features.gni")
	import("//build/config/mips.gni")
	import("//build/config/sanitizers/sanitizers.gni")
	import("//build/config/ui.gni")
	import("//build_overrides/build.gni")

	if (!build_with_chromium && is_component_build) {
	print("The Gn argument `is_component_build` is currently " +
	"ignored for WebRTC builds.")
	print("Component builds are supported by Chromium and the argument " +
	"`is_component_build` makes it possible to create shared libraries " +
	"instead of static libraries.")
	print("If an app depends on WebRTC it makes sense to just depend on the " +
	"WebRTC static library, so there is no difference between " +
	"`is_component_build=true` and `is_component_build=false`.")
	print(
	"More info about component builds at: " + "https://chromium.googlesource.com/chromium/src/+/master/docs/component_build.md")
	assert(!is_component_build, "Component builds are not supported in WebRTC.")
	}

	if (is_ios) {
	import("//build/config/ios/rules.gni")
	}

	declare_args() {
	# Setting this to false will require the API user to pass in their own
	# SSLCertificateVerifier to verify the certificates presented from a
	# TLS-TURN server. In return disabling this saves around 100kb in the binary.
	rtc_builtin_ssl_root_certificates = true

	# Include the iLBC audio codec?
	rtc_include_ilbc = true

	# Disable this to avoid building the Opus audio codec.
	rtc_include_opus = true

	# Enable this if the Opus version upon which WebRTC is built supports direct
	# encoding of 120 ms packets.
	rtc_opus_support_120ms_ptime = true

	# Enable this to let the Opus audio codec change complexity on the fly.
	rtc_opus_variable_complexity = false

	# Used to specify an external Jsoncpp include path when not compiling the
	# library that comes with WebRTC (i.e. rtc_build_json == 0).
	rtc_jsoncpp_root = "//third_party/jsoncpp/source/include"

	# Used to specify an external OpenSSL include path when not compiling the
	# library that comes with WebRTC (i.e. rtc_build_ssl == 0).
	rtc_ssl_root = ""

	# Selects fixed-point code where possible.
	rtc_prefer_fixed_point = false

	# Disable the code for the intelligibility enhancer by default.
	rtc_enable_intelligibility_enhancer = false

	# Enable when an external authentication mechanism is used for performing
	# packet authentication for RTP packets instead of libsrtp.
	rtc_enable_external_auth = build_with_chromium

	# Selects whether debug dumps for the audio processing module
	# should be generated.
	apm_debug_dump = false

	# Set this to true to enable BWE test logging.
	rtc_enable_bwe_test_logging = false

	# Set this to false to skip building examples.
	rtc_build_examples = true

	# Set this to false to skip building tools.
	rtc_build_tools = true

	# Set this to false to skip building code that requires X11.
	rtc_use_x11 = use_x11

	# Enable to use the Mozilla internal settings.
	build_with_mozilla = false

	# Enable use of Android AAudio which requires Android SDK 26 or above and
	# NDK r16 or above.
	rtc_enable_android_aaudio = false

	# TODO(henrika): can this flag be removed?
	rtc_enable_android_opensl = false

	# Link-Time Optimizations.
	# Executes code generation at link-time instead of compile-time.
	# https://gcc.gnu.org/wiki/LinkTimeOptimization
	rtc_use_lto = false

	# Set to "func", "block", "edge" for coverage generation.
	# At unit test runtime set UBSAN_OPTIONS="coverage=1".
	# It is recommend to set include_examples=0.
	# Use llvm's sancov -html-report for human readable reports.
	# See http://clang.llvm.org/docs/SanitizerCoverage.html .
	rtc_sanitize_coverage = ""

	# Links a default implementation of task queues to targets
	# that depend on the target rtc_task_queue. Set to false to
	# use an external implementation.
	rtc_link_task_queue_impl = true

	if (current_cpu == "arm" \|\| current_cpu == "arm64") {
	rtc_prefer_fixed_point = true
	}

	# Determines whether NEON code will be built.
	rtc_build_with_neon =
	(current_cpu == "arm" && arm_use_neon) \|\| current_cpu == "arm64"

	# Enable this to build OpenH264 encoder/FFmpeg decoder. This is supported on
	# all platforms except Android and iOS. Because FFmpeg can be built
	# with/without H.264 support, \|ffmpeg_branding\| has to separately be set to a
	# value that includes H.264, for example "Chrome". If FFmpeg is built without
	# H.264, compilation succeeds but \|H264DecoderImpl\| fails to initialize. See
	# also: \|rtc_initialize_ffmpeg\|.
	# CHECK THE OPENH264, FFMPEG AND H.264 LICENSES/PATENTS BEFORE BUILDING.
	# http://www.openh264.org, https://www.ffmpeg.org/
	rtc_use_h264 = proprietary_codecs && !is_android && !is_ios

	# By default, use normal platform audio support or dummy audio, but don't
	# use file-based audio playout and record.
	rtc_use_dummy_audio_file_devices = false

	# When set to true, replace the audio output with a sinus tone at 440Hz.
	# The ADM will ask for audio data from WebRTC but instead of reading real
	# audio samples from NetEQ, a sinus tone will be generated and replace the
	# real audio samples.
	rtc_audio_device_plays_sinus_tone = false

	# When set to true, test targets will declare the files needed to run memcheck
	# as data dependencies. This is to enable memcheck execution on swarming bots.
	rtc_use_memcheck = false

	# FFmpeg must be initialized for \|H264DecoderImpl\| to work. This can be done
	# by WebRTC during \|H264DecoderImpl::InitDecode\| or externally. FFmpeg must
	# only be initialized once. Projects that initialize FFmpeg externally, such
	# as Chromium, must turn this flag off so that WebRTC does not also
	# initialize.
	rtc_initialize_ffmpeg = !build_with_chromium

	# Disable this to build without support for built-in software codecs.
	rtc_use_builtin_sw_codecs = true

	if (is_ios) {
	# Build broadcast extension in AppRTCMobile for iOS. This results in the
	# binary only running on iOS 11+, which is why it is disabled by default.
	rtc_apprtcmobile_broadcast_extension = false
	}
	}

	if (!build_with_mozilla) {
	import("//testing/test.gni")
	}

	# A second declare_args block, so that declarations within it can
	# depend on the possibly overridden variables in the first
	# declare_args block.
	declare_args() {
	# Enables the use of protocol buffers for debug recordings.
	rtc_enable_protobuf = !build_with_mozilla

	# Set this to disable building with support for SCTP data channels.
	rtc_enable_sctp = !build_with_mozilla

	# Disable these to not build components which can be externally provided.
	rtc_build_json = !build_with_mozilla
	rtc_build_libsrtp = !build_with_mozilla
	rtc_build_libvpx = !build_with_mozilla
	rtc_libvpx_build_vp9 = !build_with_mozilla
	rtc_build_opus = !build_with_mozilla
	rtc_build_ssl = !build_with_mozilla
	rtc_build_usrsctp = !build_with_mozilla

	# Enable libevent task queues on platforms that support it.
	# rtc_link_task_queue_impl must be set to true for this to
	# have an effect.
	if (is_win \|\| is_mac \|\| is_ios \|\| is_nacl \|\| is_fuchsia) {
	rtc_enable_libevent = false
	rtc_build_libevent = false
	} else {
	rtc_enable_libevent = true
	rtc_build_libevent = !build_with_mozilla
	}

	# Build sources requiring GTK. NOTICE: This is not present in Chrome OS
	# build environments, even if available for Chromium builds.
	rtc_use_gtk = !build_with_chromium && !build_with_mozilla

	# Excluded in Chromium since its prerequisites don't require Pulse Audio.
	rtc_include_pulse_audio = !build_with_chromium

	# Chromium uses its own IO handling, so the internal ADM is only built for
	# standalone WebRTC.
	rtc_include_internal_audio_device = !build_with_chromium

	# Include tests in standalone checkout.
	rtc_include_tests = !build_with_chromium && !build_with_mozilla
	}

	# Make it possible to provide custom locations for some libraries (move these
	# up into declare_args should we need to actually use them for the GN build).
	rtc_libvpx_dir = "//third_party/libvpx"
	rtc_opus_dir = "//third_party/opus"

	# Desktop capturer is supported only on Windows, OSX and Linux.
	rtc_desktop_capture_supported = is_win \|\| is_mac \|\| (is_linux && rtc_use_x11)

	###############################################################################
	# Templates
	#

	# Points to // in webrtc stand-alone or to //third_party/webrtc/ in
	# chromium.
	# We need absolute paths for all configs in templates as they are shared in
	# different subdirectories.
	webrtc_root = get_path_info(".", "abspath")

	# Global configuration that should be applied to all WebRTC targets.
	# You normally shouldn't need to include this in your target as it's
	# automatically included when using the rtc_* templates.
	# It sets defines, include paths and compilation warnings accordingly,
	# both for WebRTC stand-alone builds and for the scenario when WebRTC
	# native code is built as part of Chromium.
	rtc_common_configs = [ webrtc_root + ":common_config" ]

	if (is_mac \|\| is_ios) {
	rtc_common_configs += [ "//build/config/compiler:enable_arc" ]
	}

	# Global public configuration that should be applied to all WebRTC targets. You
	# normally shouldn't need to include this in your target as it's automatically
	# included when using the rtc_* templates. It set the defines, include paths and
	# compilation warnings that should be propagated to dependents of the targets
	# depending on the target having this config.
	rtc_common_inherited_config = webrtc_root + ":common_inherited_config"

	# Common configs to remove or add in all rtc targets.
	rtc_remove_configs = []
	rtc_add_configs = rtc_common_configs

	set_defaults("rtc_test") {
	configs = rtc_add_configs
	suppressed_configs = []
	}

	set_defaults("rtc_source_set") {
	configs = rtc_add_configs
	suppressed_configs = []
	}

	set_defaults("rtc_executable") {
	configs = rtc_add_configs
	suppressed_configs = []
	}

	set_defaults("rtc_static_library") {
	configs = rtc_add_configs
	suppressed_configs = []
	}

	set_defaults("rtc_shared_library") {
	configs = rtc_add_configs
	suppressed_configs = []
	}

	webrtc_default_visibility = [ webrtc_root + "/*" ]
	if (build_with_chromium) {
	# Allow Chromium's WebRTC overrides targets to bypass the regular
	# visibility restrictions.
	webrtc_default_visibility += [ webrtc_root + "/../webrtc_overrides/*" ]
	}

	# ---- Poisons ----
	#
	# The general idea is that some targets declare that they contain some
	# kind of poison, which makes it impossible for other targets to
	# depend on them (even transitively) unless they declare themselves
	# immune to that particular type of poison.
	#
	# Targets that contain poison of type foo should contain the line
	#
	# poisonous = [ "foo" ]
	#
	# and targets that are immune but arent't themselves poisonous
	# should contain
	#
	# allow_poison = [ "foo" ]
	#
	# This useful in cases where we have some large target or set of
	# targets and want to ensure that most other targets do not
	# transitively depend on them. For example, almost no high-level
	# target should depend on the audio codecs, since we want WebRTC users
	# to be able to inject any subset of them and actually end up with a
	# binary that doesn't include the codecs they didn't inject.
	#
	# Test-only targets (`testonly` set to true) and non-public targets
	# (`visibility` not containing "*") are automatically immune to all
	# types of poison.
	#
	# Here's the complete list of all types of poison. It must be kept in
	# 1:1 correspondence with the set of //:poison_* targets.
	#
	all_poison_types = [
	# Encoders and decoders for specific audio codecs such as Opus and iSAC.
	"audio_codecs",

	# Software video codecs (VP8 and VP9 through libvpx).
	"software_video_codecs",
	]

	absl_include_config = "//third_party/abseil-cpp:absl_include_config"
	absl_define_config = "//third_party/abseil-cpp:absl_define_config"

	template("rtc_test") {
	test(target_name) {
	forward_variables_from(invoker,
	"*",
	[
	"configs",
	"public_configs",
	"suppressed_configs",
	"visibility",
	])

	# Always override to public because when target_os is Android the `test`
	# template can override it to [ "*" ] and we want to avoid conditional
	# visibility.
	visibility = [ "*" ]
	configs += invoker.configs
	configs -= rtc_remove_configs
	configs -= invoker.suppressed_configs
	public_configs = [
	rtc_common_inherited_config,
	absl_include_config,
	absl_define_config,
	]
	if (defined(invoker.public_configs)) {
	public_configs += invoker.public_configs
	}
	if (!build_with_chromium && is_android) {
	android_manifest = webrtc_root + "test/android/AndroidManifest.xml"
	deps += [ webrtc_root + "test:native_test_java" ]
	}
	}
	}

	template("rtc_source_set") {
	source_set(target_name) {
	forward_variables_from(invoker,
	"*",
	[
	"configs",
	"public_configs",
	"suppressed_configs",
	"visibility",
	])
	forward_variables_from(invoker, [ "visibility" ])
	if (!defined(visibility)) {
	visibility = webrtc_default_visibility
	}

	# What's your poison?
	if (defined(testonly) && testonly) {
	assert(!defined(poisonous))
	assert(!defined(allow_poison))
	} else {
	if (!defined(poisonous)) {
	poisonous = []
	}
	if (!defined(allow_poison)) {
	allow_poison = []
	}
	if (!defined(assert_no_deps)) {
	assert_no_deps = []
	}
	if (!defined(deps)) {
	deps = []
	}
	foreach(p, poisonous) {
	deps += [ webrtc_root + ":poison_" + p ]
	}
	foreach(poison_type, all_poison_types) {
	allow_dep = true
	foreach(v, visibility) {
	if (v == "*") {
	allow_dep = false
	}
	}
	foreach(p, allow_poison + poisonous) {
	if (p == poison_type) {
	allow_dep = true
	}
	}
	if (!allow_dep) {
	assert_no_deps += [ webrtc_root + ":poison_" + poison_type ]
	}
	}
	}

	configs += invoker.configs
	configs -= rtc_remove_configs
	configs -= invoker.suppressed_configs
	public_configs = [
	rtc_common_inherited_config,
	absl_include_config,
	absl_define_config,
	]
	if (defined(invoker.public_configs)) {
	public_configs += invoker.public_configs
	}
	}
	}

	template("rtc_executable") {
	executable(target_name) {
	forward_variables_from(invoker,
	"*",
	[
	"deps",
	"configs",
	"public_configs",
	"suppressed_configs",
	"visibility",
	])
	forward_variables_from(invoker, [ "visibility" ])
	if (!defined(visibility)) {
	visibility = webrtc_default_visibility
	}
	configs += invoker.configs
	configs -= rtc_remove_configs
	configs -= invoker.suppressed_configs
	deps = [
	"//build/config:exe_and_shlib_deps",
	]
	deps += invoker.deps

	public_configs = [
	rtc_common_inherited_config,
	absl_include_config,
	absl_define_config,
	]
	if (defined(invoker.public_configs)) {
	public_configs += invoker.public_configs
	}
	}
	}

	template("rtc_static_library") {
	static_library(target_name) {
	forward_variables_from(invoker,
	"*",
	[
	"configs",
	"public_configs",
	"suppressed_configs",
	"visibility",
	])
	forward_variables_from(invoker, [ "visibility" ])
	if (!defined(visibility)) {
	visibility = webrtc_default_visibility
	}

	# What's your poison?
	if (defined(testonly) && testonly) {
	assert(!defined(poisonous))
	assert(!defined(allow_poison))
	} else {
	if (!defined(poisonous)) {
	poisonous = []
	}
	if (!defined(allow_poison)) {
	allow_poison = []
	}
	if (!defined(assert_no_deps)) {
	assert_no_deps = []
	}
	if (!defined(deps)) {
	deps = []
	}
	foreach(p, poisonous) {
	deps += [ webrtc_root + ":poison_" + p ]
	}
	foreach(poison_type, all_poison_types) {
	allow_dep = true
	foreach(v, visibility) {
	if (v == "*") {
	allow_dep = false
	}
	}
	foreach(p, allow_poison + poisonous) {
	if (p == poison_type) {
	allow_dep = true
	}
	}
	if (!allow_dep) {
	assert_no_deps += [ webrtc_root + ":poison_" + poison_type ]
	}
	}
	}

	configs += invoker.configs
	configs -= rtc_remove_configs
	configs -= invoker.suppressed_configs
	public_configs = [
	rtc_common_inherited_config,
	absl_include_config,
	absl_define_config,
	]
	if (defined(invoker.public_configs)) {
	public_configs += invoker.public_configs
	}
	}
	}

	template("rtc_shared_library") {
	shared_library(target_name) {
	forward_variables_from(invoker,
	"*",
	[
	"configs",
	"public_configs",
	"suppressed_configs",
	"visibility",
	])
	forward_variables_from(invoker, [ "visibility" ])
	if (!defined(visibility)) {
	visibility = webrtc_default_visibility
	}

	# What's your poison?
	if (defined(testonly) && testonly) {
	assert(!defined(poisonous))
	assert(!defined(allow_poison))
	} else {
	if (!defined(poisonous)) {
	poisonous = []
	}
	if (!defined(allow_poison)) {
	allow_poison = []
	}
	if (!defined(assert_no_deps)) {
	assert_no_deps = []
	}
	if (!defined(deps)) {
	deps = []
	}
	foreach(p, poisonous) {
	deps += [ webrtc_root + ":poison_" + p ]
	}
	foreach(poison_type, all_poison_types) {
	allow_dep = true
	foreach(v, visibility) {
	if (v == "*") {
	allow_dep = false
	}
	}
	foreach(p, allow_poison + poisonous) {
	if (p == poison_type) {
	allow_dep = true
	}
	}
	if (!allow_dep) {
	assert_no_deps += [ webrtc_root + ":poison_" + poison_type ]
	}
	}
	}

	configs += invoker.configs
	configs -= rtc_remove_configs
	configs -= invoker.suppressed_configs
	public_configs = [
	rtc_common_inherited_config,
	absl_include_config,
	absl_define_config,
	]
	if (defined(invoker.public_configs)) {
	public_configs += invoker.public_configs
	}
	}
	}

	if (is_ios) {
	set_defaults("rtc_ios_xctest_test") {
	configs = rtc_add_configs
	suppressed_configs = []
	}

	template("rtc_ios_xctest_test") {
	ios_xctest_test(target_name) {
	forward_variables_from(invoker,
	"*",
	[
	"configs",
	"public_configs",
	"suppressed_configs",
	"visibility",
	])
	forward_variables_from(invoker, [ "visibility" ])
	if (!defined(visibility)) {
	visibility = webrtc_default_visibility
	}
	configs += invoker.configs
	configs -= rtc_remove_configs
	configs -= invoker.suppressed_configs
	public_configs = [ rtc_common_inherited_config ]
	if (defined(invoker.public_configs)) {
	public_configs += invoker.public_configs
	}
	}
	}

	template("ios_framework_bundle_with_umbrella_header") {
	forward_variables_from(invoker, [ "output_name" ])
	umbrella_header_path =
	"$target_gen_dir/$output_name.framework/Headers/$output_name.h"

	ios_framework_bundle(target_name) {
	forward_variables_from(invoker, "*", [])

	deps += [ ":copy_umbrella_header_$target_name" ]
	}

	action("umbrella_header_$target_name") {
	forward_variables_from(invoker, [ "public_headers" ])

	script = "//tools_webrtc/ios/generate_umbrella_header.py"

	outputs = [
	umbrella_header_path,
	]
	args = [
	"--out",
	rebase_path(umbrella_header_path, root_build_dir),
	"--sources",
	] + rebase_path(public_headers, "objc/Framework/Headers/")
	}

	copy("copy_umbrella_header_$target_name") {
	sources = [
	umbrella_header_path,
	]
	outputs = [
	"$root_out_dir/$output_name.framework/Headers/$output_name.h",
	]

	deps = [
	":umbrella_header_$target_name",
	]
	}
	}

	set_defaults("ios_framework_bundle_with_umbrella_header") {
	configs = default_shared_library_configs
	}
	}

	if (is_android) {
	template("rtc_android_library") {
	android_library(target_name) {
	forward_variables_from(invoker,
	"*",
	[
	"configs",
	"public_configs",
	"suppressed_configs",
	"visibility",
	])

	javac_args = []

	# Treat warnings as errors.
	javac_args += [ "-Werror" ]

	# TODO(crbug.com/824679): Find out why this fails in Chromium
	if (!build_with_chromium) {
	javac_args += [
	"-Xep:ParameterNotNullable:ERROR",
	"-Xep:FieldMissingNullable:ERROR",
	"-Xep:ReturnMissingNullable:ERROR",
	]
	}

	# Add any arguments defined by the invoker.
	if (defined(invoker.javac_args)) {
	javac_args += invoker.javac_args
	}

	if (!defined(deps)) {
	deps = []
	}
	deps += [ "//third_party/jsr-305:jsr_305_javalib" ]

	no_build_hooks = true
	}
	}

	template("rtc_android_apk") {
	android_apk(target_name) {
	forward_variables_from(invoker,
	"*",
	[
	"configs",
	"public_configs",
	"suppressed_configs",
	"visibility",
	])

	# Treat warnings as errors.
	javac_args = [ "-Werror" ]

	# TODO(crbug.com/824679): Find out why this fails in Chromium
	if (!build_with_chromium) {
	javac_args += [
	"-Xep:ParameterNotNullable:ERROR",
	"-Xep:FieldMissingNullable:ERROR",
	"-Xep:ReturnMissingNullable:ERROR",
	]
	}

	if (!defined(deps)) {
	deps = []
	}
	deps += [ "//third_party/jsr-305:jsr_305_javalib" ]

	no_build_hooks = true
	}
	}

	template("rtc_instrumentation_test_apk") {
	instrumentation_test_apk(target_name) {
	forward_variables_from(invoker,
	"*",
	[
	"configs",
	"public_configs",
	"suppressed_configs",
	"visibility",
	])

	# Treat warnings as errors.
	javac_args = [ "-Werror" ]

	# TODO(crbug.com/824679): Find out why this fails in Chromium
	if (!build_with_chromium) {
	javac_args += [
	"-Xep:ParameterNotNullable:ERROR",
	"-Xep:FieldMissingNullable:ERROR",
	"-Xep:ReturnMissingNullable:ERROR",
	]
	}

	if (!defined(deps)) {
	deps = []
	}
	deps += [ "//third_party/jsr-305:jsr_305_javalib" ]

	no_build_hooks = true
	}
	}
	}